| |
| """Persist a five-minute machine-readable heartbeat for the Codex SDK sweep.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import os |
| import subprocess |
| import time |
| from datetime import datetime, timezone |
| from pathlib import Path |
|
|
| from ptb_codex_sdk_status import MODELS, ROOT, SWEEP, TASKS, classify |
|
|
| INITIAL_JOB = { |
| (model, task): str(402112 + model_i * len(TASKS) + task_i) |
| for model_i, model in enumerate(MODELS) |
| for task_i, task in enumerate(TASKS) |
| } |
| TERMINAL_FAILURES = { |
| "BOOT_FAIL", "CANCELLED", "DEADLINE", "FAILED", "NODE_FAIL", "OUT_OF_MEMORY", |
| "PREEMPTED", "REVOKED", "TIMEOUT", |
| } |
|
|
|
|
| def current_jobs() -> dict[tuple[str, str], str]: |
| """Overlay recovery job IDs recorded after an initial cell failure.""" |
| jobs = dict(INITIAL_JOB) |
| path = ROOT / "RECOVERY_JOBS.json" |
| if path.is_file(): |
| for key, job in json.loads(path.read_text()).items(): |
| model, task = key.split("|", 1) |
| jobs[(model, task)] = str(job) |
| return jobs |
|
|
|
|
| def scheduler_states(jobs: dict[tuple[str, str], str]) -> dict[str, dict[str, str]]: |
| ids = ",".join(jobs.values()) |
| output = subprocess.run( |
| ["sacct", "-j", ids, "--format=JobIDRaw,State,ExitCode,Elapsed", "-n", "-P"], |
| check=False, capture_output=True, text=True, |
| ).stdout |
| states: dict[str, dict[str, str]] = {} |
| for line in output.splitlines(): |
| job, state, code, elapsed, *_ = (line.split("|") + [""] * 4)[:4] |
| if "." not in job and job in jobs.values(): |
| states[job] = {"state": state.split()[0], "exit_code": code, "elapsed": elapsed} |
| return states |
|
|
|
|
| def build_snapshot() -> dict: |
| jobs = current_jobs() |
| scheduler = scheduler_states(jobs) |
| cells = [] |
| counts: dict[str, int] = {} |
| action_required = [] |
| for model in MODELS: |
| safe_model = model.replace("/", "_") |
| for task in TASKS: |
| runs = sorted(SWEEP.glob(f"{task}_{safe_model}_*")) |
| run = runs[-1] if runs else None |
| status, score = classify(run) |
| counts[status] = counts.get(status, 0) + 1 |
| job = jobs[(model, task)] |
| job_state = scheduler.get(job, {}).get("state", "UNKNOWN") |
| cell = { |
| "task": task, "model": model, "job_id": job, "job_state": job_state, |
| "artifact_status": status, "score": score, |
| "run_dir": str(run) if run else None, |
| } |
| cells.append(cell) |
| if job_state in TERMINAL_FAILURES and status != "complete": |
| action_required.append(cell) |
| return { |
| "checked_at": datetime.now(timezone.utc).isoformat(), |
| "results_root": str(ROOT), |
| "counts": counts, |
| "complete": counts.get("complete", 0) == len(TASKS) * len(MODELS), |
| "action_required": action_required, |
| "cells": cells, |
| } |
|
|
|
|
| def write_snapshot(snapshot: dict) -> None: |
| ROOT.mkdir(parents=True, exist_ok=True) |
| temporary = ROOT / "WATCH_STATUS.json.tmp" |
| destination = ROOT / "WATCH_STATUS.json" |
| temporary.write_text(json.dumps(snapshot, indent=2) + "\n") |
| temporary.replace(destination) |
| with (ROOT / "WATCH.log").open("a") as log: |
| log.write(f"{snapshot['checked_at']} counts={snapshot['counts']} " |
| f"action_required={len(snapshot['action_required'])}\n") |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--interval", type=int, default=300) |
| parser.add_argument("--once", action="store_true") |
| args = parser.parse_args() |
| while True: |
| snapshot = build_snapshot() |
| write_snapshot(snapshot) |
| print(json.dumps({key: snapshot[key] for key in |
| ("checked_at", "counts", "complete", "action_required")}), flush=True) |
| if args.once or snapshot["complete"]: |
| return |
| time.sleep(args.interval) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
