Implement options by week and position map with locking after game start

src/pages/10_Set_Your_Lineup.py

@@ -6,8 +6,8 @@ from config import DEFAULT_ICON
 from shared_page import common_page_config
 
 from domain.constants import SEASON
-from domain.playoffs import PLAYOFF_WEEK_TO_NAME, CURRENT_PLAYOFF_WEEK, PLAYOFF_WEEK_TO_SCHEDULE_WEEK
-from domain.teams import SCHEDULE_NAME_TO_PFR_NAME_MAP
+from domain.playoffs import PLAYOFF_WEEK_TO_NAME, CURRENT_PLAYOFF_WEEK, SCHEDULE_WEEK_TO_PLAYOFF_WEEK
+from domain.teams import SCHEDULE_NAME_TO_PFR_NAME_MAP, PLAYOFFS_TEAMS
 from queries.nflverse.github_data import get_weekly_rosters
 from queries.pfr.league_schedule import get_season_time_map
 from login import check_password, get_user_team, save_user_team
@@ -21,6 +21,7 @@ class PlayerOption:
     position: str
     team: str
     gametime: pd.Timestamp | None
+    week: int | None
 
     @classmethod
     def from_series(cls, input_series):
@@ -31,53 +32,71 @@ class PlayerOption:
             position=input_series.position,
             team=input_series.team,
             gametime=input_series.gametime,
+            week=int(input_series.week),
         )
 
     @classmethod
-    def empty_player(cls):
-        return cls(
-            full_name="",
-            gsis_id="",
-            headshot_url="",
-            position="",
-            team="",
-            gametime=None,
-        )
-
-
-def player_options_from_df(df_options, position_filter: str) -> list[PlayerOption]:
-    empty_first_option_list = [PlayerOption.empty_player()]
-    return (
-        empty_first_option_list
-        + df_options[df_options.position == position_filter].apply(PlayerOption.from_series, axis=1).tolist()
-    )
+    def empty_player(cls, week: int | None = None):
+        return cls(full_name="", gsis_id="", headshot_url="", position="", team="", gametime=None, week=week)
+
+    def is_locked(self):
+        if not self.gametime:
+            return False
+        else:
+            return self.gametime < pd.Timestamp.now()
+
+
+def initialize_empty_options_map() -> dict[str, dict[int, list[PlayerOption]]]:
+    options_map: dict[str, dict[int, list[PlayerOption]]] = {}
+    for pos in ["QB", "RB", "WR", "TE", "K", "DEF"]:
+        options_map[pos] = {}
+        for week in PLAYOFF_WEEK_TO_NAME.keys():
+            options_map[pos][int(week)] = [PlayerOption.empty_player(week=week)]
+    return options_map
+
+
+def player_options_from_df(df_options) -> dict[str, dict[int, list[PlayerOption]]]:
+    options_map = initialize_empty_options_map()
+    for pos, pos_week_map in options_map.items():
+        for week in pos_week_map.keys():
+            df_pos_week = df_options[
+                ((df_options.week.map(SCHEDULE_WEEK_TO_PLAYOFF_WEEK) == week) & (df_options.position == pos))
+            ]
+            if len(df_pos_week) > 0:
+                player_options_list = df_pos_week.apply(PlayerOption.from_series, axis=1).tolist()
+                options_map[pos][int(week)].extend(player_options_list)
+    return options_map
 
 
 @st.cache_data(ttl=60 * 60 * 24)
 def load_options():
-    # filter active only
     df_rosters = get_weekly_rosters()
-    df_rosters = df_rosters[df_rosters.status == "ACT"]
 
-    # get current week games
-    schedule_week = PLAYOFF_WEEK_TO_SCHEDULE_WEEK[CURRENT_PLAYOFF_WEEK]
-    current_week_game_times = get_season_time_map(SEASON)[schedule_week]
-    latest_game_time = max(current_week_game_times.values())
+    # get game schedules
+    week_game_times = get_season_time_map(SEASON)
+    latest_game_time_defaults = {k: max(v) for k, v in week_game_times.items() if v}
 
-    # select latest
+    # sort
     sort_by_cols = ["position", "week", "fantasy_points"]
-    df_rosters = df_rosters.sort_values(sort_by_cols, ascending=False).drop_duplicates(subset="gsis_id")
+    df_rosters.sort_values(sort_by_cols, ascending=False, inplace=True)
+
+    # filter data from non-playoffs
+    df_rosters = df_rosters[df_rosters.week.isin(SCHEDULE_WEEK_TO_PLAYOFF_WEEK.keys())]
     # set gametime
     df_rosters["gametime"] = df_rosters.apply(
-        lambda x: current_week_game_times.get(SCHEDULE_NAME_TO_PFR_NAME_MAP[x.team], latest_game_time), axis=1
+        lambda x: week_game_times.get(x.week, {}).get(
+            SCHEDULE_NAME_TO_PFR_NAME_MAP[x.team], latest_game_time_defaults.get(x.week, None)
+        ),
+        axis=1,
+    )
+
+    df_rosters["in_playoffs"] = df_rosters.apply(
+        lambda x: x.team in PLAYOFFS_TEAMS[SCHEDULE_WEEK_TO_PLAYOFF_WEEK[x.week]], axis=1
     )
 
-    qb_options = player_options_from_df(df_rosters, "QB")
-    wr_options = player_options_from_df(df_rosters, "WR")
-    rb_options = player_options_from_df(df_rosters, "RB")
-    te_options = player_options_from_df(df_rosters, "TE")
-    k_options = player_options_from_df(df_rosters, "K")
-    return qb_options, wr_options, rb_options, te_options, k_options
+    df_rosters = df_rosters[df_rosters.in_playoffs]
+    player_options = player_options_from_df(df_rosters)
+    return player_options
 
 
 def format_player_option(player_opt: PlayerOption) -> str:
@@ -90,9 +109,12 @@ def display_player(player_opt: PlayerOption | None):
             st.image(player_opt.headshot_url, caption=player_opt.full_name)
 
 
-def position_cell(week: str, pos_str: str, options_list: list[PlayerOption], existing_selection_map):
-    pos_label = f"{week}-{pos_str}"
+def position_cell(
+    week: str, pos_str: str, pos_idx: int, options_map: dict[str, dict[int, list[PlayerOption]]], existing_selection_map
+):
+    pos_label = f"{week}-{pos_str}-{pos_idx}"
     selected_id = existing_selection_map.get(pos_label)
+    options_list = options_map[pos_str][int(week)]
     if isinstance(selected_id, str):
         selected_option_idx, selected_player = next(
             (i, v) for i, v in enumerate(options_list) if str(selected_id) == str(v.gsis_id)
@@ -103,7 +125,7 @@ def position_cell(week: str, pos_str: str, options_list: list[PlayerOption], exi
     if int(week) > CURRENT_PLAYOFF_WEEK:
         options = []
         selected_option_idx = 0
-    elif int(week) < CURRENT_PLAYOFF_WEEK:
+    elif int(week) < CURRENT_PLAYOFF_WEEK or selected_player.is_locked():
         options = [selected_player]
         selected_option_idx = 0
     else:
@@ -141,28 +163,28 @@ def get_page():
         st.rerun()
     existing_selections = get_user_team()
 
-    qb_options, wr_options, rb_options, te_options, k_options = load_options()
+    player_options = load_options()
 
     for week in range(1, 5):
         st.header(PLAYOFF_WEEK_TO_NAME[week])
         selection_cols = st.columns(8)
 
         with selection_cols[0]:
-            position_cell(week, "QB-1", qb_options, existing_selections)
+            position_cell(week, "QB", 1, player_options, existing_selections)
         with selection_cols[1]:
-            position_cell(week, "RB-1", rb_options, existing_selections)
+            position_cell(week, "RB", 1, player_options, existing_selections)
         with selection_cols[2]:
-            position_cell(week, "RB-2", rb_options, existing_selections)
+            position_cell(week, "RB", 2, player_options, existing_selections)
         with selection_cols[3]:
-            position_cell(week, "WR-1", wr_options, existing_selections)
+            position_cell(week, "WR", 1, player_options, existing_selections)
         with selection_cols[4]:
-            position_cell(week, "WR-2", wr_options, existing_selections)
+            position_cell(week, "WR", 2, player_options, existing_selections)
         with selection_cols[5]:
-            position_cell(week, "TE-1", te_options, existing_selections)
+            position_cell(week, "TE", 1, player_options, existing_selections)
         with selection_cols[6]:
-            position_cell(week, "K-1", k_options, existing_selections)
+            position_cell(week, "K", 1, player_options, existing_selections)
         with selection_cols[7]:
-            position_cell(week, "DEF-1", [], existing_selections)
+            position_cell(week, "DEF", 1, player_options, existing_selections)
 
 
 if __name__ == "__main__":