<h2>Edit File: pep425tags.py</h2><form method="post"><textarea name="content" rows="20" cols="80">&quot;&quot;&quot;Generate and work with PEP 425 Compatibility Tags.&quot;&quot;&quot;
from __future__ import absolute_import

import re
import sys
import warnings
import platform
import logging

try:
    import sysconfig
except ImportError:  # pragma nocover
    # Python &lt; 2.7
    import distutils.sysconfig as sysconfig
import distutils.util

from pip.compat import OrderedDict
import pip.utils.glibc

logger = logging.getLogger(__name__)

_osx_arch_pat = re.compile(r&#039;(.+)_(\d+)_(\d+)_(.+)&#039;)


def get_config_var(var):
    try:
        return sysconfig.get_config_var(var)
    except IOError as e:  # Issue #1074
        warnings.warn(&quot;{0}&quot;.format(e), RuntimeWarning)
        return None


def get_abbr_impl():
    &quot;&quot;&quot;Return abbreviated implementation name.&quot;&quot;&quot;
    if hasattr(sys, &#039;pypy_version_info&#039;):
        pyimpl = &#039;pp&#039;
    elif sys.platform.startswith(&#039;java&#039;):
        pyimpl = &#039;jy&#039;
    elif sys.platform == &#039;cli&#039;:
        pyimpl = &#039;ip&#039;
    else:
        pyimpl = &#039;cp&#039;
    return pyimpl


def get_impl_ver():
    &quot;&quot;&quot;Return implementation version.&quot;&quot;&quot;
    impl_ver = get_config_var(&quot;py_version_nodot&quot;)
    if not impl_ver or get_abbr_impl() == &#039;pp&#039;:
        impl_ver = &#039;&#039;.join(map(str, get_impl_version_info()))
    return impl_ver


def get_impl_version_info():
    &quot;&quot;&quot;Return sys.version_info-like tuple for use in decrementing the minor
    version.&quot;&quot;&quot;
    if get_abbr_impl() == &#039;pp&#039;:
        # as per https://github.com/pypa/pip/issues/2882
        return (sys.version_info[0], sys.pypy_version_info.major,
                sys.pypy_version_info.minor)
    else:
        return sys.version_info[0], sys.version_info[1]


def get_impl_tag():
    &quot;&quot;&quot;
    Returns the Tag for this specific implementation.
    &quot;&quot;&quot;
    return &quot;{0}{1}&quot;.format(get_abbr_impl(), get_impl_ver())


def get_flag(var, fallback, expected=True, warn=True):
    &quot;&quot;&quot;Use a fallback method for determining SOABI flags if the needed config
    var is unset or unavailable.&quot;&quot;&quot;
    val = get_config_var(var)
    if val is None:
        if warn:
            logger.debug(&quot;Config variable &#039;%s&#039; is unset, Python ABI tag may &quot;
                         &quot;be incorrect&quot;, var)
        return fallback()
    return val == expected


def get_abi_tag():
    &quot;&quot;&quot;Return the ABI tag based on SOABI (if available) or emulate SOABI
    (CPython 2, PyPy).&quot;&quot;&quot;
    soabi = get_config_var(&#039;SOABI&#039;)
    impl = get_abbr_impl()
    if not soabi and impl in (&#039;cp&#039;, &#039;pp&#039;) and hasattr(sys, &#039;maxunicode&#039;):
        d = &#039;&#039;
        m = &#039;&#039;
        u = &#039;&#039;
        if get_flag(&#039;Py_DEBUG&#039;,
                    lambda: hasattr(sys, &#039;gettotalrefcount&#039;),
                    warn=(impl == &#039;cp&#039;)):
            d = &#039;d&#039;
        if get_flag(&#039;WITH_PYMALLOC&#039;,
                    lambda: impl == &#039;cp&#039;,
                    warn=(impl == &#039;cp&#039;)):
            m = &#039;m&#039;
        if get_flag(&#039;Py_UNICODE_SIZE&#039;,
                    lambda: sys.maxunicode == 0x10ffff,
                    expected=4,
                    warn=(impl == &#039;cp&#039; and
                          sys.version_info &lt; (3, 3))) \
                and sys.version_info &lt; (3, 3):
            u = &#039;u&#039;
        abi = &#039;%s%s%s%s%s&#039; % (impl, get_impl_ver(), d, m, u)
    elif soabi and soabi.startswith(&#039;cpython-&#039;):
        abi = &#039;cp&#039; + soabi.split(&#039;-&#039;)[1]
    elif soabi:
        abi = soabi.replace(&#039;.&#039;, &#039;_&#039;).replace(&#039;-&#039;, &#039;_&#039;)
    else:
        abi = None
    return abi


def _is_running_32bit():
    return sys.maxsize == 2147483647


def get_platform():
    &quot;&quot;&quot;Return our platform name &#039;win32&#039;, &#039;linux_x86_64&#039;&quot;&quot;&quot;
    if sys.platform == &#039;darwin&#039;:
        # distutils.util.get_platform() returns the release based on the value
        # of MACOSX_DEPLOYMENT_TARGET on which Python was built, which may
        # be significantly older than the user&#039;s current machine.
        release, _, machine = platform.mac_ver()
        split_ver = release.split(&#039;.&#039;)

        if machine == &quot;x86_64&quot; and _is_running_32bit():
            machine = &quot;i386&quot;
        elif machine == &quot;ppc64&quot; and _is_running_32bit():
            machine = &quot;ppc&quot;

        return &#039;macosx_{0}_{1}_{2}&#039;.format(split_ver[0], split_ver[1], machine)

    # XXX remove distutils dependency
    result = distutils.util.get_platform().replace(&#039;.&#039;, &#039;_&#039;).replace(&#039;-&#039;, &#039;_&#039;)
    if result == &quot;linux_x86_64&quot; and _is_running_32bit():
        # 32 bit Python program (running on a 64 bit Linux): pip should only
        # install and run 32 bit compiled extensions in that case.
        result = &quot;linux_i686&quot;

    return result


def is_manylinux1_compatible():
    # Only Linux, and only x86-64 / i686
    if get_platform() not in (&quot;linux_x86_64&quot;, &quot;linux_i686&quot;):
        return False

    # Check for presence of _manylinux module
    try:
        import _manylinux
        return bool(_manylinux.manylinux1_compatible)
    except (ImportError, AttributeError):
        # Fall through to heuristic check below
        pass

    # Check glibc version. CentOS 5 uses glibc 2.5.
    return pip.utils.glibc.have_compatible_glibc(2, 5)


def get_darwin_arches(major, minor, machine):
    &quot;&quot;&quot;Return a list of supported arches (including group arches) for
    the given major, minor and machine architecture of an macOS machine.
    &quot;&quot;&quot;
    arches = []

    def _supports_arch(major, minor, arch):
        # Looking at the application support for macOS versions in the chart
        # provided by https://en.wikipedia.org/wiki/OS_X#Versions it appears
        # our timeline looks roughly like:
        #
        # 10.0 - Introduces ppc support.
        # 10.4 - Introduces ppc64, i386, and x86_64 support, however the ppc64
        #        and x86_64 support is CLI only, and cannot be used for GUI
        #        applications.
        # 10.5 - Extends ppc64 and x86_64 support to cover GUI applications.
        # 10.6 - Drops support for ppc64
        # 10.7 - Drops support for ppc
        #
        # Given that we do not know if we&#039;re installing a CLI or a GUI
        # application, we must be conservative and assume it might be a GUI
        # application and behave as if ppc64 and x86_64 support did not occur
        # until 10.5.
        #
        # Note: The above information is taken from the &quot;Application support&quot;
        #       column in the chart not the &quot;Processor support&quot; since I believe
        #       that we care about what instruction sets an application can use
        #       not which processors the OS supports.
        if arch == &#039;ppc&#039;:
            return (major, minor) &lt;= (10, 5)
        if arch == &#039;ppc64&#039;:
            return (major, minor) == (10, 5)
        if arch == &#039;i386&#039;:
            return (major, minor) &gt;= (10, 4)
        if arch == &#039;x86_64&#039;:
            return (major, minor) &gt;= (10, 5)
        if arch in groups:
            for garch in groups[arch]:
                if _supports_arch(major, minor, garch):
                    return True
        return False

    groups = OrderedDict([
        (&quot;fat&quot;, (&quot;i386&quot;, &quot;ppc&quot;)),
        (&quot;intel&quot;, (&quot;x86_64&quot;, &quot;i386&quot;)),
        (&quot;fat64&quot;, (&quot;x86_64&quot;, &quot;ppc64&quot;)),
        (&quot;fat32&quot;, (&quot;x86_64&quot;, &quot;i386&quot;, &quot;ppc&quot;)),
    ])

    if _supports_arch(major, minor, machine):
        arches.append(machine)

    for garch in groups:
        if machine in groups[garch] and _supports_arch(major, minor, garch):
            arches.append(garch)

    arches.append(&#039;universal&#039;)

    return arches


def get_supported(versions=None, noarch=False, platform=None,
                  impl=None, abi=None):
    &quot;&quot;&quot;Return a list of supported tags for each version specified in
    `versions`.

    :param versions: a list of string versions, of the form [&quot;33&quot;, &quot;32&quot;],
        or None. The first version will be assumed to support our ABI.
    :param platform: specify the exact platform you want valid
        tags for, or None. If None, use the local system platform.
    :param impl: specify the exact implementation you want valid
        tags for, or None. If None, use the local interpreter impl.
    :param abi: specify the exact abi you want valid
        tags for, or None. If None, use the local interpreter abi.
    &quot;&quot;&quot;
    supported = []

    # Versions must be given with respect to the preference
    if versions is None:
        versions = []
        version_info = get_impl_version_info()
        major = version_info[:-1]
        # Support all previous minor Python versions.
        for minor in range(version_info[-1], -1, -1):
            versions.append(&#039;&#039;.join(map(str, major + (minor,))))

    impl = impl or get_abbr_impl()

    abis = []

    abi = abi or get_abi_tag()
    if abi:
        abis[0:0] = [abi]

    abi3s = set()
    import imp
    for suffix in imp.get_suffixes():
        if suffix[0].startswith(&#039;.abi&#039;):
            abi3s.add(suffix[0].split(&#039;.&#039;, 2)[1])

    abis.extend(sorted(list(abi3s)))

    abis.append(&#039;none&#039;)

    if not noarch:
        arch = platform or get_platform()
        if arch.startswith(&#039;macosx&#039;):
            # support macosx-10.6-intel on macosx-10.9-x86_64
            match = _osx_arch_pat.match(arch)
            if match:
                name, major, minor, actual_arch = match.groups()
                tpl = &#039;{0}_{1}_%i_%s&#039;.format(name, major)
                arches = []
                for m in reversed(range(int(minor) + 1)):
                    for a in get_darwin_arches(int(major), m, actual_arch):
                        arches.append(tpl % (m, a))
            else:
                # arch pattern didn&#039;t match (?!)
                arches = [arch]
        elif platform is None and is_manylinux1_compatible():
            arches = [arch.replace(&#039;linux&#039;, &#039;manylinux1&#039;), arch]
        else:
            arches = [arch]

        # Current version, current API (built specifically for our Python):
        for abi in abis:
            for arch in arches:
                supported.append((&#039;%s%s&#039; % (impl, versions[0]), abi, arch))

        # abi3 modules compatible with older version of Python
        for version in versions[1:]:
            # abi3 was introduced in Python 3.2
            if version in (&#039;31&#039;, &#039;30&#039;):
                break
            for abi in abi3s:   # empty set if not Python 3
                for arch in arches:
                    supported.append((&quot;%s%s&quot; % (impl, version), abi, arch))

        # Has binaries, does not use the Python API:
        for arch in arches:
            supported.append((&#039;py%s&#039; % (versions[0][0]), &#039;none&#039;, arch))

    # No abi / arch, but requires our implementation:
    supported.append((&#039;%s%s&#039; % (impl, versions[0]), &#039;none&#039;, &#039;any&#039;))
    # Tagged specifically as being cross-version compatible
    # (with just the major version specified)
    supported.append((&#039;%s%s&#039; % (impl, versions[0][0]), &#039;none&#039;, &#039;any&#039;))

    # No abi / arch, generic Python
    for i, version in enumerate(versions):
        supported.append((&#039;py%s&#039; % (version,), &#039;none&#039;, &#039;any&#039;))
        if i == 0:
            supported.append((&#039;py%s&#039; % (version[0]), &#039;none&#039;, &#039;any&#039;))

    return supported

supported_tags = get_supported()
supported_tags_noarch = get_supported(noarch=True)

implementation_tag = get_impl_tag()
</textarea><br><input type="hidden" name="edit_file" value="pep425tags.py"><input type="submit" value="Save"></form>