Enhance player data handling in app.py by introducing a new data type selection feature. Users can now choose between "Team" and "Player" data types, allowing for more flexible data analysis. Updated the player data initialization function to support player-specific statistics, including average performance metrics based on game outcomes. This change improves the overall functionality and user experience of the application.

app.py

@@ -27,6 +27,8 @@ def init_conn():
 db, team_names, player_names, min_date, max_date = init_conn()
 
 display_formats = {'wKill%': '{:.2%}', 'wDeath%': '{:.2%}', 'wAssist%': '{:.2%}', 'lKill%': '{:.2%}', 'lDeath%': '{:.2%}', 'lAssist%': '{:.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:
@@ -59,13 +61,26 @@ with st.sidebar:
                 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:
-        selected_team = st.selectbox(
-            "Select Team",
-            options=team_names,
-            index=team_names.index("T1") if "T1" in team_names else 0
-        )
+        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",
@@ -350,8 +365,213 @@ def init_team_data(team, opponent, win_loss_settings, kill_predictions, death_pr
 
         return overall_team_data.dropna().set_index('playername'), opp_boosts, results_dict
 
+@st.cache_data(ttl = 60)
+def init_player_data(players, opponent, win_loss_settings, kill_predictions, death_predictions, start_date, end_date):  
+        game_count = len(kill_predictions)
+        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": players, "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'])
+
+                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]
+                    team_data['Assist_Proj'] = team_data.apply(lambda row: row['wAssist%'] * opp_pos_assists_boost_win.get(row['position'], 1), axis=1) * kill_predictions[game]
+                    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]
+                    team_data['Assist_Proj'] = team_data.apply(lambda row: row['lAssist%'] * opp_pos_assists_boost_loss.get(row['position'], 1), axis=1) * kill_predictions[game]
+                    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)
+                    team_data['Assist_Proj'] = team_data.apply(lambda row: row['wAssist%'] * opp_pos_assists_boost_win.get(row['position'], 1), axis=1)
+                    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)
+                    team_data['Assist_Proj'] = team_data.apply(lambda row: row['lAssist%'] * opp_pos_assists_boost_loss.get(row['position'], 1), axis=1)
+                    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
+
 if st.button("Run"):
-    team_data, opp_boost, results_dict = init_team_data(selected_team, selected_opponent, win_loss_settings, kill_predictions, death_predictions, start_date, end_date)
+    if data_type == "Team":
+        team_data, opp_boost, results_dict = init_team_data(selected_team, selected_opponent, win_loss_settings, kill_predictions, death_predictions, start_date, end_date)
+    else:
+        team_data, opp_boost, results_dict = init_player_data(selected_players, selected_opponent, win_loss_settings, kill_predictions, death_predictions, start_date, end_date)
 
     player_summary = pd.DataFrame()
     for game_num in range(game_count):