Update config/settings.py

config/settings.py

@@ -1,59 +1,374 @@
 from __future__ import annotations
 
-import os
-
-APP_TITLE = "WBC Analytics Assistant"
-REFRESH_TTL_SECONDS = 30
-
-DUCKDB_PATH = "data/wbc.duckdb"
-
-DEFAULT_EDGE_THRESHOLD = 0.05
-DEFAULT_CONFIDENCE_THRESHOLD = 0.70
-
-STATCAST_SEARCH_URL = "https://baseballsavant.mlb.com/statcast_search/csv"
-MLB_SCHEDULE_URL = "https://statsapi.mlb.com/api/v1/schedule"
-MLB_TEAMS_URL = "https://statsapi.mlb.com/api/v1/teams"
-MLB_GAME_FEED_URL_TEMPLATE = "https://statsapi.mlb.com/api/v1.1/game/{game_pk}/feed/live"
-
-OPENWEATHER_URL = "https://api.openweathermap.org/data/2.5/weather"
-
-ODDS_SPORT_KEY = "baseball_mlb"
-ODDS_BASE_URL = "https://api.the-odds-api.com/v4"
-ODDS_REGIONS = "us"
-ODDS_FEATURED_MARKETS = "h2h,spreads,totals"
-ODDS_FORMAT = "american"
-
-ODDS_API_KEY = os.getenv("ODDS_API_KEY", "")
-OPENWEATHER_API_KEY = os.getenv("OPENWEATHER_API_KEY", "")
-
-SUPPORTED_BOOKS = [
-    "DraftKings",
-    "FanDuel",
-    "BetMGM",
-    "Caesars",
-    "bet365",
-    "Pinnacle",
-]
-
-WBC_TEAMS = [
-    "Japan",
-    "United States",
-    "Dominican Republic",
-    "Mexico",
-    "Puerto Rico",
-    "Venezuela",
-    "Korea",
-    "Chinese Taipei",
-    "Netherlands",
-    "Cuba",
-    "Australia",
-    "Italy",
-    "Panama",
-    "Colombia",
-    "Czech Republic",
-    "Israel",
-    "Nicaragua",
-    "Great Britain",
-    "Canada",
-    "China",
-]
+from datetime import date, timedelta
+
+import pandas as pd
+import plotly.graph_objects as go
+import streamlit as st
+
+from analytics.bankroll import bankroll_curve, grade_profit, summary_metrics
+from analytics.edge import (
+    american_to_implied_prob,
+    calculate_edge,
+    kelly_fraction,
+    remove_vig_two_way,
+)
+from config.settings import (
+    APP_TITLE,
+    DEFAULT_EDGE_THRESHOLD,
+    ODDS_API_KEY,
+    OPENWEATHER_API_KEY,
+    REFRESH_TTL_SECONDS,
+)
+from data.odds import fetch_featured_odds
+from data.rosters import fetch_mlb_teams
+from data.schedule import fetch_schedule_for_date
+from data.statcast import fetch_statcast_range, normalize_statcast
+from data.weather import fetch_weather_for_venue
+from database.db import (
+    get_connection,
+    insert_bet,
+    next_bet_id,
+    read_table,
+    update_bet_result,
+    upsert_dataframe,
+)
+from utils.helpers import utc_now_iso
+from visualization.batter import create_exit_velocity_chart, create_launch_angle_chart
+from visualization.betting import create_bankroll_chart, create_edge_chart
+from visualization.pitcher import create_pitch_movement_chart
+
+
+st.set_page_config(
+    page_title=APP_TITLE,
+    layout="wide",
+    page_icon="⚾",
+)
+
+st.markdown(
+    """
+    <style>
+    .stApp {
+        background: linear-gradient(180deg, #0b1020 0%, #0f172a 100%);
+    }
+    .block-container {
+        padding-top: 1.25rem;
+        padding-bottom: 2rem;
+        max-width: 1500px;
+    }
+    div[data-testid="stMetric"] {
+        background: rgba(255,255,255,0.04);
+        border: 1px solid rgba(255,255,255,0.08);
+        border-radius: 16px;
+        padding: 12px;
+    }
+    </style>
+    """,
+    unsafe_allow_html=True,
+)
+
+conn = get_connection()
+
+
+@st.cache_data(ttl=REFRESH_TTL_SECONDS)
+def load_schedule_for_today() -> pd.DataFrame:
+    df = fetch_schedule_for_date(date.today().isoformat())
+    if not df.empty:
+        upsert_dataframe(conn, "cached_schedule", df, replace=True)
+    return df
+
+
+@st.cache_data(ttl=REFRESH_TTL_SECONDS)
+def load_odds() -> pd.DataFrame:
+    df = fetch_featured_odds()
+    if not df.empty:
+        upsert_dataframe(conn, "cached_odds", df, replace=True)
+    return df
+
+
+@st.cache_data(ttl=REFRESH_TTL_SECONDS)
+def load_statcast_recent() -> pd.DataFrame:
+    end_date = date.today()
+    start_date = end_date - timedelta(days=7)
+    raw = fetch_statcast_range(start_date.isoformat(), end_date.isoformat())
+    return normalize_statcast(raw)
+
+
+@st.cache_data(ttl=3600)
+def load_teams() -> pd.DataFrame:
+    return fetch_mlb_teams()
+
+
+def load_weather(venue_name: str) -> pd.DataFrame:
+    df = fetch_weather_for_venue(venue_name)
+    if not df.empty:
+        upsert_dataframe(conn, "cached_weather", df, replace=False)
+    return df
+
+
+def render_header() -> None:
+    st.title("⚾ WBC Analytics Assistant")
+    st.caption(
+        "Real-data app using MLB schedule/statcast-style pulls, The Odds API, weather overlays, "
+        "DuckDB storage, and a modern Streamlit UI."
+    )
+    secret_status = []
+    secret_status.append("ODDS_API_KEY ✓" if ODDS_API_KEY else "ODDS_API_KEY missing")
+    secret_status.append(
+        "OPENWEATHER_API_KEY ✓" if OPENWEATHER_API_KEY else "OPENWEATHER_API_KEY missing"
+    )
+    st.caption(" | ".join(secret_status))
+
+
+def render_dashboard() -> None:
+    st.subheader("Live Dashboard")
+
+    schedule_df = load_schedule_for_today()
+    if schedule_df.empty:
+        st.warning("No schedule data returned for today.")
+        return
+
+    st.dataframe(schedule_df, use_container_width=True, hide_index=True)
+
+    venue_name = schedule_df["venue"].dropna().astype(str).iloc[0] if not schedule_df.empty else ""
+    if venue_name:
+        weather_df = load_weather(venue_name)
+        if not weather_df.empty:
+            row = weather_df.iloc[0]
+            c1, c2, c3, c4 = st.columns(4)
+            c1.metric("Venue", row["location_name"])
+            c2.metric("Temp °F", f"{row['temperature_f']:.1f}")
+            c3.metric("Wind mph", f"{row['wind_speed_mph']:.1f}" if pd.notna(row["wind_speed_mph"]) else "N/A")
+            c4.metric("Conditions", row["description"])
+
+    statcast_df = load_statcast_recent()
+    if not statcast_df.empty:
+        col1, col2 = st.columns(2)
+        with col1:
+            st.plotly_chart(create_pitch_movement_chart(statcast_df), use_container_width=True)
+        with col2:
+            st.plotly_chart(create_exit_velocity_chart(statcast_df), use_container_width=True)
+
+
+def render_players() -> None:
+    st.subheader("Player Analytics")
+
+    teams_df = load_teams()
+    if not teams_df.empty:
+        st.dataframe(teams_df, use_container_width=True, hide_index=True)
+
+    statcast_df = load_statcast_recent()
+    if statcast_df.empty:
+        st.info("No recent statcast data available.")
+        return
+
+    col1, col2 = st.columns(2)
+    with col1:
+        st.plotly_chart(create_exit_velocity_chart(statcast_df), use_container_width=True)
+    with col2:
+        st.plotly_chart(create_launch_angle_chart(statcast_df), use_container_width=True)
+
+
+def compute_market_edges(odds_df: pd.DataFrame) -> pd.DataFrame:
+    if odds_df.empty:
+        return odds_df
+
+    out = odds_df.copy()
+    out["implied_prob"] = out["price"].apply(american_to_implied_prob)
+
+    grouped_rows: list[dict] = []
+    for (event_id, sportsbook, market_key), group in out.groupby(["event_id", "sportsbook", "market_key"]):
+        temp = group.copy().reset_index(drop=True)
+
+        if len(temp) == 2:
+            p1, p2 = temp.loc[0, "implied_prob"], temp.loc[1, "implied_prob"]
+            nv1, nv2 = remove_vig_two_way(p1, p2)
+            temp.loc[0, "no_vig_prob"] = nv1
+            temp.loc[1, "no_vig_prob"] = nv2
+        else:
+            total = temp["implied_prob"].sum()
+            temp["no_vig_prob"] = temp["implied_prob"] / total if total else temp["implied_prob"]
+
+        for _, row in temp.iterrows():
+            model_prob = float(row["no_vig_prob"]) + 0.03
+            edge = calculate_edge(model_prob, float(row["no_vig_prob"]))
+            grouped_rows.append(
+                {
+                    **row.to_dict(),
+                    "model_prob": model_prob,
+                    "edge": edge,
+                    "kelly": kelly_fraction(model_prob, int(row["price"])) if pd.notna(row["price"]) else 0.0,
+                }
+            )
+
+    return pd.DataFrame(grouped_rows)
+
+
+def render_betting() -> None:
+    st.subheader("Betting Intelligence")
+
+    odds_df = load_odds()
+    if odds_df.empty:
+        st.warning("No odds returned. Check ODDS_API_KEY or free-tier usage limits.")
+        return
+
+    edges_df = compute_market_edges(odds_df)
+    if edges_df.empty:
+        st.info("No edge rows computed.")
+        return
+
+    top_edges = edges_df.sort_values("edge", ascending=False).head(30)
+
+    c1, c2, c3 = st.columns(3)
+    c1.metric("Markets loaded", len(edges_df))
+    c2.metric("Top edge", f"{top_edges['edge'].max():.2%}")
+    c3.metric("Threshold", f"{DEFAULT_EDGE_THRESHOLD:.0%}")
+
+    st.plotly_chart(create_edge_chart(top_edges), use_container_width=True)
+    st.dataframe(
+        top_edges[
+            [
+                "sportsbook",
+                "home_team",
+                "away_team",
+                "market_key",
+                "outcome_name",
+                "price",
+                "no_vig_prob",
+                "model_prob",
+                "edge",
+                "kelly",
+            ]
+        ],
+        use_container_width=True,
+        hide_index=True,
+    )
+
+
+def render_bet_tracker() -> None:
+    st.subheader("Bet Tracker")
+
+    with st.form("bet_form", clear_on_submit=True):
+        c1, c2, c3 = st.columns(3)
+        sportsbook = c1.text_input("Sportsbook", value="DraftKings")
+        market = c2.text_input("Market", value="h2h")
+        selection = c3.text_input("Selection", value="Example Team")
+
+        c4, c5, c6 = st.columns(3)
+        odds = c4.number_input("Odds", min_value=-1000, max_value=1000, value=120, step=1)
+        stake = c5.number_input("Stake", min_value=0.0, value=10.0, step=1.0)
+        game_id = c6.text_input("Game ID", value="")
+
+        notes = st.text_input("Notes", value="")
+        submitted = st.form_submit_button("Log Bet")
+
+        if submitted:
+            bet_id = next_bet_id(conn)
+            insert_bet(
+                conn=conn,
+                bet_id=bet_id,
+                created_at=utc_now_iso(),
+                sportsbook=sportsbook,
+                market=market,
+                selection=selection,
+                odds=int(odds),
+                stake=float(stake),
+                result="open",
+                profit=0.0,
+                game_id=game_id,
+                notes=notes,
+            )
+            st.success(f"Logged bet #{bet_id}")
+
+    bets_df = read_table(conn, "bets")
+    if bets_df.empty:
+        st.info("No bets logged yet.")
+        return
+
+    st.dataframe(bets_df, use_container_width=True, hide_index=True)
+
+    with st.expander("Grade a bet"):
+        bet_id_to_grade = st.number_input("Bet ID", min_value=1, step=1, value=1)
+        result = st.selectbox("Result", options=["win", "loss"])
+        if st.button("Apply Grade"):
+            row = bets_df[bets_df["bet_id"] == bet_id_to_grade]
+            if row.empty:
+                st.error("Bet ID not found.")
+            else:
+                stake = float(row.iloc[0]["stake"])
+                odds = int(row.iloc[0]["odds"])
+                profit = grade_profit(stake, odds, result)
+                update_bet_result(conn, int(bet_id_to_grade), result, profit)
+                st.success(f"Updated bet #{bet_id_to_grade} to {result}")
+
+    bets_df = read_table(conn, "bets")
+    metrics = summary_metrics(bets_df)
+    c1, c2, c3, c4 = st.columns(4)
+    c1.metric("Graded Bets", metrics["bets"])
+    c2.metric("Profit", f"${metrics['profit']:.2f}")
+    c3.metric("ROI", f"{metrics['roi']:.2%}")
+    c4.metric("Win Rate", f"{metrics['win_rate']:.2%}")
+
+    curve_df = bankroll_curve(bets_df)
+    st.plotly_chart(create_bankroll_chart(curve_df), use_container_width=True)
+
+
+def render_algorithm_breakdown() -> None:
+    st.subheader("Algorithm Breakdown")
+    st.markdown(
+        """
+        ### Data inputs
+        - MLB schedule feed
+        - Baseball Savant statcast search CSV
+        - The Odds API featured odds
+        - OpenWeather venue conditions
+
+        ### Market math
+        1. Convert American odds to implied probability
+        2. Remove vig for 2-way markets
+        3. Compare model probability to no-vig probability
+        4. Report edge and Kelly fraction
+
+        ### Current demo model
+        The current app uses a simple research baseline:
+        - no-vig market probability + fixed model uplift
+        - this keeps the edge pipeline real and testable
+        - later you can replace the uplift with your matchup model output
+
+        ### Persistence
+        - DuckDB stores bets and cached snapshots
+        - all storage remains local to the Space container
+        """
+    )
+
+
+def main() -> None:
+    render_header()
+
+    page = st.sidebar.radio(
+        "Navigation",
+        options=[
+            "Dashboard",
+            "Players",
+            "Betting",
+            "Bet Tracker",
+            "Algorithm Breakdown",
+        ],
+    )
+
+    st.sidebar.caption(f"Refresh TTL: {REFRESH_TTL_SECONDS}s")
+
+    if page == "Dashboard":
+        render_dashboard()
+    elif page == "Players":
+        render_players()
+    elif page == "Betting":
+        render_betting()
+    elif page == "Bet Tracker":
+        render_bet_tracker()
+    else:
+        render_algorithm_breakdown()
+
+
+if __name__ == "__main__":
+    main()