Implement existing simulation in admin page

src/analyze_yahoo.py

@@ -1,5 +1,13 @@
+import json
 import pandas as pd
+from stqdm import stqdm
 from typing import Optional
+from simulate import (
+    calculate_scenario_probabilities,
+    create_simulate_summary,
+    run_simulations,
+)
+from yahoo_client import YahooFantasyClient
 
 
 def calculate_luck(df: pd.DataFrame, as_of_week: Optional[int] = None, include_current: bool = False) -> pd.DataFrame:
@@ -70,3 +78,28 @@ def summarize_remaining_wins_from_matches_map(matches_map):
                 team_remaining_map[n_wins] = prob_list
         remaining_map[team_name] = team_remaining_map
     return remaining_map
+
+
+def analyze_league(league_key: str, yahoo_client: YahooFantasyClient) -> None:
+    df_scores = yahoo_client.full_schedule_dataframe(league_key)
+    league_settings = yahoo_client.parse_league_settings(league_key)
+    name_str = league_settings.name.strip().replace(" ", "_").lower()
+    sim_completed_weeks = league_settings.current_week - 1
+    print(f"{sim_completed_weeks=}")
+    stqdm.pandas()
+    df_sims = run_simulations(
+        df_scores,
+        complete_weeks=sim_completed_weeks,
+        n_sims=10000,
+        n_playoff=league_settings.num_playoff_teams,
+    )
+    df_sim_sum = create_simulate_summary(df_sims)
+    df_sim_sum.to_csv(f"{name_str}_sim_sum.csv")
+
+    scenario_probs = calculate_scenario_probabilities(df_sims)
+    with open(f"{name_str}_scenario_probs.json", "w") as f:
+        json.dump(scenario_probs, f)
+
+    remaining_wins_to_probs_map = summarize_remaining_wins_from_matches_map(scenario_probs)
+    with open(f"{name_str}_remaining_wins_probs.json", "w") as f:
+        json.dump(remaining_wins_to_probs_map, f)

src/pages/99_Admin_Simulation.py

@@ -1,5 +1,7 @@
 import streamlit as st
 
+
+from analyze_yahoo import analyze_league
 from config import DEFAULT_ICON, SEASON
 from shared_page import common_page_config
 
@@ -27,6 +29,8 @@ def get_page():
         user_leagues = get_all_league_settings_with_cache(season=selected_season)
         selected_league = st.selectbox("Select league", user_leagues, format_func=lambda x: x.name)
         st.header(f"{selected_league.name} - {selected_league.season}")
+        if st.button("Analyze League"):
+            analyze_league(selected_league.league_key, st.session_state.yahoo_client)
 
 
 if __name__ == "__main__":

src/simulate.py

@@ -0,0 +1,134 @@
+import numpy as np
+import pandas as pd
+from stqdm import stqdm
+from typing import List, Mapping, MutableMapping, Tuple
+
+
+def simulate_game(team_name: str, mean_points: float, std_points: float) -> float:
+    general_normal = np.round(np.random.normal(mean_points, std_points), 3)
+    return general_normal
+
+
+def simulate_week_matchups(df_week: pd.DataFrame, mean_points: float, std_points: float) -> pd.DataFrame:
+    df_week.loc[:, "team_points"] = df_week.team_name.apply(lambda x: simulate_game(x, mean_points, std_points)).values
+    df_week.loc[:, "max_match"] = df_week.groupby("match_index").team_points.transform("max").values
+    df_week.loc[:, "win_probability"] = ((df_week["team_points"] == df_week["max_match"]) * 1.0).values
+    df_week.drop(columns=["max_match"], inplace=True)
+    return df_week
+
+
+def simulate_remaining_season(df_completed_weeks: pd.DataFrame, df_incomplete_weeks: pd.DataFrame) -> pd.DataFrame:
+    df_comp = df_completed_weeks.copy()
+    df_inc = df_incomplete_weeks.copy()
+
+    mean_points = df_comp.team_points.mean()
+    std_points = df_comp.team_points.std()
+
+    sim_week_list = [
+        simulate_week_matchups(df_week, mean_points, std_points) for (_, df_week) in df_inc.groupby("week")
+    ]
+    df_full_sim = pd.concat([df_comp] + sim_week_list)
+    return df_full_sim
+
+
+def summarize_season(df_sim: pd.DataFrame, n_bye: int, n_playoff: int) -> pd.DataFrame:
+    sim_sum = (
+        df_sim.groupby("team_name")[["win_probability", "team_points"]]
+        .sum()
+        .sort_values(["win_probability", "team_points"], ascending=False)
+    )
+    sim_sum["season_rank"] = range(1, 1 + len(sim_sum))
+    sim_sum["bye"] = (sim_sum["season_rank"] <= n_bye) * 1
+    sim_sum["playoff"] = (sim_sum["season_rank"] <= n_playoff) * 1
+    return sim_sum
+
+
+def finalize_all(df: pd.DataFrame) -> None:
+    df["win_probability"] = (df.groupby(["week", "match_index"]).team_points.transform("max") == df.team_points) * 1
+
+
+def run_simulations(df: pd.DataFrame, complete_weeks: int, n_sims: int, n_playoff: int):
+    if n_playoff == 6:
+        n_bye = 2
+    else:
+        n_bye = 0
+
+    df_comp = df[df.week <= complete_weeks]
+    finalize_all(df_comp)
+    df_inc = df[df.week > complete_weeks]
+    sim_list = []
+    for i in stqdm(range(n_sims)):
+        df_sim = simulate_remaining_season(df_comp, df_inc)
+        sim_sum = summarize_season(df_sim, n_bye, n_playoff)
+        df_simmed = df_sim[df_sim.week > complete_weeks]
+        win_dict = {
+            match_key: df_match.sort_values("team_points").team_name.iloc[-1]
+            for (match_key, df_match) in df_simmed.groupby(["week", "match_index"])
+        }
+        df_wins = pd.DataFrame(win_dict, index=[i])
+        df_melt = (
+            sim_sum.reset_index()[["team_name", "bye", "playoff", "season_rank", "team_points"]]
+            .melt(id_vars="team_name")
+            .sort_values(["variable", "team_name"])
+        )
+        df_team_sum = pd.DataFrame(
+            {x[0]: x[1] for x in df_melt.apply(lambda r: [(r.variable, r.team_name), r.value], axis=1).values},
+            index=[i],
+        )
+        df_sim_result = df_team_sum.join(df_wins)
+        sim_list.append(df_sim_result)
+    df_all_sims = pd.concat(sim_list)
+    return df_all_sims
+
+
+def create_simulate_summary(sims: pd.DataFrame) -> pd.DataFrame:
+    df_sim_sum = pd.DataFrame()
+    df_sim_sum["bye"] = sims.bye.mean()
+    df_sim_sum["playoffs"] = sims.playoff.mean()
+
+    return (
+        df_sim_sum[["bye", "playoffs"]]
+        .sort_values(["playoffs", "bye"], ascending=False)
+        .map(lambda n: "{:,.2%}".format(n))
+    )
+
+
+def get_matches_by_team_from_sims_df(sims: pd.DataFrame) -> Mapping[str, List[Tuple[int]]]:
+    team_matches: MutableMapping[str, List[Tuple[int]]] = {}
+    for col in sims.columns:
+        if isinstance(col[0], (int, float)):
+            teams_in_match = sims[col].unique()
+            for team in teams_in_match:
+                if team in team_matches:
+                    team_matches[team].append(col)
+                else:
+                    team_matches[team] = [col]
+
+    return team_matches
+
+
+def calc_wins_on_scenario(team_name, match_cols_list, sims_df):
+    n_matches = len(match_cols_list)
+    scenario_bye_playoff_results = {}
+    for i in range(2**n_matches):
+        binary_scenario = format(i, f"0{n_matches}b")
+        filters = []
+        for scenario, match in zip(binary_scenario, match_cols_list):
+            match_filter = (sims_df[match] == team_name) == bool(int(scenario))
+            filters.append(match_filter)
+        filtered_sims = sims_df[pd.DataFrame(filters).all()]
+        playoff_odds = filtered_sims["playoff"][team_name].mean()
+        bye_odds = filtered_sims["bye"][team_name].mean()
+        scenario_bye_playoff_results[binary_scenario] = np.nan_to_num(
+            [len(filtered_sims), round(playoff_odds, 3), round(bye_odds, 3)]
+        ).tolist()
+
+    return scenario_bye_playoff_results
+
+
+def calculate_scenario_probabilities(sims: pd.DataFrame) -> Mapping:
+    remaining_matches = get_matches_by_team_from_sims_df(sims)
+    team_scenario_probs = {
+        team: calc_wins_on_scenario(team, matches, sims) for team, matches in remaining_matches.items()
+    }
+    return team_scenario_probs