| from __future__ import annotations |
|
|
| import json |
| from pathlib import Path |
| from typing import Any |
|
|
|
|
| ROOT = Path(__file__).resolve().parent |
| REQUIRED_ROW_FIELDS = { |
| "id", |
| "taxonomy_version", |
| "text", |
| "language", |
| "country", |
| "domain", |
| "entities", |
| "source", |
| "synthetic", |
| "review_status", |
| "split", |
| } |
| ALLOWED_SPLITS = {"train", "validation", "test"} |
|
|
|
|
| def _read_json(path: Path) -> Any: |
| with path.open(encoding="utf-8") as stream: |
| return json.load(stream) |
|
|
|
|
| def validate() -> list[str]: |
| errors: list[str] = [] |
| manifest = _read_json(ROOT / "manifest.json") |
| taxonomy_version = manifest["taxonomy_version"] |
| files: dict[str, str] = manifest["files"] |
| expected_paths = {ROOT / name for name in files} |
| actual_paths = set(ROOT.glob("*.jsonl")) |
|
|
| for path in sorted(expected_paths - actual_paths): |
| errors.append(f"missing manifest file: {path.name}") |
| for path in sorted(actual_paths - expected_paths): |
| errors.append(f"unlisted JSONL file: {path.name}") |
|
|
| seen_ids: set[str] = set() |
| for filename, primary_type in sorted(files.items()): |
| path = ROOT / filename |
| if not path.exists(): |
| continue |
| primary_found = False |
| with path.open(encoding="utf-8") as stream: |
| for line_number, raw_line in enumerate(stream, start=1): |
| if not raw_line.strip(): |
| continue |
| location = f"{filename}:{line_number}" |
| try: |
| row = json.loads(raw_line) |
| except json.JSONDecodeError as error: |
| errors.append(f"{location}: invalid JSON: {error.msg}") |
| continue |
|
|
| missing = REQUIRED_ROW_FIELDS - set(row) |
| if missing: |
| errors.append(f"{location}: missing fields: {', '.join(sorted(missing))}") |
| continue |
| if row["id"] in seen_ids: |
| errors.append(f"{location}: duplicate id: {row['id']}") |
| seen_ids.add(row["id"]) |
| if row["taxonomy_version"] != taxonomy_version: |
| errors.append(f"{location}: taxonomy_version must be {taxonomy_version}") |
| if not isinstance(row["text"], str) or not row["text"]: |
| errors.append(f"{location}: text must be a non-empty string") |
| continue |
| if row["split"] not in ALLOWED_SPLITS: |
| errors.append(f"{location}: invalid split: {row['split']}") |
| if not isinstance(row["entities"], list): |
| errors.append(f"{location}: entities must be an array") |
| continue |
|
|
| for entity_index, entity in enumerate(row["entities"]): |
| entity_location = f"{location}:entity[{entity_index}]" |
| if not isinstance(entity, dict): |
| errors.append(f"{entity_location}: entity must be an object") |
| continue |
| missing_entity = {"start", "end", "type", "subtype"} - set(entity) |
| if missing_entity: |
| errors.append( |
| f"{entity_location}: missing fields: {', '.join(sorted(missing_entity))}" |
| ) |
| continue |
| start, end = entity["start"], entity["end"] |
| if ( |
| not isinstance(start, int) |
| or isinstance(start, bool) |
| or not isinstance(end, int) |
| or isinstance(end, bool) |
| or not 0 <= start < end <= len(row["text"]) |
| ): |
| errors.append( |
| f"{entity_location}: invalid span [{start!r}, {end!r}) " |
| f"for text length {len(row['text'])}" |
| ) |
| continue |
| if not row["text"][start:end].strip(): |
| errors.append(f"{entity_location}: span contains only whitespace") |
| if entity["type"] == primary_type: |
| primary_found = True |
|
|
| if not primary_found: |
| errors.append(f"{filename}: no positive {primary_type} entity found") |
|
|
| return errors |
|
|
|
|
| if __name__ == "__main__": |
| validation_errors = validate() |
| if validation_errors: |
| print(f"Sample training data validation failed ({len(validation_errors)} errors):") |
| for validation_error in validation_errors: |
| print(f"- {validation_error}") |
| raise SystemExit(1) |
| print("Sample training data validation passed") |
