[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
"""
class Version(_BaseVersion):
_regex = re.compile(r"^\s*" + VERSION_PATTERN + r"\s*$", re.VERBOSE | re.IGNORECASE)
def __init__(self, version: str) -> None:
# 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:
return f""
def __str__(self) -> str:
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:
_epoch: int = self._version.epoch
return _epoch
@property
def release(self) -> Tuple[int, ...]:
_release: Tuple[int, ...] = self._version.release
return _release
@property
def pre(self) -> Optional[Tuple[str, int]]:
_pre: Optional[Tuple[str, int]] = self._version.pre
return _pre
@property
def post(self) -> Optional[int]:
return self._version.post[1] if self._version.post else None
@property
def dev(self) -> Optional[int]:
return self._version.dev[1] if self._version.dev else None
@property
def local(self) -> Optional[str]:
if self._version.local:
return ".".join(str(x) for x in self._version.local)
else:
return None
@property
def public(self) -> str:
return str(self).split("+", 1)[0]
@property
def base_version(self) -> str:
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:
return self.dev is not None or self.pre is not None
@property
def is_postrelease(self) -> bool:
return self.post is not None
@property
def is_devrelease(self) -> bool:
return self.dev is not None
@property
def major(self) -> int:
return self.release[0] if len(self.release) >= 1 else 0
@property
def minor(self) -> int:
return self.release[1] if len(self.release) >= 2 else 0
@property
def micro(self) -> int:
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
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1637195939.7622433
packaging-21.3/packaging.egg-info/ 0000755 0000765 0000024 00000000000 00000000000 017202 5 ustar 00brettcannon staff ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1637195939.0
packaging-21.3/packaging.egg-info/PKG-INFO 0000644 0000765 0000024 00000035400 00000000000 020301 0 ustar 00brettcannon staff Metadata-Version: 2.1
Name: packaging
Version: 21.3
Summary: Core utilities for Python packages
Home-page: https://github.com/pypa/packaging
Author: Donald Stufft and individual contributors
Author-email: donald@stufft.io
License: BSD-2-Clause or Apache-2.0
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: Apache Software License
Classifier: License :: OSI Approved :: BSD License
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3 :: Only
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: Implementation :: CPython
Classifier: Programming Language :: Python :: Implementation :: PyPy
Requires-Python: >=3.6
Description-Content-Type: text/x-rst
License-File: LICENSE
License-File: LICENSE.APACHE
License-File: LICENSE.BSD
packaging
=========
.. start-intro
Reusable core utilities for various Python Packaging
`interoperability 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
---------
21.3 - 2021-11-17
~~~~~~~~~~~~~~~~~
* Add a ``pp3-none-any`` tag (`#311 `__)
* Replace the blank pyparsing 3 exclusion with a 3.0.5 exclusion (`#481 `__, `#486 `__)
* Fix a spelling mistake (`#479 `__)
21.2 - 2021-10-29
~~~~~~~~~~~~~~~~~
* Update documentation entry for 21.1.
21.1 - 2021-10-29
~~~~~~~~~~~~~~~~~
* Update pin to pyparsing to exclude 3.0.0.
21.0 - 2021-07-03
~~~~~~~~~~~~~~~~~
* PEP 656: musllinux support (`#411 `__)
* Drop support for Python 2.7, Python 3.4 and Python 3.5.
* Replace distutils usage with sysconfig (`#396 `__)
* Add support for zip files in ``parse_sdist_filename`` (`#429 `__)
* Use cached ``_hash`` attribute to short-circuit tag equality comparisons (`#417 `__)
* Specify the default value for the ``specifier`` argument to ``SpecifierSet`` (`#437 `__)
* Proper keyword-only "warn" argument in packaging.tags (`#403 `__)
* Correctly remove prerelease suffixes from ~= check (`#366 `__)
* Fix type hints for ``Version.post`` and ``Version.dev`` (`#393 `__)
* Use typing alias ``UnparsedVersion`` (`#398 `__)
* Improve type inference for ``packaging.specifiers.filter()`` (`#430 `__)
* Tighten the return type of ``canonicalize_version()`` (`#402 `__)
20.9 - 2021-01-29
~~~~~~~~~~~~~~~~~
* Run `isort `_ over the code base (`#377 `__)
* Add support for the ``macosx_10_*_universal2`` platform tags (`#379 `__)
* Introduce ``packaging.utils.parse_wheel_filename()`` and ``parse_sdist_filename()``
(`#387 `__ and `#389 `__)
20.8 - 2020-12-11
~~~~~~~~~~~~~~~~~
* Revert back to setuptools for compatibility purposes for some Linux distros (`#363 `__)
* Do not insert an underscore in wheel tags when the interpreter version number
is more than 2 digits (`#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 `__)
* Make `intel` a recognized CPU architecture for the `universal` macOS platform tag (`#361 `__)
* Add some missing type hints to `packaging.requirements` (issue:`350`)
20.5 - 2020-11-27
~~~~~~~~~~~~~~~~~
* Officially support Python 3.9 (`#343 `__)
* Deprecate the ``LegacyVersion`` and ``LegacySpecifier`` classes (`#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 `__)
* 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 `__)
20.0 - 2020-01-06
~~~~~~~~~~~~~~~~~
* Add type hints (`#191 `__)
* Add proper trove classifiers for PyPy support (`#198 `__)
* Scale back depending on ``ctypes`` for manylinux support detection (`#171 `__)
* Use ``sys.implementation.name`` where appropriate for ``packaging.tags`` (`#193 `__)
* Expand upon the API provided by ``packaging.tags``: ``interpreter_name()``, ``mac_platforms()``, ``compatible_tags()``, ``cpython_tags()``, ``generic_tags()`` (`#187 `__)
* Officially support Python 3.8 (`#232 `__)
* Add ``major``, ``minor``, and ``micro`` aliases to ``packaging.version.Version`` (`#226 `__)
* Properly mark ``packaging`` has being fully typed by adding a `py.typed` file (`#226 `__)
19.2 - 2019-09-18
~~~~~~~~~~~~~~~~~
* Remove dependency on ``attrs`` (`#178 `__, `#179 `__)
* Use appropriate fallbacks for CPython ABI tag (`#181 `__, `#185 `__)
* Add manylinux2014 support (`#186 `__)
* Improve ABI detection (`#181 `__)
* Properly handle debug wheels for Python 3.8 (`#172 `__)
* Improve detection of debug builds on Windows (`#194 `__)
19.1 - 2019-07-30
~~~~~~~~~~~~~~~~~
* Add the ``packaging.tags`` module. (`#156 `__)
* Correctly handle two-digit versions in ``python_version`` (`#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 `__)
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 `__).
* Add ``epoch``, ``release``, ``pre``, ``dev``, and ``post`` attributes to
``Version`` and ``LegacyVersion`` (`#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 `__).
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 `__).
* Implement environment markers from PEP 508.
15.3 - 2015-08-01
~~~~~~~~~~~~~~~~~
* Normalize post-release spellings for rev/r prefixes. `#35 `__
15.2 - 2015-05-13
~~~~~~~~~~~~~~~~~
* Fix an error where the arbitrary 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`` or ````) 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/
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1637195939.0
packaging-21.3/packaging.egg-info/SOURCES.txt 0000644 0000765 0000024 00000003332 00000000000 021067 0 ustar 00brettcannon staff .coveragerc
.flake8
.pre-commit-config.yaml
CHANGELOG.rst
CONTRIBUTING.rst
LICENSE
LICENSE.APACHE
LICENSE.BSD
MANIFEST.in
README.rst
mypy.ini
pyproject.toml
setup.cfg
setup.py
docs/Makefile
docs/changelog.rst
docs/conf.py
docs/index.rst
docs/markers.rst
docs/requirements.rst
docs/requirements.txt
docs/security.rst
docs/specifiers.rst
docs/tags.rst
docs/utils.rst
docs/version.rst
docs/_static/.empty
docs/development/getting-started.rst
docs/development/index.rst
docs/development/release-process.rst
docs/development/reviewing-patches.rst
docs/development/submitting-patches.rst
packaging/__about__.py
packaging/__init__.py
packaging/_manylinux.py
packaging/_musllinux.py
packaging/_structures.py
packaging/markers.py
packaging/py.typed
packaging/requirements.py
packaging/specifiers.py
packaging/tags.py
packaging/utils.py
packaging/version.py
packaging.egg-info/PKG-INFO
packaging.egg-info/SOURCES.txt
packaging.egg-info/dependency_links.txt
packaging.egg-info/requires.txt
packaging.egg-info/top_level.txt
tests/__init__.py
tests/test_manylinux.py
tests/test_markers.py
tests/test_musllinux.py
tests/test_requirements.py
tests/test_specifiers.py
tests/test_structures.py
tests/test_tags.py
tests/test_utils.py
tests/test_version.py
tests/manylinux/hello-world-armv7l-armel
tests/manylinux/hello-world-armv7l-armhf
tests/manylinux/hello-world-invalid-class
tests/manylinux/hello-world-invalid-data
tests/manylinux/hello-world-invalid-magic
tests/manylinux/hello-world-s390x-s390x
tests/manylinux/hello-world-too-short
tests/manylinux/hello-world-x86_64-amd64
tests/manylinux/hello-world-x86_64-i386
tests/manylinux/hello-world-x86_64-x32
tests/musllinux/glibc-x86_64
tests/musllinux/musl-aarch64
tests/musllinux/musl-i386
tests/musllinux/musl-x86_64 ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1637195939.0
packaging-21.3/packaging.egg-info/dependency_links.txt 0000644 0000765 0000024 00000000001 00000000000 023250 0 ustar 00brettcannon staff
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1637195939.0
packaging-21.3/packaging.egg-info/requires.txt 0000644 0000765 0000024 00000000031 00000000000 021574 0 ustar 00brettcannon staff pyparsing!=3.0.5,>=2.0.2
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1637195939.0
packaging-21.3/packaging.egg-info/top_level.txt 0000644 0000765 0000024 00000000012 00000000000 021725 0 ustar 00brettcannon staff packaging
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1607730281.0
packaging-21.3/pyproject.toml 0000644 0000765 0000024 00000000144 00000000000 016477 0 ustar 00brettcannon staff [build-system]
requires = ['setuptools >= 40.8.0', 'wheel']
build-backend = 'setuptools.build_meta'
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1637195939.8200293
packaging-21.3/setup.cfg 0000644 0000765 0000024 00000000131 00000000000 015400 0 ustar 00brettcannon staff [isort]
profile = black
combine_as_imports = true
[egg_info]
tag_build =
tag_date = 0
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1637079931.0
packaging-21.3/setup.py 0000644 0000765 0000024 00000005047 00000000000 015304 0 ustar 00brettcannon staff #!/usr/bin/env python
# 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 os
import re
# While I generally consider it an antipattern to try and support both
# setuptools and distutils with a single setup.py, in this specific instance
# where packaging is a dependency of setuptools, it can create a circular
# dependency when projects attempt to unbundle stuff from setuptools and pip.
# Though we don't really support that, it makes things easier if we do this and
# should hopefully cause less issues for end users.
try:
from setuptools import setup
except ImportError:
from distutils.core import setup
base_dir = os.path.dirname(__file__)
about = {}
with open(os.path.join(base_dir, "packaging", "__about__.py")) as f:
exec(f.read(), about)
with open(os.path.join(base_dir, "README.rst")) as f:
long_description = f.read()
with open(os.path.join(base_dir, "CHANGELOG.rst")) as f:
# Remove :issue:`ddd` tags that breaks the description rendering
changelog = re.sub(
r":issue:`(\d+)`",
r"`#\1 `__",
f.read(),
)
long_description = "\n".join([long_description, changelog])
setup(
name=about["__title__"],
version=about["__version__"],
description=about["__summary__"],
long_description=long_description,
long_description_content_type="text/x-rst",
license=about["__license__"],
url=about["__uri__"],
author=about["__author__"],
author_email=about["__email__"],
python_requires=">=3.6",
install_requires=["pyparsing>=2.0.2,!=3.0.5"], # 2.0.2 + needed to avoid issue #91
classifiers=[
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Developers",
"License :: OSI Approved :: Apache Software License",
"License :: OSI Approved :: BSD License",
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: Implementation :: CPython",
"Programming Language :: Python :: Implementation :: PyPy",
],
packages=["packaging"],
package_data={"packaging": ["py.typed"]},
)
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1637195939.7755272
packaging-21.3/tests/ 0000755 0000765 0000024 00000000000 00000000000 014726 5 ustar 00brettcannon staff ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1613160782.0
packaging-21.3/tests/__init__.py 0000644 0000765 0000024 00000000264 00000000000 017041 0 ustar 00brettcannon staff # 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.
././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1637195939.7938979
packaging-21.3/tests/manylinux/ 0000755 0000765 0000024 00000000000 00000000000 016752 5 ustar 00brettcannon staff ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1625175504.0
packaging-21.3/tests/manylinux/hello-world-armv7l-armel 0000755 0000765 0000024 00000000064 00000000000 023434 0 ustar 00brettcannon staff ELF ( 4 € 4 ( ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1625175504.0
packaging-21.3/tests/manylinux/hello-world-armv7l-armhf 0000755 0000765 0000024 00000000064 00000000000 023431 0 ustar 00brettcannon staff ELF ( 4 ˆ 4 ( ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1625175504.0
packaging-21.3/tests/manylinux/hello-world-invalid-class 0000755 0000765 0000024 00000000064 00000000000 023657 0 ustar 00brettcannon staff ELF 4 01 4 ( ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1625175504.0
packaging-21.3/tests/manylinux/hello-world-invalid-data 0000755 0000765 0000024 00000000064 00000000000 023463 0 ustar 00brettcannon staff ELF 4 01 4 ( ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1625175504.0
packaging-21.3/tests/manylinux/hello-world-invalid-magic 0000755 0000765 0000024 00000000064 00000000000 023632 0 ustar 00brettcannon staff ELF 4 01 4 ( ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1625175504.0
packaging-21.3/tests/manylinux/hello-world-s390x-s390x 0000644 0000765 0000024 00000000100 00000000000 022664 0 ustar 00brettcannon staff ELF P @ p @ 8 @ ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1625175504.0
packaging-21.3/tests/manylinux/hello-world-too-short 0000644 0000765 0000024 00000000050 00000000000 023054 0 ustar 00brettcannon staff ELF 4 01 ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1625175504.0
packaging-21.3/tests/manylinux/hello-world-x86_64-amd64 0000644 0000765 0000024 00000000100 00000000000 022761 0 ustar 00brettcannon staff ELF > p @ H1 @ 8 @ ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1625175504.0
packaging-21.3/tests/manylinux/hello-world-x86_64-i386 0000755 0000765 0000024 00000000064 00000000000 022553 0 ustar 00brettcannon staff ELF 4 01 4 ( ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1625175504.0
packaging-21.3/tests/manylinux/hello-world-x86_64-x32 0000755 0000765 0000024 00000000064 00000000000 022476 0 ustar 00brettcannon staff ELF > p 4 <1 4 ( ././@PaxHeader 0000000 0000000 0000000 00000000034 00000000000 010212 x ustar 00 28 mtime=1637195939.8055744
packaging-21.3/tests/musllinux/ 0000755 0000765 0000024 00000000000 00000000000 016766 5 ustar 00brettcannon staff ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1624128339.0
packaging-21.3/tests/musllinux/glibc-x86_64 0000755 0000765 0000024 00000002000 00000000000 020720 0 ustar 00brettcannon staff ELF > € @ ˆ9 @ 8
@ @ @ @ Ø Ø õ õ X X ¸- ¸= ¸= X ` È- È= È= ð ð 8 8 8 X X X D D Såtd 8 8 8 Påtd D D Qåtd Råtd ¸- ¸= ¸= H H /lib64/ld-linux-x86-64.so.2 GNU À GNU °KïWz³£Ù7£Styx”ºyÊ GNU ÑeÎm Q ' ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1624128339.0
packaging-21.3/tests/musllinux/musl-aarch64 0000755 0000765 0000024 00000002000 00000000000 021112 0 ustar 00brettcannon staff ELF · @ @ €# @ 8 @ @ @ @ À À Œ Œ ¨
¨
¨
` ˜ ¸
¸
¸
À À Påtd ° ° ° 4 4 Qåtd Råtd ¨
¨
¨
X X /lib/ld-musl-aarch64.so.1
€ @
¸ñëÓï ˜ " L d ~ # š ˜
” _init printf _fini __cxa_finalize __libc_start_main libc.musl-aarch64.so.1 __deregister_frame_info _ITM_registerTMCloneTable _ITM_deregisterTMCloneTabl././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1624128339.0
packaging-21.3/tests/musllinux/musl-i386 0000755 0000765 0000024 00000002000 00000000000 020353 0 ustar 00brettcannon staff ELF ¥ 4 ä= 4
( ! 4 4 4 @ @ t t t ` ` í í ¸ ¸ ü. ü> ü> ( / ? ? À À Påtd $ $ Qåtd Råtdü. ü> ü> /lib/ld-musl-i386.so.1 $ ¸ñëÓï " H d ~ œ # á _init printf _fini __cxa_finalize __libc_start_main libc.musl-x86.so.1 __register_frame_info_bases _ITM_registerTMCloneTable __deregister_frame_info_bases _ITM_deregisterTMCloneTable ä? ø? ü? @ à? è? ì? ð? ô? Ø? Ü? ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1624128339.0
packaging-21.3/tests/musllinux/musl-x86_64 0000755 0000765 0000024 00000002000 00000000000 020620 0 ustar 00brettcannon staff ELF > s @ A @ 8
@ ! @ @ @ 0 0 p p p Y Y ¤ ¤ . > > ø ` 0. 0> 0> € € Påtd $ $ Qåtd Råtd . > > ð ð /lib/ld-musl-x86_64.so.1 € @ ÑeÎm¹ñëÓï K c } # ™ " Q _init printf _fini __cxa_finalize __libc_start_main libc.musl-x86_64.so.1 __der././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1625175504.0
packaging-21.3/tests/test_manylinux.py 0000644 0000765 0000024 00000016713 00000000000 020373 0 ustar 00brettcannon staff try:
import ctypes
except ImportError:
ctypes = None
import os
import platform
import sys
import types
import warnings
import pretend
import pytest
from packaging import _manylinux
from packaging._manylinux import (
_ELFFileHeader,
_get_elf_header,
_get_glibc_version,
_glibc_version_string,
_glibc_version_string_confstr,
_glibc_version_string_ctypes,
_is_compatible,
_is_linux_armhf,
_is_linux_i686,
_parse_glibc_version,
)
@pytest.fixture(autouse=True)
def clear_lru_cache():
yield
_get_glibc_version.cache_clear()
@pytest.fixture
def manylinux_module(monkeypatch):
monkeypatch.setattr(_manylinux, "_get_glibc_version", lambda *args: (2, 20))
module_name = "_manylinux"
module = types.ModuleType(module_name)
monkeypatch.setitem(sys.modules, module_name, module)
return module
@pytest.mark.parametrize("tf", (True, False))
@pytest.mark.parametrize(
"attribute,glibc", (("1", (2, 5)), ("2010", (2, 12)), ("2014", (2, 17)))
)
def test_module_declaration(monkeypatch, manylinux_module, attribute, glibc, tf):
manylinux = f"manylinux{attribute}_compatible"
monkeypatch.setattr(manylinux_module, manylinux, tf, raising=False)
res = _is_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(
monkeypatch, manylinux_module, attribute, glibc
):
manylinux = f"manylinux{attribute}_compatible"
monkeypatch.delattr(manylinux_module, manylinux, raising=False)
assert _is_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(version, compatible, monkeypatch):
monkeypatch.setitem(sys.modules, "_manylinux", None)
monkeypatch.setattr(_manylinux, "_get_glibc_version", lambda: (2, 5))
assert bool(_is_compatible("manylinux1", "any", version)) == compatible
@pytest.mark.parametrize("version_str", ["glibc-2.4.5", "2"])
def test_check_glibc_version_warning(version_str):
with warnings.catch_warnings(record=True) as w:
_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"),
("2.4", "2.4"),
],
)
def test_glibc_version_string(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(_manylinux, "_glibc_version_string_confstr", lambda: False)
assert _glibc_version_string() == expected
del process_namespace.gnu_get_libc_version
assert _glibc_version_string() is None
def test_glibc_version_string_confstr(monkeypatch):
monkeypatch.setattr(os, "confstr", lambda x: "glibc 2.20", raising=False)
assert _glibc_version_string_confstr() == "2.20"
def test_glibc_version_string_fail(monkeypatch):
monkeypatch.setattr(os, "confstr", lambda x: None, raising=False)
monkeypatch.setitem(sys.modules, "ctypes", None)
assert _glibc_version_string() is None
assert _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(monkeypatch, failure):
monkeypatch.setattr(os, "confstr", failure, raising=False)
assert _glibc_version_string_confstr() is None
def test_glibc_version_string_confstr_missing(monkeypatch):
monkeypatch.delattr(os, "confstr", raising=False)
assert _glibc_version_string_confstr() is None
def test_glibc_version_string_ctypes_missing(monkeypatch):
monkeypatch.setitem(sys.modules, "ctypes", None)
assert _glibc_version_string_ctypes() is None
def test_glibc_version_string_ctypes_raise_oserror(monkeypatch):
def patched_cdll(name):
raise OSError("Dynamic loading not supported")
monkeypatch.setattr(ctypes, "CDLL", patched_cdll)
assert _glibc_version_string_ctypes() is None
@pytest.mark.skipif(platform.system() != "Linux", reason="requires Linux")
def test_is_manylinux_compatible_old():
# Assuming no one is running this test with a version of glibc released in
# 1997.
assert _is_compatible("any", "any", (2, 0))
def test_is_manylinux_compatible(monkeypatch):
monkeypatch.setattr(_manylinux, "_glibc_version_string", lambda: "2.4")
assert _is_compatible("", "any", (2, 4))
def test_glibc_version_string_none(monkeypatch):
monkeypatch.setattr(_manylinux, "_glibc_version_string", lambda: None)
assert not _is_compatible("any", "any", (2, 4))
def test_is_linux_armhf_not_elf(monkeypatch):
monkeypatch.setattr(_manylinux, "_get_elf_header", lambda: None)
assert not _is_linux_armhf()
def test_is_linux_i686_not_elf(monkeypatch):
monkeypatch.setattr(_manylinux, "_get_elf_header", lambda: None)
assert not _is_linux_i686()
@pytest.mark.parametrize(
"machine, abi, elf_class, elf_data, elf_machine",
[
(
"x86_64",
"x32",
_ELFFileHeader.ELFCLASS32,
_ELFFileHeader.ELFDATA2LSB,
_ELFFileHeader.EM_X86_64,
),
(
"x86_64",
"i386",
_ELFFileHeader.ELFCLASS32,
_ELFFileHeader.ELFDATA2LSB,
_ELFFileHeader.EM_386,
),
(
"x86_64",
"amd64",
_ELFFileHeader.ELFCLASS64,
_ELFFileHeader.ELFDATA2LSB,
_ELFFileHeader.EM_X86_64,
),
(
"armv7l",
"armel",
_ELFFileHeader.ELFCLASS32,
_ELFFileHeader.ELFDATA2LSB,
_ELFFileHeader.EM_ARM,
),
(
"armv7l",
"armhf",
_ELFFileHeader.ELFCLASS32,
_ELFFileHeader.ELFDATA2LSB,
_ELFFileHeader.EM_ARM,
),
(
"s390x",
"s390x",
_ELFFileHeader.ELFCLASS64,
_ELFFileHeader.ELFDATA2MSB,
_ELFFileHeader.EM_S390,
),
],
)
def test_get_elf_header(monkeypatch, machine, abi, elf_class, elf_data, elf_machine):
path = os.path.join(
os.path.dirname(__file__),
"manylinux",
f"hello-world-{machine}-{abi}",
)
monkeypatch.setattr(sys, "executable", path)
elf_header = _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_executable(monkeypatch, content):
if content:
path = os.path.join(
os.path.dirname(__file__),
"manylinux",
f"hello-world-{content}",
)
else:
path = None
monkeypatch.setattr(sys, "executable", path)
assert _get_elf_header() is None
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1637079931.0
packaging-21.3/tests/test_markers.py 0000644 0000765 0000024 00000024453 00000000000 020013 0 ustar 00brettcannon staff # 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 collections
import itertools
import os
import platform
import sys
import pytest
from packaging.markers import (
InvalidMarker,
Marker,
Node,
UndefinedComparison,
UndefinedEnvironmentName,
default_environment,
format_full_version,
)
VARIABLES = [
"extra",
"implementation_name",
"implementation_version",
"os_name",
"platform_machine",
"platform_release",
"platform_system",
"platform_version",
"python_full_version",
"python_version",
"platform_python_implementation",
"sys_platform",
]
PEP_345_VARIABLES = [
"os.name",
"sys.platform",
"platform.version",
"platform.machine",
"platform.python_implementation",
]
SETUPTOOLS_VARIABLES = ["python_implementation"]
OPERATORS = ["===", "==", ">=", "<=", "!=", "~=", ">", "<", "in", "not in"]
VALUES = [
"1.0",
"5.6a0",
"dog",
"freebsd",
"literally any string can go here",
"things @#4 dsfd (((",
]
class TestNode:
@pytest.mark.parametrize("value", ["one", "two", None, 3, 5, []])
def test_accepts_value(self, value):
assert Node(value).value == value
@pytest.mark.parametrize("value", ["one", "two", None, 3, 5, []])
def test_str(self, value):
assert str(Node(value)) == str(value)
@pytest.mark.parametrize("value", ["one", "two", None, 3, 5, []])
def test_repr(self, value):
assert repr(Node(value)) == f""
def test_base_class(self):
with pytest.raises(NotImplementedError):
Node("cover all the code").serialize()
class TestOperatorEvaluation:
def test_prefers_pep440(self):
assert Marker('"2.7.9" < "foo"').evaluate(dict(foo="2.7.10"))
def test_falls_back_to_python(self):
assert Marker('"b" > "a"').evaluate(dict(a="a"))
def test_fails_when_undefined(self):
with pytest.raises(UndefinedComparison):
Marker("'2.7.0' ~= os_name").evaluate()
FakeVersionInfo = collections.namedtuple(
"FakeVersionInfo", ["major", "minor", "micro", "releaselevel", "serial"]
)
class TestDefaultEnvironment:
def test_matches_expected(self):
environment = default_environment()
iver = "{0.major}.{0.minor}.{0.micro}".format(sys.implementation.version)
if sys.implementation.version.releaselevel != "final":
iver = "{0}{1[0]}{2}".format(
iver,
sys.implementation.version.releaselevel,
sys.implementation.version.serial,
)
assert environment == {
"implementation_name": sys.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,
}
def test_multidigit_minor_version(self, monkeypatch):
version_info = (3, 10, 0, "final", 0)
monkeypatch.setattr(sys, "version_info", version_info, raising=False)
monkeypatch.setattr(platform, "python_version", lambda: "3.10.0", raising=False)
monkeypatch.setattr(
platform, "python_version_tuple", lambda: ("3", "10", "0"), raising=False
)
environment = default_environment()
assert environment["python_version"] == "3.10"
def tests_when_releaselevel_final(self):
v = FakeVersionInfo(3, 4, 2, "final", 0)
assert format_full_version(v) == "3.4.2"
def tests_when_releaselevel_not_final(self):
v = FakeVersionInfo(3, 4, 2, "beta", 4)
assert format_full_version(v) == "3.4.2b4"
class TestMarker:
@pytest.mark.parametrize(
"marker_string",
[
"{} {} {!r}".format(*i)
for i in itertools.product(VARIABLES, OPERATORS, VALUES)
]
+ [
"{2!r} {1} {0}".format(*i)
for i in itertools.product(VARIABLES, OPERATORS, VALUES)
],
)
def test_parses_valid(self, marker_string):
Marker(marker_string)
@pytest.mark.parametrize(
"marker_string",
[
"this_isnt_a_real_variable >= '1.0'",
"python_version",
"(python_version)",
"python_version >= 1.0 and (python_version)",
],
)
def test_parses_invalid(self, marker_string):
with pytest.raises(InvalidMarker):
Marker(marker_string)
@pytest.mark.parametrize(
("marker_string", "expected"),
[
# Test the different quoting rules
("python_version == '2.7'", 'python_version == "2.7"'),
('python_version == "2.7"', 'python_version == "2.7"'),
# Test and/or expressions
(
'python_version == "2.7" and os_name == "linux"',
'python_version == "2.7" and os_name == "linux"',
),
(
'python_version == "2.7" or os_name == "linux"',
'python_version == "2.7" or os_name == "linux"',
),
(
'python_version == "2.7" and os_name == "linux" or '
'sys_platform == "win32"',
'python_version == "2.7" and os_name == "linux" or '
'sys_platform == "win32"',
),
# Test nested expressions and grouping with ()
('(python_version == "2.7")', 'python_version == "2.7"'),
(
'(python_version == "2.7" and sys_platform == "win32")',
'python_version == "2.7" and sys_platform == "win32"',
),
(
'python_version == "2.7" and (sys_platform == "win32" or '
'sys_platform == "linux")',
'python_version == "2.7" and (sys_platform == "win32" or '
'sys_platform == "linux")',
),
],
)
def test_str_and_repr(self, marker_string, expected):
m = Marker(marker_string)
assert str(m) == expected
assert repr(m) == f""
def test_extra_with_no_extra_in_environment(self):
# We can't evaluate an extra if no extra is passed into the environment
m = Marker("extra == 'security'")
with pytest.raises(UndefinedEnvironmentName):
m.evaluate()
@pytest.mark.parametrize(
("marker_string", "environment", "expected"),
[
(f"os_name == '{os.name}'", None, True),
("os_name == 'foo'", {"os_name": "foo"}, True),
("os_name == 'foo'", {"os_name": "bar"}, False),
("'2.7' in python_version", {"python_version": "2.7.5"}, True),
("'2.7' not in python_version", {"python_version": "2.7"}, False),
(
"os_name == 'foo' and python_version ~= '2.7.0'",
{"os_name": "foo", "python_version": "2.7.6"},
True,
),
(
"python_version ~= '2.7.0' and (os_name == 'foo' or "
"os_name == 'bar')",
{"os_name": "foo", "python_version": "2.7.4"},
True,
),
(
"python_version ~= '2.7.0' and (os_name == 'foo' or "
"os_name == 'bar')",
{"os_name": "bar", "python_version": "2.7.4"},
True,
),
(
"python_version ~= '2.7.0' and (os_name == 'foo' or "
"os_name == 'bar')",
{"os_name": "other", "python_version": "2.7.4"},
False,
),
("extra == 'security'", {"extra": "quux"}, False),
("extra == 'security'", {"extra": "security"}, True),
],
)
def test_evaluates(self, marker_string, environment, expected):
args = [] if environment is None else [environment]
assert Marker(marker_string).evaluate(*args) == expected
@pytest.mark.parametrize(
"marker_string",
[
"{} {} {!r}".format(*i)
for i in itertools.product(PEP_345_VARIABLES, OPERATORS, VALUES)
]
+ [
"{2!r} {1} {0}".format(*i)
for i in itertools.product(PEP_345_VARIABLES, OPERATORS, VALUES)
],
)
def test_parses_pep345_valid(self, marker_string):
Marker(marker_string)
@pytest.mark.parametrize(
("marker_string", "environment", "expected"),
[
(f"os.name == '{os.name}'", None, True),
("sys.platform == 'win32'", {"sys_platform": "linux2"}, False),
("platform.version in 'Ubuntu'", {"platform_version": "#39"}, False),
("platform.machine=='x86_64'", {"platform_machine": "x86_64"}, True),
(
"platform.python_implementation=='Jython'",
{"platform_python_implementation": "CPython"},
False,
),
(
"python_version == '2.5' and platform.python_implementation"
"!= 'Jython'",
{"python_version": "2.7"},
False,
),
],
)
def test_evaluate_pep345_markers(self, marker_string, environment, expected):
args = [] if environment is None else [environment]
assert Marker(marker_string).evaluate(*args) == expected
@pytest.mark.parametrize(
"marker_string",
[
"{} {} {!r}".format(*i)
for i in itertools.product(SETUPTOOLS_VARIABLES, OPERATORS, VALUES)
]
+ [
"{2!r} {1} {0}".format(*i)
for i in itertools.product(SETUPTOOLS_VARIABLES, OPERATORS, VALUES)
],
)
def test_parses_setuptools_legacy_valid(self, marker_string):
Marker(marker_string)
def test_evaluate_setuptools_legacy_markers(self):
marker_string = "python_implementation=='Jython'"
args = [{"platform_python_implementation": "CPython"}]
assert Marker(marker_string).evaluate(*args) is False
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1625175504.0
packaging-21.3/tests/test_musllinux.py 0000644 0000765 0000024 00000010450 00000000000 020377 0 ustar 00brettcannon staff import collections
import io
import pathlib
import struct
import subprocess
import pretend
import pytest
from packaging import _musllinux
from packaging._musllinux import (
_get_musl_version,
_MuslVersion,
_parse_ld_musl_from_elf,
_parse_musl_version,
)
MUSL_AMD64 = "musl libc (x86_64)\nVersion 1.2.2\n"
MUSL_I386 = "musl libc (i386)\nVersion 1.2.1\n"
MUSL_AARCH64 = "musl libc (aarch64)\nVersion 1.1.24\n"
MUSL_INVALID = "musl libc (invalid)\n"
MUSL_UNKNOWN = "musl libc (unknown)\nVersion unknown\n"
MUSL_DIR = pathlib.Path(__file__).with_name("musllinux").resolve()
BIN_GLIBC_X86_64 = MUSL_DIR.joinpath("glibc-x86_64")
BIN_MUSL_X86_64 = MUSL_DIR.joinpath("musl-x86_64")
BIN_MUSL_I386 = MUSL_DIR.joinpath("musl-i386")
BIN_MUSL_AARCH64 = MUSL_DIR.joinpath("musl-aarch64")
LD_MUSL_X86_64 = "/lib/ld-musl-x86_64.so.1"
LD_MUSL_I386 = "/lib/ld-musl-i386.so.1"
LD_MUSL_AARCH64 = "/lib/ld-musl-aarch64.so.1"
@pytest.fixture(autouse=True)
def clear_lru_cache():
yield
_get_musl_version.cache_clear()
@pytest.mark.parametrize(
"output, version",
[
(MUSL_AMD64, _MuslVersion(1, 2)),
(MUSL_I386, _MuslVersion(1, 2)),
(MUSL_AARCH64, _MuslVersion(1, 1)),
(MUSL_INVALID, None),
(MUSL_UNKNOWN, None),
],
ids=["amd64-1.2.2", "i386-1.2.1", "aarch64-1.1.24", "invalid", "unknown"],
)
def test_parse_musl_version(output, version):
assert _parse_musl_version(output) == version
@pytest.mark.parametrize(
"executable, location",
[
(BIN_GLIBC_X86_64, None),
(BIN_MUSL_X86_64, LD_MUSL_X86_64),
(BIN_MUSL_I386, LD_MUSL_I386),
(BIN_MUSL_AARCH64, LD_MUSL_AARCH64),
],
ids=["glibc", "x86_64", "i386", "aarch64"],
)
def test_parse_ld_musl_from_elf(executable, location):
with executable.open("rb") as f:
assert _parse_ld_musl_from_elf(f) == location
@pytest.mark.parametrize(
"data",
[
# Too short for magic.
b"\0",
# Enough for magic, but not ELF.
b"#!/bin/bash" + b"\0" * 16,
# ELF, but unknown byte declaration.
b"\x7fELF\3" + b"\0" * 16,
],
ids=["no-magic", "wrong-magic", "unknown-format"],
)
def test_parse_ld_musl_from_elf_invalid(data):
assert _parse_ld_musl_from_elf(io.BytesIO(data)) is None
@pytest.mark.parametrize(
"head",
[
25, # Enough for magic, but not the section definitions.
58, # Enough for section definitions, but not the actual sections.
],
)
def test_parse_ld_musl_from_elf_invalid_section(head):
data = BIN_MUSL_X86_64.read_bytes()[:head]
assert _parse_ld_musl_from_elf(io.BytesIO(data)) is None
def test_parse_ld_musl_from_elf_no_interpreter_section():
with BIN_MUSL_X86_64.open("rb") as f:
data = f.read()
# Change all sections to *not* PT_INTERP.
unpacked = struct.unpack("16BHHIQQQIHHH", data[:58])
*_, e_phoff, _, _, _, e_phentsize, e_phnum = unpacked
for i in range(e_phnum + 1):
sb = e_phoff + e_phentsize * i
se = sb + 56
section = struct.unpack("IIQQQQQQ", data[sb:se])
data = data[:sb] + struct.pack("IIQQQQQQ", 0, *section[1:]) + data[se:]
assert _parse_ld_musl_from_elf(io.BytesIO(data)) is None
@pytest.mark.parametrize(
"executable, output, version, ld_musl",
[
(MUSL_DIR.joinpath("does-not-exist"), "error", None, None),
(BIN_GLIBC_X86_64, "error", None, None),
(BIN_MUSL_X86_64, MUSL_AMD64, _MuslVersion(1, 2), LD_MUSL_X86_64),
(BIN_MUSL_I386, MUSL_I386, _MuslVersion(1, 2), LD_MUSL_I386),
(BIN_MUSL_AARCH64, MUSL_AARCH64, _MuslVersion(1, 1), LD_MUSL_AARCH64),
],
ids=["does-not-exist", "glibc", "x86_64", "i386", "aarch64"],
)
def test_get_musl_version(monkeypatch, executable, output, version, ld_musl):
def mock_run(*args, **kwargs):
return collections.namedtuple("Proc", "stderr")(output)
run_recorder = pretend.call_recorder(mock_run)
monkeypatch.setattr(_musllinux.subprocess, "run", run_recorder)
assert _get_musl_version(str(executable)) == version
if ld_musl is not None:
expected_calls = [
pretend.call(
[ld_musl],
stderr=subprocess.PIPE,
universal_newlines=True,
)
]
else:
expected_calls = []
assert run_recorder.calls == expected_calls
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1637079931.0
packaging-21.3/tests/test_requirements.py 0000644 0000765 0000024 00000016322 00000000000 021066 0 ustar 00brettcannon staff # 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 pytest
from packaging.markers import Marker
from packaging.requirements import URL, URL_AND_MARKER, InvalidRequirement, Requirement
from packaging.specifiers import SpecifierSet
class TestRequirements:
def test_string_specifier_marker(self):
requirement = 'name[bar]>=3; python_version == "2.7"'
req = Requirement(requirement)
assert str(req) == requirement
def test_string_url(self):
requirement = "name@ http://foo.com"
req = Requirement(requirement)
assert str(req) == requirement
def test_string_url_with_marker(self):
requirement = 'name@ http://foo.com ; extra == "feature"'
req = Requirement(requirement)
assert str(req) == requirement
def test_repr(self):
req = Requirement("name")
assert repr(req) == ""
def _assert_requirement(
self, req, name, url=None, extras=[], specifier="", marker=None
):
assert req.name == name
assert req.url == url
assert sorted(req.extras) == sorted(extras)
assert str(req.specifier) == specifier
if marker:
assert str(req.marker) == marker
else:
assert req.marker is None
def test_simple_names(self):
for name in ("A", "aa", "name"):
req = Requirement(name)
self._assert_requirement(req, name)
def test_name_with_other_characters(self):
name = "foo-bar.quux_baz"
req = Requirement(name)
self._assert_requirement(req, name)
def test_invalid_name(self):
with pytest.raises(InvalidRequirement):
Requirement("foo!")
def test_name_with_version(self):
req = Requirement("name>=3")
self._assert_requirement(req, "name", specifier=">=3")
def test_with_legacy_version(self):
req = Requirement("name==1.0.org1")
self._assert_requirement(req, "name", specifier="==1.0.org1")
def test_with_legacy_version_and_marker(self):
req = Requirement("name>=1.x.y;python_version=='2.6'")
self._assert_requirement(
req, "name", specifier=">=1.x.y", marker='python_version == "2.6"'
)
def test_version_with_parens_and_whitespace(self):
req = Requirement("name (==4)")
self._assert_requirement(req, "name", specifier="==4")
def test_name_with_multiple_versions(self):
req = Requirement("name>=3,<2")
self._assert_requirement(req, "name", specifier="<2,>=3")
def test_name_with_multiple_versions_and_whitespace(self):
req = Requirement("name >=2, <3")
self._assert_requirement(req, "name", specifier="<3,>=2")
def test_extras(self):
req = Requirement("foobar [quux,bar]")
self._assert_requirement(req, "foobar", extras=["bar", "quux"])
def test_empty_extras(self):
req = Requirement("foo[]")
self._assert_requirement(req, "foo")
def test_url(self):
url_section = "@ http://example.com"
parsed = URL.parseString(url_section)
assert parsed.url == "http://example.com"
def test_url_and_marker(self):
instring = "@ http://example.com ; os_name=='a'"
parsed = URL_AND_MARKER.parseString(instring)
assert parsed.url == "http://example.com"
assert str(parsed.marker) == 'os_name == "a"'
def test_invalid_url(self):
with pytest.raises(InvalidRequirement) as e:
Requirement("name @ gopher:/foo/com")
assert "Invalid URL: " in str(e.value)
assert "gopher:/foo/com" in str(e.value)
def test_file_url(self):
req = Requirement("name @ file:///absolute/path")
self._assert_requirement(req, "name", "file:///absolute/path")
req = Requirement("name @ file://.")
self._assert_requirement(req, "name", "file://.")
def test_invalid_file_urls(self):
with pytest.raises(InvalidRequirement):
Requirement("name @ file:.")
with pytest.raises(InvalidRequirement):
Requirement("name @ file:/.")
def test_extras_and_url_and_marker(self):
req = Requirement("name [fred,bar] @ http://foo.com ; python_version=='2.7'")
self._assert_requirement(
req,
"name",
extras=["bar", "fred"],
url="http://foo.com",
marker='python_version == "2.7"',
)
def test_complex_url_and_marker(self):
url = "https://example.com/name;v=1.1/?query=foo&bar=baz#blah"
req = Requirement("foo @ %s ; python_version=='3.4'" % url)
self._assert_requirement(req, "foo", url=url, marker='python_version == "3.4"')
def test_multiple_markers(self):
req = Requirement(
"name[quux, strange];python_version<'2.7' and " "platform_version=='2'"
)
marker = 'python_version < "2.7" and platform_version == "2"'
self._assert_requirement(req, "name", extras=["strange", "quux"], marker=marker)
def test_multiple_comparison_markers(self):
req = Requirement("name; os_name=='a' and os_name=='b' or os_name=='c'")
marker = 'os_name == "a" and os_name == "b" or os_name == "c"'
self._assert_requirement(req, "name", marker=marker)
def test_invalid_marker(self):
with pytest.raises(InvalidRequirement):
Requirement("name; foobar=='x'")
def test_types(self):
req = Requirement("foobar[quux]<2,>=3; os_name=='a'")
assert isinstance(req.name, str)
assert isinstance(req.extras, set)
assert req.url is None
assert isinstance(req.specifier, SpecifierSet)
assert isinstance(req.marker, Marker)
def test_types_with_nothing(self):
req = Requirement("foobar")
assert isinstance(req.name, str)
assert isinstance(req.extras, set)
assert req.url is None
assert isinstance(req.specifier, SpecifierSet)
assert req.marker is None
def test_types_with_url(self):
req = Requirement("foobar @ http://foo.com")
assert isinstance(req.name, str)
assert isinstance(req.extras, set)
assert isinstance(req.url, str)
assert isinstance(req.specifier, SpecifierSet)
assert req.marker is None
def test_sys_platform_linux_equal(self):
req = Requirement('something>=1.2.3; sys_platform == "foo"')
assert req.name == "something"
assert req.marker is not None
assert req.marker.evaluate(dict(sys_platform="foo")) is True
assert req.marker.evaluate(dict(sys_platform="bar")) is False
def test_sys_platform_linux_in(self):
req = Requirement("aviato>=1.2.3; 'f' in sys_platform")
assert req.name == "aviato"
assert req.marker is not None
assert req.marker.evaluate(dict(sys_platform="foo")) is True
assert req.marker.evaluate(dict(sys_platform="bar")) is False
def test_parseexception_error_msg(self):
with pytest.raises(InvalidRequirement) as e:
Requirement("toto 42")
assert "Expected stringEnd" in str(e.value) or (
"Expected string_end" in str(e.value) # pyparsing>=3.0.0
)
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1637079931.0
packaging-21.3/tests/test_specifiers.py 0000644 0000765 0000024 00000101612 00000000000 020474 0 ustar 00brettcannon staff # 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 itertools
import operator
import warnings
import pytest
from packaging.specifiers import (
InvalidSpecifier,
LegacySpecifier,
Specifier,
SpecifierSet,
)
from packaging.version import LegacyVersion, Version, parse
from .test_version import LEGACY_VERSIONS, VERSIONS
LEGACY_SPECIFIERS = [
"==2.1.0.3",
"!=2.2.0.5",
"<=5",
">=7.9a1",
"<1.0.dev1",
">2.0.post1",
]
SPECIFIERS = [
"~=2.0",
"==2.1.*",
"==2.1.0.3",
"!=2.2.*",
"!=2.2.0.5",
"<=5",
">=7.9a1",
"<1.0.dev1",
">2.0.post1",
"===lolwat",
]
class TestSpecifier:
@pytest.mark.parametrize("specifier", SPECIFIERS)
def test_specifiers_valid(self, specifier):
Specifier(specifier)
@pytest.mark.parametrize(
"specifier",
[
# Operator-less specifier
"2.0",
# Invalid operator
"=>2.0",
# Version-less specifier
"==",
# Local segment on operators which don't support them
"~=1.0+5",
">=1.0+deadbeef",
"<=1.0+abc123",
">1.0+watwat",
"<1.0+1.0",
# Prefix matching on operators which don't support them
"~=1.0.*",
">=1.0.*",
"<=1.0.*",
">1.0.*",
"<1.0.*",
# Combination of local and prefix matching on operators which do
# support one or the other
"==1.0.*+5",
"!=1.0.*+deadbeef",
# Prefix matching cannot be used inside of a local version
"==1.0+5.*",
"!=1.0+deadbeef.*",
# Prefix matching must appear at the end
"==1.0.*.5",
# Compatible operator requires 2 digits in the release operator
"~=1",
# Cannot use a prefix matching after a .devN version
"==1.0.dev1.*",
"!=1.0.dev1.*",
],
)
def test_specifiers_invalid(self, specifier):
with pytest.raises(InvalidSpecifier):
Specifier(specifier)
@pytest.mark.parametrize(
"version",
[
# Various development release incarnations
"1.0dev",
"1.0.dev",
"1.0dev1",
"1.0dev",
"1.0-dev",
"1.0-dev1",
"1.0DEV",
"1.0.DEV",
"1.0DEV1",
"1.0DEV",
"1.0.DEV1",
"1.0-DEV",
"1.0-DEV1",
# Various alpha incarnations
"1.0a",
"1.0.a",
"1.0.a1",
"1.0-a",
"1.0-a1",
"1.0alpha",
"1.0.alpha",
"1.0.alpha1",
"1.0-alpha",
"1.0-alpha1",
"1.0A",
"1.0.A",
"1.0.A1",
"1.0-A",
"1.0-A1",
"1.0ALPHA",
"1.0.ALPHA",
"1.0.ALPHA1",
"1.0-ALPHA",
"1.0-ALPHA1",
# Various beta incarnations
"1.0b",
"1.0.b",
"1.0.b1",
"1.0-b",
"1.0-b1",
"1.0beta",
"1.0.beta",
"1.0.beta1",
"1.0-beta",
"1.0-beta1",
"1.0B",
"1.0.B",
"1.0.B1",
"1.0-B",
"1.0-B1",
"1.0BETA",
"1.0.BETA",
"1.0.BETA1",
"1.0-BETA",
"1.0-BETA1",
# Various release candidate incarnations
"1.0c",
"1.0.c",
"1.0.c1",
"1.0-c",
"1.0-c1",
"1.0rc",
"1.0.rc",
"1.0.rc1",
"1.0-rc",
"1.0-rc1",
"1.0C",
"1.0.C",
"1.0.C1",
"1.0-C",
"1.0-C1",
"1.0RC",
"1.0.RC",
"1.0.RC1",
"1.0-RC",
"1.0-RC1",
# Various post release incarnations
"1.0post",
"1.0.post",
"1.0post1",
"1.0post",
"1.0-post",
"1.0-post1",
"1.0POST",
"1.0.POST",
"1.0POST1",
"1.0POST",
"1.0.POST1",
"1.0-POST",
"1.0-POST1",
"1.0-5",
# Local version case insensitivity
"1.0+AbC"
# Integer Normalization
"1.01",
"1.0a05",
"1.0b07",
"1.0c056",
"1.0rc09",
"1.0.post000",
"1.1.dev09000",
"00!1.2",
"0100!0.0",
# Various other normalizations
"v1.0",
" \r \f \v v1.0\t\n",
],
)
def test_specifiers_normalized(self, version):
if "+" not in version:
ops = ["~=", "==", "!=", "<=", ">=", "<", ">"]
else:
ops = ["==", "!="]
for op in ops:
Specifier(op + version)
@pytest.mark.parametrize(
("specifier", "expected"),
[
# Single item specifiers should just be reflexive
("!=2.0", "!=2.0"),
("<2.0", "<2.0"),
("<=2.0", "<=2.0"),
("==2.0", "==2.0"),
(">2.0", ">2.0"),
(">=2.0", ">=2.0"),
("~=2.0", "~=2.0"),
# Spaces should be removed
("< 2", "<2"),
],
)
def test_specifiers_str_and_repr(self, specifier, expected):
spec = Specifier(specifier)
assert str(spec) == expected
assert repr(spec) == f""
@pytest.mark.parametrize("specifier", SPECIFIERS)
def test_specifiers_hash(self, specifier):
assert hash(Specifier(specifier)) == hash(Specifier(specifier))
@pytest.mark.parametrize(
("left", "right", "op"),
itertools.chain(
*
# Verify that the equal (==) operator works correctly
[[(x, x, operator.eq) for x in SPECIFIERS]]
+
# Verify that the not equal (!=) operator works correctly
[
[(x, y, operator.ne) for j, y in enumerate(SPECIFIERS) if i != j]
for i, x in enumerate(SPECIFIERS)
]
),
)
def test_comparison_true(self, left, right, op):
assert op(Specifier(left), Specifier(right))
assert op(left, Specifier(right))
assert op(Specifier(left), right)
@pytest.mark.parametrize(("left", "right"), [("==2.8.0", "==2.8")])
def test_comparison_canonicalizes(self, left, right):
assert Specifier(left) == Specifier(right)
assert left == Specifier(right)
assert Specifier(left) == right
@pytest.mark.parametrize(
("left", "right", "op"),
itertools.chain(
*
# Verify that the equal (==) operator works correctly
[[(x, x, operator.ne) for x in SPECIFIERS]]
+
# Verify that the not equal (!=) operator works correctly
[
[(x, y, operator.eq) for j, y in enumerate(SPECIFIERS) if i != j]
for i, x in enumerate(SPECIFIERS)
]
),
)
def test_comparison_false(self, left, right, op):
assert not op(Specifier(left), Specifier(right))
assert not op(left, Specifier(right))
assert not op(Specifier(left), right)
def test_comparison_non_specifier(self):
assert Specifier("==1.0") != 12
assert not Specifier("==1.0") == 12
assert Specifier("==1.0") != "12"
assert not Specifier("==1.0") == "12"
@pytest.mark.parametrize(
("version", "spec", "expected"),
[
(v, s, True)
for v, s in [
# Test the equality operation
("2.0", "==2"),
("2.0", "==2.0"),
("2.0", "==2.0.0"),
("2.0+deadbeef", "==2"),
("2.0+deadbeef", "==2.0"),
("2.0+deadbeef", "==2.0.0"),
("2.0+deadbeef", "==2+deadbeef"),
("2.0+deadbeef", "==2.0+deadbeef"),
("2.0+deadbeef", "==2.0.0+deadbeef"),
("2.0+deadbeef.0", "==2.0.0+deadbeef.00"),
# Test the equality operation with a prefix
("2.dev1", "==2.*"),
("2a1", "==2.*"),
("2a1.post1", "==2.*"),
("2b1", "==2.*"),
("2b1.dev1", "==2.*"),
("2c1", "==2.*"),
("2c1.post1.dev1", "==2.*"),
("2rc1", "==2.*"),
("2", "==2.*"),
("2.0", "==2.*"),
("2.0.0", "==2.*"),
("2.0.post1", "==2.0.post1.*"),
("2.0.post1.dev1", "==2.0.post1.*"),
("2.1+local.version", "==2.1.*"),
# Test the in-equality operation
("2.1", "!=2"),
("2.1", "!=2.0"),
("2.0.1", "!=2"),
("2.0.1", "!=2.0"),
("2.0.1", "!=2.0.0"),
("2.0", "!=2.0+deadbeef"),
# Test the in-equality operation with a prefix
("2.0", "!=3.*"),
("2.1", "!=2.0.*"),
# Test the greater than equal operation
("2.0", ">=2"),
("2.0", ">=2.0"),
("2.0", ">=2.0.0"),
("2.0.post1", ">=2"),
("2.0.post1.dev1", ">=2"),
("3", ">=2"),
# Test the less than equal operation
("2.0", "<=2"),
("2.0", "<=2.0"),
("2.0", "<=2.0.0"),
("2.0.dev1", "<=2"),
("2.0a1", "<=2"),
("2.0a1.dev1", "<=2"),
("2.0b1", "<=2"),
("2.0b1.post1", "<=2"),
("2.0c1", "<=2"),
("2.0c1.post1.dev1", "<=2"),
("2.0rc1", "<=2"),
("1", "<=2"),
# Test the greater than operation
("3", ">2"),
("2.1", ">2.0"),
("2.0.1", ">2"),
("2.1.post1", ">2"),
("2.1+local.version", ">2"),
# Test the less than operation
("1", "<2"),
("2.0", "<2.1"),
("2.0.dev0", "<2.1"),
# Test the compatibility operation
("1", "~=1.0"),
("1.0.1", "~=1.0"),
("1.1", "~=1.0"),
("1.9999999", "~=1.0"),
("1.1", "~=1.0a1"),
# Test that epochs are handled sanely
("2!1.0", "~=2!1.0"),
("2!1.0", "==2!1.*"),
("2!1.0", "==2!1.0"),
("2!1.0", "!=1.0"),
("1.0", "!=2!1.0"),
("1.0", "<=2!0.1"),
("2!1.0", ">=2.0"),
("1.0", "<2!0.1"),
("2!1.0", ">2.0"),
# Test some normalization rules
("2.0.5", ">2.0dev"),
]
]
+ [
(v, s, False)
for v, s in [
# Test the equality operation
("2.1", "==2"),
("2.1", "==2.0"),
("2.1", "==2.0.0"),
("2.0", "==2.0+deadbeef"),
# Test the equality operation with a prefix
("2.0", "==3.*"),
("2.1", "==2.0.*"),
# Test the in-equality operation
("2.0", "!=2"),
("2.0", "!=2.0"),
("2.0", "!=2.0.0"),
("2.0+deadbeef", "!=2"),
("2.0+deadbeef", "!=2.0"),
("2.0+deadbeef", "!=2.0.0"),
("2.0+deadbeef", "!=2+deadbeef"),
("2.0+deadbeef", "!=2.0+deadbeef"),
("2.0+deadbeef", "!=2.0.0+deadbeef"),
("2.0+deadbeef.0", "!=2.0.0+deadbeef.00"),
# Test the in-equality operation with a prefix
("2.dev1", "!=2.*"),
("2a1", "!=2.*"),
("2a1.post1", "!=2.*"),
("2b1", "!=2.*"),
("2b1.dev1", "!=2.*"),
("2c1", "!=2.*"),
("2c1.post1.dev1", "!=2.*"),
("2rc1", "!=2.*"),
("2", "!=2.*"),
("2.0", "!=2.*"),
("2.0.0", "!=2.*"),
("2.0.post1", "!=2.0.post1.*"),
("2.0.post1.dev1", "!=2.0.post1.*"),
# Test the greater than equal operation
("2.0.dev1", ">=2"),
("2.0a1", ">=2"),
("2.0a1.dev1", ">=2"),
("2.0b1", ">=2"),
("2.0b1.post1", ">=2"),
("2.0c1", ">=2"),
("2.0c1.post1.dev1", ">=2"),
("2.0rc1", ">=2"),
("1", ">=2"),
# Test the less than equal operation
("2.0.post1", "<=2"),
("2.0.post1.dev1", "<=2"),
("3", "<=2"),
# Test the greater than operation
("1", ">2"),
("2.0.dev1", ">2"),
("2.0a1", ">2"),
("2.0a1.post1", ">2"),
("2.0b1", ">2"),
("2.0b1.dev1", ">2"),
("2.0c1", ">2"),
("2.0c1.post1.dev1", ">2"),
("2.0rc1", ">2"),
("2.0", ">2"),
("2.0.post1", ">2"),
("2.0.post1.dev1", ">2"),
("2.0+local.version", ">2"),
# Test the less than operation
("2.0.dev1", "<2"),
("2.0a1", "<2"),
("2.0a1.post1", "<2"),
("2.0b1", "<2"),
("2.0b2.dev1", "<2"),
("2.0c1", "<2"),
("2.0c1.post1.dev1", "<2"),
("2.0rc1", "<2"),
("2.0", "<2"),
("2.post1", "<2"),
("2.post1.dev1", "<2"),
("3", "<2"),
# Test the compatibility operation
("2.0", "~=1.0"),
("1.1.0", "~=1.0.0"),
("1.1.post1", "~=1.0.0"),
# Test that epochs are handled sanely
("1.0", "~=2!1.0"),
("2!1.0", "~=1.0"),
("2!1.0", "==1.0"),
("1.0", "==2!1.0"),
("2!1.0", "==1.*"),
("1.0", "==2!1.*"),
("2!1.0", "!=2!1.0"),
]
],
)
def test_specifiers(self, version, spec, expected):
spec = Specifier(spec, prereleases=True)
if expected:
# Test that the plain string form works
assert version in spec
assert spec.contains(version)
# Test that the version instance form works
assert Version(version) in spec
assert spec.contains(Version(version))
else:
# Test that the plain string form works
assert version not in spec
assert not spec.contains(version)
# Test that the version instance form works
assert Version(version) not in spec
assert not spec.contains(Version(version))
@pytest.mark.parametrize(
("version", "spec", "expected"),
[
# Test identity comparison by itself
("lolwat", "===lolwat", True),
("Lolwat", "===lolwat", True),
("1.0", "===1.0", True),
("nope", "===lolwat", False),
("1.0.0", "===1.0", False),
("1.0.dev0", "===1.0.dev0", True),
],
)
def test_specifiers_identity(self, version, spec, expected):
spec = Specifier(spec)
if expected:
# Identity comparisons only support the plain string form
assert version in spec
else:
# Identity comparisons only support the plain string form
assert version not in spec
@pytest.mark.parametrize(
("specifier", "expected"),
[
("==1.0", False),
(">=1.0", False),
("<=1.0", False),
("~=1.0", False),
("<1.0", False),
(">1.0", False),
("<1.0.dev1", False),
(">1.0.dev1", False),
("==1.0.*", False),
("==1.0.dev1", True),
(">=1.0.dev1", True),
("<=1.0.dev1", True),
("~=1.0.dev1", True),
],
)
def test_specifier_prereleases_detection(self, specifier, expected):
assert Specifier(specifier).prereleases == expected
@pytest.mark.parametrize(
("specifier", "version", "expected"),
[
(">=1.0", "2.0.dev1", False),
(">=2.0.dev1", "2.0a1", True),
("==2.0.*", "2.0a1.dev1", False),
("==2.0a1.*", "2.0a1.dev1", True),
("<=2.0", "1.0.dev1", False),
("<=2.0.dev1", "1.0a1", True),
],
)
def test_specifiers_prereleases(self, specifier, version, expected):
spec = Specifier(specifier)
if expected:
assert version in spec
spec.prereleases = False
assert version not in spec
else:
assert version not in spec
spec.prereleases = True
assert version in spec
@pytest.mark.parametrize(
("specifier", "prereleases", "input", "expected"),
[
(">=1.0", None, ["2.0a1"], ["2.0a1"]),
(">=1.0.dev1", None, ["1.0", "2.0a1"], ["1.0", "2.0a1"]),
(">=1.0.dev1", False, ["1.0", "2.0a1"], ["1.0"]),
],
)
def test_specifier_filter(self, specifier, prereleases, input, expected):
spec = Specifier(specifier)
kwargs = {"prereleases": prereleases} if prereleases is not None else {}
assert list(spec.filter(input, **kwargs)) == expected
@pytest.mark.xfail
def test_specifier_explicit_legacy(self):
assert Specifier("==1.0").contains(LegacyVersion("1.0"))
@pytest.mark.parametrize(
("spec", "op"),
[
("~=2.0", "~="),
("==2.1.*", "=="),
("==2.1.0.3", "=="),
("!=2.2.*", "!="),
("!=2.2.0.5", "!="),
("<=5", "<="),
(">=7.9a1", ">="),
("<1.0.dev1", "<"),
(">2.0.post1", ">"),
("===lolwat", "==="),
],
)
def test_specifier_operator_property(self, spec, op):
assert Specifier(spec).operator == op
@pytest.mark.parametrize(
("spec", "version"),
[
("~=2.0", "2.0"),
("==2.1.*", "2.1.*"),
("==2.1.0.3", "2.1.0.3"),
("!=2.2.*", "2.2.*"),
("!=2.2.0.5", "2.2.0.5"),
("<=5", "5"),
(">=7.9a1", "7.9a1"),
("<1.0.dev1", "1.0.dev1"),
(">2.0.post1", "2.0.post1"),
("===lolwat", "lolwat"),
],
)
def test_specifier_version_property(self, spec, version):
assert Specifier(spec).version == version
@pytest.mark.parametrize(
("spec", "expected_length"),
[("", 0), ("==2.0", 1), (">=2.0", 1), (">=2.0,<3", 2), (">=2.0,<3,==2.4", 3)],
)
def test_length(self, spec, expected_length):
spec = SpecifierSet(spec)
assert len(spec) == expected_length
@pytest.mark.parametrize(
("spec", "expected_items"),
[
("", []),
("==2.0", ["==2.0"]),
(">=2.0", [">=2.0"]),
(">=2.0,<3", [">=2.0", "<3"]),
(">=2.0,<3,==2.4", [">=2.0", "<3", "==2.4"]),
],
)
def test_iteration(self, spec, expected_items):
spec = SpecifierSet(spec)
items = {str(item) for item in spec}
assert items == set(expected_items)
class TestLegacySpecifier:
def test_legacy_specifier_is_deprecated(self):
with warnings.catch_warnings(record=True) as w:
LegacySpecifier(">=some-legacy-version")
assert len(w) == 1
assert issubclass(w[0].category, DeprecationWarning)
@pytest.mark.parametrize(
("version", "spec", "expected"),
[
(v, s, True)
for v, s in [
# Test the equality operation
("2.0", "==2"),
("2.0", "==2.0"),
("2.0", "==2.0.0"),
# Test the in-equality operation
("2.1", "!=2"),
("2.1", "!=2.0"),
("2.0.1", "!=2"),
("2.0.1", "!=2.0"),
("2.0.1", "!=2.0.0"),
# Test the greater than equal operation
("2.0", ">=2"),
("2.0", ">=2.0"),
("2.0", ">=2.0.0"),
("2.0.post1", ">=2"),
("2.0.post1.dev1", ">=2"),
("3", ">=2"),
# Test the less than equal operation
("2.0", "<=2"),
("2.0", "<=2.0"),
("2.0", "<=2.0.0"),
("2.0.dev1", "<=2"),
("2.0a1", "<=2"),
("2.0a1.dev1", "<=2"),
("2.0b1", "<=2"),
("2.0b1.post1", "<=2"),
("2.0c1", "<=2"),
("2.0c1.post1.dev1", "<=2"),
("2.0rc1", "<=2"),
("1", "<=2"),
# Test the greater than operation
("3", ">2"),
("2.1", ">2.0"),
# Test the less than operation
("1", "<2"),
("2.0", "<2.1"),
]
]
+ [
(v, s, False)
for v, s in [
# Test the equality operation
("2.1", "==2"),
("2.1", "==2.0"),
("2.1", "==2.0.0"),
# Test the in-equality operation
("2.0", "!=2"),
("2.0", "!=2.0"),
("2.0", "!=2.0.0"),
# Test the greater than equal operation
("2.0.dev1", ">=2"),
("2.0a1", ">=2"),
("2.0a1.dev1", ">=2"),
("2.0b1", ">=2"),
("2.0b1.post1", ">=2"),
("2.0c1", ">=2"),
("2.0c1.post1.dev1", ">=2"),
("2.0rc1", ">=2"),
("1", ">=2"),
# Test the less than equal operation
("2.0.post1", "<=2"),
("2.0.post1.dev1", "<=2"),
("3", "<=2"),
# Test the greater than operation
("1", ">2"),
("2.0.dev1", ">2"),
("2.0a1", ">2"),
("2.0a1.post1", ">2"),
("2.0b1", ">2"),
("2.0b1.dev1", ">2"),
("2.0c1", ">2"),
("2.0c1.post1.dev1", ">2"),
("2.0rc1", ">2"),
("2.0", ">2"),
# Test the less than operation
("3", "<2"),
]
],
)
def test_specifiers(self, version, spec, expected):
spec = LegacySpecifier(spec, prereleases=True)
if expected:
# Test that the plain string form works
assert version in spec
assert spec.contains(version)
# Test that the version instance form works
assert LegacyVersion(version) in spec
assert spec.contains(LegacyVersion(version))
else:
# Test that the plain string form works
assert version not in spec
assert not spec.contains(version)
# Test that the version instance form works
assert LegacyVersion(version) not in spec
assert not spec.contains(LegacyVersion(version))
def test_specifier_explicit_prereleases(self):
spec = LegacySpecifier(">=1.0")
assert not spec.prereleases
spec.prereleases = True
assert spec.prereleases
spec = LegacySpecifier(">=1.0", prereleases=False)
assert not spec.prereleases
spec.prereleases = True
assert spec.prereleases
spec = LegacySpecifier(">=1.0", prereleases=True)
assert spec.prereleases
spec.prereleases = False
assert not spec.prereleases
spec = LegacySpecifier(">=1.0", prereleases=True)
assert spec.prereleases
spec.prereleases = None
assert not spec.prereleases
class TestSpecifierSet:
@pytest.mark.parametrize("version", VERSIONS + LEGACY_VERSIONS)
def test_empty_specifier(self, version):
spec = SpecifierSet(prereleases=True)
assert version in spec
assert spec.contains(version)
assert parse(version) in spec
assert spec.contains(parse(version))
def test_specifier_prereleases_explicit(self):
spec = SpecifierSet()
assert not spec.prereleases
assert "1.0.dev1" not in spec
assert not spec.contains("1.0.dev1")
spec.prereleases = True
assert spec.prereleases
assert "1.0.dev1" in spec
assert spec.contains("1.0.dev1")
spec = SpecifierSet(prereleases=True)
assert spec.prereleases
assert "1.0.dev1" in spec
assert spec.contains("1.0.dev1")
spec.prereleases = False
assert not spec.prereleases
assert "1.0.dev1" not in spec
assert not spec.contains("1.0.dev1")
spec = SpecifierSet(prereleases=True)
assert spec.prereleases
assert "1.0.dev1" in spec
assert spec.contains("1.0.dev1")
spec.prereleases = None
assert not spec.prereleases
assert "1.0.dev1" not in spec
assert not spec.contains("1.0.dev1")
def test_specifier_contains_prereleases(self):
spec = SpecifierSet()
assert spec.prereleases is None
assert not spec.contains("1.0.dev1")
assert spec.contains("1.0.dev1", prereleases=True)
spec = SpecifierSet(prereleases=True)
assert spec.prereleases
assert spec.contains("1.0.dev1")
assert not spec.contains("1.0.dev1", prereleases=False)
@pytest.mark.parametrize(
("specifier", "specifier_prereleases", "prereleases", "input", "expected"),
[
# General test of the filter method
("", None, None, ["1.0", "2.0a1"], ["1.0"]),
(">=1.0.dev1", None, None, ["1.0", "2.0a1"], ["1.0", "2.0a1"]),
("", None, None, ["1.0a1"], ["1.0a1"]),
("", None, None, ["1.0", Version("2.0")], ["1.0", Version("2.0")]),
("", None, None, ["2.0dog", "1.0"], ["1.0"]),
# Test overriding with the prereleases parameter on filter
("", None, False, ["1.0a1"], []),
(">=1.0.dev1", None, False, ["1.0", "2.0a1"], ["1.0"]),
("", None, True, ["1.0", "2.0a1"], ["1.0", "2.0a1"]),
# Test overriding with the overall specifier
("", True, None, ["1.0", "2.0a1"], ["1.0", "2.0a1"]),
("", False, None, ["1.0", "2.0a1"], ["1.0"]),
(">=1.0.dev1", True, None, ["1.0", "2.0a1"], ["1.0", "2.0a1"]),
(">=1.0.dev1", False, None, ["1.0", "2.0a1"], ["1.0"]),
("", True, None, ["1.0a1"], ["1.0a1"]),
("", False, None, ["1.0a1"], []),
],
)
def test_specifier_filter(
self, specifier_prereleases, specifier, prereleases, input, expected
):
if specifier_prereleases is None:
spec = SpecifierSet(specifier)
else:
spec = SpecifierSet(specifier, prereleases=specifier_prereleases)
kwargs = {"prereleases": prereleases} if prereleases is not None else {}
assert list(spec.filter(input, **kwargs)) == expected
def test_legacy_specifiers_combined(self):
spec = SpecifierSet("<3,>1-1-1")
assert "2.0" in spec
@pytest.mark.parametrize(
("specifier", "expected"),
[
# Single item specifiers should just be reflexive
("!=2.0", "!=2.0"),
("<2.0", "<2.0"),
("<=2.0", "<=2.0"),
("==2.0", "==2.0"),
(">2.0", ">2.0"),
(">=2.0", ">=2.0"),
("~=2.0", "~=2.0"),
# Spaces should be removed
("< 2", "<2"),
# Multiple item specifiers should work
("!=2.0,>1.0", "!=2.0,>1.0"),
("!=2.0 ,>1.0", "!=2.0,>1.0"),
],
)
def test_specifiers_str_and_repr(self, specifier, expected):
spec = SpecifierSet(specifier)
assert str(spec) == expected
assert repr(spec) == f""
@pytest.mark.parametrize("specifier", SPECIFIERS + LEGACY_SPECIFIERS)
def test_specifiers_hash(self, specifier):
assert hash(SpecifierSet(specifier)) == hash(SpecifierSet(specifier))
@pytest.mark.parametrize(
("left", "right", "expected"), [(">2.0", "<5.0", ">2.0,<5.0")]
)
def test_specifiers_combine(self, left, right, expected):
result = SpecifierSet(left) & SpecifierSet(right)
assert result == SpecifierSet(expected)
result = SpecifierSet(left) & right
assert result == SpecifierSet(expected)
result = SpecifierSet(left, prereleases=True) & SpecifierSet(right)
assert result == SpecifierSet(expected)
assert result.prereleases
result = SpecifierSet(left, prereleases=False) & SpecifierSet(right)
assert result == SpecifierSet(expected)
assert not result.prereleases
result = SpecifierSet(left) & SpecifierSet(right, prereleases=True)
assert result == SpecifierSet(expected)
assert result.prereleases
result = SpecifierSet(left) & SpecifierSet(right, prereleases=False)
assert result == SpecifierSet(expected)
assert not result.prereleases
result = SpecifierSet(left, prereleases=True) & SpecifierSet(
right, prereleases=True
)
assert result == SpecifierSet(expected)
assert result.prereleases
result = SpecifierSet(left, prereleases=False) & SpecifierSet(
right, prereleases=False
)
assert result == SpecifierSet(expected)
assert not result.prereleases
with pytest.raises(ValueError):
result = SpecifierSet(left, prereleases=True) & SpecifierSet(
right, prereleases=False
)
with pytest.raises(ValueError):
result = SpecifierSet(left, prereleases=False) & SpecifierSet(
right, prereleases=True
)
def test_specifiers_combine_not_implemented(self):
with pytest.raises(TypeError):
SpecifierSet() & 12
@pytest.mark.parametrize(
("left", "right", "op"),
itertools.chain(
*
# Verify that the equal (==) operator works correctly
[[(x, x, operator.eq) for x in SPECIFIERS]]
+
# Verify that the not equal (!=) operator works correctly
[
[(x, y, operator.ne) for j, y in enumerate(SPECIFIERS) if i != j]
for i, x in enumerate(SPECIFIERS)
]
),
)
def test_comparison_true(self, left, right, op):
assert op(SpecifierSet(left), SpecifierSet(right))
assert op(SpecifierSet(left), Specifier(right))
assert op(Specifier(left), SpecifierSet(right))
assert op(left, SpecifierSet(right))
assert op(SpecifierSet(left), right)
@pytest.mark.parametrize(
("left", "right", "op"),
itertools.chain(
*
# Verify that the equal (==) operator works correctly
[[(x, x, operator.ne) for x in SPECIFIERS]]
+
# Verify that the not equal (!=) operator works correctly
[
[(x, y, operator.eq) for j, y in enumerate(SPECIFIERS) if i != j]
for i, x in enumerate(SPECIFIERS)
]
),
)
def test_comparison_false(self, left, right, op):
assert not op(SpecifierSet(left), SpecifierSet(right))
assert not op(SpecifierSet(left), Specifier(right))
assert not op(Specifier(left), SpecifierSet(right))
assert not op(left, SpecifierSet(right))
assert not op(SpecifierSet(left), right)
@pytest.mark.parametrize(("left", "right"), [("==2.8.0", "==2.8")])
def test_comparison_canonicalizes(self, left, right):
assert SpecifierSet(left) == SpecifierSet(right)
assert left == SpecifierSet(right)
assert SpecifierSet(left) == right
def test_comparison_non_specifier(self):
assert SpecifierSet("==1.0") != 12
assert not SpecifierSet("==1.0") == 12
@pytest.mark.parametrize(
("version", "specifier", "expected"),
[
("1.0.0+local", "==1.0.0", True),
("1.0.0+local", "!=1.0.0", False),
("1.0.0+local", "<=1.0.0", True),
("1.0.0+local", ">=1.0.0", True),
("1.0.0+local", "<1.0.0", False),
("1.0.0+local", ">1.0.0", False),
],
)
def test_comparison_ignores_local(self, version, specifier, expected):
assert (Version(version) in SpecifierSet(specifier)) == expected
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1624128339.0
packaging-21.3/tests/test_structures.py 0000644 0000765 0000024 00000002727 00000000000 020572 0 ustar 00brettcannon staff # 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 pytest
from packaging._structures import Infinity, NegativeInfinity
def test_infinity_repr():
repr(Infinity) == "Infinity"
def test_negative_infinity_repr():
repr(NegativeInfinity) == "-Infinity"
def test_infinity_hash():
assert hash(Infinity) == hash(Infinity)
def test_negative_infinity_hash():
assert hash(NegativeInfinity) == hash(NegativeInfinity)
@pytest.mark.parametrize("left", [1, "a", ("b", 4)])
def test_infinity_comparison(left):
assert left < Infinity
assert left <= Infinity
assert not left == Infinity
assert left != Infinity
assert not left > Infinity
assert not left >= Infinity
@pytest.mark.parametrize("left", [1, "a", ("b", 4)])
def test_negative_infinity_lesser(left):
assert not left < NegativeInfinity
assert not left <= NegativeInfinity
assert not left == NegativeInfinity
assert left != NegativeInfinity
assert left > NegativeInfinity
assert left >= NegativeInfinity
def test_infinity_equal():
assert Infinity == Infinity
def test_negative_infinity_equal():
assert NegativeInfinity == NegativeInfinity
def test_negate_infinity():
assert isinstance(-Infinity, NegativeInfinity.__class__)
def test_negate_negative_infinity():
assert isinstance(-NegativeInfinity, Infinity.__class__)
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1637079931.0
packaging-21.3/tests/test_tags.py 0000644 0000765 0000024 00000135143 00000000000 017304 0 ustar 00brettcannon staff # 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 collections.abc
try:
import ctypes
except ImportError:
ctypes = None
import os
import pathlib
import platform
import sys
import sysconfig
import types
import pretend
import pytest
from packaging import tags
from packaging._musllinux import _MuslVersion
@pytest.fixture
def example_tag():
return tags.Tag("py3", "none", "any")
@pytest.fixture
def manylinux_module(monkeypatch):
monkeypatch.setattr(tags._manylinux, "_get_glibc_version", lambda *args: (2, 20))
module_name = "_manylinux"
module = types.ModuleType(module_name)
monkeypatch.setitem(sys.modules, module_name, module)
return module
@pytest.fixture
def mock_interpreter_name(monkeypatch):
def mock(name):
name = name.lower()
if sys.implementation.name != name:
monkeypatch.setattr(sys.implementation, "name", name)
return True
return False
return mock
class TestTag:
def test_lowercasing(self):
tag = tags.Tag("PY3", "None", "ANY")
assert tag.interpreter == "py3"
assert tag.abi == "none"
assert tag.platform == "any"
def test_equality(self):
args = "py3", "none", "any"
assert tags.Tag(*args) == tags.Tag(*args)
def test_equality_fails_with_non_tag(self):
assert not tags.Tag("py3", "none", "any") == "non-tag"
def test_hashing(self, example_tag):
tags = {example_tag} # Should not raise TypeError.
assert example_tag in tags
def test_hash_equality(self, example_tag):
equal_tag = tags.Tag("py3", "none", "any")
assert example_tag == equal_tag # Sanity check.
assert example_tag.__hash__() == equal_tag.__hash__()
def test_str(self, example_tag):
assert str(example_tag) == "py3-none-any"
def test_repr(self, example_tag):
assert repr(example_tag) == "".format(
tag_id=id(example_tag)
)
def test_attribute_access(self, example_tag):
assert example_tag.interpreter == "py3"
assert example_tag.abi == "none"
assert example_tag.platform == "any"
class TestParseTag:
def test_simple(self, example_tag):
parsed_tags = tags.parse_tag(str(example_tag))
assert parsed_tags == {example_tag}
def test_multi_interpreter(self, example_tag):
expected = {example_tag, tags.Tag("py2", "none", "any")}
given = tags.parse_tag("py2.py3-none-any")
assert given == expected
def test_multi_platform(self):
expected = {
tags.Tag("cp37", "cp37m", platform)
for platform in (
"macosx_10_6_intel",
"macosx_10_9_intel",
"macosx_10_9_x86_64",
"macosx_10_10_intel",
"macosx_10_10_x86_64",
)
}
given = tags.parse_tag(
"cp37-cp37m-macosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64."
"macosx_10_10_intel.macosx_10_10_x86_64"
)
assert given == expected
class TestInterpreterName:
def test_sys_implementation_name(self, monkeypatch):
class MockImplementation:
pass
mock_implementation = MockImplementation()
mock_implementation.name = "sillywalk"
monkeypatch.setattr(sys, "implementation", mock_implementation, raising=False)
assert tags.interpreter_name() == "sillywalk"
def test_interpreter_short_names(self, mock_interpreter_name, monkeypatch):
mock_interpreter_name("cpython")
assert tags.interpreter_name() == "cp"
class TestInterpreterVersion:
def test_warn(self, monkeypatch):
class MockConfigVar:
def __init__(self, return_):
self.warn = None
self._return = return_
def __call__(self, name, warn):
self.warn = warn
return self._return
mock_config_var = MockConfigVar("38")
monkeypatch.setattr(tags, "_get_config_var", mock_config_var)
tags.interpreter_version(warn=True)
assert mock_config_var.warn
def test_python_version_nodot(self, monkeypatch):
monkeypatch.setattr(tags, "_get_config_var", lambda var, warn: "NN")
assert tags.interpreter_version() == "NN"
@pytest.mark.parametrize(
"version_info,version_str",
[
((1, 2, 3), "12"),
((1, 12, 3), "112"),
((11, 2, 3), "112"),
((11, 12, 3), "1112"),
((1, 2, 13), "12"),
],
)
def test_sys_version_info(self, version_info, version_str, monkeypatch):
monkeypatch.setattr(tags, "_get_config_var", lambda *args, **kwargs: None)
monkeypatch.setattr(sys, "version_info", version_info)
assert tags.interpreter_version() == version_str
class TestMacOSPlatforms:
@pytest.mark.parametrize(
"arch, is_32bit, expected",
[
("i386", True, "i386"),
("ppc", True, "ppc"),
("x86_64", False, "x86_64"),
("x86_64", True, "i386"),
("ppc64", False, "ppc64"),
("ppc64", True, "ppc"),
],
)
def test_architectures(self, arch, is_32bit, expected):
assert tags._mac_arch(arch, is_32bit=is_32bit) == expected
@pytest.mark.parametrize(
"version,arch,expected",
[
(
(10, 15),
"x86_64",
["x86_64", "intel", "fat64", "fat32", "universal2", "universal"],
),
(
(10, 4),
"x86_64",
["x86_64", "intel", "fat64", "fat32", "universal2", "universal"],
),
((10, 3), "x86_64", []),
((10, 15), "i386", ["i386", "intel", "fat32", "fat", "universal"]),
((10, 4), "i386", ["i386", "intel", "fat32", "fat", "universal"]),
((10, 3), "intel", ["intel", "universal"]),
((10, 5), "intel", ["intel", "universal"]),
((10, 15), "intel", ["intel", "universal"]),
((10, 3), "i386", []),
((10, 15), "ppc64", []),
((10, 6), "ppc64", []),
((10, 5), "ppc64", ["ppc64", "fat64", "universal"]),
((10, 3), "ppc64", []),
((10, 15), "ppc", []),
((10, 7), "ppc", []),
((10, 6), "ppc", ["ppc", "fat32", "fat", "universal"]),
((10, 0), "ppc", ["ppc", "fat32", "fat", "universal"]),
((11, 0), "riscv", ["riscv"]),
(
(11, 0),
"x86_64",
["x86_64", "intel", "fat64", "fat32", "universal2", "universal"],
),
((11, 0), "arm64", ["arm64", "universal2"]),
((11, 1), "arm64", ["arm64", "universal2"]),
((12, 0), "arm64", ["arm64", "universal2"]),
],
)
def test_binary_formats(self, version, arch, expected):
assert tags._mac_binary_formats(version, arch) == expected
def test_version_detection(self, monkeypatch):
if platform.system() != "Darwin":
monkeypatch.setattr(
platform, "mac_ver", lambda: ("10.14", ("", "", ""), "x86_64")
)
version = platform.mac_ver()[0].split(".")
major = version[0]
minor = version[1] if major == "10" else "0"
expected = f"macosx_{major}_{minor}"
platforms = list(tags.mac_platforms(arch="x86_64"))
print(platforms, expected)
assert platforms[0].startswith(expected)
@pytest.mark.parametrize("arch", ["x86_64", "i386"])
def test_arch_detection(self, arch, monkeypatch):
if platform.system() != "Darwin" or platform.mac_ver()[2] != arch:
monkeypatch.setattr(
platform, "mac_ver", lambda: ("10.14", ("", "", ""), arch)
)
monkeypatch.setattr(tags, "_mac_arch", lambda *args: arch)
assert next(tags.mac_platforms((10, 14))).endswith(arch)
def test_mac_platforms(self):
platforms = list(tags.mac_platforms((10, 5), "x86_64"))
assert platforms == [
"macosx_10_5_x86_64",
"macosx_10_5_intel",
"macosx_10_5_fat64",
"macosx_10_5_fat32",
"macosx_10_5_universal2",
"macosx_10_5_universal",
"macosx_10_4_x86_64",
"macosx_10_4_intel",
"macosx_10_4_fat64",
"macosx_10_4_fat32",
"macosx_10_4_universal2",
"macosx_10_4_universal",
]
assert len(list(tags.mac_platforms((10, 17), "x86_64"))) == 14 * 6
assert not list(tags.mac_platforms((10, 0), "x86_64"))
@pytest.mark.parametrize("major,minor", [(11, 0), (11, 3), (12, 0), (12, 3)])
def test_macos_11(self, major, minor):
platforms = list(tags.mac_platforms((major, minor), "x86_64"))
assert "macosx_11_0_arm64" not in platforms
assert "macosx_11_0_x86_64" in platforms
assert "macosx_11_3_x86_64" not in platforms
assert "macosx_11_0_universal" in platforms
assert "macosx_11_0_universal2" in platforms
# Mac OS "10.16" is the version number that binaries compiled against an old
# (pre 11.0) SDK will see. It can also be enabled explicitly for a process
# with the environment variable SYSTEM_VERSION_COMPAT=1.
assert "macosx_10_16_x86_64" in platforms
assert "macosx_10_15_x86_64" in platforms
assert "macosx_10_15_universal2" in platforms
assert "macosx_10_4_x86_64" in platforms
assert "macosx_10_3_x86_64" not in platforms
if major >= 12:
assert "macosx_12_0_x86_64" in platforms
assert "macosx_12_0_universal" in platforms
assert "macosx_12_0_universal2" in platforms
platforms = list(tags.mac_platforms((major, minor), "arm64"))
assert "macosx_11_0_arm64" in platforms
assert "macosx_11_3_arm64" not in platforms
assert "macosx_11_0_universal" not in platforms
assert "macosx_11_0_universal2" in platforms
assert "macosx_10_15_universal2" in platforms
assert "macosx_10_15_x86_64" not in platforms
assert "macosx_10_4_x86_64" not in platforms
assert "macosx_10_3_x86_64" not in platforms
if major >= 12:
assert "macosx_12_0_arm64" in platforms
assert "macosx_12_0_universal2" in platforms
class TestManylinuxPlatform:
def teardown_method(self):
# Clear the version cache
tags._manylinux._get_glibc_version.cache_clear()
def test_get_config_var_does_not_log(self, monkeypatch):
debug = pretend.call_recorder(lambda *a: None)
monkeypatch.setattr(tags.logger, "debug", debug)
tags._get_config_var("missing")
assert debug.calls == []
def test_get_config_var_does_log(self, monkeypatch):
debug = pretend.call_recorder(lambda *a: None)
monkeypatch.setattr(tags.logger, "debug", debug)
tags._get_config_var("missing", warn=True)
assert debug.calls == [
pretend.call(
"Config variable '%s' is unset, Python ABI tag may be incorrect",
"missing",
)
]
@pytest.mark.parametrize(
"arch,is_32bit,expected",
[
("linux-x86_64", False, "linux_x86_64"),
("linux-x86_64", True, "linux_i686"),
("linux-aarch64", False, "linux_aarch64"),
("linux-aarch64", True, "linux_armv7l"),
],
)
def test_linux_platforms_32_64bit_on_64bit_os(
self, arch, is_32bit, expected, monkeypatch
):
monkeypatch.setattr(sysconfig, "get_platform", lambda: arch)
monkeypatch.setattr(os, "confstr", lambda x: "glibc 2.20", raising=False)
monkeypatch.setattr(tags._manylinux, "_is_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(sysconfig, "get_platform", lambda: "linux_x86_64")
monkeypatch.setattr(os, "confstr", lambda x: "glibc 2.20", raising=False)
monkeypatch.setattr(tags._manylinux, "_is_compatible", lambda *args: False)
linux_platform = list(tags._linux_platforms(is_32bit=False))
assert linux_platform == ["linux_x86_64"]
def test_linux_platforms_manylinux1(self, monkeypatch):
monkeypatch.setattr(
tags._manylinux, "_is_compatible", lambda name, *args: name == "manylinux1"
)
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))
arch = platform.machine()
assert platforms == ["manylinux1_" + arch, "linux_" + arch]
def test_linux_platforms_manylinux2010(self, monkeypatch):
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))
arch = platform.machine()
expected = [
"manylinux_2_12_" + arch,
"manylinux2010_" + arch,
"manylinux_2_11_" + arch,
"manylinux_2_10_" + arch,
"manylinux_2_9_" + arch,
"manylinux_2_8_" + arch,
"manylinux_2_7_" + arch,
"manylinux_2_6_" + arch,
"manylinux_2_5_" + arch,
"manylinux1_" + arch,
"linux_" + arch,
]
assert platforms == expected
def test_linux_platforms_manylinux2014(self, monkeypatch):
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))
arch = platform.machine()
expected = [
"manylinux_2_17_" + arch,
"manylinux2014_" + arch,
"manylinux_2_16_" + arch,
"manylinux_2_15_" + arch,
"manylinux_2_14_" + arch,
"manylinux_2_13_" + arch,
"manylinux_2_12_" + arch,
"manylinux2010_" + arch,
"manylinux_2_11_" + arch,
"manylinux_2_10_" + arch,
"manylinux_2_9_" + arch,
"manylinux_2_8_" + arch,
"manylinux_2_7_" + arch,
"manylinux_2_6_" + arch,
"manylinux_2_5_" + arch,
"manylinux1_" + arch,
"linux_" + arch,
]
assert platforms == expected
def test_linux_platforms_manylinux2014_armhf_abi(self, monkeypatch):
monkeypatch.setattr(tags._manylinux, "_glibc_version_string", lambda: "2.30")
monkeypatch.setattr(
tags._manylinux,
"_is_compatible",
lambda name, *args: name == "manylinux2014",
)
monkeypatch.setattr(sysconfig, "get_platform", lambda: "linux_armv7l")
monkeypatch.setattr(
sys,
"executable",
os.path.join(
os.path.dirname(__file__),
"manylinux",
"hello-world-armv7l-armhf",
),
)
platforms = list(tags._linux_platforms(is_32bit=True))
expected = ["manylinux2014_armv7l", "linux_armv7l"]
assert platforms == expected
def test_linux_platforms_manylinux2014_i386_abi(self, monkeypatch):
monkeypatch.setattr(tags._manylinux, "_glibc_version_string", lambda: "2.17")
monkeypatch.setattr(sysconfig, "get_platform", lambda: "linux_x86_64")
monkeypatch.setattr(
sys,
"executable",
os.path.join(
os.path.dirname(__file__),
"manylinux",
"hello-world-x86_64-i386",
),
)
platforms = list(tags._linux_platforms(is_32bit=True))
expected = [
"manylinux_2_17_i686",
"manylinux2014_i686",
"manylinux_2_16_i686",
"manylinux_2_15_i686",
"manylinux_2_14_i686",
"manylinux_2_13_i686",
"manylinux_2_12_i686",
"manylinux2010_i686",
"manylinux_2_11_i686",
"manylinux_2_10_i686",
"manylinux_2_9_i686",
"manylinux_2_8_i686",
"manylinux_2_7_i686",
"manylinux_2_6_i686",
"manylinux_2_5_i686",
"manylinux1_i686",
"linux_i686",
]
assert platforms == expected
def test_linux_platforms_manylinux_glibc3(self, monkeypatch):
# test for a future glic 3.x version
monkeypatch.setattr(tags._manylinux, "_glibc_version_string", lambda: "3.2")
monkeypatch.setattr(tags._manylinux, "_is_compatible", lambda name, *args: True)
monkeypatch.setattr(sysconfig, "get_platform", lambda: "linux_aarch64")
monkeypatch.setattr(
sys,
"executable",
os.path.join(
os.path.dirname(__file__),
"manylinux",
"hello-world-aarch64",
),
)
platforms = list(tags._linux_platforms(is_32bit=False))
expected = (
["manylinux_3_2_aarch64", "manylinux_3_1_aarch64", "manylinux_3_0_aarch64"]
+ [f"manylinux_2_{i}_aarch64" for i in range(50, 16, -1)]
+ ["manylinux2014_aarch64", "linux_aarch64"]
)
assert platforms == expected
@pytest.mark.parametrize(
"native_arch, cross32_arch, musl_version",
[
("aarch64", "armv7l", _MuslVersion(1, 1)),
("i386", "i386", _MuslVersion(1, 2)),
("x86_64", "i686", _MuslVersion(1, 2)),
],
)
@pytest.mark.parametrize("cross32", [True, False], ids=["cross", "native"])
def test_linux_platforms_musllinux(
self, monkeypatch, native_arch, cross32_arch, musl_version, cross32
):
fake_executable = str(
pathlib.Path(__file__)
.parent.joinpath("musllinux", f"musl-{native_arch}")
.resolve()
)
monkeypatch.setattr(tags._musllinux.sys, "executable", fake_executable)
monkeypatch.setattr(sysconfig, "get_platform", lambda: f"linux_{native_arch}")
monkeypatch.setattr(tags._manylinux, "platform_tags", lambda *_: ())
recorder = pretend.call_recorder(lambda _: musl_version)
monkeypatch.setattr(tags._musllinux, "_get_musl_version", recorder)
platforms = list(tags._linux_platforms(is_32bit=cross32))
target_arch = cross32_arch if cross32 else native_arch
expected = [
f"musllinux_{musl_version[0]}_{minor}_{target_arch}"
for minor in range(musl_version[1], -1, -1)
] + [f"linux_{target_arch}"]
assert platforms == expected
assert recorder.calls == [pretend.call(fake_executable)]
def test_linux_platforms_manylinux2014_armv6l(self, monkeypatch):
monkeypatch.setattr(
tags._manylinux, "_is_compatible", lambda name, _: name == "manylinux2014"
)
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
@pytest.mark.parametrize(
"machine, abi, alt_machine",
[("x86_64", "x32", "i686"), ("armv7l", "armel", "armv7l")],
)
def test_linux_platforms_not_manylinux_abi(
self, monkeypatch, machine, abi, alt_machine
):
monkeypatch.setattr(tags._manylinux, "_is_compatible", lambda name, _: False)
monkeypatch.setattr(sysconfig, "get_platform", lambda: f"linux_{machine}")
monkeypatch.setattr(
sys,
"executable",
os.path.join(
os.path.dirname(__file__),
"manylinux",
f"hello-world-{machine}-{abi}",
),
)
platforms = list(tags._linux_platforms(is_32bit=True))
expected = [f"linux_{alt_machine}"]
assert platforms == expected
@pytest.mark.parametrize(
"platform_name,dispatch_func",
[
("Darwin", "mac_platforms"),
("Linux", "_linux_platforms"),
("Generic", "_generic_platforms"),
],
)
def test_platform_tags(platform_name, dispatch_func, monkeypatch):
expected = ["sillywalk"]
monkeypatch.setattr(platform, "system", lambda: platform_name)
monkeypatch.setattr(tags, dispatch_func, lambda: expected)
assert tags.platform_tags() == expected
class TestCPythonABI:
@pytest.mark.parametrize(
"py_debug,gettotalrefcount,result",
[(1, False, True), (0, False, False), (None, True, True)],
)
def test_debug(self, py_debug, gettotalrefcount, result, monkeypatch):
config = {"Py_DEBUG": py_debug, "WITH_PYMALLOC": 0, "Py_UNICODE_SIZE": 2}
monkeypatch.setattr(sysconfig, "get_config_var", config.__getitem__)
if gettotalrefcount:
monkeypatch.setattr(sys, "gettotalrefcount", 1, raising=False)
expected = ["cp37d" if result else "cp37"]
assert tags._cpython_abis((3, 7)) == expected
def test_debug_file_extension(self, monkeypatch):
config = {"Py_DEBUG": None}
monkeypatch.setattr(sysconfig, "get_config_var", config.__getitem__)
monkeypatch.delattr(sys, "gettotalrefcount", raising=False)
monkeypatch.setattr(tags, "EXTENSION_SUFFIXES", {"_d.pyd"})
assert tags._cpython_abis((3, 8)) == ["cp38d", "cp38"]
@pytest.mark.parametrize(
"debug,expected", [(True, ["cp38d", "cp38"]), (False, ["cp38"])]
)
def test__debug_cp38(self, debug, expected, monkeypatch):
config = {"Py_DEBUG": debug}
monkeypatch.setattr(sysconfig, "get_config_var", config.__getitem__)
assert tags._cpython_abis((3, 8)) == expected
@pytest.mark.parametrize(
"pymalloc,version,result",
[
(1, (3, 7), True),
(0, (3, 7), False),
(None, (3, 7), True),
(1, (3, 8), False),
],
)
def test_pymalloc(self, pymalloc, version, result, monkeypatch):
config = {"Py_DEBUG": 0, "WITH_PYMALLOC": pymalloc, "Py_UNICODE_SIZE": 2}
monkeypatch.setattr(sysconfig, "get_config_var", config.__getitem__)
base_abi = f"cp{version[0]}{version[1]}"
expected = [base_abi + "m" if result else base_abi]
assert tags._cpython_abis(version) == expected
@pytest.mark.parametrize(
"unicode_size,maxunicode,version,result",
[
(4, 0x10FFFF, (3, 2), True),
(2, 0xFFFF, (3, 2), False),
(None, 0x10FFFF, (3, 2), True),
(None, 0xFFFF, (3, 2), False),
(4, 0x10FFFF, (3, 3), False),
],
)
def test_wide_unicode(self, unicode_size, maxunicode, version, result, monkeypatch):
config = {"Py_DEBUG": 0, "WITH_PYMALLOC": 0, "Py_UNICODE_SIZE": unicode_size}
monkeypatch.setattr(sysconfig, "get_config_var", config.__getitem__)
monkeypatch.setattr(sys, "maxunicode", maxunicode)
base_abi = "cp" + tags._version_nodot(version)
expected = [base_abi + "u" if result else base_abi]
assert tags._cpython_abis(version) == expected
class TestCPythonTags:
def test_iterator_returned(self):
result_iterator = tags.cpython_tags(
(3, 8), ["cp38d", "cp38"], ["plat1", "plat2"]
)
assert isinstance(result_iterator, collections.abc.Iterator)
def test_all_args(self):
result_iterator = tags.cpython_tags(
(3, 11), ["cp311d", "cp311"], ["plat1", "plat2"]
)
result = list(result_iterator)
assert result == [
tags.Tag("cp311", "cp311d", "plat1"),
tags.Tag("cp311", "cp311d", "plat2"),
tags.Tag("cp311", "cp311", "plat1"),
tags.Tag("cp311", "cp311", "plat2"),
tags.Tag("cp311", "abi3", "plat1"),
tags.Tag("cp311", "abi3", "plat2"),
tags.Tag("cp311", "none", "plat1"),
tags.Tag("cp311", "none", "plat2"),
tags.Tag("cp310", "abi3", "plat1"),
tags.Tag("cp310", "abi3", "plat2"),
tags.Tag("cp39", "abi3", "plat1"),
tags.Tag("cp39", "abi3", "plat2"),
tags.Tag("cp38", "abi3", "plat1"),
tags.Tag("cp38", "abi3", "plat2"),
tags.Tag("cp37", "abi3", "plat1"),
tags.Tag("cp37", "abi3", "plat2"),
tags.Tag("cp36", "abi3", "plat1"),
tags.Tag("cp36", "abi3", "plat2"),
tags.Tag("cp35", "abi3", "plat1"),
tags.Tag("cp35", "abi3", "plat2"),
tags.Tag("cp34", "abi3", "plat1"),
tags.Tag("cp34", "abi3", "plat2"),
tags.Tag("cp33", "abi3", "plat1"),
tags.Tag("cp33", "abi3", "plat2"),
tags.Tag("cp32", "abi3", "plat1"),
tags.Tag("cp32", "abi3", "plat2"),
]
result_iterator = tags.cpython_tags(
(3, 8), ["cp38d", "cp38"], ["plat1", "plat2"]
)
result = list(result_iterator)
assert result == [
tags.Tag("cp38", "cp38d", "plat1"),
tags.Tag("cp38", "cp38d", "plat2"),
tags.Tag("cp38", "cp38", "plat1"),
tags.Tag("cp38", "cp38", "plat2"),
tags.Tag("cp38", "abi3", "plat1"),
tags.Tag("cp38", "abi3", "plat2"),
tags.Tag("cp38", "none", "plat1"),
tags.Tag("cp38", "none", "plat2"),
tags.Tag("cp37", "abi3", "plat1"),
tags.Tag("cp37", "abi3", "plat2"),
tags.Tag("cp36", "abi3", "plat1"),
tags.Tag("cp36", "abi3", "plat2"),
tags.Tag("cp35", "abi3", "plat1"),
tags.Tag("cp35", "abi3", "plat2"),
tags.Tag("cp34", "abi3", "plat1"),
tags.Tag("cp34", "abi3", "plat2"),
tags.Tag("cp33", "abi3", "plat1"),
tags.Tag("cp33", "abi3", "plat2"),
tags.Tag("cp32", "abi3", "plat1"),
tags.Tag("cp32", "abi3", "plat2"),
]
result = list(tags.cpython_tags((3, 3), ["cp33m"], ["plat1", "plat2"]))
assert result == [
tags.Tag("cp33", "cp33m", "plat1"),
tags.Tag("cp33", "cp33m", "plat2"),
tags.Tag("cp33", "abi3", "plat1"),
tags.Tag("cp33", "abi3", "plat2"),
tags.Tag("cp33", "none", "plat1"),
tags.Tag("cp33", "none", "plat2"),
tags.Tag("cp32", "abi3", "plat1"),
tags.Tag("cp32", "abi3", "plat2"),
]
def test_python_version_defaults(self):
tag = next(tags.cpython_tags(abis=["abi3"], platforms=["any"]))
interpreter = "cp" + tags._version_nodot(sys.version_info[:2])
assert interpreter == tag.interpreter
def test_abi_defaults(self, monkeypatch):
monkeypatch.setattr(tags, "_cpython_abis", lambda _1, _2: ["cp38"])
result = list(tags.cpython_tags((3, 8), platforms=["any"]))
assert tags.Tag("cp38", "cp38", "any") in result
assert tags.Tag("cp38", "abi3", "any") in result
assert tags.Tag("cp38", "none", "any") in result
def test_abi_defaults_needs_underscore(self, monkeypatch):
monkeypatch.setattr(tags, "_cpython_abis", lambda _1, _2: ["cp311"])
result = list(tags.cpython_tags((3, 11), platforms=["any"]))
assert tags.Tag("cp311", "cp311", "any") in result
assert tags.Tag("cp311", "abi3", "any") in result
assert tags.Tag("cp311", "none", "any") in result
def test_platforms_defaults(self, monkeypatch):
monkeypatch.setattr(tags, "platform_tags", lambda: ["plat1"])
result = list(tags.cpython_tags((3, 8), abis=["whatever"]))
assert tags.Tag("cp38", "whatever", "plat1") in result
def test_platforms_defaults_needs_underscore(self, monkeypatch):
monkeypatch.setattr(tags, "platform_tags", lambda: ["plat1"])
result = list(tags.cpython_tags((3, 11), abis=["whatever"]))
assert tags.Tag("cp311", "whatever", "plat1") in result
def test_major_only_python_version(self):
result = list(tags.cpython_tags((3,), ["abi"], ["plat"]))
assert result == [
tags.Tag("cp3", "abi", "plat"),
tags.Tag("cp3", "none", "plat"),
]
def test_major_only_python_version_with_default_abis(self):
result = list(tags.cpython_tags((3,), platforms=["plat"]))
assert result == [tags.Tag("cp3", "none", "plat")]
@pytest.mark.parametrize("abis", [[], ["abi3"], ["none"]])
def test_skip_redundant_abis(self, abis):
results = list(tags.cpython_tags((3, 0), abis=abis, platforms=["any"]))
assert results == [tags.Tag("cp30", "none", "any")]
def test_abi3_python33(self):
results = list(tags.cpython_tags((3, 3), abis=["cp33"], platforms=["plat"]))
assert results == [
tags.Tag("cp33", "cp33", "plat"),
tags.Tag("cp33", "abi3", "plat"),
tags.Tag("cp33", "none", "plat"),
tags.Tag("cp32", "abi3", "plat"),
]
def test_no_excess_abi3_python32(self):
results = list(tags.cpython_tags((3, 2), abis=["cp32"], platforms=["plat"]))
assert results == [
tags.Tag("cp32", "cp32", "plat"),
tags.Tag("cp32", "abi3", "plat"),
tags.Tag("cp32", "none", "plat"),
]
def test_no_abi3_python31(self):
results = list(tags.cpython_tags((3, 1), abis=["cp31"], platforms=["plat"]))
assert results == [
tags.Tag("cp31", "cp31", "plat"),
tags.Tag("cp31", "none", "plat"),
]
def test_no_abi3_python27(self):
results = list(tags.cpython_tags((2, 7), abis=["cp27"], platforms=["plat"]))
assert results == [
tags.Tag("cp27", "cp27", "plat"),
tags.Tag("cp27", "none", "plat"),
]
class TestGenericTags:
@pytest.mark.skipif(
not sysconfig.get_config_var("SOABI"), reason="SOABI not defined"
)
def test__generic_abi_soabi_provided(self):
abi = sysconfig.get_config_var("SOABI").replace(".", "_").replace("-", "_")
assert [abi] == list(tags._generic_abi())
def test__generic_abi(self, monkeypatch):
monkeypatch.setattr(
sysconfig, "get_config_var", lambda key: "cpython-37m-darwin"
)
assert list(tags._generic_abi()) == ["cpython_37m_darwin"]
def test__generic_abi_no_soabi(self, monkeypatch):
monkeypatch.setattr(sysconfig, "get_config_var", lambda key: None)
assert not list(tags._generic_abi())
def test_generic_platforms(self):
platform = sysconfig.get_platform().replace("-", "_")
platform = platform.replace(".", "_")
assert list(tags._generic_platforms()) == [platform]
def test_iterator_returned(self):
result_iterator = tags.generic_tags("sillywalk33", ["abi"], ["plat1", "plat2"])
assert isinstance(result_iterator, collections.abc.Iterator)
def test_all_args(self):
result_iterator = tags.generic_tags("sillywalk33", ["abi"], ["plat1", "plat2"])
result = list(result_iterator)
assert result == [
tags.Tag("sillywalk33", "abi", "plat1"),
tags.Tag("sillywalk33", "abi", "plat2"),
tags.Tag("sillywalk33", "none", "plat1"),
tags.Tag("sillywalk33", "none", "plat2"),
]
@pytest.mark.parametrize("abi", [[], ["none"]])
def test_abi_unspecified(self, abi):
no_abi = list(tags.generic_tags("sillywalk34", abi, ["plat1", "plat2"]))
assert no_abi == [
tags.Tag("sillywalk34", "none", "plat1"),
tags.Tag("sillywalk34", "none", "plat2"),
]
def test_interpreter_default(self, monkeypatch):
monkeypatch.setattr(tags, "interpreter_name", lambda: "sillywalk")
monkeypatch.setattr(tags, "interpreter_version", lambda warn: "NN")
result = list(tags.generic_tags(abis=["none"], platforms=["any"]))
assert result == [tags.Tag("sillywalkNN", "none", "any")]
def test_abis_default(self, monkeypatch):
monkeypatch.setattr(tags, "_generic_abi", lambda: iter(["abi"]))
result = list(tags.generic_tags(interpreter="sillywalk", platforms=["any"]))
assert result == [
tags.Tag("sillywalk", "abi", "any"),
tags.Tag("sillywalk", "none", "any"),
]
def test_platforms_default(self, monkeypatch):
monkeypatch.setattr(tags, "platform_tags", lambda: ["plat"])
result = list(tags.generic_tags(interpreter="sillywalk", abis=["none"]))
assert result == [tags.Tag("sillywalk", "none", "plat")]
class TestCompatibleTags:
def test_all_args(self):
result = list(tags.compatible_tags((3, 3), "cp33", ["plat1", "plat2"]))
assert result == [
tags.Tag("py33", "none", "plat1"),
tags.Tag("py33", "none", "plat2"),
tags.Tag("py3", "none", "plat1"),
tags.Tag("py3", "none", "plat2"),
tags.Tag("py32", "none", "plat1"),
tags.Tag("py32", "none", "plat2"),
tags.Tag("py31", "none", "plat1"),
tags.Tag("py31", "none", "plat2"),
tags.Tag("py30", "none", "plat1"),
tags.Tag("py30", "none", "plat2"),
tags.Tag("cp33", "none", "any"),
tags.Tag("py33", "none", "any"),
tags.Tag("py3", "none", "any"),
tags.Tag("py32", "none", "any"),
tags.Tag("py31", "none", "any"),
tags.Tag("py30", "none", "any"),
]
def test_all_args_needs_underscore(self):
result = list(tags.compatible_tags((3, 11), "cp311", ["plat1", "plat2"]))
assert result == [
tags.Tag("py311", "none", "plat1"),
tags.Tag("py311", "none", "plat2"),
tags.Tag("py3", "none", "plat1"),
tags.Tag("py3", "none", "plat2"),
tags.Tag("py310", "none", "plat1"),
tags.Tag("py310", "none", "plat2"),
tags.Tag("py39", "none", "plat1"),
tags.Tag("py39", "none", "plat2"),
tags.Tag("py38", "none", "plat1"),
tags.Tag("py38", "none", "plat2"),
tags.Tag("py37", "none", "plat1"),
tags.Tag("py37", "none", "plat2"),
tags.Tag("py36", "none", "plat1"),
tags.Tag("py36", "none", "plat2"),
tags.Tag("py35", "none", "plat1"),
tags.Tag("py35", "none", "plat2"),
tags.Tag("py34", "none", "plat1"),
tags.Tag("py34", "none", "plat2"),
tags.Tag("py33", "none", "plat1"),
tags.Tag("py33", "none", "plat2"),
tags.Tag("py32", "none", "plat1"),
tags.Tag("py32", "none", "plat2"),
tags.Tag("py31", "none", "plat1"),
tags.Tag("py31", "none", "plat2"),
tags.Tag("py30", "none", "plat1"),
tags.Tag("py30", "none", "plat2"),
tags.Tag("cp311", "none", "any"),
tags.Tag("py311", "none", "any"),
tags.Tag("py3", "none", "any"),
tags.Tag("py310", "none", "any"),
tags.Tag("py39", "none", "any"),
tags.Tag("py38", "none", "any"),
tags.Tag("py37", "none", "any"),
tags.Tag("py36", "none", "any"),
tags.Tag("py35", "none", "any"),
tags.Tag("py34", "none", "any"),
tags.Tag("py33", "none", "any"),
tags.Tag("py32", "none", "any"),
tags.Tag("py31", "none", "any"),
tags.Tag("py30", "none", "any"),
]
def test_major_only_python_version(self):
result = list(tags.compatible_tags((3,), "cp33", ["plat"]))
assert result == [
tags.Tag("py3", "none", "plat"),
tags.Tag("cp33", "none", "any"),
tags.Tag("py3", "none", "any"),
]
def test_default_python_version(self, monkeypatch):
monkeypatch.setattr(sys, "version_info", (3, 1))
result = list(tags.compatible_tags(interpreter="cp31", platforms=["plat"]))
assert result == [
tags.Tag("py31", "none", "plat"),
tags.Tag("py3", "none", "plat"),
tags.Tag("py30", "none", "plat"),
tags.Tag("cp31", "none", "any"),
tags.Tag("py31", "none", "any"),
tags.Tag("py3", "none", "any"),
tags.Tag("py30", "none", "any"),
]
def test_default_python_version_needs_underscore(self, monkeypatch):
monkeypatch.setattr(sys, "version_info", (3, 11))
result = list(tags.compatible_tags(interpreter="cp311", platforms=["plat"]))
assert result == [
tags.Tag("py311", "none", "plat"),
tags.Tag("py3", "none", "plat"),
tags.Tag("py310", "none", "plat"),
tags.Tag("py39", "none", "plat"),
tags.Tag("py38", "none", "plat"),
tags.Tag("py37", "none", "plat"),
tags.Tag("py36", "none", "plat"),
tags.Tag("py35", "none", "plat"),
tags.Tag("py34", "none", "plat"),
tags.Tag("py33", "none", "plat"),
tags.Tag("py32", "none", "plat"),
tags.Tag("py31", "none", "plat"),
tags.Tag("py30", "none", "plat"),
tags.Tag("cp311", "none", "any"),
tags.Tag("py311", "none", "any"),
tags.Tag("py3", "none", "any"),
tags.Tag("py310", "none", "any"),
tags.Tag("py39", "none", "any"),
tags.Tag("py38", "none", "any"),
tags.Tag("py37", "none", "any"),
tags.Tag("py36", "none", "any"),
tags.Tag("py35", "none", "any"),
tags.Tag("py34", "none", "any"),
tags.Tag("py33", "none", "any"),
tags.Tag("py32", "none", "any"),
tags.Tag("py31", "none", "any"),
tags.Tag("py30", "none", "any"),
]
def test_default_interpreter(self):
result = list(tags.compatible_tags((3, 1), platforms=["plat"]))
assert result == [
tags.Tag("py31", "none", "plat"),
tags.Tag("py3", "none", "plat"),
tags.Tag("py30", "none", "plat"),
tags.Tag("py31", "none", "any"),
tags.Tag("py3", "none", "any"),
tags.Tag("py30", "none", "any"),
]
def test_default_platforms(self, monkeypatch):
monkeypatch.setattr(tags, "platform_tags", lambda: iter(["plat", "plat2"]))
result = list(tags.compatible_tags((3, 1), "cp31"))
assert result == [
tags.Tag("py31", "none", "plat"),
tags.Tag("py31", "none", "plat2"),
tags.Tag("py3", "none", "plat"),
tags.Tag("py3", "none", "plat2"),
tags.Tag("py30", "none", "plat"),
tags.Tag("py30", "none", "plat2"),
tags.Tag("cp31", "none", "any"),
tags.Tag("py31", "none", "any"),
tags.Tag("py3", "none", "any"),
tags.Tag("py30", "none", "any"),
]
class TestSysTags:
def teardown_method(self):
# Clear the version cache
tags._glibc_version = []
@pytest.mark.parametrize(
"name,expected",
[("CPython", "cp"), ("PyPy", "pp"), ("Jython", "jy"), ("IronPython", "ip")],
)
def test_interpreter_name(self, name, expected, mock_interpreter_name):
mock_interpreter_name(name)
assert tags.interpreter_name() == expected
def test_iterator(self):
assert isinstance(tags.sys_tags(), collections.abc.Iterator)
def test_mac_cpython(self, mock_interpreter_name, monkeypatch):
if mock_interpreter_name("CPython"):
monkeypatch.setattr(tags, "_cpython_abis", lambda *a: ["cp33m"])
if platform.system() != "Darwin":
monkeypatch.setattr(platform, "system", lambda: "Darwin")
monkeypatch.setattr(tags, "mac_platforms", lambda: ["macosx_10_5_x86_64"])
abis = tags._cpython_abis(sys.version_info[:2])
platforms = list(tags.mac_platforms())
result = list(tags.sys_tags())
assert len(abis) == 1
assert result[0] == tags.Tag(
"cp" + tags._version_nodot(sys.version_info[:2]), abis[0], platforms[0]
)
assert result[-1] == tags.Tag(
"py" + tags._version_nodot((sys.version_info[0], 0)), "none", "any"
)
def test_windows_cpython(self, mock_interpreter_name, monkeypatch):
if mock_interpreter_name("CPython"):
monkeypatch.setattr(tags, "_cpython_abis", lambda *a: ["cp33m"])
if platform.system() != "Windows":
monkeypatch.setattr(platform, "system", lambda: "Windows")
monkeypatch.setattr(tags, "_generic_platforms", lambda: ["win_amd64"])
abis = list(tags._cpython_abis(sys.version_info[:2]))
platforms = list(tags._generic_platforms())
result = list(tags.sys_tags())
interpreter = "cp" + tags._version_nodot(sys.version_info[:2])
assert len(abis) == 1
expected = tags.Tag(interpreter, abis[0], platforms[0])
assert result[0] == expected
expected = tags.Tag(
"py" + tags._version_nodot((sys.version_info[0], 0)), "none", "any"
)
assert result[-1] == expected
def test_linux_cpython(self, mock_interpreter_name, monkeypatch):
if mock_interpreter_name("CPython"):
monkeypatch.setattr(tags, "_cpython_abis", lambda *a: ["cp33m"])
if platform.system() != "Linux":
monkeypatch.setattr(platform, "system", lambda: "Linux")
monkeypatch.setattr(tags, "_linux_platforms", lambda: ["linux_x86_64"])
abis = list(tags._cpython_abis(sys.version_info[:2]))
platforms = list(tags._linux_platforms())
result = list(tags.sys_tags())
expected_interpreter = "cp" + tags._version_nodot(sys.version_info[:2])
assert len(abis) == 1
assert result[0] == tags.Tag(expected_interpreter, abis[0], platforms[0])
expected = tags.Tag(
"py" + tags._version_nodot((sys.version_info[0], 0)), "none", "any"
)
assert result[-1] == expected
def test_generic(self, monkeypatch):
monkeypatch.setattr(platform, "system", lambda: "Generic")
monkeypatch.setattr(tags, "interpreter_name", lambda: "generic")
result = list(tags.sys_tags())
expected = tags.Tag(
"py" + tags._version_nodot((sys.version_info[0], 0)), "none", "any"
)
assert result[-1] == expected
def test_linux_platforms_manylinux2014_armv6l(self, monkeypatch, manylinux_module):
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(sysconfig, "get_platform", lambda: "linux_ppc64")
monkeypatch.setattr(tags._manylinux, "_get_glibc_version", lambda: (2, 20))
monkeypatch.setattr(
manylinux_module, "manylinux2014_compatible", False, raising=False
)
expected = [
"manylinux_2_20_ppc64",
"manylinux_2_19_ppc64",
"manylinux_2_18_ppc64",
# "manylinux2014_ppc64", # this one is skipped
# "manylinux_2_17_ppc64", # this one is also skipped
"linux_ppc64",
]
platforms = list(tags._linux_platforms())
assert platforms == expected
@pytest.mark.parametrize(
"machine, abi, alt_machine",
[("x86_64", "x32", "i686"), ("armv7l", "armel", "armv7l")],
)
def test_linux_platforms_not_manylinux_abi(
self, monkeypatch, manylinux_module, machine, abi, alt_machine
):
monkeypatch.setattr(sysconfig, "get_platform", lambda: f"linux_{machine}")
monkeypatch.setattr(
sys,
"executable",
os.path.join(
os.path.dirname(__file__),
"manylinux",
f"hello-world-{machine}-{abi}",
),
)
platforms = list(tags._linux_platforms(is_32bit=True))
expected = [f"linux_{alt_machine}"]
assert platforms == expected
@pytest.mark.parametrize(
"machine, major, minor, tf", [("x86_64", 2, 20, False), ("s390x", 2, 22, True)]
)
def test_linux_use_manylinux_compatible(
self, monkeypatch, manylinux_module, machine, major, minor, tf
):
def manylinux_compatible(tag_major, tag_minor, tag_arch):
if tag_major == 2 and tag_minor == 22:
return tag_arch == "s390x"
return False
monkeypatch.setattr(
tags._manylinux,
"_get_glibc_version",
lambda: (major, minor),
)
monkeypatch.setattr(sysconfig, "get_platform", lambda: f"linux_{machine}")
monkeypatch.setattr(
manylinux_module,
"manylinux_compatible",
manylinux_compatible,
raising=False,
)
platforms = list(tags._linux_platforms(is_32bit=False))
if tf:
expected = [f"manylinux_2_22_{machine}"]
else:
expected = []
expected.append(f"linux_{machine}")
assert platforms == expected
def test_linux_use_manylinux_compatible_none(self, monkeypatch, manylinux_module):
def manylinux_compatible(tag_major, tag_minor, tag_arch):
if tag_major == 2 and tag_minor < 25:
return False
return None
monkeypatch.setattr(tags._manylinux, "_get_glibc_version", lambda: (2, 30))
monkeypatch.setattr(sysconfig, "get_platform", lambda: "linux_x86_64")
monkeypatch.setattr(
manylinux_module,
"manylinux_compatible",
manylinux_compatible,
raising=False,
)
platforms = list(tags._linux_platforms(is_32bit=False))
expected = [
"manylinux_2_30_x86_64",
"manylinux_2_29_x86_64",
"manylinux_2_28_x86_64",
"manylinux_2_27_x86_64",
"manylinux_2_26_x86_64",
"manylinux_2_25_x86_64",
"linux_x86_64",
]
assert platforms == expected
def test_pypy_first_none_any_tag(self, monkeypatch):
# When building the complete list of pypy tags, make sure the first
# -none-any one is pp3-none-any
monkeypatch.setattr(tags, "interpreter_name", lambda: "pp")
for tag in tags.sys_tags():
if tag.abi == "none" and tag.platform == "any":
break
assert tag == tags.Tag("pp3", "none", "any")
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1624128339.0
packaging-21.3/tests/test_utils.py 0000644 0000765 0000024 00000006733 00000000000 017510 0 ustar 00brettcannon staff # 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 pytest
from packaging.tags import Tag
from packaging.utils import (
InvalidSdistFilename,
InvalidWheelFilename,
canonicalize_name,
canonicalize_version,
parse_sdist_filename,
parse_wheel_filename,
)
from packaging.version import Version
@pytest.mark.parametrize(
("name", "expected"),
[
("foo", "foo"),
("Foo", "foo"),
("fOo", "foo"),
("foo.bar", "foo-bar"),
("Foo.Bar", "foo-bar"),
("Foo.....Bar", "foo-bar"),
("foo_bar", "foo-bar"),
("foo___bar", "foo-bar"),
("foo-bar", "foo-bar"),
("foo----bar", "foo-bar"),
],
)
def test_canonicalize_name(name, expected):
assert canonicalize_name(name) == expected
@pytest.mark.parametrize(
("version", "expected"),
[
(Version("1.4.0"), "1.4"),
("1.4.0", "1.4"),
("1.40.0", "1.40"),
("1.4.0.0.00.000.0000", "1.4"),
("1.0", "1"),
("1.0+abc", "1+abc"),
("1.0.dev0", "1.dev0"),
("1.0.post0", "1.post0"),
("1.0a0", "1a0"),
("1.0rc0", "1rc0"),
("100!0.0", "100!0"),
("1.0.1-test7", "1.0.1-test7"), # LegacyVersion is unchanged
],
)
def test_canonicalize_version(version, expected):
assert canonicalize_version(version) == expected
@pytest.mark.parametrize(
("filename", "name", "version", "build", "tags"),
[
(
"foo-1.0-py3-none-any.whl",
"foo",
Version("1.0"),
(),
{Tag("py3", "none", "any")},
),
(
"some_PACKAGE-1.0-py3-none-any.whl",
"some-package",
Version("1.0"),
(),
{Tag("py3", "none", "any")},
),
(
"foo-1.0-1000-py3-none-any.whl",
"foo",
Version("1.0"),
(1000, ""),
{Tag("py3", "none", "any")},
),
(
"foo-1.0-1000abc-py3-none-any.whl",
"foo",
Version("1.0"),
(1000, "abc"),
{Tag("py3", "none", "any")},
),
],
)
def test_parse_wheel_filename(filename, name, version, build, tags):
assert parse_wheel_filename(filename) == (name, version, build, tags)
@pytest.mark.parametrize(
("filename"),
[
("foo-1.0.whl"), # Missing tags
("foo-1.0-py3-none-any.wheel"), # Incorrect file extension (`.wheel`)
("foo__bar-1.0-py3-none-any.whl"), # Invalid name (`__`)
("foo#bar-1.0-py3-none-any.whl"), # Invalid name (`#`)
# Build number doesn't start with a digit (`abc`)
("foo-1.0-abc-py3-none-any.whl"),
("foo-1.0-200-py3-none-any-junk.whl"), # Too many dashes (`-junk`)
],
)
def test_parse_wheel_invalid_filename(filename):
with pytest.raises(InvalidWheelFilename):
parse_wheel_filename(filename)
@pytest.mark.parametrize(
("filename", "name", "version"),
[("foo-1.0.tar.gz", "foo", Version("1.0")), ("foo-1.0.zip", "foo", Version("1.0"))],
)
def test_parse_sdist_filename(filename, name, version):
assert parse_sdist_filename(filename) == (name, version)
@pytest.mark.parametrize(("filename"), [("foo-1.0.xz"), ("foo1.0.tar.gz")])
def test_parse_sdist_invalid_filename(filename):
with pytest.raises(InvalidSdistFilename):
parse_sdist_filename(filename)
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1637079931.0
packaging-21.3/tests/test_version.py 0000644 0000765 0000024 00000076004 00000000000 020033 0 ustar 00brettcannon staff # 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 itertools
import operator
import warnings
import pretend
import pytest
from packaging.version import InvalidVersion, LegacyVersion, Version, parse
@pytest.mark.parametrize(
("version", "klass"), [("1.0", Version), ("1-1-1", LegacyVersion)]
)
def test_parse(version, klass):
assert isinstance(parse(version), klass)
# This list must be in the correct sorting order
VERSIONS = [
# Implicit epoch of 0
"1.0.dev456",
"1.0a1",
"1.0a2.dev456",
"1.0a12.dev456",
"1.0a12",
"1.0b1.dev456",
"1.0b2",
"1.0b2.post345.dev456",
"1.0b2.post345",
"1.0b2-346",
"1.0c1.dev456",
"1.0c1",
"1.0rc2",
"1.0c3",
"1.0",
"1.0.post456.dev34",
"1.0.post456",
"1.1.dev1",
"1.2+123abc",
"1.2+123abc456",
"1.2+abc",
"1.2+abc123",
"1.2+abc123def",
"1.2+1234.abc",
"1.2+123456",
"1.2.r32+123456",
"1.2.rev33+123456",
# Explicit epoch of 1
"1!1.0.dev456",
"1!1.0a1",
"1!1.0a2.dev456",
"1!1.0a12.dev456",
"1!1.0a12",
"1!1.0b1.dev456",
"1!1.0b2",
"1!1.0b2.post345.dev456",
"1!1.0b2.post345",
"1!1.0b2-346",
"1!1.0c1.dev456",
"1!1.0c1",
"1!1.0rc2",
"1!1.0c3",
"1!1.0",
"1!1.0.post456.dev34",
"1!1.0.post456",
"1!1.1.dev1",
"1!1.2+123abc",
"1!1.2+123abc456",
"1!1.2+abc",
"1!1.2+abc123",
"1!1.2+abc123def",
"1!1.2+1234.abc",
"1!1.2+123456",
"1!1.2.r32+123456",
"1!1.2.rev33+123456",
]
class TestVersion:
@pytest.mark.parametrize("version", VERSIONS)
def test_valid_versions(self, version):
Version(version)
@pytest.mark.parametrize(
"version",
[
# Non sensical versions should be invalid
"french toast",
# Versions with invalid local versions
"1.0+a+",
"1.0++",
"1.0+_foobar",
"1.0+foo&asd",
"1.0+1+1",
],
)
def test_invalid_versions(self, version):
with pytest.raises(InvalidVersion):
Version(version)
@pytest.mark.parametrize(
("version", "normalized"),
[
# Various development release incarnations
("1.0dev", "1.0.dev0"),
("1.0.dev", "1.0.dev0"),
("1.0dev1", "1.0.dev1"),
("1.0dev", "1.0.dev0"),
("1.0-dev", "1.0.dev0"),
("1.0-dev1", "1.0.dev1"),
("1.0DEV", "1.0.dev0"),
("1.0.DEV", "1.0.dev0"),
("1.0DEV1", "1.0.dev1"),
("1.0DEV", "1.0.dev0"),
("1.0.DEV1", "1.0.dev1"),
("1.0-DEV", "1.0.dev0"),
("1.0-DEV1", "1.0.dev1"),
# Various alpha incarnations
("1.0a", "1.0a0"),
("1.0.a", "1.0a0"),
("1.0.a1", "1.0a1"),
("1.0-a", "1.0a0"),
("1.0-a1", "1.0a1"),
("1.0alpha", "1.0a0"),
("1.0.alpha", "1.0a0"),
("1.0.alpha1", "1.0a1"),
("1.0-alpha", "1.0a0"),
("1.0-alpha1", "1.0a1"),
("1.0A", "1.0a0"),
("1.0.A", "1.0a0"),
("1.0.A1", "1.0a1"),
("1.0-A", "1.0a0"),
("1.0-A1", "1.0a1"),
("1.0ALPHA", "1.0a0"),
("1.0.ALPHA", "1.0a0"),
("1.0.ALPHA1", "1.0a1"),
("1.0-ALPHA", "1.0a0"),
("1.0-ALPHA1", "1.0a1"),
# Various beta incarnations
("1.0b", "1.0b0"),
("1.0.b", "1.0b0"),
("1.0.b1", "1.0b1"),
("1.0-b", "1.0b0"),
("1.0-b1", "1.0b1"),
("1.0beta", "1.0b0"),
("1.0.beta", "1.0b0"),
("1.0.beta1", "1.0b1"),
("1.0-beta", "1.0b0"),
("1.0-beta1", "1.0b1"),
("1.0B", "1.0b0"),
("1.0.B", "1.0b0"),
("1.0.B1", "1.0b1"),
("1.0-B", "1.0b0"),
("1.0-B1", "1.0b1"),
("1.0BETA", "1.0b0"),
("1.0.BETA", "1.0b0"),
("1.0.BETA1", "1.0b1"),
("1.0-BETA", "1.0b0"),
("1.0-BETA1", "1.0b1"),
# Various release candidate incarnations
("1.0c", "1.0rc0"),
("1.0.c", "1.0rc0"),
("1.0.c1", "1.0rc1"),
("1.0-c", "1.0rc0"),
("1.0-c1", "1.0rc1"),
("1.0rc", "1.0rc0"),
("1.0.rc", "1.0rc0"),
("1.0.rc1", "1.0rc1"),
("1.0-rc", "1.0rc0"),
("1.0-rc1", "1.0rc1"),
("1.0C", "1.0rc0"),
("1.0.C", "1.0rc0"),
("1.0.C1", "1.0rc1"),
("1.0-C", "1.0rc0"),
("1.0-C1", "1.0rc1"),
("1.0RC", "1.0rc0"),
("1.0.RC", "1.0rc0"),
("1.0.RC1", "1.0rc1"),
("1.0-RC", "1.0rc0"),
("1.0-RC1", "1.0rc1"),
# Various post release incarnations
("1.0post", "1.0.post0"),
("1.0.post", "1.0.post0"),
("1.0post1", "1.0.post1"),
("1.0post", "1.0.post0"),
("1.0-post", "1.0.post0"),
("1.0-post1", "1.0.post1"),
("1.0POST", "1.0.post0"),
("1.0.POST", "1.0.post0"),
("1.0POST1", "1.0.post1"),
("1.0POST", "1.0.post0"),
("1.0r", "1.0.post0"),
("1.0rev", "1.0.post0"),
("1.0.POST1", "1.0.post1"),
("1.0.r1", "1.0.post1"),
("1.0.rev1", "1.0.post1"),
("1.0-POST", "1.0.post0"),
("1.0-POST1", "1.0.post1"),
("1.0-5", "1.0.post5"),
("1.0-r5", "1.0.post5"),
("1.0-rev5", "1.0.post5"),
# Local version case insensitivity
("1.0+AbC", "1.0+abc"),
# Integer Normalization
("1.01", "1.1"),
("1.0a05", "1.0a5"),
("1.0b07", "1.0b7"),
("1.0c056", "1.0rc56"),
("1.0rc09", "1.0rc9"),
("1.0.post000", "1.0.post0"),
("1.1.dev09000", "1.1.dev9000"),
("00!1.2", "1.2"),
("0100!0.0", "100!0.0"),
# Various other normalizations
("v1.0", "1.0"),
(" v1.0\t\n", "1.0"),
],
)
def test_normalized_versions(self, version, normalized):
assert str(Version(version)) == normalized
@pytest.mark.parametrize(
("version", "expected"),
[
("1.0.dev456", "1.0.dev456"),
("1.0a1", "1.0a1"),
("1.0a2.dev456", "1.0a2.dev456"),
("1.0a12.dev456", "1.0a12.dev456"),
("1.0a12", "1.0a12"),
("1.0b1.dev456", "1.0b1.dev456"),
("1.0b2", "1.0b2"),
("1.0b2.post345.dev456", "1.0b2.post345.dev456"),
("1.0b2.post345", "1.0b2.post345"),
("1.0rc1.dev456", "1.0rc1.dev456"),
("1.0rc1", "1.0rc1"),
("1.0", "1.0"),
("1.0.post456.dev34", "1.0.post456.dev34"),
("1.0.post456", "1.0.post456"),
("1.0.1", "1.0.1"),
("0!1.0.2", "1.0.2"),
("1.0.3+7", "1.0.3+7"),
("0!1.0.4+8.0", "1.0.4+8.0"),
("1.0.5+9.5", "1.0.5+9.5"),
("1.2+1234.abc", "1.2+1234.abc"),
("1.2+123456", "1.2+123456"),
("1.2+123abc", "1.2+123abc"),
("1.2+123abc456", "1.2+123abc456"),
("1.2+abc", "1.2+abc"),
("1.2+abc123", "1.2+abc123"),
("1.2+abc123def", "1.2+abc123def"),
("1.1.dev1", "1.1.dev1"),
("7!1.0.dev456", "7!1.0.dev456"),
("7!1.0a1", "7!1.0a1"),
("7!1.0a2.dev456", "7!1.0a2.dev456"),
("7!1.0a12.dev456", "7!1.0a12.dev456"),
("7!1.0a12", "7!1.0a12"),
("7!1.0b1.dev456", "7!1.0b1.dev456"),
("7!1.0b2", "7!1.0b2"),
("7!1.0b2.post345.dev456", "7!1.0b2.post345.dev456"),
("7!1.0b2.post345", "7!1.0b2.post345"),
("7!1.0rc1.dev456", "7!1.0rc1.dev456"),
("7!1.0rc1", "7!1.0rc1"),
("7!1.0", "7!1.0"),
("7!1.0.post456.dev34", "7!1.0.post456.dev34"),
("7!1.0.post456", "7!1.0.post456"),
("7!1.0.1", "7!1.0.1"),
("7!1.0.2", "7!1.0.2"),
("7!1.0.3+7", "7!1.0.3+7"),
("7!1.0.4+8.0", "7!1.0.4+8.0"),
("7!1.0.5+9.5", "7!1.0.5+9.5"),
("7!1.1.dev1", "7!1.1.dev1"),
],
)
def test_version_str_repr(self, version, expected):
assert str(Version(version)) == expected
assert repr(Version(version)) == f""
def test_version_rc_and_c_equals(self):
assert Version("1.0rc1") == Version("1.0c1")
@pytest.mark.parametrize("version", VERSIONS)
def test_version_hash(self, version):
assert hash(Version(version)) == hash(Version(version))
@pytest.mark.parametrize(
("version", "public"),
[
("1.0", "1.0"),
("1.0.dev0", "1.0.dev0"),
("1.0.dev6", "1.0.dev6"),
("1.0a1", "1.0a1"),
("1.0a1.post5", "1.0a1.post5"),
("1.0a1.post5.dev6", "1.0a1.post5.dev6"),
("1.0rc4", "1.0rc4"),
("1.0.post5", "1.0.post5"),
("1!1.0", "1!1.0"),
("1!1.0.dev6", "1!1.0.dev6"),
("1!1.0a1", "1!1.0a1"),
("1!1.0a1.post5", "1!1.0a1.post5"),
("1!1.0a1.post5.dev6", "1!1.0a1.post5.dev6"),
("1!1.0rc4", "1!1.0rc4"),
("1!1.0.post5", "1!1.0.post5"),
("1.0+deadbeef", "1.0"),
("1.0.dev6+deadbeef", "1.0.dev6"),
("1.0a1+deadbeef", "1.0a1"),
("1.0a1.post5+deadbeef", "1.0a1.post5"),
("1.0a1.post5.dev6+deadbeef", "1.0a1.post5.dev6"),
("1.0rc4+deadbeef", "1.0rc4"),
("1.0.post5+deadbeef", "1.0.post5"),
("1!1.0+deadbeef", "1!1.0"),
("1!1.0.dev6+deadbeef", "1!1.0.dev6"),
("1!1.0a1+deadbeef", "1!1.0a1"),
("1!1.0a1.post5+deadbeef", "1!1.0a1.post5"),
("1!1.0a1.post5.dev6+deadbeef", "1!1.0a1.post5.dev6"),
("1!1.0rc4+deadbeef", "1!1.0rc4"),
("1!1.0.post5+deadbeef", "1!1.0.post5"),
],
)
def test_version_public(self, version, public):
assert Version(version).public == public
@pytest.mark.parametrize(
("version", "base_version"),
[
("1.0", "1.0"),
("1.0.dev0", "1.0"),
("1.0.dev6", "1.0"),
("1.0a1", "1.0"),
("1.0a1.post5", "1.0"),
("1.0a1.post5.dev6", "1.0"),
("1.0rc4", "1.0"),
("1.0.post5", "1.0"),
("1!1.0", "1!1.0"),
("1!1.0.dev6", "1!1.0"),
("1!1.0a1", "1!1.0"),
("1!1.0a1.post5", "1!1.0"),
("1!1.0a1.post5.dev6", "1!1.0"),
("1!1.0rc4", "1!1.0"),
("1!1.0.post5", "1!1.0"),
("1.0+deadbeef", "1.0"),
("1.0.dev6+deadbeef", "1.0"),
("1.0a1+deadbeef", "1.0"),
("1.0a1.post5+deadbeef", "1.0"),
("1.0a1.post5.dev6+deadbeef", "1.0"),
("1.0rc4+deadbeef", "1.0"),
("1.0.post5+deadbeef", "1.0"),
("1!1.0+deadbeef", "1!1.0"),
("1!1.0.dev6+deadbeef", "1!1.0"),
("1!1.0a1+deadbeef", "1!1.0"),
("1!1.0a1.post5+deadbeef", "1!1.0"),
("1!1.0a1.post5.dev6+deadbeef", "1!1.0"),
("1!1.0rc4+deadbeef", "1!1.0"),
("1!1.0.post5+deadbeef", "1!1.0"),
],
)
def test_version_base_version(self, version, base_version):
assert Version(version).base_version == base_version
@pytest.mark.parametrize(
("version", "epoch"),
[
("1.0", 0),
("1.0.dev0", 0),
("1.0.dev6", 0),
("1.0a1", 0),
("1.0a1.post5", 0),
("1.0a1.post5.dev6", 0),
("1.0rc4", 0),
("1.0.post5", 0),
("1!1.0", 1),
("1!1.0.dev6", 1),
("1!1.0a1", 1),
("1!1.0a1.post5", 1),
("1!1.0a1.post5.dev6", 1),
("1!1.0rc4", 1),
("1!1.0.post5", 1),
("1.0+deadbeef", 0),
("1.0.dev6+deadbeef", 0),
("1.0a1+deadbeef", 0),
("1.0a1.post5+deadbeef", 0),
("1.0a1.post5.dev6+deadbeef", 0),
("1.0rc4+deadbeef", 0),
("1.0.post5+deadbeef", 0),
("1!1.0+deadbeef", 1),
("1!1.0.dev6+deadbeef", 1),
("1!1.0a1+deadbeef", 1),
("1!1.0a1.post5+deadbeef", 1),
("1!1.0a1.post5.dev6+deadbeef", 1),
("1!1.0rc4+deadbeef", 1),
("1!1.0.post5+deadbeef", 1),
],
)
def test_version_epoch(self, version, epoch):
assert Version(version).epoch == epoch
@pytest.mark.parametrize(
("version", "release"),
[
("1.0", (1, 0)),
("1.0.dev0", (1, 0)),
("1.0.dev6", (1, 0)),
("1.0a1", (1, 0)),
("1.0a1.post5", (1, 0)),
("1.0a1.post5.dev6", (1, 0)),
("1.0rc4", (1, 0)),
("1.0.post5", (1, 0)),
("1!1.0", (1, 0)),
("1!1.0.dev6", (1, 0)),
("1!1.0a1", (1, 0)),
("1!1.0a1.post5", (1, 0)),
("1!1.0a1.post5.dev6", (1, 0)),
("1!1.0rc4", (1, 0)),
("1!1.0.post5", (1, 0)),
("1.0+deadbeef", (1, 0)),
("1.0.dev6+deadbeef", (1, 0)),
("1.0a1+deadbeef", (1, 0)),
("1.0a1.post5+deadbeef", (1, 0)),
("1.0a1.post5.dev6+deadbeef", (1, 0)),
("1.0rc4+deadbeef", (1, 0)),
("1.0.post5+deadbeef", (1, 0)),
("1!1.0+deadbeef", (1, 0)),
("1!1.0.dev6+deadbeef", (1, 0)),
("1!1.0a1+deadbeef", (1, 0)),
("1!1.0a1.post5+deadbeef", (1, 0)),
("1!1.0a1.post5.dev6+deadbeef", (1, 0)),
("1!1.0rc4+deadbeef", (1, 0)),
("1!1.0.post5+deadbeef", (1, 0)),
],
)
def test_version_release(self, version, release):
assert Version(version).release == release
@pytest.mark.parametrize(
("version", "local"),
[
("1.0", None),
("1.0.dev0", None),
("1.0.dev6", None),
("1.0a1", None),
("1.0a1.post5", None),
("1.0a1.post5.dev6", None),
("1.0rc4", None),
("1.0.post5", None),
("1!1.0", None),
("1!1.0.dev6", None),
("1!1.0a1", None),
("1!1.0a1.post5", None),
("1!1.0a1.post5.dev6", None),
("1!1.0rc4", None),
("1!1.0.post5", None),
("1.0+deadbeef", "deadbeef"),
("1.0.dev6+deadbeef", "deadbeef"),
("1.0a1+deadbeef", "deadbeef"),
("1.0a1.post5+deadbeef", "deadbeef"),
("1.0a1.post5.dev6+deadbeef", "deadbeef"),
("1.0rc4+deadbeef", "deadbeef"),
("1.0.post5+deadbeef", "deadbeef"),
("1!1.0+deadbeef", "deadbeef"),
("1!1.0.dev6+deadbeef", "deadbeef"),
("1!1.0a1+deadbeef", "deadbeef"),
("1!1.0a1.post5+deadbeef", "deadbeef"),
("1!1.0a1.post5.dev6+deadbeef", "deadbeef"),
("1!1.0rc4+deadbeef", "deadbeef"),
("1!1.0.post5+deadbeef", "deadbeef"),
],
)
def test_version_local(self, version, local):
assert Version(version).local == local
@pytest.mark.parametrize(
("version", "pre"),
[
("1.0", None),
("1.0.dev0", None),
("1.0.dev6", None),
("1.0a1", ("a", 1)),
("1.0a1.post5", ("a", 1)),
("1.0a1.post5.dev6", ("a", 1)),
("1.0rc4", ("rc", 4)),
("1.0.post5", None),
("1!1.0", None),
("1!1.0.dev6", None),
("1!1.0a1", ("a", 1)),
("1!1.0a1.post5", ("a", 1)),
("1!1.0a1.post5.dev6", ("a", 1)),
("1!1.0rc4", ("rc", 4)),
("1!1.0.post5", None),
("1.0+deadbeef", None),
("1.0.dev6+deadbeef", None),
("1.0a1+deadbeef", ("a", 1)),
("1.0a1.post5+deadbeef", ("a", 1)),
("1.0a1.post5.dev6+deadbeef", ("a", 1)),
("1.0rc4+deadbeef", ("rc", 4)),
("1.0.post5+deadbeef", None),
("1!1.0+deadbeef", None),
("1!1.0.dev6+deadbeef", None),
("1!1.0a1+deadbeef", ("a", 1)),
("1!1.0a1.post5+deadbeef", ("a", 1)),
("1!1.0a1.post5.dev6+deadbeef", ("a", 1)),
("1!1.0rc4+deadbeef", ("rc", 4)),
("1!1.0.post5+deadbeef", None),
],
)
def test_version_pre(self, version, pre):
assert Version(version).pre == pre
@pytest.mark.parametrize(
("version", "expected"),
[
("1.0.dev0", True),
("1.0.dev1", True),
("1.0a1.dev1", True),
("1.0b1.dev1", True),
("1.0c1.dev1", True),
("1.0rc1.dev1", True),
("1.0a1", True),
("1.0b1", True),
("1.0c1", True),
("1.0rc1", True),
("1.0a1.post1.dev1", True),
("1.0b1.post1.dev1", True),
("1.0c1.post1.dev1", True),
("1.0rc1.post1.dev1", True),
("1.0a1.post1", True),
("1.0b1.post1", True),
("1.0c1.post1", True),
("1.0rc1.post1", True),
("1.0", False),
("1.0+dev", False),
("1.0.post1", False),
("1.0.post1+dev", False),
],
)
def test_version_is_prerelease(self, version, expected):
assert Version(version).is_prerelease is expected
@pytest.mark.parametrize(
("version", "dev"),
[
("1.0", None),
("1.0.dev0", 0),
("1.0.dev6", 6),
("1.0a1", None),
("1.0a1.post5", None),
("1.0a1.post5.dev6", 6),
("1.0rc4", None),
("1.0.post5", None),
("1!1.0", None),
("1!1.0.dev6", 6),
("1!1.0a1", None),
("1!1.0a1.post5", None),
("1!1.0a1.post5.dev6", 6),
("1!1.0rc4", None),
("1!1.0.post5", None),
("1.0+deadbeef", None),
("1.0.dev6+deadbeef", 6),
("1.0a1+deadbeef", None),
("1.0a1.post5+deadbeef", None),
("1.0a1.post5.dev6+deadbeef", 6),
("1.0rc4+deadbeef", None),
("1.0.post5+deadbeef", None),
("1!1.0+deadbeef", None),
("1!1.0.dev6+deadbeef", 6),
("1!1.0a1+deadbeef", None),
("1!1.0a1.post5+deadbeef", None),
("1!1.0a1.post5.dev6+deadbeef", 6),
("1!1.0rc4+deadbeef", None),
("1!1.0.post5+deadbeef", None),
],
)
def test_version_dev(self, version, dev):
assert Version(version).dev == dev
@pytest.mark.parametrize(
("version", "expected"),
[
("1.0", False),
("1.0.dev0", True),
("1.0.dev6", True),
("1.0a1", False),
("1.0a1.post5", False),
("1.0a1.post5.dev6", True),
("1.0rc4", False),
("1.0.post5", False),
("1!1.0", False),
("1!1.0.dev6", True),
("1!1.0a1", False),
("1!1.0a1.post5", False),
("1!1.0a1.post5.dev6", True),
("1!1.0rc4", False),
("1!1.0.post5", False),
("1.0+deadbeef", False),
("1.0.dev6+deadbeef", True),
("1.0a1+deadbeef", False),
("1.0a1.post5+deadbeef", False),
("1.0a1.post5.dev6+deadbeef", True),
("1.0rc4+deadbeef", False),
("1.0.post5+deadbeef", False),
("1!1.0+deadbeef", False),
("1!1.0.dev6+deadbeef", True),
("1!1.0a1+deadbeef", False),
("1!1.0a1.post5+deadbeef", False),
("1!1.0a1.post5.dev6+deadbeef", True),
("1!1.0rc4+deadbeef", False),
("1!1.0.post5+deadbeef", False),
],
)
def test_version_is_devrelease(self, version, expected):
assert Version(version).is_devrelease is expected
@pytest.mark.parametrize(
("version", "post"),
[
("1.0", None),
("1.0.dev0", None),
("1.0.dev6", None),
("1.0a1", None),
("1.0a1.post5", 5),
("1.0a1.post5.dev6", 5),
("1.0rc4", None),
("1.0.post5", 5),
("1!1.0", None),
("1!1.0.dev6", None),
("1!1.0a1", None),
("1!1.0a1.post5", 5),
("1!1.0a1.post5.dev6", 5),
("1!1.0rc4", None),
("1!1.0.post5", 5),
("1.0+deadbeef", None),
("1.0.dev6+deadbeef", None),
("1.0a1+deadbeef", None),
("1.0a1.post5+deadbeef", 5),
("1.0a1.post5.dev6+deadbeef", 5),
("1.0rc4+deadbeef", None),
("1.0.post5+deadbeef", 5),
("1!1.0+deadbeef", None),
("1!1.0.dev6+deadbeef", None),
("1!1.0a1+deadbeef", None),
("1!1.0a1.post5+deadbeef", 5),
("1!1.0a1.post5.dev6+deadbeef", 5),
("1!1.0rc4+deadbeef", None),
("1!1.0.post5+deadbeef", 5),
],
)
def test_version_post(self, version, post):
assert Version(version).post == post
@pytest.mark.parametrize(
("version", "expected"),
[
("1.0.dev1", False),
("1.0", False),
("1.0+foo", False),
("1.0.post1.dev1", True),
("1.0.post1", True),
],
)
def test_version_is_postrelease(self, version, expected):
assert Version(version).is_postrelease is expected
@pytest.mark.parametrize(
("left", "right", "op"),
# Below we'll generate every possible combination of VERSIONS that
# should be True for the given operator
itertools.chain(
*
# Verify that the less than (<) operator works correctly
[
[(x, y, operator.lt) for y in VERSIONS[i + 1 :]]
for i, x in enumerate(VERSIONS)
]
+
# Verify that the less than equal (<=) operator works correctly
[
[(x, y, operator.le) for y in VERSIONS[i:]]
for i, x in enumerate(VERSIONS)
]
+
# Verify that the equal (==) operator works correctly
[[(x, x, operator.eq) for x in VERSIONS]]
+
# Verify that the not equal (!=) operator works correctly
[
[(x, y, operator.ne) for j, y in enumerate(VERSIONS) if i != j]
for i, x in enumerate(VERSIONS)
]
+
# Verify that the greater than equal (>=) operator works correctly
[
[(x, y, operator.ge) for y in VERSIONS[: i + 1]]
for i, x in enumerate(VERSIONS)
]
+
# Verify that the greater than (>) operator works correctly
[
[(x, y, operator.gt) for y in VERSIONS[:i]]
for i, x in enumerate(VERSIONS)
]
),
)
def test_comparison_true(self, left, right, op):
assert op(Version(left), Version(right))
@pytest.mark.parametrize(
("left", "right", "op"),
# Below we'll generate every possible combination of VERSIONS that
# should be False for the given operator
itertools.chain(
*
# Verify that the less than (<) operator works correctly
[
[(x, y, operator.lt) for y in VERSIONS[: i + 1]]
for i, x in enumerate(VERSIONS)
]
+
# Verify that the less than equal (<=) operator works correctly
[
[(x, y, operator.le) for y in VERSIONS[:i]]
for i, x in enumerate(VERSIONS)
]
+
# Verify that the equal (==) operator works correctly
[
[(x, y, operator.eq) for j, y in enumerate(VERSIONS) if i != j]
for i, x in enumerate(VERSIONS)
]
+
# Verify that the not equal (!=) operator works correctly
[[(x, x, operator.ne) for x in VERSIONS]]
+
# Verify that the greater than equal (>=) operator works correctly
[
[(x, y, operator.ge) for y in VERSIONS[i + 1 :]]
for i, x in enumerate(VERSIONS)
]
+
# Verify that the greater than (>) operator works correctly
[
[(x, y, operator.gt) for y in VERSIONS[i:]]
for i, x in enumerate(VERSIONS)
]
),
)
def test_comparison_false(self, left, right, op):
assert not op(Version(left), Version(right))
@pytest.mark.parametrize("op", ["lt", "le", "eq", "ge", "gt", "ne"])
def test_dunder_op_returns_notimplemented(self, op):
method = getattr(Version, f"__{op}__")
assert method(Version("1"), 1) is NotImplemented
@pytest.mark.parametrize(("op", "expected"), [("eq", False), ("ne", True)])
def test_compare_other(self, op, expected):
other = pretend.stub(**{f"__{op}__": lambda other: NotImplemented})
assert getattr(operator, op)(Version("1"), other) is expected
def test_compare_legacyversion_version(self):
result = sorted([Version("0"), LegacyVersion("1")])
assert result == [LegacyVersion("1"), Version("0")]
def test_major_version(self):
assert Version("2.1.0").major == 2
def test_minor_version(self):
assert Version("2.1.0").minor == 1
assert Version("2").minor == 0
def test_micro_version(self):
assert Version("2.1.3").micro == 3
assert Version("2.1").micro == 0
assert Version("2").micro == 0
LEGACY_VERSIONS = ["foobar", "a cat is fine too", "lolwut", "1-0", "2.0-a1"]
class TestLegacyVersion:
def test_legacy_version_is_deprecated(self):
with warnings.catch_warnings(record=True) as w:
LegacyVersion("some-legacy-version")
assert len(w) == 1
assert issubclass(w[0].category, DeprecationWarning)
@pytest.mark.parametrize("version", VERSIONS + LEGACY_VERSIONS)
def test_valid_legacy_versions(self, version):
LegacyVersion(version)
@pytest.mark.parametrize("version", VERSIONS + LEGACY_VERSIONS)
def test_legacy_version_str_repr(self, version):
assert str(LegacyVersion(version)) == version
assert repr(LegacyVersion(version)) == "".format(
repr(version)
)
@pytest.mark.parametrize("version", VERSIONS + LEGACY_VERSIONS)
def test_legacy_version_hash(self, version):
assert hash(LegacyVersion(version)) == hash(LegacyVersion(version))
@pytest.mark.parametrize("version", VERSIONS + LEGACY_VERSIONS)
def test_legacy_version_public(self, version):
assert LegacyVersion(version).public == version
@pytest.mark.parametrize("version", VERSIONS + LEGACY_VERSIONS)
def test_legacy_version_base_version(self, version):
assert LegacyVersion(version).base_version == version
@pytest.mark.parametrize("version", VERSIONS + LEGACY_VERSIONS)
def test_legacy_version_epoch(self, version):
assert LegacyVersion(version).epoch == -1
@pytest.mark.parametrize("version", VERSIONS + LEGACY_VERSIONS)
def test_legacy_version_release(self, version):
assert LegacyVersion(version).release is None
@pytest.mark.parametrize("version", VERSIONS + LEGACY_VERSIONS)
def test_legacy_version_local(self, version):
assert LegacyVersion(version).local is None
@pytest.mark.parametrize("version", VERSIONS + LEGACY_VERSIONS)
def test_legacy_version_pre(self, version):
assert LegacyVersion(version).pre is None
@pytest.mark.parametrize("version", VERSIONS + LEGACY_VERSIONS)
def test_legacy_version_is_prerelease(self, version):
assert not LegacyVersion(version).is_prerelease
@pytest.mark.parametrize("version", VERSIONS + LEGACY_VERSIONS)
def test_legacy_version_dev(self, version):
assert LegacyVersion(version).dev is None
@pytest.mark.parametrize("version", VERSIONS + LEGACY_VERSIONS)
def test_legacy_version_is_devrelease(self, version):
assert not LegacyVersion(version).is_devrelease
@pytest.mark.parametrize("version", VERSIONS + LEGACY_VERSIONS)
def test_legacy_version_post(self, version):
assert LegacyVersion(version).post is None
@pytest.mark.parametrize("version", VERSIONS + LEGACY_VERSIONS)
def test_legacy_version_is_postrelease(self, version):
assert not LegacyVersion(version).is_postrelease
@pytest.mark.parametrize(
("left", "right", "op"),
# Below we'll generate every possible combination of
# VERSIONS + LEGACY_VERSIONS that should be True for the given operator
itertools.chain(
*
# Verify that the equal (==) operator works correctly
[[(x, x, operator.eq) for x in VERSIONS + LEGACY_VERSIONS]]
+
# Verify that the not equal (!=) operator works correctly
[
[
(x, y, operator.ne)
for j, y in enumerate(VERSIONS + LEGACY_VERSIONS)
if i != j
]
for i, x in enumerate(VERSIONS + LEGACY_VERSIONS)
]
),
)
def test_comparison_true(self, left, right, op):
assert op(LegacyVersion(left), LegacyVersion(right))
@pytest.mark.parametrize(
("left", "right", "op"),
# Below we'll generate every possible combination of
# VERSIONS + LEGACY_VERSIONS that should be False for the given
# operator
itertools.chain(
*
# Verify that the equal (==) operator works correctly
[
[
(x, y, operator.eq)
for j, y in enumerate(VERSIONS + LEGACY_VERSIONS)
if i != j
]
for i, x in enumerate(VERSIONS + LEGACY_VERSIONS)
]
+
# Verify that the not equal (!=) operator works correctly
[[(x, x, operator.ne) for x in VERSIONS + LEGACY_VERSIONS]]
),
)
def test_comparison_false(self, left, right, op):
assert not op(LegacyVersion(left), LegacyVersion(right))
@pytest.mark.parametrize("op", ["lt", "le", "eq", "ge", "gt", "ne"])
def test_dunder_op_returns_notimplemented(self, op):
method = getattr(LegacyVersion, f"__{op}__")
assert method(LegacyVersion("1"), 1) is NotImplemented
@pytest.mark.parametrize(("op", "expected"), [("eq", False), ("ne", True)])
def test_compare_other(self, op, expected):
other = pretend.stub(**{f"__{op}__": lambda other: NotImplemented})
assert getattr(operator, op)(LegacyVersion("1"), other) is expected