| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257 |
- """Build/CI operations with caller-owned inputs, independent of live selection."""
- from __future__ import annotations
- from collections.abc import Mapping, Sequence
- from dataclasses import dataclass
- from pathlib import Path
- import sys
- import time
- from types import MappingProxyType
- from pm.filesystem import long_root, native
- from pm.install import InstalledPackage
- from pm.lock import Lockfile
- from pm.package import InstallError
- def check_project_lock(
- source: Path, *, python: Path | None = None, cache: Path | None = None,
- env: Mapping[str, str] | None = None, offline: bool = False, explicit: bool = False,
- quiet: bool = False,
- ) -> None:
- """Reject a missing or stale lock without rewriting source or creating a venv.
- ``quiet`` captures uv's output instead of reporting it: for a caller that
- expects a stale lock and says so itself, the red failure tail is noise.
- The error still carries uv's message.
- """
- from pm.environment import managed_environment
- from pm.operations import _require_install_allowed
- if not offline:
- _require_install_allowed(explicit)
- source = Path(source).absolute()
- if not (source / "pyproject.toml").is_file():
- raise InstallError("venv", f"project manifest is missing: {source}")
- environment = managed_environment(
- source / ".venv", python=Path(python) if python is not None else None,
- cache=Path(cache) if cache is not None else None, env=env,
- offline=offline, explicit=explicit, output=None if quiet else sys.stderr,
- )
- environment.check_lock(source)
- def export_requirements(
- source: Path, out: Path, *, extras: Sequence[str] = (), python: Path | None = None,
- cache: Path | None = None, env: Mapping[str, str] | None = None, explicit: bool = False,
- ) -> None:
- """Export locked runtime requirements, preserving markers and direct URL pins."""
- from pm.environment import managed_environment
- from pm.operations import _require_install_allowed
- _require_install_allowed(explicit)
- source, out = Path(source).absolute(), Path(out).absolute()
- if not (source / "pyproject.toml").is_file():
- raise InstallError("venv", f"project manifest is missing: {source}")
- if not (source / "uv.lock").is_file():
- raise InstallError("venv", f"frozen export requires a lock: {source / 'uv.lock'}")
- environment = managed_environment(
- source / ".venv", python=Path(python) if python is not None else None,
- cache=Path(cache) if cache is not None else None, env=env,
- explicit=explicit, output=sys.stderr,
- )
- out.parent.mkdir(parents=True, exist_ok=True)
- environment.export_requirements(source, out, extras=extras)
- def build_requirements_environment(
- requirements: Sequence[str], *, out: Path, python: Path | None = None,
- cache: Path | None = None, env: Mapping[str, str] | None = None,
- wheelhouse: Path | None = None, offline: bool = False, sealed: bool = False,
- explicit: bool = False, lock: Path | None = None,
- ) -> Path:
- """Create and check a fresh environment. Never mutate an existing destination.
- Wheelhouse builds disable indexes and source builds. Failure removes only
- this invocation's exclusively claimed output, not prior builds. *lock* is the
- uv.lock the requirements were exported from: its overrides apply to the
- install and the closing check.
- """
- from pm.environment import _fresh_build, managed_environment
- from pm.operations import _require_install_allowed, _requirements
- _require_install_allowed(explicit)
- requirements = _requirements(requirements) if requirements or isinstance(requirements, str) else []
- out = Path(out).absolute()
- lock = Path(lock).absolute() if lock is not None else None
- wheelhouse = Path(wheelhouse).absolute() if wheelhouse is not None else None
- if wheelhouse is not None and not wheelhouse.is_dir():
- raise InstallError("venv", f"wheelhouse directory is missing: {wheelhouse}")
- if out.exists() or out.is_symlink():
- raise FileExistsError(f"environment destination already exists: {out}")
- environment = managed_environment(
- out, python=Path(python) if python is not None else None,
- cache=Path(cache) if cache is not None else None, env=env,
- offline=offline, explicit=explicit, output=sys.stderr,
- )
- with _fresh_build(environment, sealed=sealed, lock=lock):
- environment.install_requirements(requirements, wheelhouse=wheelhouse, lock=lock)
- return environment.executable
- def prepare_tools(names: Sequence[str], *, out: Path, target: str,
- cache: Path | None = None) -> Path:
- """Realize an explicit tool closure in a build-owned store, not live state."""
- from pm.install import _install, _lockfile
- from pm.lock import Facts
- from pm.package import StatePackage
- from pm.registry import walk
- from pm.store import Store
- if isinstance(names, str):
- raise TypeError("names must be a sequence, not a string")
- packages = walk(list(names))
- if any(isinstance(package, StatePackage) for package in packages):
- raise ValueError("prepare_tools accepts tools, not application state")
- out = Path(out).resolve()
- store, lock = Store(out), _lockfile()
- with store.install_lock():
- facts = Facts(out / "facts.json", strict=True)
- for package in packages:
- _install(package, lock, facts, store, target, _lock_held=True)
- return out
- def _copy_links(package, entry: Path) -> None:
- import os
- from pm.filesystem import is_junction
- for directory, dirs, files in os.walk(entry):
- for name in dirs + files:
- path = Path(directory) / name
- if path.is_symlink() or is_junction(path):
- if (Path(os.readlink(path)).is_absolute() or not path.exists()
- or not path.resolve().is_relative_to(entry)):
- raise InstallError(package.name, f"tool copy link escapes entry: {native(path)}")
- @dataclass(frozen=True)
- class VerifiedTools:
- entries: Mapping[str, InstalledPackage]
- _envs: tuple[dict, ...]
- def environment(self, base: Mapping[str, str]) -> dict[str, str]:
- from pm.package import compose_env
- return compose_env(list(self._envs), base=dict(base))
- def verified_tools(names: Sequence[str], *, source_store: Path, target: str,
- lock: Lockfile | None = None) -> VerifiedTools:
- """Read a pinned tool closure without writes, acquisition or binary execution.
- Publication already ran package verification. Admission binds its recorded
- digest to the canonical entry, lock and declared environment; it does not
- rerun arbitrary version probes just to read a previously published tool.
- """
- from pm.install import _identity, _lockfile
- from pm.lock import Facts
- from pm.package import StatePackage
- from pm.registry import walk
- from pm.store import digest_matches
- if isinstance(names, str):
- raise TypeError("names must be a sequence, not a string")
- packages = walk(list(names))
- if any(isinstance(package, StatePackage) for package in packages):
- raise ValueError("verified_tools accepts tool packages, not application state")
- source_store = Path(source_store).resolve()
- if not (source_store / "facts.json").is_file():
- raise InstallError("tools", f"source facts missing: {source_store}")
- # Admission walks and digests whole tool trees: spell the root like Store does.
- source_store = long_root(source_store)
- facts = Facts(source_store / "facts.json", strict=True)
- lock = lock if lock is not None else _lockfile()
- entries, envs = {}, []
- for package in packages:
- if getattr(package, "pin_only", False):
- continue
- version = lock.version(package.name)
- identity = _identity(lock, package.name, target)
- if not version or identity is None:
- raise InstallError(package.name, "tool source failed verification: missing pin")
- fact = facts.get(package.name)
- expected = package.store_entry(version, target)
- entry = source_store / expected
- if (not fact or fact.get("entry") != expected
- or not entry.is_dir() or not entry.resolve().is_relative_to(source_store)
- or not facts.installed(package.name, version, source_store, identity)
- or not digest_matches(entry, fact.get("digest"))):
- raise InstallError(package.name, "tool source failed verification", "run preparation again")
- _copy_links(package, entry)
- binary = package.binary(entry, target)
- env = package.env(entry, target)
- if ((binary is not None and (not binary.is_file() or not binary.resolve().is_relative_to(entry)))
- or facts.env_for(package.name, source_store) != env):
- raise InstallError(package.name, "tool source failed verification: binary or environment")
- # The selection leaves PM (bundle scripts compare and execute it): ordinary spelling.
- entries[package.name] = InstalledPackage(Path(native(entry)), version,
- Path(native(binary)) if binary is not None else None)
- envs.append(env)
- return VerifiedTools(MappingProxyType(entries), tuple(envs))
- def stage_tools(names: Sequence[str], *, source_store: Path, out: Path, target: str) -> Path:
- """Copy a current, verified tool closure without acquisition or live selection.
- Stores must be disjoint. Both publication locks cover admission and copying;
- the ordinary installer owns verification, independent copies and fresh facts.
- """
- from contextlib import ExitStack
- from pm.install import _entry_verified, _install, _lockfile
- from pm.lock import Facts
- from pm.package import StatePackage
- from pm.registry import walk
- from pm.store import Store
- if isinstance(names, str):
- raise TypeError("names must be a sequence, not a string")
- source_store, out = Path(source_store).resolve(), Path(out).resolve()
- if source_store.is_relative_to(out) or out.is_relative_to(source_store):
- raise ValueError("tool stores must be disjoint")
- if not (source_store / "facts.json").is_file():
- raise InstallError("tools", f"source facts missing: {source_store}")
- packages = walk(list(names))
- if any(isinstance(package, StatePackage) for package in packages):
- raise ValueError("stage_tools accepts tool packages, not application state")
- source, destination = Store(source_store), Store(out)
- lock = _lockfile()
- with ExitStack() as stack:
- for store in sorted((source, destination), key=lambda store: str(store.root)):
- stack.enter_context(store.install_lock())
- selection = verified_tools(names, source_store=source_store, target=target, lock=lock)
- facts = Facts(source_store / "facts.json", strict=True)
- for package in packages:
- if package.name not in selection.entries:
- continue
- fact = facts.get(package.name)
- assert fact is not None # Admission requires the selected fact under the same store lock.
- if not _entry_verified(package, fact, source, target):
- raise InstallError(package.name, "tool copy source failed verification", "run preparation again")
- staged = Facts(out / "facts.json", strict=True)
- for package in packages:
- started = time.monotonic()
- _install(package, lock, staged, destination, target,
- copy_from=(facts, source), _lock_held=True, _fresh_copy=True)
- # Copy plus re-digest of a large tree runs silently for minutes on Windows.
- print(f" copied {package.name} ({time.monotonic() - started:.1f}s)", flush=True)
- return out
- def prune_cache(cache: Path, *, ci: bool = False) -> None:
- """Prune unused cache entries; CI mode also discards downloaded wheels."""
- from pm.environment import managed_environment
- cache = Path(cache).absolute()
- environment = managed_environment(cache, cache=cache, realize=False, output=sys.stderr)
- environment.prune_cache(ci=ci)
|