Refactor game type handling and player filtering in app.py

- Updated the logic for calculating metrics based on game type to utilize a working dataframe instead of directly modifying the session state 'Contest' dataframe, improving code clarity and maintainability.
- Enhanced the player filtering process by integrating it into the game type selection, allowing for more dynamic user interactions and better data management.
- This change streamlines the overall data processing workflow, ensuring accurate calculations and improved user experience.

app.py

@@ -101,98 +101,89 @@ with tab2:
             'cpt_proj_map': dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'] * 1.5)),
             'cpt_own_map': dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['captain ownership']))
         }
-        
-        st.session_state['type_var'] = 'Classic'
+        # Create a copy of the dataframe for calculations
+        working_df = st.session_state['Contest'].copy()
+
+        with col1:
+            with st.expander("Info and filters"):
+                if st.button('Clear data', key='reset3'):
+                    st.session_state.clear()
+                with st.form(key='filter_form'):
+                    type_var = st.selectbox("Select Game Type", ['Classic', 'Showdown'])
+                    entry_parse_var = st.selectbox("Do you want to view a specific player(s) or a group of players?", ['All', 'Specific'])
+                    entry_names = st.multiselect("Select players", options=st.session_state['entry_list'], default=[])
+                    submitted = st.form_submit_button("Submit")
+                    if submitted:
+                        if 'player_frame' in st.session_state:
+                            del st.session_state['player_frame']
+                            del st.session_state['stack_frame']
+                        # Apply entry name filter if specific entries are selected
+                        if entry_parse_var == 'Specific' and entry_names:
+                            working_df = working_df[working_df['BaseName'].isin(entry_names)]
 
         # Calculate metrics based on game type
-        if st.session_state['type_var'] == 'Classic':
-            st.session_state['Contest']['stack'] = st.session_state['Contest'].apply(
+        if type_var == 'Classic':
+            working_df['stack'] = working_df.apply(
                 lambda row: Counter(
                     map_dict['team_map'].get(player, '') for player in row[4:]
                     if map_dict['team_map'].get(player, '') != ''
                 ).most_common(1)[0][0] if any(map_dict['team_map'].get(player, '') for player in row[4:]) else '',
                 axis=1
             )
-            st.session_state['Contest']['stack_size'] = st.session_state['Contest'].apply(
+            working_df['stack_size'] = working_df.apply(
                 lambda row: Counter(
                     map_dict['team_map'].get(player, '') for player in row[4:]
                     if map_dict['team_map'].get(player, '') != ''
                 ).most_common(1)[0][1] if any(map_dict['team_map'].get(player, '') for player in row[4:]) else '',
                 axis=1
             )
-            st.session_state['Contest']['salary'] = st.session_state['Contest'].apply(lambda row: sum(map_dict['salary_map'].get(player, 0) for player in row), axis=1)
-            st.session_state['Contest']['median'] = st.session_state['Contest'].apply(lambda row: sum(map_dict['proj_map'].get(player, 0) for player in row), axis=1)
-            st.session_state['Contest']['actual_fpts'] = st.session_state['Contest'].apply(lambda row: sum(st.session_state['actual_dict'].get(player, 0) for player in row), axis=1)
-            st.session_state['Contest']['Own'] = st.session_state['Contest'].apply(lambda row: sum(map_dict['own_map'].get(player, 0) for player in row), axis=1)
-            st.session_state['Contest']['actual_own'] = st.session_state['Contest'].apply(lambda row: sum(st.session_state['ownership_dict'].get(player, 0) for player in row), axis=1)
-            st.session_state['Contest']['sorted'] = st.session_state['Contest'][player_columns].apply(
+            working_df['salary'] = working_df.apply(lambda row: sum(map_dict['salary_map'].get(player, 0) for player in row), axis=1)
+            working_df['median'] = working_df.apply(lambda row: sum(map_dict['proj_map'].get(player, 0) for player in row), axis=1)
+            working_df['actual_fpts'] = working_df.apply(lambda row: sum(st.session_state['actual_dict'].get(player, 0) for player in row), axis=1)
+            working_df['Own'] = working_df.apply(lambda row: sum(map_dict['own_map'].get(player, 0) for player in row), axis=1)
+            working_df['actual_own'] = working_df.apply(lambda row: sum(st.session_state['ownership_dict'].get(player, 0) for player in row), axis=1)
+            working_df['sorted'] = working_df[player_columns].apply(
                 lambda row: ','.join(sorted(row.values)),
                 axis=1
             )
-            st.session_state['Contest']['dupes'] = st.session_state['Contest'].groupby('sorted').transform('size')
-            st.session_state['Contest'] = st.session_state['Contest'].drop('sorted', axis=1)
-        elif st.session_state['type_var'] == 'Showdown':
-            st.session_state['Contest']['stack'] = st.session_state['Contest'].apply(
+            working_df['dupes'] = working_df.groupby('sorted').transform('size')
+            working_df = working_df.drop('sorted', axis=1)
+        elif type_var == 'Showdown':
+            working_df['stack'] = working_df.apply(
                 lambda row: Counter(
                     map_dict['team_map'].get(player, '') for player in row
                     if map_dict['team_map'].get(player, '') != ''
                 ).most_common(1)[0][0] if any(map_dict['team_map'].get(player, '') for player in row) else '',
                 axis=1
             )
-            st.session_state['Contest']['stack_size'] = st.session_state['Contest'].apply(
+            working_df['stack_size'] = working_df.apply(
                 lambda row: Counter(
                     map_dict['team_map'].get(player, '') for player in row
                     if map_dict['team_map'].get(player, '') != ''
                 ).most_common(1)[0][1] if any(map_dict['team_map'].get(player, '') for player in row) else '',
                 axis=1
             )
-            st.session_state['Contest']['salary'] = st.session_state['Contest'].apply(
+            working_df['salary'] = working_df.apply(
                 lambda row: map_dict['cpt_salary_map'].get(row.iloc[0], 0) + 
                             sum(map_dict['salary_map'].get(player, 0) for player in row.iloc[1:]),
                 axis=1
             )
-            st.session_state['Contest']['median'] = st.session_state['Contest'].apply(
+            working_df['median'] = working_df.apply(
                 lambda row: map_dict['cpt_proj_map'].get(row.iloc[0], 0) + 
                             sum(map_dict['proj_map'].get(player, 0) for player in row.iloc[1:]),
                 axis=1
             )
-            st.session_state['Contest']['Own'] = st.session_state['Contest'].apply(
+            working_df['Own'] = working_df.apply(
                 lambda row: map_dict['cpt_own_map'].get(row.iloc[0], 0) + 
                             sum(map_dict['own_map'].get(player, 0) for player in row.iloc[1:]),
                 axis=1
             )
-            st.session_state['Contest']['sorted'] = st.session_state['Contest'][player_columns].apply(
+            working_df['sorted'] = working_df[player_columns].apply(
                 lambda row: row[0] + '|' + ','.join(sorted(row[1:].values)),
                 axis=1
             )
-            st.session_state['Contest']['dupes'] = st.session_state['Contest'].groupby('sorted').transform('size')
-            st.session_state['Contest'] = st.session_state['Contest'].drop('sorted', axis=1)
-
-        # Create a copy of the dataframe for calculations
-        for col in player_columns:
-            contest_players = st.session_state['Contest'].copy()
-            players_1per = st.session_state['Contest'].head(int(len(st.session_state['Contest']) * 0.01))
-            players_5per = st.session_state['Contest'].head(int(len(st.session_state['Contest']) * 0.05))
-            players_10per = st.session_state['Contest'].head(int(len(st.session_state['Contest']) * 0.10))
-            players_20per = st.session_state['Contest'].head(int(len(st.session_state['Contest']) * 0.20))
-        working_df = st.session_state['Contest'].copy()
-
-        with col1:
-            with st.expander("Info and filters"):
-                if st.button('Clear data', key='reset3'):
-                    st.session_state.clear()
-                with st.form(key='filter_form'):
-                    st.session_state['type_var'] = st.selectbox("Select Game Type", ['Classic', 'Showdown'])
-                    entry_parse_var = st.selectbox("Do you want to view a specific player(s) or a group of players?", ['All', 'Specific'])
-                    entry_names = st.multiselect("Select players", options=st.session_state['entry_list'], default=[])
-                    submitted = st.form_submit_button("Submit")
-                    if submitted:
-                        if 'player_frame' in st.session_state:
-                            del st.session_state['player_frame']
-                            del st.session_state['stack_frame']
-                        # Apply entry name filter if specific entries are selected
-                        if entry_parse_var == 'Specific' and entry_names:
-                            working_df = working_df[working_df['BaseName'].isin(entry_names)]
+            working_df['dupes'] = working_df.groupby('sorted').transform('size')
+            working_df = working_df.drop('sorted', axis=1)
         
         # Initialize pagination in session state if not exists
         if 'current_page' not in st.session_state:
@@ -235,6 +226,17 @@ with tab2:
             hide_index=True
         )
 
+        for col in player_columns:
+            contest_players = working_df.copy()
+            players_1per = working_df.head(int(len(working_df) * 0.01))
+            players_5per = working_df.head(int(len(working_df) * 0.05))
+            players_10per = working_df.head(int(len(working_df) * 0.10))
+            players_20per = working_df.head(int(len(working_df) * 0.20))
+            contest_len = len(st.session_state['Contest'])
+            len_1per = len(st.session_state['Contest']).head(int(len(working_df) * 0.01))
+            len_5per = len(st.session_state['Contest']).head(int(len(working_df) * 0.05))
+            len_10per = len(st.session_state['Contest']).head(int(len(working_df) * 0.10))
+            len_20per = len(st.session_state['Contest']).head(int(len(working_df) * 0.20))
         player_counts = pd.Series(list(contest_players[player_columns].values.flatten())).value_counts()
         player_1per_counts = pd.Series(list(players_1per[player_columns].values.flatten())).value_counts()
         player_5per_counts = pd.Series(list(players_5per[player_columns].values.flatten())).value_counts()
@@ -252,13 +254,15 @@ with tab2:
         dupe_20per_counts = pd.Series(list(players_20per['dupes'])).value_counts()
         each_set_name = ['Overall', ' Top 1%', ' Top 5%', 'Top 10%', 'Top 20%']
         each_frame_set = [contest_players, players_1per, players_5per, players_10per, players_20per]
+        each_len_set = [contest_len, len_1per, len_5per, len_10per, len_20per]
         with st.container():
             tab1, tab2, tab3 = st.tabs(['Player Used Info', 'Stack Used Info', 'Duplication Info'])
             with tab1:
                 player_count_var = 0
                 for each_set in [player_counts, player_1per_counts, player_5per_counts, player_10per_counts, player20_per_counts]:
                     set_frame = each_set.to_frame().reset_index().rename(columns={'index': 'Player', 'count': 'Count'})
-                    set_frame['Percent'] = set_frame['Count'] / len(each_frame_set[player_count_var])
+                    st.write(len(each_frame_set[player_count_var]))
+                    set_frame['Percent'] = set_frame['Count'] / each_len_set[player_count_var]
                     set_frame = set_frame[['Player', 'Percent']]
                     set_frame = set_frame.rename(columns={'Percent': f'Exposure {each_set_name[player_count_var]}'})
                     if 'player_frame' not in st.session_state:
@@ -275,7 +279,8 @@ with tab2:
                 stack_count_var = 0
                 for each_set in [stack_counts, stack_1per_counts, stack_5per_counts, stack_10per_counts, stack_20per_counts]:
                     set_frame = each_set.to_frame().reset_index().rename(columns={'index': 'Stack', 'count': 'Count'})
-                    set_frame['Percent'] = set_frame['Count'] / len(each_frame_set[stack_count_var])
+                    st.write(len(each_frame_set[stack_count_var]))
+                    set_frame['Percent'] = set_frame['Count'] / each_len_set[stack_count_var]
                     set_frame = set_frame[['Stack', 'Percent']]
                     set_frame = set_frame.rename(columns={'Percent': f'Exposure {each_set_name[stack_count_var]}'})
                     if 'stack_frame' not in st.session_state:
@@ -292,7 +297,7 @@ with tab2:
                 dupe_count_var = 0
                 for each_set in [dupe_counts, dupe_1per_counts, dupe_5per_counts, dupe_10per_counts, dupe_20per_counts]:
                     set_frame = each_set.to_frame().reset_index().rename(columns={'index': 'Dupes', 'count': 'Count'})
-                    set_frame['Percent'] = set_frame['Count'] / len(each_frame_set[dupe_count_var])
+                    set_frame['Percent'] = set_frame['Count'] / each_len_set[dupe_count_var]
                     set_frame = set_frame[['Dupes', 'Percent']]
                     set_frame = set_frame.rename(columns={'Percent': f'Exposure {each_set_name[dupe_count_var]}'})
                     if 'dupe_frame' not in st.session_state: