Add opponent mapping and conflict checks in exposure spread and lineup optimization functions; refactor data loading for MMA projections

app.py

@@ -42,6 +42,7 @@ pos_parse_mapping = {
 
 pos_parse_options = list(pos_parse_mapping.keys())
 
+## Should just do a loop with some f'strings here I think
 showdown_selections = ['Showdown #1', 'Showdown #2', 'Showdown #3', 'Showdown #4', 'Showdown #5', 'Showdown #6', 'Showdown #7', 'Showdown #8', 'Showdown #9', 'Showdown #10', 'Showdown #11', 'Showdown #12', 'Showdown #13', 'Showdown #14', 'Showdown #15']
 dk_db_nfl_showdown_selections = ['DK_NFL_SD_seed_frame_Showdown #1', 'DK_NFL_SD_seed_frame_Showdown #2', 'DK_NFL_SD_seed_frame_Showdown #3', 'DK_NFL_SD_seed_frame_Showdown #4', 'DK_NFL_SD_seed_frame_Showdown #5', 'DK_NFL_SD_seed_frame_Showdown #6',
 'DK_NFL_SD_seed_frame_Showdown #7', 'DK_NFL_SD_seed_frame_Showdown #8', 'DK_NFL_SD_seed_frame_Showdown #9', 'DK_NFL_SD_seed_frame_Showdown #10', 'DK_NFL_SD_seed_frame_Showdown #11', 'DK_NFL_SD_seed_frame_Showdown #12', 'DK_NFL_SD_seed_frame_Showdown #13',
@@ -74,6 +75,7 @@ fd_db_pga_showdown_selections = ['FD_PGA_SD_seed_frame_Showdown #1', 'FD_PGA_SD_
 'FD_PGA_SD_seed_frame_Showdown #7', 'FD_PGA_SD_seed_frame_Showdown #8', 'FD_PGA_SD_seed_frame_Showdown #9', 'FD_PGA_SD_seed_frame_Showdown #10', 'FD_PGA_SD_seed_frame_Showdown #11', 'FD_PGA_SD_seed_frame_Showdown #12', 'FD_PGA_SD_seed_frame_Showdown #13',
 'FD_PGA_SD_seed_frame_Showdown #14', 'FD_PGA_SD_seed_frame_Showdown #15']
 
+## This feels like a bad way to do this?
 dk_nfl_showdown_db_translation = dict(zip(showdown_selections, dk_db_nfl_showdown_selections))
 fd_nfl_showdown_db_translation = dict(zip(showdown_selections, fd_db_nfl_showdown_selections))
 dk_nba_showdown_db_translation = dict(zip(showdown_selections, dk_db_nba_showdown_selections))
@@ -1611,7 +1613,7 @@ if selected_tab == 'Data Load':
         proj_options = st.selectbox("Select a projections source", options=['Paydirt DB', 'User Upload'])
         
         upload_col, template_col = st.columns([3, 1])
-        
+
         with upload_col:
             if 'portfolio' not in st.session_state:
                 st.session_state['projections_loaded'] = False
@@ -1620,6 +1622,7 @@ if selected_tab == 'Data Load':
                 st.session_state['db_projections_file'] = projections_file
                 st.session_state['projections_loaded'] = True
             elif proj_options == 'Paydirt DB':
+                ## Should make it so this is dynamic instead of having hardcoded things here
                 if st.button("Load from Database"):
                     if sport_var == 'NBA':
                         if site_var == 'Draftkings':
@@ -1658,11 +1661,13 @@ if selected_tab == 'Data Load':
                         if site_var == 'Draftkings':
                             if type_var == 'Classic':
                                 projections_file = init_mma_baselines(type_var, site_var, slate_var3)[0]
+                                opp_map = init_mma_baselines(type_var, site_var, slate_var3)[8]
                             elif type_var == 'Showdown':
                                 projections_file = init_mma_baselines(type_var, site_var, slate_var3)[2]
                         elif site_var == 'Fanduel':
                             if type_var == 'Classic':
                                 projections_file = init_mma_baselines(type_var, site_var, slate_var3)[1]
+                                opp_map = init_mma_baselines(type_var, site_var, slate_var3)[8]
                             elif type_var == 'Showdown':
                                 projections_file = init_mma_baselines(type_var, site_var, slate_var3)[3]
                     elif sport_var == 'GOLF':
@@ -1795,6 +1800,11 @@ if selected_tab == 'Data Load':
                     type_var,
                     sport_var
                 )
+
+                if sport_var == 'MMA':
+                    st.session_state['map_dict']['opp_map'] = opp_map
+                else:
+                    st.session_state['map_dict']['opp_map'] = None
             
             st.session_state['portfolio'] = st.session_state['portfolio'].astype(str)
             st.session_state['portfolio'] = st.session_state['portfolio'][~st.session_state['portfolio'].isin(['', 'nan', 'None', 'NaN']).any(axis=1)].reset_index(drop=True)
@@ -2879,7 +2889,8 @@ if selected_tab == 'Manage Portfolio':
                                     sport_var, 
                                     type_var, 
                                     salary_max, 
-                                    stacking_sports
+                                    stacking_sports,
+                                    st.session_state['map_dict']['opp_map']
                                 )
                                 
                                 # Update the original dataframe with the modified rows
@@ -2939,7 +2950,8 @@ if selected_tab == 'Manage Portfolio':
                                     sport_var, 
                                     type_var, 
                                     salary_max, 
-                                    stacking_sports
+                                    stacking_sports,
+                                    st.session_state['map_dict']['opp_map']
                                 )
                                 
                                 parsed_frame.loc[containing_mask] = modified_rows.values
@@ -2979,7 +2991,24 @@ if selected_tab == 'Manage Portfolio':
                     if reg_submitted:
                         st.session_state['settings_base'] = False
                         working_frame_prepared = prepare_dataframe_for_exposure_spread(st.session_state['working_frame'], st.session_state['player_columns'])
-                        parsed_frame = exposure_spread(working_frame_prepared, st.session_state['exposure_player'], exposure_target, comp_salary_below, comp_salary_above, ignore_stacks, remove_teams_exposure, specific_replacements, specific_exclusions, specific_columns, st.session_state['portfolio_inc_proj'], sport_var, type_var, salary_max, stacking_sports)
+                        parsed_frame = exposure_spread(
+                            working_frame_prepared,
+                            st.session_state['exposure_player'],
+                            exposure_target,
+                            comp_salary_below,
+                            comp_salary_above,
+                            ignore_stacks,
+                            remove_teams_exposure,
+                            specific_replacements,
+                            specific_exclusions,
+                            specific_columns,
+                            st.session_state['portfolio_inc_proj'],
+                            sport_var,
+                            type_var,
+                            salary_max,
+                            stacking_sports,
+                            st.session_state['map_dict']['opp_map']
+                        )
                         
                         # Use consolidated calculation function
                         parsed_frame = calculate_lineup_metrics(
@@ -3014,7 +3043,24 @@ if selected_tab == 'Manage Portfolio':
                     elif exp_submitted:
                         st.session_state['settings_base'] = False
                         export_base_prepared = prepare_dataframe_for_exposure_spread(st.session_state['export_base'], st.session_state['player_columns'])
-                        parsed_frame = exposure_spread(export_base_prepared, st.session_state['exposure_player'], exposure_target, comp_salary_below, comp_salary_above, ignore_stacks, remove_teams_exposure, specific_replacements, specific_exclusions, specific_columns, st.session_state['portfolio_inc_proj'], sport_var, type_var, salary_max, stacking_sports)
+                        parsed_frame = exposure_spread(
+                            export_base_prepared,
+                            st.session_state['exposure_player'],
+                            exposure_target,
+                            comp_salary_below,
+                            comp_salary_above,
+                            ignore_stacks,
+                            remove_teams_exposure,
+                            specific_replacements,
+                            specific_exclusions,
+                            specific_columns,
+                            st.session_state['portfolio_inc_proj'],
+                            sport_var,
+                            type_var,
+                            salary_max,
+                            stacking_sports,
+                            st.session_state['map_dict']['opp_map']
+                        )
                         
                         # Use consolidated calculation function for export
                         parsed_frame = calculate_lineup_metrics(
@@ -3231,9 +3277,13 @@ if selected_tab == 'Manage Portfolio':
                         st.session_state['export_file'][col] = st.session_state['export_file'][col].map(position_dict)
             
             if 'export_file' in st.session_state:
-                download_port, merge_port, clear_export, add_rows_col, remove_rows_col, blank_export_col = st.columns([1, 1, 1, 2, 2, 6])
+                download_port, merge_port, clear_export, add_rows_col, remove_rows_col, blank_export_col = st.columns([1, 1, 1, 2, 2, 4])
                 with download_port:
-                    st.download_button(label="Download Portfolio", data=st.session_state['export_file'].to_csv(index=False), file_name="portfolio.csv", mime="text/csv")
+                    st.selectbox("Download as:", options=['Names+IDs', 'Names Only'], key='download_format')
+                    if st.session_state['download_format'] == 'Names+IDs':
+                        st.download_button(label="Download Portfolio", data=st.session_state['export_file'].to_csv(index=False), file_name="portfolio.csv", mime="text/csv")
+                    else:
+                        st.download_button(label="Download Portfolio", data=st.session_state['display_frame'].to_csv(index=False), file_name="portfolio.csv", mime="text/csv")
 
                 with merge_port:
                     if st.button("Add all to Custom Export"):
@@ -3266,13 +3316,11 @@ if selected_tab == 'Manage Portfolio':
 
             total_rows = len(st.session_state['display_frame'])
             rows_per_page = 500
-            total_pages = (total_rows + rows_per_page - 1) // rows_per_page  # Ceiling division
+            total_pages = (total_rows + rows_per_page - 1) // rows_per_page
 
-            # Initialize page number in session state if not exists
             if 'current_page' not in st.session_state:
                 st.session_state.current_page = 1
 
-            # Display current page range info and pagination control in a single line
             st.write(
                 f"Showing rows {(st.session_state.current_page - 1) * rows_per_page + 1} "
                 f"to {min(st.session_state.current_page * rows_per_page, total_rows)} of {total_rows}"

database_queries.py

@@ -466,7 +466,6 @@ def init_nba_baselines(type_var: str, site_var: str, slate_var: str):
         fd_sd_id_map = dict(zip(fd_sd_roo_raw['Player'], fd_sd_roo_raw['player_ID']))
         fd_sd_roo_raw['player_ID'] = fd_sd_roo_raw['player_ID'].astype(str)
         fd_sd_roo_raw['player_ID'] = fd_sd_roo_raw['player_ID'].str.rsplit('-', n=1).str[0].astype(str)
-        dk_sd_roo_raw = dk_sd_roo_raw[dk_sd_roo_raw['slate'] == slate_var]
 
         dk_sd_roo_raw = dk_sd_roo_raw.drop(columns=['player_ID', 'slate', 'version', 'timestamp', 'site'])
         fd_sd_roo_raw = fd_sd_roo_raw.drop(columns=['player_ID', 'slate', 'version', 'timestamp', 'site'])
@@ -501,6 +500,15 @@ def init_nba_baselines(type_var: str, site_var: str, slate_var: str):
         dk_roo_raw = dk_roo_raw.rename(columns={'Player': 'player_names', 'Position': 'position', 'Team': 'team', 'Salary': 'salary', 'Median': 'median', 'Own': 'ownership', 'CPT_Own': 'captain ownership'})
         fd_roo_raw = fd_roo_raw.rename(columns={'Player': 'player_names', 'Position': 'position', 'Team': 'team', 'Salary': 'salary', 'Median': 'median', 'Own': 'ownership', 'CPT_Own': 'captain ownership'})
 
+        collection = nba_db["Live_Projections"]
+        cursor = collection.find()
+
+        raw_display = pd.DataFrame(list(cursor))
+        live_dict = dict(zip(raw_display['Player'], raw_display['Live_Proj']))
+
+        dk_roo_raw['median'] = dk_roo_raw['player_names'].map(live_dict)
+        fd_roo_raw['median'] = fd_roo_raw['player_names'].map(live_dict)
+
         dk_sd_roo_raw = None
         fd_sd_roo_raw = None
         dk_sd_id_map = None
@@ -1267,6 +1275,7 @@ def init_mma_baselines(type_var: str, site_var: str, slate_var: str):
 
         dk_roo_raw = None
         fd_roo_raw = None
+        opp_map = None
         dk_id_map = None
         fd_id_map = None
 
@@ -1275,7 +1284,7 @@ def init_mma_baselines(type_var: str, site_var: str, slate_var: str):
         cursor = collection.find()
 
         raw_display = pd.DataFrame(list(cursor))
-        raw_display = raw_display[['Player', 'Position', 'Salary', 'Median', 'Own', 'CPT_Own', 'player_id']]
+        raw_display = raw_display[['Player', 'Opp', 'Position', 'Salary', 'Median', 'Own', 'CPT_Own', 'player_id']]
         raw_display['Team'] = 'MMA'
         raw_display['Site'] = site_var
         raw_display = raw_display.rename(columns={"player_id": "player_ID"})
@@ -1285,10 +1294,11 @@ def init_mma_baselines(type_var: str, site_var: str, slate_var: str):
         fd_roo_raw = raw_display[raw_display['Site'] == 'Draftkings']
         dk_id_map = dict(zip(dk_roo_raw['Player'], dk_roo_raw['player_ID']))
         fd_id_map = dict(zip(fd_roo_raw['Player'], fd_roo_raw['player_ID']))
+        opp_map = dict(zip(dk_roo_raw['Player'], dk_roo_raw['Opp']))
         raw_display = raw_display.apply(pd.to_numeric, errors='ignore')
 
-        dk_roo_raw = dk_roo_raw.drop(columns=['player_ID'])
-        fd_roo_raw = fd_roo_raw.drop(columns=['player_ID'])
+        dk_roo_raw = dk_roo_raw.drop(columns=['player_ID', 'Opp'])
+        fd_roo_raw = fd_roo_raw.drop(columns=['player_ID', 'Opp'])
 
         dk_roo_raw = dk_roo_raw.rename(columns={'Player': 'player_names', 'Position': 'position', 'Team': 'team', 'Salary': 'salary', 'Median': 'median', 'Own': 'ownership', 'CPT_Own': 'captain ownership'})
         fd_roo_raw = fd_roo_raw.rename(columns={'Player': 'player_names', 'Position': 'position', 'Team': 'team', 'Salary': 'salary', 'Median': 'median', 'Own': 'ownership', 'CPT_Own': 'captain ownership'})
@@ -1298,7 +1308,7 @@ def init_mma_baselines(type_var: str, site_var: str, slate_var: str):
         dk_sd_id_map = None
         fd_sd_id_map = None
     
-    return dk_roo_raw, fd_roo_raw, dk_sd_roo_raw, fd_sd_roo_raw, dk_id_map, fd_id_map, dk_sd_id_map, fd_sd_id_map
+    return dk_roo_raw, fd_roo_raw, dk_sd_roo_raw, fd_sd_roo_raw, dk_id_map, fd_id_map, dk_sd_id_map, fd_sd_id_map, opp_map
 
 def init_DK_MMA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, salary_min, salary_max, player_var2):
 

global_func/exposure_spread.py

@@ -173,7 +173,12 @@ def check_salary_eligibility(current_lineup_salary, current_player, new_player,
     salary_diff = calculate_salary_difference(current_player, new_player, column_name, projections_df, type_var)
     return current_lineup_salary + salary_diff <= salary_max
 
-def exposure_spread(working_frame, exposure_player, exposure_target, comp_salary_below, comp_salary_above, ignore_stacks, remove_teams, specific_replacements, specific_exclusions, specific_columns, projections_df, sport_var, type_var, salary_max, stacking_sports):
+def exposure_spread(working_frame, exposure_player, exposure_target, comp_salary_below, comp_salary_above, ignore_stacks, remove_teams, specific_replacements, specific_exclusions, specific_columns, projections_df, sport_var, type_var, salary_max, stacking_sports, opp_map=None):
+    """
+    Added parameter:
+        opp_map: Dictionary mapping player names to their opponents (optional)
+    """
+    
     if specific_exclusions != []:
         projections_df = projections_df[~projections_df['player_names'].isin(specific_exclusions)]
     comparable_players = projections_df[projections_df['player_names'] == exposure_player]
@@ -191,8 +196,7 @@ def exposure_spread(working_frame, exposure_player, exposure_target, comp_salary
         comp_projection_low = comparable_players['median'][0] - (comparable_players['median'][0] * .5)
     else:
         comp_projection_low = comparable_players['median'][0] - (comparable_players['median'][0] * .5)
-    # players can be eligible at multiple positions, so we need to find all the positions the player is eligible at
-    # the position column can have positions designated as 1B/OF which means they are eligible at 1B and OF
+    
     comp_player_position = comparable_players['position'].tolist()
     comp_team = comparable_players['team'].tolist()
     try:
@@ -206,6 +210,23 @@ def exposure_spread(working_frame, exposure_player, exposure_target, comp_salary
         player_pos_list = player_positions.split('/')
         return any(pos in target_positions for pos in player_pos_list)
 
+    def check_opponent_conflict(candidate_player, current_row_data, opp_map):
+        """Check if candidate player is an opponent of any player in the current row"""
+        if not opp_map:
+            return False  # No conflicts if opp_map doesn't exist
+        
+        # Get all players currently in the row
+        existing_players = set(current_row_data.values)
+        
+        # Check if candidate is opponent of any existing player
+        for existing_player in existing_players:
+            if opp_map.get(existing_player) == candidate_player:
+                return True  # Conflict found
+            if opp_map.get(candidate_player) == existing_player:
+                return True  # Conflict found
+        
+        return False  # No conflicts
+
     # find the exposure rate of the player in the working frame
     if specific_columns != []:
         player_mask = working_frame[specific_columns].apply(
@@ -249,15 +270,9 @@ def exposure_spread(working_frame, exposure_player, exposure_target, comp_salary
     random.shuffle(random_row_indices_insert)
     random.shuffle(random_row_indices_replace)
 
-    # for each row to the the number of lineups to remove, replace with random choice from comparable player list if they can be inserted
-
-    # we will need to use two separate functions here, one for an exposure player who has a lineups to remove above 0 and one for below 0
-    # 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
+    # REMOVING EXPOSURE_PLAYER (lineups_to_remove > 0)
     if lineups_to_remove > 0:
-        # 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 != []:
@@ -296,7 +311,6 @@ def exposure_spread(working_frame, exposure_player, exposure_target, comp_salary
                 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
@@ -304,25 +318,23 @@ def exposure_spread(working_frame, exposure_player, exposure_target, comp_salary
                     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
+                                # NEW: Check for opponent conflicts
+                                if check_opponent_conflict(candidate, current_row_data, opp_map):
+                                    continue  # Skip this candidate
+                                
                                 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:
-                                    # For non-Classic types, check salary eligibility using helper function
                                     current_lineup_salary = working_frame.iloc[row]['salary']
                                     if check_salary_eligibility(current_lineup_salary, exposure_player, candidate, col, projections_df, type_var, salary_max):
                                         suitable_replacements.append(candidate)
@@ -331,39 +343,55 @@ def exposure_spread(working_frame, exposure_player, exposure_target, comp_salary
                                 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:
                     for col in working_columns:
                         if row_data[col] == exposure_player:
-                            insert_player = random.choice(comparable_player_list)
-                            # Get the replacement player's positions
+                            # Filter candidates to exclude opponent conflicts
+                            valid_candidates = [
+                                candidate for candidate in comparable_player_list 
+                                if not check_opponent_conflict(candidate, current_row_data, opp_map)
+                            ]
+                            
+                            if not valid_candidates:
+                                break  # No valid replacements available
+                            
+                            insert_player = random.choice(valid_candidates)
                             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
                             else:
-                                # For non-Classic types, check salary eligibility using helper function
                                 current_lineup_salary = working_frame.iloc[row]['salary']
                                 if check_salary_eligibility(current_lineup_salary, exposure_player, insert_player, col, projections_df, type_var, salary_max):
                                     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
+    
+    # ADDING EXPOSURE_PLAYER (lineups_to_remove < 0)
     else:
         while change_counter < math.ceil(lineups_to_add) and random_row_indices_replace:
             row = random_row_indices_replace.pop(0)
+            
+            # Get current row data first to check for opponent conflicts
+            if specific_columns != []:
+                current_row_data = working_frame.iloc[row][specific_columns]
+            else:
+                current_row_data = working_frame.iloc[row]
+            
+            # NEW: Check if exposure_player conflicts with existing players
+            if check_opponent_conflict(exposure_player, current_row_data, opp_map):
+                continue  # Skip this row, can't add exposure_player here
+            
             if specific_replacements != []:
                 comparable_players = projections_df[(projections_df['player_names'].isin(specific_replacements))
                 ]
@@ -394,14 +422,12 @@ def exposure_spread(working_frame, exposure_player, exposure_target, comp_salary
 
             comparable_players = comparable_players[comparable_players['player_names'] != exposure_player]
 
-            # Create a list of comparable players
             comparable_player_list = comparable_players['player_names'].tolist()
             
             if exposure_player in working_frame.iloc[row].values:
                 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
@@ -414,19 +440,17 @@ def exposure_spread(working_frame, exposure_player, exposure_target, comp_salary
                         current_lineup_salary = working_frame.iloc[row]['salary']
                         current_player = row_data[col]
                         
-                        # Check salary eligibility using helper function
                         if check_salary_eligibility(current_lineup_salary, current_player, exposure_player, col, projections_df, type_var, salary_max):
                             if type_var == 'Classic':
-                                # For Classic types, also check position eligibility
                                 exposure_player_positions = projections_df[projections_df['player_names'] == exposure_player]['position'].iloc[0].split('/')
                                 if check_position_eligibility(sport_var, col, exposure_player_positions):
                                     working_frame.at[row, col] = exposure_player
                                     change_counter += 1
                                     break
                             else:
-                                # For non-Classic types, salary check is sufficient (position eligibility handled elsewhere)
                                 working_frame.at[row, col] = exposure_player
                                 change_counter += 1
                                 break
+    
     return working_frame
     

global_func/optimize_lineup.py

@@ -146,12 +146,49 @@ def optimize_single_lineup(
     for i in range(num_players):
         solver.Add(sum(x[i, j] for j in range(num_open_cols)) <= 1)
 
-    # Constraint 3: Players already LOCKED in the row cannot be selected again
-    for i, player in enumerate(player_list):
-        player_name = player['player_names']
-        if player_name in locked_player_names:
-            for j in range(num_open_cols):
-                solver.Add(x[i, j] == 0)
+   # Constraint 3 & Opponent Exclusion: Handle locked players and opponents
+    opp_map = map_dict.get('opp_map', {})
+
+    if opp_map:
+        # When opp_map exists, use opponent-based constraints
+        
+        # Build a mapping of locked opponents that cannot be selected
+        locked_opponents = set()
+        for locked_player in locked_player_names:
+            opponent = opp_map.get(locked_player)
+            if opponent:
+                locked_opponents.add(opponent)
+        
+        # Prevent locked opponents from being selected
+        for i, player in enumerate(player_list):
+            player_name = player['player_names']
+            if player_name in locked_opponents:
+                for j in range(num_open_cols):
+                    solver.Add(x[i, j] == 0)
+        
+        # Prevent opponents from being selected together in open positions
+        player_name_to_idx = {player['player_names']: i for i, player in enumerate(player_list)}
+        
+        for i, player in enumerate(player_list):
+            player_name = player['player_names']
+            opponent_name = opp_map.get(player_name)
+            
+            if opponent_name and opponent_name in player_name_to_idx:
+                opponent_idx = player_name_to_idx[opponent_name]
+                
+                # If player i is selected, opponent cannot be selected
+                solver.Add(
+                    sum(x[i, j] for j in range(num_open_cols)) + 
+                    sum(x[opponent_idx, j] for j in range(num_open_cols)) <= 1
+                )
+    else:
+        # When opp_map doesn't exist, use standard locked player constraint
+        # Constraint 3: Players already LOCKED in the row cannot be selected again
+        for i, player in enumerate(player_list):
+            player_name = player['player_names']
+            if player_name in locked_player_names:
+                for j in range(num_open_cols):
+                    solver.Add(x[i, j] == 0)
 
     # Constraint 4: Position eligibility
     for i, player in enumerate(player_list):