Enhance team data analysis in app.py by adding opponent selection and refining statistical calculations. Introduced a select box for choosing opponents, updated the init_team_data function to include opponent data in performance metrics, and streamlined calculations for kills, deaths, assists, and total CS. This improves the depth and usability of team performance evaluations.

app.py

@@ -64,6 +64,13 @@ with st.sidebar:
         index=team_names.index("T1") if "T1" in team_names else 0
     )
     
+    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")
     win_loss = st.selectbox(
         "Select Win/Loss",
@@ -96,7 +103,7 @@ with st.sidebar:
         )
 
 @st.cache_data(ttl = 60)
-def init_team_data(team, win_loss, kill_prediction, death_prediction, start_date, end_date):  
+def init_team_data(team, opponent, win_loss, kill_prediction, death_prediction, start_date, end_date):  
         
         # 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")
@@ -104,191 +111,201 @@ def init_team_data(team, win_loss, kill_prediction, death_prediction, start_date
 
         collection = db["gamelogs"] 
         cursor = collection.find({"teamname": team, "date": {"$gte": start_datetime, "$lte": end_datetime}})
-    
         raw_display = pd.DataFrame(list(cursor))
-        calc_columns = ['kills', 'deaths', 'assists', 'total_cs']
-        league_win_stats = {}
-        league_loss_stats = {}
-        league_pos_win_stats = {}   
-        league_pos_loss_stats = {}
-        Opponent_win_allowed_stats = {}
-        Opponent_loss_allowed_stats = {}
-        Opponent_pos_win_allowed_stats = {}
-        Opponent_pos_loss_allowed_stats = {}
-        playername_win_stats = {}
-        playername_loss_stats = {}
-        teamname_win_stats = {}
-        teamname_loss_stats = {}
-
-        for stats in calc_columns:
-            league_win_stats[stats] = raw_display[(raw_display['result'] == 1) & (raw_display['position'] != 'team')].groupby('league')[stats].mean().to_dict()
-            league_loss_stats[stats] = raw_display[(raw_display['result'] == 0) & (raw_display['position'] != 'team')].groupby('league')[stats].mean().to_dict()
-            Opponent_win_allowed_stats[stats] = raw_display[(raw_display['result'] == 1) & (raw_display['position'] != 'team')].groupby('Opponent')[stats].mean().to_dict()
-            Opponent_loss_allowed_stats[stats] = raw_display[(raw_display['result'] == 0) & (raw_display['position'] != 'team')].groupby('Opponent')[stats].mean().to_dict()
-
-        for stats in calc_columns:
-            league_pos_win_stats[stats] = {
-                league: group.groupby('position')[stats].mean().to_dict()
-                for league, group in raw_display[raw_display['result'] == 1].groupby('league')
-            }
-            league_pos_loss_stats[stats] = {
-                league: group.groupby('position')[stats].mean().to_dict()
-                for league, group in raw_display[raw_display['result'] == 0].groupby('league')
-            }
-            
-            Opponent_pos_win_allowed_stats[stats] = {
-                opponent: group.groupby('position')[stats].mean().to_dict()
-                for opponent, group in raw_display[raw_display['result'] == 1].groupby('Opponent')
-            }
-            Opponent_pos_loss_allowed_stats[stats] = {
-                opponent: group.groupby('position')[stats].mean().to_dict()
-                for opponent, group in raw_display[raw_display['result'] == 0].groupby('Opponent')
-            }
-
-        for stats in calc_columns:
-            playername_win_stats[stats] = raw_display[raw_display['result'] == 1].groupby(['playername'])[stats].mean().to_dict()
-            playername_loss_stats[stats] = raw_display[raw_display['result'] == 0].groupby(['playername'])[stats].mean().to_dict()
-            teamname_win_stats[stats] = raw_display[(raw_display['result'] == 1) & (raw_display['position'] == 'team')].groupby(['teamname'])[stats].mean().to_dict()
-            teamname_loss_stats[stats] = raw_display[(raw_display['result'] == 0) & (raw_display['position'] == 'team')].groupby(['teamname'])[stats].mean().to_dict() 
-
-        for stat in calc_columns:
-
-            column_name = f'league_avg_{stat}_win'
-            raw_display[column_name] = raw_display.apply(
-                lambda row: league_win_stats[stat].get(row['league'], 0), 
-                axis=1
-            )
-
-            column_name = f'league_avg_{stat}_loss'
-            raw_display[column_name] = raw_display.apply(
-                lambda row: league_loss_stats[stat].get(row['league'], 0), 
-                axis=1
-            )
-
-            column_name = f'Opponent_avg_{stat}_allowed_win'
-            raw_display[column_name] = raw_display.apply(
-                lambda row: Opponent_win_allowed_stats[stat].get(row['Opponent'], 0), 
-                axis=1
-            )
-
-            column_name = f'Opponent_avg_{stat}_allowed_loss'
-            raw_display[column_name] = raw_display.apply(
-                lambda row: Opponent_loss_allowed_stats[stat].get(row['Opponent'], 0), 
-                axis=1
-            )
-
-            column_name = f'league_pos_avg_{stat}_win'
-            raw_display[column_name] = raw_display.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'
-            raw_display[column_name] = raw_display.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'
-            raw_display[column_name] = raw_display.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'
-            raw_display[column_name] = raw_display.apply(
-                lambda row: Opponent_pos_loss_allowed_stats[stat].get(row['Opponent'], {}).get(row['position'], 0), 
-                axis=1
-            )
-
-            column_name = f'playername_avg_{stat}_win'
-            raw_display[column_name] = raw_display.apply(
-                lambda row: playername_win_stats[stat].get(row['playername'], 0), 
-                axis=1
-            )
-
-            column_name = f'playername_avg_{stat}_loss'
-            raw_display[column_name] = raw_display.apply(
-                lambda row: playername_loss_stats[stat].get(row['playername'], 0), 
-                axis=1
-            )
 
-            column_name = f'teamname_avg_{stat}_win'
-            raw_display[column_name] = raw_display.apply(
-                lambda row: teamname_win_stats[stat].get(row['teamname'], 0), 
-                axis=1
-            )
-
-            column_name = f'teamname_avg_{stat}_loss'
-            raw_display[column_name] = raw_display.apply(
-                lambda row: teamname_loss_stats[stat].get(row['teamname'], 0), 
-                axis=1
-            )
+        cursor = collection.find({"Opponent": opponent, "date": {"$gte": start_datetime, "$lte": end_datetime}})
+        raw_opponent = pd.DataFrame(list(cursor))
+
+        for tables in [raw_display, raw_opponent]:
+            calc_columns = ['kills', 'deaths', 'assists', 'total_cs']
+            league_win_stats = {}
+            league_loss_stats = {}
+            league_pos_win_stats = {}   
+            league_pos_loss_stats = {}
+            Opponent_win_allowed_stats = {}
+            Opponent_loss_allowed_stats = {}
+            Opponent_pos_win_allowed_stats = {}
+            Opponent_pos_loss_allowed_stats = {}
+            playername_win_stats = {}
+            playername_loss_stats = {}
+            teamname_win_stats = {}
+            teamname_loss_stats = {}
+
+            for stats in calc_columns:
+                league_win_stats[stats] = tables[(tables['result'] == 1) & (tables['position'] != 'team')].groupby('league')[stats].mean().to_dict()
+                league_loss_stats[stats] = tables[(tables['result'] == 0) & (tables['position'] != 'team')].groupby('league')[stats].mean().to_dict()
+                Opponent_win_allowed_stats[stats] = tables[(tables['result'] == 1) & (tables['position'] != 'team')].groupby('Opponent')[stats].mean().to_dict()
+                Opponent_loss_allowed_stats[stats] = tables[(tables['result'] == 0) & (tables['position'] != 'team')].groupby('Opponent')[stats].mean().to_dict()
+
+            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 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'league_avg_{stat}_win'
+                tables[column_name] = tables.apply(
+                    lambda row: league_win_stats[stat].get(row['league'], 0), 
+                    axis=1
+                )
+
+                column_name = f'league_avg_{stat}_loss'
+                tables[column_name] = tables.apply(
+                    lambda row: league_loss_stats[stat].get(row['league'], 0), 
+                    axis=1
+                )
+
+                column_name = f'Opponent_avg_{stat}_allowed_win'
+                tables[column_name] = tables.apply(
+                    lambda row: Opponent_win_allowed_stats[stat].get(row['Opponent'], 0), 
+                    axis=1
+                )
+
+                column_name = f'Opponent_avg_{stat}_allowed_loss'
+                tables[column_name] = tables.apply(
+                    lambda row: Opponent_loss_allowed_stats[stat].get(row['Opponent'], 0), 
+                    axis=1
+                )
+
+                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
+                )
+
+                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['overall_win_kills_boost'] = tables['Opponent_avg_kills_allowed_win'] / tables['league_avg_kills_win']
+            tables['overall_win_deaths_boost'] = tables['Opponent_avg_deaths_allowed_win'] / tables['league_avg_deaths_win']
+            tables['overall_win_assists_boost'] = tables['Opponent_avg_assists_allowed_win'] / tables['league_avg_assists_win']
+            tables['overall_win_total_cs_boost'] = tables['Opponent_avg_total_cs_allowed_win'] / tables['league_avg_total_cs_win']
+            tables['overall_loss_kills_boost'] = tables['Opponent_avg_kills_allowed_loss'] / tables['league_avg_kills_loss']
+            tables['overall_loss_deaths_boost'] = tables['Opponent_avg_deaths_allowed_loss'] / tables['league_avg_deaths_loss']
+            tables['overall_loss_assists_boost'] = tables['Opponent_avg_assists_allowed_loss'] / tables['league_avg_assists_loss']
+            tables['overall_loss_total_cs_boost'] = tables['Opponent_avg_total_cs_allowed_loss'] / tables['league_avg_total_cs_loss']
+
+            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']
+
+            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']
+
+            if tables == raw_display:
+                player_tables = tables
+            else:
+                opp_tables = tables
 
-        raw_display['overall_win_kills_boost'] = raw_display['Opponent_avg_kills_allowed_win'] / raw_display['league_avg_kills_win']
-        raw_display['overall_win_deaths_boost'] = raw_display['Opponent_avg_deaths_allowed_win'] / raw_display['league_avg_deaths_win']
-        raw_display['overall_win_assists_boost'] = raw_display['Opponent_avg_assists_allowed_win'] / raw_display['league_avg_assists_win']
-        raw_display['overall_win_total_cs_boost'] = raw_display['Opponent_avg_total_cs_allowed_win'] / raw_display['league_avg_total_cs_win']
-        raw_display['overall_loss_kills_boost'] = raw_display['Opponent_avg_kills_allowed_loss'] / raw_display['league_avg_kills_loss']
-        raw_display['overall_loss_deaths_boost'] = raw_display['Opponent_avg_deaths_allowed_loss'] / raw_display['league_avg_deaths_loss']
-        raw_display['overall_loss_assists_boost'] = raw_display['Opponent_avg_assists_allowed_loss'] / raw_display['league_avg_assists_loss']
-        raw_display['overall_loss_total_cs_boost'] = raw_display['Opponent_avg_total_cs_allowed_loss'] / raw_display['league_avg_total_cs_loss']
-
-        raw_display['overall_win_kills_boost_pos'] = raw_display['Opponent_pos_avg_kills_allowed_win'] / raw_display['league_pos_avg_kills_win']
-        raw_display['overall_win_deaths_boost_pos'] = raw_display['Opponent_pos_avg_deaths_allowed_win'] / raw_display['league_pos_avg_deaths_win']
-        raw_display['overall_win_assists_boost_pos'] = raw_display['Opponent_pos_avg_assists_allowed_win'] / raw_display['league_pos_avg_assists_win']
-        raw_display['overall_win_total_cs_boost_pos'] = raw_display['Opponent_pos_avg_total_cs_allowed_win'] / raw_display['league_pos_avg_total_cs_win']
-        raw_display['overall_loss_kills_boost_pos'] = raw_display['Opponent_pos_avg_kills_allowed_loss'] / raw_display['league_pos_avg_kills_loss']
-        raw_display['overall_loss_deaths_boost_pos'] = raw_display['Opponent_pos_avg_deaths_allowed_loss'] / raw_display['league_pos_avg_deaths_loss']
-        raw_display['overall_loss_assists_boost_pos'] = raw_display['Opponent_pos_avg_assists_allowed_loss'] / raw_display['league_pos_avg_assists_loss']
-        raw_display['overall_loss_total_cs_boost_pos'] = raw_display['Opponent_pos_avg_total_cs_allowed_loss'] / raw_display['league_pos_avg_total_cs_loss']
-
-        raw_display['playername_avg_kill_share_win'] = raw_display['playername_avg_kills_win'] / raw_display['teamname_avg_kills_win']
-        raw_display['playername_avg_death_share_win'] = raw_display['playername_avg_deaths_win'] / raw_display['teamname_avg_deaths_win']
-        raw_display['playername_avg_assist_share_win'] = raw_display['playername_avg_assists_win'] / raw_display['teamname_avg_kills_win']
-        raw_display['playername_avg_cs_share_win'] = raw_display['playername_avg_total_cs_win'] / raw_display['teamname_avg_total_cs_win']
-        raw_display['playername_avg_kill_share_loss'] = raw_display['playername_avg_kills_loss'] / raw_display['teamname_avg_kills_loss']
-        raw_display['playername_avg_death_share_loss'] = raw_display['playername_avg_deaths_loss'] / raw_display['teamname_avg_deaths_loss']
-        raw_display['playername_avg_assist_share_loss'] = raw_display['playername_avg_assists_loss'] / raw_display['teamname_avg_kills_loss']
-        raw_display['playername_avg_cs_share_loss'] = raw_display['playername_avg_total_cs_loss'] / raw_display['teamname_avg_total_cs_loss']
         if kill_prediction > 0:
-            raw_display = raw_display[['playername', 'teamname', 'playername_avg_kill_share_win', 'playername_avg_death_share_win','playername_avg_assist_share_win',
+            player_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']]
-            raw_display = raw_display.rename(columns = {'playername_avg_kill_share_win': 'wKill%', 'playername_avg_death_share_win': 'wDeath%', 'playername_avg_assist_share_win': 'wAssist%',
+            player_tables = player_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 = raw_display.drop_duplicates(subset = ['playername'])
+            team_data = player_tables.drop_duplicates(subset = ['playername'])
 
             if win_loss == "Win":
                 team_data['Kill_Proj'] = team_data['wKill%'] * kill_prediction
                 team_data['Death_Proj'] = team_data['wDeath%'] * death_prediction
                 team_data['Assist_Proj'] = team_data['wAssist%'] * kill_prediction
-                team_data = team_data[['playername', 'teamname', 'wKill%', 'wDeath%', 'wAssist%', 'wCS', 'Kill_Proj', 'Death_Proj', 'Assist_Proj']]
+                team_data = team_data[['playername', 'teamname', 'position', 'Kill_Proj', 'Death_Proj', 'Assist_Proj', 'wCS']]
             else:
                 team_data['Kill_Proj'] = team_data['lKill%'] * kill_prediction
                 team_data['Death_Proj'] = team_data['lDeath%'] * death_prediction
                 team_data['Assist_Proj'] = team_data['lAssist%'] * kill_prediction
-                team_data = team_data[['playername', 'teamname', 'lKill%', 'lDeath%', 'lAssist%', 'lCS', 'Kill_Proj', 'Death_Proj', 'Assist_Proj']]
+                team_data = team_data[['playername', 'teamname', 'position', 'Kill_Proj', 'Death_Proj', 'Assist_Proj', 'lCS']]
         else:
-            raw_display = raw_display[['playername', 'teamname', 'playername_avg_kills_win', 'playername_avg_deaths_win', 'playername_avg_assists_win', 'playername_avg_total_cs_win',
+            player_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']]
-            raw_display = raw_display.rename(columns = {'playername_avg_kills_win': 'wKill%', 'playername_avg_deaths_win': 'wDeath%', 'playername_avg_assists_win': 'wAssist%',
+            player_tables = player_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 = raw_display.drop_duplicates(subset = ['playername'])
+            team_data = player_tables.drop_duplicates(subset = ['playername'])
 
             if win_loss == "Win":
                 team_data['Kill_Proj'] = team_data['wKill%']
                 team_data['Death_Proj'] = team_data['wDeath%']
                 team_data['Assist_Proj'] = team_data['wAssist%']
-                team_data = team_data[['playername', 'teamname', 'wKill%', 'wDeath%', 'wAssist%', 'wCS', 'Kill_Proj', 'Death_Proj', 'Assist_Proj']]
+                team_data = team_data[['playername', 'teamname', 'position', 'Kill_Proj', 'Death_Proj', 'Assist_Proj', 'wCS']]
             else:
                 team_data['Kill_Proj'] = team_data['lKill%']
                 team_data['Death_Proj'] = team_data['lDeath%']
                 team_data['Assist_Proj'] = team_data['lAssist%']
-                team_data = team_data[['playername', 'teamname', 'lKill%', 'lDeath%', 'lAssist%', 'lCS', 'Kill_Proj', 'Death_Proj', 'Assist_Proj']]
+                team_data = team_data[['playername', 'teamname', 'position', 'Kill_Proj', 'Death_Proj', 'Assist_Proj', 'lCS']]
 
         return team_data.dropna().reset_index(drop=True)
 
 if st.button("Run"):
-    st.dataframe(init_team_data(selected_team, win_loss, kill_prediction, death_prediction, start_date, end_date).style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(display_formats, precision=2), use_container_width = True)
+    st.dataframe(init_team_data(selected_team, selected_opponent, win_loss, kill_prediction, death_prediction, start_date, end_date).style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(display_formats, precision=2), use_container_width = True)