Post-patch cleanup: statcast season derivation + platoon lower bounds

- statcast.py: derive season from start_date instead of hardcoding "2026"
- live_fair_simulator_v3.py: add max() lower bounds to opposite-hand platoon path

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

data/statcast.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from datetime import datetime
 from io import StringIO
 
 import pandas as pd
@@ -72,22 +73,9 @@ def _query_statcast(start_date: str, end_date: str, season: str) -> pd.DataFrame
 
 
 def fetch_statcast_range(start_date: str, end_date: str) -> pd.DataFrame:
-    """
-    WBC-first pull.
-    Try current 2026 range first.
-    If that returns nothing, fall back to 2023 WBC historical window so the
-    analytics tabs still show real WBC Statcast data instead of blank charts.
-    """
-    current_df = _query_statcast(start_date, end_date, season="2026")
-    if not current_df.empty:
-        return current_df
-
-    # Historical WBC fallback: real WBC data, not mock data
-    fallback_df = _query_statcast("2023-03-07", "2023-03-23", season="2023")
-    if not fallback_df.empty:
-        return fallback_df
-
-    return pd.DataFrame()
+    """Fetch Statcast data for the given date range (MLB only)."""
+    season = str(datetime.strptime(start_date, "%Y-%m-%d").year)
+    return _query_statcast(start_date, end_date, season=season)
 
 
 def normalize_statcast(df: pd.DataFrame) -> pd.DataFrame:

models/live_fair_simulator_v3.py

@@ -274,45 +274,79 @@ def build_upcoming_simulated_rows(
             ),
         )
 
-        # Batch 9 zone-matchup overlay
-        zone_hr_boost = float(zone_matchup_adj.get("hr_zone_boost", 0.0) or 0.0)
-        zone_hit_boost = float(zone_matchup_adj.get("hit_zone_boost", 0.0) or 0.0)
+        # ---------------------------------------------------------------------------
+        # Batter trend adjustment (7d/30d signals wired into probability stack)
+        # ---------------------------------------------------------------------------
+        trend_delta_ev90   = batter_trend_row.get("trend_delta_ev90")
+        trend_delta_barrel = batter_trend_row.get("trend_delta_barrel")
+        xwoba_7d           = batter_trend_row.get("xwoba_7d")
+        xwoba_season       = batter_features.get("xwoba")
+        hot_flag           = batter_trend_row.get("batter_hot_flag", False)
+        cold_flag          = batter_trend_row.get("batter_cold_flag", False)
+
+        trend_adj_hr  = 0.0
+        trend_adj_hit = 0.0
+        trend_adj_tb  = 0.0
+
+        if trend_delta_ev90 is not None:
+            if trend_delta_ev90 >= 2.0:
+                trend_adj_hr  += 0.006
+                trend_adj_hit += 0.005
+            elif trend_delta_ev90 <= -2.0:
+                trend_adj_hr  -= 0.006
+                trend_adj_hit -= 0.005
+
+        if trend_delta_barrel is not None:
+            if trend_delta_barrel >= 0.02:
+                trend_adj_hr += 0.008
+                trend_adj_tb += 0.006
+            elif trend_delta_barrel <= -0.02:
+                trend_adj_hr -= 0.008
+                trend_adj_tb -= 0.006
+
+        if xwoba_7d is not None and xwoba_season is not None:
+            xwoba_delta = float(xwoba_7d) - float(xwoba_season)
+            if xwoba_delta >= 0.030:
+                trend_adj_hit += 0.006
+            elif xwoba_delta <= -0.030:
+                trend_adj_hit -= 0.006
+
+        if hot_flag:
+            trend_adj_hr  += 0.003
+            trend_adj_hit += 0.003
+        if cold_flag:
+            trend_adj_hr  -= 0.003
+            trend_adj_hit -= 0.003
+
+        # Hard caps
+        trend_adj_hr  = max(-0.010, min(0.010, trend_adj_hr))
+        trend_adj_hit = max(-0.008, min(0.008, trend_adj_hit))
+        trend_adj_tb  = max(-0.008, min(0.008, trend_adj_tb))
+
+        batter_baseline["hr_prob_base"]   = min(0.25, max(0.005,
+            float(batter_baseline.get("hr_prob_base",   0.03) or 0.03) + trend_adj_hr))
+        batter_baseline["hit_prob_base"]  = min(0.55, max(0.05,
+            float(batter_baseline.get("hit_prob_base",  0.15) or 0.15) + trend_adj_hit))
+        batter_baseline["tb2p_prob_base"] = min(0.45, max(0.03,
+            float(batter_baseline.get("tb2p_prob_base", 0.10) or 0.10) + trend_adj_tb))
+
+        _snap_after_trend_hr   = float(batter_baseline.get("hr_prob_base",   0.03) or 0.03)
+        _snap_after_trend_hit  = float(batter_baseline.get("hit_prob_base",  0.15) or 0.15)
+        _snap_after_trend_tb2p = float(batter_baseline.get("tb2p_prob_base", 0.10) or 0.10)
+
+        # ---------------------------------------------------------------------------
+        # Zone + family-zone matchup deduplication (take max by absolute magnitude)
+        # ---------------------------------------------------------------------------
+        # Batch 9 zone-matchup overlay — compute effective values only
+        zone_hr_boost   = float(zone_matchup_adj.get("hr_zone_boost",   0.0) or 0.0)
+        zone_hit_boost  = float(zone_matchup_adj.get("hit_zone_boost",  0.0) or 0.0)
         zone_tb2p_boost = float(zone_matchup_adj.get("tb2p_zone_boost", 0.0) or 0.0)
 
-        # Convert raw zone tendencies into a light additive adjustment.
-        # Keep this conservative in first pass.
-        batter_baseline["hit_prob_base"] = min(
-            0.55,
-            max(
-                0.05,
-                float(batter_baseline.get("hit_prob_base", 0.15) or 0.15)
-                + (zone_hit_boost * 0.10),
-            ),
-        )
-
-        batter_baseline["hr_prob_base"] = min(
-            0.25,
-            max(
-                0.005,
-                float(batter_baseline.get("hr_prob_base", 0.03) or 0.03)
-                + (zone_hr_boost * 0.10),
-            ),
-        )
-
-        batter_baseline["tb2p_prob_base"] = min(
-            0.45,
-            max(
-                0.03,
-                float(batter_baseline.get("tb2p_prob_base", 0.10) or 0.10)
-                + (zone_tb2p_boost * 0.10),
-            ),
-        )
-
-        _snap_after_zone_hr   = float(batter_baseline.get("hr_prob_base",   0.03) or 0.03)
-        _snap_after_zone_hit  = float(batter_baseline.get("hit_prob_base",  0.15) or 0.15)
-        _snap_after_zone_tb2p = float(batter_baseline.get("tb2p_prob_base", 0.10) or 0.10)
+        zone_hr_eff   = zone_hr_boost   * 0.10
+        zone_hit_eff  = zone_hit_boost  * 0.10
+        zone_tb2p_eff = zone_tb2p_boost * 0.10
 
-                # Family + zone conditional arsenal overlay
+        # Family + zone conditional arsenal overlay — compute effective values only
         family_zone_hr_boost = float(
             family_zone_matchup_adj.get("family_zone_hr_boost", 0.0) or 0.0
         )
@@ -326,73 +360,52 @@ def build_upcoming_simulated_rows(
             family_zone_matchup_adj.get("family_zone_whiff_risk", 0.0) or 0.0
         )
 
-        # Keep this conservative so we stack signal instead of overpowering existing layers.
-        batter_baseline["hit_prob_base"] = min(
-            0.55,
-            max(
-                0.05,
-                float(batter_baseline.get("hit_prob_base", 0.15) or 0.15)
-                + (family_zone_hit_boost * 0.06)
-                - (family_zone_whiff_risk * 0.02),
-            ),
-        )
-
-        batter_baseline["hr_prob_base"] = min(
-            0.25,
-            max(
-                0.005,
-                float(batter_baseline.get("hr_prob_base", 0.03) or 0.03)
-                + (family_zone_hr_boost * 0.07),
-            ),
-        )
-
-        batter_baseline["tb2p_prob_base"] = min(
-            0.45,
-            max(
-                0.03,
-                float(batter_baseline.get("tb2p_prob_base", 0.10) or 0.10)
-                + (family_zone_tb2p_boost * 0.06)
-                + (family_zone_hit_boost * 0.02),
-            ),
-        )
+        fz_hr_eff   = family_zone_hr_boost * 0.07
+        fz_hit_eff  = (family_zone_hit_boost * 0.06) - (family_zone_whiff_risk * 0.02)
+        fz_tb2p_eff = (family_zone_tb2p_boost * 0.06) + (family_zone_hit_boost * 0.02)
 
-        _snap_after_family_zone_hr   = float(batter_baseline.get("hr_prob_base",   0.03) or 0.03)
-        _snap_after_family_zone_hit  = float(batter_baseline.get("hit_prob_base",  0.15) or 0.15)
-        _snap_after_family_zone_tb2p = float(batter_baseline.get("tb2p_prob_base", 0.10) or 0.10)
+        # Apply whichever signal is stronger per dimension (no double-counting)
+        primary_hr   = zone_hr_eff   if abs(zone_hr_eff)   >= abs(fz_hr_eff)   else fz_hr_eff
+        primary_hit  = zone_hit_eff  if abs(zone_hit_eff)  >= abs(fz_hit_eff)  else fz_hit_eff
+        primary_tb2p = zone_tb2p_eff if abs(zone_tb2p_eff) >= abs(fz_tb2p_eff) else fz_tb2p_eff
 
-        # Arsenal matchup overlay
-        arsenal_hr_boost = float(arsenal_matchup_adj.get("arsenal_hr_boost", 0.0) or 0.0)
-        arsenal_hit_boost = float(arsenal_matchup_adj.get("arsenal_hit_boost", 0.0) or 0.0)
+        batter_baseline["hr_prob_base"]   = min(0.25, max(0.005,
+            float(batter_baseline.get("hr_prob_base",   0.03) or 0.03) + primary_hr))
+        batter_baseline["hit_prob_base"]  = min(0.55, max(0.05,
+            float(batter_baseline.get("hit_prob_base",  0.15) or 0.15) + primary_hit))
+        batter_baseline["tb2p_prob_base"] = min(0.45, max(0.03,
+            float(batter_baseline.get("tb2p_prob_base", 0.10) or 0.10) + primary_tb2p))
+
+        # Single dedup snap (debug ladder uses snap_after_zone_dedup_*)
+        _snap_after_zone_dedup_hr   = float(batter_baseline.get("hr_prob_base",   0.03) or 0.03)
+        _snap_after_zone_dedup_hit  = float(batter_baseline.get("hit_prob_base",  0.15) or 0.15)
+        _snap_after_zone_dedup_tb2p = float(batter_baseline.get("tb2p_prob_base", 0.10) or 0.10)
+        # Keep legacy snap names for signal attribution dict compatibility
+        _snap_after_zone_hr   = _snap_after_zone_dedup_hr
+        _snap_after_zone_hit  = _snap_after_zone_dedup_hit
+        _snap_after_zone_tb2p = _snap_after_zone_dedup_tb2p
+        _snap_after_family_zone_hr   = _snap_after_zone_dedup_hr
+        _snap_after_family_zone_hit  = _snap_after_zone_dedup_hit
+        _snap_after_family_zone_tb2p = _snap_after_zone_dedup_tb2p
+
+        # Arsenal matchup overlay — applied at 50% scalar (zone/fz already cover family+zone)
+        arsenal_hr_boost   = float(arsenal_matchup_adj.get("arsenal_hr_boost",   0.0) or 0.0)
+        arsenal_hit_boost  = float(arsenal_matchup_adj.get("arsenal_hit_boost",  0.0) or 0.0)
         arsenal_tb2p_boost = float(arsenal_matchup_adj.get("arsenal_tb2p_boost", 0.0) or 0.0)
         arsenal_whiff_risk = float(arsenal_matchup_adj.get("arsenal_whiff_risk", 0.0) or 0.0)
 
-        batter_baseline["hit_prob_base"] = min(
-            0.55,
-            max(
-                0.05,
-                float(batter_baseline.get("hit_prob_base", 0.15) or 0.15)
-                + (arsenal_hit_boost * 0.08)
-                - (arsenal_whiff_risk * 0.04),
-            ),
-        )
+        batter_baseline["hit_prob_base"]  = min(0.55, max(0.05,
+            float(batter_baseline.get("hit_prob_base",  0.15) or 0.15)
+            + (arsenal_hit_boost * 0.04)
+            - (arsenal_whiff_risk * 0.02)))
 
-        batter_baseline["hr_prob_base"] = min(
-            0.25,
-            max(
-                0.005,
-                float(batter_baseline.get("hr_prob_base", 0.03) or 0.03)
-                + (arsenal_hr_boost * 0.10),
-            ),
-        )
+        batter_baseline["hr_prob_base"]   = min(0.25, max(0.005,
+            float(batter_baseline.get("hr_prob_base",   0.03) or 0.03)
+            + (arsenal_hr_boost * 0.05)))
 
-        batter_baseline["tb2p_prob_base"] = min(
-            0.45,
-            max(
-                0.03,
-                float(batter_baseline.get("tb2p_prob_base", 0.10) or 0.10)
-                + (arsenal_tb2p_boost * 0.08),
-            ),
-        )
+        batter_baseline["tb2p_prob_base"] = min(0.45, max(0.03,
+            float(batter_baseline.get("tb2p_prob_base", 0.10) or 0.10)
+            + (arsenal_tb2p_boost * 0.04)))
 
         _snap_after_arsenal_hr   = float(batter_baseline.get("hr_prob_base",   0.03) or 0.03)
         _snap_after_arsenal_hit  = float(batter_baseline.get("hit_prob_base",  0.15) or 0.15)
@@ -472,25 +485,25 @@ def build_upcoming_simulated_rows(
             or (batter_stand == "R" and p_throws == "R")
         )
         if platoon_same_hand:
-            batter_baseline["hit_prob_base"] = max(
+            batter_baseline["hit_prob_base"] = min(0.55, max(
                 0.05, float(batter_baseline.get("hit_prob_base", 0.15) or 0.15) - 0.008
-            )
-            batter_baseline["hr_prob_base"] = max(
-                0.005, float(batter_baseline.get("hr_prob_base", 0.03) or 0.03) - 0.005
-            )
-            batter_baseline["tb2p_prob_base"] = max(
+            ))
+            batter_baseline["hr_prob_base"] = min(0.25, max(
+                0.005, float(batter_baseline.get("hr_prob_base", 0.03) or 0.03) - 0.008
+            ))
+            batter_baseline["tb2p_prob_base"] = min(0.45, max(
                 0.03, float(batter_baseline.get("tb2p_prob_base", 0.10) or 0.10) - 0.006
-            )
+            ))
         else:
-            batter_baseline["hit_prob_base"] = min(
-                0.55, float(batter_baseline.get("hit_prob_base", 0.15) or 0.15) + 0.007
-            )
-            batter_baseline["hr_prob_base"] = min(
-                0.25, float(batter_baseline.get("hr_prob_base", 0.03) or 0.03) + 0.004
-            )
-            batter_baseline["tb2p_prob_base"] = min(
-                0.45, float(batter_baseline.get("tb2p_prob_base", 0.10) or 0.10) + 0.005
-            )
+            batter_baseline["hit_prob_base"] = min(0.55, max(
+                0.05, float(batter_baseline.get("hit_prob_base", 0.15) or 0.15) + 0.007
+            ))
+            batter_baseline["hr_prob_base"] = min(0.25, max(
+                0.005, float(batter_baseline.get("hr_prob_base", 0.03) or 0.03) + 0.007
+            ))
+            batter_baseline["tb2p_prob_base"] = min(0.45, max(
+                0.03, float(batter_baseline.get("tb2p_prob_base", 0.10) or 0.10) + 0.005
+            ))
 
         _snap_after_platoon_hr   = float(batter_baseline.get("hr_prob_base",   0.03) or 0.03)
         _snap_after_platoon_hit  = float(batter_baseline.get("hit_prob_base",  0.15) or 0.15)
@@ -844,9 +857,15 @@ def build_upcoming_simulated_rows(
                 "snap_baseline_hr":           _snap_baseline_hr,
                 "snap_baseline_hit":          _snap_baseline_hit,
                 "snap_baseline_tb2p":         _snap_baseline_tb2p,
+                "snap_after_trend_hr":        _snap_after_trend_hr,
+                "snap_after_trend_hit":       _snap_after_trend_hit,
+                "snap_after_trend_tb2p":      _snap_after_trend_tb2p,
                 "snap_after_zone_hr":              _snap_after_zone_hr,
                 "snap_after_zone_hit":             _snap_after_zone_hit,
                 "snap_after_zone_tb2p":            _snap_after_zone_tb2p,
+                "snap_after_zone_dedup_hr":        _snap_after_zone_dedup_hr,
+                "snap_after_zone_dedup_hit":       _snap_after_zone_dedup_hit,
+                "snap_after_zone_dedup_tb2p":      _snap_after_zone_dedup_tb2p,
                 "snap_after_family_zone_hr":       _snap_after_family_zone_hr,
                 "snap_after_family_zone_hit":      _snap_after_family_zone_hit,
                 "snap_after_family_zone_tb2p":     _snap_after_family_zone_tb2p,