| """Validate all publication bundles, evidence counts and anonymous-safe data. |
| |
| Reads at most one compressed episode at a time. Never prints source contents. |
| """ |
| from pathlib import Path |
| import argparse |
| import collections |
| import gzip |
| import json |
| import math |
| import resource |
|
|
| import numpy as np |
| import pandas as pd |
| import pyarrow.parquet as pq |
|
|
| from export_corpus import Builder, Redactor, digest, dumps, telemetry |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--check-originals", action="store_true") |
| args = parser.parse_args() |
| out = Path(__file__).resolve().parents[1] |
| episodes = pd.concat([pd.read_parquet(out / f"data/{c}.parquet") for c in ["olmo", "qwen", "forest"]], ignore_index=True) |
| sources = pd.read_parquet(out / "data/sources.parquet") |
| coverage = pd.read_parquet(out / "data/coverage.parquet") |
| examples = pd.read_parquet(out / "data/example_summary.parquet") |
| tokens = pd.read_parquet(out / "data/token_diagnostics.parquet") |
| joins = pd.read_parquet(out / "data/forest_joins.parquet") |
| inventory = pd.read_csv(out / "provenance/recording_inventory.csv", keep_default_na=False) |
| assert episodes.episode_id.is_unique |
| assert episodes.groupby("collection").size().to_dict() == {"forest":371,"olmo":570,"qwen":510} |
| assert examples.groupby("example_kind").size().to_dict() == {"experiment1_judge_packet":144,"final":218,"process":8633,"rejection":74} |
| assert len(inventory) == 1958 |
| assert not inventory.path.str.match(r"(?:tmax|opd_exp)/").any() |
| assert (inventory.archive_member == "").all() |
| assert not sources.source_path.str.contains(r"codex-session-trajectories|(?:^|/)\.codex/|^tmax/").any() |
| expected = {"invalid":3,"trajectory_missing_at_archive_time":368,"27b_summary_only":64,"original_raw_run_missing":1} |
| assert coverage.status.value_counts().to_dict() == expected, coverage.status.value_counts().to_dict() |
| assert len(episodes[episodes.retained_experiment2_id.notna()]) == 503 |
| assert set(tokens.episode_id).issubset(set(episodes.episode_id)) |
| verified = joins[joins.match_status == "verified_trial_uuid_and_branch"] |
| assert (verified.candidate_count == 1).all() |
| assert verified.episode_id.notna().all() |
| assert set(verified.episode_id).issubset(set(episodes.loc[episodes.collection == "forest", "episode_id"])) |
| assert joins.loc[joins.match_status != "verified_trial_uuid_and_branch", "episode_id"].isna().all() |
| forest_keys = collections.defaultdict(set) |
| for r in inventory[inventory.project == "forestOfAudits"].itertuples(): |
| key = Builder.forest_identity(None, r.path) |
| if key: |
| from export_corpus import identity |
| forest_keys[key].add(identity(r.episode_key)) |
| for r in verified.itertuples(): |
| key = Builder.forest_identity(None, r.public_source_path) |
| assert forest_keys[key] == {r.episode_id} |
| redactor = Redactor() |
| source_count, token_count, bundle_count = 0, 0, 0 |
| max_bundle_bytes = 0 |
| episode_events = collections.Counter() |
| for i, row in enumerate(episodes.itertuples()): |
| path = out / row.detail_path |
| with gzip.open(path, "rb") as handle: |
| raw = handle.read() |
| max_bundle_bytes = max(max_bundle_bytes, len(raw)) |
| bundle = json.loads(raw) |
| assert bundle["episode"]["episode_id"] == row.episode_id |
| assert sum(e["canonical_view"] for e in bundle["events"]) == row.events |
| episode_events[row.episode_id] = len(bundle["events"]) |
| raw_tokens = [] |
| for view in bundle["recordings"]: |
| source = view["source"] |
| payload = dumps(view["data"]).encode() |
| assert digest(payload) == source["publication_sha256"], source["source_path"] |
| if args.check_originals: |
| original = out.parent / source["source_path"] |
| assert digest(original.read_bytes()) == source["source_sha256"], source["source_path"] |
| before = len(redactor.rows) |
| redactor.clean(view["data"], source["source_path"]) |
| assert len(redactor.rows) == before, f"Credential pattern remains in {source['source_path']}" |
| obj = view["data"] |
| if isinstance(obj, dict): |
| for s in obj.get("steps", []): |
| m = s.get("metrics") or {} |
| if isinstance(m.get("completion_token_ids"), list) and isinstance(m.get("logprobs"), list): |
| raw_tokens.append(telemetry(m)) |
| for batch in (obj.get("agent_result") or {}).get("rollout_details") or []: |
| ids, lps = batch.get("completion_token_ids", []), batch.get("logprobs", []) |
| if ids and isinstance(ids[0], list): |
| for j in range(max(len(ids), len(lps))): |
| raw_tokens.append(telemetry({"completion_token_ids":ids[j] if j<len(ids) else [],"logprobs":lps[j] if j<len(lps) else []})) |
| else: |
| raw_tokens.append(telemetry(batch)) |
| source_count += 1 |
| stored = bundle["token_diagnostics"] |
| assert len(raw_tokens) == len(stored), row.episode_id |
| for raw_t, stored_t in zip(raw_tokens, stored): |
| assert raw_t["alignment"] == stored_t["alignment"] |
| assert raw_t["token_count"] == stored_t["token_count"] |
| if raw_t["alignment"] == "aligned": |
| assert math.isclose(raw_t["nll_sum"], stored_t["nll_sum"], rel_tol=1e-10, abs_tol=1e-8) |
| good = [t for t in stored if t["alignment"] == "aligned"] |
| count = sum(t["token_count"] for t in good) |
| if count: |
| assert math.isclose(sum(t["nll_sum"] for t in good)/count, row.selected_token_surprisal_nats, rel_tol=1e-9) |
| token_count += len(stored) |
| bundle_count += 1 |
| if i % 200 == 0: |
| print(f"Verified {i}/{len(episodes)} bundles", flush=True) |
| assert token_count == len(tokens) |
| parquet_counts = collections.Counter() |
| for p in (out / "data/events").rglob("*.parquet"): |
| for batch in pq.ParquetFile(p).iter_batches(batch_size=4096, columns=["episode_id"]): |
| parquet_counts.update(batch.column(0).to_pylist()) |
| assert parquet_counts == episode_events |
| |
| for row in sources[sources.public_path.notna()].itertuples() if "public_path" in sources else []: |
| p = out / row.public_path |
| raw = gzip.decompress(p.read_bytes()) if p.suffix == ".gz" else p.read_bytes() |
| assert digest(raw) == row.publication_sha256, row.source_path |
| redactor.text(raw.decode(), row.source_path, "$") |
| |
| for p in out.rglob("*.gz"): |
| if "recordings" in p.parts: |
| continue |
| raw = gzip.decompress(p.read_bytes()) |
| if p.name.endswith(".jsonl.gz"): |
| values = [json.loads(line) for line in raw.splitlines() if line.strip()] |
| else: |
| values = json.loads(raw) |
| before = len(redactor.rows) |
| redactor.clean(values, str(p.relative_to(out))) |
| assert len(redactor.rows) == before, f"Credential pattern in {p.name}" |
| for name in ["annotations", "examples", "q09_transitions", "qwen27b_summary_only"]: |
| frame = pd.read_parquet(out / f"data/{name}.parquet") |
| for column in [c for c in frame if c.endswith("_json")]: |
| for value in frame[column].dropna(): |
| before = len(redactor.rows) |
| redactor.clean(json.loads(value), name) |
| assert len(redactor.rows) == before, f"Credential pattern in table {name}" |
| assert not redactor.rows |
| report = {"status":"passed", "episode_counts":episodes.groupby("collection").size().to_dict(), |
| "bundles_verified":bundle_count, "embedded_source_hashes_verified":source_count, |
| "token_sequences_recomputed":token_count, "event_rows_verified":sum(parquet_counts.values()), |
| "example_counts":examples.groupby("example_kind").size().to_dict(), |
| "coverage":expected, "verified_forest_example_joins":len(verified), |
| "max_uncompressed_bundle_bytes":max_bundle_bytes, |
| "peak_validation_rss_mib":resource.getrusage(resource.RUSAGE_SELF).ru_maxrss/1024, |
| "original_source_hashes_checked":args.check_originals, |
| "credential_scan":"all publication recording views and derived public copies"} |
| (out / "provenance/validation.json").write_text(json.dumps(report,indent=2)+"\n") |
| print(json.dumps(report,indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
