"""Restore dependency generations without importing the damaged environment.""" from __future__ import annotations import contextlib import subprocess import sys from pathlib import Path from pm.package import InstallError STARTUP_IMPORTS = ( ("ruamel.yaml", "ruamel.yaml", "YAML"), ("python-dotenv", "dotenv", "load_dotenv"), ("click", "click", "Command"), ("certifi", "certifi", "contents"), ("rich", "rich", "print"), ("cryptography", "cryptography.hazmat.bindings._rust", "openssl"), ("PyJWT", "jwt", "encode"), ) def validate_environment(python: Path | list[str], *, env: dict, cwd: Path) -> None: """Run startup import checks in the candidate, never the repairing process. *python* is the candidate's interpreter or its argv prefix (``venv_command``).""" script = ( "import importlib, importlib.metadata, pathlib, re, tomllib\n" "project = tomllib.loads(pathlib.Path('pyproject.toml').read_text(encoding='utf-8-sig'))['project']\n" "required = {re.split(r'[\\[<>=!~; @]', dep, 1)[0].lower().replace('_', '-')\n" " for dep in project.get('dependencies', [])}\n" f"checks = {STARTUP_IMPORTS!r}\n" "for distribution, module, attribute in checks:\n" " try:\n" " importlib.metadata.distribution(distribution)\n" " except importlib.metadata.PackageNotFoundError:\n" " if distribution.lower().replace('_', '-') in required:\n" " raise\n" " continue\n" " loaded = importlib.import_module(module)\n" " getattr(loaded, attribute)\n" " if module == 'certifi':\n" " bundle = pathlib.Path(loaded.where())\n" " assert bundle.is_file() and bundle.stat().st_size >= 1024, 'CA bundle is missing'\n" ) command = [str(python), "-I"] if isinstance(python, (str, Path)) else [*python] result = subprocess.run([*command, "-c", script], cwd=cwd, env=env, capture_output=True, text=True, encoding="utf-8", errors="replace", timeout=60, check=False) if result.returncode: raise InstallError("venv", f"startup validation failed: {result.stderr.strip()[-1000:]}") def repair_dependencies(project_root: Path) -> None: """Restore this installation's recorded set; never repair a foreign tree.""" from hermes_cli.venv_sync import collect_superseded_generations from pm.client import sync_venv from pm.paths import repo_root if Path(project_root).resolve() != repo_root().resolve(): raise InstallError("venv", "recovery root does not match this PM installation") with contextlib.redirect_stdout(sys.stderr): sync_venv(repair=True) collect_superseded_generations(project_root) def _baseline_gaps(root: Path) -> list[str]: """Extras the store's shipped selection carries that the recorded selection lacks. A volume whose first generation was built before the image recorded its selection holds only what was installed on use (``["fal"]``, or ``[]``), and that generation replaces the image's environment with one missing everything the image ships. """ from pm.environments import runtime_facts_path from pm.install import _carried, _extra_key, _facts from pm.lock import Facts from pm.packages import Venv fact = Facts(runtime_facts_path(root), strict=True).get("venv") if fact is None: return [] # The same checks venv_is_current applies; a gap must not skip them. recorded = fact.get("extras") if isinstance(fact, dict) else None stamp = fact.get("stamp") if isinstance(fact, dict) else None if (not isinstance(recorded, list) or any(not isinstance(extra, str) for extra in recorded) or not isinstance(stamp, str) or not stamp): raise ValueError("invalid recorded dependency state") shipped = (_facts().get("venv") or {}).get("extras") or [] have = {_extra_key(extra) for extra in recorded} return sorted({extra for extra in _carried(Venv(root), shipped) if _extra_key(extra) not in have}) def refresh_dependencies(project_root: Path) -> str: """Re-resolve the durable selection against inputs an external update replaced. A container image swaps the code and lock under a selection recorded on the data volume; a generation resolved against the previous lock must never boot the new code. Rebuilds the recorded extras and plugins, or on failure boots the image's own environment while keeping them recorded, so the next boot or install rebuilds them. A recorded selection missing extras the image ships gets them back. Returns what happened. """ from hermes_cli.runtime_state import runtime_lock from pm.client import sync_venv from pm.environments import runtime_facts_path from pm.install import venv_is_current from pm.lock import Facts from pm.paths import repo_root root = Path(project_root).resolve() if root != repo_root().resolve(): raise InstallError("venv", "refresh root does not match this PM installation") if not runtime_facts_path(root).is_file(): return "base" missing = _baseline_gaps(root) if not missing and venv_is_current(project_root=root): return "current" try: with contextlib.redirect_stdout(sys.stderr): # The image's baseline, not a user request: it never undoes a `--without`. sync_venv(missing or None, explicit=True, automatic=missing) return f"restored {', '.join(missing)}" if missing else "rebuilt" except Exception as exc: print(f"dependency refresh failed: {exc}", file=sys.stderr) with runtime_lock(root, timeout=None): facts = Facts(runtime_facts_path(root), strict=True) fact = facts.get("venv") or {} # Keep the restored extras recorded too: a lazy install before the next boot # unions onto this selection and must not publish a generation without them. recorded = list(fact.get("extras") or []) facts.record_state("venv", fact.get("stamp") or "stale", recorded + [extra for extra in missing if extra not in recorded]) return "fallback"