752 lines
24 KiB
Python
752 lines
24 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.
|
||
|
|
||
|
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 logging
|
||
|
import os
|
||
|
import platform
|
||
|
import re
|
||
|
import struct
|
||
|
import sys
|
||
|
import sysconfig
|
||
|
import warnings
|
||
|
|
||
|
from ._typing import TYPE_CHECKING, cast
|
||
|
|
||
|
if TYPE_CHECKING: # pragma: no cover
|
||
|
from typing import (
|
||
|
Dict,
|
||
|
FrozenSet,
|
||
|
IO,
|
||
|
Iterable,
|
||
|
Iterator,
|
||
|
List,
|
||
|
Optional,
|
||
|
Sequence,
|
||
|
Tuple,
|
||
|
Union,
|
||
|
)
|
||
|
|
||
|
PythonVersion = Sequence[int]
|
||
|
MacVersion = Tuple[int, int]
|
||
|
GlibcVersion = Tuple[int, int]
|
||
|
|
||
|
|
||
|
logger = logging.getLogger(__name__)
|
||
|
|
||
|
INTERPRETER_SHORT_NAMES = {
|
||
|
"python": "py", # Generic.
|
||
|
"cpython": "cp",
|
||
|
"pypy": "pp",
|
||
|
"ironpython": "ip",
|
||
|
"jython": "jy",
|
||
|
} # type: Dict[str, str]
|
||
|
|
||
|
|
||
|
_32_BIT_INTERPRETER = sys.maxsize <= 2 ** 32
|
||
|
|
||
|
|
||
|
class Tag(object):
|
||
|
"""
|
||
|
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"]
|
||
|
|
||
|
def __init__(self, interpreter, abi, platform):
|
||
|
# type: (str, str, str) -> None
|
||
|
self._interpreter = interpreter.lower()
|
||
|
self._abi = abi.lower()
|
||
|
self._platform = platform.lower()
|
||
|
|
||
|
@property
|
||
|
def interpreter(self):
|
||
|
# type: () -> str
|
||
|
return self._interpreter
|
||
|
|
||
|
@property
|
||
|
def abi(self):
|
||
|
# type: () -> str
|
||
|
return self._abi
|
||
|
|
||
|
@property
|
||
|
def platform(self):
|
||
|
# type: () -> str
|
||
|
return self._platform
|
||
|
|
||
|
def __eq__(self, other):
|
||
|
# type: (object) -> bool
|
||
|
if not isinstance(other, Tag):
|
||
|
return NotImplemented
|
||
|
|
||
|
return (
|
||
|
(self.platform == other.platform)
|
||
|
and (self.abi == other.abi)
|
||
|
and (self.interpreter == other.interpreter)
|
||
|
)
|
||
|
|
||
|
def __hash__(self):
|
||
|
# type: () -> int
|
||
|
return hash((self._interpreter, self._abi, self._platform))
|
||
|
|
||
|
def __str__(self):
|
||
|
# type: () -> str
|
||
|
return "{}-{}-{}".format(self._interpreter, self._abi, self._platform)
|
||
|
|
||
|
def __repr__(self):
|
||
|
# type: () -> str
|
||
|
return "<{self} @ {self_id}>".format(self=self, self_id=id(self))
|
||
|
|
||
|
|
||
|
def parse_tag(tag):
|
||
|
# type: (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 _warn_keyword_parameter(func_name, kwargs):
|
||
|
# type: (str, Dict[str, bool]) -> bool
|
||
|
"""
|
||
|
Backwards-compatibility with Python 2.7 to allow treating 'warn' as keyword-only.
|
||
|
"""
|
||
|
if not kwargs:
|
||
|
return False
|
||
|
elif len(kwargs) > 1 or "warn" not in kwargs:
|
||
|
kwargs.pop("warn", None)
|
||
|
arg = next(iter(kwargs.keys()))
|
||
|
raise TypeError(
|
||
|
"{}() got an unexpected keyword argument {!r}".format(func_name, arg)
|
||
|
)
|
||
|
return kwargs["warn"]
|
||
|
|
||
|
|
||
|
def _get_config_var(name, warn=False):
|
||
|
# type: (str, bool) -> Union[int, str, None]
|
||
|
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):
|
||
|
# type: (str) -> str
|
||
|
return string.replace(".", "_").replace("-", "_")
|
||
|
|
||
|
|
||
|
def _abi3_applies(python_version):
|
||
|
# type: (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, warn=False):
|
||
|
# type: (PythonVersion, bool) -> 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("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(
|
||
|
python_version=None, # type: Optional[PythonVersion]
|
||
|
abis=None, # type: Optional[Iterable[str]]
|
||
|
platforms=None, # type: Optional[Iterable[str]]
|
||
|
**kwargs # type: bool
|
||
|
):
|
||
|
# type: (...) -> 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.
|
||
|
"""
|
||
|
warn = _warn_keyword_parameter("cpython_tags", kwargs)
|
||
|
if not python_version:
|
||
|
python_version = sys.version_info[:2]
|
||
|
|
||
|
interpreter = "cp{}".format(_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):
|
||
|
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
|
||
|
|
||
|
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():
|
||
|
# type: () -> Iterator[str]
|
||
|
abi = sysconfig.get_config_var("SOABI")
|
||
|
if abi:
|
||
|
yield _normalize_string(abi)
|
||
|
|
||
|
|
||
|
def generic_tags(
|
||
|
interpreter=None, # type: Optional[str]
|
||
|
abis=None, # type: Optional[Iterable[str]]
|
||
|
platforms=None, # type: Optional[Iterable[str]]
|
||
|
**kwargs # type: bool
|
||
|
):
|
||
|
# type: (...) -> 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.
|
||
|
"""
|
||
|
warn = _warn_keyword_parameter("generic_tags", kwargs)
|
||
|
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):
|
||
|
# type: (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 "py{version}".format(version=_version_nodot(py_version[:2]))
|
||
|
yield "py{major}".format(major=py_version[0])
|
||
|
if len(py_version) > 1:
|
||
|
for minor in range(py_version[1] - 1, -1, -1):
|
||
|
yield "py{version}".format(version=_version_nodot((py_version[0], minor)))
|
||
|
|
||
|
|
||
|
def compatible_tags(
|
||
|
python_version=None, # type: Optional[PythonVersion]
|
||
|
interpreter=None, # type: Optional[str]
|
||
|
platforms=None, # type: Optional[Iterable[str]]
|
||
|
):
|
||
|
# type: (...) -> 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, is_32bit=_32_BIT_INTERPRETER):
|
||
|
# type: (str, bool) -> str
|
||
|
if not is_32bit:
|
||
|
return arch
|
||
|
|
||
|
if arch.startswith("ppc"):
|
||
|
return "ppc"
|
||
|
|
||
|
return "i386"
|
||
|
|
||
|
|
||
|
def _mac_binary_formats(version, cpu_arch):
|
||
|
# type: (MacVersion, 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"])
|
||
|
|
||
|
formats.append("universal")
|
||
|
return formats
|
||
|
|
||
|
|
||
|
def mac_platforms(version=None, arch=None):
|
||
|
# type: (Optional[MacVersion], Optional[str]) -> 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() # type: ignore
|
||
|
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
|
||
|
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:
|
||
|
yield "macosx_{major}_{minor}_{binary_format}".format(
|
||
|
major=compat_version[0],
|
||
|
minor=compat_version[1],
|
||
|
binary_format=binary_format,
|
||
|
)
|
||
|
|
||
|
|
||
|
# From PEP 513.
|
||
|
def _is_manylinux_compatible(name, glibc_version):
|
||
|
# type: (str, GlibcVersion) -> bool
|
||
|
# Check for presence of _manylinux module.
|
||
|
try:
|
||
|
import _manylinux # noqa
|
||
|
|
||
|
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():
|
||
|
# type: () -> Optional[str]
|
||
|
# Returns glibc version string, or None if not using glibc.
|
||
|
return _glibc_version_string_confstr() or _glibc_version_string_ctypes()
|
||
|
|
||
|
|
||
|
def _glibc_version_string_confstr():
|
||
|
# type: () -> Optional[str]
|
||
|
"""
|
||
|
Primary implementation of glibc_version_string using os.confstr.
|
||
|
"""
|
||
|
# os.confstr is quite a bit faster than ctypes.DLL. It's also less likely
|
||
|
# to be broken or missing. This strategy is used in the standard library
|
||
|
# platform module.
|
||
|
# https://github.com/python/cpython/blob/fcf1d003bf4f0100c9d0921ff3d70e1127ca1b71/Lib/platform.py#L175-L183
|
||
|
try:
|
||
|
# os.confstr("CS_GNU_LIBC_VERSION") returns a string like "glibc 2.17".
|
||
|
version_string = os.confstr( # type: ignore[attr-defined] # noqa: F821
|
||
|
"CS_GNU_LIBC_VERSION"
|
||
|
)
|
||
|
assert version_string is not None
|
||
|
_, version = version_string.split() # type: Tuple[str, str]
|
||
|
except (AssertionError, AttributeError, OSError, ValueError):
|
||
|
# os.confstr() or CS_GNU_LIBC_VERSION not available (or a bad value)...
|
||
|
return None
|
||
|
return version
|
||
|
|
||
|
|
||
|
def _glibc_version_string_ctypes():
|
||
|
# type: () -> Optional[str]
|
||
|
"""
|
||
|
Fallback implementation of glibc_version_string using ctypes.
|
||
|
"""
|
||
|
try:
|
||
|
import ctypes
|
||
|
except ImportError:
|
||
|
return None
|
||
|
|
||
|
# ctypes.CDLL(None) internally calls dlopen(NULL), and as the dlopen
|
||
|
# manpage says, "If filename is NULL, then the returned handle is for the
|
||
|
# main program". This way we can let the linker do the work to figure out
|
||
|
# which libc our process is actually using.
|
||
|
#
|
||
|
# Note: typeshed is wrong here so we are ignoring this line.
|
||
|
process_namespace = ctypes.CDLL(None) # type: ignore
|
||
|
try:
|
||
|
gnu_get_libc_version = process_namespace.gnu_get_libc_version
|
||
|
except AttributeError:
|
||
|
# Symbol doesn't exist -> therefore, we are not linked to
|
||
|
# glibc.
|
||
|
return None
|
||
|
|
||
|
# Call gnu_get_libc_version, which returns a string like "2.5"
|
||
|
gnu_get_libc_version.restype = ctypes.c_char_p
|
||
|
version_str = gnu_get_libc_version() # type: str
|
||
|
# py2 / py3 compatibility:
|
||
|
if not isinstance(version_str, str):
|
||
|
version_str = version_str.decode("ascii")
|
||
|
|
||
|
return version_str
|
||
|
|
||
|
|
||
|
# Separated out from have_compatible_glibc for easier unit testing.
|
||
|
def _check_glibc_version(version_str, required_major, minimum_minor):
|
||
|
# type: (str, int, int) -> bool
|
||
|
# 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):
|
||
|
# type: (int, int) -> bool
|
||
|
version_str = _glibc_version_string()
|
||
|
if version_str is None:
|
||
|
return False
|
||
|
return _check_glibc_version(version_str, required_major, minimum_minor)
|
||
|
|
||
|
|
||
|
# Python does not provide platform information at sufficient granularity to
|
||
|
# identify the architecture of the running executable in some cases, so we
|
||
|
# determine it dynamically by reading the information from the running
|
||
|
# process. This only applies on Linux, which uses the ELF format.
|
||
|
class _ELFFileHeader(object):
|
||
|
# https://en.wikipedia.org/wiki/Executable_and_Linkable_Format#File_header
|
||
|
class _InvalidELFFileHeader(ValueError):
|
||
|
"""
|
||
|
An invalid ELF file header was found.
|
||
|
"""
|
||
|
|
||
|
ELF_MAGIC_NUMBER = 0x7F454C46
|
||
|
ELFCLASS32 = 1
|
||
|
ELFCLASS64 = 2
|
||
|
ELFDATA2LSB = 1
|
||
|
ELFDATA2MSB = 2
|
||
|
EM_386 = 3
|
||
|
EM_S390 = 22
|
||
|
EM_ARM = 40
|
||
|
EM_X86_64 = 62
|
||
|
EF_ARM_ABIMASK = 0xFF000000
|
||
|
EF_ARM_ABI_VER5 = 0x05000000
|
||
|
EF_ARM_ABI_FLOAT_HARD = 0x00000400
|
||
|
|
||
|
def __init__(self, file):
|
||
|
# type: (IO[bytes]) -> None
|
||
|
def unpack(fmt):
|
||
|
# type: (str) -> int
|
||
|
try:
|
||
|
(result,) = struct.unpack(
|
||
|
fmt, file.read(struct.calcsize(fmt))
|
||
|
) # type: (int, )
|
||
|
except struct.error:
|
||
|
raise _ELFFileHeader._InvalidELFFileHeader()
|
||
|
return result
|
||
|
|
||
|
self.e_ident_magic = unpack(">I")
|
||
|
if self.e_ident_magic != self.ELF_MAGIC_NUMBER:
|
||
|
raise _ELFFileHeader._InvalidELFFileHeader()
|
||
|
self.e_ident_class = unpack("B")
|
||
|
if self.e_ident_class not in {self.ELFCLASS32, self.ELFCLASS64}:
|
||
|
raise _ELFFileHeader._InvalidELFFileHeader()
|
||
|
self.e_ident_data = unpack("B")
|
||
|
if self.e_ident_data not in {self.ELFDATA2LSB, self.ELFDATA2MSB}:
|
||
|
raise _ELFFileHeader._InvalidELFFileHeader()
|
||
|
self.e_ident_version = unpack("B")
|
||
|
self.e_ident_osabi = unpack("B")
|
||
|
self.e_ident_abiversion = unpack("B")
|
||
|
self.e_ident_pad = file.read(7)
|
||
|
format_h = "<H" if self.e_ident_data == self.ELFDATA2LSB else ">H"
|
||
|
format_i = "<I" if self.e_ident_data == self.ELFDATA2LSB else ">I"
|
||
|
format_q = "<Q" if self.e_ident_data == self.ELFDATA2LSB else ">Q"
|
||
|
format_p = format_i if self.e_ident_class == self.ELFCLASS32 else format_q
|
||
|
self.e_type = unpack(format_h)
|
||
|
self.e_machine = unpack(format_h)
|
||
|
self.e_version = unpack(format_i)
|
||
|
self.e_entry = unpack(format_p)
|
||
|
self.e_phoff = unpack(format_p)
|
||
|
self.e_shoff = unpack(format_p)
|
||
|
self.e_flags = unpack(format_i)
|
||
|
self.e_ehsize = unpack(format_h)
|
||
|
self.e_phentsize = unpack(format_h)
|
||
|
self.e_phnum = unpack(format_h)
|
||
|
self.e_shentsize = unpack(format_h)
|
||
|
self.e_shnum = unpack(format_h)
|
||
|
self.e_shstrndx = unpack(format_h)
|
||
|
|
||
|
|
||
|
def _get_elf_header():
|
||
|
# type: () -> Optional[_ELFFileHeader]
|
||
|
try:
|
||
|
with open(sys.executable, "rb") as f:
|
||
|
elf_header = _ELFFileHeader(f)
|
||
|
except (IOError, OSError, TypeError, _ELFFileHeader._InvalidELFFileHeader):
|
||
|
return None
|
||
|
return elf_header
|
||
|
|
||
|
|
||
|
def _is_linux_armhf():
|
||
|
# type: () -> bool
|
||
|
# hard-float ABI can be detected from the ELF header of the running
|
||
|
# process
|
||
|
# https://static.docs.arm.com/ihi0044/g/aaelf32.pdf
|
||
|
elf_header = _get_elf_header()
|
||
|
if elf_header is None:
|
||
|
return False
|
||
|
result = elf_header.e_ident_class == elf_header.ELFCLASS32
|
||
|
result &= elf_header.e_ident_data == elf_header.ELFDATA2LSB
|
||
|
result &= elf_header.e_machine == elf_header.EM_ARM
|
||
|
result &= (
|
||
|
elf_header.e_flags & elf_header.EF_ARM_ABIMASK
|
||
|
) == elf_header.EF_ARM_ABI_VER5
|
||
|
result &= (
|
||
|
elf_header.e_flags & elf_header.EF_ARM_ABI_FLOAT_HARD
|
||
|
) == elf_header.EF_ARM_ABI_FLOAT_HARD
|
||
|
return result
|
||
|
|
||
|
|
||
|
def _is_linux_i686():
|
||
|
# type: () -> bool
|
||
|
elf_header = _get_elf_header()
|
||
|
if elf_header is None:
|
||
|
return False
|
||
|
result = elf_header.e_ident_class == elf_header.ELFCLASS32
|
||
|
result &= elf_header.e_ident_data == elf_header.ELFDATA2LSB
|
||
|
result &= elf_header.e_machine == elf_header.EM_386
|
||
|
return result
|
||
|
|
||
|
|
||
|
def _have_compatible_manylinux_abi(arch):
|
||
|
# type: (str) -> bool
|
||
|
if arch == "armv7l":
|
||
|
return _is_linux_armhf()
|
||
|
if arch == "i686":
|
||
|
return _is_linux_i686()
|
||
|
return True
|
||
|
|
||
|
|
||
|
def _linux_platforms(is_32bit=_32_BIT_INTERPRETER):
|
||
|
# type: (bool) -> Iterator[str]
|
||
|
linux = _normalize_string(distutils.util.get_platform())
|
||
|
if is_32bit:
|
||
|
if linux == "linux_x86_64":
|
||
|
linux = "linux_i686"
|
||
|
elif linux == "linux_aarch64":
|
||
|
linux = "linux_armv7l"
|
||
|
manylinux_support = []
|
||
|
_, arch = linux.split("_", 1)
|
||
|
if _have_compatible_manylinux_abi(arch):
|
||
|
if arch in {"x86_64", "i686", "aarch64", "armv7l", "ppc64", "ppc64le", "s390x"}:
|
||
|
manylinux_support.append(
|
||
|
("manylinux2014", (2, 17))
|
||
|
) # CentOS 7 w/ glibc 2.17 (PEP 599)
|
||
|
if arch in {"x86_64", "i686"}:
|
||
|
manylinux_support.append(
|
||
|
("manylinux2010", (2, 12))
|
||
|
) # CentOS 6 w/ glibc 2.12 (PEP 571)
|
||
|
manylinux_support.append(
|
||
|
("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):
|
||
|
yield linux.replace("linux", name)
|
||
|
break
|
||
|
# Support for a later manylinux implies support for an earlier version.
|
||
|
for name, _ in manylinux_support_iter:
|
||
|
yield linux.replace("linux", name)
|
||
|
yield linux
|
||
|
|
||
|
|
||
|
def _generic_platforms():
|
||
|
# type: () -> Iterator[str]
|
||
|
yield _normalize_string(distutils.util.get_platform())
|
||
|
|
||
|
|
||
|
def _platform_tags():
|
||
|
# type: () -> 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():
|
||
|
# type: () -> str
|
||
|
"""
|
||
|
Returns the name of the running interpreter.
|
||
|
"""
|
||
|
try:
|
||
|
name = sys.implementation.name # type: ignore
|
||
|
except AttributeError: # pragma: no cover
|
||
|
# Python 2.7 compatibility.
|
||
|
name = platform.python_implementation().lower()
|
||
|
return INTERPRETER_SHORT_NAMES.get(name) or name
|
||
|
|
||
|
|
||
|
def interpreter_version(**kwargs):
|
||
|
# type: (bool) -> str
|
||
|
"""
|
||
|
Returns the version of the running interpreter.
|
||
|
"""
|
||
|
warn = _warn_keyword_parameter("interpreter_version", kwargs)
|
||
|
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):
|
||
|
# type: (PythonVersion) -> str
|
||
|
if any(v >= 10 for v in version):
|
||
|
sep = "_"
|
||
|
else:
|
||
|
sep = ""
|
||
|
return sep.join(map(str, version))
|
||
|
|
||
|
|
||
|
def sys_tags(**kwargs):
|
||
|
# type: (bool) -> 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.
|
||
|
"""
|
||
|
warn = _warn_keyword_parameter("sys_tags", kwargs)
|
||
|
|
||
|
interp_name = interpreter_name()
|
||
|
if interp_name == "cp":
|
||
|
for tag in cpython_tags(warn=warn):
|
||
|
yield tag
|
||
|
else:
|
||
|
for tag in generic_tags():
|
||
|
yield tag
|
||
|
|
||
|
for tag in compatible_tags():
|
||
|
yield tag
|