Source code for packaging.tags

# This file is dual licensed under the terms of the Apache License, Version
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
# for complete details.

from __future__ import absolute_import

import distutils.util

try:
    from importlib.machinery import EXTENSION_SUFFIXES
except ImportError:  # pragma: no cover
    import imp

    EXTENSION_SUFFIXES = [x[0] for x in imp.get_suffixes()]
    del imp
import platform
import re
import sys
import sysconfig
import warnings


INTERPRETER_SHORT_NAMES = {
    "python": "py",  # Generic.
    "cpython": "cp",
    "pypy": "pp",
    "ironpython": "ip",
    "jython": "jy",
}


_32_BIT_INTERPRETER = sys.maxsize <= 2 ** 32


[docs]class Tag(object): __slots__ = ["_interpreter", "_abi", "_platform"] def __init__(self, interpreter, abi, platform): self._interpreter = interpreter.lower() self._abi = abi.lower() self._platform = platform.lower() @property def interpreter(self): return self._interpreter @property def abi(self): return self._abi @property def platform(self): return self._platform def __eq__(self, other): return ( (self.platform == other.platform) and (self.abi == other.abi) and (self.interpreter == other.interpreter) ) def __hash__(self): return hash((self._interpreter, self._abi, self._platform)) def __str__(self): return "{}-{}-{}".format(self._interpreter, self._abi, self._platform) def __repr__(self): return "<{self} @ {self_id}>".format(self=self, self_id=id(self))
[docs]def parse_tag(tag): 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 _normalize_string(string): return string.replace(".", "_").replace("-", "_") def _cpython_interpreter(py_version): # TODO: Is using py_version_nodot for interpreter version critical? return "cp{major}{minor}".format(major=py_version[0], minor=py_version[1]) def _cpython_abis(py_version): abis = [] version = "{}{}".format(*py_version[:2]) debug = pymalloc = ucs4 = "" with_debug = sysconfig.get_config_var("Py_DEBUG") 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 = sysconfig.get_config_var("WITH_PYMALLOC") if with_pymalloc or with_pymalloc is None: pymalloc = "m" if py_version < (3, 3): unicode_size = sysconfig.get_config_var("Py_UNICODE_SIZE") 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("cp{version}".format(version=version)) abis.insert( 0, "cp{version}{debug}{pymalloc}{ucs4}".format( version=version, debug=debug, pymalloc=pymalloc, ucs4=ucs4 ), ) return abis def _cpython_tags(py_version, interpreter, abis, platforms): for abi in abis: for platform_ in platforms: yield Tag(interpreter, abi, platform_) for tag in (Tag(interpreter, "abi3", platform_) for platform_ in platforms): yield tag for tag in (Tag(interpreter, "none", platform_) for platform_ in platforms): yield tag # PEP 384 was first implemented in Python 3.2. for minor_version in range(py_version[1] - 1, 1, -1): for platform_ in platforms: interpreter = "cp{major}{minor}".format( major=py_version[0], minor=minor_version ) yield Tag(interpreter, "abi3", platform_) def _pypy_interpreter(): return "pp{py_major}{pypy_major}{pypy_minor}".format( py_major=sys.version_info[0], pypy_major=sys.pypy_version_info.major, pypy_minor=sys.pypy_version_info.minor, ) def _generic_abi(): abi = sysconfig.get_config_var("SOABI") if abi: return _normalize_string(abi) else: return "none" def _pypy_tags(py_version, interpreter, abi, platforms): for tag in (Tag(interpreter, abi, platform) for platform in platforms): yield tag for tag in (Tag(interpreter, "none", platform) for platform in platforms): yield tag def _generic_tags(interpreter, py_version, abi, platforms): for tag in (Tag(interpreter, abi, platform) for platform in platforms): yield tag if abi != "none": tags = (Tag(interpreter, "none", platform_) for platform_ in platforms) for tag in tags: yield tag def _py_interpreter_range(py_version): """ Yield Python versions in descending order. After the latest version, the major-only version will be yielded, and then all following versions up to 'end'. """ yield "py{major}{minor}".format(major=py_version[0], minor=py_version[1]) yield "py{major}".format(major=py_version[0]) for minor in range(py_version[1] - 1, -1, -1): yield "py{major}{minor}".format(major=py_version[0], minor=minor) def _independent_tags(interpreter, py_version, platforms): """ Return the sequence of tags that are consistent across implementations. The tags consist of: - py*-none-<platform> - <interpreter>-none-any - py*-none-any """ for version in _py_interpreter_range(py_version): for platform_ in platforms: yield Tag(version, "none", platform_) yield Tag(interpreter, "none", "any") for version in _py_interpreter_range(py_version): yield Tag(version, "none", "any") def _mac_arch(arch, is_32bit=_32_BIT_INTERPRETER): if not is_32bit: return arch if arch.startswith("ppc"): return "ppc" return "i386" def _mac_binary_formats(version, cpu_arch): 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"]) formats.append("universal") return formats def _mac_platforms(version=None, arch=None): version_str, _, cpu_arch = platform.mac_ver() if version is None: version = tuple(map(int, version_str.split(".")[:2])) if arch is None: arch = _mac_arch(cpu_arch) platforms = [] for minor_version in range(version[1], -1, -1): compat_version = version[0], minor_version binary_formats = _mac_binary_formats(compat_version, arch) for binary_format in binary_formats: platforms.append( "macosx_{major}_{minor}_{binary_format}".format( major=compat_version[0], minor=compat_version[1], binary_format=binary_format, ) ) return platforms # From PEP 513. def _is_manylinux_compatible(name, glibc_version): # Check for presence of _manylinux module. try: import _manylinux return bool(getattr(_manylinux, name + "_compatible")) except (ImportError, AttributeError): # Fall through to heuristic check below. pass return _have_compatible_glibc(*glibc_version) def _glibc_version_string(): # Returns glibc version string, or None if not using glibc. import ctypes # ctypes.CDLL(None) internally calls dlopen(NULL), and as the dlopen # manpage says, "If filename is NULL, then the returned handle is for the # main program". This way we can let the linker do the work to figure out # which libc our process is actually using. process_namespace = ctypes.CDLL(None) try: gnu_get_libc_version = process_namespace.gnu_get_libc_version except AttributeError: # Symbol doesn't exist -> therefore, we are not linked to # glibc. return None # Call gnu_get_libc_version, which returns a string like "2.5" gnu_get_libc_version.restype = ctypes.c_char_p version_str = gnu_get_libc_version() # py2 / py3 compatibility: if not isinstance(version_str, str): version_str = version_str.decode("ascii") return version_str # Separated out from have_compatible_glibc for easier unit testing. def _check_glibc_version(version_str, required_major, minimum_minor): # Parse string and check against requested version. # # We use a regexp instead of str.split because we want to discard any # random junk that might come after the minor version -- this might happen # in patched/forked versions of glibc (e.g. Linaro's version of glibc # uses version strings like "2.20-2014.11"). See gh-3588. m = re.match(r"(?P<major>[0-9]+)\.(?P<minor>[0-9]+)", version_str) if not m: warnings.warn( "Expected glibc version with 2 components major.minor," " got: %s" % version_str, RuntimeWarning, ) return False return ( int(m.group("major")) == required_major and int(m.group("minor")) >= minimum_minor ) def _have_compatible_glibc(required_major, minimum_minor): version_str = _glibc_version_string() if version_str is None: return False return _check_glibc_version(version_str, required_major, minimum_minor) def _linux_platforms(is_32bit=_32_BIT_INTERPRETER): linux = _normalize_string(distutils.util.get_platform()) if linux == "linux_x86_64" and is_32bit: linux = "linux_i686" manylinux_support = ( ("manylinux2014", (2, 17)), # CentOS 7 w/ glibc 2.17 (PEP 599) ("manylinux2010", (2, 12)), # CentOS 6 w/ glibc 2.12 (PEP 571) ("manylinux1", (2, 5)), # CentOS 5 w/ glibc 2.5 (PEP 513) ) manylinux_support_iter = iter(manylinux_support) for name, glibc_version in manylinux_support_iter: if _is_manylinux_compatible(name, glibc_version): platforms = [linux.replace("linux", name)] break else: platforms = [] # Support for a later manylinux implies support for an earlier version. platforms += [linux.replace("linux", name) for name, _ in manylinux_support_iter] platforms.append(linux) return platforms def _generic_platforms(): platform = _normalize_string(distutils.util.get_platform()) return [platform] def _interpreter_name(): name = platform.python_implementation().lower() return INTERPRETER_SHORT_NAMES.get(name) or name def _generic_interpreter(name, py_version): version = sysconfig.get_config_var("py_version_nodot") if not version: version = "".join(map(str, py_version[:2])) return "{name}{version}".format(name=name, version=version)
[docs]def sys_tags(): """ 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. """ py_version = sys.version_info[:2] interpreter_name = _interpreter_name() if platform.system() == "Darwin": platforms = _mac_platforms() elif platform.system() == "Linux": platforms = _linux_platforms() else: platforms = _generic_platforms() if interpreter_name == "cp": interpreter = _cpython_interpreter(py_version) abis = _cpython_abis(py_version) for tag in _cpython_tags(py_version, interpreter, abis, platforms): yield tag elif interpreter_name == "pp": interpreter = _pypy_interpreter() abi = _generic_abi() for tag in _pypy_tags(py_version, interpreter, abi, platforms): yield tag else: interpreter = _generic_interpreter(interpreter_name, py_version) abi = _generic_abi() for tag in _generic_tags(interpreter, py_version, abi, platforms): yield tag for tag in _independent_tags(interpreter, py_version, platforms): yield tag