Optimize performance in app.py with vectorized operations

- Refactored multiple calculations in the app to utilize vectorized operations, significantly improving performance and efficiency. This includes stack, salary, actual_fpts, and ownership calculations, as well as unique player counts. Enhanced readability and maintainability of the code by consolidating repetitive logic.

app.py

@@ -204,6 +204,8 @@ with tab2:
         st.session_state['player_columns'] = [col for col in st.session_state['Contest'].columns if col not in excluded_cols]
         st.session_state['stack_columns'] = [col for col in st.session_state['Contest'].columns if col not in exclude_stacks]
         print(st.session_state['player_columns'])
+        
+        # Vectorized string operations
         for col in st.session_state['player_columns']:
             st.session_state['Contest'][col] = st.session_state['Contest'][col].astype(str).str.strip()
     
@@ -215,121 +217,146 @@ with tab2:
             'own_map': st.session_state['ownership_dict'],
             'own_percent_rank': dict(zip(st.session_state['ownership_df']['Player'], st.session_state['ownership_df']['Own'].rank(pct=True)))
         }
+        
         # Create a copy of the dataframe for calculations
         working_df = st.session_state['Contest'].copy()
-
+        
+        # Pre-compute lookup arrays for vectorized operations
+        team_map = st.session_state['map_dict']['team_map']
+        salary_map = st.session_state['salary_dict']
+        actual_map = st.session_state['actual_dict']
+        ownership_map = st.session_state['ownership_dict']
+        
         if type_var == 'Classic':
-            working_df['stack'] = working_df.apply(
-                lambda row: Counter(
-                    st.session_state['map_dict']['team_map'].get(player, '') for player in row[st.session_state['stack_columns']]
-                    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[st.session_state['stack_columns']]) else '',
-                axis=1
+            # Vectorized stack calculation
+            player_teams = working_df[st.session_state['stack_columns']].apply(
+                lambda x: x.map(team_map).fillna('')
             )
-            working_df['stack_size'] = working_df.apply(
-                lambda row: Counter(
-                    st.session_state['map_dict']['team_map'].get(player, '') for player in row[st.session_state['stack_columns']]
-                    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[st.session_state['stack_columns']]) else '',
-                axis=1
+            
+            # Vectorized stack and stack_size calculation
+            def get_most_common_team(teams):
+                if teams.empty or teams.isna().all():
+                    return '', 0
+                non_empty_teams = teams[teams != '']
+                if len(non_empty_teams) == 0:
+                    return '', 0
+                team_counts = non_empty_teams.value_counts()
+                return team_counts.index[0], team_counts.iloc[0]
+            
+            stack_results = player_teams.apply(get_most_common_team, axis=1)
+            working_df['stack'] = [result[0] for result in stack_results]
+            working_df['stack_size'] = [result[1] for result in stack_results]
+            
+            # Vectorized salary calculation
+            player_salaries = working_df[st.session_state['player_columns']].apply(
+                lambda x: x.map(salary_map).fillna(0)
             )
-            working_df['salary'] = working_df.apply(lambda row: sum(st.session_state['salary_dict'].get(player, 0) for player in row[st.session_state['player_columns']]), axis=1)
-            working_df['actual_fpts'] = working_df.apply(lambda row: sum(st.session_state['actual_dict'].get(player, 0) for player in row[st.session_state['player_columns']]), axis=1)
-            working_df['actual_own'] = working_df.apply(lambda row: sum(st.session_state['ownership_dict'].get(player, 0) for player in row[st.session_state['player_columns']]), axis=1)
-            print("Sample row values:")
-            print(working_df.iloc[0][st.session_state['player_columns']])
-            print("Sample salary calculation:")
-            sample_row = working_df.iloc[0]
-            sample_salary = sum(st.session_state['salary_dict'].get(player, 0) for player in sample_row[st.session_state['player_columns']])
-            print(f"Sample salary: {sample_salary}")
-            print("Individual player salaries:")
-            for player in sample_row[st.session_state['player_columns']]:
-                salary = st.session_state['salary_dict'].get(player, 0)
-                print(f"  {player}: {salary}")
+            working_df['salary'] = player_salaries.sum(axis=1)
+            
+            # Vectorized actual_fpts calculation
+            player_fpts = working_df[st.session_state['player_columns']].apply(
+                lambda x: x.map(actual_map).fillna(0)
+            )
+            working_df['actual_fpts'] = player_fpts.sum(axis=1)
+            
+            # Vectorized actual_own calculation
+            player_ownership = working_df[st.session_state['player_columns']].apply(
+                lambda x: x.map(ownership_map).fillna(0)
+            )
+            working_df['actual_own'] = player_ownership.sum(axis=1)
+            
+            # Vectorized duplication calculation
             working_df['sorted'] = working_df[st.session_state['player_columns']].apply(
-                lambda row: ','.join(sorted(row.values)),
-                axis=1
+                lambda row: ','.join(sorted(row.values)), axis=1
             )
             working_df['dupes'] = working_df.groupby('sorted').transform('size')
-
-            working_df['uniques'] = working_df.groupby('BaseName').apply(
-                lambda x: (x['dupes'] == 1).sum()
-            ).reindex(working_df['BaseName']).values
-
-            working_df['under_5'] = working_df.groupby('BaseName').apply(
-                lambda x: (x['dupes'] <= 5).sum()
-            ).reindex(working_df['BaseName']).values
-
-            working_df['under_10'] = working_df.groupby('BaseName').apply(
-                lambda x: (x['dupes'] <= 10).sum()
-            ).reindex(working_df['BaseName']).values
-
+            
+            # Vectorized unique calculations
+            working_df['uniques'] = working_df.groupby('BaseName')['dupes'].transform(
+                lambda x: (x == 1).sum()
+            )
+            working_df['under_5'] = working_df.groupby('BaseName')['dupes'].transform(
+                lambda x: (x <= 5).sum()
+            )
+            working_df['under_10'] = working_df.groupby('BaseName')['dupes'].transform(
+                lambda x: (x <= 10).sum()
+            )
+            
             working_df = working_df.reset_index()
             working_df['percentile_finish'] = working_df['index'].rank(pct=True)
             working_df['finish'] = working_df['index']
             working_df = working_df.drop(['sorted', 'index'], axis=1)
         
         elif type_var == 'Showdown':
-            working_df['stack'] = working_df.apply(
-                lambda row: Counter(
-                    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(
-                    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
+            # Vectorized stack calculation for Showdown
+            player_teams = working_df.iloc[:, 2:].apply(
+                lambda x: x.map(team_map).fillna('')
             )
+            
+            stack_results = player_teams.apply(get_most_common_team, axis=1)
+            working_df['stack'] = [result[0] for result in stack_results]
+            working_df['stack_size'] = [result[1] for result in stack_results]
+            
             if sport_select == 'GOLF':
-                working_df['salary'] = working_df.apply(lambda row: sum(st.session_state['salary_dict'].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)
-            else:
-                # Modified salary calculation with 1.5x multiplier for first player
-                working_df['salary'] = working_df.apply(
-                    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
+                # Vectorized calculations for GOLF
+                player_salaries = working_df.apply(
+                    lambda x: x.map(salary_map).fillna(0)
                 )
-                # Modified actual_fpts calculation with 1.5x multiplier for first player
-                working_df['actual_fpts'] = working_df.apply(
-                    lambda row: (st.session_state['actual_dict'].get(row[2], 0) * 1.5) + 
-                            sum(st.session_state['actual_dict'].get(player, 0) for player in row[3:]),
-                    axis=1
+                working_df['salary'] = player_salaries.sum(axis=1)
+                
+                player_fpts = working_df.apply(
+                    lambda x: x.map(actual_map).fillna(0)
                 )
-            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['actual_fpts'] = player_fpts.sum(axis=1)
+            else:
+                # Vectorized calculations with 1.5x multiplier for first player
+                first_player_salary = working_df.iloc[:, 2].map(salary_map).fillna(0) * 1.5
+                other_players_salary = working_df.iloc[:, 3:].apply(
+                    lambda x: x.map(salary_map).fillna(0)
+                ).sum(axis=1)
+                working_df['salary'] = first_player_salary + other_players_salary
+                
+                first_player_fpts = working_df.iloc[:, 2].map(actual_map).fillna(0) * 1.5
+                other_players_fpts = working_df.iloc[:, 3:].apply(
+                    lambda x: x.map(actual_map).fillna(0)
+                ).sum(axis=1)
+                working_df['actual_fpts'] = first_player_fpts + other_players_fpts
+            
+            # Vectorized actual_own calculation
+            player_ownership = working_df.apply(
+                lambda x: x.map(ownership_map).fillna(0)
+            )
+            working_df['actual_own'] = player_ownership.sum(axis=1)
+            
+            # Vectorized duplication calculation
             working_df['sorted'] = working_df[st.session_state['player_columns']].apply(
-                lambda row: ','.join(sorted(row.values)),
-                axis=1
+                lambda row: ','.join(sorted(row.values)), axis=1
             )
             working_df['dupes'] = working_df.groupby('sorted').transform('size')
-
-            working_df['uniques'] = working_df.groupby('BaseName').apply(
-                lambda x: (x['dupes'] == 1).sum()
-            ).reindex(working_df['BaseName']).values
-
-            working_df['under_5'] = working_df.groupby('BaseName').apply(
-                lambda x: (x['dupes'] <= 5).sum()
-            ).reindex(working_df['BaseName']).values
-
-            working_df['under_10'] = working_df.groupby('BaseName').apply(
-                lambda x: (x['dupes'] <= 10).sum()
-            ).reindex(working_df['BaseName']).values
-
+            
+            # Vectorized unique calculations
+            working_df['uniques'] = working_df.groupby('BaseName')['dupes'].transform(
+                lambda x: (x == 1).sum()
+            )
+            working_df['under_5'] = working_df.groupby('BaseName')['dupes'].transform(
+                lambda x: (x <= 5).sum()
+            )
+            working_df['under_10'] = working_df.groupby('BaseName')['dupes'].transform(
+                lambda x: (x <= 10).sum()
+            )
+            
             working_df = working_df.reset_index()
             working_df['percentile_finish'] = working_df['index'].rank(pct=True)
             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)
+        
+        # Store results
         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()
         st.session_state['contest_info_reset'] = working_df.copy()
         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['unique_players'] = [p for p in st.session_state['unique_players'] if p != 'nan']
 
     if 'display_contest_info' in st.session_state:
         with st.expander("Info and filters"):
@@ -354,7 +381,7 @@ with tab2:
                     st.session_state['remove_names'] = []
                     st.session_state['display_contest_info'] = st.session_state['contest_info_reset'].copy()
                     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['unique_players'] = [p for p in st.session_state['unique_players'] if p != 'nan']
 
             with st.form(key='filter_form'):
                 users_var, entries_var, stack_var, stack_size_var, player_var, remove_var = st.columns(6)