Odds tab: add pitcher strikeout alt lines with Standard/Alt Lines/Both view toggle

- Fetch pitcher_strikeouts_alternate market from TheOddsAPI
- Normalize alt K rows: populate threshold from line, set market_variant=alternate, is_primary_line=False
- Fix latent bug: threshold now populated for all K rows, enabling Strikeout Ladder Summary to render
- Ladder Summary gains Variant column (Standard/Alt/Mixed), sorted Standard-first
- K section adds horizontal radio: Standard (existing O/U grids) | Alt Lines (Over-only alt grid) | Both (unified single table of all lines)

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

config/settings.py

@@ -18,7 +18,7 @@ ENABLE_XGB_SHADOW = os.getenv("ENABLE_XGB_SHADOW", "true").lower() == "true"
 LIVE_PROP_ODDS_TTL_SECONDS = 20
 DEFAULT_PROP_BOOKS = ["draftkings", "fanduel", "betmgm", "williamhill_us"]
 DEFAULT_PROP_MARKETS = ["batter_home_runs", "batter_hits", "batter_total_bases"]
-DEFAULT_UPCOMING_PROP_MARKETS = ["batter_home_runs", "pitcher_strikeouts"]
+DEFAULT_UPCOMING_PROP_MARKETS = ["batter_home_runs", "pitcher_strikeouts", "pitcher_strikeouts_alternate"]
 
 # Phase 2: Baseline HR probability (empirical MLB 2024 per-PA HR rate ≈ 0.036)
 BASELINE_HR_PROB = 0.036

data/live_prop_odds.py

@@ -127,6 +127,7 @@ def normalize_prop_odds(raw_df: pd.DataFrame) -> pd.DataFrame:
         out.loc[~hr_mask, "threshold"].notna(),
         None,
     )
+    out.loc[k_mask, "threshold"] = out.loc[k_mask, "line"].apply(_safe_float)
     out.loc[hr_mask, "market_variant"] = out.loc[hr_mask, "threshold"].apply(
         lambda v: "primary" if pd.notna(v) and int(v) == 1 else "alternate"
     )
@@ -143,6 +144,9 @@ def normalize_prop_odds(raw_df: pd.DataFrame) -> pd.DataFrame:
         out.loc[~hr_mask, "market_variant"].notna(),
         "standard",
     )
+    if "market_key" in out.columns:
+        k_alt_mask = k_mask & out["market_key"].astype(str).str.strip().eq("pitcher_strikeouts_alternate")
+        out.loc[k_alt_mask, "market_variant"] = "alternate"
     out.loc[k_mask, "selection_scope"] = out.loc[k_mask, "selection_scope"].where(
         out.loc[k_mask, "selection_scope"].notna(),
         "pitcher",
@@ -155,7 +159,9 @@ def normalize_prop_odds(raw_df: pd.DataFrame) -> pd.DataFrame:
         ),
         axis=1,
     )
-    out.loc[k_mask, "is_primary_line"] = True
+    out.loc[k_mask, "is_primary_line"] = out.loc[k_mask, "market_variant"].apply(
+        lambda v: v != "alternate"
+    )
     out.loc[k_mask, "is_modeled"] = out.loc[k_mask, "selection_side"].isin(["over", "under"])
 
     out.loc[no_hr_mask, "selection_scope"] = out.loc[no_hr_mask, "selection_scope"].where(

data/provider_theoddsapi.py

@@ -36,6 +36,7 @@ SUPPORTED_MARKETS = {
     "batter_hits",
     "batter_total_bases",
     "pitcher_strikeouts",
+    "pitcher_strikeouts_alternate",
 }
 
 MARKET_NAME_MAP = {
@@ -43,6 +44,7 @@ MARKET_NAME_MAP = {
     "batter_hits": "hit",
     "batter_total_bases": "tb",
     "pitcher_strikeouts": "k",
+    "pitcher_strikeouts_alternate": "k",
 }
 
 BOOK_KEY_MAP = {

visualization/betting_page.py

@@ -551,8 +551,16 @@ def _build_strikeout_ladder_summary(df: pd.DataFrame) -> pd.DataFrame:
         line_df = df[pd.to_numeric(df["threshold"], errors="coerce") == threshold].copy()
         if line_df.empty:
             continue
+        variants = line_df["market_variant"].dropna().astype(str).unique().tolist() if "market_variant" in line_df.columns else []
+        if all(v == "alternate" for v in variants) and variants:
+            variant_label = "Alt"
+        elif any(v == "alternate" for v in variants):
+            variant_label = "Mixed"
+        else:
+            variant_label = "Standard"
         row: dict[str, Any] = {
             "Line": f"{float(threshold):.1f} K",
+            "Variant": variant_label,
             "Pitchers": int(line_df["player_name"].dropna().nunique()) if "player_name" in line_df.columns else 0,
             "Books": int(line_df["sportsbook"].dropna().nunique()) if "sportsbook" in line_df.columns else 0,
             "Rows": int(len(line_df)),
@@ -568,7 +576,12 @@ def _build_strikeout_ladder_summary(df: pd.DataFrame) -> pd.DataFrame:
                 row[f"{side.title()} Book"] = str(best_row.get("sportsbook") or "-")
         rows.append(row)
     summary_df = pd.DataFrame(rows)
-    preferred = ["Line", "Pitchers", "Books", "Rows", "Over Best", "Over Book", "Under Best", "Under Book"]
+    if not summary_df.empty and "Variant" in summary_df.columns:
+        _variant_order = {"Standard": 0, "Mixed": 1, "Alt": 2}
+        summary_df = summary_df.sort_values(
+            "Variant", key=lambda s: s.map(lambda v: _variant_order.get(v, 99))
+        ).reset_index(drop=True)
+    preferred = ["Line", "Variant", "Pitchers", "Books", "Rows", "Over Best", "Over Book", "Under Best", "Under Book"]
     return summary_df[[col for col in preferred if col in summary_df.columns]] if not summary_df.empty else summary_df
 
 
@@ -579,13 +592,17 @@ def _render_market_section(df: pd.DataFrame, family: str, prev_snap: dict[str, f
     with controls[1]:
         teams = sorted({team for col in ("away_team", "home_team") if col in df.columns for team in df[col].dropna().astype(str).unique()})
         team_sel = st.selectbox("team", ["All teams"] + teams, key=f"team_{family}", label_visibility="collapsed")
-    thresholds = sorted(pd.to_numeric(df["threshold"], errors="coerce").dropna().unique().tolist()) if "threshold" in df.columns else []
+    _thresh_src = df[df["market_variant"] != "alternate"] if (family == "k" and "market_variant" in df.columns) else df
+    thresholds = sorted(pd.to_numeric(_thresh_src["threshold"], errors="coerce").dropna().unique().tolist()) if "threshold" in _thresh_src.columns else []
     selected_threshold: float | None = None
     with controls[2]:
         if len(thresholds) > 1:
             selected_threshold = float(st.selectbox("thresh", thresholds, key=f"thresh_{family}", label_visibility="collapsed", format_func=lambda value: f"{float(value):.1f} K" if family == "k" else f"{float(value):.1f}+"))
         elif thresholds:
             st.caption(f"Line: {float(thresholds[0]):.1f} K" if family == "k" else f"Line: {float(thresholds[0]):.1f}+")
+    k_view = "Standard"
+    if family == "k":
+        k_view = st.radio("View", ["Standard", "Alt Lines", "Both"], horizontal=True, key=f"k_view_{family}", label_visibility="collapsed")
     if search_q:
         df = df[df["player_name"].astype(str).str.contains(search_q, case=False, na=False)].copy()
     if team_sel != "All teams":
@@ -595,49 +612,85 @@ def _render_market_section(df: pd.DataFrame, family: str, prev_snap: dict[str, f
         st.info("No lines match the current filter.")
         return
     grouped_source_df = df.copy()
-    if selected_threshold is not None:
-        df = df[pd.to_numeric(df["threshold"], errors="coerce") == selected_threshold].copy()
-        if df.empty:
-            st.info("No lines match the selected line.")
+    alt_source_df = pd.DataFrame()
+    if family == "k" and "market_variant" in df.columns:
+        alt_source_df = df[df["market_variant"] == "alternate"].copy()
+        df = df[df["market_variant"] != "alternate"].copy()
+    if k_view == "Standard":
+        std_df = df.copy()
+        if selected_threshold is not None:
+            std_df = std_df[pd.to_numeric(std_df["threshold"], errors="coerce") == selected_threshold].copy()
+            if std_df.empty:
+                st.info("No lines match the selected line.")
+                return
+        if std_df.empty:
+            st.info("No lines match the current filter.")
             return
-    books = [book for book in df["sportsbook"].dropna().unique() if book] if "sportsbook" in df.columns else []
-    book_cols = sorted(books, key=lambda book: (_BOOK_PRIORITY.index(book) if book in _BOOK_PRIORITY else 99, book))
-    if not book_cols:
-        st.info("No sportsbook columns found.")
-        return
-    sides_present = df["selection_side"].dropna().astype(str).str.lower().unique().tolist() if "selection_side" in df.columns else ["over"]
-    over_numeric = pd.DataFrame()
-    under_numeric = pd.DataFrame()
-    for side in ["over", "under"]:
-        if side not in sides_present or (family == "hr" and side == "under"):
-            continue
-        side_df = df[df["selection_side"].astype(str).str.lower() == side].copy()
-        if side_df.empty:
-            continue
-        if "over" in sides_present and "under" in sides_present:
-            st.markdown(f"**{'Over' if side == 'over' else 'Under'}**")
-        numeric_df, display_df = _build_side_table(side_df, book_cols, prev_snap, steam_set, model_probs)
-        css_df = _build_css_df(display_df, numeric_df, [col for col in book_cols if col in display_df.columns])
-        display_df, numeric_df, css_df = _render_sortable_grid(display_df, numeric_df, css_df, family=family, side=side)
-        if side == "over":
-            over_numeric = numeric_df
+        books = [book for book in std_df["sportsbook"].dropna().unique() if book] if "sportsbook" in std_df.columns else []
+        book_cols = sorted(books, key=lambda book: (_BOOK_PRIORITY.index(book) if book in _BOOK_PRIORITY else 99, book))
+        if not book_cols:
+            st.info("No sportsbook columns found.")
+            return
+        sides_present = std_df["selection_side"].dropna().astype(str).str.lower().unique().tolist() if "selection_side" in std_df.columns else ["over"]
+        over_numeric = pd.DataFrame()
+        under_numeric = pd.DataFrame()
+        for side in ["over", "under"]:
+            if side not in sides_present or (family == "hr" and side == "under"):
+                continue
+            side_df = std_df[std_df["selection_side"].astype(str).str.lower() == side].copy()
+            if side_df.empty:
+                continue
+            if "over" in sides_present and "under" in sides_present:
+                st.markdown(f"**{'Over' if side == 'over' else 'Under'}**")
+            numeric_df, display_df = _build_side_table(side_df, book_cols, prev_snap, steam_set, model_probs)
+            css_df = _build_css_df(display_df, numeric_df, [col for col in book_cols if col in display_df.columns])
+            display_df, numeric_df, css_df = _render_sortable_grid(display_df, numeric_df, css_df, family=family, side=side)
+            if side == "over":
+                over_numeric = numeric_df
+            else:
+                under_numeric = numeric_df
+            market_label = next((label for market, label in _MARKETS if market == family), family)
+            side_label = f"{side.title()} {selected_threshold:.1f} K" if family == "k" and selected_threshold is not None else side.title()
+            try:
+                png_bytes = _render_table_png(display_df, css_df, market_label=market_label, side_label=side_label)
+                st.download_button(
+                    label="Export PNG",
+                    data=png_bytes,
+                    file_name=f"kasper_odds_{family}_{side}_{datetime.now().strftime('%Y%m%d_%H%M')}.png",
+                    mime="image/png",
+                    key=f"export_{family}_{side}_{selected_threshold}_{id(display_df)}",
+                )
+            except Exception:
+                pass
+        if not over_numeric.empty and not under_numeric.empty:
+            _render_vig_section(over_numeric, under_numeric, book_cols)
+    elif family == "k" and k_view == "Alt Lines":
+        if alt_source_df.empty:
+            st.info("No alt line data available for the current filters.")
         else:
-            under_numeric = numeric_df
-        market_label = next((label for market, label in _MARKETS if market == family), family)
-        side_label = f"{side.title()} {selected_threshold:.1f} K" if family == "k" and selected_threshold is not None else side.title()
-        try:
-            png_bytes = _render_table_png(display_df, css_df, market_label=market_label, side_label=side_label)
-            st.download_button(
-                label="Export PNG",
-                data=png_bytes,
-                file_name=f"kasper_odds_{family}_{side}_{datetime.now().strftime('%Y%m%d_%H%M')}.png",
-                mime="image/png",
-                key=f"export_{family}_{side}_{selected_threshold}_{id(display_df)}",
-            )
-        except Exception:
-            pass
-    if not over_numeric.empty and not under_numeric.empty:
-        _render_vig_section(over_numeric, under_numeric, book_cols)
+            alt_books = [b for b in alt_source_df["sportsbook"].dropna().unique() if b] if "sportsbook" in alt_source_df.columns else []
+            alt_book_cols = sorted(alt_books, key=lambda b: (_BOOK_PRIORITY.index(b) if b in _BOOK_PRIORITY else 99, b))
+            if alt_book_cols:
+                alt_over_df = alt_source_df[alt_source_df["selection_side"].astype(str).str.lower() == "over"].copy() if "selection_side" in alt_source_df.columns else alt_source_df
+                if not alt_over_df.empty:
+                    alt_numeric_df, alt_display_df = _build_side_table(alt_over_df, alt_book_cols, prev_snap, steam_set, model_probs)
+                    alt_css_df = _build_css_df(alt_display_df, alt_numeric_df, [col for col in alt_book_cols if col in alt_display_df.columns])
+                    _render_sortable_grid(alt_display_df, alt_numeric_df, alt_css_df, family=family, side="alt_over")
+            else:
+                st.info("No alt line data available for the current filters.")
+    elif family == "k" and k_view == "Both":
+        combined_df = pd.concat([df, alt_source_df], ignore_index=True) if not alt_source_df.empty else df.copy()
+        if combined_df.empty:
+            st.info("No lines match the current filter.")
+        else:
+            all_books = [b for b in combined_df["sportsbook"].dropna().unique() if b] if "sportsbook" in combined_df.columns else []
+            all_book_cols = sorted(all_books, key=lambda b: (_BOOK_PRIORITY.index(b) if b in _BOOK_PRIORITY else 99, b))
+            if all_book_cols:
+                combined_numeric_df, combined_display_df = _build_side_table(combined_df, all_book_cols, prev_snap, steam_set, model_probs)
+                combined_css_df = _build_css_df(combined_display_df, combined_numeric_df, [col for col in all_book_cols if col in combined_display_df.columns])
+                _render_sortable_grid(combined_display_df, combined_numeric_df, combined_css_df, family=family, side="both")
+            else:
+                st.info("No sportsbook columns found.")
     if family == "k":
         summary_df = _build_strikeout_ladder_summary(grouped_source_df)
         if not summary_df.empty: