| """Atomic writers and runtime provenance for evaluation artifacts.""" |
|
|
| from __future__ import annotations |
|
|
| import hashlib |
| import json |
| import os |
| import platform |
| import selectors |
| import socket |
| import subprocess |
| import sys |
| import tempfile |
| import time |
| from pathlib import Path |
| from typing import Mapping |
|
|
| from benchkit.contracts import JsonValue, ensure_jsonable |
|
|
|
|
| def utc_now() -> str: |
| """Return a UTC timestamp in a stable machine-readable format.""" |
| from datetime import datetime, timezone |
|
|
| return datetime.now(timezone.utc).isoformat(timespec="milliseconds").replace("+00:00", "Z") |
|
|
|
|
| def atomic_write_json(path: Path, payload: Mapping[str, JsonValue], *, overwrite: bool = True) -> None: |
| """Write one JSON object without exposing a partially written final file.""" |
| normalized = ensure_jsonable(payload, str(path)) |
| path.parent.mkdir(parents=True, exist_ok=True) |
| with tempfile.NamedTemporaryFile( |
| "w", encoding="utf-8", dir=path.parent, prefix=f".{path.name}.", delete=False |
| ) as handle: |
| json.dump(normalized, handle, indent=2, sort_keys=True) |
| handle.write("\n") |
| temporary = Path(handle.name) |
| try: |
| if overwrite: |
| os.replace(temporary, path) |
| else: |
| |
| os.link(temporary, path) |
| finally: |
| temporary.unlink(missing_ok=True) |
|
|
|
|
| def append_jsonl(path: Path, payload: Mapping[str, JsonValue]) -> None: |
| """Append and flush one event to a JSON Lines stream.""" |
| normalized = ensure_jsonable(payload, str(path)) |
| path.parent.mkdir(parents=True, exist_ok=True) |
| with path.open("a", encoding="utf-8") as handle: |
| json.dump(normalized, handle, sort_keys=True, separators=(",", ":")) |
| handle.write("\n") |
| handle.flush() |
| os.fsync(handle.fileno()) |
|
|
|
|
| def _git_diff_digest(repository: Path, scope: str, *, max_bytes: int = 32 * 1024 * 1024, |
| timeout_s: float = 15.0) -> dict[str, JsonValue]: |
| """Hash a bounded package-scoped diff stream without retaining patch text.""" |
| command = ["git", "-C", str(repository), "diff", "--no-ext-diff", "--no-textconv", |
| "HEAD", "--binary", "--", scope] |
| digest = hashlib.sha256() |
| byte_count = 0 |
| deadline = time.monotonic() + timeout_s |
| with subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, |
| env={**os.environ, "GIT_OPTIONAL_LOCKS": "0"}) as process: |
| try: |
| with selectors.DefaultSelector() as selector: |
| selector.register(process.stdout, selectors.EVENT_READ) |
| while True: |
| remaining = deadline - time.monotonic() |
| if remaining <= 0 or not selector.select(remaining): |
| raise TimeoutError("evaluation package Git diff exceeded its time limit") |
| chunk = os.read(process.stdout.fileno(), 65536) |
| if not chunk: |
| break |
| byte_count += len(chunk) |
| if byte_count > max_bytes: |
| raise ValueError("evaluation package Git diff exceeded its byte limit") |
| digest.update(chunk) |
| return_code = process.wait(timeout=max(0.001, deadline - time.monotonic())) |
| if return_code: |
| raise subprocess.CalledProcessError(return_code, command) |
| except BaseException: |
| process.kill() |
| process.wait() |
| raise |
| return {"status": "recorded", "scope": scope, "sha256": digest.hexdigest(), |
| "size_bytes": byte_count, "includes_untracked_files": False, |
| "format": "git diff --no-ext-diff --no-textconv HEAD --binary -- <scope>"} |
|
|
|
|
| def git_provenance(repository: Path | None, *, evaluation_root: Path | None = None) -> dict[str, JsonValue]: |
| """Collect a revision and dirty flag without mutating Git state.""" |
| evaluation_root = Path(evaluation_root) if evaluation_root is not None else Path(__file__).parent |
| location = Path(repository) if repository is not None else evaluation_root |
| unavailable: dict[str, JsonValue] = { |
| "status": "unavailable", "scope": "installed harness package", |
| "sha256": None, "includes_untracked_files": False, |
| } |
| try: |
| root = Path(subprocess.run( |
| ["git", "-C", str(location), "rev-parse", "--show-toplevel"], |
| check=True, capture_output=True, text=True, timeout=10, |
| env={**os.environ, "GIT_OPTIONAL_LOCKS": "0"}, |
| ).stdout.strip()).resolve() |
| revision = subprocess.run( |
| ["git", "-C", str(root), "rev-parse", "HEAD"], |
| env={**os.environ, "GIT_OPTIONAL_LOCKS": "0"}, |
| check=True, |
| capture_output=True, |
| text=True, |
| timeout=10, |
| ).stdout.strip() |
| dirty = bool( |
| subprocess.run( |
| ["git", "-C", str(root), "status", "--porcelain"], |
| env={**os.environ, "GIT_OPTIONAL_LOCKS": "0"}, |
| check=True, |
| capture_output=True, |
| text=True, |
| timeout=10, |
| ).stdout.strip() |
| ) |
| except (OSError, subprocess.SubprocessError): |
| return {"revision": None, "dirty": None, |
| "evaluation_package_diff": {**unavailable, "reason": "git_checkout_unavailable"}} |
| try: |
| scope = evaluation_root.resolve().relative_to(root).as_posix() |
| except ValueError: |
| scoped_diff = {**unavailable, "reason": "installed_package_outside_requested_repository"} |
| else: |
| try: |
| scoped_diff = _git_diff_digest(root, scope) |
| except (OSError, subprocess.SubprocessError, TimeoutError, ValueError) as exc: |
| scoped_diff = {**unavailable, "scope": scope, "reason": type(exc).__name__} |
| return {"revision": revision, "dirty": dirty, "evaluation_package_diff": scoped_diff} |
|
|
|
|
| def runtime_provenance(repository: Path | None = None, *, evaluation_root: Path | None = None) -> dict[str, JsonValue]: |
| """Collect the minimum environment identity needed to interpret a run.""" |
| return ensure_jsonable( |
| { |
| "hostname": socket.gethostname(), |
| "platform": platform.platform(), |
| "python": sys.version.split()[0], |
| "executable": sys.executable, |
| "git": git_provenance(repository, evaluation_root=evaluation_root), |
| } |
| ) |
|
|
