pbs-installer 2024.3.22__py3-none-any.whl → 2024.3.23__py3-none-any.whl

pbs_installer/__main__.py

@@ -50,10 +50,15 @@ def main():
     archs, platforms = get_available_arch_platforms()
     parser = ArgumentParser("pbs-install", description="Installer for Python Build Standalone")
     install_group = parser.add_argument_group("Install Arguments")
-    install_group.add_argument("version", help="The version of Python to install, e.g. 3.8,3.10.4")
+    install_group.add_argument(
+        "version", help="The version of Python to install, e.g. 3.8, 3.10.4, pypy@3.10"
+    )
     install_group.add_argument(
         "--version-dir", help="Install to a subdirectory named by the version", action="store_true"
     )
+    install_group.add_argument(
+        "--build-dir", help="Include the build directory", action="store_true"
+    )
     install_group.add_argument(
         "-d", "--destination", help="The directory to install to", required=True
     )
@@ -66,12 +71,17 @@ def main():
 
     args = parser.parse_args()
     _setup_logger(args.verbose)
+    impl, has_amp, version = args.version.rpartition("@")
+    if not has_amp:
+        impl = "cpython"
     install(
-        args.version,
+        version,
         args.destination,
         version_dir=args.version_dir,
         arch=args.arch,
         platform=args.platform,
+        implementation=impl,
+        build_dir=args.build_dir,
     )
     print("Done!")
 

pbs_installer/_install.py

@@ -4,18 +4,18 @@ import hashlib
 import logging
 import os
 import tempfile
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Tuple
 from urllib.parse import unquote
 
-from ._utils import PythonVersion, get_arch_platform, unpack_tar
-
-logger = logging.getLogger(__name__)
+from ._utils import PythonVersion, get_arch_platform
 
 if TYPE_CHECKING:
     import httpx
     from _typeshed import StrPath
 
+logger = logging.getLogger(__name__)
 THIS_ARCH, THIS_PLATFORM = get_arch_platform()
+PythonFile = Tuple[str, str | None]
 
 
 def _get_headers() -> dict[str, str] | None:
@@ -29,14 +29,18 @@ def _get_headers() -> dict[str, str] | None:
 
 
 def get_download_link(
-    request: str, arch: str | None = None, platform: str | None = None
-) -> tuple[PythonVersion, str]:
+    request: str,
+    arch: str = THIS_ARCH,
+    platform: str = THIS_PLATFORM,
+    implementation: str = "cpython",
+) -> tuple[PythonVersion, PythonFile]:
     """Get the download URL matching the given requested version.
 
     Parameters:
         request: The version of Python to install, e.g. 3.8,3.10.4
         arch: The architecture to install, e.g. x86_64, arm64
         platform: The platform to install, e.g. linux, macos
+        implementation: The implementation of Python to install, allowed values are 'cpython' and 'pypy'
 
     Returns:
         A tuple of the PythonVersion and the download URL
@@ -48,47 +52,35 @@ def get_download_link(
     """
     from ._versions import PYTHON_VERSIONS
 
-    if arch is None:
-        arch = THIS_ARCH
-    if platform is None:
-        platform = THIS_PLATFORM
-
     for py_ver, urls in PYTHON_VERSIONS.items():
-        if not py_ver.matches(request):
+        if not py_ver.matches(request, implementation):
             continue
 
-        for iarch, iplatform, url in urls:
-            logger.debug(
-                "Checking %s %s with requested system %s %s", iarch, iplatform, arch, platform
-            )
-            if (iarch, iplatform) == (arch, platform):
-                return py_ver, url
-        break
-    raise ValueError(f"Could not find a CPython {request!r} matching this system")
-
-
-def _read_sha256(url: str, client: httpx.Client) -> str | None:
-    resp = client.get(url + ".sha256", headers=_get_headers())
-    if not resp.is_success:
-        logger.warning("No checksum found for %s, this would be insecure", url)
-        return None
-    return resp.text.strip()
+        matched = urls.get((platform, arch))
+        if matched is not None:
+            return py_ver, matched
+    raise ValueError(
+        f"Could not find a version matching version={request!r}, implementation={implementation}"
+    )
 
 
-def download(url: str, destination: StrPath, client: httpx.Client | None = None) -> str:
+def download(
+    python_file: PythonFile, destination: StrPath, client: httpx.Client | None = None
+) -> str:
     """Download the given url to the destination.
 
     Note: Extras required
         `pbs-installer[download]` must be installed to use this function.
 
     Parameters:
-        url: The url to download
+        python_file: The (url, checksum) tuple to download
         destination: The file path to download to
         client: A http.Client to use for downloading, or None to create a new one
 
     Returns:
         The original filename of the downloaded file
     """
+    url, checksum = python_file
     logger.debug("Downloading url %s to %s", url, destination)
     try:
         import httpx
@@ -100,9 +92,13 @@ def download(url: str, destination: StrPath, client: httpx.Client | None = None)
 
     filename = unquote(url.rsplit("/")[-1])
     hasher = hashlib.sha256()
-    checksum = _read_sha256(url, client)
+    if not checksum:
+        logger.warning("No checksum found for %s, this would be insecure", url)
 
-    with open(destination, "wb") as f, client.stream("GET", url, headers=_get_headers()) as resp:
+    with (
+        open(destination, "wb") as f,
+        client.stream("GET", url, headers=_get_headers()) as resp,
+    ):
         resp.raise_for_status()
         for chunk in resp.iter_bytes(chunk_size=8192):
             if checksum:
@@ -115,7 +111,10 @@ def download(url: str, destination: StrPath, client: httpx.Client | None = None)
 
 
 def install_file(
-    filename: StrPath, destination: StrPath, original_filename: str | None = None
+    filename: StrPath,
+    destination: StrPath,
+    original_filename: str | None = None,
+    build_dir: bool = False,
 ) -> None:
     """Unpack the downloaded file to the destination.
 
@@ -126,11 +125,10 @@ def install_file(
         filename: The file to unpack
         destination: The directory to unpack to
         original_filename: The original filename of the file, if it was renamed
+        build_dir: Whether to include the `build/` directory from indygreg builds
     """
 
-    import tarfile
-
-    import zstandard as zstd
+    from ._utils import unpack_tar, unpack_zip, unpack_zst
 
     if original_filename is None:
         original_filename = str(filename)
@@ -141,17 +139,11 @@ def install_file(
         original_filename,
     )
     if original_filename.endswith(".zst"):
-        dctx = zstd.ZstdDecompressor()
-        with tempfile.TemporaryFile(suffix=".tar") as ofh:
-            with open(filename, "rb") as ifh:
-                dctx.copy_stream(ifh, ofh)
-            ofh.seek(0)
-            with tarfile.open(fileobj=ofh) as z:
-                unpack_tar(z, destination, 1)
-
+        unpack_zst(filename, destination, build_dir)
+    elif original_filename.endswith(".zip"):
+        unpack_zip(filename, destination, build_dir)
     else:
-        with tarfile.open(filename) as z:
-            unpack_tar(z, destination, 1)
+        unpack_tar(filename, destination, build_dir)
 
 
 def install(
@@ -161,6 +153,8 @@ def install(
     client: httpx.Client | None = None,
     arch: str | None = None,
     platform: str | None = None,
+    implementation: str = "cpython",
+    build_dir: bool = False,
 ) -> None:
     """Download and install the requested python version.
 
@@ -174,6 +168,8 @@ def install(
         client: A httpx.Client to use for downloading
         arch: The architecture to install, e.g. x86_64, arm64
         platform: The platform to install, e.g. linux, macos
+        implementation: The implementation of Python to install, allowed values are 'cpython' and 'pypy'
+        build_dir: Whether to include the `build/` directory from indygreg builds
 
     Examples:
         >>> install("3.10", "./python")
@@ -181,12 +177,19 @@ def install(
         >>> install("3.10", "./python", version_dir=True)
         Installing cpython@3.10.4 to ./python/cpython@3.10.4
     """
-    ver, url = get_download_link(request, arch=arch, platform=platform)
+    if platform is None:
+        platform = THIS_PLATFORM
+    if arch is None:
+        arch = THIS_ARCH
+
+    ver, python_file = get_download_link(
+        request, arch=arch, platform=platform, implementation=implementation
+    )
     if version_dir:
         destination = os.path.join(destination, str(ver))
     logger.debug("Installing %s to %s", ver, destination)
     os.makedirs(destination, exist_ok=True)
     with tempfile.NamedTemporaryFile() as tf:
         tf.close()
-        original_filename = download(url, tf.name, client)
-        install_file(tf.name, destination, original_filename)
+        original_filename = download(python_file, tf.name, client)
+        install_file(tf.name, destination, original_filename, build_dir)

pbs_installer/_utils.py

@@ -7,21 +7,25 @@ if TYPE_CHECKING:
     from _typeshed import StrPath
 
 ARCH_MAPPING = {
-    "aarch64": "arm64",
+    "arm64": "aarch64",
     "amd64": "x86_64",
+    "i686": "x86",
 }
+PLATFORM_MAPPING = {"darwin": "macos"}
 
 
 class PythonVersion(NamedTuple):
-    kind: str
+    implementation: str
     major: int
     minor: int
     micro: int
 
     def __str__(self) -> str:
-        return f"{self.kind}@{self.major}.{self.minor}.{self.micro}"
+        return f"{self.implementation}@{self.major}.{self.minor}.{self.micro}"
 
-    def matches(self, request: str) -> bool:
+    def matches(self, request: str, implementation: str) -> bool:
+        if implementation != self.implementation:
+            return False
         try:
             parts = tuple(int(v) for v in request.split("."))
         except ValueError:
@@ -46,17 +50,68 @@ def get_arch_platform() -> tuple[str, str]:
 
     plat = platform.system().lower()
     arch = platform.machine().lower()
-    return ARCH_MAPPING.get(arch, arch), plat
+    return ARCH_MAPPING.get(arch, arch), PLATFORM_MAPPING.get(plat, plat)
 
 
-def unpack_tar(tf: tarfile.TarFile, destination: StrPath, skip_parts: int = 0) -> None:
+def _unpack_tar(tf: tarfile.TarFile, destination: StrPath, build_dir: bool = False) -> None:
     """Unpack the tarfile to the destination, with the first skip_parts parts of the path removed"""
+    members: list[tarfile.TarInfo] = []
+    has_build = any(
+        (p := fn.lstrip("/").split("/")) and len(p) > 1 and p[1] == "build" for fn in tf.getnames()
+    )
     for member in tf.getmembers():
-        fn = member.name.lstrip("/")
-        parts = fn.split("/")
-        fn = "/".join(parts[skip_parts:])
-        member.name = fn
-        tf.extract(member, destination)
+        parts = member.name.lstrip("/").split("/")
+        if build_dir or not has_build:
+            member.name = "/".join(parts[1:])
+        elif len(parts) > 1 and parts[1] == "install":
+            member.name = "/".join(parts[2:])
+        else:
+            continue
+        if member.name:
+            members.append(member)
+    tf.extractall(destination, members=members)
+
+
+def unpack_tar(filename: str, destination: StrPath, build_dir: bool = False) -> None:
+    """Unpack the tarfile to the destination"""
+    with tarfile.open(filename) as z:
+        _unpack_tar(z, destination, build_dir=build_dir)
+
+
+def unpack_zst(filename: str, destination: StrPath, build_dir: bool = False) -> None:
+    """Unpack the zstd compressed tarfile to the destination"""
+    import tempfile
+
+    import zstandard as zstd
+
+    dctx = zstd.ZstdDecompressor()
+    with tempfile.TemporaryFile(suffix=".tar") as ofh:
+        with open(filename, "rb") as ifh:
+            dctx.copy_stream(ifh, ofh)
+        ofh.seek(0)
+        with tarfile.open(fileobj=ofh) as z:
+            _unpack_tar(z, destination, build_dir=build_dir)
+
+
+def unpack_zip(filename: str, destination: StrPath, build_dir: bool = False) -> None:
+    """Unpack the zip file to the destination"""
+    import zipfile
+
+    with zipfile.ZipFile(filename) as z:
+        members: list[zipfile.ZipInfo] = []
+        has_build = any(fn.lstrip("/").split("/")[1] == "build" for fn in z.namelist())
+        for member in z.infolist():
+            parts = member.filename.lstrip("/").split("/")
+            if (build_dir or not has_build) and len(parts) > 1:
+                member.filename = "/".join(parts[1:])
+            elif len(parts) > 1 and parts[1] == "install":
+                member.filename = "/".join(parts[2:])
+            else:
+                continue
+            if member.filename:
+                members.append(member)
+
+        z.extractall(destination, members=members)
 
 
 def get_available_arch_platforms() -> tuple[list[str], list[str]]:
@@ -66,6 +121,6 @@ def get_available_arch_platforms() -> tuple[list[str], list[str]]:
     platforms: set[str] = set()
     for items in PYTHON_VERSIONS.values():
         for item in items:
-            archs.add(item[0])
-            platforms.add(item[1])
+            platforms.add(item[0])
+            archs.add(item[1])
     return sorted(archs), sorted(platforms)