Batch 14: HR props odds-injection layer + Props page

- Add fetch_all_upcoming_hr_props() bulk fetch (single API call, no game filter)
- Add Caesars (williamhill_us) to provider supported books; document Pinnacle path
- Add analytics/props_mapper.py: get_player_hr_prob() with source tracking
(internal_model_baseline via compute_batter_baseline, fallback to unavailable);
modular map_hr_props_to_model() with injectable prob_fn
- Add upcoming_hr_props table to durable DuckDB schema
- Add visualization/props_page.py: Props page with all-book + best-line views,
sportsbook filter, min-edge slider, edge-sorted table, DB logging
- Replace Players tab with Props tab in app navigation

Deferred: Batch 13, Batch 12.5 follow-up, Pinnacle integration, CLV, bankroll sizing

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

analytics/props_mapper.py

@@ -0,0 +1,151 @@
+"""
+analytics/props_mapper.py
+
+Batch 14: Maps sportsbook HR prop rows to internal model HR probabilities
+and computes edge.
+
+Model HR probability resolution order (pre-game, no live lineup context):
+  1. internal_model_baseline — compute_batter_baseline() using batter statcast
+     features (EV90, barrel rate, hard hit rate, xwOBA, launch angle).
+     Preferred source when plate_appearances > 0.
+  2. unavailable — insufficient statcast coverage for this player.
+
+Note: XGBoost HR model (xgb_shadow.py) requires anchor probs from the live
+simulator and cannot be used pre-game. It remains the source for Dashboard
+live-game recommendations only.
+
+The prob_fn parameter in map_hr_props_to_model() is injectable so the
+probability source can be swapped later without touching odds ingestion or
+the Props page.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable
+
+import pandas as pd
+
+from analytics.no_vig_props import american_to_implied_prob, compute_edge
+from data.odds_name_map import map_odds_name_to_model_name
+from models.batter_baseline import build_batter_feature_row, compute_batter_baseline
+
+
+def _build_statcast_name_index(statcast_df: pd.DataFrame) -> dict[str, str]:
+    """
+    Build a lookup: normalized_name -> original statcast player_name.
+    Built once per call to avoid per-row overhead.
+    """
+    if statcast_df.empty or "player_name" not in statcast_df.columns:
+        return {}
+    index: dict[str, str] = {}
+    for name in statcast_df["player_name"].astype(str).unique():
+        normalized = map_odds_name_to_model_name(name)
+        if normalized not in index:
+            index[normalized] = name
+    return index
+
+
+def get_player_hr_prob(
+    player_name_normalized: str,
+    statcast_df: pd.DataFrame,
+    _name_index: dict[str, str] | None = None,
+) -> tuple[float | None, str]:
+    """
+    Returns (prob, source) for a pre-game HR probability.
+
+    source values:
+      "internal_model_baseline" — compute_batter_baseline() with statcast features
+      "unavailable"             — player not found or insufficient data
+    """
+    name_index = _name_index if _name_index is not None else _build_statcast_name_index(statcast_df)
+
+    statcast_name = name_index.get(player_name_normalized)
+    if statcast_name is None:
+        return (None, "unavailable")
+
+    feature_row = build_batter_feature_row(statcast_df, statcast_name)
+    if feature_row.get("plate_appearances", 0) == 0:
+        return (None, "unavailable")
+
+    baseline = compute_batter_baseline(feature_row)
+    hr_prob = baseline.get("hr_prob_base")
+    if hr_prob is None:
+        return (None, "unavailable")
+
+    return (float(hr_prob), "internal_model_baseline")
+
+
+def map_hr_props_to_model(
+    props_df: pd.DataFrame,
+    statcast_df: pd.DataFrame,
+    prob_fn: Callable[[str, pd.DataFrame, dict[str, str] | None], tuple[float | None, str]] | None = None,
+) -> pd.DataFrame:
+    """
+    Join HR prop rows to model HR probabilities and compute edge.
+
+    Adds columns:
+      implied_prob         — book implied probability (vig-inclusive)
+      model_hr_prob        — pre-game model HR probability (or None)
+      model_hr_prob_source — source label for model_hr_prob
+      edge                 — model_hr_prob - implied_prob (or None)
+
+    Filters to market == "hr".
+    Sorts by edge descending (rows with no edge/model prob sort last).
+    prob_fn is injectable for future source swaps; defaults to get_player_hr_prob.
+    """
+    if props_df.empty:
+        return pd.DataFrame()
+
+    _prob_fn = prob_fn if prob_fn is not None else get_player_hr_prob
+
+    hr_df = props_df[props_df["market"] == "hr"].copy()
+    if hr_df.empty:
+        return pd.DataFrame()
+
+    # Build name index once for all players
+    name_index = _build_statcast_name_index(statcast_df)
+
+    implied_probs: list[float] = []
+    model_probs: list[float | None] = []
+    sources: list[str] = []
+    edges: list[float | None] = []
+
+    for _, row in hr_df.iterrows():
+        odds = row.get("odds_american")
+        player_name = str(row.get("player_name") or "")
+
+        # Implied probability from book odds
+        try:
+            implied = american_to_implied_prob(odds) if odds is not None else None
+        except Exception:
+            implied = None
+
+        # Model HR probability
+        if player_name:
+            model_prob, source = _prob_fn(player_name, statcast_df, name_index)
+        else:
+            model_prob, source = None, "unavailable"
+
+        # Edge
+        if model_prob is not None and implied is not None:
+            edge = compute_edge(model_prob, implied)
+        else:
+            edge = None
+
+        implied_probs.append(implied)  # type: ignore[arg-type]
+        model_probs.append(model_prob)
+        sources.append(source)
+        edges.append(edge)
+
+    hr_df = hr_df.copy()
+    hr_df["implied_prob"] = implied_probs
+    hr_df["model_hr_prob"] = model_probs
+    hr_df["model_hr_prob_source"] = sources
+    hr_df["edge"] = edges
+
+    # Sort: rows with edge first (highest edge first), then no-edge rows
+    has_edge = hr_df["edge"].notna()
+    with_edge = hr_df[has_edge].sort_values("edge", ascending=False)
+    without_edge = hr_df[~has_edge]
+
+    return pd.concat([with_edge, without_edge], ignore_index=True)

app.py

@@ -110,6 +110,8 @@ from database.db import (
     read_batter_prop_outcomes,
     replace_batter_prop_outcomes,
     read_batter_prop_audit_view,
+    ensure_upcoming_hr_props_table,
+    insert_upcoming_hr_props,
 )
 
 from features.batter_features import batter_summary
@@ -122,6 +124,7 @@ from visualization.batter import create_exit_velocity_chart, create_launch_angle
 from visualization.betting import create_bankroll_chart, create_edge_chart
 from visualization.matchup import create_hit_hr_chart, create_matchup_score_chart
 from visualization.pitcher import create_pitch_movement_chart
+from visualization.props_page import render_props
 from visualization.simulation import create_hr_distribution, create_total_bases_distribution
 from visualization.game_cards import render_game_card
 
@@ -3962,7 +3965,7 @@ def main() -> None:
         "Navigation",
         options=[
             "Dashboard",
-            "Players",
+            "Props",
             "Matchups",
             "Betting",
             "Bet Tracker",
@@ -3975,8 +3978,8 @@ def main() -> None:
 
     if page == "Dashboard":
         render_dashboard()
-    elif page == "Players":
-        render_players()
+    elif page == "Props":
+        render_props(load_statcast_recent(), conn=conn)
     elif page == "Matchups":
         render_matchups()
     elif page == "Betting":

data/live_prop_odds.py

@@ -61,6 +61,40 @@ def best_book_by_player_market(df: pd.DataFrame) -> pd.DataFrame:
     return pd.DataFrame(rows)
 
 
+def fetch_all_upcoming_hr_props(
+    sportsbooks: list[str] | None = None,
+) -> pd.DataFrame:
+    """
+    Fetch HR props for all upcoming MLB games in a single API call (no game filter).
+    Returns normalized DataFrame with columns per normalize_prop_odds().
+    Returns empty DataFrame on any failure.
+    """
+    providers = []
+
+    if ENABLE_ENTERPRISE_PROVIDER:
+        providers.append(EnterpriseMarketProvider())
+
+    providers.append(TheOddsAPIProvider())
+
+    frames = []
+    for provider in providers:
+        try:
+            fetch_fn = getattr(provider, "fetch_all_upcoming_hr_props", None)
+            if fetch_fn is None:
+                continue
+            df = fetch_fn(sportsbooks=sportsbooks)
+            if not df.empty:
+                frames.append(df)
+        except Exception:
+            continue
+
+    if not frames:
+        return pd.DataFrame()
+
+    merged = pd.concat(frames, ignore_index=True)
+    return normalize_prop_odds(merged)
+
+
 def fetch_live_prop_odds(
     game_context: dict,
     sportsbooks: list[str] | None = None,

data/provider_theoddsapi.py

@@ -11,10 +11,20 @@ from data.odds_name_map import map_odds_name_to_model_name
 
 ODDS_API_BASE = "https://api.the-odds-api.com/v4/sports"
 
+# ---------------------------------------------------------------------------
+# Provider strategy (Batch 14)
+# Active v1:     The Odds API → DraftKings, FanDuel, BetMGM, Caesars (williamhill_us)
+# Sharp feed:    Pinnacle — planned as separate PinnacleProvider class with its own
+#                API key; register it in live_prop_odds.py when ready
+# Deferred:      Bet365, Circa (unclear API availability on The Odds API)
+# Enterprise:    ENABLE_ENTERPRISE_PROVIDER flag in config/settings.py
+# ---------------------------------------------------------------------------
+
 SUPPORTED_BOOKS = {
     "draftkings",
     "fanduel",
     "betmgm",
+    "williamhill_us",   # Caesars
 }
 
 SUPPORTED_MARKETS = {
@@ -30,9 +40,10 @@ MARKET_NAME_MAP = {
 }
 
 BOOK_KEY_MAP = {
-    "draftkings": "DraftKings",
-    "fanduel": "FanDuel",
-    "betmgm": "BetMGM",
+    "draftkings":    "DraftKings",
+    "fanduel":       "FanDuel",
+    "betmgm":        "BetMGM",
+    "williamhill_us": "Caesars",
 }
 
 TEAM_NAME_ALIASES = {
@@ -174,4 +185,88 @@ class TheOddsAPIProvider(MarketProviderBase):
                             }
                         )
 
+        return pd.DataFrame(rows)
+
+    def fetch_all_upcoming_hr_props(
+        self,
+        sportsbooks: list[str] | None = None,
+    ) -> pd.DataFrame:
+        """
+        Fetch HR props for ALL upcoming MLB events in a single API call.
+        Unlike fetch_live_prop_odds(), this applies no game-level team filter —
+        every event in the payload is included.
+
+        HR market only (batter_home_runs).
+        """
+        if not ODDS_API_KEY:
+            return pd.DataFrame()
+
+        books = [b for b in (sportsbooks or ["draftkings", "fanduel", "betmgm"]) if b in SUPPORTED_BOOKS]
+        if not books:
+            return pd.DataFrame()
+
+        sport_key = "baseball_mlb"
+        url = f"{ODDS_API_BASE}/{sport_key}/odds"
+        params = {
+            "apiKey": ODDS_API_KEY,
+            "regions": "us",
+            "markets": "batter_home_runs",
+            "bookmakers": ",".join(books),
+            "oddsFormat": "american",
+            "dateFormat": "iso",
+        }
+
+        response = requests.get(url, params=params, timeout=30)
+        response.raise_for_status()
+        payload = response.json()
+
+        rows: list[dict[str, Any]] = []
+
+        for event in payload:
+            event_id = str(event.get("id", "") or "")
+            commence_time = str(event.get("commence_time", "") or "")
+            away_team = str(event.get("away_team", "") or "")
+            home_team = str(event.get("home_team", "") or "")
+
+            for bookmaker in event.get("bookmakers", []) or []:
+                book_key = str(bookmaker.get("key", "") or "")
+                book_name = BOOK_KEY_MAP.get(book_key, book_key)
+
+                for market in bookmaker.get("markets", []) or []:
+                    market_key = str(market.get("key", "") or "")
+                    if market_key != "batter_home_runs":
+                        continue
+                    market_name = MARKET_NAME_MAP.get(market_key, market_key)
+
+                    for outcome in market.get("outcomes", []) or []:
+                        player_name_raw = str(
+                            outcome.get("description", "") or outcome.get("name", "") or ""
+                        ).strip()
+                        if not player_name_raw:
+                            continue
+
+                        price = outcome.get("price")
+                        if price is None:
+                            continue
+
+                        line = _safe_float(outcome.get("point"))
+
+                        rows.append(
+                            {
+                                "provider": self.provider_name,
+                                "event_id": event_id,
+                                "commence_time": commence_time,
+                                "away_team": away_team,
+                                "home_team": home_team,
+                                "sportsbook": book_name,
+                                "sportsbook_key": book_key,
+                                "market_key": market_key,
+                                "market": market_name,
+                                "player_name_raw": player_name_raw,
+                                "player_name": map_odds_name_to_model_name(player_name_raw),
+                                "odds_american": int(price),
+                                "line": line,
+                            }
+                        )
+
         return pd.DataFrame(rows)

database/db.py

@@ -434,6 +434,64 @@ def replace_batter_prop_outcomes(conn, df: pd.DataFrame) -> None:
     )
     conn.unregister("batter_prop_outcomes_replace_df")
 
+def ensure_upcoming_hr_props_table(conn) -> None:
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS upcoming_hr_props (
+            fetched_at           TEXT,
+            event_id             TEXT,
+            commence_time        TEXT,
+            away_team            TEXT,
+            home_team            TEXT,
+            sportsbook           TEXT,
+            market               TEXT,
+            player_name_raw      TEXT,
+            player_name          TEXT,
+            odds_american        INTEGER,
+            line                 DOUBLE,
+            implied_prob         DOUBLE,
+            model_hr_prob        DOUBLE,
+            model_hr_prob_source TEXT,
+            edge                 DOUBLE
+        )
+        """
+    )
+    for _col, _dtype in [
+        ("model_hr_prob_source", "TEXT"),
+        ("edge",                 "DOUBLE"),
+    ]:
+        try:
+            conn.execute(f"ALTER TABLE upcoming_hr_props ADD COLUMN {_col} {_dtype}")
+        except Exception:
+            pass  # Column already exists
+
+
+def insert_upcoming_hr_props(conn, df: pd.DataFrame) -> None:
+    if df is None or df.empty:
+        return
+    ensure_upcoming_hr_props_table(conn)
+    conn.register("upcoming_hr_props_df", df)
+    conn.execute(
+        """
+        INSERT INTO upcoming_hr_props
+        SELECT
+            fetched_at, event_id, commence_time, away_team, home_team,
+            sportsbook, market, player_name_raw, player_name,
+            odds_american, line, implied_prob, model_hr_prob,
+            model_hr_prob_source, edge
+        FROM upcoming_hr_props_df
+        """
+    )
+    conn.unregister("upcoming_hr_props_df")
+
+
+def read_upcoming_hr_props(conn) -> pd.DataFrame:
+    ensure_upcoming_hr_props_table(conn)
+    return conn.execute(
+        "SELECT * FROM upcoming_hr_props ORDER BY fetched_at DESC"
+    ).df()
+
+
 def read_batter_prop_audit_view(conn) -> pd.DataFrame:
     ensure_batter_prop_outcomes_table(conn)
 

visualization/props_page.py

@@ -0,0 +1,196 @@
+"""
+visualization/props_page.py
+
+Batch 14: Props page — upcoming HR props sorted by edge.
+
+Displays HR prop odds from retail sportsbooks (DK, FD, BetMGM, Caesars)
+alongside model HR probabilities and computed edge.
+
+Model HR% source:
+  - "internal_model_baseline": compute_batter_baseline() from statcast features
+    (EV90, barrel rate, hard hit rate, xwOBA, launch angle). Pre-game only.
+  - "unavailable": player not found in statcast data.
+
+Full simulator context (matchup, park, weather adjustments) is only available
+for live in-game batters — see the Dashboard tab.
+
+Deferred:
+  - Batch 13: post-game evaluation grading, multi-market expansion
+  - Batch 12.5 follow-up: audit view join fix
+  - Pinnacle sharp-feed integration
+  - xgb_hr_adjusted for pre-game use (requires anchor probs from simulator)
+"""
+
+from __future__ import annotations
+
+import pandas as pd
+import streamlit as st
+
+from analytics.props_mapper import map_hr_props_to_model
+from config.settings import DEFAULT_PROP_BOOKS
+from data.live_prop_odds import fetch_all_upcoming_hr_props
+from database.db import ensure_upcoming_hr_props_table, insert_upcoming_hr_props
+from utils.helpers import utc_now_iso
+
+
+def _format_pct(val: float | None) -> str:
+    if val is None:
+        return "—"
+    return f"{val * 100:.1f}%"
+
+
+def _format_odds(val: int | float | None) -> str:
+    if val is None:
+        return "—"
+    v = int(val)
+    return f"+{v}" if v > 0 else str(v)
+
+
+def _format_edge(val: float | None) -> str:
+    if val is None:
+        return "—"
+    return f"{val * 100:+.1f}%"
+
+
+def render_props(statcast_df: pd.DataFrame, conn=None) -> None:
+    st.subheader("Props")
+    st.caption("HR — upcoming games — sorted by edge")
+
+    # Fetch all upcoming HR props (single API call, no game filter)
+    with st.spinner("Loading HR props..."):
+        raw = fetch_all_upcoming_hr_props(sportsbooks=DEFAULT_PROP_BOOKS)
+
+    if raw.empty:
+        st.warning(
+            "No HR props returned. Check ODDS_API_KEY or provider coverage. "
+            "This may also occur outside of game days."
+        )
+        return
+
+    hr_props = raw[raw["market"] == "hr"].copy() if not raw.empty else raw
+    if hr_props.empty:
+        st.info("No HR props in current feed.")
+        return
+
+    # Map to model + compute edge
+    mapped = map_hr_props_to_model(hr_props, statcast_df)
+    if mapped.empty:
+        st.info("No mappable HR prop rows.")
+        return
+
+    # Log to durable DB (non-blocking)
+    if conn is not None:
+        try:
+            to_log = mapped.copy()
+            to_log["fetched_at"] = utc_now_iso()
+            # Ensure only expected columns are present
+            log_cols = [
+                "fetched_at", "event_id", "commence_time", "away_team", "home_team",
+                "sportsbook", "market", "player_name_raw", "player_name",
+                "odds_american", "line", "implied_prob", "model_hr_prob",
+                "model_hr_prob_source", "edge",
+            ]
+            for col in log_cols:
+                if col not in to_log.columns:
+                    to_log[col] = None
+            ensure_upcoming_hr_props_table(conn)
+            insert_upcoming_hr_props(conn, to_log[log_cols])
+        except Exception:
+            pass
+
+    # ---------------------------------------------------------------------------
+    # Sidebar filters
+    # ---------------------------------------------------------------------------
+    all_books = sorted(mapped["sportsbook"].dropna().unique().tolist())
+    selected_books = st.sidebar.multiselect(
+        "Sportsbook", options=all_books, default=all_books, key="props_books"
+    )
+    min_edge = st.sidebar.slider(
+        "Min edge", min_value=-0.50, max_value=0.50, value=-0.50, step=0.01,
+        format="%.0f%%", key="props_min_edge",
+    )
+
+    # ---------------------------------------------------------------------------
+    # View toggle
+    # ---------------------------------------------------------------------------
+    view = st.radio("View", ["All Books", "Best Line Per Player"], horizontal=True)
+
+    # Apply filters
+    display = mapped.copy()
+    if selected_books:
+        display = display[display["sportsbook"].isin(selected_books)]
+    if min_edge > -0.50:
+        display = display[display["edge"].notna() & (display["edge"] >= min_edge)]
+
+    if view == "Best Line Per Player":
+        # Best edge per player (highest edge across all books)
+        display = (
+            display
+            .sort_values("edge", ascending=False, na_position="last")
+            .drop_duplicates("player_name")
+            .reset_index(drop=True)
+        )
+
+    if display.empty:
+        st.info("No props match the current filters.")
+        return
+
+    # ---------------------------------------------------------------------------
+    # Summary metrics
+    # ---------------------------------------------------------------------------
+    col1, col2, col3 = st.columns(3)
+    col1.metric("Props shown", len(display))
+    with_edge = display["edge"].dropna()
+    col2.metric("With model edge", len(with_edge))
+    if not with_edge.empty:
+        col3.metric("Best edge", _format_edge(float(with_edge.max())))
+
+    # ---------------------------------------------------------------------------
+    # Table
+    # ---------------------------------------------------------------------------
+    def _build_matchup(row: pd.Series) -> str:
+        away = str(row.get("away_team") or "")
+        home = str(row.get("home_team") or "")
+        if away and home:
+            return f"{away} @ {home}"
+        return away or home or "—"
+
+    def _build_game_time(row: pd.Series) -> str:
+        ct = str(row.get("commence_time") or "")
+        if not ct:
+            return "—"
+        # ISO timestamp: take date + time portion only
+        try:
+            import datetime
+            dt = datetime.datetime.fromisoformat(ct.replace("Z", "+00:00"))
+            return dt.strftime("%m/%d %I:%M%p UTC")
+        except Exception:
+            return ct[:16]
+
+    rows = []
+    for _, row in display.iterrows():
+        name_raw = str(row.get("player_name_raw") or row.get("player_name") or "—")
+        rows.append({
+            "Player": name_raw,
+            "Matchup": _build_matchup(row),
+            "Game Time": _build_game_time(row),
+            "Book": str(row.get("sportsbook") or "—"),
+            "Odds": _format_odds(row.get("odds_american")),
+            "Implied%": _format_pct(row.get("implied_prob")),
+            "Model HR%": _format_pct(row.get("model_hr_prob")),
+            "Source": str(row.get("model_hr_prob_source") or "—"),
+            "Edge": _format_edge(row.get("edge")),
+        })
+
+    table_df = pd.DataFrame(rows)
+    st.dataframe(table_df, use_container_width=True, hide_index=True)
+
+    # ---------------------------------------------------------------------------
+    # Disclaimer
+    # ---------------------------------------------------------------------------
+    st.caption(
+        "Model HR% is a pre-game baseline from statcast features (EV90, barrel rate, "
+        "xwOBA, launch angle). It does not include live matchup, park, or weather "
+        "adjustments. Full simulator context is available only during live games "
+        "(Dashboard tab). Source column indicates data source used per player."
+    )