| |
| """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 |
|
|
| 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" |
|
|
| |
| 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: |
| check(f"readable {m['path']}", False, repr(e)) |
|
|
| data = load(data_dir) |
| all_ids, all_text = [], [] |
| for cfg, df in data.items(): |
| |
| 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}") |
| |
| 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)) |
| |
| 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()) |
| |
| 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") |
| |
| 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)) |
| |
| 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 = (root / "README.md").read_text() |
| m = re.search(r"<!-- STATS:BEGIN -->\n(.*?)<!-- STATS:END -->", 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) |
|
|
| |
| try: |
| import yaml |
| 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: |
| check("CITATION.cff parses", False, repr(e)) |
|
|
| |
| 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: |
| 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() |
|
|
