Hitter selector: ID-based role dominance classification

Replaces name-based exclusion with batter/pitcher numeric ID comparison.
Two queries against statcast_event_core:
1. batter id -> (player_name, batter_count) via GROUP BY batter
2. pitcher id -> pitcher_count via GROUP BY pitcher

Eligibility rule: batter_count >= 20 AND batter_count > pitcher_count.
Display names come from player_name (the batter name column in the table).
No name-matching logic used for eligibility decisions.

Diagnostic logging preserved: logs Ivan Herrera / Mick Abel / Jason Adam
with player_id, batter_count, pitcher_count, and hitter_eligible result.
Hitter cache remains disabled pending log verification.

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

visualization/cards/card_queries.py

@@ -73,99 +73,114 @@ def normalize_name_for_compare(name: str) -> str:
     return " ".join(s.lower().split())
 
 
+_HITTER_MIN_PITCHES = 20  # minimum batter-side pitches to appear in hitter selector
+
+
 def get_card_lab_hitters(conn, year: int | None = None, limit: int = 500) -> list[str]:
     """
-    Batter names filtered by dominance: must have >= 20 batter-side pitches AND
-    not be a known pitcher (unless they have >= 100 batter-side pitches, covering
-    genuine two-way players).
+    ID-based hitter classification.
 
-    Uses get_card_lab_pitchers() to build the exclusion set — no need to rewrite
-    pitcher logic here.
+    A player is hitter-eligible if:
+      - batter_count >= _HITTER_MIN_PITCHES   (at least ~5 PA)
+      - batter_count > pitcher_count          (batter role dominates)
+
+    Both sides are measured by numeric player IDs from statcast_event_core
+    (batter / pitcher columns). Name matching is NOT used for eligibility.
+    Display names come from player_name (which IS the batter's name in this table).
     """
     try:
-        # Step A: batter candidates with pitch count
+        # --- Query 1: batter_id → (display_name, batter_count) ---
         if year:
-            sql = text("""
-                SELECT player_name, COUNT(*) AS batter_pitch_count
+            batter_sql = text("""
+                SELECT batter, MAX(player_name) AS player_name, COUNT(*) AS batter_count
                 FROM statcast_event_core
                 WHERE source_season = :year
-                  AND player_name IS NOT NULL
-                GROUP BY player_name
-                HAVING COUNT(*) >= 20
+                  AND batter IS NOT NULL
+                GROUP BY batter
+                HAVING COUNT(*) >= :min_pitches
                 LIMIT :limit
             """)
-            rows = conn.execute(sql, {"year": int(year), "limit": limit}).fetchall()
+            batter_rows = conn.execute(
+                batter_sql, {"year": int(year), "min_pitches": _HITTER_MIN_PITCHES, "limit": limit}
+            ).fetchall()
         else:
-            sql = text("""
-                SELECT player_name, COUNT(*) AS batter_pitch_count
+            batter_sql = text("""
+                SELECT batter, MAX(player_name) AS player_name, COUNT(*) AS batter_count
                 FROM statcast_event_core
-                WHERE player_name IS NOT NULL
-                GROUP BY player_name
-                HAVING COUNT(*) >= 20
+                WHERE batter IS NOT NULL
+                GROUP BY batter
+                HAVING COUNT(*) >= :min_pitches
                 LIMIT :limit
             """)
-            rows = conn.execute(sql, {"limit": limit}).fetchall()
-
-        # Step B: build pitcher exclusion set from the working pitcher selector
-        # Exclude "Pitcher {id}" fallbacks — only named pitchers are excluded
-        pitcher_tuples = get_card_lab_pitchers(conn, year=year)
-        pitcher_set = {
-            normalize_name_for_compare(name)
-            for _, name in pitcher_tuples
-            if name and not name.startswith("Pitcher ")
-        }
-
-        # Diagnostic: raw snapshot
-        logger.info(
-            "[card_lab_hitter_diag] raw_candidates=%s pitcher_set_size=%s",
-            len(rows), len(pitcher_set),
-        )
-        if rows:
-            logger.info(
-                "[card_lab_hitter_diag] first_25_candidates=%s",
-                [(r[0], r[1]) for r in rows[:25]],
-            )
-        if pitcher_set:
-            logger.info(
-                "[card_lab_hitter_diag] first_25_pitcher_set=%s",
-                sorted(pitcher_set)[:25],
-            )
+            batter_rows = conn.execute(
+                batter_sql, {"min_pitches": _HITTER_MIN_PITCHES, "limit": limit}
+            ).fetchall()
 
-        # Diagnostic: named-player checks
-        _raw_map = {normalize_name_for_compare(r[0]): (r[0], r[1]) for r in rows if r[0]}
-        for check_name in ("Ivan Herrera", "Mick Abel", "Jason Adam"):
-            norm = normalize_name_for_compare(check_name)
-            raw_present = norm in _raw_map
-            b_count = _raw_map[norm][1] if raw_present else 0
-            in_ps = norm in pitcher_set
-            included = raw_present and (b_count >= 20) and (norm not in pitcher_set or b_count >= 100)
-            logger.info(
-                '[card_lab_hitter_diag] name="%s" raw_present=%s batter_pitch_count=%s '
-                'normalized="%s" in_pitcher_set=%s included=%s',
-                check_name, raw_present, b_count, norm, in_ps, included,
-            )
+        # --- Query 2: pitcher_id → pitcher_count ---
+        if year:
+            pitcher_count_rows = conn.execute(
+                text("""
+                    SELECT pitcher, COUNT(*) AS pitcher_count
+                    FROM statcast_event_core
+                    WHERE source_season = :year AND pitcher IS NOT NULL
+                    GROUP BY pitcher
+                """),
+                {"year": int(year)},
+            ).fetchall()
+        else:
+            pitcher_count_rows = conn.execute(
+                text("""
+                    SELECT pitcher, COUNT(*) AS pitcher_count
+                    FROM statcast_event_core
+                    WHERE pitcher IS NOT NULL
+                    GROUP BY pitcher
+                """)
+            ).fetchall()
+
+        pitcher_counts: dict[int, int] = {row[0]: row[1] for row in pitcher_count_rows}
+
+        # --- Classify by dominance ---
+        # Build name→row map for diagnostic checks only
+        _name_map: dict[str, tuple] = {}
+        for row in batter_rows:
+            key = normalize_name_for_compare(row[1] or "")
+            if key:
+                _name_map[key] = row
 
-        # Step C/D: filter by dominance
         names: list[str] = []
         excluded = 0
-        for row in rows:
-            raw_name, batter_count = row[0], row[1]
-            if not raw_name:
-                continue
-            if normalize_name_for_compare(raw_name) in pitcher_set and batter_count < 100:
+
+        for row in batter_rows:
+            batter_id, player_name, batter_count = row[0], row[1], row[2]
+            pitcher_count = pitcher_counts.get(batter_id, 0)
+            eligible = batter_count >= _HITTER_MIN_PITCHES and batter_count > pitcher_count
+            if not eligible:
                 excluded += 1
                 continue
-            names.append(raw_name)
-
-        names.sort()
+            display = player_name if player_name else f"Player {batter_id}"
+            names.append(display)
 
-        # Diagnostic: final output
-        logger.info("[card_lab_hitter_diag] final_count=%s", len(names))
-        logger.info("[card_lab_hitter_diag] first_25_final=%s", names[:25])
+        # --- Diagnostic: known-player checks ---
+        for check_name in ("Ivan Herrera", "Mick Abel", "Jason Adam"):
+            norm = normalize_name_for_compare(check_name)
+            row = _name_map.get(norm)
+            if row:
+                bid, pname, b_count = row[0], row[1], row[2]
+                p_count = pitcher_counts.get(bid, 0)
+                eligible = b_count >= _HITTER_MIN_PITCHES and b_count > p_count
+            else:
+                bid, pname, b_count, p_count, eligible = None, None, 0, 0, False
+            logger.info(
+                '[card_lab_hitter_diag] name="%s" player_id=%s display_name="%s" '
+                "batter_count=%s pitcher_count=%s hitter_eligible=%s",
+                check_name, bid, pname, b_count, p_count, eligible,
+            )
 
+        names.sort()
+        logger.info("[card_lab_hitter_diag] final_count=%s first_25=%s", len(names), names[:25])
         logger.info(
-            "[card_lab_db_players] type=hitter year=%s raw=%s filtered=%s excluded_pitchers=%s",
-            year, len(rows), len(names), excluded,
+            "[card_lab_db_players] type=hitter year=%s batter_ids=%s final=%s excluded=%s",
+            year, len(batter_rows), len(names), excluded,
         )
         return names
     except Exception as exc: