fixed ttl logic

app.py

@@ -13,24 +13,33 @@ import seaborn as sns
 
 from simulator import InningOutcomeDistribution, simulate_game
 
-_DATA_DIR = "/data" if os.path.isdir("/data") else "data"
-DATA_PATH = os.path.join(_DATA_DIR, "full_2025_season.parquet")
+_DATA_DIR  = "/data" if os.path.isdir("/data") else "data"
+_HF_REPO_ID = "mc0117/mlb-models-storage"
+DATA_PATH  = os.path.join(_DATA_DIR, "full_2026_season.parquet")
 _dist_cache: dict = {}
 
 
 def _ensure_data():
     if not os.path.exists(DATA_PATH):
         from huggingface_hub import hf_hub_download
+        from huggingface_hub.utils import EntryNotFoundError
         os.makedirs(_DATA_DIR, exist_ok=True)
-        print(f"Downloading dataset to {DATA_PATH}...")
-        hf_hub_download(
-            repo_id="mc0117/mlb-models-storage",
-            filename="full_2025_season.parquet",
-            repo_type="dataset",
-            local_dir=_DATA_DIR,
-            local_dir_use_symlinks=False,
-            token=os.environ.get("HF_TOKEN"),
-        )
+        filename = os.path.basename(DATA_PATH)
+        print(f"Downloading {filename} from HF Hub...")
+        try:
+            hf_hub_download(
+                repo_id=_HF_REPO_ID,
+                filename=filename,
+                repo_type="dataset",
+                local_dir=_DATA_DIR,
+                local_dir_use_symlinks=False,
+                token=os.environ.get("HF_TOKEN"),
+            )
+        except EntryNotFoundError:
+            raise RuntimeError(
+                f"{filename} not found on HF Hub. "
+                "Call update_season_data() to fetch and upload it first."
+            )
 
 
 def _get_dist(team: str) -> InningOutcomeDistribution:
@@ -143,65 +152,127 @@ def simulate_json(home_team: str, away_team: str, n_simulations: int) -> dict:
     }
 
 
-# MLB Stats API uses "AZ" for Arizona; everything else matches our abbreviations.
-_MLB_API_TO_ABBR = {"AZ": "ARI"}
+# MLB Stats API sometimes returns full names instead of abbreviations.
+_TEAM_NAME_TO_ABBR = {
+    "Arizona Diamondbacks": "ARI", "Atlanta Braves": "ATL",    "Baltimore Orioles": "BAL",
+    "Boston Red Sox": "BOS",       "Chicago Cubs": "CHC",       "Chicago White Sox": "CWS",
+    "Cincinnati Reds": "CIN",      "Cleveland Guardians": "CLE","Colorado Rockies": "COL",
+    "Detroit Tigers": "DET",       "Houston Astros": "HOU",     "Kansas City Royals": "KC",
+    "Los Angeles Angels": "LAA",   "Los Angeles Dodgers": "LAD","Miami Marlins": "MIA",
+    "Milwaukee Brewers": "MIL",    "Minnesota Twins": "MIN",    "New York Mets": "NYM",
+    "New York Yankees": "NYY",     "Oakland Athletics": "OAK",  "Athletics": "OAK",
+    "Philadelphia Phillies": "PHI","Pittsburgh Pirates": "PIT", "San Diego Padres": "SD",
+    "Seattle Mariners": "SEA",     "San Francisco Giants": "SF","St. Louis Cardinals": "STL",
+    "Tampa Bay Rays": "TB",        "Texas Rangers": "TEX",      "Toronto Blue Jays": "TOR",
+    "Washington Nationals": "WSH",
+    # abbreviation-level overrides (API returns "AZ" for Arizona)
+    "AZ": "ARI",
+}
 
-_MLB_SCHEDULE_URL = "https://statsapi.mlb.com/api/v1/schedule?sportId=1&gameType=R&date={date}"
+_MLB_SCHEDULE_URL  = "https://statsapi.mlb.com/api/v1/schedule?sportId=1&gameType=R&date={date}"
 
+_CACHE_TTL  = timedelta(hours=6)
+_mem_cache: dict = {}   # (date_str, n_sims) -> {"cached_at": datetime, "result": dict}
 
-# ── Endpoint 3: simulate_today ───────────────────────────────────────────────
-# Fetches today's MLB schedule and simulates every game.
 
-def simulate_today(n_simulations: int = 10000) -> dict:
-    """
-    Returns:
-    {
-      "date":    str,
-      "n_games": int,
-      "games": [
-        {
-          "game_pk":        int,
-          "game_status":    str,   // "Preview" | "Live" | "Final"
-          "home_team":      str,
-          "away_team":      str,
-          "home_win_pct":   float,
-          "away_win_pct":   float,
-          "home_avg_score": float,
-          "away_avg_score": float,
-          ...                      // full simulate_json payload per game
-        },
-        ...
-      ]
-    }
-    """
-    today = date.today().strftime("%Y-%m-%d")
-    url = _MLB_SCHEDULE_URL.format(date=today)
+def _cache_hf_path(today: str, n_simulations: int) -> str:
+    return f"simulate_today_cache/{today}_{n_simulations}.json"
+
+
+def _load_cache(today: str, n_simulations: int) -> dict | None:
+    key = (today, n_simulations)
+    now = datetime.now(timezone.utc)
+
+    entry = _mem_cache.get(key)
+    if entry and now - entry["cached_at"] < _CACHE_TTL:
+        return entry["result"]
+
+    try:
+        from huggingface_hub import hf_hub_download
+        local_path = hf_hub_download(
+            repo_id=_HF_REPO_ID,
+            filename=_cache_hf_path(today, n_simulations),
+            repo_type="dataset",
+            token=os.environ.get("HF_TOKEN"),
+            force_download=True,
+        )
+        with open(local_path) as f:
+            stored = json.load(f)
+        cached_at = datetime.fromisoformat(stored["cached_at"])
+        if cached_at.tzinfo is None:
+            cached_at = cached_at.replace(tzinfo=timezone.utc)
+        if now - cached_at < _CACHE_TTL:
+            _mem_cache[key] = {"cached_at": cached_at, "result": stored["result"]}
+            return stored["result"]
+    except Exception:
+        pass
+
+    return None
+
+
+def _save_cache(today: str, n_simulations: int, result: dict) -> None:
+    key = (today, n_simulations)
+    now = datetime.now(timezone.utc)
+    _mem_cache[key] = {"cached_at": now, "result": result}
+
+    payload = {"cached_at": now.isoformat(), "result": result}
+    tmp_path = None
+    try:
+        from huggingface_hub import upload_file
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
+            json.dump(payload, f)
+            tmp_path = f.name
+        upload_file(
+            path_or_fileobj=tmp_path,
+            path_in_repo=_cache_hf_path(today, n_simulations),
+            repo_id=_HF_REPO_ID,
+            repo_type="dataset",
+            token=os.environ.get("HF_TOKEN"),
+        )
+    except Exception as e:
+        print(f"Cache upload failed: {e}")
+    finally:
+        if tmp_path:
+            try:
+                os.unlink(tmp_path)
+            except Exception:
+                pass
+
 
+# ── Endpoint 3 & 4: simulate_today / simulate_today_refresh ─────────────────
+# simulate_today      — returns cached result if within 6 h, else recomputes.
+# simulate_today_refresh — always recomputes and overwrites the cache.
+
+def _resolve_abbr(info: dict) -> str:
+    raw = info.get("abbreviation") or info.get("name", "")
+    return _TEAM_NAME_TO_ABBR.get(raw, raw)
+
+
+def _compute_today(n_simulations: int) -> dict:
+    today = date.today().strftime("%Y-%m-%d")
+    url   = _MLB_SCHEDULE_URL.format(date=today)
     try:
         with urllib.request.urlopen(url, timeout=10) as resp:
             data = json.loads(resp.read())
     except Exception as e:
-        return {"error": f"Failed to fetch MLB schedule: {e}", "date": today, "n_games": 0, "games": []}
+        return {"error": f"Failed to fetch MLB schedule: {e}", "date": today, "n_games": 0, "cached": False, "cached_at": None, "games": []}
 
     raw_games = data.get("dates", [{}])[0].get("games", []) if data.get("dates") else []
-
     _ensure_data()
 
     games_out = []
     for game in raw_games:
-        home_abbr = game["teams"]["home"]["team"].get("abbreviation", "")
-        away_abbr = game["teams"]["away"]["team"].get("abbreviation", "")
-        home_abbr = _MLB_API_TO_ABBR.get(home_abbr, home_abbr)
-        away_abbr = _MLB_API_TO_ABBR.get(away_abbr, away_abbr)
+        home_abbr = _resolve_abbr(game["teams"]["home"]["team"])
+        away_abbr = _resolve_abbr(game["teams"]["away"]["team"])
         status    = game.get("status", {}).get("abstractGameState", "Unknown")
 
         if home_abbr not in MLB_TEAMS or away_abbr not in MLB_TEAMS:
             games_out.append({
-                "game_pk":   game.get("gamePk"),
+                "game_pk":     game.get("gamePk"),
                 "game_status": status,
-                "home_team": home_abbr,
-                "away_team": away_abbr,
-                "error":     "Team abbreviation not found in simulation data",
+                "home_team":   home_abbr,
+                "away_team":   away_abbr,
+                "error":       "Team abbreviation not found in simulation data",
             })
             continue
 
@@ -210,7 +281,94 @@ def simulate_today(n_simulations: int = 10000) -> dict:
         result["game_status"] = status
         games_out.append(result)
 
-    return {"date": today, "n_games": len(games_out), "games": games_out}
+    core = {"date": today, "n_games": len(games_out), "games": games_out}
+    _save_cache(today, n_simulations, core)
+    return {**core, "cached": False, "cached_at": None}
+
+
+def simulate_today(n_simulations: int = 10000) -> dict:
+    today  = date.today().strftime("%Y-%m-%d")
+    cached = _load_cache(today, n_simulations)
+    if cached is not None:
+        entry = _mem_cache.get((today, n_simulations))
+        return {**cached, "cached": True, "cached_at": entry["cached_at"].isoformat() if entry else None}
+    return _compute_today(n_simulations)
+
+
+def simulate_today_refresh(n_simulations: int = 10000) -> dict:
+    today = date.today().strftime("%Y-%m-%d")
+    key   = (today, n_simulations)
+    _mem_cache.pop(key, None)
+    return _compute_today(n_simulations)
+
+
+# ── Endpoint 4: update_season_data ──────────────────────────────────────────
+# Pulls fresh Statcast data for the given season, saves parquet, uploads to HF.
+
+def update_season_data(season_year: int = 2026) -> dict:
+    """
+    Fetches all Statcast data for `season_year` from Baseball Savant via
+    pybaseball, saves a trimmed parquet locally, and uploads it to HF Hub.
+    Clears the distribution cache so the next simulation uses fresh data.
+
+    Returns:
+    {
+      "status":      "ok" | "error",
+      "season_year": int,
+      "rows":        int,
+      "filename":    str,
+      "message":     str
+    }
+    """
+    try:
+        import pybaseball
+        pybaseball.cache.enable()
+    except ImportError:
+        return {"status": "error", "message": "pybaseball is not installed. Add it to requirements.txt."}
+
+    start_dt = f"{season_year}-03-01"
+    end_dt   = date.today().strftime("%Y-%m-%d")
+    filename = f"full_{season_year}_season.parquet"
+    local_path = os.path.join(_DATA_DIR, filename)
+
+    print(f"Fetching Statcast data {start_dt} → {end_dt} (this takes a few minutes)...")
+    try:
+        df = pybaseball.statcast(start_dt=start_dt, end_dt=end_dt, verbose=True)
+    except Exception as e:
+        return {"status": "error", "message": f"pybaseball fetch failed: {e}"}
+
+    keep = ["events", "home_team", "away_team", "inning_topbot", "game_date"]
+    df   = df[keep].copy()
+    df["home_team"] = df["home_team"].str.upper()
+    df["away_team"] = df["away_team"].str.upper()
+
+    os.makedirs(_DATA_DIR, exist_ok=True)
+    df.to_parquet(local_path, index=False)
+    print(f"Saved {len(df):,} rows to {local_path}")
+
+    try:
+        from huggingface_hub import upload_file
+        upload_file(
+            path_or_fileobj=local_path,
+            path_in_repo=filename,
+            repo_id=_HF_REPO_ID,
+            repo_type="dataset",
+            token=os.environ.get("HF_TOKEN"),
+        )
+    except Exception as e:
+        return {"status": "error", "message": f"HF Hub upload failed: {e}", "rows": len(df), "filename": filename}
+
+    global DATA_PATH
+    DATA_PATH = local_path
+    _dist_cache.clear()
+
+    return {
+        "status":      "ok",
+        "season_year": season_year,
+        "rows":        len(df),
+        "filename":    filename,
+        "message":     f"Uploaded {filename} ({len(df):,} rows) to HF Hub and refreshed dist cache.",
+    }
 
 
 # ── Gradio app ────────────────────────────────────────────────────────────────
@@ -245,12 +403,26 @@ with gr.Blocks(title="game-sim-v0 | MLB Game Simulator") as demo:
                     api_name="simulate_json")
 
     with gr.Tab("Today's Games"):
-        gr.Markdown("Fetches today's MLB schedule and simulates every game.")
+        gr.Markdown("Fetches today's MLB schedule and simulates every game. Results cached 6 h in HF Hub.")
         t_n = gr.Slider(minimum=1000, maximum=50000, step=1000, value=10000, label="Simulations per game")
-        t_btn = gr.Button("Simulate Today's Games")
+        with gr.Row():
+            t_btn  = gr.Button("Simulate Today's Games")
+            tr_btn = gr.Button("Force Refresh", variant="secondary")
         t_out = gr.JSON(label="Results")
-        t_btn.click(fn=simulate_today, inputs=[t_n], outputs=t_out,
-                    api_name="simulate_today")
+        t_btn.click(fn=simulate_today,         inputs=[t_n], outputs=t_out, api_name="simulate_today")
+        tr_btn.click(fn=simulate_today_refresh, inputs=[t_n], outputs=t_out, api_name="simulate_today_refresh")
+
+    with gr.Tab("Update Season Data"):
+        gr.Markdown(
+            "Pulls fresh Statcast data from Baseball Savant via **pybaseball**, "
+            "saves a trimmed parquet, and uploads it to HF Hub. "
+            "⚠️ Takes several minutes for a full season."
+        )
+        u_year = gr.Number(value=2026, label="Season year", precision=0)
+        u_btn  = gr.Button("Fetch & Upload")
+        u_out  = gr.JSON(label="Status")
+        u_btn.click(fn=update_season_data, inputs=[u_year], outputs=u_out,
+                    api_name="update_season_data")
 
     gr.Examples(
         examples=[["NYY", "LAD", 10000], ["BOS", "HOU", 5000], ["ATL", "PHI", 10000]],

requirements.txt

@@ -3,3 +3,4 @@ pyarrow
 matplotlib
 seaborn
 huggingface_hub
+pybaseball