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