File size: 7,924 Bytes
68f4038 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 | #!/usr/bin/env python3
"""Validate SAEI-CLINDDx JSONL structure, corpus integrity, and provisional release QA.
Usage (from repository root):
python scripts/validate_dataset.py
python scripts/validate_dataset.py --schema-only
python scripts/validate_dataset.py --report reports/validation_results.json
python scripts/validate_dataset.py --expected-count 251
Exit codes: 0 = checks passing; 1 = errors found; 2 = input/usage failure.
Requires: pip install 'jsonschema>=4.18'
"""
import argparse
import json
import re
import sys
from collections import Counter
from pathlib import Path
from jsonschema import Draft202012Validator
ERROR_MARKER = re.compile(r"(?<![A-Za-z])#(?:ERROR!|REF!|VALUE!|N/A|NAME\?|DIV/0!|NUM!|NULL!)(?![A-Za-z])", re.I)
def finding(severity, code, file, line=None, case_id=None, field=None, message=""):
return {"severity": severity, "code": code, "file": str(file), "line": line,
"case_id": case_id, "field": field, "message": message}
def read_records(path, validator, language, out):
records = {}
if not path.is_file():
out.append(finding("error", "missing_file", path, message="Expected JSONL file does not exist"))
return records
with path.open("r", encoding="utf-8-sig") as fh:
for line_no, raw in enumerate(fh, 1):
if not raw.strip():
out.append(finding("error", "empty_line", path, line_no, message="Blank JSONL line"))
continue
try:
rec = json.loads(raw)
except json.JSONDecodeError as exc:
out.append(finding("error", "invalid_json", path, line_no, message=str(exc)))
continue
if not isinstance(rec, dict):
out.append(finding("error", "not_object", path, line_no, message="Each JSONL line must be an object"))
continue
case_id = rec.get("id") if isinstance(rec.get("id"), str) else None
for err in sorted(validator.iter_errors(rec), key=lambda e: list(map(str,e.absolute_path))):
field = ".".join(map(str, err.absolute_path)) or None
out.append(finding("error", "schema", path, line_no, case_id, field, err.message))
if rec.get("language") != language:
out.append(finding("error", "language_folder", path, line_no, case_id,
"language", f"Expected {language!r} for this directory"))
if case_id is not None:
if case_id in records:
out.append(finding("error", "duplicate_id", path, line_no, case_id,
"id", "Duplicate case ID within language"))
else:
records[case_id] = (rec, line_no)
if isinstance(rec.get("year"), int) and not isinstance(rec.get("year"), bool) and case_id:
m = re.fullmatch(r"saei-(\d{4})-\d{4,}", case_id)
if m and int(m.group(1)) != rec["year"]:
out.append(finding("error", "year_id_conflict", path, line_no, case_id,
"year", "ID year differs from record year"))
return records
def integrity_checks(es, en, es_path, en_path, out, expected_count):
for lang, records, path in [("es", es, es_path), ("en", en, en_path)]:
if expected_count is not None and len(records) != expected_count:
out.append(finding("error", "record_count", path,
message=f"Expected {expected_count} unique IDs; found {len(records)}"))
for lang, records, path, other in [("es", es, es_path, en), ("en", en, en_path, es)]:
for case_id in sorted(records.keys() - other.keys()):
out.append(finding("error", "unpaired_case", path, records[case_id][1], case_id,
"id", f"No corresponding record in {('en' if lang == 'es' else 'es')}"))
for case_id in sorted(es.keys() & en.keys()):
es_rec, es_line = es[case_id]
en_rec, en_line = en[case_id]
for field in ("year", "authors"):
if es_rec.get(field) != en_rec.get(field):
out.append(finding("error", "alignment_metadata", en_path, en_line, case_id,
field, f"{field} differs between es and en"))
def content_checks(records_by_lang, out):
"""Heuristics, not an MQM judgment. Keep source text unchanged."""
for lang, (records, path) in records_by_lang.items():
for case_id, (rec, line) in records.items():
for field, value in rec.items():
if not isinstance(value, str) or field in {"id", "language"}:
continue
if ERROR_MARKER.search(value):
out.append(finding("error", "spreadsheet_error_marker", path, line,
case_id, field, "Spreadsheet/formula error token in text"))
if rec.get("differential_diagnosis") == "":
out.append(finding("warning", "missing_differential", path, line,
case_id, "differential_diagnosis", "Empty in source; keep but exclude from DDX-only evaluations"))
def main():
ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
ap.add_argument("--root", type=Path, default=Path(__file__).resolve().parents[1],
help="Repository root containing schema.json and data/{es,en}/test.jsonl")
ap.add_argument("--schema", type=Path, help="Schema path (default: ROOT/schema.json)")
ap.add_argument("--report", type=Path, help="Write full machine-readable JSON findings report")
ap.add_argument("--schema-only", action="store_true", help="Skip translation/content quality flags; still enforce structural and alignment checks")
ap.add_argument("--expected-count", type=int, default=None,
help="Optional fixed count per language; omit for extensible dataset")
args = ap.parse_args()
root = args.root.resolve()
schema_path = (args.schema or root / "schema.json").resolve()
try:
schema = json.loads(schema_path.read_text(encoding="utf-8"))
Draft202012Validator.check_schema(schema)
except (OSError, ValueError, Exception) as exc:
print(f"Cannot load valid schema: {exc}", file=sys.stderr)
return 2
validator = Draft202012Validator(schema)
findings = []
es_path, en_path = (root / "data" / "es" / "test.jsonl", root / "data" / "en" / "test.jsonl")
es = read_records(es_path, validator, "es", findings)
en = read_records(en_path, validator, "en", findings)
integrity_checks(es, en, es_path, en_path, findings, args.expected_count)
if not args.schema_only:
content_checks({"es": (es, es_path), "en": (en, en_path)}, findings)
counts = Counter(f["severity"] for f in findings)
result = {
"dataset": "SAEI-CLINDDx", "mode": "schema_and_alignment" if args.schema_only else "schema_alignment_and_content",
"records": {"es": len(es), "en": len(en)},
"findings_by_severity": {"error": counts["error"], "warning": counts["warning"]},
"findings_by_code": dict(Counter(f["code"] for f in findings)),
"status": "fail" if counts["error"] else "pass",
"findings": findings,
}
print(f"SAEI-CLINDDx: es={len(es)}, en={len(en)}, errors={counts['error']}, warnings={counts['warning']}, status={result['status']}")
for code, n in sorted(result["findings_by_code"].items()):
print(f" {code}: {n}")
if args.report:
args.report.parent.mkdir(parents=True, exist_ok=True)
args.report.write_text(json.dumps(result, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
print(f"Report: {args.report}")
return 1 if counts["error"] else 0
if __name__ == "__main__":
sys.exit(main())
|