Refactor player filtering and portfolio distribution logic in distribute_preset.py to streamline the process of removing high-exposure players. This update enhances the accuracy of lineup generation by ensuring that the final portfolio meets the lineup target while maintaining performance metrics, and improves the handling of player selection based on similarity scores.

global_func/distribute_preset.py

@@ -5,84 +5,76 @@ def distribute_preset(portfolio: pd.DataFrame, lineup_target: int, exclude_cols:
     
     excluded_cols = ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Stack', 'Size', 'Win%', 'Lineup Edge', 'Weighted Own', 'Geomean', 'Similarity Score']
     player_columns = [col for col in portfolio.columns if col not in excluded_cols]
-    player_remove_list = []
-    x = 0
-    
-    while x < 10:  # Continue until no more players need to be removed
-        for slack_var in range(1, 20):
-            concat_portfolio = pd.DataFrame(columns=portfolio.columns)
-            
-            # Start with the original portfolio, removing players from player_remove_list
+    for slack_var in range(1, 20):
+        init_portfolio = pd.DataFrame(columns=portfolio.columns)
+
+        for team in portfolio['Stack'].unique():
+            rows_to_drop = []
             working_portfolio = portfolio.copy()
-            
-            # Remove all players in player_remove_list at once
-            if player_remove_list:
-                remove_mask = working_portfolio[player_columns].apply(
-                    lambda row: not any(player in list(row) for player in player_remove_list), axis=1
-                )
-                working_portfolio = working_portfolio[remove_mask]
-                
-                if len(working_portfolio) == 0:
-                    # If no data left after removing players, return what we have
-                    return concat_portfolio.sort_values(by='median', ascending=False)
-            
-            # Apply similarity score filtering by team
-            for team in working_portfolio['Stack'].unique():
-                rows_to_drop = []
-                team_portfolio = working_portfolio[working_portfolio['Stack'] == team].sort_values(by='median', ascending=False)
-                team_portfolio = team_portfolio.reset_index(drop=True)
-                
-                if len(team_portfolio) == 0:
-                    continue
-                    
-                curr_own_type_max = team_portfolio.loc[0, 'Similarity Score'] + (slack_var / 20 * team_portfolio.loc[0, 'Similarity Score'])
+            working_portfolio = working_portfolio[working_portfolio['Stack'] == team].sort_values(by='median', ascending = False)
+            working_portfolio = working_portfolio.reset_index(drop=True)
+            curr_own_type_max = working_portfolio.loc[0, 'Similarity Score'] + (slack_var / 20 * working_portfolio.loc[0, 'Similarity Score'])
 
-                for i in range(1, len(team_portfolio)):
-                    if team_portfolio.loc[i, 'Similarity Score'] > curr_own_type_max:
-                        rows_to_drop.append(i)
-                    else:
-                        curr_own_type_max = team_portfolio.loc[i, 'Similarity Score'] + (slack_var / 20 * team_portfolio.loc[i, 'Similarity Score'])
-                
-                team_portfolio = team_portfolio.drop(rows_to_drop).reset_index(drop=True)
-                concat_portfolio = pd.concat([concat_portfolio, team_portfolio.head(math.ceil(lineup_target / 5))])
+            for i in range(1, len(working_portfolio)):
+                if working_portfolio.loc[i, 'Similarity Score'] > curr_own_type_max:
+                    rows_to_drop.append(i)
+                else:
+                    curr_own_type_max = working_portfolio.loc[i, 'Similarity Score'] + (slack_var / 20 * working_portfolio.loc[i, 'Similarity Score'])
+            
+            working_portfolio = working_portfolio.drop(rows_to_drop).reset_index(drop=True)
+            init_portfolio = pd.concat([init_portfolio, working_portfolio])
 
-            if len(concat_portfolio) >= lineup_target:
-                concat_portfolio = concat_portfolio.sort_values(by='median', ascending=False).head(lineup_target)
-                break
-        
-        # Calculate player exposures from the current concat_portfolio
-        player_list = set()
-        player_stats = []
-        for cols in concat_portfolio.columns:
-            if cols not in excluded_cols:
-                player_list.update(concat_portfolio[cols].unique())
+        if len(init_portfolio) >= lineup_target:
+            init_portfolio.sort_values(by='median', ascending=True).head(lineup_target)
+    
+    player_list = set()
+    player_stats = []
+    for cols in init_portfolio.columns:
+        if cols not in excluded_cols:
+            player_list.update(init_portfolio[cols].unique())
+    
+    for player in player_list:
+        # Select only the columns that are NOT in excluded_cols
+        player_cols = [col for col in init_portfolio.columns if col not in excluded_cols]
+        player_mask = init_portfolio[player_cols].apply(
+            lambda row: player in list(row), axis=1
+        )
         
-        for player in player_list:
-            player_cols = [col for col in concat_portfolio.columns if col not in excluded_cols]
-            player_mask = concat_portfolio[player_cols].apply(
-                lambda row: player in list(row), axis=1
+        if player_mask.any():
+            player_stats.append({
+                'Player': player,
+                'Lineup Count': player_mask.sum(),
+                'Exposure': player_mask.sum() / len(init_portfolio)
+            })
+
+    player_summary = pd.DataFrame(player_stats)
+    print(player_summary.sort_values('Lineup Count', ascending=False).head(10))
+    player_remove_list = player_summary.sort_values('Lineup Count', ascending=False).head(5)['Player'].tolist()
+
+    for slack_var in range(1, 20):
+        concat_portfolio = pd.DataFrame(columns=portfolio.columns)
+
+        for player_out in player_remove_list:
+            rows_to_drop = []
+            working_portfolio = portfolio.copy()
+            remove_mask = working_portfolio[player_columns].apply(
+                lambda row: player_out not in list(row), axis=1
             )
+            working_portfolio = working_portfolio[remove_mask]
+            print(working_portfolio.head(10))
+            working_portfolio = working_portfolio.sort_values(by='median', ascending=False).reset_index(drop=True)
+            curr_own_type_max = working_portfolio.loc[0, 'Similarity Score'] + (slack_var / 20 * working_portfolio.loc[0, 'Similarity Score'])
+
+            for i in range(1, len(working_portfolio)):
+                if working_portfolio.loc[i, 'Similarity Score'] > curr_own_type_max:
+                    rows_to_drop.append(i)
+                else:
+                    curr_own_type_max = working_portfolio.loc[i, 'Similarity Score'] + (slack_var / 20 * working_portfolio.loc[i, 'Similarity Score'])
             
-            if player_mask.any():
-                player_stats.append({
-                    'Player': player,
-                    'Lineup Count': player_mask.sum(),
-                    'Exposure': player_mask.sum() / len(concat_portfolio)
-                })
+            working_portfolio = working_portfolio.drop(rows_to_drop).reset_index(drop=True)
+            concat_portfolio = pd.concat([concat_portfolio, working_portfolio.head(math.ceil(lineup_target / 5))])
 
-        player_summary = pd.DataFrame(player_stats)
-        print(player_summary.sort_values('Lineup Count', ascending=False).head(10))
-        
-        # Find players with exposure > 0.60
-        high_exposure_players = player_summary[player_summary['Exposure'] > 0.60]['Player'].tolist()
-        
-        # Add new high-exposure players to the remove list
-        player_remove_list.extend(high_exposure_players)
-        
-        # If no new players to remove and we have enough lineups, we're done
-        if len(high_exposure_players) == 0 and len(concat_portfolio) >= lineup_target:
-            break
-        
-        x += 1
+        if len(concat_portfolio) >= lineup_target:
+            return concat_portfolio.sort_values(by='median', ascending=False).head(lineup_target)
 
     return concat_portfolio.sort_values(by='median', ascending=False)