more exposure limiting work

app.py

@@ -2755,8 +2755,8 @@ if selected_tab == 'Optimizer':
 
                 with st.expander('Exposures'):
                     st.caption(
-                        "After each lineup, players at or above the cap are removed from the pool "
-                        "(usage = appearances ÷ lineups built so far)."
+                        "Cap is based on your target lineup count (e.g. 70% with 20 lineups "
+                        "→ each player in at most 14 lineups). Pool resets before each build."
                     )
                     enforce_max_exposure = st.checkbox(
                         "Enforce max player exposure",
@@ -2902,9 +2902,10 @@ if selected_tab == 'Optimizer':
                     float(max_player_exposure_pct) if enforce_max_exposure else None
                 )
                 if enforce_max_exposure:
+                    max_apps = int(max_player_exposure_pct / 100.0 * int(num_lineups))
                     st.caption(
-                        f"Enforcing max {max_player_exposure_pct:.0f}% exposure "
-                        f"across {int(num_lineups)} lineups (pool refreshes after each lineup)."
+                        f"Enforcing max {max_player_exposure_pct:.0f}% exposure: "
+                        f"≤ {max_apps} of {int(num_lineups)} lineups per player."
                     )
 
                 def _optimizer_build_progress(done: int, total: int) -> None:

global_func/build_optimal_lineups.py

@@ -3,6 +3,7 @@ Build optimal DFS lineups from projections using OR-Tools (via optimize_lineup h
 """
 from __future__ import annotations
 
+import math
 from collections import Counter
 from typing import Any, Callable
 
@@ -407,41 +408,37 @@ def _init_usage_counts(pool: pd.DataFrame) -> dict[str, int]:
     return dict.fromkeys(pool["player_names"].unique(), 0)
 
 
+def _max_appearances_for_cap(max_exposure_fraction: float, target_lineups: int) -> int:
+    """Max lineup appearances allowed per player (e.g. 70% of 20 lineups → 14)."""
+    if target_lineups < 1:
+        return 0
+    if max_exposure_fraction >= 1.0:
+        return target_lineups
+    return max(1, math.floor(max_exposure_fraction * target_lineups + 1e-9))
+
+
 def _exposure_excluded_players(
     pool_player_names,
     usage_counts: dict[str, int],
-    num_lineups_built: int,
-    max_exposure_fraction: float,
+    max_appearances: int,
 ) -> set[str]:
-    """
-    Players above the exposure cap on current usage (count / lineups built).
-
-    Anyone at or below the cap remains eligible when the pool is reset.
-    """
-    if num_lineups_built <= 0:
-        return set()
-    excluded: set[str] = set()
-    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
+    """Players who cannot appear in another lineup (already at max appearances)."""
+    return {
+        pname
+        for pname in pool_player_names
+        if usage_counts.get(pname, 0) >= max_appearances
+    }
 
 
 def _lineup_within_exposure_cap(
     row: pd.Series,
     player_columns: list[str],
     usage_counts: dict[str, int],
-    num_lineups_built: int,
-    max_exposure_fraction: float,
+    max_appearances: int,
 ) -> bool:
-    """True if accepting this lineup keeps every player at or below the exposure cap."""
-    if num_lineups_built <= 0:
-        return True
-    next_total = num_lineups_built + 1
+    """True if accepting this lineup keeps every player at or below max appearances."""
     for pname in _lineup_player_names(row, player_columns):
-        count = usage_counts.get(pname, 0)
-        if (count + 1) / next_total > max_exposure_fraction + 1e-9:
+        if usage_counts.get(pname, 0) + 1 > max_appearances:
             return False
     return True
 
@@ -449,25 +446,22 @@ def _lineup_within_exposure_cap(
 def _build_active_pool(
     pool: pd.DataFrame,
     usage_counts: dict[str, int],
-    num_lineups_built: int,
-    max_exposure_fraction: float | None,
+    max_appearances: int | None,
     static_exclude: set[str],
     temp_exclude: set[str] | None = None,
 ) -> pd.DataFrame:
     """
     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.
+    All projection players start at 0 appearances; exclude anyone who has reached
+    the max allowed for the target lineup count.
     """
     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(
-            pool_names, usage_counts, num_lineups_built, max_exposure_fraction
-        )
+    if max_appearances is not None:
+        exclude |= _exposure_excluded_players(pool_names, usage_counts, max_appearances)
     if not exclude:
         return pool.reset_index(drop=True)
     return pool[~pool["player_names"].isin(exclude)].reset_index(drop=True)
@@ -528,12 +522,13 @@ def generate_optimal_lineups(
     usage_counts: dict[str, int] = _init_usage_counts(pool)
 
     exposure_cap = None
+    max_appearances: int | None = 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))
+        max_appearances = _max_appearances_for_cap(exposure_cap, num_lineups)
 
     static_exclude: set[str] = set(exclude_players or [])
     stack_in_solver = bool(stack_config and stack_config.get("enabled") and stack_slot_columns)
-    use_fresh_lineup_build = stack_in_solver or exposure_cap is not None
 
     def _notify_progress() -> None:
         if progress_callback is not None:
@@ -562,12 +557,11 @@ def generate_optimal_lineups(
             key = _lineup_key(row, player_columns)
             if key in used_keys:
                 continue
-            if exposure_cap is not None and not _lineup_within_exposure_cap(
+            if max_appearances is not None and not _lineup_within_exposure_cap(
                 row,
                 player_columns,
                 usage_counts,
-                len(rows),
-                exposure_cap,
+                max_appearances,
             ):
                 continue
             used_keys.add(key)
@@ -586,7 +580,7 @@ def generate_optimal_lineups(
         type_var=type_var,
         optimize_by=optimize_by,
     )
-    first_pool = _build_active_pool(pool, usage_counts, 0, exposure_cap, static_exclude)
+    first_pool = _build_active_pool(pool, usage_counts, max_appearances, static_exclude)
     first_row = try_add_lineup(seed, first_pool)
     if first_row is None:
         return pd.DataFrame(columns=player_columns)
@@ -613,15 +607,14 @@ def generate_optimal_lineups(
         active_pool = _build_active_pool(
             pool,
             usage_counts,
-            num_built,
-            exposure_cap,
+            max_appearances,
             static_exclude,
             temp_exclude,
         )
         if active_pool.empty:
             break
 
-        if use_fresh_lineup_build:
+        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:
@@ -652,6 +645,13 @@ def generate_optimal_lineups(
         candidate_key = _lineup_key(candidate_row, player_columns)
         if candidate_key in used_keys:
             continue
+        if max_appearances is not None and not _lineup_within_exposure_cap(
+            candidate_row,
+            player_columns,
+            usage_counts,
+            max_appearances,
+        ):
+            continue
         used_keys.add(candidate_key)
         _record_lineup_usage(candidate_row, player_columns, usage_counts)
         rows.append(candidate_row)