#!/usr/bin/env python3 """ 03_validate_data.py Rigorous, independent data validation gate for the NORA Bengali memory benchmark. Validates: 1. File presence and SHA-256 cryptographic hashes matching manifest.json. 2. Corpus node counts (1,028 Agri, 735 Legal, 190 Edu; Total 1,953). 3. Query counts (2,000 Agri, 1,100 Legal, 570 Edu; Total 3,670). 4. Chunk counts (4,526 Agri, 4,202 Legal, 892 Edu; Total 9,620). 5. 100% referential integrity between queries, chunk mappings, and gold corpus nodes. 6. Agent evaluation subsets: 900 candidate sample -> 872 common subset + 28 timeout exclusions. 7. Counterfactual perturbation sample (300 queries). Usage: python 03_validate_data.py [--data_dir PATH] """ import os import sys import json import hashlib import argparse from pathlib import Path if hasattr(sys.stdout, "reconfigure"): sys.stdout.reconfigure(encoding="utf-8", errors="replace") SCRIPT_DIR = Path(__file__).resolve().parent REPO_ROOT = SCRIPT_DIR.parent.parent.parent DEFAULT_DATA_DIR = REPO_ROOT / "reproducibility" / "dataset" EXPECTED_COUNTS = { "agriculture": {"nodes": 1028, "chunks": 4526, "queries": 2000}, "legal": {"nodes": 735, "chunks": 4202, "queries": 1100}, "education": {"nodes": 190, "chunks": 892, "queries": 570}, } def compute_sha256(filepath: Path) -> str: h = hashlib.sha256() with open(filepath, "rb") as f: while chunk := f.read(8192): h.update(chunk) return h.hexdigest() def run_validation_gate(data_dir: Path) -> bool: print("=" * 75) print("03_VALIDATE_DATA: EXECUTING REPRODUCIBILITY AUDIT GATE") print("=" * 75) failures = [] # 1. Manifest and Hash Verification manifest_path = data_dir / "manifest.json" if not manifest_path.exists(): print(f"[CRITICAL FAIL] manifest.json missing from {data_dir}") return False with open(manifest_path, "r", encoding="utf-8") as f: manifest = json.load(f) files_dict = manifest.get("files", {}) print(f"\n[1/5] Cryptographic Hash Verification ({len(files_dict)} registered files)...") hash_mismatches = 0 for rel_path, meta in files_dict.items(): full_p = data_dir / rel_path if not full_p.exists(): print(f" [MISSING] {rel_path}") failures.append(f"Missing file: {rel_path}") continue actual_hash = compute_sha256(full_p) expected_hash = meta["sha256"] if actual_hash != expected_hash: print(f" [HASH MISMATCH] {rel_path}: expected {expected_hash[:10]}..., got {actual_hash[:10]}...") failures.append(f"Hash mismatch: {rel_path}") hash_mismatches += 1 if hash_mismatches == 0: print(" -> All 100% of dataset SHA-256 hashes match manifest.json exactly.") # 2. Node, Chunk, and Query Census print("\n[2/5] Domain Node, Chunk, and Query Census Verification...") total_nodes = 0 total_chunks = 0 total_queries = 0 corpus_node_ids = {} for domain, expected in EXPECTED_COUNTS.items(): # Nodes node_p = data_dir / "processed" / domain / "structured_nodes.json" with open(node_p, "r", encoding="utf-8") as fp: nodes = json.load(fp) n_count = len(nodes) total_nodes += n_count corpus_node_ids[domain] = set(n["node_id"] for n in nodes) if n_count != expected["nodes"]: failures.append(f"{domain} node count mismatch: {n_count} != {expected['nodes']}") # Chunks chunk_p = data_dir / "processed" / domain / "unstructured_chunks.json" with open(chunk_p, "r", encoding="utf-8") as fp: chunks = json.load(fp) c_count = len(chunks) total_chunks += c_count if c_count != expected["chunks"]: failures.append(f"{domain} chunk count mismatch: {c_count} != {expected['chunks']}") # Queries query_p = data_dir / "processed" / domain / "queries.jsonl" with open(query_p, "r", encoding="utf-8") as fp: queries = [json.loads(line) for line in fp if line.strip()] q_count = len(queries) total_queries += q_count if q_count != expected["queries"]: failures.append(f"{domain} query count mismatch: {q_count} != {expected['queries']}") print(f" [{domain.upper()}] Nodes: {n_count}/{expected['nodes']} | Chunks: {c_count}/{expected['chunks']} | Queries: {q_count}/{expected['queries']} [OK]") print(f" -> Total Corpus Nodes: {total_nodes:,} / 1,953") print(f" -> Total Unstruct Chunks:{total_chunks:,} / 9,620") print(f" -> Total Eval Queries: {total_queries:,} / 3,670") if total_nodes != 1953 or total_chunks != 9620 or total_queries != 3670: failures.append("Census totals mismatch paper claims.") # 3. Referential Integrity (Queries -> Nodes) print("\n[3/5] Referential Integrity (100% Query -> Ground Truth Mapping)...") dangling_queries = 0 for domain in EXPECTED_COUNTS: query_p = data_dir / "processed" / domain / "queries.jsonl" with open(query_p, "r", encoding="utf-8") as fp: queries = [json.loads(line) for line in fp if line.strip()] valid_nodes = corpus_node_ids[domain] for q in queries: src = q.get("source_nodes", []) if isinstance(src, (str, dict)): src = [src] for item in src: if isinstance(item, dict): target_id = item.get("node_id") else: target_id = item if target_id and target_id not in valid_nodes: dangling_queries += 1 failures.append(f"Query {q['query_id']} targets unknown node {target_id}") if dangling_queries == 0: print(" -> 100% of benchmark queries map strictly to valid ground-truth nodes.") # 4. Agent Evaluation Subsets (900 Sample -> 872 Common + 28 Timeouts) print("\n[4/5] Agent Memory Subsets Audit...") p_900 = data_dir / "derived" / "agent_subsets" / "sample_900.json" p_872 = data_dir / "derived" / "agent_subsets" / "sample_872_common.json" p_28 = data_dir / "derived" / "agent_subsets" / "excluded_28_timeouts.json" with open(p_900, "r", encoding="utf-8") as f: s_900 = json.load(f) with open(p_872, "r", encoding="utf-8") as f: s_872 = json.load(f) with open(p_28, "r", encoding="utf-8") as f: s_28 = json.load(f) print(f" - Candidate Agent Sample: {len(s_900)} queries (Expected 900)") print(f" - Evaluated Common Subset: {len(s_872)} queries (Expected 872; 286 Agri, 289 Legal, 297 Edu)") print(f" - Documented Timeouts: {len(s_28)} queries (Expected 28; 14 Agri, 11 Legal, 3 Edu)") if len(s_900) != 900 or len(s_872) != 872 or len(s_28) != 28: failures.append("Agent subset counts do not match 900 -> 872 + 28 protocol.") set_900 = set(x["query_id"] for x in s_900) set_872 = set(x["query_id"] for x in s_872) set_28 = set(x["query_id"] for x in s_28) if set_872 | set_28 != set_900 or len(set_872 & set_28) != 0: failures.append("Partitioning failure: 872 and 28 do not form an exact disjoint partition of 900.") else: print(" -> Mechanical partition: 872 common queries + 28 timeouts == 900 candidate queries.") # 5. Perturbation Sample Audit print("\n[5/5] Counterfactual Perturbation Sample Audit...") p_300 = data_dir / "derived" / "perturbation_subsets" / "sample_300.json" with open(p_300, "r", encoding="utf-8") as f: s_300 = json.load(f) print(f" - Perturbation Sample: {len(s_300)} queries (Expected 300)") if len(s_300) != 300: failures.append("Perturbation sample count is not 300.") # Final Verdict print("\n" + "=" * 75) if len(failures) == 0: print("DATA VALIDATION AUDIT: PASS") print("All experimental datasets, hashes, subsets, and mappings are verified.") print("=" * 75) return True else: print("DATA VALIDATION AUDIT: FAIL") print(f"Detected {len(failures)} verification failure(s):") for fail in failures[:10]: print(f" - {fail}") print("=" * 75) return False def main(): parser = argparse.ArgumentParser(description="Run the independent data validation audit gate.") parser.add_argument("--data_dir", type=str, default=str(DEFAULT_DATA_DIR), help="Path to reproducibility/dataset folder") args = parser.parse_args() data_dir = Path(args.data_dir).resolve() success = run_validation_gate(data_dir) sys.exit(0 if success else 1) if __name__ == "__main__": main()