scripts/validate.py

#!/usr/bin/env python3
"""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())