Refactor session state handling in app.py

- Updated the management of player columns and mapping dictionaries to utilize session state, improving data consistency and accessibility.
- Enhanced filtering logic for user selections, ensuring that the displayed contest information reflects the latest user inputs and selections.
- Streamlined the application of calculations for player exposures and stack sizes, enhancing performance and user experience.

app.py

@@ -150,12 +150,12 @@ with tab1:
 with tab2:
     excluded_cols = ['BaseName', 'EntryCount']
     if 'Contest' in st.session_state and 'duplication_frame' not in st.session_state:
-        player_columns = [col for col in st.session_state['Contest'].columns if col not in excluded_cols]
-        for col in player_columns:
+        st.session_state['player_columns'] = [col for col in st.session_state['Contest'].columns if col not in excluded_cols]
+        for col in st.session_state['player_columns']:
             st.session_state['Contest'][col] = st.session_state['Contest'][col].astype(str)
     
         # Create mapping dictionaries
-        map_dict = {
+        st.session_state['map_dict'] = {
             'pos_map': st.session_state['pos_dict'],
             'team_map': st.session_state['team_dict'],
             'salary_map': st.session_state['salary_dict'],
@@ -168,22 +168,22 @@ with tab2:
         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 '',
+                    st.session_state['map_dict']['team_map'].get(player, '') for player in row[4:]
+                    if st.session_state['map_dict']['team_map'].get(player, '') != ''
+                ).most_common(1)[0][0] if any(st.session_state['map_dict']['team_map'].get(player, '') for player in row[4:]) else '',
                 axis=1
             )
             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 '',
+                    st.session_state['map_dict']['team_map'].get(player, '') for player in row[4:]
+                    if st.session_state['map_dict']['team_map'].get(player, '') != ''
+                ).most_common(1)[0][1] if any(st.session_state['map_dict']['team_map'].get(player, '') for player in row[4:]) else '',
                 axis=1
             )
-            working_df['salary'] = working_df.apply(lambda row: sum(map_dict['salary_map'].get(player, 0) for player in row), axis=1)
+            working_df['salary'] = working_df.apply(lambda row: sum(st.session_state['map_dict']['salary_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['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(
+            working_df['sorted'] = working_df[st.session_state['player_columns']].apply(
                 lambda row: ','.join(sorted(row.values)),
                 axis=1
             )
@@ -209,22 +209,22 @@ with tab2:
         elif type_var == 'Showdown':
             working_df['stack'] = working_df.apply(
                 lambda row: Counter(
-                    map_dict['team_map'].get(player, '') for player in row[2:]
-                    if map_dict['team_map'].get(player, '') != ''
-                ).most_common(1)[0][0] if any(map_dict['team_map'].get(player, '') for player in row[2:]) else '',
+                    st.session_state['map_dict']['team_map'].get(player, '') for player in row[2:]
+                    if st.session_state['map_dict']['team_map'].get(player, '') != ''
+                ).most_common(1)[0][0] if any(st.session_state['map_dict']['team_map'].get(player, '') for player in row[2:]) else '',
                 axis=1
             )
             working_df['stack_size'] = working_df.apply(
                 lambda row: Counter(
-                    map_dict['team_map'].get(player, '') for player in row[2:]
-                    if map_dict['team_map'].get(player, '') != ''
-                ).most_common(1)[0][1] if any(map_dict['team_map'].get(player, '') for player in row[2:]) else '',
+                    st.session_state['map_dict']['team_map'].get(player, '') for player in row[2:]
+                    if st.session_state['map_dict']['team_map'].get(player, '') != ''
+                ).most_common(1)[0][1] if any(st.session_state['map_dict']['team_map'].get(player, '') for player in row[2:]) else '',
                 axis=1
             )
             # Modified salary calculation with 1.5x multiplier for first player
             working_df['salary'] = working_df.apply(
-                lambda row: (map_dict['salary_map'].get(row[2], 0) * 1.5) + 
-                           sum(map_dict['salary_map'].get(player, 0) for player in row[3:]),
+                lambda row: (st.session_state['map_dict']['salary_map'].get(row[2], 0) * 1.5) + 
+                           sum(st.session_state['map_dict']['salary_map'].get(player, 0) for player in row[3:]),
                 axis=1
             )
             # Modified actual_fpts calculation with 1.5x multiplier for first player
@@ -234,7 +234,7 @@ with tab2:
                 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(
+            working_df['sorted'] = working_df[st.session_state['player_columns']].apply(
                 lambda row: ','.join(sorted(row.values)),
                 axis=1
             )
@@ -257,8 +257,9 @@ with tab2:
             working_df['finish'] = working_df['index']
             working_df = working_df.drop(['sorted', 'index'], axis=1)
         # working_df['stack_size'] = working_df['stack_size'].fillna(1).astype(int)
-        st.session_state['field_player_frame'] = create_player_exposures(working_df, player_columns)
+        st.session_state['field_player_frame'] = create_player_exposures(working_df, st.session_state['player_columns'])
         st.session_state['field_stack_frame'] = create_stack_exposures(working_df)
+        st.session_state['display_contest_info'] = working_df.copy()
 
         with st.expander("Info and filters"):
             st.info("Note that any filtering here needs to be reset manually, i.e. if you parse down the specific users and want to reset the table, just backtrack your filtering by setting it back to 'All'")
@@ -268,22 +269,22 @@ with tab2:
             with st.form(key='filter_form'):
                 users_var, entries_var, stack_var, stack_size_var, player_var = st.columns(5)
                 with users_var:
-                    entry_parse_var = st.selectbox("Do you want to view a specific user(s)?", ['All', 'Specific'], key = 'entry_parse_var')
-                    entry_names = st.multiselect("Select players", options=st.session_state['entry_list'], default=[], key = 'entry_names')
+                    st.session_state['entry_parse_var'] = st.selectbox("Do you want to view a specific user(s)?", ['All', 'Specific'], key = 'entry_parse_var')
+                    st.session_state['entry_names'] = st.multiselect("Select players", options=st.session_state['entry_list'], default=[], key = 'entry_names')
                 with entries_var:
-                    low_entries_var = st.number_input("Low end of entries range", min_value=0, max_value=150, value=1, key = 'low_entries_var')
-                    high_entries_var = st.number_input("High end of entries range", min_value=0, max_value=150, value=150, key = 'high_entries_var')
+                    st.session_state['low_entries_var'] = st.number_input("Low end of entries range", min_value=0, max_value=150, value=1, key = 'low_entries_var')
+                    st.session_state['high_entries_var'] = st.number_input("High end of entries range", min_value=0, max_value=150, value=150, key = 'high_entries_var')
                 with stack_var:
-                    stack_parse_var = st.selectbox("Do you want to view lineups with specific team(s)?", ['All', 'Specific'], key = 'stack_parse_var')
-                    stack_names = st.multiselect("Select teams", options=working_df['stack'].unique(), default=[], key = 'stack_names')
+                    st.session_state['stack_parse_var'] = st.selectbox("Do you want to view lineups with specific team(s)?", ['All', 'Specific'], key = 'stack_parse_var')
+                    st.session_state['stack_names'] = st.multiselect("Select teams", options=st.session_state['display_contest_info']['stack'].unique(), default=[], key = 'stack_names')
                 with stack_size_var:
-                    stack_size_parse_var = st.selectbox("Do you want to view a specific stack size(s)?", ['All', 'Specific'], key = 'stack_size_parse_var')
-                    stack_size_names = st.multiselect("Select stack sizes", options=working_df['stack_size'].unique(), default=[], key = 'stack_size_names')
+                    st.session_state['stack_size_parse_var'] = st.selectbox("Do you want to view a specific stack size(s)?", ['All', 'Specific'], key = 'stack_size_parse_var')
+                    st.session_state['stack_size_names'] = st.multiselect("Select stack sizes", options=st.session_state['display_contest_info']['stack_size'].unique(), default=[], key = 'stack_size_names')
                 with player_var:
-                    unique_players = pd.unique(working_df[player_columns].values.ravel('K'))
-                    unique_players = [p for p in unique_players if p != 'nan']  # Remove any NaN values
-                    player_parse_var = st.selectbox("Do you want to view lineups with specific player(s)?", ['All', 'Specific'], key = 'player_parse_var')
-                    player_names = st.multiselect("Select players", options=unique_players, default=[], key = 'player_names')
+                    st.session_state['unique_players'] = pd.unique(st.session_state['display_contest_info'][st.session_state['player_columns']].values.ravel('K'))
+                    st.session_state['unique_players'] = [p for p in st.session_state['unique_players'] if p != 'nan']  # Remove any NaN values
+                    st.session_state['player_parse_var'] = st.selectbox("Do you want to view lineups with specific player(s)?", ['All', 'Specific'], key = 'player_parse_var')
+                    st.session_state['player_names'] = st.multiselect("Select players", options=st.session_state['unique_players'], default=[], key = 'player_names')
                 submitted = st.form_submit_button("Submit")
                 if submitted:
                     if 'player_frame' in st.session_state:
@@ -291,17 +292,17 @@ with tab2:
                     if 'stack_frame' in st.session_state:
                         del st.session_state['stack_frame']
 
-                    if entry_parse_var == 'Specific' and entry_names:
-                        working_df = working_df[working_df['BaseName'].isin(entry_names)]
-                    if stack_parse_var == 'Specific' and stack_names:
-                        working_df = working_df[working_df['stack'].isin(stack_names)]
-                    if stack_size_parse_var == 'Specific' and stack_size_names:
-                        working_df = working_df[working_df['stack_size'].isin(stack_size_names)]
-                    if player_parse_var == 'Specific' and player_names:
-                        mask = working_df[player_columns].apply(lambda row: all(player in row.values for player in player_names), axis=1)
-                        working_df = working_df[mask]
-                    if low_entries_var and high_entries_var:
-                        working_df = working_df[working_df['EntryCount'].between(low_entries_var, high_entries_var)]
+                    if st.session_state['entry_parse_var'] == 'Specific' and st.session_state['entry_names']:
+                        st.session_state['display_contest_info'] = st.session_state['display_contest_info'][st.session_state['display_contest_info']['BaseName'].isin(st.session_state['entry_names'])]
+                    if st.session_state['stack_parse_var'] == 'Specific' and st.session_state['stack_names']:
+                        st.session_state['display_contest_info'] = st.session_state['display_contest_info'][st.session_state['display_contest_info']['stack'].isin(st.session_state['stack_names'])]
+                    if st.session_state['stack_size_parse_var'] == 'Specific' and st.session_state['stack_size_names']:
+                        st.session_state['display_contest_info'] = st.session_state['display_contest_info'][st.session_state['display_contest_info']['stack_size'].isin(st.session_state['stack_size_names'])]
+                    if st.session_state['player_parse_var'] == 'Specific' and st.session_state['player_names']:
+                        mask = st.session_state['display_contest_info'][st.session_state['player_columns']].apply(lambda row: all(player in row.values for player in st.session_state['player_names']), axis=1)
+                        st.session_state['display_contest_info'] = st.session_state['display_contest_info'][mask]
+                    if st.session_state['low_entries_var'] and st.session_state['high_entries_var']:
+                        st.session_state['display_contest_info'] = st.session_state['display_contest_info'][st.session_state['display_contest_info']['EntryCount'].between(st.session_state['low_entries_var'], st.session_state['high_entries_var'])]
             
         # Initialize pagination in session state if not exists
         if 'current_page' not in st.session_state:
@@ -309,7 +310,7 @@ with tab2:
 
         # Calculate total pages
         rows_per_page = 500
-        total_rows = len(working_df)
+        total_rows = len(st.session_state['display_contest_info'])
         total_pages = (total_rows + rows_per_page - 1) // rows_per_page
 
         # Create pagination controls in a single row
@@ -337,7 +338,7 @@ with tab2:
         start_idx = (st.session_state.current_page - 1) * rows_per_page
         end_idx = min((st.session_state.current_page) * rows_per_page, total_rows)
         st.dataframe(
-            working_df.iloc[start_idx:end_idx].style
+            st.session_state['display_contest_info'].iloc[start_idx:end_idx].style
             .background_gradient(axis=0)
             .background_gradient(cmap='RdYlGn')
             .format(precision=2), 
@@ -363,14 +364,14 @@ with tab2:
                         else:
                             pos_select = None
 
-                if entry_parse_var == 'All':
+                if st.session_state['entry_parse_var'] == 'All':
 
-                    st.session_state['player_frame'] = create_player_exposures(working_df, player_columns)
+                    st.session_state['player_frame'] = create_player_exposures(st.session_state['display_contest_info'], st.session_state['player_columns'])
                     hold_frame = st.session_state['player_frame'].copy()
                     if sport_select == 'GOLF':
                         hold_frame['Pos'] = 'G'
                     else:
-                        hold_frame['Pos'] = hold_frame['Player'].map(map_dict['pos_map'])
+                        hold_frame['Pos'] = hold_frame['Player'].map(st.session_state['map_dict']['pos_map'])
                     st.session_state['player_frame'].insert(1, 'Pos', hold_frame['Pos'])
                     st.session_state['player_frame'] = st.session_state['player_frame'].dropna(subset=['Pos'])
                     if pos_select:
@@ -383,12 +384,12 @@ with tab2:
                         hide_index=True)
                 else:
 
-                    st.session_state['player_frame'] = create_player_exposures(working_df, player_columns, entry_names)
+                    st.session_state['player_frame'] = create_player_exposures(st.session_state['display_contest_info'], st.session_state['player_columns'], st.session_state['entry_names'])
                     hold_frame = st.session_state['player_frame'].copy()
                     if sport_select == 'GOLF':
                         hold_frame['Pos'] = 'G'
                     else:
-                        hold_frame['Pos'] = hold_frame['Player'].map(map_dict['pos_map'])
+                        hold_frame['Pos'] = hold_frame['Player'].map(st.session_state['map_dict']['pos_map'])
                     st.session_state['player_frame'].insert(1, 'Pos', hold_frame['Pos'])
                     st.session_state['player_frame'] = st.session_state['player_frame'].dropna(subset=['Pos'])
                     if pos_select:
@@ -401,15 +402,15 @@ with tab2:
                         hide_index=True)
             with tab2:
 
-                if entry_parse_var == 'All':
-                    st.session_state['stack_frame'] = create_stack_exposures(working_df)
+                if st.session_state['entry_parse_var'] == 'All':
+                    st.session_state['stack_frame'] = create_stack_exposures(st.session_state['display_contest_info'])
                     st.dataframe(st.session_state['stack_frame'].
                         sort_values(by='Exposure Overall', ascending=False).
                         style.background_gradient(cmap='RdYlGn').
                         format(formatter='{:.2%}', subset=st.session_state['stack_frame'].iloc[:, 1:].select_dtypes(include=['number']).columns),
                         hide_index=True)
                 else:
-                    st.session_state['stack_frame'] = create_stack_exposures(working_df, entry_names)
+                    st.session_state['stack_frame'] = create_stack_exposures(st.session_state['display_contest_info'], st.session_state['entry_names'])
                     st.dataframe(st.session_state['stack_frame'].
                         sort_values(by='Exposure Overall', ascending=False).
                         style.background_gradient(cmap='RdYlGn').
@@ -417,15 +418,15 @@ with tab2:
                         hide_index=True)
             with tab3:
                 
-                if entry_parse_var == 'All':
-                    st.session_state['stack_size_frame'] = create_stack_size_exposures(working_df)
+                if st.session_state['entry_parse_var'] == 'All':
+                    st.session_state['stack_size_frame'] = create_stack_size_exposures(st.session_state['display_contest_info'])
                     st.dataframe(st.session_state['stack_size_frame'].
                         sort_values(by='Exposure Overall', ascending=False).
                         style.background_gradient(cmap='RdYlGn').
                         format(formatter='{:.2%}', subset=st.session_state['stack_size_frame'].iloc[:, 1:].select_dtypes(include=['number']).columns),
                         hide_index=True)
                 else:
-                    st.session_state['stack_size_frame'] = create_stack_size_exposures(working_df, entry_names)
+                    st.session_state['stack_size_frame'] = create_stack_size_exposures(st.session_state['display_contest_info'], st.session_state['entry_names'])
                     st.dataframe(st.session_state['stack_size_frame'].
                         sort_values(by='Exposure Overall', ascending=False).
                         style.background_gradient(cmap='RdYlGn').
@@ -434,12 +435,12 @@ with tab2:
             
             with tab4:
                 
-                if entry_parse_var == 'All':
-                    st.session_state['general_frame'] = create_general_exposures(working_df)
+                if st.session_state['entry_parse_var'] == 'All':
+                    st.session_state['general_frame'] = create_general_exposures(st.session_state['display_contest_info'])
                     st.dataframe(st.session_state['general_frame'].style.background_gradient(cmap='RdYlGn', axis=1).format(precision=2), hide_index=True)
                     
                 else:
-                    st.session_state['general_frame'] = create_general_exposures(working_df, entry_names)
+                    st.session_state['general_frame'] = create_general_exposures(st.session_state['display_contest_info'], st.session_state['entry_names'])
                     st.dataframe(st.session_state['general_frame'].style.background_gradient(cmap='RdYlGn', axis=1).format(precision=2), hide_index=True)
 
             with tab5:
@@ -448,7 +449,7 @@ with tab2:
                     with col1:
                         user_dupe_var = st.selectbox("Which usage(s) would you like to view?",  ['All', 'Specific'], key='user_dupe_var')
                     with col2:
-                        user_dupe_select = st.multiselect("Select your user(s)", working_df['BaseName'].sort_values().unique(), key='user_dupe_select')
+                        user_dupe_select = st.multiselect("Select your user(s)", st.session_state['display_contest_info']['BaseName'].sort_values().unique(), key='user_dupe_select')
                     submitted = st.form_submit_button("Submit")
                     if submitted:
                         if user_dupe_var == 'Specific':