mirror of
https://github.com/astral-sh/uv.git
synced 2025-07-08 05:45:00 +00:00
dd7da6af5f
Whew this is a lot. The user-facing changes are: - `uv toolchain` to `uv python` e.g. `uv python find`, `uv python install`, ... - `UV_TOOLCHAIN_DIR` to` UV_PYTHON_INSTALL_DIR` - `<UV_STATE_DIR>/toolchains` to `<UV_STATE_DIR>/python` (with [automatic migration](https://github.com/astral-sh/uv/pull/4735/files#r1663029330)) - User-facing messages no longer refer to toolchains, instead using "Python", "Python versions" or "Python installations" The internal changes are: - `uv-toolchain` crate to `uv-python` - `Toolchain` no longer referenced in type names - Dropped unused `SystemPython` type (previously replaced) - Clarified the type names for "managed Python installations" - (more little things)
85 lines
2.6 KiB
Python
85 lines
2.6 KiB
Python
"""PEP 656 support.
|
|
|
|
This module implements logic to detect if the currently running Python is
|
|
linked against musl, and what musl version is used.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import functools
|
|
import re
|
|
import subprocess
|
|
import sys
|
|
from typing import Iterator, NamedTuple, Sequence
|
|
|
|
from ._elffile import ELFFile
|
|
|
|
|
|
class _MuslVersion(NamedTuple):
|
|
major: int
|
|
minor: int
|
|
|
|
|
|
def _parse_musl_version(output: str) -> _MuslVersion | None:
|
|
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()
|
|
def _get_musl_version(executable: str) -> _MuslVersion | None:
|
|
"""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
|
|
"""
|
|
try:
|
|
with open(executable, "rb") as f:
|
|
ld = ELFFile(f).interpreter
|
|
except (OSError, TypeError, ValueError):
|
|
return None
|
|
if ld is None or "musl" not in ld:
|
|
return None
|
|
proc = subprocess.run([ld], stderr=subprocess.PIPE, text=True)
|
|
return _parse_musl_version(proc.stderr)
|
|
|
|
|
|
def platform_tags(archs: Sequence[str]) -> Iterator[str]:
|
|
"""Generate musllinux tags compatible to the current platform.
|
|
|
|
:param archs: Sequence of compatible architectures.
|
|
The first one shall be the closest to the actual architecture and 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 arch in archs:
|
|
for minor in range(sys_musl.minor, -1, -1):
|
|
yield f"musllinux_{sys_musl.major}_{minor}_{arch}"
|
|
|
|
|
|
if __name__ == "__main__": # pragma: no cover
|
|
import sysconfig
|
|
|
|
plat = sysconfig.get_platform()
|
|
assert plat.startswith("linux-"), "not linux"
|
|
|
|
print("plat:", plat)
|
|
print("musl:", _get_musl_version(sys.executable))
|
|
print("tags:", end=" ")
|
|
for t in platform_tags(re.sub(r"[.-]", "_", plat.split("-", 1)[-1])):
|
|
print(t, end="\n ")
|