Draft page (#19)

* Add blank draft page

* Fix uneeded f-string

* Load yahoo_con into session

* Enable draft view with 2023 and 2024 for testing

* Apply black

* Load league settings

* Implement selection of year and refresh button

* Implement view of roster positions with caching of league settings

* Move ECR to another file to share

* Add export of fp tiers csv

* Get ecr data loaded and merged withd draft results

* Sort into columns by pos

* Remove unused fp ecr

* Split into tiers

* Filter out some positions

* Put filters in expander

* Format red if drafted

src/config.py

@@ -3,3 +3,4 @@ DEFAULT_ICON = "🏉"
 LEAGUE_NUMBER_TEAMS = 12
 
 KEEPER_DATA_URL = "../../tests/mocks/2024_keepers.csv"
+SEASON = 2024

src/ecr.py

@@ -0,0 +1,67 @@
+import os
+import pandas as pd
+import streamlit as st
+
+from streamlit_filter import filter_dataframe
+
+
+def load_adp() -> pd.DataFrame:
+    df = pd.read_csv(r"https://raw.githubusercontent.com/dynastyprocess/data/master/files/db_fpecr_latest.csv")
+    df["ranking_type"] = df["fp_page"].apply(lambda x: os.path.split(x)[-1].replace(".php", ""))
+    return df
+
+
+@st.cache_data(ttl=60 * 60 * 24)
+def load_adp_data():
+    # Merge ADP
+    data = load_adp()
+    ranking_type_list = sorted(list(data.ranking_type.unique()))
+    return data, ranking_type_list
+
+
+def filtered_ecr_dataframe(data: pd.DataFrame, ranking_type_list: list[str]):
+    default_ix = ranking_type_list.index("ppr-superflex-cheatsheets")
+    ranking_type_selected = st.selectbox("ECR Format:", ranking_type_list, index=default_ix)
+    ranking_type_filter = data["ranking_type"] == ranking_type_selected
+
+    is_advanced = st.checkbox("Show Advanced View")
+
+    id_cols = [
+        # "player_square_image_url",
+        "player",
+        "pos",
+        "team",
+    ]
+
+    id_cols_advanced = [
+        "bye",
+        "player_owned_yahoo",
+    ]
+
+    adp_cols: list[str] = [
+        "ecr",
+    ]
+
+    adp_cols_advanced = ["sd", "best", "worst"]
+
+    if is_advanced:
+        show_columns = id_cols + id_cols_advanced + adp_cols + adp_cols_advanced
+    else:
+        show_columns = id_cols + adp_cols
+
+    data_filtered_by_ranking_type = data.loc[ranking_type_filter]
+    latest_scrape_date = data_filtered_by_ranking_type.scrape_date.max()
+    st.write(f"Scraped data as of: {latest_scrape_date}")
+
+    filtered_data = filter_dataframe(data.loc[ranking_type_filter, show_columns])
+    st.dataframe(
+        filtered_data,
+        hide_index=True,
+        height=35 * (len(filtered_data) + 1) + 12,
+        use_container_width=True,
+        column_config={
+            # "player_square_image_url": st.column_config.ImageColumn(label="", help="Player image"),
+        },
+    )
+
+    st.write("Source: https://github.com/dynastyprocess/data")

src/login_component.py

@@ -41,6 +41,7 @@ def get_authorization_button():
             st.session_state.token = result.get("token")
             yahoo_con = YahooFantasyClient(oauth2, st.session_state.token)
             st.session_state.logged_in_guid = yahoo_con.get_guid_for_logged_in_user()
+            st.session_state.yahoo_client = yahoo_con
             st.rerun()
     else:
         # # If token exists in session state, allow logout
@@ -48,6 +49,7 @@ def get_authorization_button():
         if st.button("Logout"):
             del st.session_state.token
             del st.session_state.logged_in_guid
+            del st.session_state.yahoo_client
             st.rerun()
         # # If token exists in session state, show the token
         # token = st.session_state["token"]

src/pages/3_Draft_View.py

@@ -0,0 +1,160 @@
+import json
+import pandas as pd
+import requests
+import streamlit as st
+
+from config import DEFAULT_ICON, SEASON
+from login_component import is_token_in_session
+from shared_page import common_page_config
+from streamlit_filter import filter_dataframe
+
+
+@st.cache_data(ttl=60 * 60 * 24)
+def load_yahoo_to_fp_id_map() -> dict[str, str]:
+    df = pd.read_csv(r"https://raw.githubusercontent.com/dynastyprocess/data/master/files/db_playerids.csv")
+    for id_col in ["yahoo_id", "fantasypros_id"]:
+        df[id_col] = df[id_col].fillna(-9999).apply(lambda x: str(int(x)))
+    return df.set_index("yahoo_id")["fantasypros_id"].to_dict()
+
+
+def extract_ecr_var_data(request_text_str, var_name: str):
+    start_str = f"""var {var_name} = """
+    end_str = """};"""
+    end_offset = 1  # include closing bracket
+
+    start_slice_pos = request_text_str.find(start_str) + len(start_str)
+    first_slice = request_text_str[start_slice_pos:]
+    end_slice_pos = first_slice.find(end_str) + end_offset
+    dom_str = first_slice[:end_slice_pos]
+    var_json = json.loads(dom_str)
+    return var_json
+
+
+@st.cache_data(ttl=60 * 60 * 24)
+def load_ecr_data():
+    request_text = get_ecr_request_text()
+    ecr_data = extract_ecr_var_data(request_text, "ecrData")
+    ecr_columns = [
+        "player_id",
+        "player_name",
+        "player_position_id",
+        "player_bye_week",
+        "rank_ecr",
+        "pos_rank",
+        "tier",
+    ]
+    df_ecr = pd.DataFrame(ecr_data["players"])[ecr_columns]
+    df_ecr["player_id"] = df_ecr["player_id"].apply(lambda x: str(int(x)))
+
+    # sos_data = extract_ecr_var_data(request_text, "sosData")
+    # adp_data = extract_ecr_var_data(request_text, "adpData")
+    return df_ecr
+
+
+@st.cache_data(ttl=60 * 60 * 24)
+def get_ecr_request_text():
+    r = requests.get("https://www.fantasypros.com/nfl/rankings/half-point-ppr-cheatsheets.php")
+    return r.text
+
+
+@st.cache_resource(ttl=60 * 60 * 24)
+def get_league_settings_with_cache(selected_league):
+    return st.session_state.yahoo_client.parse_league_settings(selected_league)
+
+
+def highlight_drafted(data_row_series):
+    return ["background-color: red" if data_row_series.is_drafted else "" for _ in range(len(data_row_series))]
+
+
+def display_formatted_tiers(df):
+    st.dataframe(
+        df.style.apply(highlight_drafted, axis=1),
+        hide_index=True,
+        height=35 * (len(df) + 1) + 5,
+        column_order=[
+            "rank_ecr",
+            "player_name",
+            # "player_position_id",
+            "player_bye_week",
+            # "tier",
+            # "is_drafted",
+        ],
+        column_config={
+            "player_name": st.column_config.TextColumn(label="Name", help="Player's name"),
+            "player_position_id": st.column_config.TextColumn(label="Position", help="Player's position"),
+            "player_bye_week": st.column_config.NumberColumn(label="Bye", help="Player's Bye Week"),
+            "rank_ecr": st.column_config.NumberColumn(label="Rank", help="Player ECR Rank"),
+            "tier": st.column_config.NumberColumn(label="Tier", help="Player Tier"),
+            "is_drafted": st.column_config.CheckboxColumn(label="Drafted", help="Has been drafted"),
+        },
+    )
+
+
+def get_page():
+    page_title = "Yahoo Draft Live Summary"
+    st.set_page_config(page_title=page_title, page_icon=DEFAULT_ICON, layout="wide")
+    common_page_config()
+    st.title(page_title)
+
+    if not is_token_in_session():
+        st.write(
+            "You must authorize the application to access your account in order to use this feature."
+            " Please click Login button above."
+        )
+
+    else:
+        selected_season = st.selectbox("Select Season", list(range(SEASON, 2012, -1)))
+        user_leagues = st.session_state.yahoo_client.find_all_leagues_for_logged_in_user(season=selected_season)
+        selected_league = st.selectbox("Select league", user_leagues)
+        league_settings = get_league_settings_with_cache(selected_league)
+        st.header(f"{league_settings.name} - {league_settings.season}")
+        with st.expander("Show Positions"):
+            st.dataframe(
+                pd.DataFrame(league_settings.roster_positions).set_index("position")["count"],
+            )
+
+        draft_result = pd.DataFrame(st.session_state.yahoo_client.get_draft(selected_league))
+        if st.button("Load / Refresh"):
+            draft_result = pd.DataFrame(st.session_state.yahoo_client.get_draft(selected_league))
+        if "player_key" in draft_result:
+            draft_result["player_id"] = draft_result["player_key"].apply(lambda x: x.rsplit(".", 1)[-1] if x else x)
+        else:
+            draft_result["player_id"] = ""
+        draft_result["fp_id"] = draft_result["player_id"].apply(lambda x: load_yahoo_to_fp_id_map().get(x))
+
+        if "team_key" not in draft_result:
+            draft_result["team_key"] = ""
+
+        with st.expander("Show Draft Results"):
+            st.dataframe(draft_result)
+
+        st.header("ECR Tiers")
+        ecr_data = load_ecr_data()
+        draft_result_merge_cols = [
+            "fp_id",
+            "team_key",
+        ]
+        ecr_with_draft = ecr_data.merge(
+            draft_result[draft_result_merge_cols], how="left", left_on="player_id", right_on="fp_id"
+        )
+        ecr_with_draft["is_drafted"] = ecr_with_draft["fp_id"].notna()
+        with st.expander("Filters"):
+            filtered_data = filter_dataframe(
+                ecr_with_draft, force_on=True, force_on_columns=["is_drafted", "player_position_id"]
+            )
+
+        position_list = [
+            x for x in ["QB", "RB", "WR", "TE", "DST", "K"] if x in filtered_data.player_position_id.unique()
+        ]
+        columns_list = st.columns(len(position_list))
+        for pos, col in zip(position_list, columns_list):
+            with col:
+                st.header(pos)
+                df_pos = filtered_data[filtered_data.player_position_id == pos]
+                for tier, df_tier in df_pos.groupby("tier"):
+                    st.header(f"Tier {tier}")
+                    display_formatted_tiers(df_tier)
+
+
+if __name__ == "__main__":
+    get_page()

src/pages/3_ECR.py

@@ -1,76 +1,8 @@
-import os
-import pandas as pd
 import streamlit as st
 
 from config import DEFAULT_ICON
 from shared_page import common_page_config
-from streamlit_filter import filter_dataframe
-
-
-KEEPER_DATA_URL = "../../tests/mocks/2023_keepers.csv"
-HEADSHOT_DATA_URL = "../../tests/mocks/2023_player_headshots.csv"
-
-
-def load_adp() -> pd.DataFrame:
-    df = pd.read_csv(r"https://raw.githubusercontent.com/dynastyprocess/data/master/files/db_fpecr_latest.csv")
-    df["ranking_type"] = df["fp_page"].apply(lambda x: os.path.split(x)[-1].replace(".php", ""))
-    return df
-
-
-@st.cache_data(ttl=60 * 60 * 24)
-def load_data():
-    # Merge ADP
-    data = load_adp()
-    ranking_type_list = sorted(list(data.ranking_type.unique()))
-    return data, ranking_type_list
-
-
-def filtered_ecr_dataframe(data: pd.DataFrame, ranking_type_list: list[str]):
-    default_ix = ranking_type_list.index("ppr-superflex-cheatsheets")
-    ranking_type_selected = st.selectbox("ECR Format:", ranking_type_list, index=default_ix)
-    ranking_type_filter = data["ranking_type"] == ranking_type_selected
-
-    is_advanced = st.checkbox("Show Advanced View")
-
-    id_cols = [
-        # "player_square_image_url",
-        "player",
-        "pos",
-        "team",
-    ]
-
-    id_cols_advanced = [
-        "bye",
-        "player_owned_yahoo",
-    ]
-
-    adp_cols: list[str] = [
-        "ecr",
-    ]
-
-    adp_cols_advanced = ["sd", "best", "worst"]
-
-    if is_advanced:
-        show_columns = id_cols + id_cols_advanced + adp_cols + adp_cols_advanced
-    else:
-        show_columns = id_cols + adp_cols
-
-    data_filtered_by_ranking_type = data.loc[ranking_type_filter]
-    latest_scrape_date = data_filtered_by_ranking_type.scrape_date.max()
-    st.write(f"Scraped data as of: {latest_scrape_date}")
-
-    filtered_data = filter_dataframe(data.loc[ranking_type_filter, show_columns])
-    st.dataframe(
-        filtered_data,
-        hide_index=True,
-        height=35 * (len(filtered_data) + 1) + 12,
-        use_container_width=True,
-        column_config={
-            # "player_square_image_url": st.column_config.ImageColumn(label="", help="Player image"),
-        },
-    )
-
-    st.write("Source: https://github.com/dynastyprocess/data")
+from ecr import load_adp_data, filtered_ecr_dataframe
 
 
 def get_keeper_app():
@@ -78,7 +10,7 @@ def get_keeper_app():
     st.set_page_config(page_title=keeper_title, page_icon=DEFAULT_ICON, layout="wide")
     common_page_config()
     st.title(keeper_title)
-    data, ecr_type_list = load_data()
+    data, ecr_type_list = load_adp_data()
 
     with st.container():
         filtered_ecr_dataframe(data, ecr_type_list)

src/yahoo_client.py

@@ -2,7 +2,7 @@ import asyncio
 import pandas as pd
 from pydantic import BaseModel
 import re
-from typing import List, Mapping, Tuple, Union
+from typing import List, Mapping, Tuple, Union, Optional
 import xml.etree.ElementTree as ET
 from streamlit_oauth import OAuth2Component
 
@@ -17,6 +17,7 @@ class LeagueSettings(BaseModel):
     playoff_start_week: int
     num_playoff_teams: int
     num_playoff_consolation_teams: int
+    roster_positions: list[dict]
 
     @classmethod
     def from_xml(cls, xml_settings: ET.Element) -> "LeagueSettings":
@@ -37,6 +38,19 @@ class LeagueSettings(BaseModel):
         ]
         settings_fields_dict = {f: xml_settings.findtext(f"./league/settings/{f}") for f in settings_fields_list}
         league_settings_dict = {**base_fields_dict, **settings_fields_dict}
+
+        roster_fields_list = [
+            "position",
+            "position_type",
+            "count",
+            "is_starting_position",
+        ]
+
+        roster_positions = [
+            {f: x.findtext(f"./{f}") for f in roster_fields_list}
+            for x in xml_settings.findall("./league/settings/roster_positions/*")
+        ]
+
         return cls(
             league_key=league_settings_dict["league_key"] or "",
             league_id=league_settings_dict["league_id"] or "",
@@ -47,6 +61,7 @@ class LeagueSettings(BaseModel):
             playoff_start_week=int(league_settings_dict["playoff_start_week"] or 0),
             num_playoff_teams=int(league_settings_dict["num_playoff_teams"] or 0),
             num_playoff_consolation_teams=int(league_settings_dict["num_playoff_consolation_teams"] or 0),
+            roster_positions=roster_positions,
         )
 
 
@@ -73,8 +88,14 @@ class YahooFantasyClient:
         root = ET.fromstring(xmlstring)
         return root, xmlstring
 
-    def find_all_leagues_for_logged_in_user(self) -> List[str]:
-        url = "https://fantasysports.yahooapis.com/fantasy/v2/users;use_login=1/games;game_keys=nfl/leagues"
+    def find_all_leagues_for_logged_in_user(self, season: Optional[str]) -> List[str]:
+        if season:
+            season_str = f";seasons={season}"
+        else:
+            season_str = ""
+        url = (
+            f"https://fantasysports.yahooapis.com/fantasy/v2/users;use_login=1/games{season_str};game_codes=nfl/leagues"
+        )
         root, _ = self.yahoo_request_to_xml(url)
         league_keys = list(
             filter(None, [x.text for x in root.findall("./users/user/games/game/leagues/league/league_key")])
@@ -97,6 +118,20 @@ class YahooFantasyClient:
         parsed_league_settings = LeagueSettings.from_xml(league_settings)
         return parsed_league_settings
 
+    def get_draft(self, league_key: str):
+        url = f"https://fantasysports.yahooapis.com/fantasy/v2/league/{league_key}/draftresults"
+        draft_results_xml, _ = self.yahoo_request_to_xml(url)
+        parsed_draft = [
+            {
+                "pick": x.findtext("./pick"),
+                "round": x.findtext("./round"),
+                "team_key": x.findtext("./team_key"),
+                "player_key": x.findtext("./player_key"),
+            }
+            for x in draft_results_xml.findall("./league/draft_results/*")
+        ]
+        return parsed_draft
+
     def parse_weeks_matchups(self, week: str, league_key: str) -> List[Mapping[str, Union[str, float]]]:
         url = f"https://fantasysports.yahooapis.com/fantasy/v2/leagues;league_keys={league_key}/scoreboard;week={week}"
         week_scoreboard, _ = self.yahoo_request_to_xml(url)