#!/usr/bin/env python3 """Validate the CodeMixCheck release folder. python scripts/validate_dataset.py # checks the public repo python scripts/validate_dataset.py --hf # also load every config with `datasets` python scripts/validate_dataset.py --report out.md Exit code 0 = every check PASSed (WARN does not fail the run). Checks: file integrity (sha256 vs data_manifest.json), row counts, column schema, label vocabularies, split validity, provenance completeness, duplicates, missing required values, private-data screen, README statistics block, CITATION.cff metadata and (optionally) Hugging Face loading. """ from __future__ import annotations import argparse import hashlib import json import re import sys from pathlib import Path import pandas as pd import pyarrow.parquet as pq ROOT = Path(__file__).resolve().parents[1] sys.path.insert(0, str(ROOT / "scripts")) from dataset_statistics import load, normalize, render_markdown # noqa: E402 VERSION = "2.2.1" LABELS = { "fact_verification": {"True", "False", "Partially True", "Unverifiable"}, "sentiment": {"positive", "negative", "neutral"}, "abuse_detection": {"abusive", "not_abusive"}, } LABEL_3WAY = {"True": "SUPPORTED", "False": "REFUTED", "Unverifiable": "NOT_ENOUGH_INFO", "Partially True": None} SPLITS = { "fact_verification": {"train", "validation", "test_synthetic", "test_curated"}, "sentiment": {"train", "validation", "test_human", "silver_unverified"}, "abuse_detection": {"train", "validation", "test_synthetic"}, } COMMON = ["id", "text", "label", "hf_split", "split_v2_2_1", "eval_subset", "cv_fold", "label_status", "label_origin", "human_validated", "label_source", "review_flag", "annotation_note", "content_flag", "domain", "register", "tone", "post_format", "noise_level", "script", "tamil_script_token_ratio", "provenance", "provenance_class", "data_origin", "source_detail", "source_reference", "generator", "generation_batch", "release_tier", "template_group", "content_group", "is_content_duplicate", "change_v2_1", "change_v2_2", "change_v2_2_1", "audit_flags", "task"] SPECIFIC = {"fact_verification": ["label_3way", "evidence_explanation", "proposition", "frame_family"], "sentiment": ["abuse_label", "sentiment_label_suggested"], "abuse_detection": ["sentiment_label"]} REQUIRED_NON_NULL = ["id", "text", "label", "hf_split", "label_status", "label_origin", "human_validated", "script", "provenance", "provenance_class", "release_tier", "content_group", "task"] PLACEHOLDER_HANDLES = {"@someone", "@ourvillage_updates", "@localnews_tn", "@classmates_group", "@my_friend_circle", "@somone", "@amma", "@smeone", "@office_gang", "@somene", "@SOMEONE"} results: list[tuple[str, str, str]] = [] def check(name: str, ok: bool, detail: str = "", warn: bool = False): results.append((("PASS" if ok else ("WARN" if warn else "FAIL")), name, detail)) def main(): ap = argparse.ArgumentParser() ap.add_argument("--root", default=str(ROOT)) ap.add_argument("--hf", action="store_true", help="also load each config with datasets.load_dataset") ap.add_argument("--report") ap.add_argument("--allow-withheld", action="store_true", help="permit rows whose release_tier is not public (private/full builds only)") a = ap.parse_args() root = Path(a.root) data_dir = root / "data" # ---- manifest / integrity man = json.loads((root / "data_manifest.json").read_text()) files = sorted(data_dir.rglob("*.parquet")) listed = {m["path"] for m in man["files"]} check("manifest lists exactly the parquet files present", listed == {str(f.relative_to(root)) for f in files}, f"{len(files)} files") for m in man["files"]: p = root / m["path"] try: pf = pq.ParquetFile(p) n = pf.metadata.num_rows sha = hashlib.sha256(p.read_bytes()).hexdigest() check(f"integrity {m['path']}", sha == m["sha256"], "sha256 match" if sha == m["sha256"] else "sha256 MISMATCH") check(f"row count {m['path']}", n == m["rows"], f"{n} rows (manifest {m['rows']})") except Exception as e: # noqa: BLE001 check(f"readable {m['path']}", False, repr(e)) data = load(data_dir) all_ids, all_text = [], [] for cfg, df in data.items(): # ---- schema expected = ["id", "text", "label"] + SPECIFIC[cfg] + COMMON[3:] cols = [c for c in df.columns if c != "_file"] check(f"{cfg}: column schema", cols == expected, "ok" if cols == expected else f"missing={set(expected)-set(cols)} extra={set(cols)-set(expected)}") types_ok = (str(df.cv_fold.dtype) in ("Int8", "float64", "int8")) and df.tamil_script_token_ratio.dtype.kind == "f" \ and df.is_content_duplicate.dtype == bool check(f"{cfg}: column dtypes", types_ok, f"cv_fold={df.cv_fold.dtype}, ratio={df.tamil_script_token_ratio.dtype}") # ---- labels bad = df[~df.label.isin(LABELS[cfg])] check(f"{cfg}: label vocabulary", bad.empty, f"{len(bad)} invalid") check(f"{cfg}: task column", (df.task == cfg).all()) if cfg == "fact_verification": exp3 = df.label.map(LABEL_3WAY) ok3 = ((exp3.isna() & df.label_3way.isna()) | (exp3 == df.label_3way)).all() check(f"{cfg}: label_3way consistent with label", bool(ok3)) # ---- splits check(f"{cfg}: hf_split matches file name", (df.hf_split == df._file).all()) check(f"{cfg}: split names valid", set(df._file) <= SPLITS[cfg], str(sorted(set(df._file)))) syn_in_curated = df[(df._file.isin(["test_curated", "test_human"])) & (df.provenance == "template_generated")] nonsyn_in_syn = df[(df._file.isin(["train", "validation", "test_synthetic"])) & (df.provenance != "template_generated")] check(f"{cfg}: synthetic and curated/human evaluation subsets not mixed", syn_in_curated.empty and nonsyn_in_syn.empty) silver_ok = ((df._file == "silver_unverified") == (df.label_status == "silver")).all() check(f"{cfg}: silver labels only in silver_unverified", bool(silver_ok)) if (df.label_status == "silver").any(): check(f"{cfg}: silver rows never marked human-validated", not df[(df.label_status == "silver")].human_validated.isin(["user_labelled", "yes"]).any()) # ---- provenance / missing nulls = {c: int(df[c].isna().sum()) for c in REQUIRED_NON_NULL} check(f"{cfg}: required fields non-null", not any(nulls.values()), str({k: v for k, v in nulls.items() if v})) check(f"{cfg}: provenance_class consistent with provenance", (df.groupby("provenance").provenance_class.nunique() == 1).all()) if not a.allow_withheld: wh = df[~df.release_tier.str.startswith("public")] check(f"{cfg}: no withheld records in public files", wh.empty, f"{len(wh)} withheld rows") # ---- private data screen urls = df.text.str.contains(r"https?://|www\.", regex=True) emails = df.text.str.contains(r"[\w.]+@[\w-]+\.[a-z]{2,}", regex=True) phones = df.text.str.contains(r"\b\d{10}\b|\+91", regex=True) check(f"{cfg}: no URLs / e-mails / phone numbers in text", not (urls | emails | phones).any(), f"url={int(urls.sum())} email={int(emails.sum())} phone={int(phones.sum())}") handles = {h for t in df.text for h in re.findall(r"@\w+", t)} check(f"{cfg}: @handles limited to documented template placeholders", handles <= PLACEHOLDER_HANDLES, f"unexpected={sorted(handles - PLACEHOLDER_HANDLES)}") priv_cols = [c for c in df.columns if re.search(r"user(name)?_?handle|profile|url|email|phone", c)] check(f"{cfg}: no private-metadata columns", not priv_cols, str(priv_cols)) # ---- duplicates (within config) check(f"{cfg}: unique ids", not df.id.duplicated().any()) check(f"{cfg}: no exact duplicate texts", not df.text.duplicated().any()) norm = df.text.map(normalize) xs = (pd.DataFrame({"n": norm, "f": df._file}).groupby("n").f.nunique() > 1).sum() check(f"{cfg}: no normalised-identical text shared across splits", xs == 0, f"{xs} shared") nd = int(df.audit_flags.map(lambda x: "D02" in x or "D01" in x).sum()) check(f"{cfg}: cross-split near-duplicate / same-claim rows are flagged (not removed)", True, f"{nd} rows carry D01/D02 flags - see docs/limitations.md", warn=False) all_ids += list(df.id) all_text += list(df.text) check("ids unique across all configs", len(all_ids) == len(set(all_ids)), f"{len(all_ids)} ids") check("texts unique across all configs", len(all_text) == len(set(all_text))) # ---- README stats block readme = (root / "README.md").read_text() m = re.search(r"\n(.*?)", readme, re.S) if m: fresh = render_markdown(data) check("README statistics block matches files", m.group(1) == fresh, "identical" if m.group(1) == fresh else "README stats are stale - re-run build") else: check("README statistics block present", False) yaml_head = readme.split("---")[1] for cfg in data: for f in sorted((data_dir / cfg).glob("*.parquet")): check(f"README configs reference data/{cfg}/{f.name}", f"data/{cfg}/{f.name}" in yaml_head) check("README states version", VERSION in readme) # ---- CITATION.cff try: import yaml # type: ignore cff = yaml.safe_load((root / "CITATION.cff").read_text()) check("CITATION.cff parses", True) check("CITATION.cff version", str(cff.get("version")) == VERSION, str(cff.get("version"))) check("CITATION.cff type=dataset", cff.get("type") == "dataset") check("CITATION.cff has no DOI claimed", "doi" not in cff and "identifiers" not in cff, "", warn=True) except Exception as e: # noqa: BLE001 check("CITATION.cff parses", False, repr(e)) # ---- HF loading if a.hf: try: from datasets import load_dataset for cfg in data: ds = load_dataset(str(root), cfg) exp = {k: int(v) for k, v in data[cfg]._file.value_counts().items()} got = {k: len(v) for k, v in ds.items()} check(f"datasets.load_dataset('{cfg}') split sizes", got == exp, str(got)) except Exception as e: # noqa: BLE001 check("datasets.load_dataset", False, repr(e)[:300]) width = max(len(r[1]) for r in results) lines = [f"{s:4s} {n.ljust(width)} {d}" for s, n, d in results] print("\n".join(lines)) n_fail = sum(s == "FAIL" for s, _, _ in results) summary = f"\n{len(results)} checks: {sum(s == 'PASS' for s, _, _ in results)} PASS, " \ f"{sum(s == 'WARN' for s, _, _ in results)} WARN, {n_fail} FAIL" print(summary) if a.report: Path(a.report).write_text("| status | check | detail |\n|---|---|---|\n" + "\n".join(f"| {s} | {n} | {d.replace('|', '/')} |" for s, n, d in results) + "\n\n" + summary.strip() + "\n") sys.exit(1 if n_fail else 0) if __name__ == "__main__": main()