Add MLB 2024 ChatML matchup dataset

Upload verified 2024 MLB ChatML matchup Parquet split, schema, manifest, reproducibility scripts, and a polished dataset card.

README.md

@@ -0,0 +1,214 @@
+---
+license: other
+language:
+- en
+task_categories:
+- text-generation
+- question-answering
+tags:
+- mlb
+- baseball
+- sports-analytics
+- chatml
+- parquet
+- instruction-tuning
+- matchup-analysis
+- structured-output
+- statsapi
+size_categories:
+- 1K<n<10K
+pretty_name: MLB 2024 ChatML Matchups
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train-00000-of-00001.parquet
+---
+
+# MLB 2024 ChatML Matchups
+
+MLB 2024 ChatML Matchups is a compact, inspection-friendly instruction dataset derived from the public MLB Stats API for the 2024 Major League Baseball regular season. It converts structured game, offense, and pitching data into ChatML-style examples that can be used to study grounded sports reasoning, structured response generation, and retrieval-conditioned assistant behavior.
+
+The dataset is intentionally small enough to audit directly, but structured enough to support serious supervised fine-tuning experiments. Each row asks an assistant to build a pitching and offense matchup brief for one team against its opponent on a specific date. The target answer is a compact JSON object containing the exact facts supplied by the data pipeline.
+
+## Executive Summary
+
+| Property | Value |
+|---|---:|
+| Season | 2024 MLB regular season |
+| Source | Public MLB Stats API |
+| Completed unique games | 2,425 |
+| Rows | 4,850 |
+| Teams | 30 |
+| Format | Parquet |
+| Split | `train` |
+| Primary training column | `messages` |
+| Unit of observation | One team perspective for one completed game |
+| Target format | JSON inside the assistant message |
+
+Each completed game emits two examples: one from the away team's perspective and one from the home team's perspective. Postponed placeholders are excluded. Suspended or continued games that appear on multiple schedule dates are deduplicated by MLB `gamePk`.
+
+## Motivation
+
+Sports analytics work often lives at the boundary between structured records and natural-language reasoning. A model may need to answer a seemingly simple question such as "How did the Dodgers match up with the Padres?" while preserving numerical context about offense, pitching, final score, and opponent strength.
+
+This dataset is designed for that boundary. It teaches the model to:
+
+- condition on explicit facts rather than unsupported memory
+- preserve team, opponent, score, batting, and pitching context
+- reason from a team-specific point of view
+- emit structured, machine-checkable assistant outputs
+- keep sports analysis grounded in the supplied record
+
+The result is a useful dataset for fine-tuning and evaluation workflows where the goal is not just fluent commentary, but disciplined use of retrieved or supplied sports data.
+
+## What Is In Each Row
+
+Every row includes:
+
+- game identity and date
+- team and opponent identity
+- home/away side
+- final score from the row team's perspective
+- game-level batting statistics for both teams
+- game-level pitching statistics for both teams
+- full-season 2024 hitting statistics for both teams
+- full-season 2024 pitching statistics for both teams
+- a ChatML `messages` field containing `system`, `user`, and `assistant` turns
+
+The assistant answer is JSON. This makes the target easy to validate, parse, score, and transform into downstream prose if desired.
+
+## Data Sources And Construction
+
+The dataset was built from the public MLB Stats API:
+
+- `https://statsapi.mlb.com/api/v1/schedule`
+- `https://statsapi.mlb.com/api/v1/teams/stats`
+- `https://statsapi.mlb.com/api/v1/game/{gamePk}/boxscore`
+
+The builder performs a sequential, rate-limited scrape with a local disk cache, retry/backoff behavior, and explicit `429` handling. The completed run used 2,427 network requests, had zero retries, and received zero rate-limit responses.
+
+The season team statistics are full-season 2024 aggregates. They are included as context for model learning and matchup framing, not as a pregame-only feature matrix.
+
+## Row Example
+
+```json
+[
+  {
+    "role": "system",
+    "content": "You are an MLB matchup analyst. Use only the supplied 2024 MLB Stats API facts and answer in compact JSON."
+  },
+  {
+    "role": "user",
+    "content": "Build a pitching and offense matchup brief for Los Angeles Dodgers vs San Diego Padres on 2024-03-20."
+  },
+  {
+    "role": "assistant",
+    "content": "{\"season\":2024,\"game_pk\":745444,\"team\":{\"name\":\"Los Angeles Dodgers\",...}}"
+  }
+]
+```
+
+## Column Schema
+
+| Column | Description |
+|---|---|
+| `row_id` | Stable identifier: `mlb-2024-{game_pk}-{side}` |
+| `season` | Season year, always `2024` |
+| `game_pk` | MLB game identifier |
+| `game_date` | UTC date as `YYYY-MM-DD` |
+| `game_datetime_utc` | Full UTC game datetime from MLB schedule data |
+| `team_id`, `team_name`, `team_side` | Team identity and row perspective |
+| `opponent_id`, `opponent_name`, `opponent_side` | Opponent identity and side |
+| `team_runs`, `opponent_runs` | Final score from the row team's perspective |
+| `result` | `win`, `loss`, or `tie` |
+| `messages` | ChatML-style `system`, `user`, `assistant` messages |
+| `assistant_payload_json` | Full assistant target payload as JSON text |
+| `team_game_batting_json` | Team game batting line |
+| `team_game_pitching_json` | Team game pitching line |
+| `opponent_game_batting_json` | Opponent game batting line |
+| `opponent_game_pitching_json` | Opponent game pitching line |
+| `team_season_hitting_json` | Team full-season hitting context |
+| `team_season_pitching_json` | Team full-season pitching context |
+| `opponent_season_hitting_json` | Opponent full-season hitting context |
+| `opponent_season_pitching_json` | Opponent full-season pitching context |
+
+## Loading The Dataset
+
+### Hugging Face Datasets
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("clarkkitchen22/MLB-2024-ChatML-Matchups", split="train")
+row = ds[0]
+
+messages = row["messages"]
+assistant_payload = row["assistant_payload_json"]
+```
+
+### Pandas
+
+```python
+import pandas as pd
+
+df = pd.read_parquet(
+    "hf://datasets/clarkkitchen22/MLB-2024-ChatML-Matchups/data/train-00000-of-00001.parquet"
+)
+
+print(df[["team_name", "opponent_name", "team_runs", "opponent_runs", "result"]].head())
+```
+
+## How To Use This Dataset
+
+For supervised fine-tuning, use the `messages` column directly if your trainer accepts ChatML-style conversations. If your model requires a single text field, render each message list through the tokenizer's chat template before training.
+
+Recommended experiments:
+
+- Train a small instruct model to preserve structured baseball facts in JSON.
+- Evaluate structured-output faithfulness by parsing `assistant_payload_json`.
+- Test retrieval-augmented pipelines where the retrieved Parquet row becomes the grounding context.
+- Compare prose-generation prompts against JSON-first prompts for sports analytics reliability.
+- Build a lightweight matchup assistant that can cite team offense and pitching context.
+
+The cleanest research use is to treat this as a controlled structured-output dataset: the model is asked for analysis, but the target is deliberately fact-shaped and parseable.
+
+## Why This Dataset Matters
+
+Many sports datasets are either raw tables or free-form text. Raw tables are easy to compute over but awkward for chat-model training. Free-form text is easy to train on but hard to audit for factual grounding. This dataset sits between those extremes: every example is conversational at the surface and structured at the target.
+
+That design makes it useful for a practical machine-learning question: can a model learn to be conversational while staying bound to supplied statistical evidence?
+
+## Verification
+
+The dataset was verified with `scripts/verify_dataset.py`.
+
+Verification summary:
+
+- `rows`: 4,850
+- `games`: 2,425
+- `teams`: 30
+- `rows_match_schedule_x2`: true
+- `unique_row_ids`: true
+- `all_games_present`: true
+- `all_30_teams_present`: true
+- `season_matches`: true
+- `chatml_roles_valid`: true
+- `pitching_fields_present`: true
+
+## Limitations
+
+- This dataset reflects MLB Stats API responses available at build time.
+- Season team statistics are full-season 2024 totals, not strictly pregame rolling features.
+- The assistant targets are structured JSON, not finished editorial scouting prose.
+- It does not include player-level pitch-by-pitch events, betting odds, injuries, weather, umpires, lineups, or park-factor adjustments.
+- It is not suitable by itself for causal claims about team quality or predictive wagering.
+- Commercial use and redistribution should be evaluated against applicable MLB data terms and policies.
+
+## Responsible Use
+
+Use this dataset for sports analytics research, instruction tuning, retrieval prototypes, and structured-output evaluation. Do not present model outputs as official MLB commentary, real-time predictions, injury guidance, or betting advice.
+
+## Attribution
+
+Data was collected from the public MLB Stats API. This dataset is not affiliated with, endorsed by, or sponsored by Major League Baseball, MLB Advanced Media, or any MLB club.

data/train-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9df8e2a8cbbbc04853b21ef992c40260cf0f2d63dd900656c0930c184ba89592
+size 1884925

mlb_2024_chatml_matchups.manifest.json

@@ -0,0 +1,14 @@
+{
+  "api_metrics": {
+    "cache_hits": 0,
+    "network_requests": 2427,
+    "rate_limited": 0,
+    "retries": 0
+  },
+  "created_at": "2026-05-14T01:35:56.947999+00:00",
+  "output_path": "data/processed/mlb_2024_chatml_matchups.parquet",
+  "regular_season_final_games": 2425,
+  "rows": 4850,
+  "season": 2024,
+  "source": "https://statsapi.mlb.com/api/v1"
+}

schema.json

@@ -0,0 +1,121 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "MLB 2024 ChatML Matchup Row",
+  "type": "object",
+  "required": [
+    "row_id",
+    "season",
+    "game_pk",
+    "game_date",
+    "game_datetime_utc",
+    "team_id",
+    "team_name",
+    "team_side",
+    "opponent_id",
+    "opponent_name",
+    "opponent_side",
+    "team_runs",
+    "opponent_runs",
+    "result",
+    "messages",
+    "assistant_payload_json",
+    "team_game_batting_json",
+    "team_game_pitching_json",
+    "opponent_game_batting_json",
+    "opponent_game_pitching_json",
+    "team_season_hitting_json",
+    "team_season_pitching_json",
+    "opponent_season_hitting_json",
+    "opponent_season_pitching_json"
+  ],
+  "properties": {
+    "row_id": {
+      "type": "string",
+      "pattern": "^mlb-2024-[0-9]+-(away|home)$"
+    },
+    "season": {
+      "const": 2024
+    },
+    "game_pk": {
+      "type": "integer"
+    },
+    "game_date": {
+      "type": "string",
+      "format": "date"
+    },
+    "game_datetime_utc": {
+      "type": "string"
+    },
+    "team_id": {
+      "type": "integer"
+    },
+    "team_name": {
+      "type": "string"
+    },
+    "team_side": {
+      "enum": ["away", "home"]
+    },
+    "opponent_id": {
+      "type": "integer"
+    },
+    "opponent_name": {
+      "type": "string"
+    },
+    "opponent_side": {
+      "enum": ["away", "home"]
+    },
+    "team_runs": {
+      "type": "integer"
+    },
+    "opponent_runs": {
+      "type": "integer"
+    },
+    "result": {
+      "enum": ["win", "loss", "tie"]
+    },
+    "messages": {
+      "type": "array",
+      "minItems": 3,
+      "maxItems": 3,
+      "items": {
+        "type": "object",
+        "required": ["role", "content"],
+        "properties": {
+          "role": {
+            "enum": ["system", "user", "assistant"]
+          },
+          "content": {
+            "type": "string"
+          }
+        }
+      }
+    },
+    "assistant_payload_json": {
+      "type": "string"
+    },
+    "team_game_batting_json": {
+      "type": "string"
+    },
+    "team_game_pitching_json": {
+      "type": "string"
+    },
+    "opponent_game_batting_json": {
+      "type": "string"
+    },
+    "opponent_game_pitching_json": {
+      "type": "string"
+    },
+    "team_season_hitting_json": {
+      "type": "string"
+    },
+    "team_season_pitching_json": {
+      "type": "string"
+    },
+    "opponent_season_hitting_json": {
+      "type": "string"
+    },
+    "opponent_season_pitching_json": {
+      "type": "string"
+    }
+  }
+}

scripts/build_dataset.py

@@ -0,0 +1,454 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import random
+import time
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlencode
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+import requests
+
+
+BASE_URL = "https://statsapi.mlb.com/api/v1"
+DEFAULT_SEASON = 2025
+
+STAT_KEYS = [
+    "gamesPlayed",
+    "runs",
+    "hits",
+    "doubles",
+    "triples",
+    "homeRuns",
+    "rbi",
+    "baseOnBalls",
+    "strikeOuts",
+    "stolenBases",
+    "caughtStealing",
+    "avg",
+    "obp",
+    "slg",
+    "ops",
+    "era",
+    "whip",
+    "inningsPitched",
+    "earnedRuns",
+    "battersFaced",
+    "groundOuts",
+    "airOuts",
+    "leftOnBase",
+]
+
+
+@dataclass
+class ApiMetrics:
+    network_requests: int = 0
+    cache_hits: int = 0
+    retries: int = 0
+    rate_limited: int = 0
+
+
+class RateLimiter:
+    def __init__(self, max_rps: float) -> None:
+        if max_rps <= 0:
+            raise ValueError("--max-rps must be positive")
+        self.min_interval = 1.0 / max_rps
+        self.last_request_at = 0.0
+
+    def wait(self) -> None:
+        elapsed = time.monotonic() - self.last_request_at
+        remaining = self.min_interval - elapsed
+        if remaining > 0:
+            time.sleep(remaining)
+        self.last_request_at = time.monotonic()
+
+
+class MlbApiClient:
+    def __init__(
+        self,
+        cache_dir: Path,
+        max_rps: float,
+        force_refresh: bool = False,
+        timeout: int = 30,
+        max_retries: int = 5,
+    ) -> None:
+        self.cache_dir = cache_dir
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        self.force_refresh = force_refresh
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self.rate_limiter = RateLimiter(max_rps=max_rps)
+        self.metrics = ApiMetrics()
+        self.session = requests.Session()
+        self.session.headers.update(
+            {
+                "Accept": "application/json",
+                "User-Agent": (
+                    "mlb-chatml-2025-dataset/0.1 "
+                    "(research dataset builder; contact: Clark Kitchen)"
+                ),
+            }
+        )
+
+    def get(self, path: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        params = params or {}
+        url = f"{BASE_URL}{path}"
+        cache_path = self._cache_path(url, params)
+        if cache_path.exists() and not self.force_refresh:
+            self.metrics.cache_hits += 1
+            return json.loads(cache_path.read_text())
+
+        query = urlencode(sorted(params.items()))
+        full_url = f"{url}?{query}" if query else url
+        last_error: Exception | None = None
+        for attempt in range(self.max_retries + 1):
+            if attempt:
+                self.metrics.retries += 1
+                sleep_seconds = min(60.0, (2**attempt) + random.uniform(0.0, 0.5))
+                time.sleep(sleep_seconds)
+            self.rate_limiter.wait()
+            self.metrics.network_requests += 1
+            try:
+                response = self.session.get(full_url, timeout=self.timeout)
+                if response.status_code == 429:
+                    self.metrics.rate_limited += 1
+                    retry_after = response.headers.get("Retry-After")
+                    if retry_after:
+                        time.sleep(min(float(retry_after), 120.0))
+                    continue
+                if response.status_code >= 500:
+                    continue
+                response.raise_for_status()
+                data = response.json()
+                cache_path.write_text(json.dumps(data, sort_keys=True))
+                return data
+            except (requests.RequestException, json.JSONDecodeError) as exc:
+                last_error = exc
+                continue
+        raise RuntimeError(f"MLB API request failed after retries: {full_url}") from last_error
+
+    def _cache_path(self, url: str, params: dict[str, Any]) -> Path:
+        cache_key = json.dumps({"url": url, "params": sorted(params.items())}, sort_keys=True)
+        digest = hashlib.sha256(cache_key.encode("utf-8")).hexdigest()
+        return self.cache_dir / f"{digest}.json"
+
+
+def compact_stat_dict(stats: dict[str, Any]) -> dict[str, Any]:
+    return {key: stats[key] for key in STAT_KEYS if key in stats}
+
+
+def default_start_date(season: int) -> str:
+    return f"{season}-03-01"
+
+
+def default_end_date(season: int) -> str:
+    return f"{season}-11-30"
+
+
+def load_schedule(
+    client: MlbApiClient, season: int, start_date: str, end_date: str
+) -> list[dict[str, Any]]:
+    data = client.get(
+        "/schedule",
+        {
+            "sportId": 1,
+            "season": season,
+            "gameType": "R",
+            "startDate": start_date,
+            "endDate": end_date,
+        },
+    )
+    games_by_pk: dict[int, dict[str, Any]] = {}
+    for date_block in data.get("dates", []):
+        for game in date_block.get("games", []):
+            status = game.get("status", {})
+            has_scores = (
+                game.get("teams", {}).get("away", {}).get("score") is not None
+                and game.get("teams", {}).get("home", {}).get("score") is not None
+            )
+            if status.get("statusCode") == "F" and has_scores:
+                game_pk = int(game["gamePk"])
+                previous = games_by_pk.get(game_pk)
+                if previous is None or game["gameDate"] > previous["gameDate"]:
+                    games_by_pk[game_pk] = game
+    return sorted(games_by_pk.values(), key=lambda game: (game["gameDate"], int(game["gamePk"])))
+
+
+def load_season_team_stats(
+    client: MlbApiClient, season: int
+) -> dict[int, dict[str, dict[str, Any]]]:
+    data = client.get(
+        "/teams/stats",
+        {
+            "season": season,
+            "sportIds": 1,
+            "group": "hitting,pitching",
+            "stats": "season",
+        },
+    )
+    team_stats: dict[int, dict[str, dict[str, Any]]] = {}
+    for stat_block in data.get("stats", []):
+        group = stat_block.get("group", {}).get("displayName")
+        if group not in {"hitting", "pitching"}:
+            continue
+        for split in stat_block.get("splits", []):
+            team_id = int(split["team"]["id"])
+            team_stats.setdefault(team_id, {})[group] = compact_stat_dict(split.get("stat", {}))
+    return team_stats
+
+
+def score_for_side(game: dict[str, Any], side: str) -> int | None:
+    value = game.get("teams", {}).get(side, {}).get("score")
+    return int(value) if value is not None else None
+
+
+def result_for(team_runs: int | None, opponent_runs: int | None) -> str:
+    if team_runs is None or opponent_runs is None:
+        return "unknown"
+    if team_runs > opponent_runs:
+        return "win"
+    if team_runs < opponent_runs:
+        return "loss"
+    return "tie"
+
+
+def json_dumps(data: Any) -> str:
+    return json.dumps(data, sort_keys=True, separators=(",", ":"))
+
+
+def matchup_assistant_payload(
+    game: dict[str, Any],
+    side: str,
+    opponent_side: str,
+    team_stats: dict[int, dict[str, dict[str, Any]]],
+    boxscore: dict[str, Any],
+    season: int,
+) -> dict[str, Any]:
+    team = game["teams"][side]["team"]
+    opponent = game["teams"][opponent_side]["team"]
+    team_id = int(team["id"])
+    opponent_id = int(opponent["id"])
+    team_box = boxscore["teams"][side]
+    opponent_box = boxscore["teams"][opponent_side]
+    team_runs = score_for_side(game, side)
+    opponent_runs = score_for_side(game, opponent_side)
+    return {
+        "season": season,
+        "game_pk": game["gamePk"],
+        "game_date": game["gameDate"],
+        "team": {"id": team_id, "name": team["name"], "side": side},
+        "opponent": {"id": opponent_id, "name": opponent["name"], "side": opponent_side},
+        "score": {
+            "team_runs": team_runs,
+            "opponent_runs": opponent_runs,
+            "result": result_for(team_runs, opponent_runs),
+        },
+        "team_game": {
+            "batting": compact_stat_dict(team_box.get("teamStats", {}).get("batting", {})),
+            "pitching": compact_stat_dict(team_box.get("teamStats", {}).get("pitching", {})),
+            "fielding": compact_stat_dict(team_box.get("teamStats", {}).get("fielding", {})),
+        },
+        "opponent_game": {
+            "batting": compact_stat_dict(opponent_box.get("teamStats", {}).get("batting", {})),
+            "pitching": compact_stat_dict(opponent_box.get("teamStats", {}).get("pitching", {})),
+            "fielding": compact_stat_dict(opponent_box.get("teamStats", {}).get("fielding", {})),
+        },
+        "team_season": team_stats.get(team_id, {}),
+        "opponent_season": team_stats.get(opponent_id, {}),
+    }
+
+
+def build_messages(payload: dict[str, Any], season: int) -> list[dict[str, str]]:
+    team = payload["team"]["name"]
+    opponent = payload["opponent"]["name"]
+    game_date = payload["game_date"][:10]
+    return [
+        {
+            "role": "system",
+            "content": (
+                f"You are an MLB matchup analyst. Use only the supplied {season} MLB Stats API "
+                "facts and answer in compact JSON."
+            ),
+        },
+        {
+            "role": "user",
+            "content": (
+                f"Build a pitching and offense matchup brief for {team} vs {opponent} "
+                f"on {game_date}."
+            ),
+        },
+        {"role": "assistant", "content": json_dumps(payload)},
+    ]
+
+
+def build_rows(
+    games: list[dict[str, Any]],
+    team_stats: dict[int, dict[str, dict[str, Any]]],
+    client: MlbApiClient,
+    limit_games: int | None,
+    season: int,
+) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    selected_games = games[:limit_games] if limit_games else games
+    for index, game in enumerate(selected_games, start=1):
+        if index == 1 or index % 100 == 0 or index == len(selected_games):
+            print(f"fetching boxscores {index}/{len(selected_games)} gamePk={game['gamePk']}")
+        boxscore = client.get(f"/game/{game['gamePk']}/boxscore")
+        for side, opponent_side in (("away", "home"), ("home", "away")):
+            payload = matchup_assistant_payload(
+                game, side, opponent_side, team_stats, boxscore, season
+            )
+            team = payload["team"]
+            opponent = payload["opponent"]
+            team_runs = payload["score"]["team_runs"]
+            opponent_runs = payload["score"]["opponent_runs"]
+            row = {
+                "row_id": f"mlb-{season}-{game['gamePk']}-{side}",
+                "season": season,
+                "game_pk": int(game["gamePk"]),
+                "game_date": game["gameDate"][:10],
+                "game_datetime_utc": game["gameDate"],
+                "team_id": int(team["id"]),
+                "team_name": team["name"],
+                "team_side": side,
+                "opponent_id": int(opponent["id"]),
+                "opponent_name": opponent["name"],
+                "opponent_side": opponent_side,
+                "team_runs": team_runs,
+                "opponent_runs": opponent_runs,
+                "result": payload["score"]["result"],
+                "messages": build_messages(payload, season),
+                "assistant_payload_json": json_dumps(payload),
+                "team_game_batting_json": json_dumps(payload["team_game"]["batting"]),
+                "team_game_pitching_json": json_dumps(payload["team_game"]["pitching"]),
+                "opponent_game_batting_json": json_dumps(payload["opponent_game"]["batting"]),
+                "opponent_game_pitching_json": json_dumps(payload["opponent_game"]["pitching"]),
+                "team_season_hitting_json": json_dumps(payload["team_season"].get("hitting", {})),
+                "team_season_pitching_json": json_dumps(payload["team_season"].get("pitching", {})),
+                "opponent_season_hitting_json": json_dumps(
+                    payload["opponent_season"].get("hitting", {})
+                ),
+                "opponent_season_pitching_json": json_dumps(
+                    payload["opponent_season"].get("pitching", {})
+                ),
+            }
+            rows.append(row)
+    return rows
+
+
+def write_parquet(rows: list[dict[str, Any]], output_path: Path) -> None:
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    schema = pa.schema(
+        [
+            ("row_id", pa.string()),
+            ("season", pa.int16()),
+            ("game_pk", pa.int64()),
+            ("game_date", pa.string()),
+            ("game_datetime_utc", pa.string()),
+            ("team_id", pa.int64()),
+            ("team_name", pa.string()),
+            ("team_side", pa.string()),
+            ("opponent_id", pa.int64()),
+            ("opponent_name", pa.string()),
+            ("opponent_side", pa.string()),
+            ("team_runs", pa.int16()),
+            ("opponent_runs", pa.int16()),
+            ("result", pa.string()),
+            (
+                "messages",
+                pa.list_(pa.struct([("role", pa.string()), ("content", pa.string())])),
+            ),
+            ("assistant_payload_json", pa.string()),
+            ("team_game_batting_json", pa.string()),
+            ("team_game_pitching_json", pa.string()),
+            ("opponent_game_batting_json", pa.string()),
+            ("opponent_game_pitching_json", pa.string()),
+            ("team_season_hitting_json", pa.string()),
+            ("team_season_pitching_json", pa.string()),
+            ("opponent_season_hitting_json", pa.string()),
+            ("opponent_season_pitching_json", pa.string()),
+        ]
+    )
+    table = pa.Table.from_pylist(rows, schema=schema)
+    pq.write_table(table, output_path, compression="zstd")
+
+
+def write_manifest(
+    manifest_path: Path,
+    output_path: Path,
+    games: list[dict[str, Any]],
+    rows: list[dict[str, Any]],
+    client: MlbApiClient,
+    season: int,
+) -> None:
+    manifest = {
+        "created_at": datetime.now(timezone.utc).isoformat(),
+        "season": season,
+        "source": "https://statsapi.mlb.com/api/v1",
+        "regular_season_final_games": len(games),
+        "rows": len(rows),
+        "output_path": str(output_path),
+        "api_metrics": client.metrics.__dict__,
+    }
+    manifest_path.parent.mkdir(parents=True, exist_ok=True)
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True))
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--season", type=int, default=DEFAULT_SEASON)
+    parser.add_argument("--start-date", default=None)
+    parser.add_argument("--end-date", default=None)
+    parser.add_argument("--cache-dir", type=Path, default=Path(".cache/mlb_api"))
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=None,
+    )
+    parser.add_argument(
+        "--manifest",
+        type=Path,
+        default=None,
+    )
+    parser.add_argument("--max-rps", type=float, default=4.0)
+    parser.add_argument("--force-refresh", action="store_true")
+    parser.add_argument("--limit-games", type=int, default=None)
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    start_date = args.start_date or default_start_date(args.season)
+    end_date = args.end_date or default_end_date(args.season)
+    output = args.output or Path(f"data/processed/mlb_{args.season}_chatml_matchups.parquet")
+    manifest = args.manifest or Path(
+        f"data/processed/mlb_{args.season}_chatml_matchups.manifest.json"
+    )
+    client = MlbApiClient(
+        cache_dir=args.cache_dir,
+        max_rps=args.max_rps,
+        force_refresh=args.force_refresh,
+    )
+    games = load_schedule(client, args.season, start_date, end_date)
+    print(f"loaded {len(games)} final regular-season games")
+    team_stats = load_season_team_stats(client, args.season)
+    if len(team_stats) != 30:
+        raise RuntimeError(f"expected 30 teams with season stats, got {len(team_stats)}")
+    rows = build_rows(games, team_stats, client, args.limit_games, args.season)
+    if not rows:
+        raise RuntimeError("no rows built")
+    write_parquet(rows, output)
+    write_manifest(manifest, output, games, rows, client, args.season)
+    print(f"wrote {len(rows)} rows to {output}")
+    print(f"api metrics: {client.metrics.__dict__}")
+
+
+if __name__ == "__main__":
+    main()

scripts/verify_dataset.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+import pyarrow.parquet as pq
+
+from build_dataset import MlbApiClient, default_end_date, default_start_date, load_schedule
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Verify the generated MLB ChatML parquet dataset.")
+    parser.add_argument(
+        "--parquet",
+        type=Path,
+        default=None,
+    )
+    parser.add_argument("--season", type=int, default=2025)
+    parser.add_argument("--start-date", default=None)
+    parser.add_argument("--end-date", default=None)
+    parser.add_argument("--cache-dir", type=Path, default=Path(".cache/mlb_api"))
+    parser.add_argument("--max-rps", type=float, default=4.0)
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    parquet_path = args.parquet or Path(
+        f"data/processed/mlb_{args.season}_chatml_matchups.parquet"
+    )
+    if not parquet_path.exists():
+        raise SystemExit(f"missing parquet file: {parquet_path}")
+
+    table = pq.read_table(parquet_path)
+    rows = table.to_pylist()
+    client = MlbApiClient(cache_dir=args.cache_dir, max_rps=args.max_rps)
+    start_date = args.start_date or default_start_date(args.season)
+    end_date = args.end_date or default_end_date(args.season)
+    games = load_schedule(client, args.season, start_date, end_date)
+    expected_rows = len(games) * 2
+
+    row_ids = [row["row_id"] for row in rows]
+    game_pks = {row["game_pk"] for row in rows}
+    team_ids = {row["team_id"] for row in rows}
+    seasons = {row["season"] for row in rows}
+    bad_messages = [
+        row["row_id"]
+        for row in rows
+        if [message["role"] for message in row["messages"]] != ["system", "user", "assistant"]
+    ]
+    missing_pitching = [
+        row["row_id"]
+        for row in rows
+        if not json.loads(row["team_game_pitching_json"])
+        or not json.loads(row["team_season_pitching_json"])
+        or not json.loads(row["opponent_game_pitching_json"])
+    ]
+
+    checks = {
+        "rows_match_schedule_x2": len(rows) == expected_rows,
+        "unique_row_ids": len(row_ids) == len(set(row_ids)),
+        "all_games_present": len(game_pks) == len(games),
+        "all_30_teams_present": len(team_ids) == 30,
+        "season_matches": seasons == {args.season},
+        "chatml_roles_valid": not bad_messages,
+        "pitching_fields_present": not missing_pitching,
+    }
+    print(
+        json.dumps(
+            {
+                "parquet": str(parquet_path),
+                "season": args.season,
+                "rows": len(rows),
+                "expected_rows": expected_rows,
+                "games": len(games),
+                "teams": len(team_ids),
+                "checks": checks,
+                "api_metrics": client.metrics.__dict__,
+            },
+            indent=2,
+            sort_keys=True,
+        )
+    )
+    failed = [name for name, passed in checks.items() if not passed]
+    if failed:
+        raise SystemExit(f"verification failed: {failed}")
+
+
+if __name__ == "__main__":
+    main()