Blame for validate.py

#!/usr/bin/env python3
"""Validate a generated dataset directory: offsets, label counts, regex detectability, cluster / entity / replacement
consistency (v3), random samples.

Usage: python validate.py --data /path/to/dataset [--sample-files 2] [--n-eyeball 20] [--write-sample sample.jsonl --sample-n 500]
Hard failures (assert): bad offsets, dangling or inconsistent entity ids, surface forms that do not resolve to the
entity's form table, replacements with a different format/charset, replacement collisions inside a cluster,
non-contiguous clusters, duplicate entity ids. The sample written with --write-sample consists of whole clusters.
"""
import argparse, collections, glob, json, os, random, re

SCANNER = {  # a deliberately simple regex scanner (gitleaks-like) used only as a sanity check
    "aws_access_key_id": re.compile(r"AKIA[0-9A-Z]{16}"),
    "github_pat": re.compile(r"gh[pos]_[A-Za-z0-9]{36}"),
    "github_fine_grained_pat": re.compile(r"github_pat_[A-Za-z0-9]{22}_[A-Za-z0-9]{59}"),
    "slack_token": re.compile(r"xox[abp]-[0-9A-Za-z-]{10,}"),
    "jwt": re.compile(r"eyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+"),
    "google_api_key": re.compile(r"AIza[0-9A-Za-z_-]{35}"),
    "stripe_secret_key": re.compile(r"(?:sk|rk)_(?:live|test)_[0-9A-Za-z]{24}"),
    "pem_private_key": re.compile(r"-----BEGIN [A-Z ]*PRIVATE KEY-----"),
    "email": re.compile(r"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}"),
    "sendgrid_api_key": re.compile(r"SG\.[A-Za-z0-9_-]{22}\.[A-Za-z0-9_-]{43}"),
    "openai_api_key": re.compile(r"sk-(?:proj-)?[A-Za-z0-9]{48}"),
    "hf_token": re.compile(r"hf_[A-Za-z0-9]{34}"),
    "gitlab_pat": re.compile(r"glpat-[A-Za-z0-9_-]{20}"),
    "npm_token": re.compile(r"npm_[A-Za-z0-9]{36}"),
    "generic_hex_key": re.compile(r"\b[0-9a-f]{32,64}\b"),
}
PEM_ESCAPE = ("\n", "\\n\" +\n    \"")
PERSON_LABEL = {"full_name": "person_name", "first_name": "person_name", "last_name": "person_name", "username": "username", "handle": "username", "email": "email"}

def charset(v):
    return "+".join(k for k, rx in (("digit", "[0-9]"), ("lower", "[a-z]"), ("symbol", "[^A-Za-z0-9]"), ("upper", "[A-Z]")) if re.search(rx, v))

def check_cluster(recs, st, problems):
    """All invariants that need the whole cluster: entity table on doc 0, ids, forms, replacements, uniqueness."""
    cid = recs[0]["cluster_id"]
    if [r["doc_index"] for r in recs] != list(range(len(recs))) or any(r["cluster_size"] != len(recs) or r["cluster_kind"] != recs[0]["cluster_kind"] for r in recs):
        problems["cluster_shape"] += 1
    if recs[0]["entities"] is None or any(r["entities"] is not None for r in recs[1:]):
        problems["entities_placement"] += 1
    ents = {e["entity_id"]: e for e in (recs[0]["entities"] or [])}
    if len(ents) != len(recs[0]["entities"] or []):
        problems["duplicate_entity_id"] += 1
    seen = collections.Counter(); docs = collections.defaultdict(set)
    originals = set(); replacements = set()
    for e in ents.values():
        if not e["entity_id"].startswith(cid + "/"): problems["entity_id_prefix"] += 1
        if e["owner_entity_id"] is not None and ents.get(e["owner_entity_id"], {}).get("entity_type") != "person": problems["owner_unresolved"] += 1
        if e["entity_type"] == "person" and set(e["forms"]) != {"full_name", "first_name", "last_name", "username", "handle", "email"}: problems["person_forms"] += 1
        if e["entity_type"] != "person" and (e["forms"].get("literal") != e["canonical"] or e["replacement_forms"].get("literal") != e["replacement_canonical"]): problems["canonical_form"] += 1
        for k, v in e["forms"].items():
            originals.add(v)
            rv = e["replacement_forms"].get(k)
            if rv is None or rv == v: problems["replacement_missing_or_same"] += 1
            else: replacements.add(rv)
        if e["entity_type"] != "person":
            v, rv = e["canonical"], e["replacement_canonical"]
            rx = SCANNER.get(e["value_type"])
            if rx and bool(rx.search(v)) != bool(rx.search(rv)): problems["replacement_format"] += 1
            if e["value_type"] not in ("jwt", "basic_auth_b64") and charset(v) != charset(rv): problems["replacement_charset"] += 1
            if e["value_type"] not in ("password", "email", "jwt", "basic_auth_b64") and len(v) != len(rv): problems["replacement_length"] += 1
            if e["value_type"] == "pem_private_key" and v.split("\n")[0] != rv.split("\n")[0]: problems["replacement_pem_kind"] += 1
    if originals & replacements: problems["replacement_equals_original"] += 1
    for r in recs:
        t = r["text"]
        for s in r["spans"]:
            e = ents.get(s["entity_id"])
            if e is None: problems["span_entity_missing"] += 1; continue
            seen[e["entity_id"]] += 1; docs[e["entity_id"]].add(r["doc_index"])
            k = s["surface_form_type"]; fk = "literal" if k == "escaped_literal" else k
            form, repl = e["forms"].get(fk), e["replacement_forms"].get(fk)
            if k == "escaped_literal": form = form and form.replace(*PEM_ESCAPE); repl = repl and repl.replace(*PEM_ESCAPE)
            if form != s["value"]: problems["span_form_mismatch"] += 1
            if repl != s["replacement"]: problems["span_replacement_mismatch"] += 1
            exp_label = PERSON_LABEL.get(fk, e["entity_type"]) if e["entity_type"] == "person" else e["entity_type"]
            if s["label"] != exp_label: problems["span_label_vs_entity"] += 1
            st["surface_form"][k] += 1
        for s in r["hard_negatives"]:
            if s.get("entity_id") is not None or s.get("replacement") is not None: problems["negative_with_entity"] += 1
    for eid, e in ents.items():
        if seen[eid] == 0: problems["entity_without_span"] += 1
        if seen[eid] != e["n_mentions"] or len(docs[eid]) != e["n_docs"]: problems["entity_counts"] += 1
        st["entity_type"][e["entity_type"]] += 1
        st["docs_per_entity"][min(e["n_docs"], 6)] += 1; st["mentions_per_entity"][min(e["n_mentions"], 8)] += 1
        if e["owner_entity_id"]: st["owned_entities"] += 1
        if len(recs) > 1:
            st["multi_entities"] += 1; st["recurring_entities"] += e["n_docs"] > 1
    # gold anonymized text must keep the same scanner hits at the same spans (replacements are format-preserving)
    r = recs[0]; t = r["text"]; out = []; pos = 0; ok = True
    for s in sorted(r["spans"], key=lambda s: s["start"]):
        out.append(t[pos:s["start"]]); out.append(s["replacement"]); pos = s["end"]
        rx = SCANNER.get(s["value_type"])
        if rx and bool(rx.search(s["value"])) and not rx.search(s["replacement"]): ok = False
    out.append(t[pos:]); anon = "".join(out)
    if any(s["value"] in anon for s in r["spans"] if len(s["value"]) >= 8): problems["original_survives_in_gold_anonymized"] += 1
    if not ok: problems["gold_anonymized_scanner"] += 1
    st["clusters"] += 1; st["cluster_kind"][r["cluster_kind"]] += 1; st["cluster_size"][min(len(recs), 8)] += 1

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--data", required=True)
    ap.add_argument("--sample-files", type=int, default=2)
    ap.add_argument("--n-eyeball", type=int, default=20)
    ap.add_argument("--write-sample")
    ap.add_argument("--sample-n", type=int, default=500, help="approximate number of records (whole clusters are kept)")
    ap.add_argument("--seed", type=int, default=0)
    a = ap.parse_args()
    random.seed(a.seed)
    parts = sorted(glob.glob(os.path.join(a.data, "part-?????.jsonl")))
    use = parts[:a.sample_files]
    C = collections.Counter
    st = dict(files=0, injected=0, clean=0, spans=0, negs=0, bad_offsets=0, label=C(), vtype=C(), ctx=C(), lang=C(), negtype=C(),
              size_hist=C(), spans_per_file=C(), bytes=0, clusters=0, cluster_kind=C(), cluster_size=C(), entity_type=C(),
              docs_per_entity=C(), mentions_per_entity=C(), surface_form=C(), owned_entities=0, multi_entities=0, recurring_entities=0, cross_cluster_value_reuse_dictionary=0)
    problems = C(); det = C(); det_tot = C()
    all_entity_ids = set(); all_canonicals = C()
    reservoir = []; n_seen = 0      # reservoir over clusters
    for p in use:
        cur = []
        def finish():
            nonlocal n_seen
            if not cur: return
            check_cluster(cur, st, problems)
            for e in (cur[0]["entities"] or []):
                if e["entity_id"] in all_entity_ids: problems["global_duplicate_entity_id"] += 1
                all_entity_ids.add(e["entity_id"])
                if e["entity_type"] != "person": all_canonicals[(e["value_type"], e["canonical"])] += 1
            n_seen += 1
            if len(reservoir) < a.sample_n:
                reservoir.append(list(cur))
            else:
                j = random.randrange(n_seen)
                if j < a.sample_n: reservoir[j] = list(cur)
            cur.clear()
        with open(p, encoding="utf-8") as fh:
            for line in fh:
                r = json.loads(line); t = r["text"]
                if cur and r["cluster_id"] != cur[0]["cluster_id"]:
                    finish()
                cur.append(r)
                st["files"] += 1; st["bytes"] += len(line)
                st["lang"][r["language"]] += 1
                st["size_hist"][("<1KB" if len(t) < 1024 else "<10KB" if len(t) < 10240 else "<100KB" if len(t) < 102400 else ">=100KB")] += 1
                st["spans_per_file"][min(len(r["spans"]), 6)] += 1
                st["injected" if r["spans"] else "clean"] += 1
                for s in r["spans"] + r["hard_negatives"]:
                    if t[s["start"]:s["end"]] != s["value"]:
                        st["bad_offsets"] += 1
                prev_end = -1
                for s in sorted(r["spans"] + r["hard_negatives"], key=lambda s: s["start"]):
                    if s["start"] < prev_end: problems["overlap"] += 1
                    prev_end = s["end"]
                for s in r["spans"]:
                    st["spans"] += 1; st["label"][s["label"]] += 1; st["vtype"][s["value_type"]] += 1; st["ctx"][s["context"]] += 1
                    rx = SCANNER.get(s["value_type"])
                    if rx:
                        det_tot[s["value_type"]] += 1
                        if rx.search(s["value"]) and any(m.start() <= s["start"] < m.end() for m in rx.finditer(t)):
                            det[s["value_type"]] += 1
                for s in r["hard_negatives"]:
                    st["negs"] += 1; st["negtype"][s["value_type"]] += 1
        finish()
    # short dictionary passwords / emails legitimately recur across clusters (reported); long random values must not
    st["cross_cluster_value_reuse_dictionary"] = sum(1 for (vt, v), n in all_canonicals.items() if n > 1 and vt in ("password", "email"))
    problems["cross_cluster_value_reuse_random"] = sum(1 for (vt, v), n in all_canonicals.items() if n > 1 and vt not in ("password", "email"))
    out = {k: (dict(v.most_common()) if isinstance(v, C) else v) for k, v in st.items()}
    out["regex_detectability"] = {k: f"{det[k]}/{det_tot[k]} ({100*det[k]/det_tot[k]:.1f}%)" for k in sorted(det_tot)}
    out["problems"] = dict(problems)
    print(json.dumps(out, indent=1))
    assert st["bad_offsets"] == 0, st["bad_offsets"]
    assert not any(problems.values()), problems
    if a.write_sample:
        with open(a.write_sample, "w", encoding="utf-8") as fh:
            for cl in reservoir:
                for r in cl:
                    fh.write(json.dumps(r, ensure_ascii=False) + "\n")
    print("\n===== EYEBALL SAMPLES (clusters) =====")
    eye = [cl for cl in reservoir if any(r["spans"] or r["hard_negatives"] for r in cl)]
    for cl in random.sample(eye, min(a.n_eyeball, len(eye))):
        print(f"\n=== {cl[0]['cluster_id']} {cl[0]['cluster_kind']} size={len(cl)}")
        for e in cl[0]["entities"] or []:
            print(f"  ENT {e['entity_id'][-4:]} {e['entity_type']}/{e['value_type']} {e['canonical'][:40]!r} -> {e['replacement_canonical'][:40]!r} owner={e['owner_entity_id'] and e['owner_entity_id'][-4:]} docs={e['n_docs']} mentions={e['n_mentions']}")
        for r in cl:
            t = r["text"]
            print(f"--- doc {r['doc_index']} {r['id']} {r['language']} {r['path']}")
            for s in r["spans"] + r["hard_negatives"]:
                ls = t.rfind("\n", 0, s["start"]) + 1; le = t.find("\n", s["end"]); le = len(t) if le < 0 else le
                eid = s.get("entity_id"); eid = eid[-4:] if eid else "-"
                print(f"  [{s['label']}/{s['value_type']} {eid}] {t[ls:le][:140]!r}")

if __name__ == "__main__":
    main()