| import argparse |
| import logging |
| import asyncio |
| import json |
| import re |
| from pathlib import Path |
| import csv |
|
|
| from pythonjsonlogger import jsonlogger |
| from langchain_text_splitters import MarkdownHeaderTextSplitter |
| from openai import AsyncOpenAI |
| from pydantic import BaseModel |
| from markdown_it import MarkdownIt |
|
|
| logger = logging.getLogger(__name__) |
| logHandler = logging.StreamHandler() |
| formatter = jsonlogger.JsonFormatter("%(asctime)s %(levelname)s %(message)s %(name)s") |
| logHandler.setFormatter(formatter) |
| logger.addHandler(logHandler) |
| logger.setLevel(logging.INFO) |
|
|
|
|
| class QuestionAnswer(BaseModel): |
| question: str |
| answer: str |
| source_quote: str |
| section: str |
| manufacturer: str = "" |
| game: str = "" |
|
|
|
|
| class Extraction(BaseModel): |
| qas: list[QuestionAnswer] |
|
|
|
|
| class RewrittenQuestion(BaseModel): |
| question: str |
|
|
|
|
| class Validation(BaseModel): |
| accurate: bool |
| grounded: bool |
| reasoning: str |
|
|
|
|
| async def chat_structured( |
| client: AsyncOpenAI, |
| model: str, |
| messages: list[dict], |
| response_model: type[BaseModel], |
| max_tokens: int, |
| ) -> BaseModel | None: |
| try: |
| resp = await client.chat.completions.create( |
| model=model, |
| messages=messages, |
| max_tokens=max_tokens, |
| ) |
| content = resp.choices[0].message.content or "" |
| stripped = content.strip() |
| if stripped.startswith("```"): |
| stripped = re.sub(r"^```[a-zA-Z]*\s*|\s*```$", "", stripped, flags=re.S) |
| start = stripped.find("{") |
| end = stripped.rfind("}") |
| if start == -1 or end == -1: |
| return None |
| data = json.loads(stripped[start : end + 1]) |
| return response_model.model_validate(data) |
| except Exception: |
| return None |
|
|
|
|
| async def extract_facts( |
| client: AsyncOpenAI, model: str, text: str, manufacturer: str, game: str |
| ) -> list[QuestionAnswer]: |
| system_prompt = f"""You are an expert at building benchmark questions from pinball rulesheets. |
| The machine is the {game} pinball game, manufactured by {manufacturer}. |
| |
| Your task is to generate self-contained (including machine name), objective question/answer pairs based on the provided markdown text. |
| |
| Guidelines: |
| 1. Topics: Focus on features, rules, scoring, layout, mechanics, and credits. |
| 2. Verifiability: Each question must be answerable using ONLY the provided text. The answer must be a single, verifiable fact. |
| 3. Objectivity: Do NOT include subjective opinions, memories, or uncertain claims. |
| 4. Scope: The text is a CHUNK of the rulesheet, not the full document. Only generate questions whose answers are fully contained within this specific chunk. |
| |
| Output the questions and answers in the requested format. |
| """ |
| parsed = await chat_structured( |
| client, |
| model, |
| [ |
| {"role": "system", "content": system_prompt}, |
| {"role": "user", "content": text}, |
| ], |
| Extraction, |
| max_tokens=32_768, |
| ) |
| if parsed is None: |
| return [] |
| return parsed.qas |
|
|
|
|
| async def rewrite_self_contained( |
| client: AsyncOpenAI, model: str, question: str, manufacturer: str, game: str |
| ) -> str: |
| system_prompt = f"""You are an expert at making pinball rulesheet benchmark questions self-contained. |
| |
| The question is about the {game} pinball game, manufactured by {manufacturer}. |
| |
| Rewrite the question so it includes the game name (and manufacturer if relevant) so that a reader with no other context can understand it. Keep the same meaning, wording, and answer. Only change the question text; do not change the answer. |
| |
| Return ONLY a JSON document with a single field `question` that is the result of you rewriting the question with the game name. |
| """ |
| parsed = await chat_structured( |
| client, |
| model, |
| [ |
| {"role": "system", "content": system_prompt}, |
| { |
| "role": "user", |
| "content": ( |
| f"Game: {game}\n" |
| f"Manufacturer: {manufacturer}\n" |
| f"Question: {question}\n" |
| ), |
| }, |
| ], |
| RewrittenQuestion, |
| max_tokens=4096, |
| ) |
| if parsed is None: |
| return question |
| return parsed.question |
|
|
|
|
| async def validate_qa( |
| client: AsyncOpenAI, model: str, question: str, answer: str, text: str |
| ) -> Validation | None: |
| system_prompt = """You are an expert at verifying pinball rulesheet benchmark questions. |
| |
| Given a question, its answer, and the full rulesheet that supposedly supports it, determine: |
| - accurate: whether the answer is factually correct. |
| - grounded: whether the answer is fully supported by the rulesheet (every claim in the answer appears in, or follows directly from, the rulesheet text). |
| - reasoning: rationale for the accurate and grounded results |
| |
| Return ONLY a JSON document with `accurate`, `grounded` and `reasoning` fields. |
| """ |
| parsed = await chat_structured( |
| client, |
| model, |
| [ |
| {"role": "system", "content": system_prompt}, |
| {"role": "user", "content": f"Rulesheet:\n{text}"}, |
| {"role": "user", "content": f"Question: {question}\nAnswer: {answer}\n"}, |
| ], |
| Validation, |
| max_tokens=4096, |
| ) |
| return parsed |
|
|
|
|
| async def validate_row( |
| client: AsyncOpenAI, model: str, row: dict, text: str |
| ) -> Validation | None: |
| question = row["question"] |
| answer = row["answer"] |
| return await validate_qa(client, model, question, answer, text) |
|
|
|
|
| def build_parser() -> argparse.ArgumentParser: |
| parser = argparse.ArgumentParser( |
| prog="pinball_benchmarks", |
| description="Build benchmark questions from pinball rulesheets.", |
| ) |
| subparsers = parser.add_subparsers(dest="action", required=True) |
|
|
| extract_p = subparsers.add_parser("extract", help="Extract facts into CSV files.") |
| extract_p.add_argument( |
| "--rules-dir", |
| type=Path, |
| default=Path("/tmp/pinballrules/docs"), |
| help="Directory containing the pinball rulesheets.", |
| ) |
| extract_p.add_argument( |
| "--output-dir", |
| type=Path, |
| default=Path("output"), |
| help="Directory to write CSV outputs to.", |
| ) |
| extract_p.add_argument( |
| "--model", |
| default="deepseek-v4-flash", |
| help="Model to use for extraction.", |
| ) |
| extract_p.add_argument( |
| "--base-url", |
| default="http://localhost:8000/v1", |
| help="OpenAI-compatible API base URL.", |
| ) |
| extract_p.add_argument( |
| "--api-key", |
| default="foobar", |
| help="API key for the OpenAI-compatible server.", |
| ) |
| extract_p.add_argument( |
| "--max-concurrent", |
| type=int, |
| default=5, |
| help="Max concurrent extraction calls per batch.", |
| ) |
|
|
| update_p = subparsers.add_parser( |
| "update-to-self-contained", |
| help="Rewrite CSV questions to be self-contained (include the game name).", |
| ) |
| update_p.add_argument( |
| "--output-dir", |
| type=Path, |
| default=Path("output"), |
| help="Directory containing CSV files to update in place.", |
| ) |
| update_p.add_argument( |
| "--start-file", |
| type=Path, |
| default=None, |
| help="CSV filename to start processing from, instead of the first file in the glob.", |
| ) |
| update_p.add_argument( |
| "--model", |
| default="deepseek-v4-flash", |
| help="Model to use for rewriting.", |
| ) |
| update_p.add_argument( |
| "--base-url", |
| default="http://localhost:8000/v1", |
| help="OpenAI-compatible API base URL.", |
| ) |
| update_p.add_argument( |
| "--api-key", |
| default="foobar", |
| help="API key for the OpenAI-compatible server.", |
| ) |
| update_p.add_argument( |
| "--max-concurrent", |
| type=int, |
| default=5, |
| help="Max concurrent rewrite calls per batch.", |
| ) |
|
|
| validate_p = subparsers.add_parser( |
| "validate-question", |
| help="Validate that CSV question/answer pairs are accurate and grounded in the rulesheet.", |
| ) |
| validate_p.add_argument( |
| "--rules-dir", |
| type=Path, |
| default=Path("/tmp/pinballrules/docs"), |
| help="Directory containing the pinball rulesheets.", |
| ) |
| validate_p.add_argument( |
| "--output-dir", |
| type=Path, |
| default=Path("output"), |
| help="Directory containing CSV files to validate.", |
| ) |
| validate_p.add_argument( |
| "--model", |
| default="deepseek-v4-flash", |
| help="Model to use for validation.", |
| ) |
| validate_p.add_argument( |
| "--base-url", |
| default="http://localhost:8000/v1", |
| help="OpenAI-compatible API base URL.", |
| ) |
| validate_p.add_argument( |
| "--api-key", |
| default="foobar", |
| help="API key for the OpenAI-compatible server.", |
| ) |
| validate_p.add_argument( |
| "--max-concurrent", |
| type=int, |
| default=5, |
| help="Max concurrent validation calls per batch.", |
| ) |
| return parser |
|
|
|
|
| async def run_validate_question(args: argparse.Namespace) -> None: |
| rules_path = args.rules_dir |
| output_dir = args.output_dir |
| openai_client = AsyncOpenAI(base_url=args.base_url, api_key=args.api_key) |
| model = args.model |
| max_concurrent = args.max_concurrent |
|
|
| csv_paths = sorted(output_dir.glob("*.csv")) |
| logger.info(f"found {len(csv_paths)} csv files") |
|
|
| out_path = output_dir / "validation-results.csv" |
| fieldnames = ["game", "question", "answer", "accurate", "grounded", "reasoning"] |
|
|
| done: dict[str, set[str]] = {} |
| last_game = "" |
| if out_path.exists(): |
| with open(out_path, mode="r", newline="", encoding="utf-8") as f: |
| reader = csv.DictReader(f) |
| for result in reader: |
| game = result.get("game", "") |
| done.setdefault(game, set()).add(result["question"]) |
| last_game = game |
| logger.info(f"found {len(done)} games already validated, resuming from {last_game!r}") |
| else: |
| logger.info("no validation-results.csv found, starting fresh") |
|
|
| written = 0 |
| with open(out_path, mode="w", newline="", encoding="utf-8") as f: |
| writer = csv.DictWriter(f, fieldnames=fieldnames) |
| writer.writeheader() |
| for csv_path in csv_paths: |
| md_paths = list(rules_path.rglob(f"{csv_path.stem}.md")) |
| if not md_paths: |
| logger.info(f"skipping {csv_path.name}, no matching rulesheet markdown") |
| continue |
| md_path = md_paths[0] |
| text = md_path.read_text(encoding="utf-8") |
|
|
| rows = [] |
| with open(csv_path, mode="r", newline="", encoding="utf-8") as cf: |
| reader = csv.DictReader(cf) |
| for row in reader: |
| rows.append(row) |
|
|
| for start in range(0, len(rows), max_concurrent): |
| batch = rows[start : start + max_concurrent] |
| logger.info( |
| f"\t{csv_path.name} validating {start}/{len(rows)} batch ({len(batch)} rows)" |
| ) |
| batch_results = await asyncio.gather( |
| *(validate_row(openai_client, model, row, text) for row in batch) |
| ) |
| for row, result in zip(batch, batch_results): |
| game = row.get("game", "") or csv_path.stem |
| question = row["question"] |
| if game in done and question in done[game]: |
| continue |
| if result is None: |
| logger.info( |
| f"\t{question} -> could not find a relevant chunk" |
| ) |
| continue |
| logger.info( |
| f"\t{question} -> " |
| f"accurate={result.accurate} grounded={result.grounded}" |
| ) |
| writer.writerow( |
| { |
| "game": game, |
| "question": question, |
| "answer": row["answer"], |
| "accurate": result.accurate, |
| "grounded": result.grounded, |
| "reasoning": result.reasoning, |
| } |
| ) |
| f.flush() |
| written += 1 |
| logger.info(f"wrote {written} validation results to {out_path}") |
|
|
|
|
| async def run_extract(args: argparse.Namespace) -> None: |
| rules_path = args.rules_dir |
| master_list = rules_path / "rulesheet-master-list.md" |
| output_dir = args.output_dir |
| output_dir.mkdir(exist_ok=True) |
|
|
| openai_client = AsyncOpenAI(base_url=args.base_url, api_key=args.api_key) |
| model = args.model |
| max_concurrent = args.max_concurrent |
| filename_deny_list = set(["README.md", "rulesheet-master-list.md"]) |
|
|
| master_text = master_list.read_text(encoding="utf-8") |
| tokens = MarkdownIt().parse(master_text) |
| markdown_files = sorted( |
| rules_path / (href.lstrip("/") + ".md") |
| for token in tokens |
| if token.type == "inline" and token.children |
| for child in token.children |
| if child.type == "link_open" |
| for href in [child.attrGet("href")] |
| if href.startswith("/") and not href.startswith("http") |
| ) |
| splitter = MarkdownHeaderTextSplitter( |
| headers_to_split_on=[ |
| ("##", "section"), |
| ("###", "subsection"), |
| ], |
| strip_headers=False, |
| ) |
|
|
| for idx, md_path in enumerate(markdown_files): |
| if md_path.name in filename_deny_list: |
| continue |
| logger.info(f"Processing file {idx + 1}/{len(markdown_files)}: {md_path.name}") |
| csv_path = output_dir / md_path.with_suffix(".csv").name |
| if csv_path.exists(): |
| logger.info(f"skipping {md_path.name}, {csv_path.name} already exists") |
| continue |
| manufacturer = md_path.parent.name |
| stem = md_path.stem |
| game = ( |
| stem.replace("-rulesheet", "").replace("--rulesheet", "").replace("-", " ") |
| ) |
| text = md_path.read_text(encoding="utf-8") |
| chunks = [chunk.page_content for chunk in splitter.split_text(text)] |
| qas: list[QuestionAnswer] = [] |
| logger.info(f"found {len(chunks)} chunks") |
| for start in range(0, len(chunks), max_concurrent): |
| batch = chunks[start : start + max_concurrent] |
| logger.info(f"\tstarting {start}/{len(chunks)} batch ({len(batch)} chunks)") |
| batch_facts = await asyncio.gather( |
| *( |
| extract_facts(openai_client, model, chunk, manufacturer, game) |
| for chunk in batch |
| ) |
| ) |
| for facts in batch_facts: |
| logger.info(f"\tfound {len(facts)} facts") |
| qas.extend(facts) |
| for qa in qas: |
| qa.manufacturer = manufacturer |
| qa.game = game |
| logger.info(f"=== {md_path.relative_to(rules_path)} ===") |
|
|
| |
| with open(csv_path, mode="w", newline="", encoding="utf-8") as f: |
| writer = csv.DictWriter( |
| f, |
| fieldnames=[ |
| "question", |
| "answer", |
| "source_quote", |
| "section", |
| "manufacturer", |
| "game", |
| ], |
| ) |
| writer.writeheader() |
| for qa in qas: |
| writer.writerow(qa.model_dump()) |
|
|
| for qa in qas: |
| logger.info(qa.model_dump()) |
| logger.info(f"finished {md_path.name}") |
|
|
| logger.info("") |
|
|
|
|
| async def run_update_to_self_contained(args: argparse.Namespace) -> None: |
| output_dir = args.output_dir |
| openai_client = AsyncOpenAI(base_url=args.base_url, api_key=args.api_key) |
| model = args.model |
| max_concurrent = args.max_concurrent |
|
|
| csv_paths = sorted(output_dir.glob("*.csv")) |
| if args.start_file is not None: |
| start = args.start_file.name |
| try: |
| idx = next(i for i, p in enumerate(csv_paths) if p.name == start) |
| except StopIteration: |
| raise FileNotFoundError( |
| f"--start-file {start} not found among CSV files in {output_dir}" |
| ) |
| csv_paths = csv_paths[idx:] |
| logger.info(f"found {len(csv_paths)} csv files") |
| for csv_path in csv_paths: |
| rows = [] |
| with open(csv_path, mode="r", newline="", encoding="utf-8") as f: |
| reader = csv.DictReader(f) |
| for row in reader: |
| rows.append(row) |
|
|
| fieldnames = list(rows[0].keys()) if rows else [] |
| needs_update: list[dict] = [] |
| for row in rows: |
| question = row["question"] |
| game = row.get("game", "") |
| if game and game.lower() not in question.lower(): |
| needs_update.append(row) |
|
|
| logger.info( |
| f"{csv_path.name}: {len(needs_update)}/{len(rows)} questions need updating" |
| ) |
| if not needs_update: |
| continue |
|
|
| updated = [] |
| for start in range(0, len(needs_update), max_concurrent): |
| batch = needs_update[start : start + max_concurrent] |
| logger.info( |
| f"\tstarting {start}/{len(needs_update)} batch ({len(batch)} rows)" |
| ) |
| batch_questions = await asyncio.gather( |
| *( |
| rewrite_self_contained( |
| openai_client, |
| model, |
| row["question"], |
| row.get("manufacturer", ""), |
| row.get("game", ""), |
| ) |
| for row in batch |
| ) |
| ) |
| for row, new_question in zip(batch, batch_questions): |
| row["question"] = new_question |
| updated.append(row) |
|
|
| with open(csv_path, mode="w", newline="", encoding="utf-8") as f: |
| writer = csv.DictWriter(f, fieldnames=fieldnames) |
| writer.writeheader() |
| for row in rows: |
| writer.writerow(row) |
|
|
| logger.info(f"finished {csv_path.name}") |
|
|
|
|
| async def main(args: argparse.Namespace) -> None: |
| if args.action == "extract": |
| await run_extract(args) |
| elif args.action == "update-to-self-contained": |
| await run_update_to_self_contained(args) |
| elif args.action == "validate-question": |
| await run_validate_question(args) |
| else: |
| raise ValueError(f"Unknown action: {args.action}") |
|
|
|
|
| if __name__ == "__main__": |
| asyncio.run(main(build_parser().parse_args())) |
|
|
