more fixes towards exposure limiting

global_func/build_optimal_lineups.py

@@ -402,25 +402,28 @@ def _record_lineup_usage(
         usage_counts[pname] = usage_counts.get(pname, 0) + 1
 
 
+def _init_usage_counts(pool: pd.DataFrame) -> dict[str, int]:
+    """Every player in the projections pool starts at 0 appearances (0% exposure)."""
+    return dict.fromkeys(pool["player_names"].unique(), 0)
+
+
 def _exposure_excluded_players(
+    pool_player_names,
     usage_counts: dict[str, int],
     num_lineups_built: int,
     max_exposure_fraction: float,
 ) -> set[str]:
     """
-    Players to remove from the pool after ``num_lineups_built`` lineups exist.
+    Players above the exposure cap on current usage (count / lineups built).
 
-    Excludes anyone at or above the cap on current usage (count / built), and anyone
-    who would exceed the cap if they appeared in one more lineup.
+    Anyone at or below the cap remains eligible when the pool is reset.
     """
     if num_lineups_built <= 0:
         return set()
     excluded: set[str] = set()
-    next_total = num_lineups_built + 1
-    for pname, count in usage_counts.items():
-        if count / num_lineups_built >= max_exposure_fraction - 1e-9:
-            excluded.add(pname)
-        elif (count + 1) / next_total > max_exposure_fraction + 1e-9:
+    for pname in pool_player_names:
+        count = usage_counts.get(pname, 0)
+        if count / num_lineups_built > max_exposure_fraction + 1e-9:
             excluded.add(pname)
     return excluded
 
@@ -451,79 +454,25 @@ def _build_active_pool(
     static_exclude: set[str],
     temp_exclude: set[str] | None = None,
 ) -> pd.DataFrame:
-    """Player pool for the next lineup after applying exposure and user exclusions."""
+    """
+    Reset the optimization pool from the full projections pool before each lineup.
+
+    Includes every player at or below the exposure cap (0% by default); excludes
+    user blocks, optional temp blocks, and anyone strictly over the cap.
+    """
+    pool_names = pool["player_names"].unique()
     exclude = set(static_exclude)
     if temp_exclude:
         exclude |= temp_exclude
     if max_exposure_fraction is not None and num_lineups_built > 0:
         exclude |= _exposure_excluded_players(
-            usage_counts, num_lineups_built, max_exposure_fraction
+            pool_names, usage_counts, num_lineups_built, max_exposure_fraction
         )
     if not exclude:
-        return pool
+        return pool.reset_index(drop=True)
     return pool[~pool["player_names"].isin(exclude)].reset_index(drop=True)
 
 
-def _print_exposure_debug(
-    *,
-    label: str,
-    num_lineups_built: int,
-    num_lineups_target: int,
-    usage_counts: dict[str, int],
-    full_pool: pd.DataFrame,
-    active_pool: pd.DataFrame,
-    max_exposure_fraction: float | None,
-    static_exclude: set[str],
-    temp_exclude: set[str] | None = None,
-    attempt: int | None = None,
-) -> None:
-    """Stdout debug: player usage rates and who is in the optimization pool."""
-    cap_pct = max_exposure_fraction * 100 if max_exposure_fraction is not None else None
-    attempt_str = f" attempt={attempt}" if attempt is not None else ""
-    print(
-        f"\n[optimizer exposure] {label} | built={num_lineups_built}/{num_lineups_target}"
-        f"{attempt_str} | cap={cap_pct}%"
-    )
-    print(f"  full_pool={len(full_pool)} players | active_pool={len(active_pool)} players")
-
-    if usage_counts and num_lineups_built > 0:
-        usage_rows = []
-        for pname, count in sorted(usage_counts.items(), key=lambda x: (-x[1], x[0])):
-            rate = count / num_lineups_built
-            usage_rows.append(f"    {pname}: {count}/{num_lineups_built} ({rate:.1%})")
-        print(f"  usage ({len(usage_counts)} players with appearances):")
-        for line in usage_rows[:25]:
-            print(line)
-        if len(usage_rows) > 25:
-            print(f"    ... and {len(usage_rows) - 25} more")
-    elif num_lineups_built == 0:
-        print("  usage: (none yet — first lineup)")
-
-    if max_exposure_fraction is not None and num_lineups_built > 0:
-        exposure_blocked = _exposure_excluded_players(
-            usage_counts, num_lineups_built, max_exposure_fraction
-        )
-        print(f"  exposure_blocked={len(exposure_blocked)} players")
-        if exposure_blocked:
-            sample = sorted(exposure_blocked)[:15]
-            print(f"    sample: {', '.join(sample)}")
-            if len(exposure_blocked) > 15:
-                print(f"    ... and {len(exposure_blocked) - 15} more")
-
-    if static_exclude:
-        print(f"  user_excluded={len(static_exclude)} players")
-    if temp_exclude:
-        print(f"  temp_excluded (diversity)={len(temp_exclude)}: {', '.join(sorted(temp_exclude))}")
-
-    if not active_pool.empty:
-        avail = active_pool["player_names"].tolist()
-        print(f"  pool_available ({len(avail)}): {', '.join(avail[:20])}")
-        if len(avail) > 20:
-            print(f"    ... and {len(avail) - 20} more")
-    else:
-        print("  pool_available: EMPTY")
-
-
 def generate_optimal_lineups(
     player_pool: pd.DataFrame,
     player_columns: list[str],
@@ -576,19 +525,15 @@ def generate_optimal_lineups(
     lock_teams = lock_teams or []
     rows: list[pd.Series] = []
     used_keys: set[frozenset] = set()
-    usage_counts: dict[str, int] = {}
+    usage_counts: dict[str, int] = _init_usage_counts(pool)
 
     exposure_cap = None
     if max_player_exposure is not None and 0 < max_player_exposure < 100.0:
         exposure_cap = max(0.0, min(1.0, float(max_player_exposure) / 100.0))
-        print(
-            f"\n[optimizer exposure] START build | target_lineups={num_lineups} "
-            f"| cap={max_player_exposure}% | full_pool={len(pool)}"
-        )
 
     static_exclude: set[str] = set(exclude_players or [])
     stack_in_solver = bool(stack_config and stack_config.get("enabled") and stack_slot_columns)
-    debug_exposure = exposure_cap is not None
+    use_fresh_lineup_build = stack_in_solver or exposure_cap is not None
 
     def _notify_progress() -> None:
         if progress_callback is not None:
@@ -596,11 +541,9 @@ def generate_optimal_lineups(
 
     def try_add_lineup(seed: pd.Series, active_pool: pd.DataFrame) -> pd.Series | None:
         if active_pool.empty:
-            if debug_exposure:
-                print("  [try_add_lineup] skipped — active_pool is empty")
             return None
         max_tries = 8 if exposure_cap is not None else (5 if stack_in_solver else 8)
-        for try_idx in range(max_tries):
+        for _ in range(max_tries):
             row = _build_one_lineup(
                 seed,
                 player_columns,
@@ -615,13 +558,9 @@ def generate_optimal_lineups(
                 stack_slot_columns,
             )
             if row is None:
-                if debug_exposure:
-                    print(f"  [try_add_lineup] try {try_idx + 1}/{max_tries}: solver returned None")
                 continue
             key = _lineup_key(row, player_columns)
             if key in used_keys:
-                if debug_exposure:
-                    print(f"  [try_add_lineup] try {try_idx + 1}/{max_tries}: duplicate lineup")
                 continue
             if exposure_cap is not None and not _lineup_within_exposure_cap(
                 row,
@@ -630,23 +569,10 @@ def generate_optimal_lineups(
                 len(rows),
                 exposure_cap,
             ):
-                if debug_exposure:
-                    over = [
-                        p
-                        for p in _lineup_player_names(row, player_columns)
-                        if (usage_counts.get(p, 0) + 1) / (len(rows) + 1)
-                        > exposure_cap + 1e-9
-                    ]
-                    print(
-                        f"  [try_add_lineup] try {try_idx + 1}/{max_tries}: "
-                        f"over exposure cap — {over[:8]}"
-                    )
                 continue
             used_keys.add(key)
             _record_lineup_usage(row, player_columns, usage_counts)
             return row
-        if debug_exposure:
-            print(f"  [try_add_lineup] failed after {max_tries} tries")
         return None
 
     seed = seed_row_with_constraints(
@@ -661,35 +587,11 @@ def generate_optimal_lineups(
         optimize_by=optimize_by,
     )
     first_pool = _build_active_pool(pool, usage_counts, 0, exposure_cap, static_exclude)
-    if debug_exposure:
-        _print_exposure_debug(
-            label="before lineup 1",
-            num_lineups_built=0,
-            num_lineups_target=num_lineups,
-            usage_counts=usage_counts,
-            full_pool=pool,
-            active_pool=first_pool,
-            max_exposure_fraction=exposure_cap,
-            static_exclude=static_exclude,
-        )
     first_row = try_add_lineup(seed, first_pool)
     if first_row is None:
-        if debug_exposure:
-            print("[optimizer exposure] FAILED — could not build first lineup")
         return pd.DataFrame(columns=player_columns)
     rows.append(first_row)
     _notify_progress()
-    if debug_exposure:
-        _print_exposure_debug(
-            label="after lineup 1 accepted",
-            num_lineups_built=len(rows),
-            num_lineups_target=num_lineups,
-            usage_counts=usage_counts,
-            full_pool=pool,
-            active_pool=first_pool,
-            max_exposure_fraction=exposure_cap,
-            static_exclude=static_exclude,
-        )
 
     max_attempts = max(num_lineups * 50, 100) if exposure_cap is not None else max(num_lineups * 20, 40)
     attempts = 0
@@ -697,7 +599,7 @@ def generate_optimal_lineups(
         attempts += 1
         num_built = len(rows)
         temp_exclude: set[str] = set()
-        if stack_in_solver:
+        if stack_in_solver and exposure_cap is None:
             drop_name = _exclude_player_for_next_lineup(
                 rows[-1],
                 pool,
@@ -716,35 +618,13 @@ def generate_optimal_lineups(
             static_exclude,
             temp_exclude,
         )
-        if debug_exposure and (attempts == 1 or attempts % 10 == 0):
-            _print_exposure_debug(
-                label=f"before lineup {num_built + 1}",
-                num_lineups_built=num_built,
-                num_lineups_target=num_lineups,
-                usage_counts=usage_counts,
-                full_pool=pool,
-                active_pool=active_pool,
-                max_exposure_fraction=exposure_cap,
-                static_exclude=static_exclude,
-                temp_exclude=temp_exclude,
-                attempt=attempts,
-            )
         if active_pool.empty:
-            if debug_exposure:
-                print(
-                    f"[optimizer exposure] STOP — active_pool empty at attempt {attempts} "
-                    f"(built {num_built}/{num_lineups})"
-                )
             break
 
-        if stack_in_solver:
+        if use_fresh_lineup_build:
             next_seed = empty_lineup_row(player_columns)
             candidate_row = try_add_lineup(next_seed, active_pool)
             if candidate_row is None:
-                if debug_exposure and attempts <= 3:
-                    print(
-                        f"  [stack path] attempt {attempts}: try_add_lineup returned None"
-                    )
                 continue
             rows.append(candidate_row)
             _notify_progress()
@@ -764,44 +644,19 @@ def generate_optimal_lineups(
             used_keys,
         )
         if candidate_row is None:
-            if debug_exposure and attempts <= 5:
-                print(f"  [swap path] attempt {attempts}: _one_swap_below returned None")
             continue
         if not lineup_satisfies_stack(
             candidate_row, stack_config, stack_slot_columns, map_dict["team_map"]
         ):
-            if debug_exposure and attempts <= 5:
-                print(f"  [swap path] attempt {attempts}: stack check failed")
             continue
         candidate_key = _lineup_key(candidate_row, player_columns)
         if candidate_key in used_keys:
-            if debug_exposure and attempts <= 5:
-                print(
-                    f"  [swap path] attempt {attempts}: duplicate lineup "
-                    f"(same as prior — swap found nothing new)"
-                )
-            continue
-        if exposure_cap is not None and not _lineup_within_exposure_cap(
-            candidate_row,
-            player_columns,
-            usage_counts,
-            num_built,
-            exposure_cap,
-        ):
-            if debug_exposure and attempts <= 5:
-                print(f"  [swap path] attempt {attempts}: rejected by exposure cap")
             continue
         used_keys.add(candidate_key)
         _record_lineup_usage(candidate_row, player_columns, usage_counts)
         rows.append(candidate_row)
         _notify_progress()
 
-    if debug_exposure:
-        print(
-            f"\n[optimizer exposure] END build | built={len(rows)}/{num_lineups} "
-            f"| total_attempts={attempts}"
-        )
-
     result = pd.DataFrame(rows)
     objectives = [
         calculate_lineup_objective(result.iloc[i], player_columns, pool, metric_col)