more work on the exposure limiting and adding some prints

global_func/build_optimal_lineups.py

@@ -464,6 +464,66 @@ def _build_active_pool(
     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],
@@ -521,9 +581,14 @@ def generate_optimal_lineups(
     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
 
     def _notify_progress() -> None:
         if progress_callback is not None:
@@ -531,9 +596,11 @@ 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 _ in range(max_tries):
+        for try_idx in range(max_tries):
             row = _build_one_lineup(
                 seed,
                 player_columns,
@@ -548,9 +615,13 @@ 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,
@@ -559,10 +630,23 @@ 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(
@@ -577,11 +661,35 @@ 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
@@ -608,13 +716,35 @@ 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:
             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()
@@ -634,13 +764,22 @@ 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,
@@ -649,12 +788,20 @@ def generate_optimal_lineups(
             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)