#!/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)