| """Validate SREB dataset integrity. |
| |
| python scripts/check_corpus.py [--repo-root .] |
| |
| Rules: |
| 1. If manifest.json exists, every listed file must match its sha256, and every file |
| under data/ must be listed (so no data file escapes the frozen hashes). |
| 2. Every corpus file in data/corpus/*.json must declare a schema, a DDL and families; |
| every family must have a reference SQL, a profile, a breaking_profile and a schema. |
| Family ids are unique across all corpus files. |
| 3. Every state in states/states.json must reference an existing family. |
| 4. Every family must have a run record for every model directory and an evidence file |
| once it is evaluated; a family without runs yet is allowed (staged dataset), but a |
| run record may only exist for a family that has frozen states. |
| 5. Every run record must name its model, digest and sampling protocol; candidate_sql |
| and raw_response keys must be present. |
| 6. Every evidence record must have an allowed status; "refuted" requires refuting_states |
| and a witness, and the witness state must be one of the refuting states. |
| 7. Every evidence file must pin, in protocol.corpus_sha256 and |
| protocol.state_bank_sha256, the current sha256 of its schema corpus file and of |
| data/states/states.json. A stale pin is an error: published evidence would otherwise |
| refer to inputs that are no longer in the tree. |
| 8. If manifest.json declares counts, they must be recomputable from data/ alone. |
| Exits non-zero on any violation. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| import sys |
| from pathlib import Path |
|
|
| STATUSES = {"preserved", "refuted", "no_rewrite", "unsupported", "error"} |
| BREAKING_PROFILES = {"multiplicity", "nullable", "empty", "boundary", "ties", "zero_value", "random"} |
|
|
|
|
| def sha256(path: Path) -> str: |
| return hashlib.sha256(path.read_bytes()).hexdigest() |
|
|
|
|
| def load(path: Path): |
| return json.loads(path.read_text(encoding="utf-8")) |
|
|
|
|
| def check_evidence_record(rel: str, rec: dict, errors: list[str], family_ids: set[str]) -> None: |
| status = rec.get("status") |
| if status not in STATUSES: |
| errors.append(f"{rel}: unknown status {status!r}") |
| if not rec.get("model"): |
| errors.append(f"{rel}: evidence record without model") |
| if not rec.get("model_digest"): |
| errors.append(f"{rel}: evidence record without model digest") |
| if status == "refuted": |
| states = rec.get("refuting_states") or [] |
| witness = rec.get("witness") or {} |
| if not states: |
| errors.append(f"{rel}: refuted without refuting_states") |
| if not witness: |
| errors.append(f"{rel}: refuted without witness") |
| elif witness.get("reference_rows") is None or witness.get("candidate_rows") is None: |
| errors.append(f"{rel}: witness without reference or candidate rows") |
| elif witness.get("state") not in states: |
| errors.append(f"{rel}: witness state is not among refuting_states") |
| elif status in {"preserved", "no_rewrite"}: |
| if rec.get("refuting_states"): |
| errors.append(f"{rel}: {status} record has refuting_states") |
| if rec.get("family") and rec["family"] not in family_ids: |
| errors.append(f"{rel}: evidence record for unknown family {rec['family']}") |
|
|
|
|
| def main() -> int: |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--repo-root", type=Path, default=Path(".")) |
| root = ap.parse_args().repo_root.resolve() |
| errors: list[str] = [] |
| checked = 0 |
|
|
| listed: dict[str, str] = {} |
| manifest = root / "manifest.json" |
| if manifest.exists(): |
| data = load(manifest) |
| listed = data.get("files") or {} |
| for rel, expected in listed.items(): |
| path = root / rel |
| if not path.exists(): |
| errors.append(f"manifest lists missing file: {rel}") |
| continue |
| if sha256(path) != expected: |
| errors.append(f"hash mismatch: {rel}") |
| checked += 1 |
| data_root = root / "data" |
| if data_root.exists(): |
| for path in sorted(data_root.rglob("*")): |
| if path.is_file(): |
| rel = path.relative_to(root).as_posix() |
| if rel not in listed: |
| errors.append(f"data file is not frozen in manifest.json: {rel}") |
|
|
| family_ids: set[str] = set() |
| family_schema: dict[str, str] = {} |
| corpus_hashes: dict[str, str] = {} |
| corpus_root = root / "data" / "corpus" |
| corpus_files = sorted(corpus_root.glob("*.json")) if corpus_root.exists() else [] |
| for corpus_file in corpus_files: |
| rel = corpus_file.relative_to(root).as_posix() |
| try: |
| corpus = load(corpus_file) |
| except Exception as exc: |
| errors.append(f"{rel}: cannot parse ({exc})") |
| continue |
| schema = corpus.get("schema") |
| if not schema: |
| errors.append(f"{rel}: no schema name") |
| else: |
| corpus_hashes[schema] = sha256(corpus_file) |
| if not corpus.get("ddl"): |
| errors.append(f"{rel}: no schema DDL") |
| for fam in corpus.get("families", []): |
| fid = fam.get("id") |
| if not fid: |
| errors.append(f"{rel}: family without id") |
| continue |
| if fid in family_ids: |
| errors.append(f"duplicate family id: {fid}") |
| family_ids.add(fid) |
| family_schema[fid] = fam.get("schema") or schema |
| if (fam.get("schema") or schema) != schema: |
| errors.append(f"family {fid}: schema differs from {rel}") |
| if not fam.get("reference_sql"): |
| errors.append(f"family {fid}: no reference_sql") |
| if not fam.get("profile"): |
| errors.append(f"family {fid}: no profile") |
| if fam.get("breaking_profile") not in BREAKING_PROFILES: |
| errors.append(f"family {fid}: bad breaking_profile {fam.get('breaking_profile')!r}") |
| checked += 1 |
|
|
| state_counts: dict[str, int] = {} |
| state_pairs = 0 |
| state_file = root / "data" / "states" / "states.json" |
| states_hash: str | None = sha256(state_file) if state_file.exists() else None |
| if state_file.exists(): |
| states = load(state_file) |
| for st in states.get("states", []): |
| state_pairs += 1 |
| fid = st.get("family") |
| if family_ids and fid not in family_ids: |
| errors.append(f"state references unknown family: {fid}") |
| if not st.get("profile"): |
| errors.append(f"state of {fid}: no profile") |
| if st.get("rows") is None: |
| errors.append(f"state {st.get('profile')} of {fid}: no rows") |
| state_counts[fid] = state_counts.get(fid, 0) + 1 |
| checked += 1 |
|
|
| runs_root = root / "data" / "runs" |
| run_slugs = sorted(p.name for p in runs_root.iterdir() if p.is_dir()) if runs_root.exists() else [] |
| run_records = 0 |
| evaluated: set[str] = set() |
| checks = 0 |
| if runs_root.exists(): |
| for path in sorted(runs_root.glob("*/*.json")): |
| rel = path.relative_to(root).as_posix() |
| rec = load(path) |
| run_records += 1 |
| checked += 1 |
| fid = rec.get("family") |
| if fid not in family_ids: |
| errors.append(f"{rel}: run for unknown family {fid!r}") |
| else: |
| evaluated.add(fid) |
| checks += state_counts.get(fid, 0) |
| if fid != path.stem: |
| errors.append(f"{rel}: family does not match file name") |
| if "schema" in rec and rec["schema"] != family_schema.get(fid): |
| errors.append(f"{rel}: run schema does not match corpus schema") |
| if not rec.get("model"): |
| errors.append(f"{rel}: run without model name") |
| if not rec.get("model_digest"): |
| errors.append(f"{rel}: run without model digest") |
| protocol = rec.get("protocol") or {} |
| for field in ("temperature", "num_ctx", "num_predict"): |
| if field not in protocol: |
| errors.append(f"{rel}: protocol without {field}") |
| if "seed" not in protocol: |
| errors.append(f"{rel}: protocol without seed (use null when unset)") |
| if "candidate_sql" not in rec: |
| errors.append(f"{rel}: run without candidate_sql key") |
| if "raw_response" not in rec: |
| errors.append(f"{rel}: run without raw_response") |
| if state_counts.get(fid, 0) == 0: |
| errors.append(f"{rel}: run record for a family without frozen states") |
|
|
| evidence_root = root / "data" / "evidence" |
| evidence_records = 0 |
| if evidence_root.exists(): |
| for path in sorted(evidence_root.glob("*.json")): |
| rel = path.relative_to(root).as_posix() |
| ev = load(path) |
| checked += 1 |
| if ev.get("family") not in family_ids: |
| errors.append(f"{rel}: evidence for unknown family {ev.get('family')!r}") |
| if ev.get("family") != path.stem: |
| errors.append(f"{rel}: family does not match file name") |
| protocol = ev.get("protocol") or {} |
| schema = ev.get("schema") or family_schema.get(ev.get("family")) |
| expected_corpus = corpus_hashes.get(schema) |
| pinned_corpus = protocol.get("corpus_sha256") |
| if not pinned_corpus: |
| errors.append(f"{rel}: protocol without corpus_sha256 pin") |
| elif expected_corpus is None: |
| errors.append(f"{rel}: cannot resolve corpus file for schema {schema!r}") |
| elif pinned_corpus != expected_corpus: |
| errors.append(f"{rel}: stale corpus_sha256 pin " |
| f"({pinned_corpus[:12]}… != {expected_corpus[:12]}…)") |
| pinned_states = protocol.get("state_bank_sha256") |
| if not pinned_states: |
| errors.append(f"{rel}: protocol without state_bank_sha256 pin") |
| elif states_hash is None: |
| errors.append(f"{rel}: state bank file is missing") |
| elif pinned_states != states_hash: |
| errors.append(f"{rel}: stale state_bank_sha256 pin " |
| f"({pinned_states[:12]}… != {states_hash[:12]}…)") |
| records = ev.get("evidence") |
| if isinstance(records, list): |
| for rec in records: |
| evidence_records += 1 |
| rec = dict(rec) |
| rec.setdefault("family", ev.get("family")) |
| check_evidence_record(rel, rec, errors, family_ids) |
| else: |
| evidence_records += 1 |
| check_evidence_record(rel, ev, errors, family_ids) |
|
|
| for fid in sorted(evaluated): |
| if state_counts.get(fid, 0) == 0: |
| errors.append(f"evaluated family without states: {fid}") |
| for slug in run_slugs: |
| if not (runs_root / slug / f"{fid}.json").exists(): |
| errors.append(f"missing run record: {slug}/{fid}.json") |
| if not (evidence_root / f"{fid}.json").exists(): |
| errors.append(f"missing evidence file for evaluated family: {fid}") |
|
|
| counts = (load(manifest).get("counts") or {}) if manifest.exists() else {} |
| if counts: |
| per_family = {state_counts[f] for f in state_counts} |
| spf = per_family.pop() if len(per_family) == 1 else -1 |
| by_schema: dict[str, int] = {} |
| for fid in family_ids: |
| schema = family_schema.get(fid, "") |
| by_schema[schema] = by_schema.get(schema, 0) + 1 |
| derived = { |
| "families": len(family_ids), |
| "families_by_schema": by_schema, |
| "families_with_states": len(state_counts), |
| "evaluated_families": len(evaluated), |
| "states_per_family": spf, |
| "state_family_pairs": state_pairs, |
| "models": len(run_slugs), |
| "run_records": run_records, |
| "evidence_records": evidence_records, |
| "checks": checks, |
| } |
| for key, value in derived.items(): |
| if key in counts and counts[key] != value: |
| errors.append(f"manifest count {key}={counts[key]!r} does not match data ({value!r})") |
|
|
| if errors: |
| print("VALIDATION FAILED") |
| for e in errors: |
| print(" -", e) |
| return 1 |
| print(f"OK: checked {checked} entries, no violations") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| sys.exit(main()) |
|
|
