| """Run manifest for immutable results preservation. |
| |
| Records the full context of a training/eval run (git state, config, seed, |
| environment, dataset hashes, metrics) and emits ``manifest.json`` plus |
| ``metrics.json`` under a uniquely-named run directory so results can be |
| reproduced and independently verified. |
| |
| Pure stdlib only; torch is imported lazily (and optionally) inside |
| :meth:`RunManifest._collect_env`. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import hashlib |
| import json |
| import platform |
| import re |
| import subprocess |
| import time |
| from datetime import datetime, timezone |
| from pathlib import Path |
| from typing import Any, Optional |
|
|
| __all__ = ["RunManifest"] |
|
|
| _HASH_CHUNK_BYTES = 1 << 20 |
|
|
|
|
| def _find_repo_root() -> Optional[Path]: |
| """Walk up from this file until a ``.git`` dir or file is found.""" |
| for parent in Path(__file__).resolve().parents: |
| if (parent / ".git").exists(): |
| return parent |
| return None |
|
|
|
|
| def _git_output(args: list[str], cwd: Path) -> Optional[str]: |
| """Run a git command, returning stripped stdout or None on any failure.""" |
| try: |
| proc = subprocess.run( |
| ["git", *args], |
| cwd=str(cwd), |
| capture_output=True, |
| text=True, |
| timeout=30, |
| check=False, |
| ) |
| except (OSError, subprocess.SubprocessError): |
| return None |
| if proc.returncode != 0: |
| return None |
| return proc.stdout.strip() or None |
|
|
|
|
| def _slugify(name: str) -> str: |
| """Lowercase, replace non-alphanumeric runs with single dashes.""" |
| slug = re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-") |
| return slug or "run" |
|
|
|
|
| class RunManifest: |
| """Accumulates provenance for a single run; ``finalize`` writes it out.""" |
|
|
| def __init__(self) -> None: |
| self._config: dict[str, Any] = {} |
| self._seed: Optional[Any] = None |
| self._git_sha: Optional[str] = None |
| self._git_dirty: Optional[bool] = None |
| self._env: dict[str, Any] = {} |
| self._started_at: Optional[str] = None |
| self._start_monotonic: Optional[float] = None |
| self._metrics: Optional[dict[str, Any]] = None |
| self._artifact_hashes: dict[str, str] = {} |
|
|
| |
| |
| |
|
|
| def begin(self, config: dict) -> None: |
| """Record config, git state, seed, environment and start time.""" |
| self._config = dict(config) |
| self._seed = config.get("seed") |
|
|
| root = _find_repo_root() |
| if root is not None: |
| sha = _git_output(["rev-parse", "HEAD"], root) |
| self._git_sha = sha |
| if sha is not None: |
| status = _git_output(["status", "--porcelain"], root) |
| self._git_dirty = bool(status) if status is not None else None |
| else: |
| self._git_dirty = None |
| else: |
| self._git_sha = None |
| self._git_dirty = None |
|
|
| self._env = self._collect_env() |
|
|
| now = datetime.now(timezone.utc) |
| self._started_at = now.isoformat() |
| self._start_monotonic = time.monotonic() |
|
|
| def _collect_env(self) -> dict[str, Any]: |
| """Python version plus optional torch/ROCm/GPU info (never raises).""" |
| env: dict[str, Any] = {"python_version": platform.python_version()} |
| try: |
| import torch |
| except Exception: |
| return env |
| try: |
| env["torch_version"] = torch.__version__ |
| hip = getattr(torch.version, "hip", None) |
| cuda = getattr(torch.version, "cuda", None) |
| if hip: |
| env["torch_hip_version"] = hip |
| if cuda: |
| env["torch_cuda_version"] = cuda |
| if torch.cuda.is_available(): |
| env["gpu_name"] = torch.cuda.get_device_name(0) |
| except Exception: |
| pass |
| return env |
|
|
| def record_metrics(self, metrics: dict) -> None: |
| """Store metrics; raises ``TypeError`` if not JSON-serializable.""" |
| json.dumps(metrics) |
| self._metrics = dict(metrics) |
|
|
| def record_artifact_hash(self, path: Path) -> None: |
| """Compute and store the SHA256 of ``path`` (keyed by file name).""" |
| sha256 = hashlib.sha256() |
| with Path(path).open("rb") as f: |
| while True: |
| chunk = f.read(_HASH_CHUNK_BYTES) |
| if not chunk: |
| break |
| sha256.update(chunk) |
| self._artifact_hashes[Path(path).name] = sha256.hexdigest() |
|
|
| |
| |
| |
|
|
| def _make_run_id(self) -> str: |
| timestamp = datetime.now(timezone.utc).strftime("%Y%m%d-%H%M%S") |
| if "name" in self._config: |
| slug = _slugify(str(self._config["name"])) |
| else: |
| slug = "run" |
| sha_part = self._git_sha[:7] if self._git_sha else "nogit" |
| return f"{timestamp}__{slug}__{sha_part}" |
|
|
| def finalize(self, out_dir: Path) -> Path: |
| """Create ``out_dir / run_id`` and write manifest + metrics files.""" |
| if self._started_at is None or self._start_monotonic is None: |
| raise RuntimeError("begin() must be called before finalize()") |
| if self._metrics is None: |
| raise RuntimeError("record_metrics() must be called before finalize()") |
|
|
| run_id = self._make_run_id() |
| run_dir = Path(out_dir) / run_id |
| run_dir.mkdir(parents=True, exist_ok=True) |
|
|
| duration_s = time.monotonic() - self._start_monotonic |
| manifest: dict[str, Any] = { |
| "run_id": run_id, |
| "git_sha": self._git_sha, |
| "git_dirty": self._git_dirty, |
| "config": self._config, |
| "seed": self._seed, |
| "env": self._env, |
| "artifact_hashes": self._artifact_hashes, |
| "started_at": self._started_at, |
| "duration_s": duration_s, |
| } |
| (run_dir / "manifest.json").write_text( |
| json.dumps(manifest, indent=2, sort_keys=True) + "\n", encoding="utf-8" |
| ) |
| (run_dir / "metrics.json").write_text( |
| json.dumps(self._metrics, indent=2, sort_keys=True) + "\n", encoding="utf-8" |
| ) |
| return run_dir |
|
|
