code/quickstart.py

#!/usr/bin/env python3
"""Run a zero-dependency XL-DocBench release smoke test."""

from __future__ import annotations

import argparse
import json
import sys
from pathlib import Path
from typing import Any

sys.dont_write_bytecode = True

import evaluate as evaluator


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument(
        "--release-root",
        type=Path,
        default=Path(__file__).resolve().parent.parent,
        help="Release directory; defaults to the parent of code/",
    )
    return parser.parse_args()


def require(condition: bool, message: str) -> None:
    if not condition:
        raise ValueError(message)


def read_jsonl(path: Path) -> list[dict[str, Any]]:
    rows: list[dict[str, Any]] = []
    with path.open("r", encoding="utf-8") as handle:
        for line_number, line in enumerate(handle, start=1):
            if not line.strip():
                continue
            value = json.loads(line)
            require(isinstance(value, dict), f"Expected object on {path}:{line_number}")
            rows.append(value)
    return rows


def row_documents(row: dict[str, Any]) -> list[dict[str, Any]]:
    if row.get("task_type") == "single_doc":
        document = row.get("document")
        require(
            isinstance(document, dict), f"Missing document in {row.get('question_id')}"
        )
        return [document]
    documents = row.get("documents")
    require(
        isinstance(documents, list), f"Missing documents in {row.get('question_id')}"
    )
    return documents


def validate_release(release_root: Path) -> dict[str, int]:
    manifest_path = release_root / "manifest.json"
    require(manifest_path.is_file(), f"Missing {manifest_path}")
    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))

    release_files = manifest.get("release_files", {})
    paths = {
        name: release_root / release_files[name]
        for name in ("documents", "single_doc_questions", "cross_doc_questions")
    }
    for path in paths.values():
        require(path.is_file(), f"Missing release file: {path}")

    documents = read_jsonl(paths["documents"])
    single = read_jsonl(paths["single_doc_questions"])
    cross = read_jsonl(paths["cross_doc_questions"])
    questions = single + cross

    require(len(documents) == manifest["document_count"], "Document count mismatch")
    require(len(single) == manifest["single_doc_qa_count"], "Single-doc count mismatch")
    require(len(cross) == manifest["cross_doc_qa_count"], "Cross-doc count mismatch")
    require(len(questions) == manifest["qa_count"], "QA count mismatch")

    document_ids = [str(document.get("document_id") or "") for document in documents]
    question_ids = [str(row.get("question_id") or "") for row in questions]
    require(all(document_ids), "Empty document_id")
    require(all(question_ids), "Empty question_id")
    require(len(set(document_ids)) == len(document_ids), "Duplicate document_id")
    require(len(set(question_ids)) == len(question_ids), "Duplicate question_id")

    known_documents = set(document_ids)
    referenced_documents: set[str] = set()
    evidence_item_count = 0
    for row in questions:
        question_id = row["question_id"]
        require(
            str(row.get("question") or "").strip(), f"Empty question: {question_id}"
        )
        require(isinstance(row.get("answer"), dict), f"Missing answer: {question_id}")
        documents_for_row = row_documents(row)
        metadata = row.get("metadata")
        require(isinstance(metadata, dict), f"Missing metadata: {question_id}")
        require(
            metadata.get("n_context_documents") == len(documents_for_row),
            f"Context-document count mismatch: {question_id}",
        )

        actual_evidence_documents = 0
        for document in documents_for_row:
            document_id = str(document.get("document_id") or "")
            require(document_id in known_documents, f"Unknown document: {document_id}")
            referenced_documents.add(document_id)
            require(
                document.get("evidence_page_numbering") == "pdf_index",
                f"Missing evidence page semantics: {question_id}",
            )
            evidence_pages = document.get("evidence_pages")
            evidence_items = document.get("evidence_items")
            require(
                isinstance(evidence_pages, list),
                f"Invalid evidence_pages: {question_id}",
            )
            require(
                isinstance(evidence_items, list),
                f"Invalid evidence_items: {question_id}",
            )
            actual_evidence_documents += bool(evidence_pages or evidence_items)
            evidence_item_count += len(evidence_items)
            for item in evidence_items:
                require(
                    str(item.get("locator") or "").strip(),
                    f"Empty locator: {question_id}",
                )
                require(bool(item.get("pages")), f"Empty item pages: {question_id}")
                require(
                    item.get("page_numbering") == "annotator_supplied",
                    f"Missing item page semantics: {question_id}",
                )
                require(
                    item.get("evidence_kind")
                    in {"supporting_excerpt", "annotator_rationale"},
                    f"Invalid evidence kind: {question_id}",
                )

        require(
            metadata.get("n_evidence_documents") == actual_evidence_documents,
            f"Evidence-document count mismatch: {question_id}",
        )
        for item in row.get("unassigned_evidence_items", []):
            require(
                item.get("evidence_kind") == "unassigned_annotation",
                f"Invalid unassigned evidence kind: {question_id}",
            )

    require(referenced_documents == known_documents, "Unreferenced released documents")
    require(
        evidence_item_count == manifest["evidence_item_count"],
        "Evidence-item count mismatch",
    )

    score_path = release_root / release_files["per_question_scores"]
    summary_path = release_root / release_files["score_summary"]
    require(score_path.is_file(), f"Missing score file: {score_path}")
    require(summary_path.is_file(), f"Missing score summary: {summary_path}")
    score_rows = read_jsonl(score_path)
    score_ids = [str(row.get("question_id") or "") for row in score_rows]
    require(len(score_rows) == len(questions), "Per-question score count mismatch")
    require(set(score_ids) == set(question_ids), "Per-question score IDs mismatch")
    score_summary = json.loads(summary_path.read_text(encoding="utf-8"))
    systems = score_summary.get("systems", {})
    require(
        len(systems) == manifest["scored_system_count"], "Scored-system count mismatch"
    )
    expected_systems = set(systems)
    for row in score_rows:
        row_scores = row.get("scores")
        require(isinstance(row_scores, dict), "Invalid per-question scores")
        require(set(row_scores) == expected_systems, "Per-question system mismatch")
        for metrics in row_scores.values():
            require(isinstance(metrics, dict), "Invalid metric record")
            for metric in ("accuracy", "token_f1", "anls"):
                value = metrics.get(metric)
                require(
                    isinstance(value, (int, float)) and 0 <= value <= 1,
                    f"Invalid {metric} score",
                )
    return {
        "documents": len(documents),
        "single_doc": len(single),
        "cross_doc": len(cross),
        "questions": len(questions),
        "evidence_items": evidence_item_count,
        "systems": len(systems),
    }


def evaluate_examples(code_dir: Path) -> dict[str, float | int]:
    examples = code_dir / "examples"
    gold = evaluator.load_gold_records([examples / "gold_sample.jsonl"])
    predictions, statuses = evaluator.load_predictions(
        examples / "predictions_sample.jsonl"
    )
    report = evaluator.evaluate(gold, predictions, statuses)
    overall = report["overall"]
    require(report["evaluated_count"] == 5, "Example evaluation count mismatch")
    require(overall["accuracy"] == 1.0, "Example Accuracy regression")
    require(overall["token_f1"] == 1.0, "Example Token F1 regression")
    require(overall["anls"] == 1.0, "Example ANLS regression")
    return overall


def main() -> None:
    args = parse_args()
    release_root = args.release_root.resolve()
    counts = validate_release(release_root)
    metrics = evaluate_examples(Path(__file__).resolve().parent)

    print("XL-DocBench smoke test: PASS")
    print(
        f"  data: {counts['documents']:,} documents, "
        f"{counts['questions']:,} QA "
        f"({counts['single_doc']:,} single + {counts['cross_doc']:,} cross)"
    )
    print(f"  evidence items: {counts['evidence_items']:,}")
    print(f"  per-question scores: {counts['systems']} systems")
    print(
        f"  sample metrics: Accuracy={metrics['accuracy'] * 100:.1f}, "
        f"F1={metrics['token_f1'] * 100:.1f}, ANLS={metrics['anls'] * 100:.1f}"
    )


if __name__ == "__main__":
    try:
        main()
    except (KeyError, OSError, TypeError, ValueError, json.JSONDecodeError) as exc:
        print(f"XL-DocBench smoke test: FAIL — {exc}", file=sys.stderr)
        sys.exit(1)