pbs-installer 2024.2.26__tar.gz → 2024.3.23__tar.gz

{pbs_installer-2024.2.26 → pbs_installer-2024.3.23}/PKG-INFO

@@ -1,14 +1,14 @@
 Metadata-Version: 2.1
 Name: pbs-installer
-Version: 2024.2.26
+Version: 2024.3.23
 Summary: Installer for Python Build Standalone
 Author-Email: Frost Ming <me@frostming.com>
 License: MIT
-Requires-Python: >=3.7
+Requires-Python: >=3.8
 Provides-Extra: download
 Provides-Extra: install
 Provides-Extra: all
-Requires-Dist: requests>=2.24.0; extra == "download"
+Requires-Dist: httpx<1,>=0.27.0; extra == "download"
 Requires-Dist: zstandard>=0.21.0; extra == "install"
 Requires-Dist: pbs-installer[download,install]; extra == "all"
 Description-Content-Type: text/markdown
@@ -20,3 +20,5 @@ Description-Content-Type: text/markdown
 An installer for @indygreg's [python-build-standalone](https://github.com/indygreg/python-build-standalone)
 
 The list of python versions are kept sync with the upstream automatically, via a periodically GitHub Action.
+
+[📖 Read the docs](http://pbs-installer.readthedocs.io/)

{pbs_installer-2024.2.26 → pbs_installer-2024.3.23}/README.md

@@ -5,3 +5,5 @@
 An installer for @indygreg's [python-build-standalone](https://github.com/indygreg/python-build-standalone)
 
 The list of python versions are kept sync with the upstream automatically, via a periodically GitHub Action.
+
+[📖 Read the docs](http://pbs-installer.readthedocs.io/)

{pbs_installer-2024.2.26 → pbs_installer-2024.3.23}/pyproject.toml

@@ -4,18 +4,17 @@ description = "Installer for Python Build Standalone"
 authors = [
     { name = "Frost Ming", email = "me@frostming.com" },
 ]
-dependencies = []
-requires-python = ">=3.7"
+requires-python = ">=3.8"
 readme = "README.md"
 dynamic = []
-version = "2024.2.26"
+version = "2024.3.23"
 
 [project.license]
 text = "MIT"
 
 [project.optional-dependencies]
 download = [
-    "requests>=2.24.0",
+    "httpx<1,>=0.27.0",
 ]
 install = [
     "zstandard>=0.21.0",
@@ -33,25 +32,24 @@ requires = [
 ]
 build-backend = "pdm.backend"
 
-[tool.pdm.dev-dependencies]
-dev = [
-    "black>=23.3.0",
-]
-
 [tool.pdm.version]
 source = "scm"
 
 [tool.pdm.scripts.update]
 shell = "./scripts/update.sh"
 
-[tool.black]
-line-length = 100
-include = "\\.pyi?$"
-exclude = "/(\n    \\.eggs\n  | \\.git\n  | \\.hg\n  | \\.mypy_cache\n  | \\.tox\n  | \\.venv\n  | build\n  | dist\n  | src/pythonfinder/_vendor\n)\n"
+[tool.pdm.dev-dependencies]
+doc = [
+    "mkdocs>=1.5.3",
+    "mkdocs-material>=9.5.14",
+    "mkdocstrings[python]>=0.24",
+]
 
 [tool.ruff]
 line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
 extend-select = [
     "I",
 ]
-target-version = "py310"

{pbs_installer-2024.2.26 → pbs_installer-2024.3.23}/src/pbs_installer/__init__.py

@@ -1,8 +1,5 @@
 """
-Installer for Python Build Standalone
-
-Author: frostming
-License: MIT
+Core functions for the PBS Installer.
 """
 
 from ._install import download, get_download_link, install, install_file

{pbs_installer-2024.2.26 → pbs_installer-2024.3.23}/src/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-2024.3.23/src/pbs_installer/_install.py

@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+import hashlib
+import logging
+import os
+import tempfile
+from typing import TYPE_CHECKING, Tuple
+from urllib.parse import unquote
+
+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:
+    TOKEN = os.getenv("GITHUB_TOKEN")
+    if TOKEN is None:
+        return None
+    return {
+        "X-GitHub-Api-Version": "2022-11-28",
+        "Authorization": f"Bearer {TOKEN}",
+    }
+
+
+def get_download_link(
+    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
+
+    Examples:
+        >>> get_download_link("3.10", "x86_64", "linux")
+        (PythonVersion(kind='cpython', major=3, minor=10, micro=13),
+        'https://github.com/indygreg/python-build-standalone/releases/download/20240224/cpython-3.10.13%2B20240224-x86_64-unknown-linux-gnu-pgo%2Blto-full.tar.zst')
+    """
+    from ._versions import PYTHON_VERSIONS
+
+    for py_ver, urls in PYTHON_VERSIONS.items():
+        if not py_ver.matches(request, implementation):
+            continue
+
+        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(
+    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:
+        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
+    except ModuleNotFoundError:
+        raise RuntimeError("You must install httpx to use this function") from None
+
+    if client is None:
+        client = httpx.Client(trust_env=True, follow_redirects=True)
+
+    filename = unquote(url.rsplit("/")[-1])
+    hasher = hashlib.sha256()
+    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,
+    ):
+        resp.raise_for_status()
+        for chunk in resp.iter_bytes(chunk_size=8192):
+            if checksum:
+                hasher.update(chunk)
+            f.write(chunk)
+
+    if checksum and hasher.hexdigest() != checksum:
+        raise RuntimeError(f"Checksum mismatch. Expected {checksum}, got {hasher.hexdigest()}")
+    return filename
+
+
+def install_file(
+    filename: StrPath,
+    destination: StrPath,
+    original_filename: str | None = None,
+    build_dir: bool = False,
+) -> None:
+    """Unpack the downloaded file to the destination.
+
+    Note: Extras required
+        `pbs-installer[install]` must be installed to use this function.
+
+    Parameters:
+        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
+    """
+
+    from ._utils import unpack_tar, unpack_zip, unpack_zst
+
+    if original_filename is None:
+        original_filename = str(filename)
+    logger.debug(
+        "Extracting file %s to %s with original filename %s",
+        filename,
+        destination,
+        original_filename,
+    )
+    if original_filename.endswith(".zst"):
+        unpack_zst(filename, destination, build_dir)
+    elif original_filename.endswith(".zip"):
+        unpack_zip(filename, destination, build_dir)
+    else:
+        unpack_tar(filename, destination, build_dir)
+
+
+def install(
+    request: str,
+    destination: StrPath,
+    version_dir: bool = False,
+    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.
+
+    Note: Extras required
+        `pbs-installer[all]` must be installed to use this function.
+
+    Parameters:
+        request: The version of Python to install, e.g. 3.8,3.10.4
+        destination: The directory to install to
+        version_dir: Whether to install to a subdirectory named with the python version
+        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")
+        Installing cpython@3.10.4 to ./python
+        >>> install("3.10", "./python", version_dir=True)
+        Installing cpython@3.10.4 to ./python/cpython@3.10.4
+    """
+    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(python_file, tf.name, client)
+        install_file(tf.name, destination, original_filename, build_dir)

pbs_installer-2024.3.23/src/pbs_installer/_utils.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+import tarfile
+from typing import TYPE_CHECKING, NamedTuple
+
+if TYPE_CHECKING:
+    from _typeshed import StrPath
+
+ARCH_MAPPING = {
+    "arm64": "aarch64",
+    "amd64": "x86_64",
+    "i686": "x86",
+}
+PLATFORM_MAPPING = {"darwin": "macos"}
+
+
+class PythonVersion(NamedTuple):
+    implementation: str
+    major: int
+    minor: int
+    micro: int
+
+    def __str__(self) -> str:
+        return f"{self.implementation}@{self.major}.{self.minor}.{self.micro}"
+
+    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:
+            raise ValueError(
+                f"Invalid version: {request!r}, each part must be an integer"
+            ) from None
+
+        if len(parts) < 1:
+            raise ValueError("Version must have at least one part")
+
+        if parts[0] != self.major:
+            return False
+        if len(parts) > 1 and parts[1] != self.minor:
+            return False
+        if len(parts) > 2 and parts[2] != self.micro:
+            return False
+        return True
+
+
+def get_arch_platform() -> tuple[str, str]:
+    import platform
+
+    plat = platform.system().lower()
+    arch = platform.machine().lower()
+    return ARCH_MAPPING.get(arch, arch), PLATFORM_MAPPING.get(plat, plat)
+
+
+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():
+        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]]:
+    from ._versions import PYTHON_VERSIONS
+
+    archs: set[str] = set()
+    platforms: set[str] = set()
+    for items in PYTHON_VERSIONS.values():
+        for item in items:
+            platforms.add(item[0])
+            archs.add(item[1])
+    return sorted(archs), sorted(platforms)