scripts/validate_full_graph_loader_release.py

#!/usr/bin/env python3
"""Resumable full-release gate for the strict GWAM temporal-window loader.

Every selected manifest episode is opened through ``GWAMFullGraphEpisode`` in
strict mode and exercised at the first, middle, and last legal L/H windows.
Results are append-only JSONL so interrupted runs can resume safely.
"""
from __future__ import annotations

import argparse
import concurrent.futures
import hashlib
import json
import os
import sys
import time
import traceback
from collections import Counter, defaultdict
from pathlib import Path
from typing import Any, Iterable

import numpy as np

PACKAGE_ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(PACKAGE_ROOT / "loaders"))

from gwam_full_graph_window import (  # noqa: E402
    CONTACT_EVENT,
    EXPECTED_SCHEMA,
    GWAMFullGraphEpisode,
    clear_full_graph_loader_caches,
)


def _sha256(path: Path) -> str:
    digest = hashlib.sha256()
    with path.open("rb") as f:
        for chunk in iter(lambda: f.read(8 * 1024 * 1024), b""):
            digest.update(chunk)
    return digest.hexdigest()


def _window_starts(count: int) -> list[int]:
    if count <= 0:
        return []
    return sorted({0, (count - 1) // 2, count - 1})


def _validate_sample(sample: dict[str, Any]) -> dict[str, Any]:
    history = sample["history"]
    targets = sample["targets"]
    metadata = sample["metadata"]
    n = int(metadata["N_real"])
    l = int(metadata["history_length"])
    h = int(metadata["horizon"])
    if metadata["schema"] != EXPECTED_SCHEMA:
        raise AssertionError(f"unexpected schema {metadata['schema']!r}")
    expected_shapes = {
        "kinematic_state": (l, n, 15),
        "static_flags": (l, n, 2),
        "state_visibility": (l, n, 3),
        "sam2_visual": (l, n, 3, 256),
        "sam2_valid": (l, n, 3),
        "sam2_failed": (l, n, 3),
        "mask_valid": (l, n, 3),
    }
    for key, shape in expected_shapes.items():
        if history[key].shape != shape:
            raise AssertionError(f"history.{key} {history[key].shape} != {shape}")
    if targets["kinematic_state"].shape != (h, n, 15):
        raise AssertionError("future kinematic shape mismatch")
    if targets["contact_pair_event"].dtype != np.int64:
        raise AssertionError("contact_pair_event must be int64")
    expected_pairs = n * (n - 1) // 2
    if targets["contact_pair_index"].shape != (2, expected_pairs):
        raise AssertionError("contact pair domain is incomplete")
    if sample["future_action"].shape != (h, 12) or not sample["future_action_valid"].all():
        raise AssertionError("conditioning action contract failed")
    if not np.isfinite(history["kinematic_state"]).all():
        raise AssertionError("non-finite kinematic input")
    if not np.isfinite(history["sam2_visual"]).all():
        raise AssertionError("non-finite SAM2 input")
    if np.any(history["sam2_valid"] & history["sam2_failed"]):
        raise AssertionError("SAM2 valid/failed overlap")
    if not np.array_equal(
        history["sam2_valid"] | history["sam2_failed"], history["mask_valid"]
    ):
        raise AssertionError("SAM2 partition does not equal visible-mask pairs")
    if history["family_id"].min(initial=0) < 0 or history["family_id"].max(initial=0) > 9:
        raise AssertionError("dataset family id outside 0..9")
    for edge_index, edge_attr in zip(
        history["edge_index"], history["edge_attr"], strict=True
    ):
        if edge_index.shape[1] != edge_attr.shape[0]:
            raise AssertionError("edge row mismatch")
        contacts = edge_index[:, edge_attr[:, 2] == 1]
        contact_set = {tuple(pair) for pair in contacts.T.tolist()}
        if any((dst, src) not in contact_set for src, dst in contact_set):
            raise AssertionError("contact message edge lacks reverse direction")
    valid_events = targets["contact_pair_event"][targets["contact_pair_valid"]]
    event_counts = np.bincount(valid_events, minlength=4)
    return {
        "N_real": n,
        "history_mask_valid": int(history["mask_valid"].sum()),
        "history_sam2_valid": int(history["sam2_valid"].sum()),
        "history_sam2_failed": int(history["sam2_failed"].sum()),
        "event_off": int(event_counts[CONTACT_EVENT["off"]]),
        "event_make": int(event_counts[CONTACT_EVENT["make"]]),
        "event_hold": int(event_counts[CONTACT_EVENT["hold"]]),
        "event_break": int(event_counts[CONTACT_EVENT["break"]]),
        "history_edges": int(sum(edge.shape[1] for edge in history["edge_index"])),
        "future_dynamic_edges": int(
            sum(edge.shape[1] for edge in targets["dynamic_edge_index"])
        ),
    }


def _validate_episode(job: dict[str, Any]) -> dict[str, Any]:
    started = time.perf_counter()
    row = job["row"]
    stage_root = Path(job["stage_root"])
    zip_path = stage_root / row["zip_path"]
    result: dict[str, Any] = {
        "zip_path": row["zip_path"],
        "split": row.get("split"),
        "task": row.get("task"),
        "episode_id": row.get("episode_id"),
        "ok": False,
    }
    try:
        if not zip_path.is_file():
            raise FileNotFoundError(zip_path)
        actual_size = zip_path.stat().st_size
        expected_size = int(row.get("zip_size", actual_size))
        if actual_size != expected_size:
            raise ValueError(f"ZIP size {actual_size} != manifest {expected_size}")
        if job["verify_sha"]:
            actual_sha = _sha256(zip_path)
            if actual_sha != row.get("zip_sha256"):
                raise ValueError("ZIP SHA256 differs from manifest")
            result["zip_sha256"] = actual_sha

        with GWAMFullGraphEpisode(zip_path=zip_path, strict=True) as episode:
            legal_starts = episode.valid_start_times(
                history_length=job["history_length"], horizon=job["horizon"]
            )
            starts = _window_starts(len(legal_starts))
            if not starts:
                raise ValueError("episode has no legal temporal windows")
            window_stats = []
            for start_t in starts:
                sample = episode.load_window(
                    start_t=start_t,
                    history_length=job["history_length"],
                    horizon=job["horizon"],
                    mask_size=job["mask_size"],
                )
                stats = _validate_sample(sample)
                stats["start_t"] = start_t
                stats["anchor_t"] = int(sample["metadata"]["anchor_t"])
                window_stats.append(stats)
                del sample
            result.update(
                {
                    "ok": True,
                    "T": len(legal_starts) + job["history_length"] + job["horizon"] - 1,
                    "N_real": window_stats[0]["N_real"],
                    "legal_window_count": len(legal_starts),
                    "checked_starts": starts,
                    "window_stats": window_stats,
                }
            )
    except Exception as exc:
        result["error_type"] = type(exc).__name__
        result["error"] = str(exc)
        result["traceback"] = traceback.format_exc(limit=8)
    finally:
        clear_full_graph_loader_caches()
        result["elapsed_seconds"] = time.perf_counter() - started
    return result


def _read_jsonl(path: Path) -> list[dict[str, Any]]:
    rows: list[dict[str, Any]] = []
    if not path.exists():
        return rows
    with path.open() as f:
        for line in f:
            if line.strip():
                rows.append(json.loads(line))
    return rows


def _atomic_json(path: Path, value: Any) -> None:
    tmp = path.with_suffix(path.suffix + ".tmp")
    tmp.write_text(json.dumps(value, indent=2, sort_keys=True) + "\n")
    os.replace(tmp, path)


def _summarize(records: list[dict[str, Any]], expected: int) -> dict[str, Any]:
    unique: dict[str, dict[str, Any]] = {row["zip_path"]: row for row in records}
    rows = list(unique.values())
    passed = [row for row in rows if row.get("ok")]
    failed = [row for row in rows if not row.get("ok")]
    by_task: dict[str, Counter[str]] = defaultdict(Counter)
    for row in rows:
        key = f"{row.get('split')}/{row.get('task')}"
        by_task[key]["passed" if row.get("ok") else "failed"] += 1
    return {
        "expected_episode_count": expected,
        "unique_result_count": len(rows),
        "passed": len(passed),
        "failed": len(failed),
        "complete": len(rows) == expected,
        "all_passed": len(rows) == expected and not failed,
        "total_legal_windows": int(sum(row.get("legal_window_count", 0) for row in passed)),
        "min_T": min((row["T"] for row in passed), default=None),
        "max_T": max((row["T"] for row in passed), default=None),
        "min_N_real": min((row["N_real"] for row in passed), default=None),
        "max_N_real": max((row["N_real"] for row in passed), default=None),
        "elapsed_episode_seconds_sum": float(sum(row.get("elapsed_seconds", 0) for row in rows)),
        "failure_types": dict(Counter(row.get("error_type", "unknown") for row in failed)),
        "failed_zip_paths": [row["zip_path"] for row in failed],
        "by_split_task": {key: dict(value) for key, value in sorted(by_task.items())},
    }


def main(argv: Iterable[str] | None = None) -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument(
        "--stage-root",
        type=Path,
        default=PACKAGE_ROOT / "staging" / "gwam_v12_sparse_v2_full",
    )
    parser.add_argument("--manifest", type=Path)
    parser.add_argument("--output-dir", type=Path, required=True)
    parser.add_argument("--workers", type=int, default=8)
    parser.add_argument("--history-length", type=int, default=8)
    parser.add_argument("--horizon", type=int, default=8)
    parser.add_argument("--mask-size", type=int, default=16)
    parser.add_argument("--split")
    parser.add_argument("--task")
    parser.add_argument("--limit", type=int)
    parser.add_argument("--resume", action="store_true")
    parser.add_argument("--retry-failures", action="store_true")
    parser.add_argument("--verify-sha", action="store_true")
    parser.add_argument("--progress-every", type=int, default=25)
    args = parser.parse_args(list(argv) if argv is not None else None)

    stage_root = args.stage_root.expanduser().resolve()
    manifest = (args.manifest or stage_root / "MANIFEST.jsonl").expanduser().resolve()
    rows = _read_jsonl(manifest)
    if args.split:
        rows = [row for row in rows if row.get("split") == args.split]
    if args.task:
        rows = [row for row in rows if row.get("task") == args.task]
    if args.limit is not None:
        rows = rows[: args.limit]
    if not rows:
        raise SystemExit("no manifest rows selected")

    output_dir = args.output_dir.expanduser().resolve()
    output_dir.mkdir(parents=True, exist_ok=True)
    result_path = output_dir / "episode_results.jsonl"
    summary_path = output_dir / "summary.json"
    prior = _read_jsonl(result_path) if args.resume else []
    done = {
        row["zip_path"]
        for row in prior
        if row.get("ok") or not args.retry_failures
    }
    pending = [row for row in rows if row["zip_path"] not in done]
    mode = "a" if args.resume and result_path.exists() else "w"
    if mode == "w":
        prior = []

    jobs = [
        {
            "row": row,
            "stage_root": str(stage_root),
            "history_length": args.history_length,
            "horizon": args.horizon,
            "mask_size": args.mask_size,
            "verify_sha": args.verify_sha,
        }
        for row in pending
    ]
    started = time.perf_counter()
    completed = 0
    with result_path.open(mode) as out:
        with concurrent.futures.ProcessPoolExecutor(max_workers=args.workers) as pool:
            futures = [pool.submit(_validate_episode, job) for job in jobs]
            for future in concurrent.futures.as_completed(futures):
                record = future.result()
                out.write(json.dumps(record, sort_keys=True) + "\n")
                out.flush()
                completed += 1
                if completed % args.progress_every == 0 or not record.get("ok"):
                    elapsed = time.perf_counter() - started
                    rate = completed / elapsed if elapsed else 0.0
                    print(
                        f"completed={completed}/{len(jobs)} rate={rate:.2f}/s "
                        f"latest_ok={record.get('ok')} {record['zip_path']}",
                        flush=True,
                    )

    records = _read_jsonl(result_path)
    summary = _summarize(records, expected=len(rows))
    summary.update(
        {
            "stage_root": str(stage_root),
            "manifest": str(manifest),
            "history_length": args.history_length,
            "horizon": args.horizon,
            "mask_size": args.mask_size,
            "workers": args.workers,
            "verify_sha": bool(args.verify_sha),
            "wall_seconds_this_run": time.perf_counter() - started,
        }
    )
    latest = {record["zip_path"]: record for record in records}
    with (output_dir / "validated_manifest.jsonl").open("w") as out:
        for row in rows:
            validation = latest.get(row["zip_path"], {})
            if validation.get("ok"):
                merged = dict(row)
                merged["loader_validation"] = {
                    "history_length": args.history_length,
                    "horizon": args.horizon,
                    "mask_size": args.mask_size,
                    "checked_starts": validation.get("checked_starts", []),
                }
                out.write(json.dumps(merged, sort_keys=True) + "\n")
    with (output_dir / "quarantine_manifest.jsonl").open("w") as out:
        for row in rows:
            validation = latest.get(row["zip_path"], {})
            if validation and not validation.get("ok"):
                out.write(
                    json.dumps(
                        {
                            "zip_path": row["zip_path"],
                            "split": row.get("split"),
                            "task": row.get("task"),
                            "episode_id": row.get("episode_id"),
                            "error_type": validation.get("error_type"),
                            "error": validation.get("error"),
                        },
                        sort_keys=True,
                    )
                    + "\n"
                )
    _atomic_json(summary_path, summary)
    print(json.dumps(summary, indent=2, sort_keys=True))
    return 0 if summary["all_passed"] else 1


if __name__ == "__main__":
    raise SystemExit(main())