Adding optimization

app.py

@@ -28,6 +28,7 @@ from global_func.stratification_function import stratification_function
 from global_func.exposure_spread import exposure_spread
 from global_func.reassess_edge import reassess_edge
 from global_func.recalc_diversity import recalc_diversity
+from global_func.optimize_lineup import optimize_lineup
 
 from database_queries import *
 from database import *
@@ -3023,7 +3024,145 @@ if selected_tab == 'Manage Portfolio':
                                 axis=1
                             )
                             st.session_state['export_merge'] = st.session_state['export_base'].copy()
+            
+            with st.expander('Lineup Reoptimization'):
+                with st.form(key='Reoptimize'):
+                    optimize_by = st.selectbox("Optimize By", options=['median', 'ownership'], key='optimize_by')
+                    lock_teams_optimize = st.multiselect(
+                        "Locked Teams", 
+                        options=sorted(list(set(st.session_state['projections_df']['team'].unique()))), 
+                        default=[],
+                        key='lock_teams_optimize'
+                    )
+                    opt_submitted_col, opt_export_col = st.columns(2)
+                    st.info("Portfolio Button applies to your overall Portfolio, Export button applies to your Custom Export")
+                    with opt_submitted_col:
+                        opt_reg_submitted = st.form_submit_button("Portfolio")
+                    with opt_export_col:
+                        opt_exp_submitted = st.form_submit_button("Export")
+                    
+                    if opt_reg_submitted:
+                        st.session_state['settings_base'] = False
+                        # Run optimization on working_frame
+                        optimized_frame = optimize_lineup(
+                            working_frame=st.session_state['working_frame'],
+                            projections_df=st.session_state['portfolio_inc_proj'],
+                            player_columns=st.session_state['player_columns'],
+                            map_dict=st.session_state['map_dict'],
+                            lock_teams=lock_teams_optimize,
+                            site_var=site_var,
+                            type_var=type_var,
+                            sport_var=sport_var,
+                            salary_max=salary_max,
+                            optimize_by=optimize_by
+                        )
+                        
+                        # Recalculate lineup metrics
+                        optimized_frame = calculate_lineup_metrics(
+                            optimized_frame, 
+                            st.session_state['player_columns'], 
+                            st.session_state['map_dict'], 
+                            type_var, 
+                            sport_var, 
+                            st.session_state['portfolio_inc_proj']
+                        )
+                        
+                        st.session_state['working_frame'] = optimized_frame.reset_index(drop=True)
+                        
+                        # Load Default base from compressed storage for reassess_edge
+                        default_base = load_base_frame('Default')
+                        st.session_state['working_frame'] = reassess_edge(
+                            st.session_state['working_frame'], 
+                            default_base, 
+                            st.session_state['map_dict'], 
+                            site_var, 
+                            type_var, 
+                            Contest_Size, 
+                            strength_var, 
+                            sport_var, 
+                            salary_max
+                        )
                         
+                        # Update Stack/Size columns if applicable
+                        team_dict = dict(zip(st.session_state['portfolio_inc_proj']['player_names'], st.session_state['portfolio_inc_proj']['team']))
+                        if 'Stack' in st.session_state['working_frame'].columns:
+                            st.session_state['working_frame']['Stack'] = st.session_state['working_frame'].apply(
+                                lambda row: Counter(
+                                    team_dict.get(player, '') for player in row[stack_column_dict[site_var][type_var][sport_var]]
+                                    if team_dict.get(player, '') != ''
+                                ).most_common(1)[0][0] if any(team_dict.get(player, '') for player in row[stack_column_dict[site_var][type_var][sport_var]]) else '',
+                                axis=1
+                            )
+                            st.session_state['working_frame']['Size'] = st.session_state['working_frame'].apply(
+                                lambda row: Counter(
+                                    team_dict.get(player, '') for player in row[stack_column_dict[site_var][type_var][sport_var]]
+                                    if team_dict.get(player, '') != ''
+                                ).most_common(1)[0][1] if any(team_dict.get(player, '') for player in row[stack_column_dict[site_var][type_var][sport_var]]) else 0,
+                                axis=1
+                            )
+                        st.session_state['export_merge'] = st.session_state['working_frame'].copy()
+                    
+                    elif opt_exp_submitted:
+                        st.session_state['settings_base'] = False
+                        # Run optimization on export_base
+                        optimized_frame = optimize_lineup(
+                            working_frame=st.session_state['export_base'],
+                            projections_df=st.session_state['portfolio_inc_proj'],
+                            player_columns=st.session_state['player_columns'],
+                            map_dict=st.session_state['map_dict'],
+                            lock_teams=lock_teams_optimize,
+                            site_var=site_var,
+                            type_var=type_var,
+                            sport_var=sport_var,
+                            salary_max=salary_max,
+                            optimize_by=optimize_by
+                        )
+                        
+                        # Recalculate lineup metrics for export
+                        optimized_frame = calculate_lineup_metrics(
+                            optimized_frame, 
+                            st.session_state['player_columns'], 
+                            st.session_state['map_dict'], 
+                            type_var, 
+                            sport_var, 
+                            st.session_state['portfolio_inc_proj']
+                        )
+                        
+                        st.session_state['export_base'] = optimized_frame.reset_index(drop=True)
+                        
+                        # Load Default base from compressed storage for reassess_edge
+                        default_base = load_base_frame('Default')
+                        st.session_state['export_base'] = reassess_edge(
+                            st.session_state['export_base'], 
+                            default_base, 
+                            st.session_state['map_dict'], 
+                            site_var, 
+                            type_var, 
+                            Contest_Size, 
+                            strength_var, 
+                            sport_var, 
+                            salary_max
+                        )
+                        
+                        # Update Stack/Size columns if applicable
+                        team_dict = dict(zip(st.session_state['portfolio_inc_proj']['player_names'], st.session_state['portfolio_inc_proj']['team']))
+                        if 'Stack' in st.session_state['export_base'].columns:
+                            st.session_state['export_base']['Stack'] = st.session_state['export_base'].apply(
+                                lambda row: Counter(
+                                    team_dict.get(player, '') for player in row[stack_column_dict[site_var][type_var][sport_var]]
+                                    if team_dict.get(player, '') != ''
+                                ).most_common(1)[0][0] if any(team_dict.get(player, '') for player in row[stack_column_dict[site_var][type_var][sport_var]]) else '',
+                                axis=1
+                            )
+                            st.session_state['export_base']['Size'] = st.session_state['export_base'].apply(
+                                lambda row: Counter(
+                                    team_dict.get(player, '') for player in row[stack_column_dict[site_var][type_var][sport_var]]
+                                    if team_dict.get(player, '') != ''
+                                ).most_common(1)[0][1] if any(team_dict.get(player, '') for player in row[stack_column_dict[site_var][type_var][sport_var]]) else 0,
+                                axis=1
+                            )
+                        st.session_state['export_merge'] = st.session_state['export_base'].copy()
+            
         with st.container():
             if 'export_base' not in st.session_state:
                     st.session_state['export_base'] = pd.DataFrame(columns=st.session_state['working_frame'].columns)

global_func/optimize_lineup.py

@@ -1,74 +1,206 @@
-import streamlit as st
-import numpy as np
 import pandas as pd
-import time
-from rapidfuzz import process
+import numpy as np
+from ortools.linear_solver import pywraplp
 
-def optimize_lineup(row):
-    current_lineup = []
-    total_salary = 0
-    salary_cap = 50000
-    used_players = set()
+from global_func.exposure_spread import check_position_eligibility
 
-    # Convert row to dictionary with roster positions
-    roster = {}
-    for col, player in zip(row.index, row):
-        if col not in ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Lineup Edge']:
-            roster[col] = {
-                'name': player,
-                'position': map_dict['pos_map'].get(player, '').split('/'),
-                'team': map_dict['team_map'].get(player, ''),
-                'salary': map_dict['salary_map'].get(player, 0),
-                'median': map_dict['proj_map'].get(player, 0),
-                'ownership': map_dict['own_map'].get(player, 0)
-            }
-            total_salary += roster[col]['salary']
-            used_players.add(player)
 
-    # Optimize each roster position in random order
-    roster_positions = list(roster.items())
-    random.shuffle(roster_positions)
-    
-    for roster_pos, current in roster_positions:
-        # Skip optimization for players from removed teams
-        if current['team'] in remove_teams_var:
-            continue
-        
-        valid_positions = position_rules[roster_pos]
-        better_options = []
+def get_effective_salary(player_name: str, column_name: str, map_dict: dict, type_var: str) -> float:
+    """Calculate the effective salary for a player in a specific column (handles CPT multiplier)"""
+    base_salary = map_dict['salary_map'].get(player_name, 0)
+    if type_var != 'Classic' and column_name == 'CPT':
+        return base_salary * 1.5
+    return base_salary
 
-        # Find valid replacements for this roster position
-        for pos in valid_positions:
-            if pos in position_groups:
-                pos_options = [
-                    p for p in position_groups[pos]
-                    if p['median'] > current['median']
-                    and (total_salary - current['salary'] + p['salary']) <= salary_cap
-                    and p['player_names'] not in used_players
-                    and any(valid_pos in p['positions'] for valid_pos in valid_positions)
-                    and map_dict['team_map'].get(p['player_names']) not in remove_teams_var  # Check team restriction
-                ]
-                better_options.extend(pos_options)
 
-        if better_options:
-            # Remove duplicates
-            better_options = {opt['player_names']: opt for opt in better_options}.values()
-            
-            # Sort by median projection and take the best one
-            best_replacement = max(better_options, key=lambda x: x['median'])
-            
-            # Update the lineup and tracking variables
-            used_players.remove(current['name'])
-            used_players.add(best_replacement['player_names'])
-            total_salary = total_salary - current['salary'] + best_replacement['salary']
-            roster[roster_pos] = {
-                'name': best_replacement['player_names'],
-                'position': map_dict['pos_map'][best_replacement['player_names']].split('/'),
-                'team': map_dict['team_map'][best_replacement['player_names']],
-                'salary': best_replacement['salary'],
-                'median': best_replacement['median'],
-                'ownership': best_replacement['ownership']
-            }
+def optimize_single_lineup(
+    row: pd.Series,
+    player_columns: list,
+    player_pool: pd.DataFrame,
+    map_dict: dict,
+    lock_teams: list,
+    type_var: str,
+    sport_var: str,
+    salary_max: int,
+    optimize_by: str = 'median'
+) -> pd.Series:
+    """
+    Optimize a single lineup row using linear programming.
+    
+    Players from lock_teams are kept (locked), all other positions are cleared
+    and re-optimized using OR-Tools linear solver.
+    
+    Args:
+        row: A single lineup row from the DataFrame
+        player_columns: List of column names containing player positions
+        player_pool: DataFrame of available players (projections_df)
+        map_dict: Dictionary containing player mappings
+        lock_teams: List of team names whose players should be KEPT (locked)
+        type_var: 'Classic' or 'Showdown'
+        sport_var: Sport identifier (NFL, NBA, MLB, etc.)
+        salary_max: Maximum salary cap for the lineup
+        optimize_by: 'median' or 'ownership' - which metric to optimize for
+        
+    Returns:
+        Optimized row with potentially upgraded players
+    """
+    # Create a copy of the row to modify
+    optimized_row = row.copy()
+    
+    # Identify locked players (from lock_teams) and open positions
+    locked_players = {}  # {column: player_name}
+    open_columns = []
+    locked_salary = 0
+    locked_player_names = set()
+    
+    for col in player_columns:
+        player_name = row[col]
+        player_team = map_dict['team_map'].get(player_name, '')
+        
+        if player_team in lock_teams:
+            # Keep this player locked
+            locked_players[col] = player_name
+            locked_salary += get_effective_salary(player_name, col, map_dict, type_var)
+            locked_player_names.add(player_name)
+        else:
+            # This position is open for optimization
+            open_columns.append(col)
+    
+    # If no open columns, nothing to optimize
+    if not open_columns:
+        return optimized_row
+    
+    # Calculate remaining salary budget
+    remaining_salary = salary_max - locked_salary
+    
+    # Filter player pool: exclude locked teams and already-locked players
+    available_players = player_pool[
+        (~player_pool['team'].isin(lock_teams)) & 
+        (~player_pool['player_names'].isin(locked_player_names))
+    ].copy()
+    
+    if available_players.empty:
+        return optimized_row
+    
+    # Build the optimization model
+    solver = pywraplp.Solver.CreateSolver('CBC')
+    if not solver:
+        # Fallback if solver not available
+        return optimized_row
+    
+    # Create decision variables: x[player_idx, col_idx] = 1 if player is assigned to column
+    player_list = available_players.to_dict('records')
+    num_players = len(player_list)
+    num_open_cols = len(open_columns)
+    
+    # x[i][j] = 1 if player i is assigned to open column j
+    x = {}
+    for i in range(num_players):
+        for j in range(num_open_cols):
+            x[i, j] = solver.BoolVar(f'x_{i}_{j}')
+    
+    # Constraint 1: Each open column gets exactly one player
+    for j in range(num_open_cols):
+        solver.Add(sum(x[i, j] for i in range(num_players)) == 1)
+    
+    # Constraint 2: Each player can only be used once across all open columns
+    for i in range(num_players):
+        solver.Add(sum(x[i, j] for j in range(num_open_cols)) <= 1)
+    
+    # Constraint 3: Position eligibility
+    for i, player in enumerate(player_list):
+        player_positions = player['position'].split('/')
+        for j, col in enumerate(open_columns):
+            if type_var == 'Classic':
+                if not check_position_eligibility(sport_var, col, player_positions):
+                    solver.Add(x[i, j] == 0)
+            else:
+                # For Showdown, CPT and FLEX can take any player
+                pass
+    
+    # Constraint 4: Total salary of selected players <= remaining_salary
+    salary_constraint = []
+    for i, player in enumerate(player_list):
+        for j, col in enumerate(open_columns):
+            effective_salary = get_effective_salary(player['player_names'], col, map_dict, type_var)
+            salary_constraint.append(x[i, j] * effective_salary)
+    solver.Add(sum(salary_constraint) <= remaining_salary)
+    
+    # Objective: Maximize the sum of the optimization metric
+    objective_terms = []
+    for i, player in enumerate(player_list):
+        metric_value = player.get(optimize_by, player.get('median', 0))
+        for j in range(num_open_cols):
+            objective_terms.append(x[i, j] * metric_value)
+    
+    solver.Maximize(sum(objective_terms))
+    
+    # Solve
+    status = solver.Solve()
+    
+    if status == pywraplp.Solver.OPTIMAL or status == pywraplp.Solver.FEASIBLE:
+        # Extract solution
+        for j, col in enumerate(open_columns):
+            for i, player in enumerate(player_list):
+                if x[i, j].solution_value() > 0.5:
+                    optimized_row[col] = player['player_names']
+                    break
+    
+    return optimized_row
+
 
-    # Return optimized lineup maintaining original column order
-    return [roster[pos]['name'] for pos in row.index if pos in roster]
+def optimize_lineup(
+    working_frame: pd.DataFrame,
+    projections_df: pd.DataFrame,
+    player_columns: list,
+    map_dict: dict,
+    lock_teams: list,
+    site_var: str,
+    type_var: str,
+    sport_var: str,
+    salary_max: int,
+    optimize_by: str = 'median'
+) -> pd.DataFrame:
+    """
+    Optimize all lineups in a portfolio using linear programming.
+    
+    Players from lock_teams are kept (locked), all other positions are cleared
+    and re-optimized to find the best combination that fits the salary cap.
+    
+    Args:
+        working_frame: DataFrame containing lineups to optimize
+        projections_df: DataFrame with player projections (must have columns: 
+                       player_names, team, position, salary, median, ownership)
+        player_columns: List of column names containing player positions
+        map_dict: Dictionary containing player mappings
+        lock_teams: List of team names whose players should be KEPT (locked).
+                   All other players will be cleared and re-optimized.
+        site_var: 'Draftkings' or 'Fanduel'
+        type_var: 'Classic' or 'Showdown'
+        sport_var: Sport identifier (NFL, NBA, MLB, etc.)
+        salary_max: Maximum salary cap for lineups
+        optimize_by: 'median' or 'ownership' - which metric to optimize for (higher is better)
+        
+    Returns:
+        DataFrame with optimized lineups
+    """
+    # Create a copy to avoid modifying the original
+    optimized_frame = working_frame.copy()
+    
+    # Optimize each row
+    for idx in optimized_frame.index:
+        row = optimized_frame.loc[idx]
+        optimized_row = optimize_single_lineup(
+            row=row,
+            player_columns=player_columns,
+            player_pool=projections_df,
+            map_dict=map_dict,
+            lock_teams=lock_teams if lock_teams else [],
+            type_var=type_var,
+            sport_var=sport_var,
+            salary_max=salary_max,
+            optimize_by=optimize_by
+        )
+        optimized_frame.loc[idx] = optimized_row
+    
+    return optimized_frame

requirements.txt

@@ -5,4 +5,5 @@ numpy
 rapidfuzz
 matplotlib
 scipy
-pytz
+pytz
+ortools