uv-pack 0.0.1__py3-none-any.whl → 0.1.1__py3-none-any.whl

uv_pack/_download.py

@@ -1,158 +1,52 @@
-import os
-import platform
-import re
 from pathlib import Path
-from typing import Literal
-from urllib.parse import unquote
 
-import requests
-import typer
-from requests.adapters import HTTPAdapter
-from rich.console import Console
-from rich.progress import (
-    BarColumn,
-    DownloadColumn,
-    Progress,
-    SpinnerColumn,
-    TextColumn,
-    TimeRemainingColumn,
-    TransferSpeedColumn,
-)
-from urllib3.util.retry import Retry
+from packaging.utils import parse_wheel_filename
 
-LATEST_RELEASE_API = (
-    "https://api.github.com/repos/astral-sh/python-build-standalone/releases/latest"
-)
+from uv_pack._process import exit_on_error, run_cmd
 
 
-def find_latest_python_build(
-    python_version: str,
-    target_arch: str,
+def download_third_party_wheels(
     *,
-    target_format: Literal["install_only", "install_only_stripped"] = "install_only_stripped",
-    session: requests.Session | None = None,
-) -> str:
-    session = session or requests.Session()
-    release_api = os.getenv("UV_PYTHON_INSTALL_MIRROR", LATEST_RELEASE_API)
-
-    resp = session.get(release_api, timeout=10)
-    resp.raise_for_status()
-    release = resp.json()
-
-    py_pattern = re.compile(
-        rf"^cpython-{re.escape(python_version)}(\.\d+)?",
-        re.IGNORECASE,
-    )
-
-    for asset in release.get("assets", []):
-        name = asset["name"]
-        if (
-            py_pattern.search(name)
-            and target_arch in name
-            and name.endswith(f"{target_format}.tar.gz")
-        ):
-            return asset["browser_download_url"]
-
-    msg = f"No asset found for Python {python_version} on {target_arch}"
-    raise RuntimeError(msg)
-
-def download_with_progress(
-    url: str,
-    dest_dir: Path,
+    requirements_file: Path,
+    wheels_directory: Path,
+    other_args: str,
+) -> None:
+    wheels_directory.mkdir(parents=True, exist_ok=True)
+
+    cmd = [
+        "uv",
+        "run",
+        "--with",
+        "pip",
+        "python",
+        "-m",
+        "pip",
+        "download",
+        "--prefer-binary",
+        "--no-deps",
+        "--disable-pip-version-check",
+        "-r",
+        str(requirements_file),
+        "-d",
+        str(wheels_directory),
+    ]
+
+    cmd.extend(other_args.split())
+    exit_on_error(run_cmd(cmd, "pip download"))
+
+
+def determine_download_requirements(
     *,
-    filename: str | None = None,
-    console: Console | None = None,
-    session: requests.Session | None = None,
-) -> Path:
-    """Download a file with retries and a Rich progress bar.
-
-    Returns the final file path.
-    """
-    session = session or requests.Session()
-    console = console or Console()
-    dest_dir.mkdir(parents=True, exist_ok=True)
-
-    with session.get(url, stream=True, timeout=30) as resp:
-        resp.raise_for_status()
-        total = int(resp.headers.get("Content-Length", 0))
-        # try to get the filename from headers, otherwise fall back to the file name in the URL
-        filename = resp.headers.get("Content-Disposition", unquote(url.rsplit("/", 1)[-1])).split("filename=")[1]
-        final_path = dest_dir / filename
-        temp_path = final_path.with_suffix(final_path.suffix + ".part")
-
-        progress = Progress(
-            SpinnerColumn(),
-            TextColumn("{task.description}"),
-            BarColumn(),
-            DownloadColumn(),
-            TransferSpeedColumn(),
-            TimeRemainingColumn(),
-            console=console,
-        )
-
-        with progress:
-            task = progress.add_task(
-                "Downloading...",
-                total=total if total > 0 else None,
-            )
-
-            with temp_path.open("wb") as f:
-                for chunk in resp.iter_content(chunk_size=1024 * 64):
-                    if chunk:
-                        f.write(chunk)
-                        progress.update(task, advance=len(chunk))
-
-    temp_path.replace(final_path)
-    return final_path
-
-
-def session_with_retries() -> requests.Session:
-    session = requests.Session()
-    session.headers.update({
-        "User-Agent": "venv-pack-download",
-        "Accept": "application/vnd.github+json",
-    })
-
-    # authenticate to GitHub API to prevent rate-limiting
-    if token := os.getenv("GITHUB_TOKEN"):
-        session.headers["Authorization"] = f"Bearer {token}"
-
-    retries = Retry(
-        total=5,
-        connect=5,
-        read=5,
-        backoff_factor=0.5,
-        status_forcelist=(502, 503, 504),
-        allowed_methods=("GET",),
+    requirements_file: Path,
+    wheels_directory: Path,
+) -> None:
+    available_wheels: list[str] = []
+
+    for wheel in wheels_directory.glob("*.whl"):
+        name, version, *_ = parse_wheel_filename(wheel.name)
+        available_wheels.append(f"{name}=={version}")
+
+    requirements_file.write_text(
+        "\n".join(sorted(set(available_wheels))),
+        encoding="utf-8",
     )
-
-    adapter = HTTPAdapter(max_retries=retries)
-    session.mount("https://", adapter)
-    return session
-
-
-def resolve_platform(console: Console | None = None) -> str:
-    console = console or Console()
-    system = platform.system().lower()
-    machine = platform.machine().lower()
-
-    # Normalize architecture
-    arch_map = {
-        "x86_64": "x86_64",
-        "amd64": "x86_64",
-        "arm64": "aarch64",
-        "aarch64": "aarch64",
-    }
-    arch = arch_map.get(machine, machine)
-
-    if system == "windows":
-        return f"{arch}-pc-windows-msvc"
-
-    if system == "linux":
-        return f"{arch}-unknown-linux-gnu"
-
-    if system == "darwin":
-        return f"{arch}-apple-darwin"
-
-    console.print(f"[bold red]Found unsupported platform:[/bold red] {system}")
-    raise typer.Exit(code=1)

uv_pack/_export.py

@@ -0,0 +1,48 @@
+from pathlib import Path
+
+from uv_pack._process import exit_on_error, run_cmd
+
+
+def export_requirements(
+    *,
+    requirements_file: Path,
+    other_args: str,
+) -> None:
+    cmd = [
+        "uv",
+        "export",
+        "--quiet",
+        "--no-dev",
+        "--no-header",
+        "--no-hashes",
+        "--no-emit-local",
+        "--format=requirements.txt",
+        f"--output-file={requirements_file}",
+    ]
+
+    cmd.extend(other_args.split())
+    exit_on_error(run_cmd(cmd, "uv export"))
+
+
+def export_local_requirements(
+    *,
+    requirements_file: Path,
+    other_args: str,
+) -> None:
+    """Export only local packages to a plain requirements.txt file (each line is a local requirement path)."""
+    cmd = [
+        "uv",
+        "export",
+        "--quiet",
+        "--no-dev",
+        "--no-header",
+        "--no-hashes",
+        "--no-annotate",
+        "--no-editable",
+        "--only-emit-local",
+        "--format=requirements.txt",
+        f"--output-file={requirements_file}",
+    ]
+
+    cmd.extend(other_args.split())
+    exit_on_error(run_cmd(cmd, "uv export"))

uv_pack/_files.py

@@ -0,0 +1,56 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+__all__ = [
+    "PackLayout",
+]
+
+
+@dataclass(frozen=True, slots=True)
+class PackLayout:
+    """Layout of the output directory for a uv-pack."""
+
+    output_directory: Path
+    gitignore_file: Path
+    requirements_txt: Path
+    requirements_export_txt: Path
+    requirements_local_txt: Path
+    _wheels_dir: Path
+    _vendor_dir: Path
+    _python_dir: Path
+
+    @property
+    def wheels_dir(self) -> Path:
+        self._wheels_dir.mkdir(exist_ok=True)
+        return self._wheels_dir
+
+    @property
+    def vendor_dir(self) -> Path:
+        self._vendor_dir.mkdir(exist_ok=True)
+        return self._vendor_dir
+
+    @property
+    def python_dir(self) -> Path:
+        self._python_dir.mkdir(exist_ok=True)
+        return self._python_dir
+
+    @classmethod
+    def create(cls, output_directory: Path) -> "PackLayout":
+        output_directory.mkdir(parents=True, exist_ok=True)
+        wheels_dir = output_directory / "wheels"
+        vendor_dir = output_directory / "vendor"
+        python_dir = output_directory / "python"
+
+        gitignore_file = output_directory / ".gitignore"
+        gitignore_file.write_text("*", encoding="utf-8")
+
+        return cls(
+            output_directory,
+            gitignore_file=gitignore_file,
+            requirements_txt=output_directory / "requirements.txt",
+            requirements_export_txt=wheels_dir / "requirements.txt",
+            requirements_local_txt=vendor_dir / "requirements.txt",
+            _wheels_dir=wheels_dir,
+            _vendor_dir=vendor_dir,
+            _python_dir=python_dir,
+        )

uv_pack/_logging.py

@@ -0,0 +1,46 @@
+from enum import Enum
+from typing import Any
+
+from rich.console import Console
+from typer import Exit
+
+__all__ = [
+    "ConsoleError",
+    "Verbosity",
+    "console_print",
+    "set_verbosity",
+]
+
+console = Console(legacy_windows=False)
+
+
+class Verbosity(Enum):
+    quiet = 0
+    normal = 1
+    verbose = 2
+
+
+_internal_verbosity = Verbosity.normal
+
+
+def set_verbosity(mode: Verbosity) -> None:
+    """Globally set the verbosity level for console printing."""
+    global _internal_verbosity  # noqa: PLW0603
+    _internal_verbosity = mode
+
+
+def console_print(
+    *objects: Any,
+    level: Verbosity = Verbosity.normal,
+    **kwargs: Any,
+) -> None:
+    """Print to console if the current verbosity level is sufficient."""
+    if _internal_verbosity.value >= level.value:
+        console.print(*objects, **kwargs)
+
+
+class ConsoleError(Exit):
+    def __init__(self, *objects: Any, **kwargs: Any) -> None:
+        """Raise a user-friendly console error and print the message to the console."""
+        console.print(*objects, **kwargs)
+        super().__init__(code=1)

uv_pack/_process.py

@@ -1,16 +1,18 @@
 import subprocess
 import sys
+from collections.abc import Iterator
+from contextlib import contextmanager, nullcontext
 from dataclasses import dataclass
 
 import typer
-from rich.console import Console
 from rich.panel import Panel
 from rich.progress import Progress, SpinnerColumn, TextColumn
 
+from uv_pack._logging import console_print
+
 
 @dataclass(frozen=True)
 class CommandOutput:
-
     """Captured subprocess execution result."""
 
     name: str
@@ -18,19 +20,33 @@ class CommandOutput:
     stderr: str
     returncode: int
 
-def run_cmd(cmd: list[str], *, cmd_name: str) -> CommandOutput:
-    """Execute a subprocess command and capture output."""
-    with Progress(
-        SpinnerColumn(),
-        TextColumn("[progress.description]{task.description}"),
-    ) as progress:
-        progress.add_task(f"Running '{cmd_name}'...", total=None)
-        proc = subprocess.run(
-            cmd,
-            text=True,
-            capture_output=True,
-            check=False,
+
+@contextmanager
+def run_step(cmd_name: str, *, should_run: bool = True) -> Iterator[Progress | None]:
+    """Context manager to show a progress display during step execution."""
+    ctx = (
+        Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
         )
+        if should_run
+        else nullcontext()
+    )
+
+    with ctx as progress:
+        if progress is not None:
+            progress.add_task(f"Running '{cmd_name}'...", total=None)
+        yield progress
+
+
+def run_cmd(cmd: list[str], cmd_name: str) -> CommandOutput:
+    """Execute a subprocess command and capture output."""
+    proc = subprocess.run(
+        cmd,
+        text=True,
+        capture_output=True,
+        check=False,
+    )
     return CommandOutput(
         name=cmd_name,
         stdout=proc.stdout,
@@ -39,17 +55,17 @@ def run_cmd(cmd: list[str], *, cmd_name: str) -> CommandOutput:
     )
 
 
-def exit_on_error(result: CommandOutput, console: Console) -> None:
+def exit_on_error(result: CommandOutput) -> None:
     """Exit the CLI if a subprocess failed."""
     if result.returncode == 0:
         return
 
     if result.stderr:
         if sys.stderr.isatty():
-            console.print(
+            console_print(
                 Panel.fit(
                     result.stderr.rstrip(),
-                    title=f"[bold red]{result.name} failed[/bold red]",
+                    title=f"[bold red]✘ '{result.name}' failed[/bold red]",
                     border_style="red",
                 ),
             )

uv_pack/_python.py

@@ -0,0 +1,203 @@
+import os
+import platform
+import re
+import sys
+from pathlib import Path
+from typing import Literal
+from urllib.parse import unquote
+
+import requests
+from requests.adapters import HTTPAdapter
+from rich.console import Console
+from rich.progress import (
+    BarColumn,
+    DownloadColumn,
+    Progress,
+    SpinnerColumn,
+    TextColumn,
+    TimeRemainingColumn,
+    TransferSpeedColumn,
+)
+from urllib3.util.retry import Retry
+
+from uv_pack._logging import ConsoleError, Verbosity, console_print
+
+__all__ = [
+    "download_latest_python_build",
+]
+
+LATEST_RELEASE_API = (
+    "https://api.github.com/repos/astral-sh/python-build-standalone/releases/latest"
+)
+
+
+def download_latest_python_build(
+    *,
+    dest_dir: Path,
+    target_format: Literal[
+        "install_only",
+        "install_only_stripped",
+    ] = "install_only_stripped",
+) -> Path:
+    """Resolve and download the latest python-build-standalone artifact.
+
+    Returns the downloaded file path.
+    """
+    session = session_with_retries()
+    url = find_latest_python_build(
+        python_version=f"{sys.version_info.major}.{sys.version_info.minor}",
+        target_arch=resolve_platform(),
+        target_format=target_format,
+        session=session,
+    )
+    console_print(f"[dim]Resolved asset:[/dim] {url}", level=Verbosity.verbose)
+    return download_with_progress(
+        url=url,
+        dest_dir=dest_dir,
+        session=session,
+    )
+
+
+def find_latest_python_build(
+    python_version: str,
+    target_arch: str,
+    *,
+    target_format: Literal[
+        "install_only",
+        "install_only_stripped",
+    ] = "install_only_stripped",
+    session: requests.Session | None = None,
+) -> str:
+    session = session or requests.Session()
+    release_api = os.getenv("UV_PYTHON_INSTALL_MIRROR", LATEST_RELEASE_API)
+
+    resp = session.get(release_api, timeout=10)
+    resp.raise_for_status()
+    release = resp.json()
+
+    py_pattern = re.compile(
+        rf"^cpython-{re.escape(python_version)}(\.\d+)?",
+        re.IGNORECASE,
+    )
+
+    for asset in release.get("assets", []):
+        name = asset["name"]
+        if (
+            py_pattern.search(name)
+            and target_arch in name
+            and name.endswith(f"{target_format}.tar.gz")
+        ):
+            return asset["browser_download_url"]
+
+    msg = f"No asset found for Python {python_version} on {target_arch}"
+    raise RuntimeError(msg)
+
+
+def download_with_progress(
+    url: str,
+    dest_dir: Path,
+    *,
+    filename: str | None = None,
+    console: Console | None = None,
+    session: requests.Session | None = None,
+) -> Path:
+    """Download a file with retries and a Rich progress bar.
+
+    Returns the final file path.
+    """
+    session = session or requests.Session()
+    console = console or Console()
+    dest_dir.mkdir(parents=True, exist_ok=True)
+
+    with session.get(url, stream=True, timeout=30) as resp:
+        resp.raise_for_status()
+        total = int(resp.headers.get("Content-Length", 0))
+        # try to get the filename from headers, otherwise fall back to the file name in the URL
+        filename = resp.headers.get(
+            "Content-Disposition",
+            unquote(url.rsplit("/", 1)[-1]),
+        ).split("filename=")[1]
+        final_path = dest_dir / filename
+        temp_path = final_path.with_suffix(final_path.suffix + ".part")
+
+        # shortcut if the file already exists
+        if final_path.is_file():
+            console_print(f"[dim]Using cached file:[/dim] {final_path}")
+            return final_path
+
+        progress = Progress(
+            SpinnerColumn(),
+            TextColumn("{task.description}"),
+            BarColumn(),
+            DownloadColumn(),
+            TransferSpeedColumn(),
+            TimeRemainingColumn(),
+            console=console,
+        )
+
+        with progress:
+            task = progress.add_task(
+                "Running 'python'...",
+                total=total if total > 0 else None,
+            )
+            with temp_path.open("wb") as f:
+                for chunk in resp.iter_content(chunk_size=1024 * 64):
+                    if chunk:
+                        f.write(chunk)
+                        progress.update(task, advance=len(chunk))
+
+    temp_path.replace(final_path)
+    return final_path
+
+
+def session_with_retries() -> requests.Session:
+    session = requests.Session()
+    session.headers.update(
+        {
+            "User-Agent": "venv-pack-download",
+            "Accept": "application/vnd.github+json",
+        },
+    )
+
+    # authenticate to GitHub API to prevent rate-limiting
+    if token := os.getenv("GITHUB_TOKEN"):
+        session.headers["Authorization"] = f"Bearer {token}"
+
+    retries = Retry(
+        total=5,
+        connect=5,
+        read=5,
+        backoff_factor=0.5,
+        status_forcelist=(502, 503, 504),
+        allowed_methods=("GET",),
+    )
+
+    adapter = HTTPAdapter(max_retries=retries)
+    session.mount("https://", adapter)
+    return session
+
+
+def resolve_platform() -> str:
+    system = platform.system().lower()
+    machine = platform.machine().lower()
+
+    # Normalize architecture
+    arch_map = {
+        "x86_64": "x86_64",
+        "amd64": "x86_64",
+        "arm64": "aarch64",
+        "aarch64": "aarch64",
+    }
+    arch = arch_map.get(machine, machine)
+
+    if system == "windows":
+        return f"{arch}-pc-windows-msvc"
+
+    if system == "linux":
+        return f"{arch}-unknown-linux-gnu"
+
+    if system == "darwin":
+        return f"{arch}-apple-darwin"
+
+    msg = f"[bold red]✘ Found unsupported platform:[/bold red] {system}"
+    raise ConsoleError(msg)

uv_pack/{_unpack.py → _scripts.py}

@@ -5,6 +5,10 @@ import stat
 from importlib.resources import files
 from pathlib import Path
 
+__all__ = [
+    "copy_unpack_scripts",
+]
+
 
 def copy_unpack_scripts(
     *,
@@ -12,16 +16,29 @@ def copy_unpack_scripts(
 ) -> None:
     """Write unpack scripts into the pack directory."""
     scripts_dir = files("uv_pack") / "scripts"
-    copy_file = lambda src: shutil.copyfile(str(src), str(output_directory / src.name)) # noqa: E731 # type: ignore
+    copy_file = lambda src, force_lf=False: _copy_file(src, output_directory, force_lf=force_lf)  # type: ignore
 
     output_directory.mkdir(parents=True, exist_ok=True)
-    copy_file(scripts_dir / "unpack.sh")
+    copy_file(scripts_dir / "unpack.sh", force_lf=True)
     copy_file(scripts_dir / "unpack.ps1")
     copy_file(scripts_dir / "unpack.cmd")
     copy_file(scripts_dir / "README.md")
     _make_executable(output_directory / "unpack.sh")
 
 
+def _copy_file(src: Path, dst_dir: Path, *, force_lf: bool = False) -> None:
+    """Copy a file from src to dst_dir, optionally normalizing line endings to LF."""
+    dst = dst_dir / src.name
+
+    if force_lf:
+        # Normalize line endings to LF regardless of how Git stored it
+        data = src.read_bytes()
+        data = data.replace(b"\r\n", b"\n")
+        dst.write_bytes(data)
+    else:
+        shutil.copyfile(str(src), str(dst))
+
+
 def _make_executable(path: Path) -> None:
     """Best-effort make a script executable (POSIX)."""
     try: