Update app.py

app.py

@@ -111,8 +111,8 @@ def main():
     # Sidebar controls
     with st.sidebar:
         st.header("Optimization Settings")
-        min_stack = st.slider("Min players from same team (stacking)", 0, 5, 2)
-        max_stack = st.slider("Max players from same team", min_stack, 5, 4)
+        # Removed stacking controls
+        max_players_per_team = st.slider("Max players from same team", 1, 5, 5)
         max_exposure = st.slider("Max player exposure (%)", 10, 100, 60)
         min_salary = st.slider("Min Salary", 48000, 49900, 48500, 100)
         max_salary = st.slider("Max Salary", min_salary, 50000, 50000, 100)
@@ -131,19 +131,88 @@ def main():
                 
                 # Generate lineups using the optimizer
                 optimizer.setup_model(data_processor.players_df, max_salary)
-                optimizer.add_team_stack(data_processor.players_df, min_stack, max_stack)
+                
+                # Add team constraint without stacking requirement
+                # Only enforce maximum players per team
+                teams = data_processor.players_df["Team Name"].unique()
+                for team in teams:
+                    team_vars = [optimizer.player_vars[f"player_{idx}"]
+                               for idx, row in data_processor.players_df.iterrows()
+                               if row["Team Name"] == team]
+                    if team_vars:
+                        optimizer.model += lpSum(team_vars) <= max_players_per_team
+                
                 optimizer.add_exposure_constraints(data_processor.players_df, max_exposure/100)
                 
                 # Generate the specified number of lineups
-                lineups = optimizer.generate_lineups(
-                    data_processor.players_df, 
-                    num_lineups=num_lineups,
-                    min_salary=min_salary,
-                    max_salary=max_salary,
-                    min_stack=min_stack,
-                    max_stack=max_stack,
-                    max_exposure=max_exposure/100
-                )
+                lineups = []
+                
+                for i in range(num_lineups):
+                    try:
+                        # Setup optimizer for each lineup
+                        if i > 0:
+                            optimizer.setup_model(data_processor.players_df, max_salary)
+                            
+                            # Add team constraint without stacking
+                            for team in teams:
+                                team_vars = [optimizer.player_vars[f"player_{idx}"]
+                                           for idx, row in data_processor.players_df.iterrows()
+                                           if row["Team Name"] == team]
+                                if team_vars:
+                                    optimizer.model += lpSum(team_vars) <= max_players_per_team
+                            
+                            # Add exposure constraint
+                            optimizer.add_exposure_constraints(data_processor.players_df, max_exposure/100)
+                            
+                            # Add minimum salary constraint
+                            optimizer.model += lpSum([optimizer.player_vars[f"player_{idx}"] * row["Credits"]
+                                                for idx, row in data_processor.players_df.iterrows()]) >= min_salary
+                            
+                            # Add uniqueness constraint
+                            for prev_lineup in lineups:
+                                prev_players = [p["Player"] for p in prev_lineup["players"]]
+                                overlap_vars = [optimizer.player_vars[f"player_{idx}"]
+                                             for idx, row in data_processor.players_df.iterrows()
+                                             if row["Player"] in prev_players]
+                                if overlap_vars:
+                                    optimizer.model += lpSum(overlap_vars) <= 6  # Allow max 6 players overlap
+                        
+                        # Solve the optimization model
+                        from pulp import LpStatus, lpSum, value
+                        optimizer.model.solve()
+                        
+                        # Check if a solution was found
+                        if optimizer.model.status != 1:  # 1 means optimal solution found
+                            st.warning(f"No optimal solution found for lineup {i+1}. Stopping generation.")
+                            break
+                            
+                        # Get the selected players from the solution
+                        selected_players = []
+                        total_points = 0
+                        total_salary = 0
+                        
+                        for var_name, var in optimizer.player_vars.items():
+                            if var.value() > 0:
+                                player_idx = int(var_name.split('_')[1])
+                                player_data = data_processor.players_df.iloc[player_idx]
+                                selected_players.append({
+                                    "Player": player_data["Player"],
+                                    "Position": player_data["Position"],
+                                    "Team": player_data["Team Name"],
+                                    "Salary": player_data["Credits"],
+                                    "Projected": player_data["Projected Points"]
+                                })
+                                total_points += player_data["Projected Points"]
+                                total_salary += player_data["Credits"]
+                        
+                        lineups.append({
+                            "players": selected_players,
+                            "total_points": total_points,
+                            "total_salary": total_salary
+                        })
+                    except Exception as e:
+                        st.error(f"Error generating lineup {i+1}: {str(e)}")
+                        continue
                 
                 if not lineups:
                     st.error("No valid lineups found with given constraints")
@@ -252,4 +321,5 @@ def main():
         st.success(f"✅ Generated {len(st.session_state.df_lineups)} lineups (showing {len(filtered_lineups)} after filtering) and saved to Google Sheets!")
 
 if __name__ == "__main__":
-    main()
+    from pulp import LpVariable, LpProblem, LpMaximize, LpBinary, lpSum, LpStatus
+    main()