Update app.py

app.py

@@ -1,551 +1,374 @@
-import streamlit as st
+from __future__ import annotations
+
+from datetime import date, timedelta
+
 import pandas as pd
-import numpy as np
-import plotly.express as px
 import plotly.graph_objects as go
-import torch
-import torch.nn as nn
-import requests
-import time
-from datetime import datetime
+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
 
-# -------------------------------------------------
-# APP CONFIG
-# -------------------------------------------------
 
 st.set_page_config(
-    page_title="WBC Analytics Assistant",
+    page_title=APP_TITLE,
     layout="wide",
-    page_icon="⚾"
+    page_icon="⚾",
 )
 
-# -------------------------------------------------
-# GLOBAL SETTINGS
-# -------------------------------------------------
-
-REFRESH_RATE = 30
-
-SPORTSBOOKS = [
-    "DraftKings",
-    "FanDuel",
-    "BetMGM",
-    "Caesars",
-    "Bet365",
-    "Pinnacle"
-]
-
-# -------------------------------------------------
-# DARK UI STYLE
-# -------------------------------------------------
-
-st.markdown("""
-<style>
-
-body {
-background-color: #0e1117;
-}
-
-.stApp {
-background-color: #0e1117;
-color: white;
-}
-
-h1,h2,h3 {
-color:white;
-}
-
-.card{
-background-color:#161b22;
-padding:20px;
-border-radius:10px;
-box-shadow:0px 0px 10px rgba(0,0,0,0.6);
-}
-
-</style>
-""", unsafe_allow_html=True)
-
-# -------------------------------------------------
-# DATA INGESTION
-# -------------------------------------------------
-
-def fetch_statcast():
-
-    df = pd.DataFrame({
-        "velocity": np.random.normal(95,3,500),
-        "spin_rate": np.random.normal(2300,200,500),
-        "vertical_break": np.random.normal(15,4,500),
-        "horizontal_break": np.random.normal(-8,4,500),
-        "exit_velocity": np.random.normal(92,5,500),
-        "launch_angle": np.random.normal(15,10,500),
-        "bat_speed": np.random.normal(72,4,500)
-    })
-
-    return df
-
-
-def fetch_odds():
-
-    odds = np.random.randint(-150,200,len(SPORTSBOOKS))
-
-    prob = []
-
-    for o in odds:
-
-        if o > 0:
-            prob.append(100/(o+100))
-        else:
-            prob.append(abs(o)/(abs(o)+100))
-
-    return pd.DataFrame({
-        "sportsbook":SPORTSBOOKS,
-        "odds":odds,
-        "prob":prob
-    })
-
-# -------------------------------------------------
-# EDGE + VIG REMOVAL
-# -------------------------------------------------
-
-def remove_vig(probs):
-
-    total = sum(probs)
-
-    return [p/total for p in probs]
-
-
-def calculate_edge(model_prob, market_prob):
-
-    return model_prob - market_prob
-
-
-def kelly(edge, odds):
-
-    if odds > 0:
-        b = odds/100
-    else:
-        b = 100/abs(odds)
-
-    return edge / b
-
-
-# -------------------------------------------------
-# PITCH AI MODEL
-# -------------------------------------------------
-
-class PitchModel(nn.Module):
-
-    def __init__(self):
-
-        super().__init__()
-
-        self.net = nn.Sequential(
-            nn.Linear(4,32),
-            nn.ReLU(),
-            nn.Linear(32,32),
-            nn.ReLU(),
-            nn.Linear(32,3),
-            nn.Sigmoid()
-        )
-
-    def forward(self,x):
-
-        return self.net(x)
-
-
-model = PitchModel()
-
-
-def predict_pitch(velocity, spin, vbreak, hbreak):
-
-    x = torch.tensor([[velocity,spin,vbreak,hbreak]],dtype=torch.float32)
-
-    out = model(x).detach().numpy()[0]
-
-    return {
-        "strike":out[0],
-        "whiff":out[1],
-        "damage":out[2]
+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,
+)
 
-# -------------------------------------------------
-# MONTE CARLO SIMULATION
-# -------------------------------------------------
-
-def simulate_game():
-
-    home = []
-    away = []
-
-    for i in range(10000):
-
-        home_runs = np.random.poisson(4.5)
-        away_runs = np.random.poisson(4.2)
-
-        home.append(home_runs)
-        away.append(away_runs)
-
-    return home, away
+conn = get_connection()
 
 
-# -------------------------------------------------
-# BET TRACKER
-# -------------------------------------------------
+@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
 
-if "bets" not in st.session_state:
-    st.session_state.bets = []
 
-def log_bet(book, odds, stake, bet):
+@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.session_state.bets.append({
-        "date":datetime.now(),
-        "sportsbook":book,
-        "odds":odds,
-        "stake":stake,
-        "bet":bet,
-        "result":"open"
-    })
 
+@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)
 
-def settle_bet(index,result):
 
-    st.session_state.bets[index]["result"] = result
+@st.cache_data(ttl=3600)
+def load_teams() -> pd.DataFrame:
+    return fetch_mlb_teams()
 
 
-# -------------------------------------------------
-# VISUALIZATIONS
-# -------------------------------------------------
+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 pitch_movement_chart(df):
 
-    fig = px.scatter(
-        df,
-        x="horizontal_break",
-        y="vertical_break",
-        title="Pitch Movement"
+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."
     )
-
-    return fig
-
-
-def velocity_distribution(df):
-
-    fig = px.histogram(
-        df,
-        x="velocity",
-        title="Velocity Distribution"
+    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))
 
-    return fig
 
+def render_dashboard() -> None:
+    st.subheader("Live Dashboard")
 
-def exit_velocity_chart(df):
+    schedule_df = load_schedule_for_today()
+    if schedule_df.empty:
+        st.warning("No schedule data returned for today.")
+        return
 
-    fig = px.histogram(
-        df,
-        x="exit_velocity",
-        title="Exit Velocity Distribution"
-    )
-
-    return fig
+    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"])
 
-def launch_angle_chart(df):
+    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)
 
-    fig = px.histogram(
-        df,
-        x="launch_angle",
-        title="Launch Angle Distribution"
-    )
 
-    return fig
+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)
 
-def spray_chart():
+    statcast_df = load_statcast_recent()
+    if statcast_df.empty:
+        st.info("No recent statcast data available.")
+        return
 
-    x = np.random.normal(0,120,200)
-    y = np.random.normal(150,40,200)
+    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)
 
-    fig = px.scatter(x=x,y=y,title="Spray Chart")
 
-    return fig
+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)
 
-def edge_chart(df):
+    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)
 
-    fig = px.bar(
-        df,
-        x="sportsbook",
-        y="edge",
-        title="Edge by Sportsbook"
+        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,
     )
 
-    return fig
-
-
-def bankroll_chart():
-
-    profits = []
-    profit = 0
-
-    for b in st.session_state.bets:
-
-        if b["result"]=="win":
-
-            if b["odds"]>0:
-                profit += b["stake"]*(b["odds"]/100)
 
+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:
-                profit += b["stake"]*(100/abs(b["odds"]))
-
-        elif b["result"]=="loss":
-
-            profit -= b["stake"]
-
-        profits.append(profit)
-
-    fig = px.line(
-        x=list(range(len(profits))),
-        y=profits,
-        title="Bankroll Growth"
+                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
+        """
     )
 
-    return fig
-
-
-# -------------------------------------------------
-# SIDEBAR NAV
-# -------------------------------------------------
-
-st.sidebar.title("⚾ WBC Assistant")
-
-page = st.sidebar.selectbox(
-
-    "Navigation",
-
-    [
-        "Live Dashboard",
-        "Matchup Analyzer",
-        "Player Analytics",
-        "Betting Intelligence",
-        "Bet Tracker",
-        "Simulation Center",
-        "Algorithm Breakdown"
-    ]
-)
-
-# -------------------------------------------------
-# LIVE DASHBOARD
-# -------------------------------------------------
-
-if page == "Live Dashboard":
-
-    st.title("Live Statcast Dashboard")
 
-    df = fetch_statcast()
+def main() -> None:
+    render_header()
 
-    col1,col2 = st.columns(2)
-
-    with col1:
-        st.plotly_chart(pitch_movement_chart(df),use_container_width=True)
-
-    with col2:
-        st.plotly_chart(velocity_distribution(df),use_container_width=True)
-
-    st.plotly_chart(exit_velocity_chart(df),use_container_width=True)
-
-
-# -------------------------------------------------
-# MATCHUP ANALYZER
-# -------------------------------------------------
-
-elif page == "Matchup Analyzer":
-
-    st.title("Pitch-by-Pitch Matchup Model")
-
-    velocity = st.slider("Velocity",80,102,95)
-    spin = st.slider("Spin Rate",1800,3000,2300)
-    vbreak = st.slider("Vertical Break",-20,25,15)
-    hbreak = st.slider("Horizontal Break",-20,20,-8)
-
-    result = predict_pitch(velocity,spin,vbreak,hbreak)
-
-    col1,col2,col3 = st.columns(3)
-
-    col1.metric("Strike Probability",round(result["strike"],2))
-    col2.metric("Whiff Probability",round(result["whiff"],2))
-    col3.metric("Damage Probability",round(result["damage"],2))
-
-
-# -------------------------------------------------
-# PLAYER ANALYTICS
-# -------------------------------------------------
-
-elif page == "Player Analytics":
-
-    st.title("Player Analytics")
-
-    df = fetch_statcast()
-
-    col1,col2 = st.columns(2)
-
-    with col1:
-        st.plotly_chart(exit_velocity_chart(df),use_container_width=True)
-
-    with col2:
-        st.plotly_chart(launch_angle_chart(df),use_container_width=True)
-
-    st.plotly_chart(spray_chart(),use_container_width=True)
-
-
-# -------------------------------------------------
-# BETTING INTELLIGENCE
-# -------------------------------------------------
-
-elif page == "Betting Intelligence":
-
-    st.title("Betting Intelligence")
-
-    odds_df = fetch_odds()
-
-    model_prob = np.random.uniform(0.45,0.65)
-
-    odds_df["edge"] = odds_df["prob"].apply(
-        lambda p: calculate_edge(model_prob,p)
+    page = st.sidebar.radio(
+        "Navigation",
+        options=[
+            "Dashboard",
+            "Players",
+            "Betting",
+            "Bet Tracker",
+            "Algorithm Breakdown",
+        ],
     )
 
-    st.dataframe(odds_df)
-
-    st.plotly_chart(edge_chart(odds_df),use_container_width=True)
-
-
-# -------------------------------------------------
-# BET TRACKER
-# -------------------------------------------------
-
-elif page == "Bet Tracker":
-
-    st.title("Bet Tracker")
-
-    col1,col2,col3,col4 = st.columns(4)
-
-    with col1:
-        book = st.selectbox("Sportsbook",SPORTSBOOKS)
-
-    with col2:
-        odds = st.number_input("Odds")
-
-    with col3:
-        stake = st.number_input("Stake")
-
-    with col4:
-        bet = st.text_input("Bet Type")
-
-    if st.button("Log Bet"):
-        log_bet(book,odds,stake,bet)
+    st.sidebar.caption(f"Refresh TTL: {REFRESH_TTL_SECONDS}s")
 
-    if len(st.session_state.bets) > 0:
-
-        bets_df = pd.DataFrame(st.session_state.bets)
-
-        st.dataframe(bets_df)
-
-        st.plotly_chart(bankroll_chart(),use_container_width=True)
-
-
-# -------------------------------------------------
-# SIMULATION CENTER
-# -------------------------------------------------
-
-elif page == "Simulation Center":
-
-    st.title("Monte Carlo Game Simulation")
-
-    home,away = simulate_game()
-
-    fig1 = px.histogram(home,nbins=15,title="Home Run Distribution")
-    fig2 = px.histogram(away,nbins=15,title="Away Run Distribution")
-
-    st.plotly_chart(fig1,use_container_width=True)
-    st.plotly_chart(fig2,use_container_width=True)
-
-
-# -------------------------------------------------
-# ALGORITHM BREAKDOWN
-# -------------------------------------------------
-
-elif page == "Algorithm Breakdown":
-
-    st.title("Algorithm Breakdown")
-
-    st.markdown("""
-
-### Data Sources
-
-Statcast pitch data  
-Sportsbook odds APIs  
-Weather data  
-
----
-
-### Feature Engineering
-
-EV90  
-Barrel rate  
-Pitch movement  
-Spin efficiency  
-Bat speed  
-Attack angle  
-
----
-
-### Pitch-by-Pitch AI Model
-
-Neural network predicts:
-
-Strike probability  
-Whiff probability  
-Damage probability  
-
----
-
-### Matchup Engine
-
-Compares pitcher arsenal vs hitter strengths.
-
----
-
-### Simulation Engine
-
-10,000 Monte Carlo simulations per game.
-
----
-
-### Edge Detection
-
-Edge = Model Probability − Market Probability
-
----
-
-### Bet Sizing
-
-Kelly Criterion.
-
----
-
-### Continuous Training
-
-Historical Statcast training  
-Weighted recent data retraining  
-Reinforcement learning updates  
-
-""")
-
-# -------------------------------------------------
-# AUTO REFRESH
-# -------------------------------------------------
-
-st.caption(f"Auto refresh every {REFRESH_RATE} seconds")
+    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()
 
-time.sleep(REFRESH_RATE)
 
-st.experimental_rerun()
+if __name__ == "__main__":
+    main()