scripts/validate.py

#!/usr/bin/env python3
"""
Validate the UnsolvedMed (ulamai/UnsolvedMedical) dataset (v1.0.0 / v1.5.0 / v2.0.0) against:
  1. JSON Schemas in schemas/ (problem, source, status_event, relation, query_manifest)
  2. All 18 Publication Gates (Section 3)
  3. Exact category quotas (10,000 for v1.0, 15,000 for v1.5, 20,000 for v2.0 + 10% Gold Seed + 100 calibration audit)
  4. Portfolio & source diversity guardrails (Sections 12.6, 12.7, 12.8)
  5. Strict data hygiene: zero raw documents/excerpts, zero noisy case reports/protocols, and total repo footprint < 400 MB
"""

import json
import re
import sys
from collections import Counter
from pathlib import Path

from jsonschema import Draft202012Validator

ROOT = Path(__file__).resolve().parent.parent

BASE_CATEGORY_QUOTAS = {
    "oncology_and_hematology": 800,
    "cardiovascular_and_cerebrovascular_medicine": 600,
    "neurology": 600,
    "mental_health_behavioral_health_and_addiction": 600,
    "infectious_diseases_tropical_medicine_and_amr": 800,
    "respiratory_and_sleep_medicine": 400,
    "endocrine_metabolic_obesity_and_nutrition_medicine": 500,
    "gastroenterology_hepatology_and_pancreatic_disease": 400,
    "kidney_urinary_and_reproductive_urology": 360,
    "immunology_rheumatology_and_allergy": 440,
    "musculoskeletal_orthopedics_pain_and_dermatology": 400,
    "reproductive_maternal_and_womens_health": 500,
    "pediatrics_neonatology_and_adolescent_medicine": 500,
    "aging_geriatrics_dementia_and_palliative_medicine": 400,
    "surgery_anesthesia_critical_care_emergency_and_trauma": 500,
    "diagnostics_imaging_pathology_laboratory_and_genomic_medicine": 500,
    "prevention_primary_care_public_health_and_population_medicine": 500,
    "health_services_implementation_quality_and_patient_safety": 400,
    "rehabilitation_disability_sensory_oral_and_communication_health": 400,
    "rare_multisystem_and_undiagnosed_conditions": 400,
}

CLINICAL_ADVICE_PATTERNS = re.compile(
    r"\b(should i take|what ointment should i|by how many units per hour should i|my doctor|my symptoms)\b",
    re.I,
)

NOISE_PATTERNS = re.compile(
    r"\b(case report|a case of|two cases of|three cases of|case series|study protocol|protocol for|"
    r"trial protocol|corrigendum|erratum|retracted|retraction|comment on|reply to|author response|"
    r"letter to|editorial|book review|conference abstract|in mice|mouse model|murine model|"
    r"in rats|rat model|zebrafish|drosophila|in vitro|cell line)\b",
    re.I,
)

HTML_ENTITY_RE = re.compile(r"&(amp|lt|gt|quot|apos|#\d+|#x[0-9a-f]+);", re.I)


def load_jsonl(path: Path) -> list[dict]:
    with path.open("r", encoding="utf-8") as f:
        return [json.loads(line) for line in f if line.strip()]


def main() -> int:
    errors = []

    print("1. Loading schemas and dataset artifacts...")
    stats = json.loads((ROOT / "statistics.json").read_text(encoding="utf-8"))
    version = stats.get("version", "3.0.0")
    scale_factor = {"1.0.0": 1.0, "1.5.0": 1.5, "2.0.0": 2.0, "3.0.0": 2.0}.get(version, 2.0)
    expected_category_quotas = {k: int(round(v * scale_factor)) for k, v in BASE_CATEGORY_QUOTAS.items()}
    expected_total_published = sum(expected_category_quotas.values())
    expected_total_gold = expected_total_published // 10
    expected_total_all = expected_total_published + 100

    prob_schema = json.loads((ROOT / "schemas" / "problem.schema.json").read_text(encoding="utf-8"))
    src_schema = json.loads((ROOT / "schemas" / "source.schema.json").read_text(encoding="utf-8"))
    stat_schema = json.loads((ROOT / "schemas" / "status_event.schema.json").read_text(encoding="utf-8"))
    rel_schema = json.loads((ROOT / "schemas" / "relation.schema.json").read_text(encoding="utf-8"))
    qm_schema = json.loads((ROOT / "schemas" / "query_manifest.schema.json").read_text(encoding="utf-8"))

    prob_validator = Draft202012Validator(prob_schema)
    src_validator = Draft202012Validator(src_schema)
    stat_validator = Draft202012Validator(stat_schema)
    rel_validator = Draft202012Validator(rel_schema)
    qm_validator = Draft202012Validator(qm_schema)

    current_problems = json.loads((ROOT / "problems.json").read_text(encoding="utf-8"))
    gold_problems = load_jsonl(ROOT / "data" / "gold" / "problems.jsonl")
    archived_problems = load_jsonl(ROOT / "data" / "archived" / "problems.jsonl")
    all_problems = current_problems + archived_problems
    dataset_bundle = json.loads((ROOT / "dataset.json").read_text(encoding="utf-8"))
    if len(dataset_bundle.get("problems", [])) != expected_total_all:
        errors.append(f"dataset.json problems count {len(dataset_bundle.get('problems', []))} != {expected_total_all}")
    sources = json.loads((ROOT / "source_registry.json").read_text(encoding="utf-8"))
    relations = load_jsonl(ROOT / "relations" / "relations.jsonl")
    status_events = load_jsonl(ROOT / "history" / "status_events.jsonl")

    if (ROOT / "raw").exists():
        errors.append("Raw directory `raw/` should not exist in the published repository")

    total_bytes = sum(
        f.stat().st_size for f in ROOT.rglob("*") if f.is_file() and ".git" not in f.parts
    )
    total_mb = total_bytes / (1024 * 1024)
    print(f"   Total repository footprint (excluding .git): {total_mb:.1f} MB")
    if total_mb >= 400.0:
        errors.append(f"Total repository size {total_mb:.1f} MB exceeds the 400 MB limit")

    if len(current_problems) != expected_total_published:
        errors.append(f"Expected {expected_total_published} current problems, found {len(current_problems)}")
    if len(gold_problems) != expected_total_gold:
        errors.append(f"Expected {expected_total_gold} gold problems, found {len(gold_problems)}")
    if len(all_problems) != expected_total_all:
        errors.append(f"Expected {expected_total_all} total records, found {len(all_problems)}")

    print("2. Validating JSON Schemas across all records, sources, status events, relations, and query manifests...")
    for r in all_problems:
        for err in prob_validator.iter_errors(r):
            errors.append(f"Problem {r.get('id')} schema error: {err.message}")
            if len(errors) > 50:
                break

    source_ids = set()
    for s in sources:
        source_ids.add(s["source_id"])
        for err in src_validator.iter_errors(s):
            errors.append(f"Source {s.get('source_id')} schema error: {err.message}")

    for ev in status_events:
        for err in stat_validator.iter_errors(ev):
            errors.append(f"Status event {ev.get('event_id')} schema error: {err.message}")

    all_ids = {r["id"] for r in all_problems}
    for rel in relations:
        for err in rel_validator.iter_errors(rel):
            errors.append(f"Relation {rel.get('relation_id')} schema error: {err.message}")
        if rel["subject_id"] not in all_ids:
            errors.append(f"Relation {rel['relation_id']} has unknown subject_id {rel['subject_id']}")
        if rel["object_id"].startswith("UMED-") and rel["object_id"] not in all_ids:
            errors.append(f"Relation {rel['relation_id']} has unknown object_id {rel['object_id']}")

    qm_files = sorted((ROOT / "sources" / "query_manifests").glob("MEDQ-*.yaml"))
    if not qm_files:
        errors.append("No query manifests found in sources/query_manifests/")
    import yaml
    for qf in qm_files:
        qdata = yaml.safe_load(qf.read_text(encoding="utf-8"))
        for err in qm_validator.iter_errors(qdata):
            errors.append(f"Query manifest {qf.name} schema error: {err.message}")

    print("3. Checking category allocations, Gold Seed quotas, data hygiene, and 18 Publication Gates...")
    cat_counts = Counter(r["category_id"] for r in current_problems)
    gold_cat_counts = Counter(r["category_id"] for r in gold_problems)
    for slug, expected in expected_category_quotas.items():
        if cat_counts[slug] != expected:
            errors.append(f"Category {slug}: expected {expected} current problems, got {cat_counts[slug]}")
        if gold_cat_counts[slug] != expected // 10:
            errors.append(f"Category {slug} Gold Seed: expected {expected // 10}, got {gold_cat_counts[slug]}")

    seen_titles = set()
    seen_stmts = set()
    origin_source_counts = Counter()
    any_source_counts = Counter()

    for r in current_problems:
        if not r["published"]:
            errors.append(f"{r['id']} in current_problems has published=False")
        if r["original_statement"] is not None:
            errors.append(f"{r['id']} stores raw excerpt in original_statement instead of None")
        if r["publication_class"] not in ("OPEN-VERIFIED", "PARTIAL-PROGRESS", "DISPUTED-OPEN", "BLOCKED-OPEN"):
            errors.append(f"{r['id']} has invalid current publication_class {r['publication_class']}")
        if r["status"] not in ("open", "partially_resolved", "contested"):
            errors.append(f"{r['id']} has invalid current status {r['status']}")
        if not r["statement"].endswith("?"):
            errors.append(f"{r['id']} statement does not end with '?'")
        if CLINICAL_ADVICE_PATTERNS.search(r["statement"]):
            errors.append(f"{r['id']} statement contains clinical advice pattern")
        if NOISE_PATTERNS.search(r["title"]) or NOISE_PATTERNS.search(r["statement"]):
            errors.append(f"{r['id']} contains noisy non-research pattern in title or statement")
        if HTML_ENTITY_RE.search(r["title"]) or HTML_ENTITY_RE.search(r["statement"]):
            errors.append(f"{r['id']} contains unescaped HTML entity in title or statement")
        if not all(r["statement_audit"][k] for k in ("self_contained", "atomic", "medical_research_question", "does_not_imply_clinical_advice")):
            errors.append(f"{r['id']} failed statement_audit booleans")
        if r["rights"]["contains_extended_source_text"]:
            errors.append(f"{r['id']} contains extended source text")
        if r["responsible_release"]["contains_personal_data"]:
            errors.append(f"{r['id']} contains personal data")
        for w in r["why_open"]:
            if w.strip().lower() in ("more research is needed", "more research is needed."):
                errors.append(f"{r['id']} has generic why_open")

        t_norm = r["title"].lower().strip()
        s_norm = r["statement"].lower().strip()
        if t_norm in seen_titles:
            errors.append(f"Duplicate title in current_problems: {r['id']}")
        if s_norm in seen_stmts:
            errors.append(f"Duplicate statement in current_problems: {r['id']}")
        seen_titles.add(t_norm)
        seen_stmts.add(s_norm)

        min_sources = 5 if version == "3.0.0" else 4
        if len(r["source_support"]) < min_sources:
            errors.append(f"{r['id']} has fewer than {min_sources} sources in source_support ({len(r['source_support'])})")
        lit_sids = [
            ss["source_id"]
            for ss in r["source_support"]
            if not ss["source_id"].startswith("SRC-MED-ANC-") and not ss["source_id"].startswith("SRC-MED-NCT-")
        ]
        if len(set(lit_sids)) < 3:
            errors.append(f"{r['id']} has fewer than 3 distinct peer-reviewed literature papers ({len(set(lit_sids))})")
        for ss in r["source_support"]:
            if ss["source_id"] not in source_ids:
                errors.append(f"{r['id']} references unknown source_id {ss['source_id']}")
            any_source_counts[ss["source_id"]] += 1
            if ss["role"] == "problem_origin":
                origin_source_counts[ss["source_id"]] += 1

    print("4. Checking portfolio & source diversity guardrails (Sections 12.6 & 12.7)...")
    qtype_counts = Counter(r["question_type"] for r in current_problems)
    n_total = len(current_problems)
    for qt, cnt in qtype_counts.items():
        if cnt / n_total > 0.30:
            errors.append(f"Question type {qt} exceeds 30% guardrail: {cnt / n_total:.2%}")

    etio_share = sum(qtype_counts[q] for q in ("etiology", "mechanism", "natural_history")) / n_total
    diag_share = sum(qtype_counts[q] for q in ("diagnosis", "screening", "prognosis", "classification", "measurement")) / n_total
    safe_share = sum(qtype_counts[q] for q in ("safety", "supportive_palliative", "rehabilitation", "patient_experience")) / n_total
    impl_share = sum(qtype_counts[q] for q in ("implementation", "health_services", "public_health")) / n_total

    for label, share in [
        ("Etiology/Mechanism/Natural History", etio_share),
        ("Diagnosis/Screening/Prognosis/Classification/Measurement", diag_share),
        ("Safety/Supportive/Rehab/Patient Experience", safe_share),
        ("Implementation/Health Services/Public Health", impl_share),
    ]:
        if share < 0.10:
            errors.append(f"Portfolio guardrail failed: {label} share is {share:.2%} (< 10%)")

    max_origin = max(origin_source_counts.values()) if origin_source_counts else 0
    max_any = max(any_source_counts.values()) if any_source_counts else 0
    if max_origin > 50:
        errors.append(f"Source diversity guardrail failed: max problem_origin records per source is {max_origin} (> 50)")
    if max_any > 50:
        errors.append(f"Source diversity guardrail failed: max total records per source in any role is {max_any} (> 50)")

    if errors:
        print(f"VALIDATION FAILED with {len(errors)} errors:")
        for e in errors[:25]:
            print("  -", e)
        return 1

    print(
        f"ALL VALIDATION CHECKS PASSED (0 errors)! "
        f"Verified {len(current_problems)} published problems ({len(gold_problems)} Gold Seed), "
        f"{len(all_problems) - len(current_problems)} calibration audit records, "
        f"{len(sources)} sources (max origin={max_origin}, max any role={max_any}), "
        f"{len(relations)} relations, and total size {total_mb:.1f} MB (< 400 MB)."
    )
    return 0


if __name__ == "__main__":
    sys.exit(main())