Refactor player removal and portfolio filtering logic in distribute_preset.py to improve accuracy in lineup generation. This update introduces a mechanism to continuously remove high-exposure players and ensures that the final portfolio meets the lineup target while maintaining performance metrics.

global_func/distribute_preset.py

@@ -5,76 +5,81 @@ 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]
-    for slack_var in range(1, 20):
-        init_portfolio = pd.DataFrame(columns=portfolio.columns)
-
-        for team in portfolio['Stack'].unique():
-            rows_to_drop = []
+    player_remove_list = []
+    
+    while True:  # 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
             working_portfolio = portfolio.copy()
-            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(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(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
-        )
-        
-        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()
+            # 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'])
 
-    for slack_var in range(1, 20):
-        concat_portfolio = pd.DataFrame(columns=portfolio.columns)
+                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 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
+            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())
+        
+        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
             )
-            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'])
             
-            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))])
+            if player_mask.any():
+                player_stats.append({
+                    'Player': player,
+                    'Lineup Count': player_mask.sum(),
+                    'Exposure': player_mask.sum() / len(concat_portfolio)
+                })
 
-        if len(concat_portfolio) >= lineup_target:
-            return concat_portfolio.sort_values(by='median', ascending=False).head(lineup_target)
+        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
 
     return concat_portfolio.sort_values(by='median', ascending=False)