| |
| """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()) |
|
|
