Remove Fangraphs starter fallback in favor of MLB and Odds API

data/mlb_starters.py

@@ -32,6 +32,21 @@ def _normalize_team(name: str) -> str:
     return text
 
 
+def _normalize_person(name: str) -> str:
+    text = str(name or "").strip().lower()
+    text = unicodedata.normalize("NFKD", text)
+    text = "".join(ch for ch in text if not unicodedata.combining(ch))
+    text = re.sub(r"[^a-z0-9 ]", "", text)
+    text = re.sub(r"\s+", " ", text).strip()
+    return text
+
+
+def _names_match(left: str, right: str) -> bool:
+    left_norm = _normalize_person(left)
+    right_norm = _normalize_person(right)
+    return bool(left_norm and right_norm and left_norm == right_norm)
+
+
 def fetch_probable_starters_for_props() -> dict[tuple[str, str], dict[str, str | None]]:
     """
     Fetch probable starters for all MLB games in the next 7 days.
@@ -110,55 +125,199 @@ def fetch_probable_starters_for_props() -> dict[tuple[str, str], dict[str, str |
     return result
 
 
-def _first_rotation_pitcher(team_payload: dict[str, Any] | None) -> str | None:
-    payload = dict(team_payload or {})
-    rotation = payload.get("rotation") or []
-    if not rotation:
-        return None
-    first = rotation[0]
-    if isinstance(first, dict):
-        pitcher_name = str(first.get("pitcher_name") or first.get("player_name") or "").strip()
-        return pitcher_name or None
-    pitcher_name = str(first or "").strip()
-    return pitcher_name or None
-
+def _infer_pitcher_team_from_rows(
+    pitcher_name: str,
+    pitcher_statcast_df: pd.DataFrame | None,
+    away_team: str,
+    home_team: str,
+) -> str:
+    if (
+        not pitcher_name
+        or pitcher_statcast_df is None
+        or pitcher_statcast_df.empty
+        or "player_name" not in pitcher_statcast_df.columns
+    ):
+        return ""
+
+    target = _normalize_person(pitcher_name)
+    rows = pitcher_statcast_df[
+        pitcher_statcast_df["player_name"].astype(str).map(_normalize_person) == target
+    ].copy()
+    if rows.empty:
+        return ""
 
-def build_fangraphs_starter_fallback_map(
-    matchups: list[tuple[str, str]] | tuple[tuple[str, str], ...],
-    projected_lineups: dict[str, dict[str, Any]] | None,
+    away_norm = _normalize_team(away_team)
+    home_norm = _normalize_team(home_team)
+    team_candidates: list[str] = []
+
+    if {"inning_topbot", "home_team", "away_team"}.issubset(rows.columns):
+        inning_half = rows["inning_topbot"].fillna("").astype(str).str.lower()
+        top_mask = inning_half.str.contains("top")
+        bottom_mask = inning_half.str.contains("bot|bottom")
+        if top_mask.any():
+            team_candidates.extend(
+                rows.loc[top_mask, "home_team"].dropna().astype(str).tolist()
+            )
+        if bottom_mask.any():
+            team_candidates.extend(
+                rows.loc[bottom_mask, "away_team"].dropna().astype(str).tolist()
+            )
+
+    for col in ("team", "pitcher_team", "team_name"):
+        if col in rows.columns:
+            team_candidates.extend(rows[col].dropna().astype(str).tolist())
+
+    normalized = [_normalize_team(value) for value in team_candidates if str(value).strip()]
+    if not normalized:
+        return ""
+    mode = pd.Series(normalized).mode()
+    inferred = str(mode.iloc[0]).strip() if not mode.empty else ""
+    if inferred == away_norm:
+        return away_team
+    if inferred == home_norm:
+        return home_team
+    return ""
+
+
+def build_oddsapi_starter_fallback_map(
+    props_feed: pd.DataFrame | None,
+    primary_starters: dict[tuple[str, str], dict[str, Any]] | None = None,
+    pitcher_statcast_df: pd.DataFrame | None = None,
 ) -> dict[tuple[str, str], dict[str, str | None]]:
+    if props_feed is None or props_feed.empty:
+        return {}
+
+    working = props_feed.copy()
+    market_series = working.get("market_family", working.get("market", pd.Series(dtype="object", index=working.index)))
+    scope_series = working.get("selection_scope", pd.Series(dtype="object", index=working.index))
+    working = working[
+        market_series.fillna("").astype(str).str.strip().str.lower().eq("k")
+        & scope_series.fillna("").astype(str).str.strip().str.lower().eq("pitcher")
+    ].copy()
+    if working.empty:
+        return {}
+
     results: dict[tuple[str, str], dict[str, str | None]] = {}
-    for away_team, home_team in list(matchups or []):
-        away_raw = str(away_team or "").strip()
-        home_raw = str(home_team or "").strip()
-        away_norm = _normalize_team(away_raw)
-        home_norm = _normalize_team(home_raw)
+    primary = dict(primary_starters or {})
+    group_cols = [col for col in ("event_id", "away_team", "home_team") if col in working.columns]
+    if len(group_cols) < 3:
+        return {}
+
+    for _, event_df in working.groupby(group_cols, dropna=False):
+        away_team = str(event_df["away_team"].iloc[0] or "").strip()
+        home_team = str(event_df["home_team"].iloc[0] or "").strip()
+        away_norm = _normalize_team(away_team)
+        home_norm = _normalize_team(home_team)
         if not away_norm or not home_norm:
             continue
 
-        away_payload = (projected_lineups or {}).get(away_norm) or {}
-        home_payload = (projected_lineups or {}).get(home_norm) or {}
-        away_pitcher = _first_rotation_pitcher(away_payload)
-        home_pitcher = _first_rotation_pitcher(home_payload)
+        primary_payload = dict(primary.get((away_norm, home_norm)) or {})
+        away_pitcher = str(primary_payload.get("away_pitcher") or "").strip() or None
+        home_pitcher = str(primary_payload.get("home_pitcher") or "").strip() or None
+        away_source = str(primary_payload.get("away_pitcher_source") or "").strip() or "unresolved"
+        home_source = str(primary_payload.get("home_pitcher_source") or "").strip() or "unresolved"
+
+        candidate_names = [
+            str(name).strip()
+            for name in event_df.get("player_name_raw", pd.Series(dtype="object")).dropna().astype(str).tolist()
+            if str(name).strip()
+        ]
+        unique_candidates: list[str] = []
+        for candidate in candidate_names:
+            if not any(_names_match(candidate, existing) for existing in unique_candidates):
+                unique_candidates.append(candidate)
+
+        candidate_team_map: dict[str, str] = {}
+        for candidate in unique_candidates:
+            if away_pitcher and _names_match(candidate, away_pitcher):
+                candidate_team_map[candidate] = away_team
+                continue
+            if home_pitcher and _names_match(candidate, home_pitcher):
+                candidate_team_map[candidate] = home_team
+                continue
+            inferred_team = _infer_pitcher_team_from_rows(
+                pitcher_name=candidate,
+                pitcher_statcast_df=pitcher_statcast_df,
+                away_team=away_team,
+                home_team=home_team,
+            )
+            if inferred_team:
+                candidate_team_map[candidate] = inferred_team
+
+        blank_sides = int(not away_pitcher) + int(not home_pitcher)
+        assigned_from_odds = 0
+
+        if not away_pitcher:
+            for candidate, team_name in candidate_team_map.items():
+                if _normalize_team(team_name) == away_norm:
+                    away_pitcher = candidate
+                    assigned_from_odds += 1
+                    break
+        if not home_pitcher:
+            for candidate, team_name in candidate_team_map.items():
+                if _normalize_team(team_name) == home_norm and not _names_match(candidate, away_pitcher or ""):
+                    home_pitcher = candidate
+                    assigned_from_odds += 1
+                    break
+
+        unresolved_candidates = [
+            candidate
+            for candidate in unique_candidates
+            if not _names_match(candidate, away_pitcher or "") and not _names_match(candidate, home_pitcher or "")
+        ]
+        if len(unresolved_candidates) == 1:
+            if not away_pitcher and home_pitcher:
+                away_pitcher = unresolved_candidates[0]
+                assigned_from_odds += 1
+            elif not home_pitcher and away_pitcher:
+                home_pitcher = unresolved_candidates[0]
+                assigned_from_odds += 1
+
+        odds_source = "unresolved"
+        if assigned_from_odds >= 2 or (blank_sides >= 2 and away_pitcher and home_pitcher):
+            odds_source = "oddsapi_pitcher_strikeouts_two_candidate_match"
+        elif assigned_from_odds == 1:
+            odds_source = "oddsapi_pitcher_strikeouts_single_candidate_match"
+        elif len(unique_candidates) > 2 or (len(unique_candidates) >= 2 and not away_pitcher and not home_pitcher):
+            odds_source = "oddsapi_pitcher_strikeouts_ambiguous"
+
+        if away_source == "unresolved" and away_pitcher:
+            away_source = odds_source if odds_source != "unresolved" else "oddsapi_pitcher_strikeouts_single_candidate_match"
+        if home_source == "unresolved" and home_pitcher:
+            home_source = odds_source if odds_source != "unresolved" else "oddsapi_pitcher_strikeouts_single_candidate_match"
+
+        if away_source.startswith("statsapi_") or home_source.startswith("statsapi_"):
+            starter_cache_source = (
+                "statsapi_plus_oddsapi_fallback"
+                if (away_source.startswith("oddsapi_") or home_source.startswith("oddsapi_"))
+                else "statsapi_probable_pitcher"
+            )
+        elif away_source.startswith("oddsapi_") or home_source.startswith("oddsapi_"):
+            starter_cache_source = odds_source if odds_source != "unresolved" else "oddsapi_pitcher_strikeouts_single_candidate_match"
+        else:
+            starter_cache_source = odds_source
+
         results[(away_norm, home_norm)] = {
-            "away_team_raw": away_raw,
-            "home_team_raw": home_raw,
+            "away_team_raw": away_team,
+            "home_team_raw": home_team,
             "away_pitcher": away_pitcher,
             "home_pitcher": home_pitcher,
-            "away_pitcher_source": "fangraphs_rotation_fallback" if away_pitcher else "unresolved",
-            "home_pitcher_source": "fangraphs_rotation_fallback" if home_pitcher else "unresolved",
-            "starter_cache_source": "fangraphs_rotation_fallback",
-            "fallback_used": bool(away_pitcher or home_pitcher),
+            "away_pitcher_source": away_source if away_pitcher else "unresolved",
+            "home_pitcher_source": home_source if home_pitcher else "unresolved",
+            "starter_cache_source": starter_cache_source if (away_pitcher or home_pitcher or odds_source != "unresolved") else "unresolved",
+            "fallback_used": bool(
+                str(away_source).startswith("oddsapi_") or str(home_source).startswith("oddsapi_")
+            ),
         }
     return results
 
 
-def merge_probable_starters_with_fallback(
+def merge_probable_starters_with_odds_fallback(
     primary_starters: dict[tuple[str, str], dict[str, Any]] | None,
-    fallback_starters: dict[tuple[str, str], dict[str, Any]] | None,
+    odds_fallback_starters: dict[tuple[str, str], dict[str, Any]] | None,
 ) -> dict[tuple[str, str], dict[str, str | None]]:
     primary = dict(primary_starters or {})
-    fallback = dict(fallback_starters or {})
+    fallback = dict(odds_fallback_starters or {})
     merged: dict[tuple[str, str], dict[str, str | None]] = {}
     for key in sorted(set(primary.keys()) | set(fallback.keys())):
         primary_payload = dict(primary.get(key) or {})
@@ -175,13 +334,16 @@ def merge_probable_starters_with_fallback(
             or str(fallback_payload.get("home_pitcher_source") or "").strip()
             or "unresolved"
         )
-        fallback_used = away_source.startswith("fangraphs_") or home_source.startswith("fangraphs_")
+        fallback_used = away_source.startswith("oddsapi_") or home_source.startswith("oddsapi_")
         if away_source.startswith("statsapi_") or home_source.startswith("statsapi_"):
-            starter_cache_source = "statsapi_probable_pitcher" if not fallback_used else "statsapi_plus_fangraphs_fallback"
+            starter_cache_source = "statsapi_probable_pitcher" if not fallback_used else "statsapi_plus_oddsapi_fallback"
         elif fallback_used:
-            starter_cache_source = "fangraphs_rotation_fallback"
+            starter_cache_source = (
+                str(fallback_payload.get("starter_cache_source") or "").strip()
+                or "oddsapi_pitcher_strikeouts_single_candidate_match"
+            )
         else:
-            starter_cache_source = "unresolved"
+            starter_cache_source = str(fallback_payload.get("starter_cache_source") or "").strip() or "unresolved"
         merged[key] = {
             "away_team_raw": str(primary_payload.get("away_team_raw") or fallback_payload.get("away_team_raw") or "").strip(),
             "home_team_raw": str(primary_payload.get("home_team_raw") or fallback_payload.get("home_team_raw") or "").strip(),

database/db.py

@@ -631,24 +631,6 @@ def initialize_schema(conn) -> None:
         """
     ))
 
-    conn.execute(text(
-        """
-        CREATE TABLE IF NOT EXISTS cached_fangraphs_starters (
-            fetched_at       TEXT,
-            away_team_norm   TEXT,
-            home_team_norm   TEXT,
-            away_team_raw    TEXT,
-            home_team_raw    TEXT,
-            away_pitcher     TEXT,
-            home_pitcher     TEXT,
-            away_pitcher_source TEXT,
-            home_pitcher_source TEXT,
-            starter_cache_source TEXT,
-            fallback_used    BOOLEAN
-        )
-        """
-    ))
-
     conn.execute(text(
         """
         CREATE TABLE IF NOT EXISTS cached_projected_lineups (
@@ -867,10 +849,6 @@ def initialize_schema(conn) -> None:
         "CREATE INDEX IF NOT EXISTS idx_cached_probable_starters_matchup "
         "ON cached_probable_starters (away_team_norm, home_team_norm)"
     ))
-    conn.execute(text(
-        "CREATE INDEX IF NOT EXISTS idx_cached_fangraphs_starters_matchup "
-        "ON cached_fangraphs_starters (away_team_norm, home_team_norm)"
-    ))
     conn.execute(text(
         "CREATE INDEX IF NOT EXISTS idx_cached_projected_lineups_team "
         "ON cached_projected_lineups (team_name_norm)"
@@ -1151,97 +1129,6 @@ def read_cached_probable_starters_meta(conn) -> pd.DataFrame:
     )
 
 
-def replace_cached_fangraphs_starters(
-    conn,
-    starters_map: Mapping[tuple[str, str], Mapping[str, Any]] | None,
-) -> None:
-    rows: list[dict[str, Any]] = []
-    fetched_at = utc_now_iso()
-    for key, payload in (starters_map or {}).items():
-        if not isinstance(key, tuple) or len(key) != 2:
-            continue
-        away_norm, home_norm = key
-        payload = dict(payload or {})
-        rows.append(
-            {
-                "fetched_at": fetched_at,
-                "away_team_norm": str(away_norm or "").strip(),
-                "home_team_norm": str(home_norm or "").strip(),
-                "away_team_raw": str(payload.get("away_team_raw") or "").strip(),
-                "home_team_raw": str(payload.get("home_team_raw") or "").strip(),
-                "away_pitcher": str(payload.get("away_pitcher") or "").strip() or None,
-                "home_pitcher": str(payload.get("home_pitcher") or "").strip() or None,
-                "away_pitcher_source": str(payload.get("away_pitcher_source") or "").strip() or None,
-                "home_pitcher_source": str(payload.get("home_pitcher_source") or "").strip() or None,
-                "starter_cache_source": str(payload.get("starter_cache_source") or "").strip() or None,
-                "fallback_used": bool(payload.get("fallback_used")),
-            }
-        )
-    replace_table_contents(conn, "cached_fangraphs_starters", pd.DataFrame(rows))
-
-
-def read_cached_fangraphs_starters(
-    conn,
-    matchups_norm: Iterable[tuple[str, str]] | None = None,
-) -> dict[tuple[str, str], dict[str, str | None]]:
-    matchups = [
-        (str(away or "").strip(), str(home or "").strip())
-        for away, home in (matchups_norm or [])
-        if str(away or "").strip() and str(home or "").strip()
-    ]
-    if matchups:
-        clauses = []
-        params: dict[str, Any] = {}
-        for idx, (away, home) in enumerate(matchups):
-            away_key = f"away_{idx}"
-            home_key = f"home_{idx}"
-            clauses.append(f"(away_team_norm = :{away_key} AND home_team_norm = :{home_key})")
-            params[away_key] = away
-            params[home_key] = home
-        df = pd.read_sql(
-            text(f"SELECT * FROM cached_fangraphs_starters WHERE {' OR '.join(clauses)}"),
-            conn,
-            params=params,
-        )
-    else:
-        df = pd.read_sql(text("SELECT * FROM cached_fangraphs_starters"), conn)
-    if df.empty:
-        return {}
-    out: dict[tuple[str, str], dict[str, str | None]] = {}
-    for _, row in df.iterrows():
-        key = (
-            str(row.get("away_team_norm") or "").strip(),
-            str(row.get("home_team_norm") or "").strip(),
-        )
-        if not key[0] or not key[1]:
-            continue
-        out[key] = {
-            "away_team_raw": str(row.get("away_team_raw") or "").strip(),
-            "home_team_raw": str(row.get("home_team_raw") or "").strip(),
-            "away_pitcher": str(row.get("away_pitcher") or "").strip() or None,
-            "home_pitcher": str(row.get("home_pitcher") or "").strip() or None,
-            "away_pitcher_source": str(row.get("away_pitcher_source") or "").strip() or None,
-            "home_pitcher_source": str(row.get("home_pitcher_source") or "").strip() or None,
-            "starter_cache_source": str(row.get("starter_cache_source") or "").strip() or None,
-            "fallback_used": bool(row.get("fallback_used")),
-        }
-    return out
-
-
-def read_cached_fangraphs_starters_meta(conn) -> pd.DataFrame:
-    return pd.read_sql(
-        text(
-            """
-            SELECT fetched_at, COUNT(*) AS matchup_count
-            FROM cached_fangraphs_starters
-            GROUP BY fetched_at
-            ORDER BY fetched_at DESC
-            """
-        ),
-        conn,
-    )
-
-
 def replace_cached_projected_lineups(
     conn,
     projected_lineups: Mapping[str, Mapping[str, Any]] | None,

tests/test_mlb_starters.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+import os
+import sys
+import unittest
+
+import pandas as pd
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
+
+from data.mlb_starters import (
+    build_oddsapi_starter_fallback_map,
+    merge_probable_starters_with_odds_fallback,
+)
+
+
+class TestMlbStarters(unittest.TestCase):
+    def test_oddsapi_fallback_can_fill_tba_matchup_from_pitcher_team_inference(self) -> None:
+        props_feed = pd.DataFrame(
+            [
+                {
+                    "event_id": "event-1",
+                    "away_team": "New York Yankees",
+                    "home_team": "San Francisco Giants",
+                    "market_family": "k",
+                    "selection_scope": "pitcher",
+                    "player_name_raw": "Max Fried",
+                },
+                {
+                    "event_id": "event-1",
+                    "away_team": "New York Yankees",
+                    "home_team": "San Francisco Giants",
+                    "market_family": "k",
+                    "selection_scope": "pitcher",
+                    "player_name_raw": "Logan Webb",
+                },
+            ]
+        )
+        pitcher_statcast_df = pd.DataFrame(
+            [
+                {
+                    "player_name": "Max Fried",
+                    "inning_topbot": "Bottom",
+                    "away_team": "New York Yankees",
+                    "home_team": "San Francisco Giants",
+                },
+                {
+                    "player_name": "Logan Webb",
+                    "inning_topbot": "Top",
+                    "away_team": "New York Yankees",
+                    "home_team": "San Francisco Giants",
+                },
+            ]
+        )
+        primary = {
+            ("new york yankees", "san francisco giants"): {
+                "away_team_raw": "New York Yankees",
+                "home_team_raw": "San Francisco Giants",
+                "away_pitcher": None,
+                "home_pitcher": None,
+                "away_pitcher_source": "unresolved",
+                "home_pitcher_source": "unresolved",
+                "starter_cache_source": "statsapi_probable_pitcher",
+                "fallback_used": False,
+            }
+        }
+
+        fallback = build_oddsapi_starter_fallback_map(
+            props_feed=props_feed,
+            primary_starters=primary,
+            pitcher_statcast_df=pitcher_statcast_df,
+        )
+        merged = merge_probable_starters_with_odds_fallback(primary, fallback)
+        row = merged[("new york yankees", "san francisco giants")]
+
+        self.assertEqual(row["away_pitcher"], "Max Fried")
+        self.assertEqual(row["home_pitcher"], "Logan Webb")
+        self.assertEqual(row["away_pitcher_source"], "oddsapi_pitcher_strikeouts_two_candidate_match")
+        self.assertEqual(row["home_pitcher_source"], "oddsapi_pitcher_strikeouts_two_candidate_match")
+        self.assertEqual(row["starter_cache_source"], "statsapi_plus_oddsapi_fallback")
+        self.assertTrue(bool(row["fallback_used"]))
+
+    def test_oddsapi_fallback_does_not_override_existing_mlb_side(self) -> None:
+        props_feed = pd.DataFrame(
+            [
+                {
+                    "event_id": "event-2",
+                    "away_team": "Cleveland Guardians",
+                    "home_team": "Detroit Tigers",
+                    "market_family": "k",
+                    "selection_scope": "pitcher",
+                    "player_name_raw": "Tanner Bibee",
+                },
+                {
+                    "event_id": "event-2",
+                    "away_team": "Cleveland Guardians",
+                    "home_team": "Detroit Tigers",
+                    "market_family": "k",
+                    "selection_scope": "pitcher",
+                    "player_name_raw": "Tarik Skubal",
+                },
+            ]
+        )
+        primary = {
+            ("cleveland guardians", "detroit tigers"): {
+                "away_team_raw": "Cleveland Guardians",
+                "home_team_raw": "Detroit Tigers",
+                "away_pitcher": "Tanner Bibee",
+                "home_pitcher": None,
+                "away_pitcher_source": "statsapi_probable_pitcher",
+                "home_pitcher_source": "unresolved",
+                "starter_cache_source": "statsapi_probable_pitcher",
+                "fallback_used": False,
+            }
+        }
+
+        fallback = build_oddsapi_starter_fallback_map(
+            props_feed=props_feed,
+            primary_starters=primary,
+            pitcher_statcast_df=None,
+        )
+        merged = merge_probable_starters_with_odds_fallback(primary, fallback)
+        row = merged[("cleveland guardians", "detroit tigers")]
+
+        self.assertEqual(row["away_pitcher"], "Tanner Bibee")
+        self.assertEqual(row["away_pitcher_source"], "statsapi_probable_pitcher")
+        self.assertEqual(row["home_pitcher"], "Tarik Skubal")
+        self.assertEqual(row["home_pitcher_source"], "oddsapi_pitcher_strikeouts_single_candidate_match")
+        self.assertEqual(row["starter_cache_source"], "statsapi_plus_oddsapi_fallback")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_props_mapper.py

@@ -209,9 +209,9 @@ class TestPropsMapper(unittest.TestCase):
             ("away team", "home team"): {
                 "home_pitcher": "Home Starter",
                 "away_pitcher": "Away Starter",
-                "home_pitcher_source": "fangraphs_rotation_fallback",
+                "home_pitcher_source": "oddsapi_pitcher_strikeouts_two_candidate_match",
                 "away_pitcher_source": "statsapi_probable_pitcher",
-                "starter_cache_source": "statsapi_plus_fangraphs_fallback",
+                "starter_cache_source": "statsapi_plus_oddsapi_fallback",
                 "fallback_used": True,
             }
         }
@@ -280,9 +280,9 @@ class TestPropsMapper(unittest.TestCase):
         self.assertEqual(result.iloc[0]["projected_home_pitcher"], "Home Starter")
         self.assertEqual(result.iloc[0]["projected_away_pitcher"], "Away Starter")
         self.assertTrue(bool(result.iloc[0]["projected_starter_available"]))
-        self.assertEqual(result.iloc[0]["projected_home_pitcher_source"], "fangraphs_rotation_fallback")
+        self.assertEqual(result.iloc[0]["projected_home_pitcher_source"], "oddsapi_pitcher_strikeouts_two_candidate_match")
         self.assertEqual(result.iloc[0]["projected_away_pitcher_source"], "statsapi_probable_pitcher")
-        self.assertEqual(result.iloc[0]["starter_cache_source"], "statsapi_plus_fangraphs_fallback")
+        self.assertEqual(result.iloc[0]["starter_cache_source"], "statsapi_plus_oddsapi_fallback")
         self.assertTrue(bool(result.iloc[0]["fallback_used"]))
         self.assertEqual(result.iloc[0]["projected_starter_match_status"], "matched_projected_home")
         self.assertEqual(mocked_build.call_args.kwargs["pitcher_name"], "Home Starter")

visualization/debug_page.py

@@ -1424,9 +1424,7 @@ def render_debug(
                                         "starter_cache_source": starter_debug.get("starter_cache_source"),
                                         "starter_cache_age_seconds": starter_debug.get("starter_cache_age_seconds"),
                                         "starter_refresh_mode": starter_debug.get("starter_refresh_mode"),
-                                        "fangraphs_starter_cache_age_seconds": starter_debug.get("fangraphs_starter_cache_age_seconds"),
-                                        "fangraphs_starter_refresh_mode": starter_debug.get("fangraphs_starter_refresh_mode"),
-                                        "fallback_used_matchup_count": starter_debug.get("fallback_used_matchup_count"),
+                                        "oddsapi_fallback_used_matchup_count": starter_debug.get("oddsapi_fallback_used_matchup_count"),
                                         "lineup_cache_age_seconds": starter_debug.get("lineup_cache_age_seconds"),
                                         "lineup_refresh_mode": starter_debug.get("lineup_refresh_mode"),
                                     }

visualization/props_page.py

@@ -30,19 +30,15 @@ from database.db import (
     ensure_upcoming_hr_props_table,
     get_connection,
     insert_upcoming_hr_props,
-    read_cached_fangraphs_starters,
-    read_cached_fangraphs_starters_meta,
     read_cached_projected_lineups,
     read_cached_projected_lineups_meta,
-    replace_cached_fangraphs_starters,
     replace_cached_projected_lineups,
 )
 from utils.helpers import utc_now_iso
 from data.mlb_starters import (
-    _normalize_team as _normalize_starter_team,
-    build_fangraphs_starter_fallback_map,
+    build_oddsapi_starter_fallback_map,
     lookup_pitchers_for_game,
-    merge_probable_starters_with_fallback,
+    merge_probable_starters_with_odds_fallback,
 )
 
 _PROPS_ASYNC_LOCK = threading.Lock()
@@ -589,6 +585,25 @@ def _extract_slate_matchups(filtered_raw: pd.DataFrame) -> tuple[tuple[str, str]
     return tuple(sorted(matchups))
 
 
+def _extract_oddsapi_pitcher_names(raw: pd.DataFrame | None) -> tuple[str, ...]:
+    if raw is None or raw.empty:
+        return tuple()
+    market_series = raw.get("market_family", raw.get("market", pd.Series(dtype="object", index=raw.index)))
+    scope_series = raw.get("selection_scope", pd.Series(dtype="object", index=raw.index))
+    k_rows = raw[
+        market_series.fillna("").astype(str).str.strip().str.lower().eq("k")
+        & scope_series.fillna("").astype(str).str.strip().str.lower().eq("pitcher")
+    ].copy()
+    if k_rows.empty:
+        return tuple()
+    names = {
+        str(name).strip()
+        for name in k_rows.get("player_name_raw", pd.Series(dtype="object")).dropna().astype(str).tolist()
+        if str(name).strip()
+    }
+    return tuple(sorted(names))
+
+
 def _filter_probable_starters_to_slate(
     probable_starters: dict | None,
     slate_teams: tuple[str, ...],
@@ -685,6 +700,21 @@ def _load_props_market_baseline_bundle(
     }
 
 
+@st.cache_data(ttl=60 * 10, show_spinner=False)
+def _load_props_starter_pitcher_identity_bundle(
+    pitcher_names: tuple[str, ...],
+) -> pd.DataFrame:
+    if not pitcher_names:
+        return pd.DataFrame()
+    bundle = load_or_build_shared_baseline_bundle_complete_for_request(
+        batter_names=tuple(),
+        pitcher_names=pitcher_names,
+        max_age_seconds=60 * 60,
+        persist_runtime_refresh=False,
+    )
+    return bundle.get("blended_pitcher_df", pd.DataFrame())
+
+
 def _build_market_modeling_payload(
     *,
     filtered_raw: pd.DataFrame,
@@ -985,110 +1015,39 @@ def _refresh_projected_lineups_cache(teams: list[str]) -> None:
     _persist_projected_lineups_cache(payload)
 
 
-def _persist_fangraphs_starter_fallback_cache(payload: dict[tuple[str, str], dict[str, Any]]) -> None:
-    try:
-        conn = get_connection()
-        try:
-            replace_cached_fangraphs_starters(conn, payload)
-        finally:
-            conn.close()
-    except Exception:
-        pass
-
-
-def _refresh_fangraphs_starter_fallback_cache(matchups: list[tuple[str, str]]) -> None:
-    if not matchups:
-        return
-    teams = sorted({team for matchup in matchups for team in matchup if str(team or "").strip()})
-    projected_lineups = _load_projected_lineups_for_props(tuple(teams))
-    payload = build_fangraphs_starter_fallback_map(matchups, projected_lineups)
-    _persist_fangraphs_starter_fallback_cache(payload)
-
-
-def _load_fangraphs_starter_fallback_for_props(
-    matchups: tuple[tuple[str, str], ...],
-    *,
-    allow_sync_fetch: bool,
-) -> tuple[dict[tuple[str, str], dict[str, Any]], float | None, str]:
-    if not matchups:
-        return ({}, None, "starter_fallback_unneeded")
-    normalized_matchups = tuple(
-        sorted(
-            {
-                (_normalize_starter_team(away), _normalize_starter_team(home))
-                for away, home in matchups
-                if str(away or "").strip() and str(home or "").strip()
-            }
-        )
-    )
-    conn = get_connection()
-    try:
-        cached_meta = read_cached_fangraphs_starters_meta(conn)
-        cached = read_cached_fangraphs_starters(conn, matchups_norm=normalized_matchups)
-        latest = pd.to_datetime(cached_meta.iloc[0]["fetched_at"], errors="coerce", utc=True) if not cached_meta.empty else pd.NaT
-        age_seconds = None
-        if pd.notna(latest):
-            age_seconds = float((pd.Timestamp.now(tz="UTC") - latest).total_seconds())
-        if cached:
-            if age_seconds is not None and age_seconds <= float(60 * 60 * 6):
-                return (cached, age_seconds, "starter_fallback_cache_fresh")
-            _queue_props_async_refresh(
-                f"fangraphs_starters:{'|'.join(f'{away}@{home}' for away, home in normalized_matchups)}",
-                lambda: _refresh_fangraphs_starter_fallback_cache(list(matchups)),
-            )
-            return (cached, age_seconds, "starter_fallback_cache_stale_async_refresh")
-    finally:
-        try:
-            conn.close()
-        except Exception:
-            pass
-
-    if not allow_sync_fetch:
-        _queue_props_async_refresh(
-            f"fangraphs_starters:{'|'.join(f'{away}@{home}' for away, home in normalized_matchups)}",
-            lambda: _refresh_fangraphs_starter_fallback_cache(list(matchups)),
-        )
-        return ({}, None, "starter_fallback_cache_missing_async_refresh")
-
-    teams = sorted({team for matchup in matchups for team in matchup if str(team or "").strip()})
-    projected_lineups = _load_projected_lineups_for_props(tuple(teams))
-    payload = build_fangraphs_starter_fallback_map(matchups, projected_lineups)
-    _persist_fangraphs_starter_fallback_cache(payload)
-    return (payload, 0.0, "starter_fallback_sync_seed")
-
-
 def _load_props_starter_bundle(
     raw: pd.DataFrame,
     probable_starters: dict | None,
+    pitcher_statcast_df: pd.DataFrame | None = None,
 ) -> dict[str, Any]:
     slate_matchups = _extract_slate_matchups(raw)
     primary_starters = dict(probable_starters or {})
-    usable_primary_games = 0
-    missing_primary_games: list[tuple[str, str]] = []
-    for away_team, home_team in slate_matchups:
-        matchup_payload = lookup_pitchers_for_game(
-            away_team=away_team,
-            home_team=home_team,
-            starters_map=primary_starters,
-        )
-        if str(matchup_payload.get("away_pitcher") or "").strip() or str(matchup_payload.get("home_pitcher") or "").strip():
-            usable_primary_games += 1
-        else:
-            missing_primary_games.append((away_team, home_team))
-
-    fallback_map, fallback_age_seconds, fallback_refresh_mode = _load_fangraphs_starter_fallback_for_props(
-        tuple(missing_primary_games),
-        allow_sync_fetch=usable_primary_games == 0 and bool(missing_primary_games),
+    fallback_map = build_oddsapi_starter_fallback_map(
+        props_feed=raw,
+        primary_starters=primary_starters,
+        pitcher_statcast_df=pitcher_statcast_df,
     )
-    merged = merge_probable_starters_with_fallback(primary_starters, fallback_map)
+    merged = merge_probable_starters_with_odds_fallback(primary_starters, fallback_map)
+    cache_sources = {
+        str(payload.get("starter_cache_source") or "").strip()
+        for payload in merged.values()
+        if str(payload.get("starter_cache_source") or "").strip()
+    }
+    if "statsapi_plus_oddsapi_fallback" in cache_sources:
+        aggregate_source = "statsapi_plus_oddsapi_fallback"
+    elif any(source.startswith("oddsapi_") for source in cache_sources):
+        aggregate_source = "oddsapi_pitcher_strikeouts_fallback"
+    elif "statsapi_probable_pitcher" in cache_sources:
+        aggregate_source = "statsapi_probable_pitcher"
+    else:
+        aggregate_source = "unresolved"
     return {
         "matchups": slate_matchups,
         "primary_starters": primary_starters,
-        "fallback_starters": fallback_map,
+        "oddsapi_fallback_starters": fallback_map,
         "merged_starters": merged,
-        "fallback_age_seconds": fallback_age_seconds,
-        "fallback_refresh_mode": fallback_refresh_mode,
-        "fallback_used_matchup_count": sum(
+        "starter_cache_source": aggregate_source,
+        "oddsapi_fallback_used_matchup_count": sum(
             1 for payload in merged.values() if bool(payload.get("fallback_used"))
         ),
     }
@@ -2108,16 +2067,17 @@ def render_props(
     starter_bundle = _load_props_starter_bundle(
         raw=raw,
         probable_starters=probable_starters,
+        pitcher_statcast_df=(
+            pitcher_statcast_df
+            if pitcher_statcast_df is not None and not pitcher_statcast_df.empty
+            else _load_props_starter_pitcher_identity_bundle(_extract_oddsapi_pitcher_names(raw))
+        ),
     )
     st.session_state["props_starter_debug"] = {
-        "starter_cache_source": "statsapi_plus_fangraphs_fallback"
-        if int(starter_bundle.get("fallback_used_matchup_count") or 0) > 0
-        else "statsapi_probable_pitcher",
+        "starter_cache_source": starter_bundle.get("starter_cache_source") or "unresolved",
         "starter_cache_age_seconds": st.session_state.get("probable_starters_cache_age_seconds"),
         "starter_refresh_mode": st.session_state.get("probable_starters_refresh_mode"),
-        "fangraphs_starter_cache_age_seconds": starter_bundle.get("fallback_age_seconds"),
-        "fangraphs_starter_refresh_mode": starter_bundle.get("fallback_refresh_mode"),
-        "fallback_used_matchup_count": int(starter_bundle.get("fallback_used_matchup_count") or 0),
+        "oddsapi_fallback_used_matchup_count": int(starter_bundle.get("oddsapi_fallback_used_matchup_count") or 0),
         "lineup_cache_age_seconds": lineup_cache_age_seconds,
         "lineup_refresh_mode": lineup_refresh_mode,
     }