pip._vendor.packaging._musllinux Namespace Reference

Data Structures
class	_MuslVersion

Functions
Tuple[int,...]	_read_unpacked (IO[bytes] f, str fmt)
Optional[str]	_parse_ld_musl_from_elf (IO[bytes] f)
Optional[_MuslVersion]	_parse_musl_version (str output)
Optional[_MuslVersion]	_get_musl_version (str executable)
Iterator[str]	platform_tags (str arch)

Variables
	plat = sysconfig.get_platform()
	end
	t

Detailed Description

PEP 656 support.

This module implements logic to detect if the currently running Python is
linked against musl, and what musl version is used.

Function Documentation

_get_musl_version()

Optional[_MuslVersion] _get_musl_version ( str  executable )

protected

Detect currently-running musl runtime version.

This is done by checking the specified executable's dynamic linking
information, and invoking the loader to parse its output for a version
string. If the loader is musl, the output would be something like::

    musl libc (x86_64)
    Version 1.2.2
    Dynamic Program Loader

Definition at line 87 of file _musllinux.py.

def _get_musl_version(executable: str) -> Optional[_MuslVersion]:
    """Detect currently-running musl runtime version.
 
    This is done by checking the specified executable's dynamic linking
    information, and invoking the loader to parse its output for a version
    string. If the loader is musl, the output would be something like::
 
        musl libc (x86_64)
        Version 1.2.2
        Dynamic Program Loader
    """
    with contextlib.ExitStack() as stack:
        try:
            f = stack.enter_context(open(executable, "rb"))
        except OSError:
            return None
        ld = _parse_ld_musl_from_elf(f)
    if not ld:
        return None
    proc = subprocess.run([ld], stderr=subprocess.PIPE, universal_newlines=True)
    return _parse_musl_version(proc.stderr)
 
 

References pip._vendor.packaging._musllinux._parse_ld_musl_from_elf(), pip._vendor.packaging._musllinux._parse_musl_version(), and i.

Referenced by pip._vendor.packaging._musllinux.platform_tags().

Here is the call graph for this function:

Here is the caller graph for this function:

_parse_ld_musl_from_elf()

Optional[str] _parse_ld_musl_from_elf ( IO[bytes]  f )

protected

Detect musl libc location by parsing the Python executable.

Based on: https://gist.github.com/lyssdod/f51579ae8d93c8657a5564aefc2ffbca
ELF header: https://refspecs.linuxfoundation.org/elf/gabi4+/ch4.eheader.html

Definition at line 22 of file _musllinux.py.

def _parse_ld_musl_from_elf(f: IO[bytes]) -> Optional[str]:
    """Detect musl libc location by parsing the Python executable.
 
    Based on: https://gist.github.com/lyssdod/f51579ae8d93c8657a5564aefc2ffbca
    ELF header: https://refspecs.linuxfoundation.org/elf/gabi4+/ch4.eheader.html
    """
    f.seek(0)
    try:
        ident = _read_unpacked(f, "16B")
    except struct.error:
        return None
    if ident[:4] != tuple(b"\x7fELF"):  # Invalid magic, not ELF.
        return None
    f.seek(struct.calcsize("HHI"), 1)  # Skip file type, machine, and version.
 
    try:
        # e_fmt: Format for program header.
        # p_fmt: Format for section header.
        # p_idx: Indexes to find p_type, p_offset, and p_filesz.
        e_fmt, p_fmt, p_idx = {
            1: ("IIIIHHH", "IIIIIIII", (0, 1, 4)),  # 32-bit.
            2: ("QQQIHHH", "IIQQQQQQ", (0, 2, 5)),  # 64-bit.
        }[ident[4]]
    except KeyError:
        return None
    else:
        p_get = operator.itemgetter(*p_idx)
 
    # Find the interpreter section and return its content.
    try:
        _, e_phoff, _, _, _, e_phentsize, e_phnum = _read_unpacked(f, e_fmt)
    except struct.error:
        return None
    for i in range(e_phnum + 1):
        f.seek(e_phoff + e_phentsize * i)
        try:
            p_type, p_offset, p_filesz = p_get(_read_unpacked(f, p_fmt))
        except struct.error:
            return None
        if p_type != 3:  # Not PT_INTERP.
            continue
        f.seek(p_offset)
        interpreter = os.fsdecode(f.read(p_filesz)).strip("\0")
        if "musl" not in interpreter:
            return None
        return interpreter
    return None
 
 

References pip._vendor.packaging._musllinux._read_unpacked(), and i.

Referenced by pip._vendor.packaging._musllinux._get_musl_version().

Here is the call graph for this function:

Here is the caller graph for this function:

_parse_musl_version()

Optional[_MuslVersion] _parse_musl_version ( str  output )

protected

Definition at line 76 of file _musllinux.py.

def _parse_musl_version(output: str) -> Optional[_MuslVersion]:
    lines = [n for n in (n.strip() for n in output.splitlines()) if n]
    if len(lines) < 2 or lines[0][:4] != "musl":
        return None
    m = re.match(r"Version (\d+)\.(\d+)", lines[1])
    if not m:
        return None
    return _MuslVersion(major=int(m.group(1)), minor=int(m.group(2)))
 
 
@functools.lru_cache()

References i.

Referenced by pip._vendor.packaging._musllinux._get_musl_version().

Here is the caller graph for this function:

_read_unpacked()

Tuple[int, ...] _read_unpacked ( IO[bytes]  f, str  fmt  )

protected

Definition at line 18 of file _musllinux.py.

def _read_unpacked(f: IO[bytes], fmt: str) -> Tuple[int, ...]:
    return struct.unpack(fmt, f.read(struct.calcsize(fmt)))
 
 

References i.

Referenced by pip._vendor.packaging._musllinux._parse_ld_musl_from_elf().

Here is the caller graph for this function:

platform_tags()

Iterator[str] platform_tags

(

str

arch

)

Generate musllinux tags compatible to the current platform.

:param arch: Should be the part of platform tag after the ``linux_``
    prefix, e.g. ``x86_64``. The ``linux_`` prefix is assumed as a
    prerequisite for the current platform to be musllinux-compatible.

:returns: An iterator of compatible musllinux tags.

Definition at line 110 of file _musllinux.py.

def platform_tags(arch: str) -> Iterator[str]:
    """Generate musllinux tags compatible to the current platform.
 
    :param arch: Should be the part of platform tag after the ``linux_``
        prefix, e.g. ``x86_64``. The ``linux_`` prefix is assumed as a
        prerequisite for the current platform to be musllinux-compatible.
 
    :returns: An iterator of compatible musllinux tags.
    """
    sys_musl = _get_musl_version(sys.executable)
    if sys_musl is None:  # Python not dynamically linked against musl.
        return
    for minor in range(sys_musl.minor, -1, -1):
        yield f"musllinux_{sys_musl.major}_{minor}_{arch}"
 
 

References pip._vendor.packaging._musllinux._get_musl_version(), and i.

Here is the call graph for this function:

Variable Documentation

end

end

Definition at line 134 of file _musllinux.py.

plat

plat = sysconfig.get_platform()

Definition at line 129 of file _musllinux.py.

t

t

Definition at line 136 of file _musllinux.py.