| |
| """Validate the external evaluation dataset without third-party dependencies. |
| |
| The JSON Schema documents individual rows. This validator additionally checks |
| assets, provenance joins, ontology vocabulary, review state, and split isolation. |
| A declared human review receipt is required for gold, but reviewer identity is not |
| authenticated by this offline check. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| import math |
| from datetime import datetime |
| from pathlib import Path, PurePosixPath, PureWindowsPath |
| import re |
| import sys |
| from urllib.parse import urlparse |
|
|
|
|
| CORE_LICENSES = frozenset({"CC0-1.0", "PDM-1.0", "CC-BY-3.0", "CC-BY-4.0"}) |
| SPLITS = frozenset({"development", "test"}) |
| IMAGE_EXTENSIONS = frozenset({ |
| ".png", ".apng", ".jpg", ".jpeg", ".jfif", ".webp", ".bmp", ".dib", |
| ".gif", ".tif", ".tiff", ".ico", ".avif", ".heic", ".heif", ".jp2", |
| ".jxl", ".pnm", ".ppm", ".pgm", ".pbm", |
| }) |
| HASH_PATTERN = re.compile(r"^[0-9a-f]{64}$") |
| LABEL_PATTERN = re.compile(r"^[A-Za-z][A-Za-z0-9_]*$") |
| VERSION_PATTERN = re.compile(r"^\d+\.\d+\.\d+(?:[-+][A-Za-z0-9.-]+)?$") |
| TIMESTAMP_PATTERN = re.compile(r"^\d{4}-\d{2}-\d{2}[Tt]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:[Zz]|[+-]\d{2}:\d{2})$") |
| REQUIRED_FIELDS = frozenset({ |
| "file_name", "sample_id", "task_id", "document_id", "family_id", "source_id", |
| "split", "labels", "proposed_labels", "solution", "annotation_status", |
| "annotation_method", "ontology_version", "annotation_policy_version", |
| "source_url", "license", "license_url", "attribution", "page", "crop_bbox", |
| "context_bbox", "image_sha256", "original_sha256", "exposure_status", |
| "original_path", |
| }) |
|
|
|
|
| def _object(pairs: list[tuple[str, object]]) -> dict: |
| result = {} |
| for key, value in pairs: |
| if key in result: |
| raise ValueError(f"duplicate JSON key: {key}") |
| result[key] = value |
| return result |
|
|
|
|
| def _read_json(path: Path, errors: list[str]) -> dict: |
| try: |
| value = json.loads(path.read_text(encoding="utf-8"), object_pairs_hook=_object) |
| if not isinstance(value, dict): |
| raise ValueError("expected a JSON object") |
| return value |
| except (OSError, UnicodeError, ValueError) as exc: |
| errors.append(f"{path.name}: {exc}") |
| return {} |
|
|
|
|
| def _text(value: object) -> bool: |
| return isinstance(value, str) and bool(value.strip()) |
|
|
|
|
| def _url(value: object) -> bool: |
| if not isinstance(value, str): |
| return False |
| try: |
| parsed = urlparse(value) |
| return parsed.scheme in {"http", "https"} and bool(parsed.netloc) |
| except ValueError: |
| return False |
|
|
|
|
| def _hash(value: object) -> bool: |
| return isinstance(value, str) and HASH_PATTERN.fullmatch(value) is not None |
|
|
|
|
| def _positive_integer(value: object) -> bool: |
| return type(value) is int and value > 0 |
|
|
|
|
| def _number(value: object) -> bool: |
| return type(value) is int or (type(value) is float and math.isfinite(value)) |
|
|
|
|
| def _choice(value: object, choices: set | frozenset) -> bool: |
| return isinstance(value, str) and value in choices |
|
|
|
|
| def _bbox(value: object) -> bool: |
| return (isinstance(value, list) and len(value) == 4 |
| and all(_number(v) for v in value) |
| and 0 <= value[0] < value[2] and 0 <= value[1] < value[3]) |
|
|
|
|
| def _labels(value: object) -> bool: |
| return (isinstance(value, list) |
| and all(isinstance(v, str) and LABEL_PATTERN.fullmatch(v) for v in value) |
| and len(value) == len(set(value))) |
|
|
|
|
| def _resolve_file(base: Path, relative: object, label: str, errors: list[str]) -> Path | None: |
| if not _text(relative): |
| errors.append(f"{label}: expected a nonempty relative file path") |
| return None |
| posix = PurePosixPath(relative) |
| windows = PureWindowsPath(relative) |
| if ("\\" in relative or posix.is_absolute() or windows.drive or windows.is_absolute() |
| or ".." in posix.parts or relative != posix.as_posix() or ":" in relative): |
| errors.append(f"{label}: path must be normalized, relative, and cannot escape its root") |
| return None |
| try: |
| path = (base / relative).resolve() |
| path.relative_to(base.resolve()) |
| except (ValueError, OSError): |
| errors.append(f"{label}: path escapes its root") |
| return None |
| if not path.is_file(): |
| errors.append(f"{label}: file does not exist: {relative}") |
| return None |
| return path |
|
|
|
|
| def _file_hash(path: Path, cache: dict[Path, str], errors: list[str]) -> str | None: |
| if path not in cache: |
| try: |
| digest = hashlib.sha256() |
| with path.open("rb") as stream: |
| for block in iter(lambda: stream.read(1024 * 1024), b""): |
| digest.update(block) |
| cache[path] = digest.hexdigest() |
| except OSError as exc: |
| errors.append(f"{path.name}: cannot hash file: {exc}") |
| return None |
| return cache[path] |
|
|
|
|
| def _index(payload: dict, collection: str, id_field: str, errors: list[str]) -> dict[str, dict]: |
| entries = payload.get(collection) |
| if not isinstance(entries, list): |
| errors.append(f"{collection}: expected a list") |
| return {} |
| index = {} |
| for number, entry in enumerate(entries, 1): |
| if not isinstance(entry, dict) or not _text(entry.get(id_field)): |
| errors.append(f"{collection}[{number}]: missing {id_field}") |
| continue |
| key = entry[id_field] |
| if key in index: |
| errors.append(f"{collection}: duplicate {id_field}: {key}") |
| else: |
| index[key] = entry |
| return index |
|
|
|
|
| def _timestamp(value: object) -> datetime | None: |
| if not isinstance(value, str) or not TIMESTAMP_PATTERN.fullmatch(value): |
| return None |
| try: |
| result = datetime.fromisoformat(value.upper().replace("Z", "+00:00")) |
| return result if result.tzinfo is not None else None |
| except ValueError: |
| return None |
|
|
|
|
| def _review_receipt(value: object, row: dict) -> bool: |
| """Check the declared two-human process, retaining independent judgments.""" |
| if (not isinstance(value, dict) or not _text(value.get("adjudicator_id")) |
| or not _text(value.get("rationale")) or value.get("decision") != "approved" |
| or value.get("method") != "human"): |
| return False |
| reviewer_ids = value.get("reviewer_ids") |
| reviews = value.get("reviews") |
| if (not isinstance(reviewer_ids, list) or len(reviewer_ids) < 2 |
| or not all(_text(v) for v in reviewer_ids) |
| or len(set(reviewer_ids)) != len(reviewer_ids) |
| or not isinstance(reviews, list) or len(reviews) != len(reviewer_ids)): |
| return False |
| adjudicated_at = _timestamp(value.get("adjudicated_at")) |
| if adjudicated_at is None: |
| return False |
| if any(value.get(field) != row.get(field) |
| for field in ("ontology_version", "annotation_policy_version")): |
| return False |
| seen = set() |
| for review in reviews: |
| if not isinstance(review, dict) or not _text(review.get("reviewer_id")): |
| return False |
| reviewer_id = review["reviewer_id"] |
| reviewed_at = _timestamp(review.get("reviewed_at")) |
| if (reviewer_id not in reviewer_ids or reviewer_id in seen |
| or reviewed_at is None or reviewed_at > adjudicated_at |
| or not _labels(review.get("labels"))): |
| return False |
| seen.add(reviewer_id) |
| return seen == set(reviewer_ids) |
|
|
|
|
| def _check_row_shape(row: dict, label: str, errors: list[str], require_gold: bool) -> None: |
| missing = sorted(REQUIRED_FIELDS - row.keys()) |
| if missing: |
| errors.append(f"{label}: missing fields: {', '.join(missing)}") |
| for field in ("sample_id", "task_id", "document_id", "family_id", "source_id", "attribution"): |
| if not _text(row.get(field)): |
| errors.append(f"{label}: {field} must be a nonempty string") |
| for field in ("source_url", "license_url"): |
| if not _url(row.get(field)): |
| errors.append(f"{label}: {field} must be an HTTP(S) URL") |
| for field in ("image_sha256", "original_sha256"): |
| if not _hash(row.get(field)): |
| errors.append(f"{label}: {field} must be a lowercase SHA-256") |
| for field in ("ontology_version", "annotation_policy_version"): |
| if not isinstance(row.get(field), str) or not VERSION_PATTERN.fullmatch(row[field]): |
| errors.append(f"{label}: {field} must be a semantic version") |
| if not _choice(row.get("license"), CORE_LICENSES): |
| errors.append(f"{label}: license is outside the core allowlist") |
| if type(row.get("solution")) is not bool: |
| errors.append(f"{label}: solution must be a boolean") |
| if not _positive_integer(row.get("page")): |
| errors.append(f"{label}: page must be a positive 1-based integer") |
| for field in ("crop_bbox", "context_bbox", "footer_bbox"): |
| if field != "crop_bbox" and row.get(field) is None: |
| continue |
| if not _bbox(row.get(field)): |
| errors.append(f"{label}: {field} must be an ordered nonnegative PDF-point box") |
| if not _labels(row.get("proposed_labels")): |
| errors.append(f"{label}: proposed_labels must contain unique ontology local names") |
| status = row.get("annotation_status") |
| if status == "proposed": |
| if row.get("labels") is not None: |
| errors.append(f"{label}: proposed annotations must keep labels null; proposals are not gold") |
| if row.get("annotation_method") != "assistant_proposed": |
| errors.append(f"{label}: proposed annotations require annotation_method assistant_proposed") |
| if row.get("split") != "development" or row.get("exposure_status") != "development": |
| errors.append(f"{label}: proposed annotations are development-only") |
| elif status == "human_adjudicated": |
| if not _labels(row.get("labels")) or not row.get("labels"): |
| errors.append(f"{label}: human_adjudicated requires nonempty unique gold labels") |
| if row.get("annotation_method") != "human_reviewed": |
| errors.append(f"{label}: human_adjudicated requires annotation_method human_reviewed") |
| if not _review_receipt(row.get("review_receipt"), row): |
| errors.append(f"{label}: human_adjudicated requires a dated two-human review receipt with matching versions") |
| else: |
| errors.append(f"{label}: unknown annotation_status") |
| if (require_gold or row.get("split") == "test") and status != "human_adjudicated": |
| errors.append(f"{label}: scoring requires human_adjudicated gold") |
| if not _choice(row.get("exposure_status"), {"development", "confirmation", "regression"}): |
| errors.append(f"{label}: unknown exposure_status") |
| if row.get("split") == "test" and row.get("exposure_status") == "development": |
| errors.append(f"{label}: development-exposed samples cannot enter the test split") |
|
|
|
|
| def validate_dataset(root: Path, *, require_gold: bool = False) -> list[str]: |
| """Return deterministic validation errors; an empty list means valid packaging. |
| |
| By default proposed annotations are accepted in development only. Use |
| ``require_gold`` before scoring to reject any remaining proposals. |
| """ |
| root = Path(root).resolve() |
| errors: list[str] = [] |
| hashes: dict[Path, str] = {} |
| registry = _read_json(root / "sources/registry.json", errors) |
| if registry.get("schema_version") != "0.1.0": |
| errors.append("registry: unsupported schema_version (expected 0.1.0)") |
| sources = _index(registry, "sources", "source_id", errors) |
| documents = _index(_read_json(root / "sources/documents.json", errors), "documents", "document_id", errors) |
| ontology = _read_json(root / "sources/ontology.json", errors) |
| vocabulary = ontology.get("eligible_labels") |
| if not _labels(vocabulary) or not vocabulary: |
| errors.append("ontology: eligible_labels must be a nonempty list of unique local names") |
| vocabulary = [] |
| vocabulary = set(vocabulary) |
| for field in ("version", "repository", "revision"): |
| if not _text(ontology.get(field)): |
| errors.append(f"ontology: missing {field}") |
| if not _hash(ontology.get("snapshot_sha256")): |
| errors.append("ontology: missing or invalid snapshot_sha256") |
| dimensions = ontology.get("dimensions") |
| if (not isinstance(dimensions, dict) or set(dimensions) != vocabulary |
| or not all(_choice(v, {"areas", "scopes", "abilities"}) for v in dimensions.values())): |
| errors.append("ontology: dimensions must map every eligible label exactly once to a valid dimension") |
| else: |
| canonical = json.dumps(dimensions, sort_keys=True, separators=(",", ":"), ensure_ascii=False) |
| if hashlib.sha256(canonical.encode("utf-8")).hexdigest() != ontology.get("snapshot_sha256"): |
| errors.append("ontology: snapshot SHA-256 does not match canonical dimensions map") |
|
|
| for source_id, source in sources.items(): |
| if not _choice(source.get("status"), {"approved", "candidate", "excluded"}): |
| errors.append(f"source {source_id}: unknown status") |
| if source.get("status") == "approved": |
| if not _choice(source.get("license"), CORE_LICENSES): |
| errors.append(f"source {source_id}: license is outside the core allowlist") |
| for field in ("license_url", "evidence_url"): |
| if not _url(source.get(field)): |
| errors.append(f"source {source_id}: missing or invalid {field}") |
|
|
| page_sizes: dict[str, dict[int, tuple[float, float]]] = {} |
| for document_id, document in documents.items(): |
| label = f"document {document_id}" |
| source = sources.get(document.get("source_id")) if isinstance(document.get("source_id"), str) else None |
| if source is None or source.get("status") != "approved": |
| errors.append(f"{label}: source must exist and be approved") |
| for field in ("license", "license_url"): |
| if source is not None and document.get(field) != source.get(field): |
| errors.append(f"{label}: {field} does not match source registry") |
| if not _text(document.get("family_id")): |
| errors.append(f"{label}: missing family_id") |
| if not _url(document.get("source_url")): |
| errors.append(f"{label}: missing or invalid source_url") |
| path = _resolve_file(root, document.get("path"), f"{label} path", errors) |
| if not _hash(document.get("sha256")): |
| errors.append(f"{label}: invalid sha256") |
| elif path is not None and _file_hash(path, hashes, errors) != document["sha256"]: |
| errors.append(f"{label}: original file SHA-256 mismatch") |
| if "page_count" in document and not _positive_integer(document["page_count"]): |
| errors.append(f"{label}: invalid page_count") |
| sizes = {} |
| pages = document.get("pages", []) |
| if not isinstance(pages, list): |
| errors.append(f"{label}: pages must be a list") |
| pages = [] |
| for page in pages: |
| if (not isinstance(page, dict) or not _positive_integer(page.get("page")) |
| or not _number(page.get("width_pt")) or page["width_pt"] <= 0 |
| or not _number(page.get("height_pt")) or page["height_pt"] <= 0): |
| errors.append(f"{label}: invalid page dimensions") |
| continue |
| if page["page"] in sizes: |
| errors.append(f"{label}: duplicate page dimensions") |
| if _positive_integer(document.get("page_count")) and page["page"] > document["page_count"]: |
| errors.append(f"{label}: dimensions exceed page_count") |
| sizes[page["page"]] = (page["width_pt"], page["height_pt"]) |
| page_sizes[document_id] = sizes |
|
|
| sample_ids: set[str] = set() |
| image_paths: set[Path] = set() |
| registered_image_paths: set[Path] = set() |
| groups: dict[tuple[str, str], str] = {} |
| seen_images: dict[str, tuple[str, str]] = {} |
| row_count = 0 |
| metadata_files = sorted((root / "data").glob("*/metadata.jsonl")) |
| if not metadata_files: |
| errors.append("data: no split metadata.jsonl files found") |
| for metadata_path in metadata_files: |
| split = metadata_path.parent.name |
| try: |
| metadata_path.resolve().relative_to(root) |
| except ValueError: |
| errors.append(f"data/{split}: metadata path escapes dataset root") |
| continue |
| if split not in SPLITS: |
| errors.append(f"data/{split}: unsupported split") |
| try: |
| lines = metadata_path.read_text(encoding="utf-8").splitlines() |
| except (OSError, UnicodeError) as exc: |
| errors.append(f"{metadata_path}: cannot read metadata: {exc}") |
| continue |
| for line_number, line in enumerate(lines, 1): |
| if not line.strip(): |
| continue |
| label = f"data/{split}/metadata.jsonl:{line_number}" |
| try: |
| row = json.loads(line, object_pairs_hook=_object) |
| if not isinstance(row, dict): |
| raise ValueError("expected an object") |
| except ValueError as exc: |
| errors.append(f"{label}: malformed row: {exc}") |
| continue |
| row_count += 1 |
| _check_row_shape(row, label, errors, require_gold) |
| if row.get("split") != split: |
| errors.append(f"{label}: split must match containing directory") |
| sample_id = row.get("sample_id") |
| if isinstance(sample_id, str): |
| if sample_id in sample_ids: |
| errors.append(f"{label}: duplicate sample_id: {sample_id}") |
| sample_ids.add(sample_id) |
| for field in ("task_id", "document_id", "family_id", "original_sha256"): |
| if isinstance(row.get(field), str): |
| key = (field, row[field]) |
| if key in groups and groups[key] != split: |
| errors.append(f"{label}: {field} appears across splits: {row[field]}") |
| groups[key] = split |
| if row.get("ontology_version") != ontology.get("version"): |
| errors.append(f"{label}: ontology_version does not match pinned ontology") |
| for field in ("labels", "proposed_labels"): |
| if _labels(row.get(field)): |
| unknown = sorted(set(row[field]) - vocabulary) |
| if unknown: |
| errors.append(f"{label}: {field} contains unknown or ineligible labels: {', '.join(unknown)}") |
| receipt = row.get("review_receipt") |
| if isinstance(receipt, dict) and isinstance(receipt.get("reviews"), list): |
| for review in receipt["reviews"]: |
| if isinstance(review, dict) and _labels(review.get("labels")): |
| unknown = sorted(set(review["labels"]) - vocabulary) |
| if unknown: |
| errors.append(f"{label}: human review contains unknown or ineligible labels: {', '.join(unknown)}") |
| source = sources.get(row.get("source_id")) if isinstance(row.get("source_id"), str) else None |
| if source is None or source.get("status") != "approved": |
| errors.append(f"{label}: source must exist and be approved") |
| document = documents.get(row.get("document_id")) if isinstance(row.get("document_id"), str) else None |
| if document is None: |
| errors.append(f"{label}: document_id does not exist") |
| else: |
| for field, document_field in (("source_id", "source_id"), ("family_id", "family_id"), |
| ("source_url", "source_url"), ("license", "license"), ("license_url", "license_url"), |
| ("original_path", "path"), ("original_sha256", "sha256")): |
| if row.get(field) != document.get(document_field): |
| errors.append(f"{label}: {field} does not match document provenance") |
| page_number = row.get("page") |
| if _positive_integer(page_number): |
| if _positive_integer(document.get("page_count")) and page_number > document["page_count"]: |
| errors.append(f"{label}: page exceeds document page_count") |
| sizes = page_sizes.get(row["document_id"], {}) |
| if sizes and page_number not in sizes: |
| errors.append(f"{label}: page has no recorded dimensions") |
| if page_number in sizes: |
| width, height = sizes[page_number] |
| for field in ("crop_bbox", "context_bbox", "footer_bbox"): |
| box = row.get(field) |
| if _bbox(box) and (box[2] > width or box[3] > height): |
| errors.append(f"{label}: {field} extends outside PDF page bounds") |
| _resolve_file(root, row.get("original_path"), f"{label} original_path", errors) |
| image_path = _resolve_file(metadata_path.parent, row.get("file_name"), f"{label} file_name", errors) |
| if image_path is not None: |
| registered_image_paths.add(metadata_path.parent / row["file_name"]) |
| if image_path.suffix.lower() not in IMAGE_EXTENSIONS: |
| errors.append(f"{label}: unsupported image extension") |
| if image_path in image_paths: |
| errors.append(f"{label}: duplicate image path") |
| image_paths.add(image_path) |
| image_hash = _file_hash(image_path, hashes, errors) |
| if image_hash != row.get("image_sha256"): |
| errors.append(f"{label}: image SHA-256 mismatch") |
| if image_hash is not None: |
| if image_hash in seen_images and seen_images[image_hash][0] != split: |
| errors.append(f"{label}: identical image bytes appear across splits") |
| seen_images[image_hash] = (split, label) |
| for image_path in sorted((root / "data").rglob("*")): |
| if (image_path.is_file() and image_path.suffix.lower() in IMAGE_EXTENSIONS |
| and image_path not in registered_image_paths): |
| errors.append(f"{image_path.relative_to(root).as_posix()}: orphan image is not registered in split metadata") |
| if not row_count: |
| errors.append("data: no sample rows found") |
| return errors |
|
|
|
|
| def main(argv: list[str] | None = None) -> int: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--root", type=Path, default=Path(__file__).resolve().parents[1]) |
| parser.add_argument("--require-gold", action="store_true", help="Reject proposals before scoring.") |
| args = parser.parse_args(argv) |
| errors = validate_dataset(args.root, require_gold=args.require_gold) |
| if errors: |
| for error in errors: |
| print(f"ERROR: {error}", file=sys.stderr) |
| print(f"Validation failed: {len(errors)} error(s).", file=sys.stderr) |
| return 1 |
| print("Validation passed: provenance, assets, labels, annotation state, and splits.") |
| if not args.require_gold: |
| print("Development proposals may be present. Use --require-gold before scoring.") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
