Refactor portfolio handling in app.py: replace direct references to the portfolio with a working_frame variable for improved clarity and maintainability, ensuring consistent data processing across various operations.

app.py

@@ -187,7 +187,6 @@ with tab1:
             
             # Update the portfolio in session state
             st.session_state['portfolio'] = portfolio
-            st.session_state['origin_portfolio'] = st.session_state['portfolio'].copy()
             
             # Store the match dictionary for reference
             st.session_state['portfolio_to_projection_matches'] = portfolio_match_dict
@@ -244,6 +243,7 @@ with tab1:
                     st.write(f"- {name}")
             else:
                 st.success("All portfolio names were matched to projections!")
+            working_frame = st.session_state['portfolio'].copy()
             st.session_state['origin_portfolio'] = st.session_state['portfolio'].copy()
 
 # with tab2:
@@ -761,6 +761,7 @@ with tab1:
 with tab2:
     if 'portfolio' in st.session_state and 'projections_df' in st.session_state:
         
+        
         excluded_cols = ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Stack', 'Win%', 'Lineup Edge', 'Weighted Own', 'Geomean']
         with st.container():
             
@@ -768,7 +769,7 @@ with tab2:
             with col1:
                 site_var = st.selectbox("Select Site", ['Draftkings', 'Fanduel'])
                 if st.button('Reset Portfolio', key='reset_port'):
-                    st.session_state['portfolio'] = st.session_state['origin_portfolio'].copy()
+                    working_frame = st.session_state['origin_portfolio'].copy()
                 if st.button('Clear data', key='reset3'):
                     st.session_state.clear()
                 
@@ -780,9 +781,34 @@ with tab2:
                 Contest_Size = st.number_input("Enter Contest Size", value=25000, min_value=1, step=1)
                 strength_var = st.selectbox("Select field strength", ['Average', 'Sharp', 'Weak'])
 
-        if site_var == 'Draftkings':
-            if type_var == 'Classic':
-                if sport_var == 'CS2':
+        if 'working_frame' not in st.session_state:
+            if site_var == 'Draftkings':
+                if type_var == 'Classic':
+                    if sport_var == 'CS2':
+                        map_dict = {
+                            'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])),
+                            'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])),
+                            'salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
+                            'proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])),
+                            'own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'])),
+                            'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))),
+                            'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'] * 1.5)),
+                            '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']))
+                        }
+                    elif sport_var != 'CS2':
+                        map_dict = {
+                            'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])),
+                            'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])),
+                            'salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
+                            'proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])),
+                            'own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'])),
+                            'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))),
+                            'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
+                            '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']))
+                        }
+                elif type_var == 'Showdown':
                     map_dict = {
                         'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])),
                         'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])),
@@ -794,19 +820,7 @@ 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']))
                     }
-                elif sport_var != 'CS2':
-                    map_dict = {
-                        'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])),
-                        'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])),
-                        'salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
-                        'proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])),
-                        'own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'])),
-                        'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))),
-                        'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
-                        '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']))
-                    }
-            elif type_var == 'Showdown':
+            elif site_var == 'Fanduel':
                 map_dict = {
                     'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])),
                     'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])),
@@ -814,72 +828,61 @@ with tab2:
                     'proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])),
                     'own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'])),
                     'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))),
-                    'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'] * 1.5)),
+                    'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
                     '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']))
                 }
-        elif site_var == 'Fanduel':
-            map_dict = {
-                'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])),
-                'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])),
-                'salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
-                'proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])),
-                'own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'])),
-                'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))),
-                'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
-                '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']))
-            }
-        if type_var == 'Classic':
-            if sport_var == 'CS2':
+            if type_var == 'Classic':
+                if sport_var == 'CS2':
+                    # Calculate salary (CPT uses cpt_salary_map, others use salary_map)
+                    st.session_state['working_frame']['salary'] = st.session_state['working_frame'].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
+                    )
+                    
+                    # Calculate median (CPT uses cpt_proj_map, others use proj_map)
+                    st.session_state['working_frame']['median'] = st.session_state['working_frame'].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
+                    )
+                    
+                    # Calculate ownership (CPT uses cpt_own_map, others use own_map)
+                    st.session_state['working_frame']['Own'] = st.session_state['working_frame'].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
+                    )
+
+                elif sport_var != 'CS2':
+                    st.session_state['working_frame']['salary'] = st.session_state['working_frame'].apply(lambda row: sum(map_dict['salary_map'].get(player, 0) for player in row), axis=1)
+                    st.session_state['working_frame']['median'] = st.session_state['working_frame'].apply(lambda row: sum(map_dict['proj_map'].get(player, 0) for player in row), axis=1)
+                    st.session_state['working_frame']['Own'] = st.session_state['working_frame'].apply(lambda row: sum(map_dict['own_map'].get(player, 0) for player in row), axis=1)
+                    if stack_dict is not None:
+                        st.session_state['working_frame']['Stack'] = st.session_state['working_frame'].index.map(stack_dict)
+            elif type_var == 'Showdown':
                 # Calculate salary (CPT uses cpt_salary_map, others use salary_map)
-                st.session_state['portfolio']['salary'] = st.session_state['portfolio'].apply(
+                st.session_state['working_frame']['salary'] = st.session_state['working_frame'].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
                 )
                 
                 # Calculate median (CPT uses cpt_proj_map, others use proj_map)
-                st.session_state['portfolio']['median'] = st.session_state['portfolio'].apply(
+                st.session_state['working_frame']['median'] = st.session_state['working_frame'].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
                 )
                 
                 # Calculate ownership (CPT uses cpt_own_map, others use own_map)
-                st.session_state['portfolio']['Own'] = st.session_state['portfolio'].apply(
+                st.session_state['working_frame']['Own'] = st.session_state['working_frame'].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
                 )
 
-            elif sport_var != 'CS2':
-                st.session_state['portfolio']['salary'] = st.session_state['portfolio'].apply(lambda row: sum(map_dict['salary_map'].get(player, 0) for player in row), axis=1)
-                st.session_state['portfolio']['median'] = st.session_state['portfolio'].apply(lambda row: sum(map_dict['proj_map'].get(player, 0) for player in row), axis=1)
-                st.session_state['portfolio']['Own'] = st.session_state['portfolio'].apply(lambda row: sum(map_dict['own_map'].get(player, 0) for player in row), axis=1)
-                if stack_dict is not None:
-                    st.session_state['portfolio']['Stack'] = st.session_state['portfolio'].index.map(stack_dict)
-        elif type_var == 'Showdown':
-            # Calculate salary (CPT uses cpt_salary_map, others use salary_map)
-            st.session_state['portfolio']['salary'] = st.session_state['portfolio'].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
-            )
-            
-            # Calculate median (CPT uses cpt_proj_map, others use proj_map)
-            st.session_state['portfolio']['median'] = st.session_state['portfolio'].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
-            )
-            
-            # Calculate ownership (CPT uses cpt_own_map, others use own_map)
-            st.session_state['portfolio']['Own'] = st.session_state['portfolio'].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
-            )
         col1, col2 = st.columns([2, 8])
         with col1:
             if 'trimming_dict_maxes' not in st.session_state:
@@ -903,16 +906,70 @@ with tab2:
                         stack_remove = st.multiselect("If Specific Stacks, Which to remove?", options=sorted(list(set(stack_dict.values()))), default=[])
                     
                     submitted = st.form_submit_button("Submit")
+                    if submitted:
+                        st.session_state['working_frame'] = predict_dupes(st.session_state['working_frame'], map_dict, site_var, type_var, Contest_Size, strength_var, sport_var)
+                        if 'trimming_dict_maxes' not in st.session_state:
+                            st.session_state['trimming_dict_maxes'] = {
+                                'Own': st.session_state['working_frame']['Own'].max(),
+                                'Geomean': st.session_state['working_frame']['Geomean'].max(),
+                                'Weighted Own': st.session_state['working_frame']['Weighted Own'].max(),
+                                'median': st.session_state['working_frame']['median'].max(),
+                                'Finish_percentile': st.session_state['working_frame']['Finish_percentile'].max()
+                            }
+                        st.session_state['working_frame'] = st.session_state['working_frame'][st.session_state['working_frame']['Dupes'] <= max_dupes]
+                        st.session_state['working_frame'] = st.session_state['working_frame'][st.session_state['working_frame']['salary'] >= min_salary]
+                        st.session_state['working_frame'] = st.session_state['working_frame'][st.session_state['working_frame']['salary'] <= max_salary]
+                        st.session_state['working_frame'] = st.session_state['working_frame'][st.session_state['working_frame']['Finish_percentile'] <= max_finish_percentile]
+                        st.session_state['working_frame'] = st.session_state['working_frame'][st.session_state['working_frame']['Lineup Edge'] >= min_lineup_edge]
+                        if stack_dict is not None:
+                            if stack_toggle == 'All Stacks':
+                                st.session_state['working_frame'] = st.session_state['working_frame']
+                                st.session_state['working_frame'] = st.session_state['working_frame'][~st.session_state['working_frame']['Stack'].isin(stack_remove)]
+                            else:
+                                st.session_state['working_frame'] = st.session_state['working_frame'][st.session_state['working_frame']['Stack'].isin(stack_selections)]
+                                st.session_state['working_frame'] = st.session_state['working_frame'][~st.session_state['working_frame']['Stack'].isin(stack_remove)]
+                        st.session_state['working_frame'] = st.session_state['working_frame'].sort_values(by='median', ascending=False)
+                        st.session_state['export_merge'] = st.session_state['working_frame'].copy()
+
             with st.expander('Micro Filter Options'):
                 with st.form(key='micro_filter_form'):
                     player_names = set()
-                    for col in st.session_state['portfolio'].columns:
+                    for col in st.session_state['working_frame'].columns:
                         if col not in excluded_cols:
-                            player_names.update(st.session_state['portfolio'][col].unique())
+                            player_names.update(st.session_state['working_frame'][col].unique())
                     player_lock = st.multiselect("Lock players?", options=sorted(list(player_names)), default=[])
                     player_remove = st.multiselect("Remove players?", options=sorted(list(player_names)), default=[])
                     
                     submitted = st.form_submit_button("Submit")
+                    if submitted:
+                        st.session_state['working_frame'] = predict_dupes(st.session_state['working_frame'], map_dict, site_var, type_var, Contest_Size, strength_var, sport_var)
+                        if 'trimming_dict_maxes' not in st.session_state:
+                            st.session_state['trimming_dict_maxes'] = {
+                                'Own': st.session_state['working_frame']['Own'].max(),
+                                'Geomean': st.session_state['working_frame']['Geomean'].max(),
+                                'Weighted Own': st.session_state['working_frame']['Weighted Own'].max(),
+                                'median': st.session_state['working_frame']['median'].max(),
+                                'Finish_percentile': st.session_state['working_frame']['Finish_percentile'].max()
+                            }
+                        if player_remove:
+                            # Create mask for lineups that contain any of the removed players
+                            player_columns = [col for col in st.session_state['working_frame'].columns if col not in excluded_cols]
+                            remove_mask = st.session_state['working_frame'][player_columns].apply(
+                                lambda row: not any(player in list(row) for player in player_remove), axis=1
+                            )
+                            st.session_state['working_frame'] = st.session_state['working_frame'][remove_mask]
+                        
+                        if player_lock:
+                            # Create mask for lineups that contain all locked players
+                            player_columns = [col for col in st.session_state['working_frame'].columns if col not in excluded_cols]
+                            
+                            lock_mask = st.session_state['working_frame'][player_columns].apply(
+                                lambda row: all(player in list(row) for player in player_lock), axis=1
+                            )
+                            st.session_state['working_frame'] = st.session_state['working_frame'][lock_mask]
+                        st.session_state['working_frame'] = st.session_state['working_frame'].sort_values(by='median', ascending=False)
+                        st.session_state['export_merge'] = st.session_state['working_frame'].copy()
+
             with st.expander('Trimming Options'):
                 st.info("Make sure you filter before trimming if you want to filter, trimming before a filter will reset your portfolio")
                 with st.form(key='trim_form'):
@@ -942,93 +999,26 @@ with tab2:
                     submitted = st.form_submit_button("Trim")
                     if submitted:
                         st.write('initiated')
-                        st.session_state['portfolio'] = predict_dupes(st.session_state['portfolio'], map_dict, site_var, type_var, Contest_Size, strength_var, sport_var)
+                        st.session_state['working_frame'] = predict_dupes(st.session_state['working_frame'], map_dict, site_var, type_var, Contest_Size, strength_var, sport_var)
                         if 'trimming_dict_maxes' not in st.session_state:
                             st.session_state['trimming_dict_maxes'] = {
-                                'Own': st.session_state['portfolio']['Own'].max(),
-                                'Geomean': st.session_state['portfolio']['Geomean'].max(),
-                                'Weighted Own': st.session_state['portfolio']['Weighted Own'].max(),
-                                'median': st.session_state['portfolio']['median'].max(),
-                                'Finish_percentile': st.session_state['portfolio']['Finish_percentile'].max()
+                                'Own': st.session_state['working_frame']['Own'].max(),
+                                'Geomean': st.session_state['working_frame']['Geomean'].max(),
+                                'Weighted Own': st.session_state['working_frame']['Weighted Own'].max(),
+                                'median': st.session_state['working_frame']['median'].max(),
+                                'Finish_percentile': st.session_state['working_frame']['Finish_percentile'].max()
                             }
-                        st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['Dupes'] <= max_dupes]
-                        st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['salary'] >= min_salary]
-                        st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['salary'] <= max_salary]
-                        st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['Finish_percentile'] <= max_finish_percentile]
-                        st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['Lineup Edge'] >= min_lineup_edge]
-                        if stack_dict is not None:
-                            if stack_toggle == 'All Stacks':
-                                st.session_state['portfolio'] = st.session_state['portfolio']
-                                st.session_state['portfolio'] = st.session_state['portfolio'][~st.session_state['portfolio']['Stack'].isin(stack_remove)]
-                            else:
-                                st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['Stack'].isin(stack_selections)]
-                                st.session_state['portfolio'] = st.session_state['portfolio'][~st.session_state['portfolio']['Stack'].isin(stack_remove)]
-                        if player_remove:
-                            # Create mask for lineups that contain any of the removed players
-                            player_columns = [col for col in st.session_state['portfolio'].columns if col not in excluded_cols]
-                            remove_mask = st.session_state['portfolio'][player_columns].apply(
-                                lambda row: not any(player in list(row) for player in player_remove), axis=1
-                            )
-                            st.session_state['portfolio'] = st.session_state['portfolio'][remove_mask]
                         
-                        if player_lock:
-                            # Create mask for lineups that contain all locked players
-                            player_columns = [col for col in st.session_state['portfolio'].columns if col not in excluded_cols]
-                            
-                            lock_mask = st.session_state['portfolio'][player_columns].apply(
-                                lambda row: all(player in list(row) for player in player_lock), axis=1
-                            )
-                            st.session_state['portfolio'] = st.session_state['portfolio'][lock_mask]
-                        
-                        st.session_state['portfolio'] = trim_portfolio(st.session_state['portfolio'], trim_slack_var, performance_type, own_type, performance_threshold_high, performance_threshold_low, own_threshold_high, own_threshold_low)
-                        st.session_state['portfolio'] = st.session_state['portfolio'].sort_values(by='median', ascending=False)
-                        st.session_state['export_merge'] = st.session_state['portfolio'].copy()
+                        st.session_state['working_frame'] = trim_portfolio(st.session_state['working_frame'], trim_slack_var, performance_type, own_type, performance_threshold_high, performance_threshold_low, own_threshold_high, own_threshold_low)
+                        st.session_state['working_frame'] = st.session_state['working_frame'].sort_values(by='median', ascending=False)
+                        st.session_state['export_merge'] = st.session_state['working_frame'].copy()
 
         with col2:
-            st.session_state['portfolio'] = predict_dupes(st.session_state['portfolio'], map_dict, site_var, type_var, Contest_Size, strength_var, sport_var)
-            if 'trimming_dict_maxes' not in st.session_state:
-                st.session_state['trimming_dict_maxes'] = {
-                    'Own': st.session_state['portfolio']['Own'].max(),
-                    'Geomean': st.session_state['portfolio']['Geomean'].max(),
-                    'Weighted Own': st.session_state['portfolio']['Weighted Own'].max(),
-                    'median': st.session_state['portfolio']['median'].max(),
-                    'Finish_percentile': st.session_state['portfolio']['Finish_percentile'].max()
-                }
-            st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['Dupes'] <= max_dupes]
-            st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['salary'] >= min_salary]
-            st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['salary'] <= max_salary]
-            st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['Finish_percentile'] <= max_finish_percentile]
-            st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['Lineup Edge'] >= min_lineup_edge]
-            if stack_dict is not None:
-                if stack_toggle == 'All Stacks':
-                    st.session_state['portfolio'] = st.session_state['portfolio']
-                    st.session_state['portfolio'] = st.session_state['portfolio'][~st.session_state['portfolio']['Stack'].isin(stack_remove)]
-                else:
-                    st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['Stack'].isin(stack_selections)]
-                    st.session_state['portfolio'] = st.session_state['portfolio'][~st.session_state['portfolio']['Stack'].isin(stack_remove)]
-            if player_remove:
-                # Create mask for lineups that contain any of the removed players
-                player_columns = [col for col in st.session_state['portfolio'].columns if col not in excluded_cols]
-                remove_mask = st.session_state['portfolio'][player_columns].apply(
-                    lambda row: not any(player in list(row) for player in player_remove), axis=1
-                )
-                st.session_state['portfolio'] = st.session_state['portfolio'][remove_mask]
-            
-            if player_lock:
-                # Create mask for lineups that contain all locked players
-                player_columns = [col for col in st.session_state['portfolio'].columns if col not in excluded_cols]
-                
-                lock_mask = st.session_state['portfolio'][player_columns].apply(
-                    lambda row: all(player in list(row) for player in player_lock), axis=1
-                )
-                st.session_state['portfolio'] = st.session_state['portfolio'][lock_mask]
-            st.session_state['portfolio'] = st.session_state['portfolio'].sort_values(by='median', ascending=False)
-            st.session_state['export_merge'] = st.session_state['portfolio'].copy()
             with st.expander("Download options"):
                 if stack_dict is not None:
                     download_type = st.selectbox("Simple or Advanced Download?", options=['Simple', 'Advanced'], key='download_choice')
                     if download_type == 'Simple':
-                        st.session_state['export_file'] = st.session_state['portfolio'].copy()
+                        st.session_state['export_file'] = st.session_state['working_frame'].copy()
                         for col in st.session_state['export_file'].columns:
                                     if col not in excluded_cols:
                                         st.session_state['export_file'][col] = st.session_state['export_file'][col].map(st.session_state['export_dict'])
@@ -1057,7 +1047,7 @@ with tab2:
                                         # Create a unique key for each number input
                                         key = f"stack_count_{stack}"
                                         # Get the current count of this stack in the portfolio
-                                        current_stack_count = len(st.session_state['portfolio'][st.session_state['portfolio']['Stack'] == stack])
+                                        current_stack_count = len(st.session_state['working_frame'][st.session_state['working_frame']['Stack'] == stack])
                                         # Create number input with current value and max value based on actual count
                                         st.session_state.stack_multipliers[stack] = st.number_input(
                                             f"{stack} count",
@@ -1068,7 +1058,7 @@ with tab2:
                                             key=key
                                         )
                             
-                            portfolio_copy = st.session_state['portfolio'].copy()
+                            portfolio_copy = st.session_state['working_frame'].copy()
                             
                             submitted = st.form_submit_button("Submit")
                             if submitted:
@@ -1095,9 +1085,9 @@ with tab2:
                                         st.session_state['export_file'][col] = st.session_state['export_file'][col].map(st.session_state['export_dict'])
                                 st.write('Export portfolio updated!')
                 else:
-                    st.session_state['export_file'] = st.session_state['portfolio'].copy()
+                    st.session_state['export_file'] = st.session_state['working_frame'].copy()
                     if 'export_base' not in st.session_state:
-                        st.session_state['export_base'] = pd.DataFrame(columns=st.session_state['portfolio'].columns)
+                        st.session_state['export_base'] = pd.DataFrame(columns=st.session_state['working_frame'].columns)
                     for col in st.session_state['export_file'].columns:
                                     if col not in excluded_cols:
                                         st.session_state['export_file'][col] = st.session_state['export_file'][col].map(st.session_state['export_dict'])
@@ -1114,10 +1104,10 @@ with tab2:
             
             # display_frame_source = st.selectbox("Display:", options=['Portfolio', 'Export Base'], key='display_frame_source')
             # if display_frame_source == 'Portfolio':
-            #     display_frame = st.session_state['portfolio']
+            #     display_frame = st.session_state['working_frame']
             # elif display_frame_source == 'Export Base':
             #     display_frame = st.session_state['export_base']
-            display_frame = st.session_state['portfolio']
+            display_frame = st.session_state['working_frame']
             total_rows = len(display_frame)
             rows_per_page = 500
             total_pages = (total_rows + rows_per_page - 1) // rows_per_page  # Ceiling division
@@ -1159,26 +1149,26 @@ with tab2:
             
         # Create player summary dataframe
         player_stats = []
-        player_columns = [col for col in st.session_state['portfolio'].columns if col not in excluded_cols]
+        player_columns = [col for col in st.session_state['working_frame'].columns if col not in excluded_cols]
         
         if type_var == 'Showdown':
             for player in player_names:
                 # Create mask for lineups where this player is Captain (first column)
-                cpt_mask = st.session_state['portfolio'][player_columns[0]] == player
+                cpt_mask = st.session_state['working_frame'][player_columns[0]] == player
                 
                 if cpt_mask.any():
                     player_stats.append({
                         'Player': f"{player} (CPT)",
                         'Lineup Count': cpt_mask.sum(),
-                        'Avg Median': st.session_state['portfolio'][cpt_mask]['median'].mean(),
-                        'Avg Own': st.session_state['portfolio'][cpt_mask]['Own'].mean(),
-                        'Avg Dupes': st.session_state['portfolio'][cpt_mask]['Dupes'].mean(),
-                        'Avg Finish %': st.session_state['portfolio'][cpt_mask]['Finish_percentile'].mean(),
-                        'Avg Lineup Edge': st.session_state['portfolio'][cpt_mask]['Lineup Edge'].mean(),
+                        'Avg Median': st.session_state['working_frame'][cpt_mask]['median'].mean(),
+                        'Avg Own': st.session_state['working_frame'][cpt_mask]['Own'].mean(),
+                        'Avg Dupes': st.session_state['working_frame'][cpt_mask]['Dupes'].mean(),
+                        'Avg Finish %': st.session_state['working_frame'][cpt_mask]['Finish_percentile'].mean(),
+                        'Avg Lineup Edge': st.session_state['working_frame'][cpt_mask]['Lineup Edge'].mean(),
                     })
                 
                 # Create mask for lineups where this player is FLEX (other columns)
-                flex_mask = st.session_state['portfolio'][player_columns[1:]].apply(
+                flex_mask = st.session_state['working_frame'][player_columns[1:]].apply(
                     lambda row: player in list(row), axis=1
                 )
                 
@@ -1186,32 +1176,32 @@ with tab2:
                     player_stats.append({
                         'Player': f"{player} (FLEX)",
                         'Lineup Count': flex_mask.sum(),
-                        'Avg Median': st.session_state['portfolio'][flex_mask]['median'].mean(),
-                        'Avg Own': st.session_state['portfolio'][flex_mask]['Own'].mean(),
-                        'Avg Dupes': st.session_state['portfolio'][flex_mask]['Dupes'].mean(),
-                        'Avg Finish %': st.session_state['portfolio'][flex_mask]['Finish_percentile'].mean(),
-                        'Avg Lineup Edge': st.session_state['portfolio'][flex_mask]['Lineup Edge'].mean(),
+                        'Avg Median': st.session_state['working_frame'][flex_mask]['median'].mean(),
+                        'Avg Own': st.session_state['working_frame'][flex_mask]['Own'].mean(),
+                        'Avg Dupes': st.session_state['working_frame'][flex_mask]['Dupes'].mean(),
+                        'Avg Finish %': st.session_state['working_frame'][flex_mask]['Finish_percentile'].mean(),
+                        'Avg Lineup Edge': st.session_state['working_frame'][flex_mask]['Lineup Edge'].mean(),
                     })
         else:
             if sport_var == 'CS2':
                 # Handle Captain positions
                 for player in player_names:
                     # Create mask for lineups where this player is Captain (first column)
-                    cpt_mask = st.session_state['portfolio'][player_columns[0]] == player
+                    cpt_mask = st.session_state['working_frame'][player_columns[0]] == player
                     
                     if cpt_mask.any():
                         player_stats.append({
                             'Player': f"{player} (CPT)",
                             'Lineup Count': cpt_mask.sum(),
-                            'Avg Median': st.session_state['portfolio'][cpt_mask]['median'].mean(),
-                            'Avg Own': st.session_state['portfolio'][cpt_mask]['Own'].mean(),
-                            'Avg Dupes': st.session_state['portfolio'][cpt_mask]['Dupes'].mean(),
-                            'Avg Finish %': st.session_state['portfolio'][cpt_mask]['Finish_percentile'].mean(),
-                            'Avg Lineup Edge': st.session_state['portfolio'][cpt_mask]['Lineup Edge'].mean(),
+                            'Avg Median': st.session_state['working_frame'][cpt_mask]['median'].mean(),
+                            'Avg Own': st.session_state['working_frame'][cpt_mask]['Own'].mean(),
+                            'Avg Dupes': st.session_state['working_frame'][cpt_mask]['Dupes'].mean(),
+                            'Avg Finish %': st.session_state['working_frame'][cpt_mask]['Finish_percentile'].mean(),
+                            'Avg Lineup Edge': st.session_state['working_frame'][cpt_mask]['Lineup Edge'].mean(),
                         })
                     
                     # Create mask for lineups where this player is FLEX (other columns)
-                    flex_mask = st.session_state['portfolio'][player_columns[1:]].apply(
+                    flex_mask = st.session_state['working_frame'][player_columns[1:]].apply(
                         lambda row: player in list(row), axis=1
                     )
                     
@@ -1219,16 +1209,16 @@ with tab2:
                         player_stats.append({
                             'Player': f"{player} (FLEX)",
                             'Lineup Count': flex_mask.sum(),
-                            'Avg Median': st.session_state['portfolio'][flex_mask]['median'].mean(),
-                            'Avg Own': st.session_state['portfolio'][flex_mask]['Own'].mean(),
-                            'Avg Dupes': st.session_state['portfolio'][flex_mask]['Dupes'].mean(),
-                            'Avg Finish %': st.session_state['portfolio'][flex_mask]['Finish_percentile'].mean(),
-                            'Avg Lineup Edge': st.session_state['portfolio'][flex_mask]['Lineup Edge'].mean(),
+                            'Avg Median': st.session_state['working_frame'][flex_mask]['median'].mean(),
+                            'Avg Own': st.session_state['working_frame'][flex_mask]['Own'].mean(),
+                            'Avg Dupes': st.session_state['working_frame'][flex_mask]['Dupes'].mean(),
+                            'Avg Finish %': st.session_state['working_frame'][flex_mask]['Finish_percentile'].mean(),
+                            'Avg Lineup Edge': st.session_state['working_frame'][flex_mask]['Lineup Edge'].mean(),
                         })
             elif sport_var != 'CS2':
                 # Original Classic format processing
                 for player in player_names:
-                    player_mask = st.session_state['portfolio'][player_columns].apply(
+                    player_mask = st.session_state['working_frame'][player_columns].apply(
                         lambda row: player in list(row), axis=1
                     )
                     
@@ -1236,11 +1226,11 @@ with tab2:
                         player_stats.append({
                             'Player': player,
                             'Lineup Count': player_mask.sum(),
-                            'Avg Median': st.session_state['portfolio'][player_mask]['median'].mean(),
-                            'Avg Own': st.session_state['portfolio'][player_mask]['Own'].mean(),
-                            'Avg Dupes': st.session_state['portfolio'][player_mask]['Dupes'].mean(),
-                            'Avg Finish %': st.session_state['portfolio'][player_mask]['Finish_percentile'].mean(),
-                            'Avg Lineup Edge': st.session_state['portfolio'][player_mask]['Lineup Edge'].mean(),
+                            'Avg Median': st.session_state['working_frame'][player_mask]['median'].mean(),
+                            'Avg Own': st.session_state['working_frame'][player_mask]['Own'].mean(),
+                            'Avg Dupes': st.session_state['working_frame'][player_mask]['Dupes'].mean(),
+                            'Avg Finish %': st.session_state['working_frame'][player_mask]['Finish_percentile'].mean(),
+                            'Avg Lineup Edge': st.session_state['working_frame'][player_mask]['Lineup Edge'].mean(),
                         })
         
         player_summary = pd.DataFrame(player_stats)