Implement vectorized calculations for salary, median, and ownership in app.py to enhance performance and memory efficiency. Refactor reassess_edge and stratification_function to minimize DataFrame copies and improve memory management. Update filtering logic to use boolean masks for better efficiency.

app.py

@@ -204,6 +204,134 @@ def create_memory_efficient_mappings(projections_df, site_var, type_var, sport_v
     
     return base_mappings
 
+def calculate_salary_vectorized(df, player_columns, map_dict, type_var, sport_var):
+    """Vectorized salary calculation to replace expensive apply operations"""
+    if type_var == 'Classic' and (sport_var == 'CS2' or sport_var == 'LOL'):
+        # Captain + flex calculations
+        cpt_salaries = df.iloc[:, 0].map(map_dict['cpt_salary_map']).fillna(0)
+        flex_salaries = sum(df.iloc[:, i].map(map_dict['salary_map']).fillna(0) for i in range(1, len(player_columns)))
+        return cpt_salaries + flex_salaries
+    elif type_var == 'Showdown':
+        if sport_var == 'GOLF':
+            return sum(df[col].map(map_dict['salary_map']).fillna(0) for col in player_columns)
+        else:
+            cpt_salaries = df.iloc[:, 0].map(map_dict['cpt_salary_map']).fillna(0)
+            flex_salaries = sum(df.iloc[:, i].map(map_dict['salary_map']).fillna(0) for i in range(1, len(player_columns)))
+            return cpt_salaries + flex_salaries
+    else:
+        # Classic non-CS2/LOL
+        return sum(df[col].map(map_dict['salary_map']).fillna(0) for col in player_columns)
+
+def calculate_median_vectorized(df, player_columns, map_dict, type_var, sport_var):
+    """Vectorized median calculation to replace expensive apply operations"""
+    if type_var == 'Classic' and (sport_var == 'CS2' or sport_var == 'LOL'):
+        cpt_medians = df.iloc[:, 0].map(map_dict['cpt_proj_map']).fillna(0)
+        flex_medians = sum(df.iloc[:, i].map(map_dict['proj_map']).fillna(0) for i in range(1, len(player_columns)))
+        return cpt_medians + flex_medians
+    elif type_var == 'Showdown':
+        if sport_var == 'GOLF':
+            return sum(df[col].map(map_dict['proj_map']).fillna(0) for col in player_columns)
+        else:
+            cpt_medians = df.iloc[:, 0].map(map_dict['cpt_proj_map']).fillna(0)
+            flex_medians = sum(df.iloc[:, i].map(map_dict['proj_map']).fillna(0) for i in range(1, len(player_columns)))
+            return cpt_medians + flex_medians
+    else:
+        return sum(df[col].map(map_dict['proj_map']).fillna(0) for col in player_columns)
+
+def calculate_ownership_vectorized(df, player_columns, map_dict, type_var, sport_var):
+    """Vectorized ownership calculation to replace expensive apply operations"""
+    if type_var == 'Classic' and (sport_var == 'CS2' or sport_var == 'LOL'):
+        cpt_own = df.iloc[:, 0].map(map_dict['cpt_own_map']).fillna(0)
+        flex_own = sum(df.iloc[:, i].map(map_dict['own_map']).fillna(0) for i in range(1, len(player_columns)))
+        return cpt_own + flex_own
+    elif type_var == 'Showdown':
+        if sport_var == 'GOLF':
+            return sum(df[col].map(map_dict['own_map']).fillna(0) for col in player_columns)
+        else:
+            cpt_own = df.iloc[:, 0].map(map_dict['cpt_own_map']).fillna(0)
+            flex_own = sum(df.iloc[:, i].map(map_dict['own_map']).fillna(0) for i in range(1, len(player_columns)))
+            return cpt_own + flex_own
+    else:
+        return sum(df[col].map(map_dict['own_map']).fillna(0) for col in player_columns)
+
+def calculate_lineup_metrics(df, player_columns, map_dict, type_var, sport_var, projections_df=None):
+    """Centralized function to calculate salary, median, and ownership efficiently"""
+    df = df.copy()  # Work on a copy to avoid modifying original
+    
+    # Vectorized calculations
+    df['salary'] = calculate_salary_vectorized(df[player_columns], player_columns, map_dict, type_var, sport_var)
+    df['median'] = calculate_median_vectorized(df[player_columns], player_columns, map_dict, type_var, sport_var)
+    df['Own'] = calculate_ownership_vectorized(df[player_columns], player_columns, map_dict, type_var, sport_var)
+    
+    # Handle stacking for specific sports
+    if projections_df is not None and 'team' in projections_df.columns:
+        team_dict = dict(zip(projections_df['player_names'], projections_df['team']))
+        
+        if type_var == 'Classic' and sport_var not in ['CS2', 'LOL', 'GOLF']:
+            # Stack calculation for classic sports (excluding first 2 columns for pitchers)
+            stack_columns = player_columns[2:] if len(player_columns) > 2 else player_columns
+            df['Stack'] = df[stack_columns].apply(
+                lambda row: Counter(
+                    team_dict.get(player, '') for player in row
+                    if team_dict.get(player, '') != ''
+                ).most_common(1)[0][0] if any(team_dict.get(player, '') for player in row) else '',
+                axis=1
+            )
+            df['Size'] = df[stack_columns].apply(
+                lambda row: Counter(
+                    team_dict.get(player, '') for player in row
+                    if team_dict.get(player, '') != ''
+                ).most_common(1)[0][1] if any(team_dict.get(player, '') for player in row) else 0,
+                axis=1
+            )
+        elif sport_var == 'LOL':
+            # LOL uses all player columns for stacking
+            df['Stack'] = df[player_columns].apply(
+                lambda row: Counter(
+                    team_dict.get(player, '') for player in row
+                    if team_dict.get(player, '') != ''
+                ).most_common(1)[0][0] if any(team_dict.get(player, '') for player in row) else '',
+                axis=1
+            )
+            df['Size'] = df[player_columns].apply(
+                lambda row: Counter(
+                    team_dict.get(player, '') for player in row
+                    if team_dict.get(player, '') != ''
+                ).most_common(1)[0][1] if any(team_dict.get(player, '') for player in row) else 0,
+                axis=1
+            )
+    
+    # Optimize data types
+    df['salary'] = df['salary'].astype('uint16')
+    df['median'] = df['median'].astype('float32')
+    
+    return df
+
+def create_team_filter_mask(df, player_columns, team_map, teams_to_filter, focus_type='Overall', type_var='Classic'):
+    """Create boolean mask for team filtering without creating intermediate DataFrames"""
+    mask = pd.Series(False, index=df.index)
+    
+    if type_var == 'Showdown' and focus_type != 'Overall':
+        if focus_type == 'CPT':
+            focus_columns = [player_columns[0]]  # First column only
+        elif focus_type == 'FLEX':
+            focus_columns = player_columns[1:]  # All except first
+        else:
+            focus_columns = player_columns
+    else:
+        # For Classic or Overall focus, use appropriate columns
+        if type_var == 'Classic':
+            focus_columns = [col for col in player_columns if col not in ['SP1', 'SP2']]  # Exclude pitchers
+        else:
+            focus_columns = player_columns
+    
+    for team in teams_to_filter:
+        for col in focus_columns:
+            team_mask = df[col].map(team_map) == team
+            mask |= team_mask
+    
+    return mask
+
 def create_position_export_dict(column_name, csv_file, site_var, type_var, sport_var):
     try:
         # Remove any numbers from the column name to get the position
@@ -1143,60 +1271,20 @@ if selected_tab == 'Manage Portfolio':
             st.session_state['working_frame'] = pd.read_parquet(io.BytesIO(st.session_state['origin_portfolio']))
             st.session_state['player_columns'] = [col for col in st.session_state['working_frame'].columns if col not in excluded_cols]
             
-            if type_var == 'Classic':
-                if sport_var == 'CS2' or sport_var == 'LOL':
-                    # 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: st.session_state['map_dict']['cpt_salary_map'].get(row.iloc[0], 0) + 
-                                sum(st.session_state['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: st.session_state['map_dict']['cpt_proj_map'].get(row.iloc[0], 0) + 
-                                sum(st.session_state['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: st.session_state['map_dict']['cpt_own_map'].get(row.iloc[0], 0) + 
-                                sum(st.session_state['map_dict']['own_map'].get(player, 0) for player in row.iloc[1:]),
-                        axis=1
-                    )
-
-                elif sport_var != 'CS2' and sport_var != 'LOL':
-                    st.session_state['working_frame']['salary'] = st.session_state['working_frame'].apply(lambda row: sum(st.session_state['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(st.session_state['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(st.session_state['map_dict']['own_map'].get(player, 0) for player in row), axis=1)
-                    if 'stack_dict' in st.session_state:
-                        st.session_state['working_frame']['Stack'] = st.session_state['working_frame'].index.map(st.session_state['stack_dict'])
-                        st.session_state['working_frame']['Size'] = st.session_state['working_frame'].index.map(st.session_state['size_dict'])
-            elif type_var == 'Showdown':
-                # 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: st.session_state['map_dict']['cpt_salary_map'].get(row.iloc[0], 0) + 
-                            sum(st.session_state['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: st.session_state['map_dict']['cpt_proj_map'].get(row.iloc[0], 0) + 
-                            sum(st.session_state['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: st.session_state['map_dict']['cpt_own_map'].get(row.iloc[0], 0) + 
-                            sum(st.session_state['map_dict']['own_map'].get(player, 0) for player in row.iloc[1:]),
-                    axis=1
-                )
-            # st.session_state['working_frame']['Own'] = st.session_state['working_frame']['Own'].astype('float32')
-            st.session_state['working_frame']['median'] = st.session_state['working_frame']['median'].astype('float32')
-            st.session_state['working_frame']['salary'] = st.session_state['working_frame']['salary'].astype('uint16')
+            # Use vectorized calculation function
+            st.session_state['working_frame'] = calculate_lineup_metrics(
+                st.session_state['working_frame'], 
+                st.session_state['player_columns'], 
+                st.session_state['map_dict'], 
+                type_var, 
+                sport_var, 
+                st.session_state['projections_df'] if 'stack_dict' in st.session_state else None
+            )
+            
+            # Map existing stack/size data if available
+            if 'stack_dict' in st.session_state:
+                st.session_state['working_frame']['Stack'] = st.session_state['working_frame'].index.map(st.session_state['stack_dict'])
+                st.session_state['working_frame']['Size'] = st.session_state['working_frame'].index.map(st.session_state['size_dict'])
             
             st.session_state['base_frame'] = predict_dupes(st.session_state['working_frame'], st.session_state['map_dict'], site_var, type_var, Contest_Size, strength_var, sport_var, salary_max)
             st.session_state['working_frame'] = st.session_state['base_frame'].copy()
@@ -1259,60 +1347,60 @@ if selected_tab == 'Manage Portfolio':
                     
                     if reg_submitted:
                         st.session_state['settings_base'] = False
-                        parsed_frame = st.session_state['working_frame'].copy()
                         
-                        parsed_frame = parsed_frame[parsed_frame['salary'] >= min_salary]
-                        parsed_frame = parsed_frame[parsed_frame['salary'] <= max_salary]
-                        parsed_frame = parsed_frame[parsed_frame['median'] >= min_proj]
-                        parsed_frame = parsed_frame[parsed_frame['median'] <= max_proj]
-                        parsed_frame = parsed_frame[parsed_frame['Own'] >= min_own]
-                        parsed_frame = parsed_frame[parsed_frame['Own'] <= max_own]
-                        parsed_frame = parsed_frame[parsed_frame['Dupes'] >= min_dupes]
-                        parsed_frame = parsed_frame[parsed_frame['Dupes'] <= max_dupes]
-                        parsed_frame = parsed_frame[parsed_frame['Finish_percentile'] >= min_finish_percentile]
-                        parsed_frame = parsed_frame[parsed_frame['Finish_percentile'] <= max_finish_percentile]
-                        parsed_frame = parsed_frame[parsed_frame['Lineup Edge'] >= min_lineup_edge]
-                        parsed_frame = parsed_frame[parsed_frame['Lineup Edge'] <= max_lineup_edge]
+                        # Use index-based filtering instead of copying DataFrame
+                        filter_mask = (
+                            (st.session_state['working_frame']['salary'] >= min_salary) &
+                            (st.session_state['working_frame']['salary'] <= max_salary) &
+                            (st.session_state['working_frame']['median'] >= min_proj) &
+                            (st.session_state['working_frame']['median'] <= max_proj) &
+                            (st.session_state['working_frame']['Own'] >= min_own) &
+                            (st.session_state['working_frame']['Own'] <= max_own) &
+                            (st.session_state['working_frame']['Dupes'] >= min_dupes) &
+                            (st.session_state['working_frame']['Dupes'] <= max_dupes) &
+                            (st.session_state['working_frame']['Finish_percentile'] >= min_finish_percentile) &
+                            (st.session_state['working_frame']['Finish_percentile'] <= max_finish_percentile) &
+                            (st.session_state['working_frame']['Lineup Edge'] >= min_lineup_edge) &
+                            (st.session_state['working_frame']['Lineup Edge'] <= max_lineup_edge)
+                        )
                         
                         
-                        if 'Stack' in parsed_frame.columns:
-                            if stack_include_toggle == 'All Stacks':
-                                parsed_frame = parsed_frame
-                            else:
-                                parsed_frame = parsed_frame[parsed_frame['Stack'].isin(stack_selections)]
+                        # Handle stack filtering
+                        if 'Stack' in st.session_state['working_frame'].columns:
+                            if stack_include_toggle != 'All Stacks':
+                                filter_mask &= st.session_state['working_frame']['Stack'].isin(stack_selections)
                             if stack_remove_toggle == 'Yes':
-                                parsed_frame = parsed_frame[~parsed_frame['Stack'].isin(stack_remove)]
-                            else:
-                                parsed_frame = parsed_frame
-                        st.session_state['working_frame'] = parsed_frame.sort_values(by='median', ascending=False).reset_index(drop=True)
+                                filter_mask &= ~st.session_state['working_frame']['Stack'].isin(stack_remove)
+                        
+                        # Apply all filters at once
+                        st.session_state['working_frame'] = st.session_state['working_frame'][filter_mask].sort_values(by='median', ascending=False).reset_index(drop=True)
                         st.session_state['export_merge'] = st.session_state['working_frame'].copy()
                     if exp_submitted:
                         st.session_state['settings_base'] = False
-                        parsed_frame = st.session_state['export_base'].copy()
-
-                        parsed_frame = parsed_frame[parsed_frame['salary'] >= min_salary]
-                        parsed_frame = parsed_frame[parsed_frame['salary'] <= max_salary]
-                        parsed_frame = parsed_frame[parsed_frame['median'] >= min_proj]
-                        parsed_frame = parsed_frame[parsed_frame['median'] <= max_proj]
-                        parsed_frame = parsed_frame[parsed_frame['Own'] >= min_own]
-                        parsed_frame = parsed_frame[parsed_frame['Own'] <= max_own]
-                        parsed_frame = parsed_frame[parsed_frame['Dupes'] >= min_dupes]
-                        parsed_frame = parsed_frame[parsed_frame['Dupes'] <= max_dupes]
-                        parsed_frame = parsed_frame[parsed_frame['Finish_percentile'] >= min_finish_percentile]
-                        parsed_frame = parsed_frame[parsed_frame['Finish_percentile'] <= max_finish_percentile]
-                        parsed_frame = parsed_frame[parsed_frame['Lineup Edge'] >= min_lineup_edge]
-                        parsed_frame = parsed_frame[parsed_frame['Lineup Edge'] <= max_lineup_edge]
-
-                        if 'Stack' in parsed_frame.columns:
-                            if stack_include_toggle == 'All Stacks':
-                                parsed_frame = parsed_frame
-                            else:
-                                parsed_frame = parsed_frame[parsed_frame['Stack'].isin(stack_selections)]
+                        
+                        # Use index-based filtering for export_base
+                        export_filter_mask = (
+                            (st.session_state['export_base']['salary'] >= min_salary) &
+                            (st.session_state['export_base']['salary'] <= max_salary) &
+                            (st.session_state['export_base']['median'] >= min_proj) &
+                            (st.session_state['export_base']['median'] <= max_proj) &
+                            (st.session_state['export_base']['Own'] >= min_own) &
+                            (st.session_state['export_base']['Own'] <= max_own) &
+                            (st.session_state['export_base']['Dupes'] >= min_dupes) &
+                            (st.session_state['export_base']['Dupes'] <= max_dupes) &
+                            (st.session_state['export_base']['Finish_percentile'] >= min_finish_percentile) &
+                            (st.session_state['export_base']['Finish_percentile'] <= max_finish_percentile) &
+                            (st.session_state['export_base']['Lineup Edge'] >= min_lineup_edge) &
+                            (st.session_state['export_base']['Lineup Edge'] <= max_lineup_edge)
+                        )
+
+                        if 'Stack' in st.session_state['export_base'].columns:
+                            if stack_include_toggle != 'All Stacks':
+                                export_filter_mask &= st.session_state['export_base']['Stack'].isin(stack_selections)
                             if stack_remove_toggle == 'Yes':
-                                parsed_frame = parsed_frame[~parsed_frame['Stack'].isin(stack_remove)]
-                            else:
-                                parsed_frame = parsed_frame
-                        st.session_state['export_base'] = parsed_frame.sort_values(by='median', ascending=False).reset_index(drop=True)
+                                export_filter_mask &= ~st.session_state['export_base']['Stack'].isin(stack_remove)
+                        
+                        st.session_state['export_base'] = st.session_state['export_base'][export_filter_mask].sort_values(by='median', ascending=False).reset_index(drop=True)
                         st.session_state['export_merge'] = st.session_state['export_base'].copy()
 
             with st.expander('Micro Filter Options'):
@@ -1923,189 +2011,39 @@ if selected_tab == 'Manage Portfolio':
                         exp_submitted = st.form_submit_button("Export")
                     if reg_submitted:
                         st.session_state['settings_base'] = False
-                        prior_frame = st.session_state['working_frame'].copy()
                         parsed_frame = exposure_spread(st.session_state['working_frame'], st.session_state['exposure_player'], exposure_target, ignore_stacks, remove_teams_exposure, specific_replacements, specific_columns, st.session_state['projections_df'], sport_var, type_var, salary_max, stacking_sports)
                         
-                        if type_var == 'Classic':
-                            if sport_var == 'CS2' or sport_var == 'LOL':
-                                # Calculate salary (CPT uses cpt_salary_map, others use salary_map)
-                                parsed_frame['salary'] = parsed_frame.apply(
-                                    lambda row: st.session_state['map_dict']['cpt_salary_map'].get(row.iloc[0], 0) + 
-                                            sum(st.session_state['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)
-                                parsed_frame['median'] = parsed_frame.apply(
-                                    lambda row: st.session_state['map_dict']['cpt_proj_map'].get(row.iloc[0], 0) + 
-                                            sum(st.session_state['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)
-                                parsed_frame['Own'] = parsed_frame.apply(
-                                    lambda row: st.session_state['map_dict']['cpt_own_map'].get(row.iloc[0], 0) + 
-                                            sum(st.session_state['map_dict']['own_map'].get(player, 0) for player in row.iloc[1:]),
-                                    axis=1
-                                )
-
-                            elif sport_var != 'CS2' and sport_var != 'LOL':
-                                parsed_frame['salary'] = parsed_frame.apply(lambda row: sum(st.session_state['map_dict']['salary_map'].get(player, 0) for player in row), axis=1)
-                                parsed_frame['median'] = parsed_frame.apply(lambda row: sum(st.session_state['map_dict']['proj_map'].get(player, 0) for player in row), axis=1)
-                                parsed_frame['Own'] = parsed_frame.apply(lambda row: sum(st.session_state['map_dict']['own_map'].get(player, 0) for player in row), axis=1)
-                                if 'stack_dict' in st.session_state:
-                                    team_dict = dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team']))
-                                    if sport_var == 'LOL':
-                                        parsed_frame['Stack'] = parsed_frame.apply(
-                                            lambda row: Counter(
-                                                team_dict.get(player, '') for player in row
-                                                if team_dict.get(player, '') != ''
-                                            ).most_common(1)[0][0] if any(team_dict.get(player, '') for player in row) else '',
-                                            axis=1
-                                        )
-                                        parsed_frame['Size'] = parsed_frame.apply(
-                                            lambda row: Counter(
-                                                team_dict.get(player, '') for player in row
-                                                if team_dict.get(player, '') != ''
-                                            ).most_common(1)[0][1] if any(team_dict.get(player, '') for player in row) else 0,
-                                            axis=1
-                                        )
-                                    else:
-                                        parsed_frame['Stack'] = parsed_frame.apply(
-                                            lambda row: Counter(
-                                                team_dict.get(player, '') for player in row[2:]
-                                                if team_dict.get(player, '') != ''
-                                            ).most_common(1)[0][0] if any(team_dict.get(player, '') for player in row[2:]) else '',
-                                            axis=1
-                                        )
-                                        parsed_frame['Size'] = parsed_frame.apply(
-                                            lambda row: Counter(
-                                                team_dict.get(player, '') for player in row[2:]
-                                                if team_dict.get(player, '') != ''
-                                            ).most_common(1)[0][1] if any(team_dict.get(player, '') for player in row[2:]) else 0,
-                                            axis=1
-                                        )
-                        elif type_var == 'Showdown':
-                            # Calculate salary (CPT uses cpt_salary_map, others use salary_map)
-                            parsed_frame['salary'] = parsed_frame.apply(
-                                lambda row: st.session_state['map_dict']['cpt_salary_map'].get(row.iloc[0], 0) + 
-                                        sum(st.session_state['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)
-                            parsed_frame['median'] = parsed_frame.apply(
-                                lambda row: st.session_state['map_dict']['cpt_proj_map'].get(row.iloc[0], 0) + 
-                                        sum(st.session_state['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)
-                            parsed_frame['Own'] = parsed_frame.apply(
-                                lambda row: st.session_state['map_dict']['cpt_own_map'].get(row.iloc[0], 0) + 
-                                        sum(st.session_state['map_dict']['own_map'].get(player, 0) for player in row.iloc[1:]),
-                                axis=1
-                            )
+                        # Use consolidated calculation function
+                        parsed_frame = calculate_lineup_metrics(
+                            parsed_frame, 
+                            st.session_state['player_columns'], 
+                            st.session_state['map_dict'], 
+                            type_var, 
+                            sport_var, 
+                            st.session_state['projections_df']
+                        )
+                        
                         st.session_state['working_frame'] = parsed_frame.reset_index(drop=True)
-                        # st.session_state['working_frame']['Own'] = st.session_state['working_frame']['Own'].astype('float32')
-                        st.session_state['working_frame']['median'] = st.session_state['working_frame']['median'].astype('float32')
-                        st.session_state['working_frame']['salary'] = st.session_state['working_frame']['salary'].astype('uint16')
                         
                         # st.session_state['working_frame'] = predict_dupes(st.session_state['working_frame'], st.session_state['map_dict'], site_var, type_var, Contest_Size, strength_var, sport_var)
                         st.session_state['working_frame'] = reassess_edge(st.session_state['working_frame'], st.session_state['base_frame'], st.session_state['map_dict'], site_var, type_var, Contest_Size, strength_var, sport_var, salary_max)
                         st.session_state['export_merge'] = st.session_state['working_frame'].copy()
                     elif exp_submitted:
                         st.session_state['settings_base'] = False
-                        prior_frame = st.session_state['export_base'].copy()
                         parsed_frame = exposure_spread(st.session_state['export_base'], st.session_state['exposure_player'], exposure_target, ignore_stacks, remove_teams_exposure, specific_replacements, specific_columns, st.session_state['projections_df'], sport_var, type_var, salary_max, stacking_sports)
                         
-                        if type_var == 'Classic':
-                            if sport_var == 'CS2' or sport_var == 'LOL':
-                                parsed_frame['salary'] = parsed_frame.apply(
-                                    lambda row: st.session_state['map_dict']['cpt_salary_map'].get(row.iloc[0], 0) + 
-                                            sum(st.session_state['map_dict']['salary_map'].get(player, 0) for player in row.iloc[1:]),
-                                    axis=1
-                                )
-                                
-                                parsed_frame['median'] = parsed_frame.apply(
-                                    lambda row: st.session_state['map_dict']['cpt_proj_map'].get(row.iloc[0], 0) + 
-                                            sum(st.session_state['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)
-                                parsed_frame['Own'] = parsed_frame.apply(
-                                    lambda row: st.session_state['map_dict']['cpt_own_map'].get(row.iloc[0], 0) + 
-                                            sum(st.session_state['map_dict']['own_map'].get(player, 0) for player in row.iloc[1:]),
-                                    axis=1
-                                )
+                        # Use consolidated calculation function for export
+                        parsed_frame = calculate_lineup_metrics(
+                            parsed_frame, 
+                            st.session_state['player_columns'], 
+                            st.session_state['map_dict'], 
+                            type_var, 
+                            sport_var, 
+                            st.session_state['projections_df']
+                        )
 
-                            elif sport_var != 'CS2' and sport_var != 'LOL':
-                                parsed_frame['salary'] = parsed_frame.apply(lambda row: sum(st.session_state['map_dict']['salary_map'].get(player, 0) for player in row), axis=1)
-                                parsed_frame['median'] = parsed_frame.apply(lambda row: sum(st.session_state['map_dict']['proj_map'].get(player, 0) for player in row), axis=1)
-                                parsed_frame['Own'] = parsed_frame.apply(lambda row: sum(st.session_state['map_dict']['own_map'].get(player, 0) for player in row), axis=1)
-                                if 'stack_dict' in st.session_state:
-                                    team_dict = dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team']))
-                                    if sport_var == 'LOL':
-                                        parsed_frame['Stack'] = parsed_frame.apply(
-                                            lambda row: Counter(
-                                                team_dict.get(player, '') for player in row
-                                                if team_dict.get(player, '') != ''
-                                            ).most_common(1)[0][0] if any(team_dict.get(player, '') for player in row) else '',
-                                            axis=1
-                                        )
-                                        parsed_frame['Size'] = parsed_frame.apply(
-                                            lambda row: Counter(
-                                                team_dict.get(player, '') for player in row
-                                                if team_dict.get(player, '') != ''
-                                            ).most_common(1)[0][1] if any(team_dict.get(player, '') for player in row) else 0,
-                                            axis=1
-                                        )
-                                    else:
-                                        parsed_frame['Stack'] = parsed_frame.apply(
-                                            lambda row: Counter(
-                                                team_dict.get(player, '') for player in row[2:]
-                                                if team_dict.get(player, '') != ''
-                                            ).most_common(1)[0][0] if any(team_dict.get(player, '') for player in row[2:]) else '',
-                                            axis=1
-                                        )
-                                        parsed_frame['Size'] = parsed_frame.apply(
-                                            lambda row: Counter(
-                                                team_dict.get(player, '') for player in row[2:]
-                                                if team_dict.get(player, '') != ''
-                                            ).most_common(1)[0][1] if any(team_dict.get(player, '') for player in row[2:]) else 0,
-                                            axis=1
-                                        )
-                        elif type_var == 'Showdown':
-                            if sport_var == 'GOLF':
-                                
-                                parsed_frame['salary'] = parsed_frame.apply(lambda row: sum(st.session_state['map_dict']['salary_map'].get(player, 0) for player in row), axis=1)
-                                parsed_frame['median'] = parsed_frame.apply(lambda row: sum(st.session_state['map_dict']['proj_map'].get(player, 0) for player in row), axis=1)
-                                parsed_frame['Own'] = parsed_frame.apply(lambda row: sum(st.session_state['map_dict']['own_map'].get(player, 0) for player in row), axis=1)
-                            else:
-                                parsed_frame['salary'] = parsed_frame.apply(
-                                    lambda row: st.session_state['map_dict']['cpt_salary_map'].get(row.iloc[0], 0) + 
-                                            sum(st.session_state['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)
-                                parsed_frame['median'] = parsed_frame.apply(
-                                    lambda row: st.session_state['map_dict']['cpt_proj_map'].get(row.iloc[0], 0) + 
-                                            sum(st.session_state['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)
-                                parsed_frame['Own'] = parsed_frame.apply(
-                                    lambda row: st.session_state['map_dict']['cpt_own_map'].get(row.iloc[0], 0) + 
-                                            sum(st.session_state['map_dict']['own_map'].get(player, 0) for player in row.iloc[1:]),
-                                    axis=1
-                                )
+                        
                         st.session_state['export_base'] = parsed_frame.reset_index(drop=True)
-                        # st.session_state['export_base']['Own'] = st.session_state['export_base']['Own'].astype('float32')
-                        st.session_state['export_base']['median'] = st.session_state['export_base']['median'].astype('float32')
-                        st.session_state['export_base']['salary'] = st.session_state['export_base']['salary'].astype('uint16')
                         
                         # st.session_state['export_base'] = predict_dupes(st.session_state['export_base'], st.session_state['map_dict'], site_var, type_var, Contest_Size, strength_var, sport_var)
                         st.session_state['export_base'] = reassess_edge(st.session_state['export_base'], st.session_state['base_frame'], st.session_state['map_dict'], site_var, type_var, Contest_Size, strength_var, sport_var, salary_max)

global_func/reassess_edge.py

@@ -23,13 +23,20 @@ def reassess_edge(modified_frame: pd.DataFrame, base_frame: pd.DataFrame, maps_d
     # Store the number of rows in the modified frame
     num_modified_rows = len(modified_frame)
     
-    # Concatenate the modified frame with the base frame
-    combined_frame = pd.concat([modified_frame.drop(columns=['Dupes', 'Finish_percentile', 'Lineup Edge', 'Win%', 'Weighted Own', 'Geomean', 'Diversity']), base_frame.drop(columns=['Dupes', 'Finish_percentile', 'Lineup Edge', 'Win%', 'Weighted Own', 'Geomean', 'Diversity'])], ignore_index=True)
+    # Define columns to drop for memory efficiency
+    cols_to_drop = ['Dupes', 'Finish_percentile', 'Lineup Edge', 'Win%', 'Weighted Own', 'Geomean', 'Diversity']
+    
+    # More memory-efficient concatenation
+    modified_clean = modified_frame.drop(columns=[col for col in cols_to_drop if col in modified_frame.columns])
+    base_clean = base_frame.drop(columns=[col for col in cols_to_drop if col in base_frame.columns])
+    
+    # Use ignore_index=True and avoid unnecessary copies
+    combined_frame = pd.concat([modified_clean, base_clean], ignore_index=True, copy=False)
     
     # Run predict_dupes on the combined frame
     updated_combined_frame = predict_dupes(combined_frame, maps_dict, site_var, type_var, Contest_Size, strength_var, sport_var, max_salary)
     
-    # Extract the first N rows (which correspond to our modified frame)
-    result_frame = updated_combined_frame.head(num_modified_rows).copy()
+    # Extract the first N rows (which correspond to our modified frame) - use iloc for efficiency
+    result_frame = updated_combined_frame.iloc[:num_modified_rows].copy()
     
     return result_frame

global_func/stratification_function.py

@@ -5,15 +5,15 @@ def stratification_function(portfolio: pd.DataFrame, lineup_target: int, exclude
     excluded_cols = ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Stack', 'Size', 'Win%', 'Lineup Edge', 'Weighted Own', 'Geomean', 'Diversity']
     player_columns = [col for col in portfolio.columns if col not in excluded_cols]
     
-    concat_portfolio = portfolio.copy()
+    # Work with indices instead of copying entire DataFrame
     if sorting_choice == 'Finish_percentile':
-        concat_portfolio = concat_portfolio.sort_values(by=sorting_choice, ascending=True).reset_index(drop=True)
+        sorted_indices = portfolio[sorting_choice].sort_values(ascending=True).index
     else:
-        concat_portfolio = concat_portfolio.sort_values(by=sorting_choice, ascending=False).reset_index(drop=True)
-
-    # Calculate target similarity scores for linear progression
-    similarity_floor = concat_portfolio[sorting_choice].quantile(low_threshold / 100)
-    similarity_ceiling = concat_portfolio[sorting_choice].quantile(high_threshold / 100)
+        sorted_indices = portfolio[sorting_choice].sort_values(ascending=False).index
+    
+    # Calculate quantiles without copying
+    similarity_floor = portfolio[sorting_choice].quantile(low_threshold / 100)
+    similarity_ceiling = portfolio[sorting_choice].quantile(high_threshold / 100)
     
     # Create evenly spaced target similarity scores
     target_similarities = np.linspace(similarity_floor, similarity_ceiling, lineup_target)
@@ -22,11 +22,9 @@ def stratification_function(portfolio: pd.DataFrame, lineup_target: int, exclude
     selected_indices = []
     for target_sim in target_similarities:
         # Find the index of the closest similarity score
-        closest_idx = (concat_portfolio[sorting_choice] - target_sim).abs().idxmin()
+        closest_idx = (portfolio[sorting_choice] - target_sim).abs().idxmin()
         if closest_idx not in selected_indices:  # Avoid duplicates
             selected_indices.append(closest_idx)
     
-    # Select the lineups
-    concat_portfolio = concat_portfolio.loc[selected_indices].reset_index(drop=True)
-    
-    return concat_portfolio.sort_values(by=sorting_choice, ascending=False)
+    # Return view instead of copy
+    return portfolio.loc[selected_indices].sort_values(by=sorting_choice, ascending=False)