CockroachDB cutover + XGBoost evaluation fix + requirements cleanup

- All 6 runtime tables now CockroachDB-backed via SQLAlchemy (db.py full rewrite, remote_db.py lazy engine)
- XGBoost evaluation pipeline: pd.read_sql(text(...)) read path fix + lineup_slot JOIN fix (xgb_hr_evaluation.py)
- config/settings.py: removed dead DUCKDB_PATH constant
- app.py: updated caption DuckDB → CockroachDB
- requirements.txt: remove duckdb==1.1.2 (unused), add xgboost (required by shadow model)

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

app.py

@@ -507,7 +507,7 @@ def render_header() -> None:
     st.title("⚾ World Baseball Classic Analytics Assistant")
     st.caption(
         "WBC-first app using official WBC schedule pages, WBC Statcast from Baseball Savant, "
-        "The Odds API, weather overlays, DuckDB storage, and a modern Streamlit UI."
+        "The Odds API, weather overlays, CockroachDB persistence, and a modern Streamlit UI."
     )
     secret_status = []
     secret_status.append("ODDS_API_KEY ✓" if ODDS_API_KEY else "ODDS_API_KEY missing")

config/settings.py

@@ -10,8 +10,6 @@ SCORES_TTL_SECONDS = 8
 SCHEDULE_TTL_SECONDS = 300
 STATCAST_TTL_SECONDS = 600
 
-DUCKDB_PATH = "data/wbc.duckdb"
-
 ENABLE_ENTERPRISE_PROVIDER = False
 
 # Batch 12.5C: XGBoost shadow inference

database/db.py

@@ -1,112 +1,182 @@
+"""
+database/db.py
+
+CockroachDB-backed persistence layer (cutover from DuckDB).
+
+All table management for the active runtime tables:
+  recommendation_logs, recommendation_outcomes, upcoming_hr_props,
+  game_outcomes, batter_prop_outcomes, bets,
+  cached_schedule, cached_odds, cached_weather (schema artifacts, no active inserts)
+
+Public API is unchanged — all callers import from this module.
+Connection is a long-lived SQLAlchemy connection opened with AUTOCOMMIT isolation
+(matches DuckDB's default auto-commit-per-statement behavior).
+
+Bulk inserts are chunked at _INSERT_CHUNK_SIZE rows per execute call to prevent
+large single-payload issues in CockroachDB. SQLAlchemy passes list-of-dicts to
+execute() as executemany — no Python-level per-row loops.
+
+No primary keys or unique constraints are added in this batch. Schema is designed
+so they can be added later without structural changes.
+"""
+
 from __future__ import annotations
 
-from pathlib import Path
-from typing import Iterable, Mapping, Any
+from typing import Any, Iterable, Mapping
 
-import duckdb
 import pandas as pd
+from sqlalchemy import text
+
+from database import remote_db
+
 
-from config.settings import DUCKDB_PATH
+# ---------------------------------------------------------------------------
+# Chunk size for bulk inserts
+# ---------------------------------------------------------------------------
 
+_INSERT_CHUNK_SIZE = 500
 
-def get_connection() -> duckdb.DuckDBPyConnection:
-    Path("data").mkdir(parents=True, exist_ok=True)
-    conn = duckdb.connect(DUCKDB_PATH)
+
+# ---------------------------------------------------------------------------
+# Connection
+# ---------------------------------------------------------------------------
+
+def get_connection():
+    """
+    Returns a CockroachDB SQLAlchemy connection with AUTOCOMMIT isolation.
+    Schema is initialized on every new connection (idempotent CREATE IF NOT EXISTS).
+    The connection is long-lived (module-level in app.py); the pool handles
+    stale connection detection via pool_pre_ping=True and pool_recycle=300.
+    """
+    conn = remote_db.get_connection().execution_options(isolation_level="AUTOCOMMIT")
     initialize_schema(conn)
     return conn
 
 
-def initialize_schema(conn: duckdb.DuckDBPyConnection) -> None:
-    conn.execute(
+# ---------------------------------------------------------------------------
+# Private helpers
+# ---------------------------------------------------------------------------
+
+def _bulk_insert(conn, table: str, df: pd.DataFrame) -> None:
+    """
+    Insert all rows from df into table using chunked executemany.
+    Column names in df must match table column names exactly.
+    NaN values are converted to None (SQL NULL) before insertion.
+    """
+    if df is None or df.empty:
+        return
+    cols = list(df.columns)
+    col_list = ", ".join(cols)
+    placeholders = ", ".join(f":{c}" for c in cols)
+    sql = text(f"INSERT INTO {table} ({col_list}) VALUES ({placeholders})")
+    records = df.where(df.notna(), other=None).to_dict("records")
+    for i in range(0, len(records), _INSERT_CHUNK_SIZE):
+        conn.execute(sql, records[i : i + _INSERT_CHUNK_SIZE])
+
+
+# ---------------------------------------------------------------------------
+# Schema initialization
+# ---------------------------------------------------------------------------
+
+def initialize_schema(conn) -> None:
+    """
+    Create base tables if they do not exist.
+    All DDL is idempotent (CREATE TABLE IF NOT EXISTS).
+    """
+    conn.execute(text(
         """
         CREATE TABLE IF NOT EXISTS bets (
-            bet_id BIGINT,
-            created_at TIMESTAMP,
-            sportsbook TEXT,
-            market TEXT,
-            selection TEXT,
-            odds INTEGER,
-            stake DOUBLE,
-            result TEXT,
-            profit DOUBLE,
-            game_id TEXT,
-            notes TEXT
-        );
+            bet_id      BIGINT,
+            created_at  TEXT,
+            sportsbook  TEXT,
+            market      TEXT,
+            selection   TEXT,
+            odds        INTEGER,
+            stake       DOUBLE PRECISION,
+            result      TEXT,
+            profit      DOUBLE PRECISION,
+            game_id     TEXT,
+            notes       TEXT
+        )
         """
-    )
+    ))
 
-    conn.execute(
+    conn.execute(text(
         """
         CREATE TABLE IF NOT EXISTS cached_schedule (
-            fetched_at TIMESTAMP,
-            game_id TEXT,
-            game_date TIMESTAMP,
-            status TEXT,
-            away_team TEXT,
-            home_team TEXT,
-            away_score INTEGER,
-            home_score INTEGER,
-            venue TEXT
-        );
+            fetched_at  TEXT,
+            game_id     TEXT,
+            game_date   TEXT,
+            status      TEXT,
+            away_team   TEXT,
+            home_team   TEXT,
+            away_score  INTEGER,
+            home_score  INTEGER,
+            venue       TEXT
+        )
         """
-    )
+    ))
 
-    conn.execute(
+    conn.execute(text(
         """
         CREATE TABLE IF NOT EXISTS cached_odds (
-            fetched_at TIMESTAMP,
-            event_id TEXT,
-            commence_time TIMESTAMP,
-            home_team TEXT,
-            away_team TEXT,
-            sportsbook TEXT,
-            market_key TEXT,
-            outcome_name TEXT,
-            price INTEGER,
-            point DOUBLE
-        );
+            fetched_at    TEXT,
+            event_id      TEXT,
+            commence_time TEXT,
+            home_team     TEXT,
+            away_team     TEXT,
+            sportsbook    TEXT,
+            market_key    TEXT,
+            outcome_name  TEXT,
+            price         INTEGER,
+            point         DOUBLE PRECISION
+        )
         """
-    )
+    ))
 
-    conn.execute(
+    conn.execute(text(
         """
         CREATE TABLE IF NOT EXISTS cached_weather (
-            fetched_at TIMESTAMP,
-            venue_key TEXT,
-            location_name TEXT,
-            temperature_f DOUBLE,
-            humidity INTEGER,
-            wind_speed_mph DOUBLE,
-            wind_deg INTEGER,
-            description TEXT
-        );
+            fetched_at      TEXT,
+            venue_key       TEXT,
+            location_name   TEXT,
+            temperature_f   DOUBLE PRECISION,
+            humidity        INTEGER,
+            wind_speed_mph  DOUBLE PRECISION,
+            wind_deg        INTEGER,
+            description     TEXT
+        )
         """
-    )
+    ))
+
 
+# ---------------------------------------------------------------------------
+# Generic helpers
+# ---------------------------------------------------------------------------
 
 def upsert_dataframe(
-    conn: duckdb.DuckDBPyConnection,
+    conn,
     table_name: str,
     df: pd.DataFrame,
     replace: bool = True,
 ) -> None:
-    if df.empty:
+    if df is None or df.empty:
         return
-
-    temp_name = f"tmp_{table_name}"
-    conn.register(temp_name, df)
     if replace:
-        conn.execute(f"DELETE FROM {table_name}")
-    conn.execute(f"INSERT INTO {table_name} SELECT * FROM {temp_name}")
-    conn.unregister(temp_name)
+        conn.execute(text(f"DELETE FROM {table_name}"))
+    _bulk_insert(conn, table_name, df)
 
 
-def read_table(conn: duckdb.DuckDBPyConnection, table_name: str) -> pd.DataFrame:
-    return conn.execute(f"SELECT * FROM {table_name}").df()
+def read_table(conn, table_name: str) -> pd.DataFrame:
+    return pd.read_sql(text(f"SELECT * FROM {table_name}"), conn)
 
 
+# ---------------------------------------------------------------------------
+# Bets
+# ---------------------------------------------------------------------------
+
 def insert_bet(
-    conn: duckdb.DuckDBPyConnection,
+    conn,
     bet_id: int,
     created_at: str,
     sportsbook: str,
@@ -120,27 +190,56 @@ def insert_bet(
     notes: str,
 ) -> None:
     conn.execute(
-        """
-        INSERT INTO bets (
-            bet_id, created_at, sportsbook, market, selection, odds, stake,
-            result, profit, game_id, notes
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        """,
-        [
-            bet_id,
-            created_at,
-            sportsbook,
-            market,
-            selection,
-            odds,
-            stake,
-            result,
-            profit,
-            game_id,
-            notes,
-        ],
+        text(
+            """
+            INSERT INTO bets (
+                bet_id, created_at, sportsbook, market, selection, odds, stake,
+                result, profit, game_id, notes
+            ) VALUES (
+                :bet_id, :created_at, :sportsbook, :market, :selection, :odds, :stake,
+                :result, :profit, :game_id, :notes
+            )
+            """
+        ),
+        {
+            "bet_id":     bet_id,
+            "created_at": created_at,
+            "sportsbook": sportsbook,
+            "market":     market,
+            "selection":  selection,
+            "odds":       odds,
+            "stake":      stake,
+            "result":     result,
+            "profit":     profit,
+            "game_id":    game_id,
+            "notes":      notes,
+        },
     )
 
+
+def next_bet_id(conn) -> int:
+    return int(
+        conn.execute(text("SELECT COALESCE(MAX(bet_id), 0) + 1 FROM bets")).scalar()
+    )
+
+
+def update_bet_result(conn, bet_id: int, result: str, profit: float) -> None:
+    conn.execute(
+        text(
+            """
+            UPDATE bets
+            SET result = :result, profit = :profit
+            WHERE bet_id = :bet_id
+            """
+        ),
+        {"result": result, "profit": profit, "bet_id": bet_id},
+    )
+
+
+# ---------------------------------------------------------------------------
+# Recommendation audit view
+# ---------------------------------------------------------------------------
+
 def read_recommendation_audit_view(conn) -> pd.DataFrame:
     ensure_recommendation_logs_table(conn)
     ensure_recommendation_outcomes_table(conn)
@@ -192,31 +291,36 @@ def read_recommendation_audit_view(conn) -> pd.DataFrame:
      AND l.slot = o.slot
     ORDER BY l.created_at DESC
     """
-    return conn.execute(query).df()
+    return pd.read_sql(text(query), conn)
+
+
+# ---------------------------------------------------------------------------
+# Recommendation outcomes
+# ---------------------------------------------------------------------------
 
 def ensure_recommendation_outcomes_table(conn) -> None:
-    conn.execute(
+    conn.execute(text(
         """
         CREATE TABLE IF NOT EXISTS recommendation_outcomes (
-            created_at TEXT,
-            game_pk TEXT,
-            away_team TEXT,
-            home_team TEXT,
-            batter_name TEXT,
-            slot TEXT,
-            market TEXT,
-            realized_hit INTEGER,
-            realized_hr INTEGER,
-            realized_tb2p INTEGER,
-            graded_at TEXT,
+            created_at     TEXT,
+            game_pk        TEXT,
+            away_team      TEXT,
+            home_team      TEXT,
+            batter_name    TEXT,
+            slot           TEXT,
+            market         TEXT,
+            realized_hit   INTEGER,
+            realized_hr    INTEGER,
+            realized_tb2p  INTEGER,
+            graded_at      TEXT,
             outcome_source TEXT,
-            lineup_slot TEXT
+            lineup_slot    TEXT
         )
         """
-    )
+    ))
 
     try:
-        conn.execute("ALTER TABLE recommendation_outcomes ADD COLUMN lineup_slot TEXT")
+        conn.execute(text("ALTER TABLE recommendation_outcomes ADD COLUMN lineup_slot TEXT"))
     except Exception:
         pass  # Column already exists
 
@@ -224,75 +328,68 @@ def ensure_recommendation_outcomes_table(conn) -> None:
 def insert_recommendation_outcomes(conn, df: pd.DataFrame) -> None:
     if df is None or df.empty:
         return
-
     ensure_recommendation_outcomes_table(conn)
-    conn.register("recommendation_outcomes_df", df)
-    conn.execute(
-        """
-        INSERT INTO recommendation_outcomes
-        SELECT * FROM recommendation_outcomes_df
-        """
-    )
-    conn.unregister("recommendation_outcomes_df")
+    _bulk_insert(conn, "recommendation_outcomes", df)
+
 
-def next_bet_id(conn: duckdb.DuckDBPyConnection) -> int:
-    value = conn.execute("SELECT COALESCE(MAX(bet_id), 0) + 1 FROM bets").fetchone()[0]
-    return int(value)
+# ---------------------------------------------------------------------------
+# Recommendation logs
+# ---------------------------------------------------------------------------
 
 def ensure_recommendation_logs_table(conn) -> None:
-    conn.execute(
+    conn.execute(text(
         """
         CREATE TABLE IF NOT EXISTS recommendation_logs (
-            created_at TEXT,
-            game_pk TEXT,
-            away_team TEXT,
-            home_team TEXT,
-            status TEXT,
-            slot TEXT,
-            batter_name TEXT,
-            pitcher_name TEXT,
-            ev90 DOUBLE,
-            hit_prob DOUBLE,
-            hr_prob DOUBLE,
-            tb2p_prob DOUBLE,
-            fair_hit_odds DOUBLE,
-            fair_hr_odds DOUBLE,
-            fair_tb2p_odds DOUBLE,
-            book_hit_odds DOUBLE,
-            book_hr_odds DOUBLE,
-            book_tb2p_odds DOUBLE,
-            hit_edge DOUBLE,
-            hr_edge DOUBLE,
-            tb2p_edge DOUBLE,
-            adjusted_edge DOUBLE,
-            hit_bet_ev DOUBLE,
-            hr_bet_ev DOUBLE,
-            tb2p_bet_ev DOUBLE,
-            confidence DOUBLE,
-            confidence_bucket TEXT,
-            recommendation_tier TEXT,
-            priority_score DOUBLE,
-            reason_tags TEXT,
-            starter_stays_next_batter_prob DOUBLE,
-            starter_stays_next_inning_prob DOUBLE,
-            bullpen_entry_prob DOUBLE,
-            xgb_hr_delta      DOUBLE,
-            xgb_hr_adjusted   DOUBLE,
-            xgb_shadow_active BOOLEAN,
-            lineup_slot TEXT
+            created_at                     TEXT,
+            game_pk                        TEXT,
+            away_team                      TEXT,
+            home_team                      TEXT,
+            status                         TEXT,
+            slot                           TEXT,
+            batter_name                    TEXT,
+            pitcher_name                   TEXT,
+            ev90                           DOUBLE PRECISION,
+            hit_prob                       DOUBLE PRECISION,
+            hr_prob                        DOUBLE PRECISION,
+            tb2p_prob                      DOUBLE PRECISION,
+            fair_hit_odds                  DOUBLE PRECISION,
+            fair_hr_odds                   DOUBLE PRECISION,
+            fair_tb2p_odds                 DOUBLE PRECISION,
+            book_hit_odds                  DOUBLE PRECISION,
+            book_hr_odds                   DOUBLE PRECISION,
+            book_tb2p_odds                 DOUBLE PRECISION,
+            hit_edge                       DOUBLE PRECISION,
+            hr_edge                        DOUBLE PRECISION,
+            tb2p_edge                      DOUBLE PRECISION,
+            adjusted_edge                  DOUBLE PRECISION,
+            hit_bet_ev                     DOUBLE PRECISION,
+            hr_bet_ev                      DOUBLE PRECISION,
+            tb2p_bet_ev                    DOUBLE PRECISION,
+            confidence                     DOUBLE PRECISION,
+            confidence_bucket              TEXT,
+            recommendation_tier            TEXT,
+            priority_score                 DOUBLE PRECISION,
+            reason_tags                    TEXT,
+            starter_stays_next_batter_prob DOUBLE PRECISION,
+            starter_stays_next_inning_prob DOUBLE PRECISION,
+            bullpen_entry_prob             DOUBLE PRECISION,
+            xgb_hr_delta                   DOUBLE PRECISION,
+            xgb_hr_adjusted                DOUBLE PRECISION,
+            xgb_shadow_active              BOOLEAN,
+            lineup_slot                    TEXT
         )
         """
-    )
+    ))
 
-    # Migrate existing tables missing shadow columns
+    # Safe migration — add columns missing from older schema
     for _col, _dtype in [
-        ("xgb_hr_delta",      "DOUBLE"),
-        ("xgb_hr_adjusted",   "DOUBLE"),
+        ("xgb_hr_delta",      "DOUBLE PRECISION"),
+        ("xgb_hr_adjusted",   "DOUBLE PRECISION"),
         ("xgb_shadow_active", "BOOLEAN"),
         ("lineup_slot",       "TEXT"),
     ]:
         try:
-            conn.execute(f"ALTER TABLE recommendation_logs ADD COLUMN {_col} {_dtype}")
+            conn.execute(text(f"ALTER TABLE recommendation_logs ADD COLUMN {_col} {_dtype}"))
         except Exception:
             pass  # Column already exists
 
@@ -300,142 +397,107 @@ def ensure_recommendation_logs_table(conn) -> None:
 def insert_recommendation_logs(conn, df: pd.DataFrame) -> None:
     if df is None or df.empty:
         return
-
     ensure_recommendation_logs_table(conn)
-    conn.register("recommendation_logs_df", df)
-    conn.execute(
-        """
-        INSERT INTO recommendation_logs
-        SELECT * FROM recommendation_logs_df
-        """
-    )
-    conn.unregister("recommendation_logs_df")
+    _bulk_insert(conn, "recommendation_logs", df)
 
-def update_bet_result(
-    conn: duckdb.DuckDBPyConnection,
-    bet_id: int,
-    result: str,
-    profit: float,
-) -> None:
-    conn.execute(
-        """
-        UPDATE bets
-        SET result = ?, profit = ?
-        WHERE bet_id = ?
-        """,
-        [result, profit, bet_id],
-    )
+
+# ---------------------------------------------------------------------------
+# Game outcomes
+# ---------------------------------------------------------------------------
 
 def ensure_game_outcomes_table(conn) -> None:
-    conn.execute(
+    conn.execute(text(
         """
         CREATE TABLE IF NOT EXISTS game_outcomes (
-            graded_at TEXT,
-            game_pk TEXT,
-            away_team TEXT,
-            home_team TEXT,
-            away_score INTEGER,
-            home_score INTEGER,
-            status TEXT,
+            graded_at      TEXT,
+            game_pk        TEXT,
+            away_team      TEXT,
+            home_team      TEXT,
+            away_score     INTEGER,
+            home_score     INTEGER,
+            status         TEXT,
             outcome_source TEXT
         )
         """
-    )
+    ))
 
 
 def insert_game_outcomes(conn, df: pd.DataFrame) -> None:
     if df is None or df.empty:
         return
-
     ensure_game_outcomes_table(conn)
-    conn.register("game_outcomes_df", df)
-    conn.execute(
-        """
-        INSERT INTO game_outcomes
-        SELECT * FROM game_outcomes_df
-        """
-    )
-    conn.unregister("game_outcomes_df")
+    _bulk_insert(conn, "game_outcomes", df)
+
 
 def read_game_outcomes(conn) -> pd.DataFrame:
     ensure_game_outcomes_table(conn)
-    return conn.execute(
-        """
-        SELECT *
-        FROM game_outcomes
-        ORDER BY graded_at DESC
-        """
-    ).df()
+    return pd.read_sql(
+        text("SELECT * FROM game_outcomes ORDER BY graded_at DESC"),
+        conn,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Batter prop outcomes
+# ---------------------------------------------------------------------------
 
 def ensure_batter_prop_outcomes_table(conn) -> None:
-    conn.execute(
+    conn.execute(text(
         """
         CREATE TABLE IF NOT EXISTS batter_prop_outcomes (
-            created_at TEXT,
-            graded_at TEXT,
-            game_pk TEXT,
-            away_team TEXT,
-            home_team TEXT,
-            slot TEXT,
-            batter_name TEXT,
-            pitcher_name TEXT,
-            market TEXT,
-            fair_hr_odds DOUBLE,
-            book_hr_odds DOUBLE,
-            adjusted_edge DOUBLE,
-            confidence DOUBLE,
+            created_at         TEXT,
+            graded_at          TEXT,
+            game_pk            TEXT,
+            away_team          TEXT,
+            home_team          TEXT,
+            slot               TEXT,
+            batter_name        TEXT,
+            pitcher_name       TEXT,
+            market             TEXT,
+            fair_hr_odds       DOUBLE PRECISION,
+            book_hr_odds       DOUBLE PRECISION,
+            adjusted_edge      DOUBLE PRECISION,
+            confidence         DOUBLE PRECISION,
             recommendation_tier TEXT,
-            realized_hit INTEGER,
-            realized_hr INTEGER,
-            realized_tb2p INTEGER,
-            grade_status TEXT,
-            outcome_source TEXT
+            realized_hit       INTEGER,
+            realized_hr        INTEGER,
+            realized_tb2p      INTEGER,
+            grade_status       TEXT,
+            outcome_source     TEXT
         )
         """
-    )
+    ))
 
 
 def insert_batter_prop_outcomes(conn, df: pd.DataFrame) -> None:
     if df is None or df.empty:
         return
-
     ensure_batter_prop_outcomes_table(conn)
-    conn.register("batter_prop_outcomes_df", df)
-    conn.execute(
-        """
-        INSERT INTO batter_prop_outcomes
-        SELECT * FROM batter_prop_outcomes_df
-        """
-    )
-    conn.unregister("batter_prop_outcomes_df")
+    _bulk_insert(conn, "batter_prop_outcomes", df)
+
 
 def read_batter_prop_outcomes(conn) -> pd.DataFrame:
     ensure_batter_prop_outcomes_table(conn)
-    return conn.execute(
-        """
-        SELECT *
-        FROM batter_prop_outcomes
-        ORDER BY graded_at DESC, created_at DESC
-        """
-    ).df()
+    return pd.read_sql(
+        text("SELECT * FROM batter_prop_outcomes ORDER BY graded_at DESC, created_at DESC"),
+        conn,
+    )
+
 
 def replace_batter_prop_outcomes(conn, df: pd.DataFrame) -> None:
     if df is None or df.empty:
         return
-
     ensure_batter_prop_outcomes_table(conn)
-    conn.execute("DELETE FROM batter_prop_outcomes")
-    conn.register("batter_prop_outcomes_replace_df", df)
-    conn.execute(
-        """
-        INSERT INTO batter_prop_outcomes
-        SELECT * FROM batter_prop_outcomes_replace_df
-        """
-    )
-    conn.unregister("batter_prop_outcomes_replace_df")
+    conn.execute(text("DELETE FROM batter_prop_outcomes"))
+    _bulk_insert(conn, "batter_prop_outcomes", df)
+
+
+# ---------------------------------------------------------------------------
+# Upcoming HR props
+# ---------------------------------------------------------------------------
 
 def ensure_upcoming_hr_props_table(conn) -> None:
-    conn.execute(
+    conn.execute(text(
         """
         CREATE TABLE IF NOT EXISTS upcoming_hr_props (
             fetched_at           TEXT,
@@ -448,20 +510,21 @@ def ensure_upcoming_hr_props_table(conn) -> None:
             player_name_raw      TEXT,
             player_name          TEXT,
             odds_american        INTEGER,
-            line                 DOUBLE,
-            implied_prob         DOUBLE,
-            model_hr_prob        DOUBLE,
+            line                 DOUBLE PRECISION,
+            implied_prob         DOUBLE PRECISION,
+            model_hr_prob        DOUBLE PRECISION,
             model_hr_prob_source TEXT,
-            edge                 DOUBLE
+            edge                 DOUBLE PRECISION
         )
         """
-    )
+    ))
+
     for _col, _dtype in [
         ("model_hr_prob_source", "TEXT"),
-        ("edge",                 "DOUBLE"),
+        ("edge",                 "DOUBLE PRECISION"),
     ]:
         try:
-            conn.execute(f"ALTER TABLE upcoming_hr_props ADD COLUMN {_col} {_dtype}")
+            conn.execute(text(f"ALTER TABLE upcoming_hr_props ADD COLUMN {_col} {_dtype}"))
         except Exception:
             pass  # Column already exists
 
@@ -470,27 +533,28 @@ 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")
+    # Select only the expected columns in the correct order
+    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",
+    ]
+    present = [c for c in log_cols if c in df.columns]
+    _bulk_insert(conn, "upcoming_hr_props", df[present])
 
 
 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()
+    return pd.read_sql(
+        text("SELECT * FROM upcoming_hr_props ORDER BY fetched_at DESC"),
+        conn,
+    )
+
 
+# ---------------------------------------------------------------------------
+# Batter prop audit view
+# ---------------------------------------------------------------------------
 
 def read_batter_prop_audit_view(conn) -> pd.DataFrame:
     ensure_batter_prop_outcomes_table(conn)
@@ -519,4 +583,4 @@ def read_batter_prop_audit_view(conn) -> pd.DataFrame:
     FROM batter_prop_outcomes
     ORDER BY graded_at DESC, created_at DESC
     """
-    return conn.execute(query).df()
+    return pd.read_sql(text(query), conn)

database/remote_db.py

@@ -4,24 +4,36 @@ import os
 
 from sqlalchemy import create_engine
 
+# ---------------------------------------------------------------------------
+# Lazy engine — built on first get_connection() call, not at import time.
+# This allows db.py (and other modules) to import remote_db safely even when
+# DATABASE_URL is not yet in the environment at import time.
+# RuntimeError is raised when get_connection() is first called without a URL.
+# ---------------------------------------------------------------------------
 
-DATABASE_URL = os.getenv("DATABASE_URL")
+_engine = None
 
-if not DATABASE_URL:
-    raise RuntimeError("DATABASE_URL is not set")
 
-DATABASE_URL = DATABASE_URL.strip()
+def _get_engine():
+    global _engine
+    if _engine is not None:
+        return _engine
 
-# Cockroach needs the cockroachdb dialect for SQLAlchemy
-if DATABASE_URL.startswith("postgresql://"):
-    DATABASE_URL = "cockroachdb://" + DATABASE_URL[len("postgresql://"):]
+    database_url = os.getenv("DATABASE_URL", "").strip()
+    if not database_url:
+        raise RuntimeError("DATABASE_URL is not set")
 
-engine = create_engine(
-    DATABASE_URL,
-    pool_pre_ping=True,
-    pool_recycle=300,
-)
+    # CockroachDB requires the cockroachdb:// dialect for SQLAlchemy
+    if database_url.startswith("postgresql://"):
+        database_url = "cockroachdb://" + database_url[len("postgresql://"):]
+
+    _engine = create_engine(
+        database_url,
+        pool_pre_ping=True,
+        pool_recycle=300,
+    )
+    return _engine
 
 
 def get_connection():
-    return engine.connect()
+    return _get_engine().connect()

evaluation/xgb_hr_evaluation.py

@@ -10,6 +10,7 @@ READ-ONLY relative to the simulator and production probabilities.
 from __future__ import annotations
 
 import pandas as pd
+from sqlalchemy import text
 
 
 # ---------------------------------------------------------------------------
@@ -50,8 +51,7 @@ def _load_evaluation_df(conn) -> pd.DataFrame:
       AND ro.realized_hr IS NOT NULL
     """
     try:
-        df = conn.execute(query).df()
-        return df
+        return pd.read_sql(text(query), conn)
     except Exception:
         return pd.DataFrame()
 

requirements.txt

@@ -3,7 +3,7 @@ pandas==2.2.3
 numpy==2.1.2
 plotly==5.24.1
 requests==2.32.3
-duckdb==1.1.2
+xgboost
 pyarrow==18.0.0
 scikit-learn==1.5.2
 torch==2.4.1