488 lines
15 KiB
Python
488 lines
15 KiB
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 logging
|
||
|
import platform
|
||
|
import sys
|
||
|
import sysconfig
|
||
|
from importlib.machinery import EXTENSION_SUFFIXES
|
||
|
from typing import (
|
||
|
Dict,
|
||
|
FrozenSet,
|
||
|
Iterable,
|
||
|
Iterator,
|
||
|
List,
|
||
|
Optional,
|
||
|
Sequence,
|
||
|
Tuple,
|
||
|
Union,
|
||
|
cast,
|
||
|
)
|
||
|
|
||
|
from . import _manylinux, _musllinux
|
||
|
|
||
|
logger = logging.getLogger(__name__)
|
||
|
|
||
|
PythonVersion = Sequence[int]
|
||
|
MacVersion = Tuple[int, int]
|
||
|
|
||
|
INTERPRETER_SHORT_NAMES: Dict[str, str] = {
|
||
|
"python": "py", # Generic.
|
||
|
"cpython": "cp",
|
||
|
"pypy": "pp",
|
||
|
"ironpython": "ip",
|
||
|
"jython": "jy",
|
||
|
}
|
||
|
|
||
|
|
||
|
_32_BIT_INTERPRETER = sys.maxsize <= 2 ** 32
|
||
|
|
||
|
|
||
|
class Tag:
|
||
|
"""
|
||
|
A representation of the tag triple for a wheel.
|
||
|
|
||
|
Instances are considered immutable and thus are hashable. Equality checking
|
||
|
is also supported.
|
||
|
"""
|
||
|
|
||
|
__slots__ = ["_interpreter", "_abi", "_platform", "_hash"]
|
||
|
|
||
|
def __init__(self, interpreter: str, abi: str, platform: str) -> None:
|
||
|
self._interpreter = interpreter.lower()
|
||
|
self._abi = abi.lower()
|
||
|
self._platform = platform.lower()
|
||
|
# The __hash__ of every single element in a Set[Tag] will be evaluated each time
|
||
|
# that a set calls its `.disjoint()` method, which may be called hundreds of
|
||
|
# times when scanning a page of links for packages with tags matching that
|
||
|
# Set[Tag]. Pre-computing the value here produces significant speedups for
|
||
|
# downstream consumers.
|
||
|
self._hash = hash((self._interpreter, self._abi, self._platform))
|
||
|
|
||
|
@property
|
||
|
def interpreter(self) -> str:
|
||
|
return self._interpreter
|
||
|
|
||
|
@property
|
||
|
def abi(self) -> str:
|
||
|
return self._abi
|
||
|
|
||
|
@property
|
||
|
def platform(self) -> str:
|
||
|
return self._platform
|
||
|
|
||
|
def __eq__(self, other: object) -> bool:
|
||
|
if not isinstance(other, Tag):
|
||
|
return NotImplemented
|
||
|
|
||
|
return (
|
||
|
(self._hash == other._hash) # Short-circuit ASAP for perf reasons.
|
||
|
and (self._platform == other._platform)
|
||
|
and (self._abi == other._abi)
|
||
|
and (self._interpreter == other._interpreter)
|
||
|
)
|
||
|
|
||
|
def __hash__(self) -> int:
|
||
|
return self._hash
|
||
|
|
||
|
def __str__(self) -> str:
|
||
|
return f"{self._interpreter}-{self._abi}-{self._platform}"
|
||
|
|
||
|
def __repr__(self) -> str:
|
||
|
return f"<{self} @ {id(self)}>"
|
||
|
|
||
|
|
||
|
def parse_tag(tag: str) -> FrozenSet[Tag]:
|
||
|
"""
|
||
|
Parses the provided tag (e.g. `py3-none-any`) into a frozenset of Tag instances.
|
||
|
|
||
|
Returning a set is required due to the possibility that the tag is a
|
||
|
compressed tag set.
|
||
|
"""
|
||
|
tags = set()
|
||
|
interpreters, abis, platforms = tag.split("-")
|
||
|
for interpreter in interpreters.split("."):
|
||
|
for abi in abis.split("."):
|
||
|
for platform_ in platforms.split("."):
|
||
|
tags.add(Tag(interpreter, abi, platform_))
|
||
|
return frozenset(tags)
|
||
|
|
||
|
|
||
|
def _get_config_var(name: str, warn: bool = False) -> Union[int, str, None]:
|
||
|
value = sysconfig.get_config_var(name)
|
||
|
if value is None and warn:
|
||
|
logger.debug(
|
||
|
"Config variable '%s' is unset, Python ABI tag may be incorrect", name
|
||
|
)
|
||
|
return value
|
||
|
|
||
|
|
||
|
def _normalize_string(string: str) -> str:
|
||
|
return string.replace(".", "_").replace("-", "_")
|
||
|
|
||
|
|
||
|
def _abi3_applies(python_version: PythonVersion) -> bool:
|
||
|
"""
|
||
|
Determine if the Python version supports abi3.
|
||
|
|
||
|
PEP 384 was first implemented in Python 3.2.
|
||
|
"""
|
||
|
return len(python_version) > 1 and tuple(python_version) >= (3, 2)
|
||
|
|
||
|
|
||
|
def _cpython_abis(py_version: PythonVersion, warn: bool = False) -> List[str]:
|
||
|
py_version = tuple(py_version) # To allow for version comparison.
|
||
|
abis = []
|
||
|
version = _version_nodot(py_version[:2])
|
||
|
debug = pymalloc = ucs4 = ""
|
||
|
with_debug = _get_config_var("Py_DEBUG", warn)
|
||
|
has_refcount = hasattr(sys, "gettotalrefcount")
|
||
|
# Windows doesn't set Py_DEBUG, so checking for support of debug-compiled
|
||
|
# extension modules is the best option.
|
||
|
# https://github.com/pypa/pip/issues/3383#issuecomment-173267692
|
||
|
has_ext = "_d.pyd" in EXTENSION_SUFFIXES
|
||
|
if with_debug or (with_debug is None and (has_refcount or has_ext)):
|
||
|
debug = "d"
|
||
|
if py_version < (3, 8):
|
||
|
with_pymalloc = _get_config_var("WITH_PYMALLOC", warn)
|
||
|
if with_pymalloc or with_pymalloc is None:
|
||
|
pymalloc = "m"
|
||
|
if py_version < (3, 3):
|
||
|
unicode_size = _get_config_var("Py_UNICODE_SIZE", warn)
|
||
|
if unicode_size == 4 or (
|
||
|
unicode_size is None and sys.maxunicode == 0x10FFFF
|
||
|
):
|
||
|
ucs4 = "u"
|
||
|
elif debug:
|
||
|
# Debug builds can also load "normal" extension modules.
|
||
|
# We can also assume no UCS-4 or pymalloc requirement.
|
||
|
abis.append(f"cp{version}")
|
||
|
abis.insert(
|
||
|
0,
|
||
|
"cp{version}{debug}{pymalloc}{ucs4}".format(
|
||
|
version=version, debug=debug, pymalloc=pymalloc, ucs4=ucs4
|
||
|
),
|
||
|
)
|
||
|
return abis
|
||
|
|
||
|
|
||
|
def cpython_tags(
|
||
|
python_version: Optional[PythonVersion] = None,
|
||
|
abis: Optional[Iterable[str]] = None,
|
||
|
platforms: Optional[Iterable[str]] = None,
|
||
|
*,
|
||
|
warn: bool = False,
|
||
|
) -> Iterator[Tag]:
|
||
|
"""
|
||
|
Yields the tags for a CPython interpreter.
|
||
|
|
||
|
The tags consist of:
|
||
|
- cp<python_version>-<abi>-<platform>
|
||
|
- cp<python_version>-abi3-<platform>
|
||
|
- cp<python_version>-none-<platform>
|
||
|
- cp<less than python_version>-abi3-<platform> # Older Python versions down to 3.2.
|
||
|
|
||
|
If python_version only specifies a major version then user-provided ABIs and
|
||
|
the 'none' ABItag will be used.
|
||
|
|
||
|
If 'abi3' or 'none' are specified in 'abis' then they will be yielded at
|
||
|
their normal position and not at the beginning.
|
||
|
"""
|
||
|
if not python_version:
|
||
|
python_version = sys.version_info[:2]
|
||
|
|
||
|
interpreter = f"cp{_version_nodot(python_version[:2])}"
|
||
|
|
||
|
if abis is None:
|
||
|
if len(python_version) > 1:
|
||
|
abis = _cpython_abis(python_version, warn)
|
||
|
else:
|
||
|
abis = []
|
||
|
abis = list(abis)
|
||
|
# 'abi3' and 'none' are explicitly handled later.
|
||
|
for explicit_abi in ("abi3", "none"):
|
||
|
try:
|
||
|
abis.remove(explicit_abi)
|
||
|
except ValueError:
|
||
|
pass
|
||
|
|
||
|
platforms = list(platforms or platform_tags())
|
||
|
for abi in abis:
|
||
|
for platform_ in platforms:
|
||
|
yield Tag(interpreter, abi, platform_)
|
||
|
if _abi3_applies(python_version):
|
||
|
yield from (Tag(interpreter, "abi3", platform_) for platform_ in platforms)
|
||
|
yield from (Tag(interpreter, "none", platform_) for platform_ in platforms)
|
||
|
|
||
|
if _abi3_applies(python_version):
|
||
|
for minor_version in range(python_version[1] - 1, 1, -1):
|
||
|
for platform_ in platforms:
|
||
|
interpreter = "cp{version}".format(
|
||
|
version=_version_nodot((python_version[0], minor_version))
|
||
|
)
|
||
|
yield Tag(interpreter, "abi3", platform_)
|
||
|
|
||
|
|
||
|
def _generic_abi() -> Iterator[str]:
|
||
|
abi = sysconfig.get_config_var("SOABI")
|
||
|
if abi:
|
||
|
yield _normalize_string(abi)
|
||
|
|
||
|
|
||
|
def generic_tags(
|
||
|
interpreter: Optional[str] = None,
|
||
|
abis: Optional[Iterable[str]] = None,
|
||
|
platforms: Optional[Iterable[str]] = None,
|
||
|
*,
|
||
|
warn: bool = False,
|
||
|
) -> Iterator[Tag]:
|
||
|
"""
|
||
|
Yields the tags for a generic interpreter.
|
||
|
|
||
|
The tags consist of:
|
||
|
- <interpreter>-<abi>-<platform>
|
||
|
|
||
|
The "none" ABI will be added if it was not explicitly provided.
|
||
|
"""
|
||
|
if not interpreter:
|
||
|
interp_name = interpreter_name()
|
||
|
interp_version = interpreter_version(warn=warn)
|
||
|
interpreter = "".join([interp_name, interp_version])
|
||
|
if abis is None:
|
||
|
abis = _generic_abi()
|
||
|
platforms = list(platforms or platform_tags())
|
||
|
abis = list(abis)
|
||
|
if "none" not in abis:
|
||
|
abis.append("none")
|
||
|
for abi in abis:
|
||
|
for platform_ in platforms:
|
||
|
yield Tag(interpreter, abi, platform_)
|
||
|
|
||
|
|
||
|
def _py_interpreter_range(py_version: PythonVersion) -> Iterator[str]:
|
||
|
"""
|
||
|
Yields Python versions in descending order.
|
||
|
|
||
|
After the latest version, the major-only version will be yielded, and then
|
||
|
all previous versions of that major version.
|
||
|
"""
|
||
|
if len(py_version) > 1:
|
||
|
yield f"py{_version_nodot(py_version[:2])}"
|
||
|
yield f"py{py_version[0]}"
|
||
|
if len(py_version) > 1:
|
||
|
for minor in range(py_version[1] - 1, -1, -1):
|
||
|
yield f"py{_version_nodot((py_version[0], minor))}"
|
||
|
|
||
|
|
||
|
def compatible_tags(
|
||
|
python_version: Optional[PythonVersion] = None,
|
||
|
interpreter: Optional[str] = None,
|
||
|
platforms: Optional[Iterable[str]] = None,
|
||
|
) -> Iterator[Tag]:
|
||
|
"""
|
||
|
Yields the sequence of tags that are compatible with a specific version of Python.
|
||
|
|
||
|
The tags consist of:
|
||
|
- py*-none-<platform>
|
||
|
- <interpreter>-none-any # ... if `interpreter` is provided.
|
||
|
- py*-none-any
|
||
|
"""
|
||
|
if not python_version:
|
||
|
python_version = sys.version_info[:2]
|
||
|
platforms = list(platforms or platform_tags())
|
||
|
for version in _py_interpreter_range(python_version):
|
||
|
for platform_ in platforms:
|
||
|
yield Tag(version, "none", platform_)
|
||
|
if interpreter:
|
||
|
yield Tag(interpreter, "none", "any")
|
||
|
for version in _py_interpreter_range(python_version):
|
||
|
yield Tag(version, "none", "any")
|
||
|
|
||
|
|
||
|
def _mac_arch(arch: str, is_32bit: bool = _32_BIT_INTERPRETER) -> str:
|
||
|
if not is_32bit:
|
||
|
return arch
|
||
|
|
||
|
if arch.startswith("ppc"):
|
||
|
return "ppc"
|
||
|
|
||
|
return "i386"
|
||
|
|
||
|
|
||
|
def _mac_binary_formats(version: MacVersion, cpu_arch: str) -> List[str]:
|
||
|
formats = [cpu_arch]
|
||
|
if cpu_arch == "x86_64":
|
||
|
if version < (10, 4):
|
||
|
return []
|
||
|
formats.extend(["intel", "fat64", "fat32"])
|
||
|
|
||
|
elif cpu_arch == "i386":
|
||
|
if version < (10, 4):
|
||
|
return []
|
||
|
formats.extend(["intel", "fat32", "fat"])
|
||
|
|
||
|
elif cpu_arch == "ppc64":
|
||
|
# TODO: Need to care about 32-bit PPC for ppc64 through 10.2?
|
||
|
if version > (10, 5) or version < (10, 4):
|
||
|
return []
|
||
|
formats.append("fat64")
|
||
|
|
||
|
elif cpu_arch == "ppc":
|
||
|
if version > (10, 6):
|
||
|
return []
|
||
|
formats.extend(["fat32", "fat"])
|
||
|
|
||
|
if cpu_arch in {"arm64", "x86_64"}:
|
||
|
formats.append("universal2")
|
||
|
|
||
|
if cpu_arch in {"x86_64", "i386", "ppc64", "ppc", "intel"}:
|
||
|
formats.append("universal")
|
||
|
|
||
|
return formats
|
||
|
|
||
|
|
||
|
def mac_platforms(
|
||
|
version: Optional[MacVersion] = None, arch: Optional[str] = None
|
||
|
) -> Iterator[str]:
|
||
|
"""
|
||
|
Yields the platform tags for a macOS system.
|
||
|
|
||
|
The `version` parameter is a two-item tuple specifying the macOS version to
|
||
|
generate platform tags for. The `arch` parameter is the CPU architecture to
|
||
|
generate platform tags for. Both parameters default to the appropriate value
|
||
|
for the current system.
|
||
|
"""
|
||
|
version_str, _, cpu_arch = platform.mac_ver()
|
||
|
if version is None:
|
||
|
version = cast("MacVersion", tuple(map(int, version_str.split(".")[:2])))
|
||
|
else:
|
||
|
version = version
|
||
|
if arch is None:
|
||
|
arch = _mac_arch(cpu_arch)
|
||
|
else:
|
||
|
arch = arch
|
||
|
|
||
|
if (10, 0) <= version and version < (11, 0):
|
||
|
# Prior to Mac OS 11, each yearly release of Mac OS bumped the
|
||
|
# "minor" version number. The major version was always 10.
|
||
|
for minor_version in range(version[1], -1, -1):
|
||
|
compat_version = 10, minor_version
|
||
|
binary_formats = _mac_binary_formats(compat_version, arch)
|
||
|
for binary_format in binary_formats:
|
||
|
yield "macosx_{major}_{minor}_{binary_format}".format(
|
||
|
major=10, minor=minor_version, binary_format=binary_format
|
||
|
)
|
||
|
|
||
|
if version >= (11, 0):
|
||
|
# Starting with Mac OS 11, each yearly release bumps the major version
|
||
|
# number. The minor versions are now the midyear updates.
|
||
|
for major_version in range(version[0], 10, -1):
|
||
|
compat_version = major_version, 0
|
||
|
binary_formats = _mac_binary_formats(compat_version, arch)
|
||
|
for binary_format in binary_formats:
|
||
|
yield "macosx_{major}_{minor}_{binary_format}".format(
|
||
|
major=major_version, minor=0, binary_format=binary_format
|
||
|
)
|
||
|
|
||
|
if version >= (11, 0):
|
||
|
# Mac OS 11 on x86_64 is compatible with binaries from previous releases.
|
||
|
# Arm64 support was introduced in 11.0, so no Arm binaries from previous
|
||
|
# releases exist.
|
||
|
#
|
||
|
# However, the "universal2" binary format can have a
|
||
|
# macOS version earlier than 11.0 when the x86_64 part of the binary supports
|
||
|
# that version of macOS.
|
||
|
if arch == "x86_64":
|
||
|
for minor_version in range(16, 3, -1):
|
||
|
compat_version = 10, minor_version
|
||
|
binary_formats = _mac_binary_formats(compat_version, arch)
|
||
|
for binary_format in binary_formats:
|
||
|
yield "macosx_{major}_{minor}_{binary_format}".format(
|
||
|
major=compat_version[0],
|
||
|
minor=compat_version[1],
|
||
|
binary_format=binary_format,
|
||
|
)
|
||
|
else:
|
||
|
for minor_version in range(16, 3, -1):
|
||
|
compat_version = 10, minor_version
|
||
|
binary_format = "universal2"
|
||
|
yield "macosx_{major}_{minor}_{binary_format}".format(
|
||
|
major=compat_version[0],
|
||
|
minor=compat_version[1],
|
||
|
binary_format=binary_format,
|
||
|
)
|
||
|
|
||
|
|
||
|
def _linux_platforms(is_32bit: bool = _32_BIT_INTERPRETER) -> Iterator[str]:
|
||
|
linux = _normalize_string(sysconfig.get_platform())
|
||
|
if is_32bit:
|
||
|
if linux == "linux_x86_64":
|
||
|
linux = "linux_i686"
|
||
|
elif linux == "linux_aarch64":
|
||
|
linux = "linux_armv7l"
|
||
|
_, arch = linux.split("_", 1)
|
||
|
yield from _manylinux.platform_tags(linux, arch)
|
||
|
yield from _musllinux.platform_tags(arch)
|
||
|
yield linux
|
||
|
|
||
|
|
||
|
def _generic_platforms() -> Iterator[str]:
|
||
|
yield _normalize_string(sysconfig.get_platform())
|
||
|
|
||
|
|
||
|
def platform_tags() -> Iterator[str]:
|
||
|
"""
|
||
|
Provides the platform tags for this installation.
|
||
|
"""
|
||
|
if platform.system() == "Darwin":
|
||
|
return mac_platforms()
|
||
|
elif platform.system() == "Linux":
|
||
|
return _linux_platforms()
|
||
|
else:
|
||
|
return _generic_platforms()
|
||
|
|
||
|
|
||
|
def interpreter_name() -> str:
|
||
|
"""
|
||
|
Returns the name of the running interpreter.
|
||
|
"""
|
||
|
name = sys.implementation.name
|
||
|
return INTERPRETER_SHORT_NAMES.get(name) or name
|
||
|
|
||
|
|
||
|
def interpreter_version(*, warn: bool = False) -> str:
|
||
|
"""
|
||
|
Returns the version of the running interpreter.
|
||
|
"""
|
||
|
version = _get_config_var("py_version_nodot", warn=warn)
|
||
|
if version:
|
||
|
version = str(version)
|
||
|
else:
|
||
|
version = _version_nodot(sys.version_info[:2])
|
||
|
return version
|
||
|
|
||
|
|
||
|
def _version_nodot(version: PythonVersion) -> str:
|
||
|
return "".join(map(str, version))
|
||
|
|
||
|
|
||
|
def sys_tags(*, warn: bool = False) -> Iterator[Tag]:
|
||
|
"""
|
||
|
Returns the sequence of tag triples for the running interpreter.
|
||
|
|
||
|
The order of the sequence corresponds to priority order for the
|
||
|
interpreter, from most to least important.
|
||
|
"""
|
||
|
|
||
|
interp_name = interpreter_name()
|
||
|
if interp_name == "cp":
|
||
|
yield from cpython_tags(warn=warn)
|
||
|
else:
|
||
|
yield from generic_tags()
|
||
|
|
||
|
if interp_name == "pp":
|
||
|
yield from compatible_tags(interpreter="pp3")
|
||
|
else:
|
||
|
yield from compatible_tags()
|