Refactor exposure_spread function to improve player replacement logic by implementing a while loop for better handling of row selections and ensuring replacements are made only when necessary. This enhances the clarity and efficiency of the code.

global_func/exposure_spread.py

@@ -228,100 +228,107 @@ def exposure_spread(working_frame, exposure_player, exposure_target, comp_salary
     # key concept here is if they have a lineups to remove above 0 it means that we are trying to replace them with comparable players
     # if the lineups to remove is below zero it means we want to find comparable players and replace them with the exposure player
     if lineups_to_remove > 0:
-        for row in random_row_indices_insert:
-            if change_counter < math.ceil(lineups_to_remove):
-                if specific_replacements != []:
-                    comparable_players = projections_df[(projections_df['player_names'].isin(specific_replacements)) &
-                        (projections_df['salary'] <= comp_salary_high + (salary_max - working_frame['salary'][row]))
-                    ]
-                else:
-                    comparable_players = projections_df[
-                        (projections_df['salary'] >= comp_salary_low) &
-                        (projections_df['salary'] <= comp_salary_high + (salary_max - working_frame['salary'][row])) &
-                        (projections_df['median'] >= comp_projection_low) &
-                        (projections_df['position'].apply(lambda x: has_position_overlap(x, comp_player_position)))
-                    ]
+        # Keep trying until we've made enough successful replacements
+        while change_counter < math.ceil(lineups_to_remove) and random_row_indices_insert:
+            # Get the next row to try
+            row = random_row_indices_insert.pop(0)
+            
+            if specific_replacements != []:
+                comparable_players = projections_df[(projections_df['player_names'].isin(specific_replacements)) &
+                    (projections_df['salary'] <= comp_salary_high + (salary_max - working_frame['salary'][row]))
+                ]
+            else:
+                comparable_players = projections_df[
+                    (projections_df['salary'] >= comp_salary_low) &
+                    (projections_df['salary'] <= comp_salary_high + (salary_max - working_frame['salary'][row])) &
+                    (projections_df['median'] >= comp_projection_low) &
+                    (projections_df['position'].apply(lambda x: has_position_overlap(x, comp_player_position)))
+                ]
 
-                if exposure_target == 0:
-                    comparable_players = comparable_players[comparable_players['player_names'] != exposure_player]
-                
-                if remove_teams is not None:
-                    remove_mask = comparable_players.apply(
-                            lambda row: not any(team in list(row) for team in remove_teams), axis=1
-                        )
-                    comparable_players = comparable_players[remove_mask]
+            if exposure_target == 0:
+                comparable_players = comparable_players[comparable_players['player_names'] != exposure_player]
+            
+            if remove_teams is not None:
+                remove_mask = comparable_players.apply(
+                        lambda row: not any(team in list(row) for team in remove_teams), axis=1
+                    )
+                comparable_players = comparable_players[remove_mask]
 
-                # Get the current row data to check for existing players
+            # Get the current row data to check for existing players
+            if specific_columns != []:
+                current_row_data = working_frame.iloc[row][specific_columns]
+            else:
+                current_row_data = working_frame.iloc[row]
+            
+            # Filter out players that are already present in this row
+            existing_players = set(current_row_data.values)
+            try:
+                comparable_players = comparable_players[~comparable_players['player_names'].isin(existing_players)]
+                comparable_player_list = comparable_players['player_names'].tolist()
+            except:
+                comparable_player_list = []
+
+            if comparable_player_list:
+                # Find which column contains the exposure_player
                 if specific_columns != []:
-                    current_row_data = working_frame.iloc[row][specific_columns]
+                    row_data = working_frame.iloc[row][specific_columns]
+                    working_columns = specific_columns
                 else:
-                    current_row_data = working_frame.iloc[row]
+                    row_data = working_frame.iloc[row]
+                    working_columns = working_frame.columns
                 
-                # Filter out players that are already present in this row
-                existing_players = set(current_row_data.values)
-                try:
-                    comparable_players = comparable_players[~comparable_players['player_names'].isin(existing_players)]
-                    comparable_player_list = comparable_players['player_names'].tolist()
-                except:
-                    comparable_player_list = []
-
-                if comparable_player_list:
-                    # Find which column contains the exposure_player
-                    if specific_columns != []:
-                        row_data = working_frame.iloc[row][specific_columns]
-                        working_columns = specific_columns
-                    else:
-                        row_data = working_frame.iloc[row]
-                        working_columns = working_frame.columns
-                    
-                    # Track if we successfully made a replacement
-                    replacement_made = False
-                    
-                    # For exposure_target == 0, replace ALL occurrences of exposure_player in this row
-                    if exposure_target == 0:
-                        for col in working_columns:
-                            if row_data[col] == exposure_player:
-                                # Try to find a suitable replacement for this specific column
-                                suitable_replacements = []
-                                for candidate in comparable_player_list:
-                                    # Get the replacement player's positions
-                                    replacement_player_positions = projections_df[projections_df['player_names'] == candidate]['position'].iloc[0].split('/')
-                                    
-                                    # Check if the replacement player is eligible for this column
-                                    if type_var == 'Classic':
-                                        if check_position_eligibility(sport_var, col, replacement_player_positions):
-                                            suitable_replacements.append(candidate)
-                                    else:
-                                        suitable_replacements.append(candidate)
-                                
-                                if suitable_replacements:
-                                    insert_player = random.choice(suitable_replacements)
-                                    working_frame.at[row, col] = insert_player
-                                    replacement_made = True
-                                    # Remove this player from the list to avoid duplicates in the same row
-                                    comparable_player_list = [p for p in comparable_player_list if p != insert_player]
-                    else:
-                        # Original logic for non-zero exposure targets
-                        for col in working_columns:
-                            if row_data[col] == exposure_player:
-                                insert_player = random.choice(comparable_player_list)
+                # Track if we successfully made a replacement
+                replacement_made = False
+                
+                # For exposure_target == 0, replace ALL occurrences of exposure_player in this row
+                if exposure_target == 0:
+                    for col in working_columns:
+                        if row_data[col] == exposure_player:
+                            # Try to find a suitable replacement for this specific column
+                            suitable_replacements = []
+                            for candidate in comparable_player_list:
                                 # Get the replacement player's positions
-                                replacement_player_positions = projections_df[projections_df['player_names'] == insert_player]['position'].iloc[0].split('/')
+                                replacement_player_positions = projections_df[projections_df['player_names'] == candidate]['position'].iloc[0].split('/')
                                 
                                 # Check if the replacement player is eligible for this column
                                 if type_var == 'Classic':
                                     if check_position_eligibility(sport_var, col, replacement_player_positions):
-                                        working_frame.at[row, col] = insert_player
-                                        replacement_made = True
-                                        break
+                                        suitable_replacements.append(candidate)
                                 else:
+                                    suitable_replacements.append(candidate)
+                            
+                            if suitable_replacements:
+                                insert_player = random.choice(suitable_replacements)
+                                working_frame.at[row, col] = insert_player
+                                replacement_made = True
+                                # Remove this player from the list to avoid duplicates in the same row
+                                comparable_player_list = [p for p in comparable_player_list if p != insert_player]
+                else:
+                    # Original logic for non-zero exposure targets
+                    for col in working_columns:
+                        if row_data[col] == exposure_player:
+                            insert_player = random.choice(comparable_player_list)
+                            # Get the replacement player's positions
+                            replacement_player_positions = projections_df[projections_df['player_names'] == insert_player]['position'].iloc[0].split('/')
+                            
+                            # Check if the replacement player is eligible for this column
+                            if type_var == 'Classic':
+                                if check_position_eligibility(sport_var, col, replacement_player_positions):
                                     working_frame.at[row, col] = insert_player
                                     replacement_made = True
                                     break
-                    
-                    # Only increment counter if we actually made a replacement
-                    if replacement_made:
-                        change_counter += 1
+                            else:
+                                working_frame.at[row, col] = insert_player
+                                replacement_made = True
+                                break
+                
+                # Only increment counter if we actually made a replacement
+                if replacement_made:
+                    change_counter += 1
+            
+            # If we've run out of rows to try, break to avoid infinite loop
+            if not random_row_indices_insert:
+                break
     else:
         for row in random_row_indices_replace:
             if change_counter < math.ceil(lineups_to_add):