"""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: # noqa: BLE001 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())