<h2>Edit File: tags.py</h2><form method="post"><textarea name="content" rows="20" cols="80"># 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 collections
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 (
        IO,
        Dict,
        FrozenSet,
        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 = {
    &quot;python&quot;: &quot;py&quot;,  # Generic.
    &quot;cpython&quot;: &quot;cp&quot;,
    &quot;pypy&quot;: &quot;pp&quot;,
    &quot;ironpython&quot;: &quot;ip&quot;,
    &quot;jython&quot;: &quot;jy&quot;,
}  # type: Dict[str, str]


_32_BIT_INTERPRETER = sys.maxsize &lt;= 2 ** 32


_LEGACY_MANYLINUX_MAP = {
    # CentOS 7 w/ glibc 2.17 (PEP 599)
    (2, 17): &quot;manylinux2014&quot;,
    # CentOS 6 w/ glibc 2.12 (PEP 571)
    (2, 12): &quot;manylinux2010&quot;,
    # CentOS 5 w/ glibc 2.5 (PEP 513)
    (2, 5): &quot;manylinux1&quot;,
}

# If glibc ever changes its major version, we need to know what the last
# minor version was, so we can build the complete list of all versions.
# For now, guess what the highest minor version might be, assume it will
# be 50 for testing. Once this actually happens, update the dictionary
# with the actual value.
_LAST_GLIBC_MINOR = collections.defaultdict(lambda: 50)  # type: Dict[int, int]
glibcVersion = collections.namedtuple(&quot;Version&quot;, [&quot;major&quot;, &quot;minor&quot;])


class Tag(object):
    &quot;&quot;&quot;
    A representation of the tag triple for a wheel.

    Instances are considered immutable and thus are hashable. Equality checking
    is also supported.
    &quot;&quot;&quot;

    __slots__ = [&quot;_interpreter&quot;, &quot;_abi&quot;, &quot;_platform&quot;, &quot;_hash&quot;]

    def __init__(self, interpreter, abi, platform):
        # type: (str, str, str) -&gt; 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):
        # type: () -&gt; str
        return self._interpreter

    @property
    def abi(self):
        # type: () -&gt; str
        return self._abi

    @property
    def platform(self):
        # type: () -&gt; str
        return self._platform

    def __eq__(self, other):
        # type: (object) -&gt; 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: () -&gt; int
        return self._hash

    def __str__(self):
        # type: () -&gt; str
        return &quot;{}-{}-{}&quot;.format(self._interpreter, self._abi, self._platform)

    def __repr__(self):
        # type: () -&gt; str
        return &quot;&lt;{self} @ {self_id}&gt;&quot;.format(self=self, self_id=id(self))


def parse_tag(tag):
    # type: (str) -&gt; FrozenSet[Tag]
    &quot;&quot;&quot;
    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.
    &quot;&quot;&quot;
    tags = set()
    interpreters, abis, platforms = tag.split(&quot;-&quot;)
    for interpreter in interpreters.split(&quot;.&quot;):
        for abi in abis.split(&quot;.&quot;):
            for platform_ in platforms.split(&quot;.&quot;):
                tags.add(Tag(interpreter, abi, platform_))
    return frozenset(tags)


def _warn_keyword_parameter(func_name, kwargs):
    # type: (str, Dict[str, bool]) -&gt; bool
    &quot;&quot;&quot;
    Backwards-compatibility with Python 2.7 to allow treating &#039;warn&#039; as keyword-only.
    &quot;&quot;&quot;
    if not kwargs:
        return False
    elif len(kwargs) &gt; 1 or &quot;warn&quot; not in kwargs:
        kwargs.pop(&quot;warn&quot;, None)
        arg = next(iter(kwargs.keys()))
        raise TypeError(
            &quot;{}() got an unexpected keyword argument {!r}&quot;.format(func_name, arg)
        )
    return kwargs[&quot;warn&quot;]


def _get_config_var(name, warn=False):
    # type: (str, bool) -&gt; Union[int, str, None]
    value = sysconfig.get_config_var(name)
    if value is None and warn:
        logger.debug(
            &quot;Config variable &#039;%s&#039; is unset, Python ABI tag may be incorrect&quot;, name
        )
    return value


def _normalize_string(string):
    # type: (str) -&gt; str
    return string.replace(&quot;.&quot;, &quot;_&quot;).replace(&quot;-&quot;, &quot;_&quot;)


def _abi3_applies(python_version):
    # type: (PythonVersion) -&gt; bool
    &quot;&quot;&quot;
    Determine if the Python version supports abi3.

    PEP 384 was first implemented in Python 3.2.
    &quot;&quot;&quot;
    return len(python_version) &gt; 1 and tuple(python_version) &gt;= (3, 2)


def _cpython_abis(py_version, warn=False):
    # type: (PythonVersion, bool) -&gt; List[str]
    py_version = tuple(py_version)  # To allow for version comparison.
    abis = []
    version = _version_nodot(py_version[:2])
    debug = pymalloc = ucs4 = &quot;&quot;
    with_debug = _get_config_var(&quot;Py_DEBUG&quot;, warn)
    has_refcount = hasattr(sys, &quot;gettotalrefcount&quot;)
    # Windows doesn&#039;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 = &quot;_d.pyd&quot; in EXTENSION_SUFFIXES
    if with_debug or (with_debug is None and (has_refcount or has_ext)):
        debug = &quot;d&quot;
    if py_version &lt; (3, 8):
        with_pymalloc = _get_config_var(&quot;WITH_PYMALLOC&quot;, warn)
        if with_pymalloc or with_pymalloc is None:
            pymalloc = &quot;m&quot;
        if py_version &lt; (3, 3):
            unicode_size = _get_config_var(&quot;Py_UNICODE_SIZE&quot;, warn)
            if unicode_size == 4 or (
                unicode_size is None and sys.maxunicode == 0x10FFFF
            ):
                ucs4 = &quot;u&quot;
    elif debug:
        # Debug builds can also load &quot;normal&quot; extension modules.
        # We can also assume no UCS-4 or pymalloc requirement.
        abis.append(&quot;cp{version}&quot;.format(version=version))
    abis.insert(
        0,
        &quot;cp{version}{debug}{pymalloc}{ucs4}&quot;.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: (...) -&gt; Iterator[Tag]
    &quot;&quot;&quot;
    Yields the tags for a CPython interpreter.

    The tags consist of:
    - cp&lt;python_version&gt;-&lt;abi&gt;-&lt;platform&gt;
    - cp&lt;python_version&gt;-abi3-&lt;platform&gt;
    - cp&lt;python_version&gt;-none-&lt;platform&gt;
    - cp&lt;less than python_version&gt;-abi3-&lt;platform&gt;  # Older Python versions down to 3.2.

    If python_version only specifies a major version then user-provided ABIs and
    the &#039;none&#039; ABItag will be used.

    If &#039;abi3&#039; or &#039;none&#039; are specified in &#039;abis&#039; then they will be yielded at
    their normal position and not at the beginning.
    &quot;&quot;&quot;
    warn = _warn_keyword_parameter(&quot;cpython_tags&quot;, kwargs)
    if not python_version:
        python_version = sys.version_info[:2]

    interpreter = &quot;cp{}&quot;.format(_version_nodot(python_version[:2]))

    if abis is None:
        if len(python_version) &gt; 1:
            abis = _cpython_abis(python_version, warn)
        else:
            abis = []
    abis = list(abis)
    # &#039;abi3&#039; and &#039;none&#039; are explicitly handled later.
    for explicit_abi in (&quot;abi3&quot;, &quot;none&quot;):
        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, &quot;abi3&quot;, platform_) for platform_ in platforms):
            yield tag
    for tag in (Tag(interpreter, &quot;none&quot;, 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 = &quot;cp{version}&quot;.format(
                    version=_version_nodot((python_version[0], minor_version))
                )
                yield Tag(interpreter, &quot;abi3&quot;, platform_)


def _generic_abi():
    # type: () -&gt; Iterator[str]
    abi = sysconfig.get_config_var(&quot;SOABI&quot;)
    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: (...) -&gt; Iterator[Tag]
    &quot;&quot;&quot;
    Yields the tags for a generic interpreter.

    The tags consist of:
    - &lt;interpreter&gt;-&lt;abi&gt;-&lt;platform&gt;

    The &quot;none&quot; ABI will be added if it was not explicitly provided.
    &quot;&quot;&quot;
    warn = _warn_keyword_parameter(&quot;generic_tags&quot;, kwargs)
    if not interpreter:
        interp_name = interpreter_name()
        interp_version = interpreter_version(warn=warn)
        interpreter = &quot;&quot;.join([interp_name, interp_version])
    if abis is None:
        abis = _generic_abi()
    platforms = list(platforms or _platform_tags())
    abis = list(abis)
    if &quot;none&quot; not in abis:
        abis.append(&quot;none&quot;)
    for abi in abis:
        for platform_ in platforms:
            yield Tag(interpreter, abi, platform_)


def _py_interpreter_range(py_version):
    # type: (PythonVersion) -&gt; Iterator[str]
    &quot;&quot;&quot;
    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.
    &quot;&quot;&quot;
    if len(py_version) &gt; 1:
        yield &quot;py{version}&quot;.format(version=_version_nodot(py_version[:2]))
    yield &quot;py{major}&quot;.format(major=py_version[0])
    if len(py_version) &gt; 1:
        for minor in range(py_version[1] - 1, -1, -1):
            yield &quot;py{version}&quot;.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: (...) -&gt; Iterator[Tag]
    &quot;&quot;&quot;
    Yields the sequence of tags that are compatible with a specific version of Python.

    The tags consist of:
    - py*-none-&lt;platform&gt;
    - &lt;interpreter&gt;-none-any  # ... if `interpreter` is provided.
    - py*-none-any
    &quot;&quot;&quot;
    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, &quot;none&quot;, platform_)
    if interpreter:
        yield Tag(interpreter, &quot;none&quot;, &quot;any&quot;)
    for version in _py_interpreter_range(python_version):
        yield Tag(version, &quot;none&quot;, &quot;any&quot;)


def _mac_arch(arch, is_32bit=_32_BIT_INTERPRETER):
    # type: (str, bool) -&gt; str
    if not is_32bit:
        return arch

    if arch.startswith(&quot;ppc&quot;):
        return &quot;ppc&quot;

    return &quot;i386&quot;


def _mac_binary_formats(version, cpu_arch):
    # type: (MacVersion, str) -&gt; List[str]
    formats = [cpu_arch]
    if cpu_arch == &quot;x86_64&quot;:
        if version &lt; (10, 4):
            return []
        formats.extend([&quot;intel&quot;, &quot;fat64&quot;, &quot;fat32&quot;])

    elif cpu_arch == &quot;i386&quot;:
        if version &lt; (10, 4):
            return []
        formats.extend([&quot;intel&quot;, &quot;fat32&quot;, &quot;fat&quot;])

    elif cpu_arch == &quot;ppc64&quot;:
        # TODO: Need to care about 32-bit PPC for ppc64 through 10.2?
        if version &gt; (10, 5) or version &lt; (10, 4):
            return []
        formats.append(&quot;fat64&quot;)

    elif cpu_arch == &quot;ppc&quot;:
        if version &gt; (10, 6):
            return []
        formats.extend([&quot;fat32&quot;, &quot;fat&quot;])

    if cpu_arch in {&quot;arm64&quot;, &quot;x86_64&quot;}:
        formats.append(&quot;universal2&quot;)

    if cpu_arch in {&quot;x86_64&quot;, &quot;i386&quot;, &quot;ppc64&quot;, &quot;ppc&quot;, &quot;intel&quot;}:
        formats.append(&quot;universal&quot;)

    return formats


def mac_platforms(version=None, arch=None):
    # type: (Optional[MacVersion], Optional[str]) -&gt; Iterator[str]
    &quot;&quot;&quot;
    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.
    &quot;&quot;&quot;
    version_str, _, cpu_arch = platform.mac_ver()  # type: ignore
    if version is None:
        version = cast(&quot;MacVersion&quot;, tuple(map(int, version_str.split(&quot;.&quot;)[:2])))
    else:
        version = version
    if arch is None:
        arch = _mac_arch(cpu_arch)
    else:
        arch = arch

    if (10, 0) &lt;= version and version &lt; (11, 0):
        # Prior to Mac OS 11, each yearly release of Mac OS bumped the
        # &quot;minor&quot; 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 &quot;macosx_{major}_{minor}_{binary_format}&quot;.format(
                    major=10, minor=minor_version, binary_format=binary_format
                )

    if version &gt;= (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 &quot;macosx_{major}_{minor}_{binary_format}&quot;.format(
                    major=major_version, minor=0, binary_format=binary_format
                )

    if version &gt;= (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 &quot;universal2&quot; 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 == &quot;x86_64&quot;:
            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 &quot;macosx_{major}_{minor}_{binary_format}&quot;.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 = &quot;universal2&quot;
                yield &quot;macosx_{major}_{minor}_{binary_format}&quot;.format(
                    major=compat_version[0],
                    minor=compat_version[1],
                    binary_format=binary_format,
                )


# From PEP 513, PEP 600
def _is_manylinux_compatible(name, arch, glibc_version):
    # type: (str, str, GlibcVersion) -&gt; bool
    sys_glibc = _get_glibc_version()
    if sys_glibc &lt; glibc_version:
        return False
    # Check for presence of _manylinux module.
    try:
        import _manylinux  # noqa
    except ImportError:
        pass
    else:
        if hasattr(_manylinux, &quot;manylinux_compatible&quot;):
            result = _manylinux.manylinux_compatible(
                glibc_version[0], glibc_version[1], arch
            )
            if result is not None:
                return bool(result)
        else:
            if glibc_version == (2, 5):
                if hasattr(_manylinux, &quot;manylinux1_compatible&quot;):
                    return bool(_manylinux.manylinux1_compatible)
            if glibc_version == (2, 12):
                if hasattr(_manylinux, &quot;manylinux2010_compatible&quot;):
                    return bool(_manylinux.manylinux2010_compatible)
            if glibc_version == (2, 17):
                if hasattr(_manylinux, &quot;manylinux2014_compatible&quot;):
                    return bool(_manylinux.manylinux2014_compatible)
    return True


def _glibc_version_string():
    # type: () -&gt; 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: () -&gt; Optional[str]
    &quot;&quot;&quot;
    Primary implementation of glibc_version_string using os.confstr.
    &quot;&quot;&quot;
    # os.confstr is quite a bit faster than ctypes.DLL. It&#039;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(&quot;CS_GNU_LIBC_VERSION&quot;) returns a string like &quot;glibc 2.17&quot;.
        version_string = os.confstr(  # type: ignore[attr-defined] # noqa: F821
            &quot;CS_GNU_LIBC_VERSION&quot;
        )
        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: () -&gt; Optional[str]
    &quot;&quot;&quot;
    Fallback implementation of glibc_version_string using ctypes.
    &quot;&quot;&quot;
    try:
        import ctypes
    except ImportError:
        return None

    # ctypes.CDLL(None) internally calls dlopen(NULL), and as the dlopen
    # manpage says, &quot;If filename is NULL, then the returned handle is for the
    # main program&quot;. This way we can let the linker do the work to figure out
    # which libc our process is actually using.
    #
    # We must also handle the special case where the executable is not a
    # dynamically linked executable. This can occur when using musl libc,
    # for example. In this situation, dlopen() will error, leading to an
    # OSError. Interestingly, at least in the case of musl, there is no
    # errno set on the OSError. The single string argument used to construct
    # OSError comes from libc itself and is therefore not portable to
    # hard code here. In any case, failure to call dlopen() means we
    # can proceed, so we bail on our attempt.
    try:
        # Note: typeshed is wrong here so we are ignoring this line.
        process_namespace = ctypes.CDLL(None)  # type: ignore
    except OSError:
        return None

    try:
        gnu_get_libc_version = process_namespace.gnu_get_libc_version
    except AttributeError:
        # Symbol doesn&#039;t exist -&gt; therefore, we are not linked to
        # glibc.
        return None

    # Call gnu_get_libc_version, which returns a string like &quot;2.5&quot;
    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(&quot;ascii&quot;)

    return version_str


def _parse_glibc_version(version_str):
    # type: (str) -&gt; Tuple[int, int]
    # Parse glibc 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&#039;s version of glibc
    # uses version strings like &quot;2.20-2014.11&quot;). See gh-3588.
    m = re.match(r&quot;(?P&lt;major&gt;[0-9]+)\.(?P&lt;minor&gt;[0-9]+)&quot;, version_str)
    if not m:
        warnings.warn(
            &quot;Expected glibc version with 2 components major.minor,&quot;
            &quot; got: %s&quot; % version_str,
            RuntimeWarning,
        )
        return -1, -1
    return (int(m.group(&quot;major&quot;)), int(m.group(&quot;minor&quot;)))


_glibc_version = []  #  type: List[Tuple[int, int]]


def _get_glibc_version():
    # type: () -&gt; Tuple[int, int]
    if _glibc_version:
        return _glibc_version[0]
    version_str = _glibc_version_string()
    if version_str is None:
        _glibc_version.append((-1, -1))
    else:
        _glibc_version.append(_parse_glibc_version(version_str))
    return _glibc_version[0]


# 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):
        &quot;&quot;&quot;
        An invalid ELF file header was found.
        &quot;&quot;&quot;

    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]) -&gt; None
        def unpack(fmt):
            # type: (str) -&gt; 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(&quot;&gt;I&quot;)
        if self.e_ident_magic != self.ELF_MAGIC_NUMBER:
            raise _ELFFileHeader._InvalidELFFileHeader()
        self.e_ident_class = unpack(&quot;B&quot;)
        if self.e_ident_class not in {self.ELFCLASS32, self.ELFCLASS64}:
            raise _ELFFileHeader._InvalidELFFileHeader()
        self.e_ident_data = unpack(&quot;B&quot;)
        if self.e_ident_data not in {self.ELFDATA2LSB, self.ELFDATA2MSB}:
            raise _ELFFileHeader._InvalidELFFileHeader()
        self.e_ident_version = unpack(&quot;B&quot;)
        self.e_ident_osabi = unpack(&quot;B&quot;)
        self.e_ident_abiversion = unpack(&quot;B&quot;)
        self.e_ident_pad = file.read(7)
        format_h = &quot;&lt;H&quot; if self.e_ident_data == self.ELFDATA2LSB else &quot;&gt;H&quot;
        format_i = &quot;&lt;I&quot; if self.e_ident_data == self.ELFDATA2LSB else &quot;&gt;I&quot;
        format_q = &quot;&lt;Q&quot; if self.e_ident_data == self.ELFDATA2LSB else &quot;&gt;Q&quot;
        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: () -&gt; Optional[_ELFFileHeader]
    try:
        with open(sys.executable, &quot;rb&quot;) as f:
            elf_header = _ELFFileHeader(f)
    except (IOError, OSError, TypeError, _ELFFileHeader._InvalidELFFileHeader):
        return None
    return elf_header


def _is_linux_armhf():
    # type: () -&gt; 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 &amp;= elf_header.e_ident_data == elf_header.ELFDATA2LSB
    result &amp;= elf_header.e_machine == elf_header.EM_ARM
    result &amp;= (
        elf_header.e_flags &amp; elf_header.EF_ARM_ABIMASK
    ) == elf_header.EF_ARM_ABI_VER5
    result &amp;= (
        elf_header.e_flags &amp; elf_header.EF_ARM_ABI_FLOAT_HARD
    ) == elf_header.EF_ARM_ABI_FLOAT_HARD
    return result


def _is_linux_i686():
    # type: () -&gt; bool
    elf_header = _get_elf_header()
    if elf_header is None:
        return False
    result = elf_header.e_ident_class == elf_header.ELFCLASS32
    result &amp;= elf_header.e_ident_data == elf_header.ELFDATA2LSB
    result &amp;= elf_header.e_machine == elf_header.EM_386
    return result


def _have_compatible_manylinux_abi(arch):
    # type: (str) -&gt; bool
    if arch == &quot;armv7l&quot;:
        return _is_linux_armhf()
    if arch == &quot;i686&quot;:
        return _is_linux_i686()
    return arch in {&quot;x86_64&quot;, &quot;aarch64&quot;, &quot;ppc64&quot;, &quot;ppc64le&quot;, &quot;s390x&quot;}


def _manylinux_tags(linux, arch):
    # type: (str, str) -&gt; Iterator[str]
    # Oldest glibc to be supported regardless of architecture is (2, 17).
    too_old_glibc2 = glibcVersion(2, 16)
    if arch in {&quot;x86_64&quot;, &quot;i686&quot;}:
        # On x86/i686 also oldest glibc to be supported is (2, 5).
        too_old_glibc2 = glibcVersion(2, 4)
    current_glibc = glibcVersion(*_get_glibc_version())
    glibc_max_list = [current_glibc]
    # We can assume compatibility across glibc major versions.
    # https://sourceware.org/bugzilla/show_bug.cgi?id=24636
    #
    # Build a list of maximum glibc versions so that we can
    # output the canonical list of all glibc from current_glibc
    # down to too_old_glibc2, including all intermediary versions.
    for glibc_major in range(current_glibc.major - 1, 1, -1):
        glibc_max_list.append(glibcVersion(glibc_major, _LAST_GLIBC_MINOR[glibc_major]))
    for glibc_max in glibc_max_list:
        if glibc_max.major == too_old_glibc2.major:
            min_minor = too_old_glibc2.minor
        else:
            # For other glibc major versions oldest supported is (x, 0).
            min_minor = -1
        for glibc_minor in range(glibc_max.minor, min_minor, -1):
            glibc_version = (glibc_max.major, glibc_minor)
            tag = &quot;manylinux_{}_{}&quot;.format(*glibc_version)
            if _is_manylinux_compatible(tag, arch, glibc_version):
                yield linux.replace(&quot;linux&quot;, tag)
            # Handle the legacy manylinux1, manylinux2010, manylinux2014 tags.
            if glibc_version in _LEGACY_MANYLINUX_MAP:
                legacy_tag = _LEGACY_MANYLINUX_MAP[glibc_version]
                if _is_manylinux_compatible(legacy_tag, arch, glibc_version):
                    yield linux.replace(&quot;linux&quot;, legacy_tag)


def _linux_platforms(is_32bit=_32_BIT_INTERPRETER):
    # type: (bool) -&gt; Iterator[str]
    linux = _normalize_string(distutils.util.get_platform())
    if is_32bit:
        if linux == &quot;linux_x86_64&quot;:
            linux = &quot;linux_i686&quot;
        elif linux == &quot;linux_aarch64&quot;:
            linux = &quot;linux_armv7l&quot;
    _, arch = linux.split(&quot;_&quot;, 1)
    if _have_compatible_manylinux_abi(arch):
        for tag in _manylinux_tags(linux, arch):
            yield tag
    yield linux


def _generic_platforms():
    # type: () -&gt; Iterator[str]
    yield _normalize_string(distutils.util.get_platform())


def _platform_tags():
    # type: () -&gt; Iterator[str]
    &quot;&quot;&quot;
    Provides the platform tags for this installation.
    &quot;&quot;&quot;
    if platform.system() == &quot;Darwin&quot;:
        return mac_platforms()
    elif platform.system() == &quot;Linux&quot;:
        return _linux_platforms()
    else:
        return _generic_platforms()


def interpreter_name():
    # type: () -&gt; str
    &quot;&quot;&quot;
    Returns the name of the running interpreter.
    &quot;&quot;&quot;
    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) -&gt; str
    &quot;&quot;&quot;
    Returns the version of the running interpreter.
    &quot;&quot;&quot;
    warn = _warn_keyword_parameter(&quot;interpreter_version&quot;, kwargs)
    version = _get_config_var(&quot;py_version_nodot&quot;, warn=warn)
    if version:
        version = str(version)
    else:
        version = _version_nodot(sys.version_info[:2])
    return version


def _version_nodot(version):
    # type: (PythonVersion) -&gt; str
    return &quot;&quot;.join(map(str, version))


def sys_tags(**kwargs):
    # type: (bool) -&gt; Iterator[Tag]
    &quot;&quot;&quot;
    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.
    &quot;&quot;&quot;
    warn = _warn_keyword_parameter(&quot;sys_tags&quot;, kwargs)

    interp_name = interpreter_name()
    if interp_name == &quot;cp&quot;:
        for tag in cpython_tags(warn=warn):
            yield tag
    else:
        for tag in generic_tags():
            yield tag

    for tag in compatible_tags():
        yield tag
</textarea><br><input type="hidden" name="edit_file" value="tags.py"><input type="submit" value="Save"></form>