updating stacking logic once again

global_func/optimize_lineup.py

@@ -298,6 +298,48 @@ def _compute_locked_stack_team_counts(
     return dict(counts)
 
 
+def _player_can_fill_open_stack_slot(
+    player: dict,
+    col_name: str,
+    sport_var: str,
+    type_var: str,
+) -> bool:
+    if type_var != "Classic":
+        return True
+    positions = str(player.get("position", "")).split("/")
+    return check_position_eligibility(sport_var, col_name, positions)
+
+
+def _teams_with_stack_capacity(
+    player_list: list[dict],
+    player_teams: list[str],
+    open_columns: list[str],
+    open_stack_indices: list[int],
+    locked_stack_counts: dict[str, int],
+    min_k: int,
+    sport_var: str,
+    type_var: str,
+) -> set[str]:
+    """Teams that can place at least ``min_k`` players on stack-eligible slots."""
+    all_teams = set(locked_stack_counts.keys()) | {t for t in player_teams if t}
+    eligible: set[str] = set()
+    for team in all_teams:
+        locked = locked_stack_counts.get(team, 0)
+        assignable_players: set[str] = set()
+        for i, pteam in enumerate(player_teams):
+            if pteam != team:
+                continue
+            for j in open_stack_indices:
+                if _player_can_fill_open_stack_slot(
+                    player_list[i], open_columns[j], sport_var, type_var
+                ):
+                    assignable_players.add(player_list[i]["player_names"])
+                    break
+        if locked + len(assignable_players) >= min_k:
+            eligible.add(team)
+    return eligible
+
+
 def _add_stack_constraints_to_solver(
     solver: pywraplp.Solver,
     x: dict,
@@ -307,6 +349,8 @@ def _add_stack_constraints_to_solver(
     stack_config: dict[str, Any],
     stack_slot_columns: list[str],
     team_map: dict,
+    sport_var: str,
+    type_var: str,
 ) -> None:
     """
     Enforce primary-stack rules on stack slot columns inside the MIP.
@@ -368,6 +412,20 @@ def _add_stack_constraints_to_solver(
         elif min_size is not None and max_size is not None and int(min_size) == int(max_size):
             target = int(min_size)
 
+        required = target if target is not None else (int(min_size) if min_size is not None else 1)
+        eligible_force = _teams_with_stack_capacity(
+            player_list,
+            player_teams,
+            open_columns,
+            open_stack_indices,
+            locked_stack_counts,
+            required,
+            sport_var,
+            type_var,
+        )
+        if force_team not in eligible_force:
+            return
+
         if target is not None:
             solver.Add(team_stack_count(force_team) == target)
         else:
@@ -375,27 +433,58 @@ def _add_stack_constraints_to_solver(
                 solver.Add(team_stack_count(force_team) >= int(min_size))
             if max_size is not None:
                 solver.Add(team_stack_count(force_team) <= int(max_size))
+        non_primary_cap = max(0, (target or int(min_size or 1)) - 1)
+        for team in candidate_teams:
+            if team and team != force_team:
+                solver.Add(team_stack_count(team) <= non_primary_cap)
         return
 
     min_k = int(min(allowed_sizes)) if allowed_sizes else (int(min_size) if min_size is not None else 0)
     max_k = int(max(allowed_sizes)) if allowed_sizes else (
         int(max_size) if max_size is not None else total_stack_slots
     )
-    if min_k <= 0 and max_k >= total_stack_slots:
+    if min_k <= 0:
         return
 
-    y = {team: solver.BoolVar(f"stack_primary_{team}") for team in candidate_teams}
-    solver.Add(sum(y[team] for team in candidate_teams) == 1)
+    eligible_primary = _teams_with_stack_capacity(
+        player_list,
+        player_teams,
+        open_columns,
+        open_stack_indices,
+        locked_stack_counts,
+        min_k,
+        sport_var,
+        type_var,
+    )
+    if allowed_teams:
+        eligible_primary &= set(allowed_teams)
+    if not eligible_primary:
+        return
 
-    big_m = total_stack_slots
+    non_primary_cap = max(0, min_k - 1)
     for team in candidate_teams:
+        if team and team not in eligible_primary:
+            solver.Add(team_stack_count(team) <= non_primary_cap)
+
+    if len(eligible_primary) == 1:
+        only_team = next(iter(eligible_primary))
+        solver.Add(team_stack_count(only_team) >= min_k)
+        solver.Add(team_stack_count(only_team) <= max_k)
+        return
+
+    y = {team: solver.BoolVar(f"stack_primary_{team}") for team in eligible_primary}
+    solver.Add(sum(y[team] for team in eligible_primary) == 1)
+
+    big_m = total_stack_slots
+    for team in eligible_primary:
         ct = team_stack_count(team)
         solver.Add(ct >= min_k * y[team])
         solver.Add(ct <= max_k + big_m * (1 - y[team]))
-        for other in candidate_teams:
+        for other in eligible_primary:
             if other == team:
                 continue
-            solver.Add(team_stack_count(other) <= (min_k - 1) + big_m * y[team])
+            # When ``team`` is primary, every other team has at most min_k-1 on stack slots.
+            solver.Add(team_stack_count(other) <= non_primary_cap + big_m * (1 - y[team]))
 
 
 def optimize_single_lineup(
@@ -605,6 +694,8 @@ def optimize_single_lineup(
             stack_config,
             stack_slot_columns,
             map_dict["team_map"],
+            sport_var,
+            type_var,
         )
     
     # Objective: Maximize the sum of the optimization metric
@@ -614,8 +705,10 @@ def optimize_single_lineup(
     status = solver.Solve()
     
     achieved_objective = locked_objective_value  # Start with locked contribution
-    
-    if status == pywraplp.Solver.OPTIMAL or status == pywraplp.Solver.FEASIBLE:
+
+    solved = status in (pywraplp.Solver.OPTIMAL, pywraplp.Solver.FEASIBLE)
+
+    if solved:
         # Extract solution: only open_columns are filled; locked columns are left untouched
         for j, col in enumerate(open_columns):
             for i, player in enumerate(player_list):
@@ -626,11 +719,18 @@ def optimize_single_lineup(
         # Enforce locked players stay in their starting column (no move to F/UTIL/etc.)
         for col, player_name in locked_players.items():
             optimized_row[col] = player_name
-    
+
+    open_filled = any(
+        optimized_row.get(col) not in ("", None)
+        and str(optimized_row.get(col)) not in ("nan", "None", "NaN")
+        for col in open_columns
+    )
+    if not solved or not open_filled:
+        return row.copy(), original_objective
+
     # CRITICAL: Only return optimized lineup if it's actually better than original
     # If optimization resulted in a worse lineup, keep the original
-    if achieved_objective < original_objective:
-        # Optimization made things worse - keep the original lineup
+    if achieved_objective < original_objective and original_objective > 0:
         return row.copy(), original_objective
 
     return optimized_row, achieved_objective