import streamlit as st st.set_page_config(layout="wide") import numpy as np import pandas as pd import pymongo import time from datetime import datetime, timedelta from scipy import stats @st.cache_resource def init_conn(): uri = st.secrets['mongo_uri'] client = pymongo.MongoClient(uri, retryWrites=True, serverSelectionTimeoutMS=500000) db = client["League_of_Legends_Database"] return db @st.cache_resource(ttl = 300) def init_data(): current_date = datetime.now() collection = db["gamelogs"] max_date = current_date - timedelta(days=1) min_date = current_date - timedelta(days=365) team_names = collection.distinct("teamname") player_names = collection.distinct("playername") return team_names, player_names, min_date, max_date db = init_conn() team_names, player_names, min_date, max_date = init_data() display_formats = {'wKill%': '{:.2%}', 'wDeath%': '{:.2%}', 'wAssist%': '{:.2%}', 'lKill%': '{:.2%}', 'lDeath%': '{:.2%}', 'lAssist%': '{:.2%}', 'Over %': '{:.2%}', 'Under %': '{:.2%}'} leagues = ['AL', 'CBLOL', 'GLL', 'HM', 'LCK', 'LCS', 'LEC', 'LFL', 'LLA', 'LPL', 'LPLOL', 'LVP SL', 'MSI', 'PCS', 'PGN', 'PRM', 'TCL', 'VCS', 'LTAN', 'LTAS', 'LLA', 'LPL', 'LPLOL', 'LVP SL', 'MSI', 'PCS', 'PGN', 'PRM', 'TCL', 'VCS', 'LTAN', 'LTAS'] # Create sidebar container for options with st.sidebar: st.header("Team Analysis Options") # Date filtering options st.subheader("Date Range") date_filter = st.radio( "Select Date Range", ["Last Year", "Custom Range"] ) if date_filter == "Last Year": end_date = max_date start_date = (end_date - timedelta(days=365)) else: col1, col2 = st.columns(2) with col1: start_date = st.date_input( "Start Date", value=max_date.date() - timedelta(days=30), min_value=min_date.date(), max_value=max_date.date() ) with col2: end_date = st.date_input( "End Date", value=max_date.date(), min_value=min_date.date(), max_value=max_date.date() ) # Date filtering options st.subheader("Data Type") data_type = st.radio( "Select Data Type", ["Team", "Player"] ) col1, col2 = st.columns(2) with col1: if data_type == "Player": selected_players = st.multiselect( "Select Players", options=player_names ) else: selected_team = st.selectbox( "Select Team", options=team_names, index=team_names.index("T1") if "T1" in team_names else 0 ) with col2: selected_opponent = st.selectbox( "Select Opponent", options=team_names, index=team_names.index("T1") if "T1" in team_names else 0 ) st.subheader("Prediction Settings") num_games = st.selectbox( "How many games to simulate?", options=["1", "2", "3", "4", "5"], index=0 ) # Convert BO format to number of games game_count = int(num_games[0]) # Create lists to store settings for each game win_loss_settings = [] game_settings_list = [] kill_predictions = [] death_predictions = [] # Create a tab for each game game_tabs = st.tabs([f"Game {i+1}" for i in range(game_count)]) for game_num, game_tab in enumerate(game_tabs, 1): with game_tab: win_loss_settings.append(st.selectbox( f"Game {game_num} Win/Loss", options=["Win", "Loss"], index=0, key=f"win_loss_{game_num}" )) game_setting = st.selectbox( f"Game {game_num} Prediction Type", options=["Average", "Predict"], index=0, key=f"game_settings_{game_num}" ) if game_setting == "Average": kill_predictions.append(0) death_predictions.append(0) else: col1, col2 = st.columns(2) with col1: kill_predictions.append(st.number_input( f"Game {game_num} Predicted Team Kills", min_value=1, max_value=100, value=20, key=f"kills_{game_num}" )) with col2: death_predictions.append(st.number_input( f"Game {game_num} Predicted Team Deaths", min_value=1, max_value=100, value=5, key=f"deaths_{game_num}" )) @st.cache_data(ttl = 60) def simulate_stats(row, num_sims=1000): """Simulate stats using normal distribution""" # Using coefficient of variation of 0.3 to generate reasonable standard deviations cv = 0.3 percentiles = [10, 25, 50, 75, 90] results = {} for stat in ['Kill_Proj', 'Death_Proj', 'Assist_Proj', 'CS_Proj']: mean = row[stat] std = mean * cv # Using coefficient of variation to determine std sims = stats.norm.rvs(loc=mean, scale=std, size=num_sims) # Ensure no negative values sims = np.maximum(sims, 0) results[stat] = np.percentile(sims, percentiles) return pd.Series(results) @st.cache_data(ttl = 60) def init_team_data(game_count, team, opponent, win_loss_settings, kill_predictions, death_predictions, start_date, end_date): game_count = game_count overall_team_data = pd.DataFrame(columns = ['playername', 'teamname', 'position', 'Kill_Proj', 'Death_Proj', 'Assist_Proj', 'CS_Proj']) # Convert date objects to datetime strings in the correct format start_datetime = datetime.combine(start_date, datetime.min.time()).strftime("%Y-%m-%d %H:%M:%S") end_datetime = datetime.combine(end_date, datetime.max.time()).strftime("%Y-%m-%d %H:%M:%S") collection = db["gamelogs"] cursor = collection.find({"teamname": team, "date": {"$gte": start_datetime, "$lte": end_datetime}}) raw_display = pd.DataFrame(list(cursor)) cursor = collection.find({"date": {"$gte": start_datetime, "$lte": end_datetime}}) raw_opponent = pd.DataFrame(list(cursor)) tables_to_loop = [raw_display, raw_opponent] for loop in range(len(tables_to_loop)): tables = tables_to_loop[loop] calc_columns = ['kills', 'deaths', 'assists', 'total_cs'] league_pos_win_stats = {} league_pos_loss_stats = {} Opponent_pos_win_allowed_stats = {} Opponent_pos_loss_allowed_stats = {} playername_win_stats = {} playername_loss_stats = {} teamname_win_stats = {} teamname_loss_stats = {} if loop == 0: for stats in calc_columns: playername_win_stats[stats] = tables[tables['result'] == 1].groupby(['playername'])[stats].mean().to_dict() playername_loss_stats[stats] = tables[tables['result'] == 0].groupby(['playername'])[stats].mean().to_dict() teamname_win_stats[stats] = tables[(tables['result'] == 1) & (tables['position'] == 'team')].groupby(['teamname'])[stats].mean().to_dict() teamname_loss_stats[stats] = tables[(tables['result'] == 0) & (tables['position'] == 'team')].groupby(['teamname'])[stats].mean().to_dict() for stat in calc_columns: column_name = f'playername_avg_{stat}_win' tables[column_name] = tables.apply( lambda row: playername_win_stats[stat].get(row['playername'], 0), axis=1 ) column_name = f'playername_avg_{stat}_loss' tables[column_name] = tables.apply( lambda row: playername_loss_stats[stat].get(row['playername'], 0), axis=1 ) column_name = f'teamname_avg_{stat}_win' tables[column_name] = tables.apply( lambda row: teamname_win_stats[stat].get(row['teamname'], 0), axis=1 ) column_name = f'teamname_avg_{stat}_loss' tables[column_name] = tables.apply( lambda row: teamname_loss_stats[stat].get(row['teamname'], 0), axis=1 ) tables['playername_avg_kill_share_win'] = tables['playername_avg_kills_win'] / tables['teamname_avg_kills_win'] tables['playername_avg_death_share_win'] = tables['playername_avg_deaths_win'] / tables['teamname_avg_deaths_win'] tables['playername_avg_assist_share_win'] = tables['playername_avg_assists_win'] / tables['teamname_avg_kills_win'] tables['playername_avg_cs_share_win'] = tables['playername_avg_total_cs_win'] / tables['teamname_avg_total_cs_win'] tables['playername_avg_kill_share_loss'] = tables['playername_avg_kills_loss'] / tables['teamname_avg_kills_loss'] tables['playername_avg_death_share_loss'] = tables['playername_avg_deaths_loss'] / tables['teamname_avg_deaths_loss'] tables['playername_avg_assist_share_loss'] = tables['playername_avg_assists_loss'] / tables['teamname_avg_kills_loss'] tables['playername_avg_cs_share_loss'] = tables['playername_avg_total_cs_loss'] / tables['teamname_avg_total_cs_loss'] player_tables = tables else: for stats in calc_columns: league_pos_win_stats[stats] = { league: group.groupby('position')[stats].mean().to_dict() for league, group in tables[tables['result'] == 1].groupby('league') } league_pos_loss_stats[stats] = { league: group.groupby('position')[stats].mean().to_dict() for league, group in tables[tables['result'] == 0].groupby('league') } Opponent_pos_win_allowed_stats[stats] = { opponent: group.groupby('position')[stats].mean().to_dict() for opponent, group in tables[tables['result'] == 1].groupby('Opponent') } Opponent_pos_loss_allowed_stats[stats] = { opponent: group.groupby('position')[stats].mean().to_dict() for opponent, group in tables[tables['result'] == 0].groupby('Opponent') } for stat in calc_columns: column_name = f'league_pos_avg_{stat}_win' tables[column_name] = tables.apply( lambda row: league_pos_win_stats[stat].get(row['league'], {}).get(row['position'], 0), axis=1 ) column_name = f'league_pos_avg_{stat}_loss' tables[column_name] = tables.apply( lambda row: league_pos_loss_stats[stat].get(row['league'], {}).get(row['position'], 0), axis=1 ) column_name = f'Opponent_pos_avg_{stat}_allowed_win' tables[column_name] = tables.apply( lambda row: Opponent_pos_win_allowed_stats[stat].get(row['Opponent'], {}).get(row['position'], 0), axis=1 ) column_name = f'Opponent_pos_avg_{stat}_allowed_loss' tables[column_name] = tables.apply( lambda row: Opponent_pos_loss_allowed_stats[stat].get(row['Opponent'], {}).get(row['position'], 0), axis=1 ) tables = tables[tables['Opponent'] == opponent] tables['overall_win_kills_boost_pos'] = tables['Opponent_pos_avg_kills_allowed_win'] / tables['league_pos_avg_kills_win'] tables['overall_win_deaths_boost_pos'] = tables['Opponent_pos_avg_deaths_allowed_win'] / tables['league_pos_avg_deaths_win'] tables['overall_win_assists_boost_pos'] = tables['Opponent_pos_avg_assists_allowed_win'] / tables['league_pos_avg_assists_win'] tables['overall_win_total_cs_boost_pos'] = tables['Opponent_pos_avg_total_cs_allowed_win'] / tables['league_pos_avg_total_cs_win'] tables['overall_loss_kills_boost_pos'] = tables['Opponent_pos_avg_kills_allowed_loss'] / tables['league_pos_avg_kills_loss'] tables['overall_loss_deaths_boost_pos'] = tables['Opponent_pos_avg_deaths_allowed_loss'] / tables['league_pos_avg_deaths_loss'] tables['overall_loss_assists_boost_pos'] = tables['Opponent_pos_avg_assists_allowed_loss'] / tables['league_pos_avg_assists_loss'] tables['overall_loss_total_cs_boost_pos'] = tables['Opponent_pos_avg_total_cs_allowed_loss'] / tables['league_pos_avg_total_cs_loss'] opp_tables = tables opp_pos_kills_boost_win = dict(zip(opp_tables['position'], opp_tables['overall_win_kills_boost_pos'])) opp_pos_deaths_boost_win = dict(zip(opp_tables['position'], opp_tables['overall_win_deaths_boost_pos'])) opp_pos_assists_boost_win = dict(zip(opp_tables['position'], opp_tables['overall_win_assists_boost_pos'])) opp_pos_cs_boost_win = dict(zip(opp_tables['position'], opp_tables['overall_win_total_cs_boost_pos'])) opp_pos_kills_boost_loss = dict(zip(opp_tables['position'], opp_tables['overall_loss_kills_boost_pos'])) opp_pos_deaths_boost_loss = dict(zip(opp_tables['position'], opp_tables['overall_loss_deaths_boost_pos'])) opp_pos_assists_boost_loss = dict(zip(opp_tables['position'], opp_tables['overall_loss_assists_boost_pos'])) opp_pos_cs_boost_loss = dict(zip(opp_tables['position'], opp_tables['overall_loss_total_cs_boost_pos'])) opp_boosts = pd.DataFrame({ 'opp_pos_kills_boost_win': opp_pos_kills_boost_win, 'opp_pos_deaths_boost_win': opp_pos_deaths_boost_win, 'opp_pos_assists_boost_win': opp_pos_assists_boost_win, 'opp_pos_cs_boost_win': opp_pos_cs_boost_win, 'opp_pos_kills_boost_loss': opp_pos_kills_boost_loss, 'opp_pos_deaths_boost_loss': opp_pos_deaths_boost_loss, 'opp_pos_assists_boost_loss': opp_pos_assists_boost_loss, 'opp_pos_cs_boost_loss': opp_pos_cs_boost_loss }).set_index(pd.Index(list(opp_pos_kills_boost_win.keys()), name='position')) results_dict = {} for game in range(game_count): if kill_predictions[game] > 0: working_tables = player_tables[['playername', 'teamname', 'position', 'playername_avg_kill_share_win', 'playername_avg_death_share_win','playername_avg_assist_share_win', 'playername_avg_total_cs_win', 'playername_avg_kill_share_loss', 'playername_avg_death_share_loss', 'playername_avg_assist_share_loss', 'playername_avg_total_cs_loss']] working_tables = working_tables.rename(columns = {'playername_avg_kill_share_win': 'wKill%', 'playername_avg_death_share_win': 'wDeath%', 'playername_avg_assist_share_win': 'wAssist%', 'playername_avg_total_cs_win': 'wCS', 'playername_avg_kill_share_loss': 'lKill%', 'playername_avg_death_share_loss': 'lDeath%', 'playername_avg_assist_share_loss': 'lAssist%', 'playername_avg_total_cs_loss': 'lCS'}) team_data = working_tables.drop_duplicates(subset = ['playername']) team_data = working_tables.drop_duplicates(subset = ['position']) if win_loss_settings[game] == "Win": team_data['Kill_Proj'] = team_data.apply(lambda row: row['wKill%'] * opp_pos_kills_boost_win.get(row['position'], 1), axis=1) * kill_predictions[game] team_data['Death_Proj'] = team_data.apply(lambda row: row['wDeath%'] * opp_pos_deaths_boost_win.get(row['position'], 1), axis=1) * death_predictions[game] # Calculate assists and scale them to not exceed total kills raw_assists = team_data.apply(lambda row: row['wAssist%'] * opp_pos_assists_boost_win.get(row['position'], 1), axis=1) * kill_predictions[game] assist_scale = min(1.0, kill_predictions[game] / raw_assists.sum()) if raw_assists.sum() > 0 else 1.0 team_data['Assist_Proj'] = raw_assists * assist_scale team_data['CS_Proj'] = team_data.apply(lambda row: row['wCS'] * opp_pos_cs_boost_win.get(row['position'], 1), axis=1) team_data = team_data[['playername', 'teamname', 'position', 'Kill_Proj', 'Death_Proj', 'Assist_Proj', 'CS_Proj']] else: team_data['Kill_Proj'] = team_data.apply(lambda row: row['lKill%'] * opp_pos_kills_boost_loss.get(row['position'], 1), axis=1) * kill_predictions[game] team_data['Death_Proj'] = team_data.apply(lambda row: row['lDeath%'] * opp_pos_deaths_boost_loss.get(row['position'], 1), axis=1) * death_predictions[game] # Calculate assists and scale them to not exceed total kills raw_assists = team_data.apply(lambda row: row['lAssist%'] * opp_pos_assists_boost_loss.get(row['position'], 1), axis=1) * kill_predictions[game] assist_scale = min(1.0, kill_predictions[game] / raw_assists.sum()) if raw_assists.sum() > 0 else 1.0 team_data['Assist_Proj'] = raw_assists * assist_scale team_data['CS_Proj'] = team_data.apply(lambda row: row['lCS'] * opp_pos_cs_boost_loss.get(row['position'], 1), axis=1) team_data = team_data[['playername', 'teamname', 'position', 'Kill_Proj', 'Death_Proj', 'Assist_Proj', 'CS_Proj']] else: working_tables = player_tables[['playername', 'teamname', 'position', 'playername_avg_kills_win', 'playername_avg_deaths_win', 'playername_avg_assists_win', 'playername_avg_total_cs_win', 'playername_avg_kills_loss', 'playername_avg_deaths_loss', 'playername_avg_assists_loss', 'playername_avg_total_cs_loss']] working_tables = working_tables.rename(columns = {'playername_avg_kills_win': 'wKill%', 'playername_avg_deaths_win': 'wDeath%', 'playername_avg_assists_win': 'wAssist%', 'playername_avg_total_cs_win': 'wCS', 'playername_avg_kills_loss': 'lKill%', 'playername_avg_deaths_loss': 'lDeath%', 'playername_avg_assists_loss': 'lAssist%', 'playername_avg_total_cs_loss': 'lCS'}) team_data = working_tables.drop_duplicates(subset = ['playername']) team_data = working_tables.drop_duplicates(subset = ['position']) if win_loss_settings[game] == "Win": team_data['Kill_Proj'] = team_data.apply(lambda row: row['wKill%'] * opp_pos_kills_boost_win.get(row['position'], 1), axis=1) team_data['Death_Proj'] = team_data.apply(lambda row: row['wDeath%'] * opp_pos_deaths_boost_win.get(row['position'], 1), axis=1) raw_assists = team_data.apply(lambda row: row['wAssist%'] * opp_pos_assists_boost_win.get(row['position'], 1), axis=1) * team_data['Kill_Proj'].sum() assist_scale = min(1.0, team_data['Kill_Proj'].sum() / raw_assists.sum()) if raw_assists.sum() > 0 else 1.0 team_data['Assist_Proj'] = raw_assists * assist_scale team_data['CS_Proj'] = team_data.apply(lambda row: row['wCS'] * opp_pos_cs_boost_win.get(row['position'], 1), axis=1) team_data = team_data[['playername', 'teamname', 'position', 'Kill_Proj', 'Death_Proj', 'Assist_Proj', 'CS_Proj']] else: team_data['Kill_Proj'] = team_data.apply(lambda row: row['lKill%'] * opp_pos_kills_boost_loss.get(row['position'], 1), axis=1) team_data['Death_Proj'] = team_data.apply(lambda row: row['lDeath%'] * opp_pos_deaths_boost_loss.get(row['position'], 1), axis=1) raw_assists = team_data.apply(lambda row: row['wAssist%'] * opp_pos_assists_boost_win.get(row['position'], 1), axis=1) * team_data['Kill_Proj'].sum() assist_scale = min(1.0, team_data['Kill_Proj'].sum() / raw_assists.sum()) if raw_assists.sum() > 0 else 1.0 team_data['Assist_Proj'] = raw_assists * assist_scale team_data['CS_Proj'] = team_data.apply(lambda row: row['lCS'] * opp_pos_cs_boost_loss.get(row['position'], 1), axis=1) team_data = team_data[['playername', 'teamname', 'position', 'Kill_Proj', 'Death_Proj', 'Assist_Proj', 'CS_Proj']] results_dict[f'game {game + 1}'] = team_data.dropna() team_data['playername'] = team_data['playername'] + f' game {game + 1}' overall_team_data = pd.concat([overall_team_data, team_data]) return overall_team_data.dropna().set_index('playername'), opp_boosts, results_dict, player_tables @st.cache_data(ttl = 60) def init_player_data(game_count, players, opponent, win_loss_settings, kill_predictions, death_predictions, start_date, end_date): game_count = game_count overall_team_data = pd.DataFrame(columns = ['playername', 'teamname', 'position', 'Kill_Proj', 'Death_Proj', 'Assist_Proj', 'CS_Proj']) # Convert date objects to datetime strings in the correct format start_datetime = datetime.combine(start_date, datetime.min.time()).strftime("%Y-%m-%d %H:%M:%S") end_datetime = datetime.combine(end_date, datetime.max.time()).strftime("%Y-%m-%d %H:%M:%S") collection = db["gamelogs"] cursor = collection.find({"playername": {"$in": players}, "date": {"$gte": start_datetime, "$lte": end_datetime}}) raw_display = pd.DataFrame(list(cursor)) teams = raw_display['teamname'].unique().tolist() cursor = collection.find({"teamname": {"$in": teams}, "date": {"$gte": start_datetime, "$lte": end_datetime}}) raw_team = pd.DataFrame(list(cursor)) cursor = collection.find({"date": {"$gte": start_datetime, "$lte": end_datetime}}) raw_opponent = pd.DataFrame(list(cursor)) tables_to_loop = [raw_display, raw_opponent, raw_team] for loop in range(len(tables_to_loop)): tables = tables_to_loop[loop] calc_columns = ['kills', 'deaths', 'assists', 'total_cs'] league_pos_win_stats = {} league_pos_loss_stats = {} Opponent_pos_win_allowed_stats = {} Opponent_pos_loss_allowed_stats = {} playername_win_stats = {} playername_loss_stats = {} teamname_win_stats = {} teamname_loss_stats = {} if loop == 0: for stats in calc_columns: playername_win_stats[stats] = tables[tables['result'] == 1].groupby(['playername'])[stats].mean().to_dict() playername_loss_stats[stats] = tables[tables['result'] == 0].groupby(['playername'])[stats].mean().to_dict() teamname_win_stats[stats] = tables[(tables['result'] == 1) & (tables['position'] == 'team')].groupby(['teamname'])[stats].mean().to_dict() teamname_loss_stats[stats] = tables[(tables['result'] == 0) & (tables['position'] == 'team')].groupby(['teamname'])[stats].mean().to_dict() for stat in calc_columns: column_name = f'playername_avg_{stat}_win' tables[column_name] = tables.apply( lambda row: playername_win_stats[stat].get(row['playername'], 0), axis=1 ) column_name = f'playername_avg_{stat}_loss' tables[column_name] = tables.apply( lambda row: playername_loss_stats[stat].get(row['playername'], 0), axis=1 ) if loop == 2: column_name = f'teamname_avg_{stat}_win' tables[column_name] = tables.apply( lambda row: teamname_win_stats[stat].get(row['teamname'], 0), axis=1 ) column_name = f'teamname_avg_{stat}_loss' tables[column_name] = tables.apply( lambda row: teamname_loss_stats[stat].get(row['teamname'], 0), axis=1 ) tables['playername_avg_kill_share_win'] = tables['playername_avg_kills_win'] / tables['teamname_avg_kills_win'] tables['playername_avg_death_share_win'] = tables['playername_avg_deaths_win'] / tables['teamname_avg_deaths_win'] tables['playername_avg_assist_share_win'] = tables['playername_avg_assists_win'] / tables['teamname_avg_kills_win'] tables['playername_avg_cs_share_win'] = tables['playername_avg_total_cs_win'] / tables['teamname_avg_total_cs_win'] tables['playername_avg_kill_share_loss'] = tables['playername_avg_kills_loss'] / tables['teamname_avg_kills_loss'] tables['playername_avg_death_share_loss'] = tables['playername_avg_deaths_loss'] / tables['teamname_avg_deaths_loss'] tables['playername_avg_assist_share_loss'] = tables['playername_avg_assists_loss'] / tables['teamname_avg_kills_loss'] tables['playername_avg_cs_share_loss'] = tables['playername_avg_total_cs_loss'] / tables['teamname_avg_total_cs_loss'] player_tables = tables else: for stats in calc_columns: league_pos_win_stats[stats] = { league: group.groupby('position')[stats].mean().to_dict() for league, group in tables[tables['result'] == 1].groupby('league') } league_pos_loss_stats[stats] = { league: group.groupby('position')[stats].mean().to_dict() for league, group in tables[tables['result'] == 0].groupby('league') } Opponent_pos_win_allowed_stats[stats] = { opponent: group.groupby('position')[stats].mean().to_dict() for opponent, group in tables[tables['result'] == 1].groupby('Opponent') } Opponent_pos_loss_allowed_stats[stats] = { opponent: group.groupby('position')[stats].mean().to_dict() for opponent, group in tables[tables['result'] == 0].groupby('Opponent') } for stat in calc_columns: column_name = f'league_pos_avg_{stat}_win' tables[column_name] = tables.apply( lambda row: league_pos_win_stats[stat].get(row['league'], {}).get(row['position'], 0), axis=1 ) column_name = f'league_pos_avg_{stat}_loss' tables[column_name] = tables.apply( lambda row: league_pos_loss_stats[stat].get(row['league'], {}).get(row['position'], 0), axis=1 ) column_name = f'Opponent_pos_avg_{stat}_allowed_win' tables[column_name] = tables.apply( lambda row: Opponent_pos_win_allowed_stats[stat].get(row['Opponent'], {}).get(row['position'], 0), axis=1 ) column_name = f'Opponent_pos_avg_{stat}_allowed_loss' tables[column_name] = tables.apply( lambda row: Opponent_pos_loss_allowed_stats[stat].get(row['Opponent'], {}).get(row['position'], 0), axis=1 ) tables = tables[tables['Opponent'] == opponent] tables['overall_win_kills_boost_pos'] = tables['Opponent_pos_avg_kills_allowed_win'] / tables['league_pos_avg_kills_win'] tables['overall_win_deaths_boost_pos'] = tables['Opponent_pos_avg_deaths_allowed_win'] / tables['league_pos_avg_deaths_win'] tables['overall_win_assists_boost_pos'] = tables['Opponent_pos_avg_assists_allowed_win'] / tables['league_pos_avg_assists_win'] tables['overall_win_total_cs_boost_pos'] = tables['Opponent_pos_avg_total_cs_allowed_win'] / tables['league_pos_avg_total_cs_win'] tables['overall_loss_kills_boost_pos'] = tables['Opponent_pos_avg_kills_allowed_loss'] / tables['league_pos_avg_kills_loss'] tables['overall_loss_deaths_boost_pos'] = tables['Opponent_pos_avg_deaths_allowed_loss'] / tables['league_pos_avg_deaths_loss'] tables['overall_loss_assists_boost_pos'] = tables['Opponent_pos_avg_assists_allowed_loss'] / tables['league_pos_avg_assists_loss'] tables['overall_loss_total_cs_boost_pos'] = tables['Opponent_pos_avg_total_cs_allowed_loss'] / tables['league_pos_avg_total_cs_loss'] opp_tables = tables opp_pos_kills_boost_win = dict(zip(opp_tables['position'], opp_tables['overall_win_kills_boost_pos'])) opp_pos_deaths_boost_win = dict(zip(opp_tables['position'], opp_tables['overall_win_deaths_boost_pos'])) opp_pos_assists_boost_win = dict(zip(opp_tables['position'], opp_tables['overall_win_assists_boost_pos'])) opp_pos_cs_boost_win = dict(zip(opp_tables['position'], opp_tables['overall_win_total_cs_boost_pos'])) opp_pos_kills_boost_loss = dict(zip(opp_tables['position'], opp_tables['overall_loss_kills_boost_pos'])) opp_pos_deaths_boost_loss = dict(zip(opp_tables['position'], opp_tables['overall_loss_deaths_boost_pos'])) opp_pos_assists_boost_loss = dict(zip(opp_tables['position'], opp_tables['overall_loss_assists_boost_pos'])) opp_pos_cs_boost_loss = dict(zip(opp_tables['position'], opp_tables['overall_loss_total_cs_boost_pos'])) opp_boosts = pd.DataFrame({ 'opp_pos_kills_boost_win': opp_pos_kills_boost_win, 'opp_pos_deaths_boost_win': opp_pos_deaths_boost_win, 'opp_pos_assists_boost_win': opp_pos_assists_boost_win, 'opp_pos_cs_boost_win': opp_pos_cs_boost_win, 'opp_pos_kills_boost_loss': opp_pos_kills_boost_loss, 'opp_pos_deaths_boost_loss': opp_pos_deaths_boost_loss, 'opp_pos_assists_boost_loss': opp_pos_assists_boost_loss, 'opp_pos_cs_boost_loss': opp_pos_cs_boost_loss }).set_index(pd.Index(list(opp_pos_kills_boost_win.keys()), name='position')) results_dict = {} for game in range(game_count): if kill_predictions[game] > 0: working_tables = player_tables[['playername', 'teamname', 'position', 'playername_avg_kill_share_win', 'playername_avg_death_share_win','playername_avg_assist_share_win', 'playername_avg_total_cs_win', 'playername_avg_kill_share_loss', 'playername_avg_death_share_loss', 'playername_avg_assist_share_loss', 'playername_avg_total_cs_loss']] working_tables = working_tables.rename(columns = {'playername_avg_kill_share_win': 'wKill%', 'playername_avg_death_share_win': 'wDeath%', 'playername_avg_assist_share_win': 'wAssist%', 'playername_avg_total_cs_win': 'wCS', 'playername_avg_kill_share_loss': 'lKill%', 'playername_avg_death_share_loss': 'lDeath%', 'playername_avg_assist_share_loss': 'lAssist%', 'playername_avg_total_cs_loss': 'lCS'}) team_data = working_tables.drop_duplicates(subset = ['playername']) if win_loss_settings[game] == "Win": team_data['Kill_Proj'] = team_data.apply(lambda row: row['wKill%'] * opp_pos_kills_boost_win.get(row['position'], 1), axis=1) * kill_predictions[game] team_data['Death_Proj'] = team_data.apply(lambda row: row['wDeath%'] * opp_pos_deaths_boost_win.get(row['position'], 1), axis=1) * death_predictions[game] # Calculate assists and scale them to not exceed total kills raw_assists = team_data.apply(lambda row: row['wAssist%'] * opp_pos_assists_boost_win.get(row['position'], 1), axis=1) * kill_predictions[game] assist_scale = min(1.0, kill_predictions[game] / raw_assists.sum()) if raw_assists.sum() > 0 else 1.0 team_data['Assist_Proj'] = raw_assists * assist_scale team_data['CS_Proj'] = team_data.apply(lambda row: row['wCS'] * opp_pos_cs_boost_win.get(row['position'], 1), axis=1) team_data = team_data[['playername', 'teamname', 'position', 'Kill_Proj', 'Death_Proj', 'Assist_Proj', 'CS_Proj']] else: team_data['Kill_Proj'] = team_data.apply(lambda row: row['lKill%'] * opp_pos_kills_boost_loss.get(row['position'], 1), axis=1) * kill_predictions[game] team_data['Death_Proj'] = team_data.apply(lambda row: row['lDeath%'] * opp_pos_deaths_boost_loss.get(row['position'], 1), axis=1) * death_predictions[game] # Calculate assists and scale them to not exceed total kills raw_assists = team_data.apply(lambda row: row['lAssist%'] * opp_pos_assists_boost_loss.get(row['position'], 1), axis=1) * kill_predictions[game] assist_scale = min(1.0, kill_predictions[game] / raw_assists.sum()) if raw_assists.sum() > 0 else 1.0 team_data['Assist_Proj'] = raw_assists * assist_scale team_data['CS_Proj'] = team_data.apply(lambda row: row['lCS'] * opp_pos_cs_boost_loss.get(row['position'], 1), axis=1) team_data = team_data[['playername', 'teamname', 'position', 'Kill_Proj', 'Death_Proj', 'Assist_Proj', 'CS_Proj']] else: working_tables = player_tables[['playername', 'teamname', 'position', 'playername_avg_kills_win', 'playername_avg_deaths_win', 'playername_avg_assists_win', 'playername_avg_total_cs_win', 'playername_avg_kills_loss', 'playername_avg_deaths_loss', 'playername_avg_assists_loss', 'playername_avg_total_cs_loss']] working_tables = working_tables.rename(columns = {'playername_avg_kills_win': 'wKill%', 'playername_avg_deaths_win': 'wDeath%', 'playername_avg_assists_win': 'wAssist%', 'playername_avg_total_cs_win': 'wCS', 'playername_avg_kills_loss': 'lKill%', 'playername_avg_deaths_loss': 'lDeath%', 'playername_avg_assists_loss': 'lAssist%', 'playername_avg_total_cs_loss': 'lCS'}) team_data = working_tables.drop_duplicates(subset = ['playername']) if win_loss_settings[game] == "Win": team_data['Kill_Proj'] = team_data.apply(lambda row: row['wKill%'] * opp_pos_kills_boost_win.get(row['position'], 1), axis=1) team_data['Death_Proj'] = team_data.apply(lambda row: row['wDeath%'] * opp_pos_deaths_boost_win.get(row['position'], 1), axis=1) raw_assists = team_data.apply(lambda row: row['wAssist%'] * opp_pos_assists_boost_win.get(row['position'], 1), axis=1) * team_data['Kill_Proj'].sum() assist_scale = min(1.0, team_data['Kill_Proj'].sum() / raw_assists.sum()) if raw_assists.sum() > 0 else 1.0 team_data['Assist_Proj'] = raw_assists * assist_scale team_data['CS_Proj'] = team_data.apply(lambda row: row['wCS'] * opp_pos_cs_boost_win.get(row['position'], 1), axis=1) team_data = team_data[['playername', 'teamname', 'position', 'Kill_Proj', 'Death_Proj', 'Assist_Proj', 'CS_Proj']] else: team_data['Kill_Proj'] = team_data.apply(lambda row: row['lKill%'] * opp_pos_kills_boost_loss.get(row['position'], 1), axis=1) team_data['Death_Proj'] = team_data.apply(lambda row: row['lDeath%'] * opp_pos_deaths_boost_loss.get(row['position'], 1), axis=1) raw_assists = team_data.apply(lambda row: row['wAssist%'] * opp_pos_assists_boost_win.get(row['position'], 1), axis=1) * team_data['Kill_Proj'].sum() assist_scale = min(1.0, team_data['Kill_Proj'].sum() / raw_assists.sum()) if raw_assists.sum() > 0 else 1.0 team_data['Assist_Proj'] = raw_assists * assist_scale team_data['CS_Proj'] = team_data.apply(lambda row: row['lCS'] * opp_pos_cs_boost_loss.get(row['position'], 1), axis=1) team_data = team_data[['playername', 'teamname', 'position', 'Kill_Proj', 'Death_Proj', 'Assist_Proj', 'CS_Proj']] results_dict[f'game {game + 1}'] = team_data.dropna() team_data['playername'] = team_data['playername'] + f' game {game + 1}' overall_team_data = pd.concat([overall_team_data, team_data]) return overall_team_data.dropna().set_index('playername'), opp_boosts, results_dict, player_tables if st.button("Load/Reset Data", key='reset1'): st.cache_data.clear() for key in st.session_state.keys(): del st.session_state[key] if st.button("Run"): if data_type == "Team": st.session_state.team_data, st.session_state.opp_boost, st.session_state.results_dict, st.session_state.gamelogs = init_team_data(game_count, selected_team, selected_opponent, win_loss_settings, kill_predictions, death_predictions, start_date, end_date) else: st.session_state.team_data, st.session_state.opp_boost, st.session_state.results_dict, st.session_state.gamelogs = init_player_data(game_count, selected_players, selected_opponent, win_loss_settings, kill_predictions, death_predictions, start_date, end_date) st.session_state.gamelogs_display = st.session_state.gamelogs[['date', 'teamname', 'Opponent', 'playername', 'position', 'result', 'kills', 'playername_avg_kills_win', 'playername_avg_kills_loss', 'deaths', 'playername_avg_deaths_win', 'playername_avg_deaths_loss', 'assists', 'playername_avg_assists_win', 'playername_avg_assists_loss', 'total_cs', 'playername_avg_total_cs_win', 'playername_avg_total_cs_loss', 'fantasy']] st.session_state.gamelogs_display = st.session_state.gamelogs_display.rename(columns = {'teamname': 'Team', 'Opponent': 'Opp', 'playername': 'Player', 'position': 'Pos', 'result': 'W/L', 'playername_avg_kills_win': 'Avg_Kill_Win', 'playername_avg_deaths_win': 'Avg_Death_Win', 'playername_avg_assists_win': 'Avg_Assist_Win', 'playername_avg_total_cs_win': 'Avg_CS_Win', 'playername_avg_kills_loss': 'Avg_Kill_Loss', 'playername_avg_deaths_loss': 'Avg_Death_Loss', 'playername_avg_assists_loss': 'Avg_Assist_Loss', 'playername_avg_total_cs_loss': 'Avg_CS_Loss', 'kills': 'Kill', 'deaths': 'Death', 'assists': 'Assist', 'total_cs': 'CS', 'fantasy': 'Fantasy'}) st.session_state.gamelogs_display = st.session_state.gamelogs_display[st.session_state.gamelogs_display['Pos'] != 'team'] st.session_state.gamelogs_display = st.session_state.gamelogs_display.sort_values(by = ['date'], ascending = False) st.session_state.gamelogs_display = st.session_state.gamelogs_display.reset_index(drop = True) st.session_state.gamelogs_display['Fantasy'] = st.session_state.gamelogs_display['Fantasy'].astype(float).round(2) st.session_state.player_summary = pd.DataFrame() for game_num in range(game_count): st.session_state.game_df = st.session_state.results_dict[f'game {game_num + 1}'] # Use correct dictionary key format # Remove 'game X' from playernames if present st.session_state.clean_df = st.session_state.game_df.copy() st.session_state.clean_df['playername'] = st.session_state.clean_df['playername'].str.split(' game ').str[0] if st.session_state.player_summary.empty: st.session_state.player_summary = st.session_state.clean_df else: # Add the stats to existing players for col in ['Kill_Proj', 'Death_Proj', 'Assist_Proj', 'CS_Proj']: st.session_state.player_summary[col] += st.session_state.clean_df[col] # Update teamname and position if needed st.session_state.player_summary['teamname'].update(st.session_state.clean_df['teamname']) st.session_state.player_summary['position'].update(st.session_state.clean_df['position']) st.session_state.player_summary = st.session_state.player_summary.set_index('playername') # Create simulated percentiles individual_sim_results = [] for idx, row in st.session_state.team_data.iterrows(): percentiles = simulate_stats(row) individual_sim_results.append({ 'Player': idx, 'Position': row['position'], 'Stat': 'Kills', '10%': percentiles['Kill_Proj'][0], '25%': percentiles['Kill_Proj'][1], '50%': percentiles['Kill_Proj'][2], '75%': percentiles['Kill_Proj'][3], '90%': percentiles['Kill_Proj'][4] }) # Repeat for other stats for stat, name in [('Death_Proj', 'Deaths'), ('Assist_Proj', 'Assists'), ('CS_Proj', 'CS')]: individual_sim_results.append({ 'Player': idx, 'Position': row['position'], 'Stat': name, '10%': percentiles[stat][0], '25%': percentiles[stat][1], '50%': percentiles[stat][2], '75%': percentiles[stat][3], '90%': percentiles[stat][4] }) st.session_state.sim_df = pd.DataFrame(individual_sim_results) # Create simulated percentiles overall_sim_results = [] for idx, row in st.session_state.player_summary.iterrows(): percentiles = simulate_stats(row) overall_sim_results.append({ 'Player': idx, 'Position': row['position'], 'Stat': 'Kills', '10%': percentiles['Kill_Proj'][0], '25%': percentiles['Kill_Proj'][1], '50%': percentiles['Kill_Proj'][2], '75%': percentiles['Kill_Proj'][3], '90%': percentiles['Kill_Proj'][4] }) # Repeat for other stats for stat, name in [('Death_Proj', 'Deaths'), ('Assist_Proj', 'Assists'), ('CS_Proj', 'CS')]: overall_sim_results.append({ 'Player': idx, 'Position': row['position'], 'Stat': name, '10%': percentiles[stat][0], '25%': percentiles[stat][1], '50%': percentiles[stat][2], '75%': percentiles[stat][3], '90%': percentiles[stat][4] }) st.session_state.overall_sim_df = pd.DataFrame(overall_sim_results) st.session_state.overall_sim_df = st.session_state.overall_sim_df.drop_duplicates(subset = ['Player', 'Stat']) tab1, tab2, tab3, tab4 = st.tabs(["Gamelogs", "Overall Data", "Individual Game Data", "Opponent Data"]) with tab4: if 'player_summary' in st.session_state: st.subheader("Full Match Data") st.dataframe(st.session_state.player_summary.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(display_formats, precision=2), use_container_width = True) if 'overall_sim_df' in st.session_state: st.subheader("Overall Simulations") stat_tabs = st.tabs(["Kills", "Deaths", "Assists", "CS"]) for stat, tab in zip(["Kills", "Deaths", "Assists", "CS"], stat_tabs): with tab: st.session_state.stat_data = st.session_state.overall_sim_df[st.session_state.overall_sim_df['Stat'] == stat].copy() st.session_state.stat_data = st.session_state.stat_data.set_index('Player')[['Position', '10%', '25%', '50%', '75%', '90%']] st.dataframe( st.session_state.stat_data.style.format(precision=2).background_gradient(axis=0).background_gradient(cmap='RdYlGn'), use_container_width=True ) st.subheader("Prop Check") col1, col2 = st.columns([2, 8]) with col1: prop_var = st.number_input("Enter Prop Value", min_value=0.0, max_value=100.0, value=4.5, step=0.5) stat_choice = st.selectbox("Select Stat", ["Kills", "Deaths", "Assists", "CS"]) with col2: # Filter data for selected stat st.session_state.stat_data = st.session_state.overall_sim_df[st.session_state.overall_sim_df['Stat'] == stat_choice].copy() # Calculate mean and standard deviation using percentiles # Using the fact that in a normal distribution: # 10th percentile is -1.28 SD from mean # 90th percentile is 1.28 SD from mean st.session_state.stat_data['mean'] = (st.session_state.stat_data['90%'] + st.session_state.stat_data['10%']) / 2 st.session_state.stat_data['std'] = (st.session_state.stat_data['90%'] - st.session_state.stat_data['10%']) / (2 * 1.28) # Calculate probabilities st.session_state.stat_data['over_prob'] = st.session_state.stat_data.apply( lambda x: 1 - stats.norm.cdf(prop_var, x['mean'], x['std']), axis=1 ) st.session_state.stat_data['under_prob'] = st.session_state.stat_data.apply( lambda x: stats.norm.cdf(prop_var, x['mean'], x['std']), axis=1 ) # Prepare display dataframe st.session_state.display_df = st.session_state.stat_data[['Player', 'Position', 'over_prob', 'under_prob']].copy() st.session_state.display_df['Over %'] = (st.session_state.display_df['over_prob']).round(2) st.session_state.display_df['Under %'] = (st.session_state.display_df['under_prob']).round(2) # Display results st.dataframe( st.session_state.display_df[['Player', 'Position', 'Over %', 'Under %']] .set_index('Player') .style.background_gradient(subset=['Over %', 'Under %'], cmap='RdYlGn').format(display_formats, precision=2), use_container_width=True ) with tab2: if 'team_data' in st.session_state: st.subheader("Individual Game Data") st.dataframe(st.session_state.team_data.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(display_formats, precision=2), use_container_width = True) if 'sim_df' in st.session_state: st.subheader("Individual Game Simulations") unique_players = st.session_state.sim_df['Player'].unique().tolist() player_tabs = st.tabs(unique_players) for player, tab in zip(unique_players, player_tabs): with tab: player_data = st.session_state.sim_df[st.session_state.sim_df['Player'] == player] player_data = player_data.set_index('Stat') st.dataframe( player_data[['10%', '25%', '50%', '75%', '90%']] .style.format(precision=2), use_container_width=True ) with tab3: if 'opp_boost' in st.session_state: st.subheader("Opponent Boosts") st.dataframe(st.session_state.opp_boost.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(precision=2), use_container_width = True) with tab1: if 'gamelogs_display' in st.session_state: st.subheader("Gamelogs") with st.container(): col1, col2, col3 = st.columns([4, 4, 4]) with col1: player_toggle = st.selectbox("Do you want to view all players or just one?", ['All', 'One']) with col2: if player_toggle == 'One': player_search = st.selectbox("Search for a player", st.session_state.gamelogs_display['Player'].unique().tolist()) else: player_search = 'All' with col3: scenario_search = st.selectbox("Wins, Losses, or All games?", ['All', 'Wins', 'Losses']) if player_toggle == 'One': st.session_state.gamelogs_final = st.session_state.gamelogs_display[st.session_state.gamelogs_display['Player'] == player_search] else: st.session_state.gamelogs_final = st.session_state.gamelogs_display if scenario_search == 'Wins': st.session_state.gamelogs_final = st.session_state.gamelogs_final[st.session_state.gamelogs_final['W/L'] == 1] elif scenario_search == 'Losses': st.session_state.gamelogs_final = st.session_state.gamelogs_final[st.session_state.gamelogs_final['W/L'] == 0] else: st.session_state.gamelogs_final = st.session_state.gamelogs_final st.dataframe(st.session_state.gamelogs_final.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(precision=2), use_container_width = True)