Card Lab: fix player classification, column aliases, pitcher ID flow

Root cause fixes:
- Remove batter_stand/pitcher_hand/xwoba aliases that broke all model lookups
(models expect stand, p_throws, estimated_woba_using_speedangle)
- Restore bb.bb_type + add ec.pitcher to pitcher SELECT for feature builders
- Hitter list: add events NOT IN filter to exclude pitchers with rare ABs
- Pitcher list: LEFT JOIN to name map (no LIMIT), fallback "Pitcher {id}",
NULL names sorted last; returns list[tuple[int,str]] keyed by pitcher ID
- Pitcher window query: accept pitcher_id directly, remove name→id lookup

UX/perf:
- Cached hitter/pitcher list wrappers (_cached_hitters/_cached_pitchers, 10m TTL)
- Game summary player filter: explicit session_state binding for rerender
- Add idx_statcast_game_pk index for game summary player dropdown

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

database/db.py

@@ -158,6 +158,10 @@ def initialize_schema(conn) -> None:
         "CREATE INDEX IF NOT EXISTS idx_statcast_pitcher_date "
         "ON statcast_event_core (pitcher, source_season, game_date)"
     ))
+    conn.execute(text(
+        "CREATE INDEX IF NOT EXISTS idx_statcast_game_pk "
+        "ON statcast_event_core (game_pk)"
+    ))
 
 
 # ---------------------------------------------------------------------------

visualization/card_lab_page.py

@@ -35,6 +35,25 @@ def normalize_name(name: str) -> str:
     return str(name).strip()
 
 
+# ---------------------------------------------------------------------------
+# Cached player list wrappers
+# Leading underscore on _conn tells Streamlit to skip hashing the connection.
+# ---------------------------------------------------------------------------
+
+@st.cache_data(ttl=600, show_spinner=False)
+def _cached_hitters(_conn, year):
+    return get_card_lab_hitters(_conn, year=year)
+
+
+@st.cache_data(ttl=600, show_spinner=False)
+def _cached_pitchers(_conn, year):
+    return get_card_lab_pitchers(_conn, year=year)
+
+
+# ---------------------------------------------------------------------------
+# Card generation functions — button-click only, no caching
+# ---------------------------------------------------------------------------
+
 def _gen_hitter_bytes(conn, player_name, mode, year, date, start_date, end_date, fmt):
     windowed_df = get_player_card_window_df(
         conn, player_name, "Hitter", mode=mode, year=year,
@@ -50,10 +69,11 @@ def _gen_hitter_bytes(conn, player_name, mode, year, date, start_date, end_date,
     return img_bytes, payload.get("timeframe", ""), payload.get("data_quality", "")
 
 
-def _gen_pitcher_bytes(conn, player_name, mode, year, date, start_date, end_date, fmt):
+def _gen_pitcher_bytes(conn, player_name, pitcher_id, mode, year, date, start_date, end_date, fmt):
     windowed_df = get_player_card_window_df(
         conn, player_name, "Pitcher", mode=mode, year=year,
         date=date, start_date=start_date, end_date=end_date,
+        pitcher_id=pitcher_id,
     )
     if windowed_df.empty:
         return None, "", "limited"
@@ -80,6 +100,10 @@ def _gen_game_bytes(conn, game_pk, away_team, home_team, away_score, home_score,
     return img_bytes, payload.get("timeframe", "")
 
 
+# ---------------------------------------------------------------------------
+# Main render function
+# ---------------------------------------------------------------------------
+
 def render_card_lab(conn) -> None:
     st.subheader("Kasper Card Lab")
     st.caption("Generate downloadable Kasper player cards.")
@@ -89,8 +113,9 @@ def render_card_lab(conn) -> None:
 
     # ---- Timeframe controls (Hitter / Pitcher only) ----
     date = start_date = end_date = None
-    year     = None
-    mode_key = "season"
+    year      = None
+    mode_key  = "season"
+    pitcher_id = None  # set in pitcher selectbox block
 
     if card_type in ("Hitter", "Pitcher"):
         st.markdown("**Data Window**")
@@ -124,7 +149,7 @@ def render_card_lab(conn) -> None:
     selected_game_row = None
 
     if card_type == "Hitter":
-        players = get_card_lab_hitters(conn, year=year if mode_key == "season" else None)
+        players = _cached_hitters(conn, year=year if mode_key == "season" else None)
         if not players:
             st.info("No hitters found in warehouse for selected season.")
             return
@@ -133,17 +158,18 @@ def render_card_lab(conn) -> None:
         )
 
     elif card_type == "Pitcher":
-        players = get_card_lab_pitchers(conn, year=year if mode_key == "season" else None)
-        if not players:
+        pitchers = _cached_pitchers(conn, year=year if mode_key == "season" else None)
+        if not pitchers:
             st.info("No pitchers found in warehouse for selected season.")
             return
-        player_name = st.selectbox(
-            "Player", players, format_func=normalize_name, key="cl_player_pitcher"
-        )
-        st.caption(
-            "Pitcher list reflects pitchers with available name mappings in the warehouse (V1). "
-            "Coverage expands as the name mapping table grows."
+
+        selected_pitcher = st.selectbox(
+            "Player",
+            pitchers,
+            format_func=lambda t: normalize_name(t[1]),
+            key="cl_player_pitcher",
         )
+        pitcher_id, player_name = selected_pitcher
 
     else:  # Game Summary
         gdf = get_recent_completed_games_for_card_lab(conn)
@@ -168,10 +194,10 @@ def render_card_lab(conn) -> None:
         if game_pk:
             try:
                 prows = conn.execute(
-                    text("SELECT DISTINCT player_name FROM statcast_event_core WHERE game_pk = :gpk"),
+                    text("SELECT DISTINCT player_name FROM statcast_event_core WHERE game_pk = :gpk ORDER BY player_name"),
                     {"gpk": int(game_pk)},
                 ).fetchall()
-                raw_game_players = sorted([r[0] for r in prows if r[0]])
+                raw_game_players = [r[0] for r in prows if r[0]]
             except Exception as exc:
                 logger.warning("[card_lab] game player list failed: %s", exc)
                 raw_game_players = []
@@ -184,6 +210,8 @@ def render_card_lab(conn) -> None:
                     format_func=lambda n: "Full Game" if n == "Full Game" else normalize_name(n),
                     key="cl_game_player",
                 )
+                # Explicit session state binding to ensure rerender picks up selection
+                st.session_state["cl_game_player_selected"] = gp_sel
                 player_name = None if gp_sel == "Full Game" else gp_sel
 
     fmt = st.radio("Format", ["PNG", "JPG"], horizontal=True, key="cl_fmt")
@@ -214,7 +242,7 @@ def render_card_lab(conn) -> None:
                 status.info("Querying warehouse data...")
                 status.info("Building charts...")
                 img_bytes, tf, dq = _gen_pitcher_bytes(
-                    conn, player_name, mode_key, year, date, start_date, end_date, fmt
+                    conn, player_name, pitcher_id, mode_key, year, date, start_date, end_date, fmt
                 )
                 st.session_state["card_player"]    = player_name or "unknown"
                 st.session_state["card_timeframe"] = tf

visualization/cards/card_queries.py

@@ -7,9 +7,8 @@ from sqlalchemy import text
 from utils.logger import logger
 
 # ---------------------------------------------------------------------------
-# Shared JOIN fragment — confirmed columns only
-# pitch_type is NOT selected (not confirmed in statcast_event_core)
-# pitch_name IS confirmed
+# Shared JOIN fragment — confirmed columns only, NO breaking aliases
+# Models expect: stand, p_throws, estimated_woba_using_speedangle (not aliased)
 # ---------------------------------------------------------------------------
 _HITTER_JOIN_SELECT = """
     ec.event_key,
@@ -20,8 +19,8 @@ _HITTER_JOIN_SELECT = """
     ec.pitch_name,
     ec.events,
     ec.description,
-    ec.stand        AS batter_stand,
-    ec.p_throws     AS pitcher_hand,
+    ec.stand,
+    ec.p_throws,
     ec.home_team,
     ec.away_team,
     ec.inning,
@@ -30,7 +29,7 @@ _HITTER_JOIN_SELECT = """
     bb.launch_speed,
     bb.launch_angle,
     bb.bb_type,
-    bb.estimated_woba_using_speedangle AS xwoba,
+    bb.estimated_woba_using_speedangle,
     pr.release_speed,
     pr.release_spin_rate,
     pr.pfx_x,
@@ -45,7 +44,6 @@ LEFT JOIN statcast_pitch_release pr ON ec.event_key = pr.event_key
 
 # ---------------------------------------------------------------------------
 # Date range helper — used only for date_range and single_date modes
-# season mode bypasses this and uses source_season = :year directly
 # ---------------------------------------------------------------------------
 def _date_range(mode, date, start_date, end_date) -> tuple[str, str]:
     """Returns (sd, ed) for date_range / single_date modes only."""
@@ -65,23 +63,33 @@ def _date_range(mode, date, start_date, end_date) -> tuple[str, str]:
 # ---------------------------------------------------------------------------
 
 def get_card_lab_hitters(conn, year: int | None = None, limit: int = 500) -> list[str]:
-    """Distinct batter names from statcast_event_core, optionally filtered by season."""
+    """
+    Distinct batter names for true batting events only.
+    Excludes walk, HBP, sac_bunt, sac_fly to prevent pitchers with rare ABs
+    from polluting the hitter list.
+    """
     try:
+        _EVENTS_FILTER = """
+            AND events IS NOT NULL
+            AND events NOT IN ('walk', 'hit_by_pitch', 'sac_bunt', 'sac_fly')
+        """
         if year:
-            sql = text("""
+            sql = text(f"""
                 SELECT DISTINCT player_name
                 FROM statcast_event_core
                 WHERE source_season = :year
                   AND player_name IS NOT NULL
+                  {_EVENTS_FILTER}
                 ORDER BY player_name
                 LIMIT :limit
             """)
             rows = conn.execute(sql, {"year": int(year), "limit": limit}).fetchall()
         else:
-            sql = text("""
+            sql = text(f"""
                 SELECT DISTINCT player_name
                 FROM statcast_event_core
                 WHERE player_name IS NOT NULL
+                  {_EVENTS_FILTER}
                 ORDER BY player_name
                 LIMIT :limit
             """)
@@ -95,63 +103,52 @@ def get_card_lab_hitters(conn, year: int | None = None, limit: int = 500) -> lis
         return []
 
 
-def get_card_lab_pitchers(conn, year: int | None = None, limit: int = 500) -> list[str]:
+def get_card_lab_pitchers(conn, year: int | None = None) -> list[tuple[int, str]]:
     """
-    Pitcher names for Card Lab dropdown.
-
-    Source: DISTINCT pitcher IDs from statcast_event_core, LEFT JOIN to
-    pitcher_inning_first_seed_events for name mapping. Only pitchers with
-    a valid name mapping are shown.
+    All distinct pitcher IDs from statcast_event_core, LEFT JOIN to name mapping.
+    Pitchers without a name mapping get fallback label "Pitcher {id}".
 
-    V1 LIMITATION: pitcher_inning_first_seed_events is the only name mapping
-    table in the warehouse (~30 unique pitchers). Pitcher IDs without a mapping
-    are excluded. The coverage gap is logged. The UI surfaces this limitation.
+    Returns list of (pitcher_id, display_name) tuples.
+    Named pitchers are sorted first (alphabetically); unnamed pitchers last.
+    No LIMIT — full result set with indexes is fast.
     """
     try:
         if year:
             sql = text("""
-                SELECT DISTINCT pife.pitcher_name
+                SELECT DISTINCT ec.pitcher, pife.pitcher_name
                 FROM statcast_event_core ec
-                INNER JOIN pitcher_inning_first_seed_events pife
+                LEFT JOIN pitcher_inning_first_seed_events pife
                     ON ec.pitcher = pife.pitcher_id
-                WHERE ec.source_season = :year
-                  AND pife.pitcher_name IS NOT NULL
-                ORDER BY pife.pitcher_name
-                LIMIT :limit
+                WHERE ec.pitcher IS NOT NULL
+                  AND ec.source_season = :year
+                ORDER BY
+                    CASE WHEN pife.pitcher_name IS NULL THEN 1 ELSE 0 END,
+                    pife.pitcher_name
             """)
-            rows = conn.execute(sql, {"year": int(year), "limit": limit}).fetchall()
+            rows = conn.execute(sql, {"year": int(year)}).fetchall()
         else:
             sql = text("""
-                SELECT DISTINCT pife.pitcher_name
+                SELECT DISTINCT ec.pitcher, pife.pitcher_name
                 FROM statcast_event_core ec
-                INNER JOIN pitcher_inning_first_seed_events pife
+                LEFT JOIN pitcher_inning_first_seed_events pife
                     ON ec.pitcher = pife.pitcher_id
-                WHERE pife.pitcher_name IS NOT NULL
-                ORDER BY pife.pitcher_name
-                LIMIT :limit
+                WHERE ec.pitcher IS NOT NULL
+                ORDER BY
+                    CASE WHEN pife.pitcher_name IS NULL THEN 1 ELSE 0 END,
+                    pife.pitcher_name
             """)
-            rows = conn.execute(sql, {"limit": limit}).fetchall()
+            rows = conn.execute(sql).fetchall()
 
-        names = [r[0] for r in rows if r[0]]
+        pitchers: list[tuple[int, str]] = []
+        for row in rows:
+            pid, name = row[0], row[1]
+            pitchers.append((pid, name if name else f"Pitcher {pid}"))
 
-        # Log coverage gap so operator knows the limitation
-        try:
-            total_sql = text(
-                "SELECT COUNT(DISTINCT pitcher) FROM statcast_event_core"
-                + (" WHERE source_season = :year" if year else "")
-            )
-            total_params = {"year": int(year)} if year else {}
-            total_row = conn.execute(total_sql, total_params).fetchone()
-            total_pitcher_ids = total_row[0] if total_row else "?"
-            logger.info(
-                "[card_lab_db_players] type=pitcher year=%s mapped=%s total_ids=%s "
-                "(unmapped pitcher_ids have no Card Lab coverage)",
-                year, len(names), total_pitcher_ids,
-            )
-        except Exception:
-            logger.info("[card_lab_db_players] type=pitcher year=%s count=%s", year, len(names))
+        # Re-sort in Python after fallback naming: named first (alpha), unnamed last (by id)
+        pitchers.sort(key=lambda t: (1 if t[1].startswith("Pitcher ") else 0, t[1]))
 
-        return names
+        logger.info("[card_lab_db_players] type=pitcher year=%s count=%s", year, len(pitchers))
+        return pitchers
     except Exception as exc:
         logger.warning("[card_lab_db_players] pitcher query failed: %s", exc)
         return []
@@ -208,36 +205,29 @@ def get_player_card_window_df(
     date: str | None = None,
     start_date: str | None = None,
     end_date: str | None = None,
+    pitcher_id: int | None = None,
 ) -> pd.DataFrame:
     """
     Fetch the FULL matching pitch/event dataset for one player over a time window.
 
-    NO row cap is applied — the full matching dataset is returned so that
-    build_hitter_card_data() / build_pitcher_card_data() compute metrics on
-    complete data. Chart-level downsampling is handled inside card_charts.py
-    (_sample_df) and is render-only; it does not affect metric computation.
-
-    This DataFrame is the ONLY data source passed to card builders.
-    No fallback to statcast HTTP loaders.
+    NO row cap is applied — full matching dataset returned for metric computation.
+    Chart-level downsampling handled inside card_charts.py (_sample_df).
 
     Season mode uses source_season INT filter (fastest).
     Date range / single date use game_date TEXT range comparison.
+
+    For Pitcher card_type, pitcher_id is REQUIRED (the numeric ID from statcast_event_core).
+    The player_name string is injected as a display label for the feature builders.
     """
     try:
         if card_type == "Pitcher":
-            # Resolve pitcher_id from name mapping table
-            pid_row = conn.execute(
-                text("SELECT pitcher_id FROM pitcher_inning_first_seed_events WHERE pitcher_name = :n LIMIT 1"),
-                {"n": player_name},
-            ).fetchone()
-            if not pid_row:
+            if pitcher_id is None:
                 logger.warning(
-                    "[card_lab_db_window] pitcher name '%s' not found in name map — "
-                    "no pitcher ID to query", player_name,
+                    "[card_lab_db_window] pitcher_id required for Pitcher card_type "
+                    "(player_name='%s') — returning empty", player_name,
                 )
                 return pd.DataFrame()
 
-            pitcher_id = pid_row[0]
             _PITCHER_SELECT = """
                 SELECT
                     ec.event_key,
@@ -248,8 +238,9 @@ def get_player_card_window_df(
                     ec.pitch_name,
                     ec.events,
                     ec.description,
-                    ec.stand        AS batter_stand,
-                    ec.p_throws     AS pitcher_hand,
+                    ec.stand,
+                    ec.p_throws,
+                    ec.pitcher,
                     ec.home_team,
                     ec.away_team,
                     ec.inning,
@@ -260,7 +251,8 @@ def get_player_card_window_df(
                     pr.pfx_x,
                     pr.pfx_z,
                     bb.launch_speed,
-                    bb.launch_angle
+                    bb.launch_angle,
+                    bb.bb_type
                 FROM statcast_event_core ec
                 LEFT JOIN statcast_pitch_release  pr ON ec.event_key = pr.event_key
                 LEFT JOIN statcast_batted_ball    bb ON ec.event_key = bb.event_key
@@ -285,6 +277,14 @@ def get_player_card_window_df(
                 params = {"player_name": player_name, "sd": sd, "ed": ed}
 
         df = pd.read_sql(sql, conn, params=params)
+
+        if df.empty:
+            logger.warning(
+                "[card_lab_db_window] empty result player=%s pitcher_id=%s mode=%s year=%s",
+                player_name, pitcher_id, mode, year,
+            )
+            return pd.DataFrame()
+
         logger.info(
             "[card_lab_db_window] player=%s type=%s mode=%s year=%s rows=%s",
             player_name, card_type, mode, year, len(df),