Spaces:
Running
Running
James McCool
Refactor data export logic in app.py: streamline the export process by consolidating column drop operations for Portfolio Manager exports and enhancing the mapping of player position columns. This update improves data clarity and ensures accurate filtering based on salary ranges.
bf4ffa6
| import streamlit as st | |
| import numpy as np | |
| import pandas as pd | |
| import streamlit as st | |
| import gspread | |
| import pymongo | |
| import unicodedata | |
| st.set_page_config(layout="wide") | |
| def init_conn(): | |
| uri = st.secrets['mongo_uri'] | |
| client = pymongo.MongoClient(uri, retryWrites=True, serverSelectionTimeoutMS=500000) | |
| db = client["NBA_DFS"] | |
| wnba_db = client["WNBA_DFS"] | |
| return db, wnba_db | |
| db, wnba_db = init_conn() | |
| dk_nba_columns = ['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'] | |
| dk_nba_sd_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'] | |
| fd_nba_columns = ['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C1', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'] | |
| fd_nba_sd_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'] | |
| dk_wnba_columns = ['G1', 'G2', 'F1', 'F2', 'F3', 'UTIL', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'] | |
| dk_wnba_sd_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'] | |
| fd_wnba_columns = ['G1', 'G2', 'G3', 'F1', 'F2', 'F3', 'F4', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'] | |
| fd_wnba_sd_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'] | |
| roo_format = {'Top_finish': '{:.2%}', 'Top_5_finish': '{:.2%}', 'Top_10_finish': '{:.2%}', '20+%': '{:.2%}', '4x%': '{:.2%}', '5x%': '{:.2%}', '6x%': '{:.2%}', 'GPP%': '{:.2%}'} | |
| st.markdown(""" | |
| <style> | |
| /* Tab styling */ | |
| .stTabs [data-baseweb="tab-list"] { | |
| gap: 8px; | |
| padding: 4px; | |
| } | |
| .stTabs [data-baseweb="tab"] { | |
| height: 50px; | |
| white-space: pre-wrap; | |
| background-color: #DAA520; | |
| color: white; | |
| border-radius: 10px; | |
| gap: 1px; | |
| padding: 10px 20px; | |
| font-weight: bold; | |
| transition: all 0.3s ease; | |
| } | |
| .stTabs [aria-selected="true"] { | |
| background-color: #DAA520; | |
| border: 3px solid #FFD700; | |
| color: white; | |
| } | |
| .stTabs [data-baseweb="tab"]:hover { | |
| background-color: #FFD700; | |
| cursor: pointer; | |
| } | |
| </style>""", unsafe_allow_html=True) | |
| def load_overall_stats(league: str): | |
| if league == 'NBA': | |
| collection = db["DK_Player_Stats"] | |
| elif league == 'WNBA': | |
| collection = wnba_db["DK_Player_Stats"] | |
| cursor = collection.find() | |
| raw_display = pd.DataFrame(list(cursor)) | |
| if league == 'NBA': | |
| raw_display = raw_display[['Name', 'Salary', 'Position', 'Team', 'Opp', 'Minutes', 'FGM', 'FGA', 'FG2M', 'FG2A', 'Threes', 'FG3A', 'FTM', 'FTA', 'TRB', 'AST', 'STL', 'BLK', 'TOV', '2P', '3P', 'FT', | |
| 'Points', 'Rebounds', 'Assists', 'PRA', 'PR', 'PA', 'RA', 'Steals', 'Blocks', 'Turnovers', 'Fantasy', 'Raw', 'Own']] | |
| raw_display = raw_display.rename(columns={"Name": "Player", "Nickname": "Player", "Fantasy": "Median"}) | |
| elif league == 'WNBA': | |
| raw_display = raw_display.rename(columns={"Name": "Player", "Nickname": "Player", "DK_Proj": "Median", "DK_ID": "ID", "DK_Pos": "Position", "DK_Salary": "Salary", "DK_Own": "Own"}) | |
| raw_display = raw_display.loc[raw_display['Median'] > 0] | |
| raw_display = raw_display.apply(pd.to_numeric, errors='ignore') | |
| dk_raw = raw_display.sort_values(by='Median', ascending=False) | |
| if league == 'NBA': | |
| collection = db["FD_Player_Stats"] | |
| elif league == 'WNBA': | |
| collection = wnba_db["FD_Player_Stats"] | |
| cursor = collection.find() | |
| raw_display = pd.DataFrame(list(cursor)) | |
| if league == 'NBA': | |
| raw_display = raw_display[['Nickname', 'Salary', 'Position', 'Team', 'Opp', 'Minutes', 'FGM', 'FGA', 'FG2M', 'FG2A', 'Threes', 'FG3A', 'FTM', 'FTA', 'TRB', 'AST', 'STL', 'BLK', 'TOV', '2P', '3P', 'FT', | |
| 'Points', 'Rebounds', 'Assists', 'PRA', 'PR', 'PA', 'RA', 'Steals', 'Blocks', 'Turnovers', 'Fantasy', 'Raw', 'Own']] | |
| raw_display = raw_display.rename(columns={"Name": "Player", "Nickname": "Player", "Fantasy": "Median"}) | |
| elif league == 'WNBA': | |
| raw_display = raw_display.rename(columns={"Name": "Player", "Nickname": "Player", "FD_Proj": "Median", "FD_ID": "ID", "FD_Pos": "Position", "FD_Salary": "Salary", "FD_Own": "Own"}) | |
| raw_display = raw_display.loc[raw_display['Median'] > 0] | |
| raw_display = raw_display.apply(pd.to_numeric, errors='ignore') | |
| fd_raw = raw_display.sort_values(by='Median', ascending=False) | |
| if league == 'NBA': | |
| collection = db["Secondary_DK_Player_Stats"] | |
| elif league == 'WNBA': | |
| collection = wnba_db["Secondary_DK_Player_Stats"] | |
| cursor = collection.find() | |
| raw_display = pd.DataFrame(list(cursor)) | |
| if league == 'NBA': | |
| raw_display = raw_display[['Name', 'Salary', 'Position', 'Team', 'Opp', 'Minutes', 'FGM', 'FGA', 'FG2M', 'FG2A', 'Threes', 'FG3A', 'FTM', 'FTA', 'TRB', 'AST', 'STL', 'BLK', 'TOV', '2P', '3P', 'FT', | |
| 'Points', 'Rebounds', 'Assists', 'PRA', 'PR', 'PA', 'RA', 'Steals', 'Blocks', 'Turnovers', 'Fantasy', 'Raw', 'Own']] | |
| raw_display = raw_display.rename(columns={"Name": "Player", "Nickname": "Player", "Fantasy": "Median"}) | |
| elif league == 'WNBA': | |
| raw_display = raw_display.rename(columns={"Name": "Player", "Nickname": "Player", "DK_Proj": "Median", "DK_ID": "ID", "DK_Pos": "Position", "DK_Salary": "Salary", "DK_Own": "Own"}) | |
| raw_display = raw_display.loc[raw_display['Median'] > 0] | |
| raw_display = raw_display.apply(pd.to_numeric, errors='ignore') | |
| dk_raw_sec = raw_display.sort_values(by='Median', ascending=False) | |
| if league == 'NBA': | |
| collection = db["Secondary_FD_Player_Stats"] | |
| elif league == 'WNBA': | |
| collection = wnba_db["Secondary_FD_Player_Stats"] | |
| cursor = collection.find() | |
| raw_display = pd.DataFrame(list(cursor)) | |
| if league == 'NBA': | |
| raw_display = raw_display[['Nickname', 'Salary', 'Position', 'Team', 'Opp', 'Minutes', 'FGM', 'FGA', 'FG2M', 'FG2A', 'Threes', 'FG3A', 'FTM', 'FTA', 'TRB', 'AST', 'STL', 'BLK', 'TOV', '2P', '3P', 'FT', | |
| 'Points', 'Rebounds', 'Assists', 'PRA', 'PR', 'PA', 'RA', 'Steals', 'Blocks', 'Turnovers', 'Fantasy', 'Raw', 'Own']] | |
| raw_display = raw_display.rename(columns={"Name": "Player", "Nickname": "Player", "Fantasy": "Median"}) | |
| elif league == 'WNBA': | |
| raw_display = raw_display.rename(columns={"Name": "Player", "Nickname": "Player", "FD_Proj": "Median", "FD_ID": "ID", "FD_Pos": "Position", "FD_Salary": "Salary", "FD_Own": "Own"}) | |
| raw_display = raw_display.loc[raw_display['Median'] > 0] | |
| raw_display = raw_display.apply(pd.to_numeric, errors='ignore') | |
| fd_raw_sec = raw_display.sort_values(by='Median', ascending=False) | |
| if league == 'NBA': | |
| collection = db["Player_SD_Range_Of_Outcomes"] | |
| elif league == 'WNBA': | |
| collection = wnba_db["Player_SD_Range_Of_Outcomes"] | |
| cursor = collection.find() | |
| raw_display = pd.DataFrame(list(cursor)) | |
| raw_display = raw_display[['Player', 'Minutes Proj', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '4x%', '5x%', '6x%', 'GPP%', | |
| 'Own', 'Small_Own', 'Large_Own', 'Cash_Own', 'CPT_Own', 'LevX', 'ValX', 'site', 'version', 'slate', 'timestamp', 'player_id']] | |
| raw_display['Median'] = raw_display['Median'].replace('', 0).astype(float) | |
| raw_display = raw_display.rename(columns={"player_id": "player_ID"}) | |
| raw_display = raw_display.loc[raw_display['Median'] > 0] | |
| raw_display = raw_display.apply(pd.to_numeric, errors='ignore') | |
| sd_raw = raw_display.sort_values(by='Median', ascending=False) | |
| dk_sd_raw = sd_raw[sd_raw['site'] == 'Draftkings'] | |
| fd_sd_raw = sd_raw[sd_raw['site'] == 'Fanduel'] | |
| fd_sd_raw['player_ID'] = fd_sd_raw['player_ID'].astype(str) | |
| fd_sd_raw['player_ID'] = fd_sd_raw['player_ID'].str.rsplit('-', n=1).str[0].astype(str) | |
| print(sd_raw.head(10)) | |
| if league == 'NBA': | |
| collection = db["Player_Range_Of_Outcomes"] | |
| elif league == 'WNBA': | |
| collection = wnba_db["Player_Range_Of_Outcomes"] | |
| cursor = collection.find() | |
| raw_display = pd.DataFrame(list(cursor)) | |
| try: | |
| raw_display = raw_display[['Player', 'Minutes Proj', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '4x%', '5x%', '6x%', 'GPP%', | |
| 'Own', 'Small_Own', 'Large_Own', 'Cash_Own', 'CPT_Own', 'LevX', 'ValX', 'site', 'version', 'slate', 'timestamp', 'player_ID']] | |
| except: | |
| raw_display = raw_display[['Player', 'Minutes Proj', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '4x%', '5x%', '6x%', 'GPP%', | |
| 'Own', 'Small_Own', 'Large_Own', 'Cash_Own', 'CPT_Own', 'LevX', 'ValX', 'site', 'version', 'slate', 'timestamp', 'player_id']] | |
| raw_display = raw_display.rename(columns={"player_id": "player_ID"}) | |
| raw_display['Median'] = raw_display['Median'].replace('', 0).astype(float) | |
| raw_display = raw_display.loc[raw_display['Median'] > 0] | |
| raw_display = raw_display.apply(pd.to_numeric, errors='ignore') | |
| roo_raw = raw_display.sort_values(by='Median', ascending=False) | |
| timestamp = raw_display['timestamp'].values[0] | |
| return dk_raw, fd_raw, dk_raw_sec, fd_raw_sec, roo_raw, sd_raw, dk_sd_raw, fd_sd_raw, timestamp | |
| def init_DK_lineups(slate_desig: str, league: str): | |
| if slate_desig == 'Main Slate': | |
| if league == 'NBA': | |
| collection = db['DK_NBA_name_map'] | |
| elif league == 'WNBA': | |
| collection = wnba_db['DK_WNBA_name_map'] | |
| cursor = collection.find() | |
| raw_data = pd.DataFrame(list(cursor)) | |
| names_dict = dict(zip(raw_data['key'], raw_data['value'])) | |
| if league == 'NBA': | |
| collection = db["DK_NBA_seed_frame"] | |
| elif league == 'WNBA': | |
| collection = wnba_db["DK_WNBA_seed_frame"] | |
| cursor = collection.find().limit(10000) | |
| elif slate_desig == 'Secondary': | |
| if league == 'NBA': | |
| collection = db['DK_NBA_Secondary_name_map'] | |
| elif league == 'WNBA': | |
| collection = wnba_db['DK_WNBA_Secondary_name_map'] | |
| cursor = collection.find() | |
| raw_data = pd.DataFrame(list(cursor)) | |
| names_dict = dict(zip(raw_data['key'], raw_data['value'])) | |
| if league == 'NBA': | |
| collection = db["DK_NBA_Secondary_seed_frame"] | |
| elif league == 'WNBA': | |
| collection = wnba_db["DK_WNBA_Secondary_seed_frame"] | |
| cursor = collection.find().limit(10000) | |
| elif slate_desig == 'Auxiliary': | |
| collection = db['DK_NBA_Auxiliary_name_map'] | |
| cursor = collection.find() | |
| raw_data = pd.DataFrame(list(cursor)) | |
| names_dict = dict(zip(raw_data['key'], raw_data['value'])) | |
| collection = db["DK_NBA_Auxiliary_seed_frame"] | |
| cursor = collection.find().limit(10000) | |
| raw_display = pd.DataFrame(list(cursor)) | |
| if league == 'NBA': | |
| raw_display = raw_display[['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']] | |
| dict_columns = ['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX'] | |
| elif league == 'WNBA': | |
| raw_display = raw_display[['G1', 'G2', 'F1', 'F2', 'F3', 'UTIL', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']] | |
| dict_columns = ['G1', 'G2', 'F1', 'F2', 'F3', 'UTIL'] | |
| for col in dict_columns: | |
| raw_display[col] = raw_display[col].map(names_dict) | |
| DK_seed = raw_display.to_numpy() | |
| return DK_seed | |
| def init_DK_SD_lineups(slate_desig: str, league: str): | |
| if slate_desig == 'Main Slate': | |
| if league == 'NBA': | |
| collection = db["DK_NBA_SD_seed_frame"] | |
| elif league == 'WNBA': | |
| collection = wnba_db["DK_WNBA_SD_seed_frame"] | |
| elif slate_desig == 'Secondary': | |
| if league == 'NBA': | |
| collection = db["DK_NBA_Secondary_SD_seed_frame"] | |
| elif league == 'WNBA': | |
| collection = wnba_db["DK_WNBA_Secondary_SD_seed_frame"] | |
| elif slate_desig == 'Auxiliary': | |
| collection = db["DK_NBA_Auxiliary_SD_seed_frame"] | |
| cursor = collection.find({"Team_count": {"$lt": 6}}).limit(10000) | |
| raw_display = pd.DataFrame(list(cursor)) | |
| raw_display = raw_display[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']] | |
| DK_seed = raw_display.to_numpy() | |
| return DK_seed | |
| def init_FD_lineups(slate_desig: str, league: str): | |
| if slate_desig == 'Main Slate': | |
| if league == 'NBA': | |
| collection = db['FD_NBA_name_map'] | |
| elif league == 'WNBA': | |
| collection = wnba_db['FD_WNBA_name_map'] | |
| cursor = collection.find() | |
| raw_data = pd.DataFrame(list(cursor)) | |
| names_dict = dict(zip(raw_data['key'], raw_data['value'])) | |
| if league == 'NBA': | |
| collection = db["FD_NBA_seed_frame"] | |
| elif league == 'WNBA': | |
| collection = wnba_db["FD_WNBA_seed_frame"] | |
| cursor = collection.find().limit(10000) | |
| elif slate_desig == 'Secondary': | |
| if league == 'NBA': | |
| collection = db['FD_NBA_Secondary_name_map'] | |
| elif league == 'WNBA': | |
| collection = wnba_db['FD_WNBA_Secondary_name_map'] | |
| cursor = collection.find() | |
| raw_data = pd.DataFrame(list(cursor)) | |
| names_dict = dict(zip(raw_data['key'], raw_data['value'])) | |
| if league == 'NBA': | |
| collection = db["FD_NBA_Secondary_seed_frame"] | |
| elif league == 'WNBA': | |
| collection = wnba_db["FD_WNBA_Secondary_seed_frame"] | |
| cursor = collection.find().limit(10000) | |
| elif slate_desig == 'Auxiliary': | |
| collection = db['FD_NBA_Auxiliary_name_map'] | |
| cursor = collection.find() | |
| raw_data = pd.DataFrame(list(cursor)) | |
| names_dict = dict(zip(raw_data['key'], raw_data['value'])) | |
| collection = db["FD_NBA_Auxiliary_seed_frame"] | |
| cursor = collection.find().limit(10000) | |
| raw_display = pd.DataFrame(list(cursor)) | |
| if league == 'NBA': | |
| raw_display = raw_display[['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C1', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']] | |
| dict_columns = ['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C1'] | |
| elif league == 'WNBA': | |
| raw_display = raw_display[['G1', 'G2', 'G3', 'F1', 'F2', 'F3', 'F4', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']] | |
| dict_columns = ['G1', 'G2', 'G3', 'F1', 'F2', 'F3', 'F4'] | |
| for col in dict_columns: | |
| raw_display[col] = raw_display[col].map(names_dict) | |
| FD_seed = raw_display.to_numpy() | |
| return FD_seed | |
| def init_FD_SD_lineups(slate_desig: str, league: str): | |
| if slate_desig == 'Main Slate': | |
| if league == 'NBA': | |
| collection = db["FD_NBA_SD_seed_frame"] | |
| elif league == 'WNBA': | |
| collection = wnba_db["FD_WNBA_SD_seed_frame"] | |
| elif slate_desig == 'Secondary': | |
| if league == 'NBA': | |
| collection = db["FD_NBA_Secondary_SD_seed_frame"] | |
| elif league == 'WNBA': | |
| collection = wnba_db["FD_WNBA_Secondary_SD_seed_frame"] | |
| elif slate_desig == 'Auxiliary': | |
| collection = db["FD_NBA_Auxiliary_SD_seed_frame"] | |
| cursor = collection.find({"Team_count": {"$lt": 6}}).limit(10000) | |
| raw_display = pd.DataFrame(list(cursor)) | |
| raw_display = raw_display[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']] | |
| DK_seed = raw_display.to_numpy() | |
| return DK_seed | |
| def normalize_special_characters(text): | |
| """Convert accented characters to their ASCII equivalents""" | |
| if pd.isna(text): | |
| return text | |
| # Normalize unicode characters to their closest ASCII equivalents | |
| normalized = unicodedata.normalize('NFKD', str(text)) | |
| # Remove diacritics (accents, umlauts, etc.) | |
| ascii_text = ''.join(c for c in normalized if not unicodedata.combining(c)) | |
| return ascii_text | |
| def convert_df_to_csv(df): | |
| df_clean = df.copy() | |
| for col in df_clean.columns: | |
| if df_clean[col].dtype == 'object': | |
| df_clean[col] = df_clean[col].apply(normalize_special_characters) | |
| return df_clean.to_csv(index=False).encode('utf-8') | |
| def convert_df(array): | |
| array = pd.DataFrame(array, columns=column_names) | |
| # Normalize special characters in the dataframe before export | |
| for col in array.columns: | |
| if array[col].dtype == 'object': | |
| array[col] = array[col].apply(normalize_special_characters) | |
| return array.to_csv(index=False).encode('utf-8') | |
| def convert_pm_df(array): | |
| array = pd.DataFrame(array) | |
| # Normalize special characters in the dataframe before export | |
| for col in array.columns: | |
| if array[col].dtype == 'object': | |
| array[col] = array[col].apply(normalize_special_characters) | |
| return array.to_csv(index=False).encode('utf-8') | |
| dk_raw, fd_raw, dk_raw_sec, fd_raw_sec, roo_raw, sd_raw, dk_sd_raw, fd_sd_raw, timestamp = load_overall_stats('NBA') | |
| salary_dict = dict(zip(roo_raw.Player, roo_raw.Salary)) | |
| id_dict = dict(zip(roo_raw.Player, roo_raw.player_ID)) | |
| salary_dict_sd = dict(zip(sd_raw.Player, sd_raw.Salary)) | |
| dk_id_dict_sd = dict(zip(dk_sd_raw.Player, dk_sd_raw.player_ID)) | |
| fd_id_dict_sd = dict(zip(fd_sd_raw.Player, fd_sd_raw.player_ID)) | |
| dk_nba_lineups = pd.DataFrame(columns=dk_nba_columns) | |
| dk_nba_sd_lineups = pd.DataFrame(columns=dk_nba_sd_columns) | |
| fd_nba_lineups = pd.DataFrame(columns=fd_nba_columns) | |
| fd_nba_sd_lineups = pd.DataFrame(columns=fd_nba_sd_columns) | |
| dk_wnba_lineups = pd.DataFrame(columns=dk_wnba_columns) | |
| dk_wnba_sd_lineups = pd.DataFrame(columns=dk_wnba_sd_columns) | |
| fd_wnba_lineups = pd.DataFrame(columns=fd_wnba_columns) | |
| fd_wnba_sd_lineups = pd.DataFrame(columns=fd_wnba_sd_columns) | |
| t_stamp = f"Last Update: " + str(timestamp) + f" CST" | |
| with st.container(): | |
| st.info("Advanced view includes all stats and thresholds, simple includes just basic columns for ease of use on mobile") | |
| reset_col, view_col, site_col, league_col = st.columns(4) | |
| with reset_col: | |
| # First row - timestamp and reset button | |
| col1, col2 = st.columns([3, 3]) | |
| with col1: | |
| st.info(t_stamp) | |
| with col2: | |
| if st.button("Load/Reset Data", key='reset1'): | |
| st.cache_data.clear() | |
| dk_raw, fd_raw, dk_raw_sec, fd_raw_sec, roo_raw, sd_raw, dk_sd_raw, fd_sd_raw, timestamp = load_overall_stats('NBA') | |
| salary_dict = dict(zip(roo_raw.Player, roo_raw.Salary)) | |
| id_dict = dict(zip(roo_raw.Player, roo_raw.player_ID)) | |
| salary_dict_sd = dict(zip(sd_raw.Player, sd_raw.Salary)) | |
| dk_id_dict_sd = dict(zip(dk_sd_raw.Player, dk_sd_raw.player_ID)) | |
| fd_id_dict_sd = dict(zip(fd_sd_raw.Player, fd_sd_raw.player_ID)) | |
| dk_nba_lineups = pd.DataFrame(columns=dk_nba_columns) | |
| dk_nba_sd_lineups = pd.DataFrame(columns=dk_nba_sd_columns) | |
| fd_nba_lineups = pd.DataFrame(columns=fd_nba_columns) | |
| fd_nba_sd_lineups = pd.DataFrame(columns=fd_nba_sd_columns) | |
| dk_wnba_lineups = pd.DataFrame(columns=dk_wnba_columns) | |
| dk_wnba_sd_lineups = pd.DataFrame(columns=dk_wnba_sd_columns) | |
| fd_wnba_lineups = pd.DataFrame(columns=fd_wnba_columns) | |
| fd_wnba_sd_lineups = pd.DataFrame(columns=fd_wnba_sd_columns) | |
| t_stamp = f"Last Update: " + str(timestamp) + f" CST" | |
| for key in st.session_state.keys(): | |
| del st.session_state[key] | |
| with view_col: | |
| view_var2 = st.radio("View Type", ('Simple', 'Advanced'), key='view_var2') | |
| with site_col: | |
| site_var2 = st.radio("Site", ('Draftkings', 'Fanduel'), key='site_var2') | |
| with league_col: | |
| league_var = st.radio("What League to load:", ('WNBA', 'NBA'), key='league_var') | |
| dk_raw, fd_raw, dk_raw_sec, fd_raw_sec, roo_raw, sd_raw, dk_sd_raw, fd_sd_raw, timestamp = load_overall_stats(league_var) | |
| tab1, tab2 = st.tabs(['Range of Outcomes', 'Optimals']) | |
| with tab1: | |
| with st.expander("Info and Filters"): | |
| col1, col2, col3 = st.columns(3) | |
| with col1: | |
| slate_type_var2 = st.radio("What slate type are you working with?", ('Regular', 'Showdown'), key='slate_type_var2') | |
| with col2: | |
| slate_split = st.radio("Slate Type", ('Main Slate', 'Secondary'), key='slate_split') | |
| if slate_split == 'Main Slate': | |
| if site_var2 == 'Draftkings': | |
| if slate_type_var2 == 'Regular': | |
| site_baselines = roo_raw[roo_raw['site'] == 'Draftkings'] | |
| raw_baselines = site_baselines[site_baselines['slate'] == 'Main Slate'] | |
| elif slate_type_var2 == 'Showdown': | |
| site_baselines = sd_raw[sd_raw['site'] == 'Draftkings'] | |
| raw_baselines = site_baselines[site_baselines['slate'] == 'Showdown #1'] | |
| elif site_var2 == 'Fanduel': | |
| if slate_type_var2 == 'Regular': | |
| site_baselines = roo_raw[roo_raw['site'] == 'Fanduel'] | |
| raw_baselines = site_baselines[site_baselines['slate'] == 'Main Slate'] | |
| elif slate_type_var2 == 'Showdown': | |
| site_baselines = sd_raw[sd_raw['site'] == 'Fanduel'] | |
| raw_baselines = site_baselines[site_baselines['slate'] == 'Showdown #1'] | |
| elif slate_split == 'Secondary': | |
| if site_var2 == 'Draftkings': | |
| if slate_type_var2 == 'Regular': | |
| site_baselines = roo_raw[roo_raw['site'] == 'Draftkings'] | |
| raw_baselines = site_baselines[site_baselines['slate'] == 'Secondary Slate'] | |
| elif slate_type_var2 == 'Showdown': | |
| site_baselines = sd_raw[sd_raw['site'] == 'Draftkings'] | |
| raw_baselines = site_baselines[site_baselines['slate'] == 'Showdown #2'] | |
| elif site_var2 == 'Fanduel': | |
| if slate_type_var2 == 'Regular': | |
| site_baselines = roo_raw[roo_raw['site'] == 'Fanduel'] | |
| raw_baselines = site_baselines[site_baselines['slate'] == 'Secondary Slate'] | |
| elif slate_type_var2 == 'Showdown': | |
| site_baselines = sd_raw[sd_raw['site'] == 'Fanduel'] | |
| raw_baselines = site_baselines[site_baselines['slate'] == 'Showdown #2'] | |
| with col3: | |
| split_var2 = st.radio("Slate Range", ('Full Slate Run', 'Specific Games'), key='split_var2') | |
| if split_var2 == 'Specific Games': | |
| team_var2 = st.multiselect('Select teams for ROO', options=raw_baselines['Team'].unique(), key='team_var2') | |
| else: | |
| team_var2 = raw_baselines.Team.values.tolist() | |
| pos_var2 = st.selectbox('Position Filter', options=['All', 'PG', 'SG', 'SF', 'PF', 'C'], key='pos_var2') | |
| col1, col2 = st.columns(2) | |
| with col1: | |
| low_salary = st.number_input('Enter Lowest Salary', min_value=300, max_value=15000, value=300, step=100, key='low_salary') | |
| with col2: | |
| high_salary = st.number_input('Enter Highest Salary', min_value=300, max_value=25000, value=25000, step=100, key='high_salary') | |
| display_container_1 = st.empty() | |
| display_dl_container_1 = st.empty() | |
| display_proj = raw_baselines[raw_baselines['Team'].isin(team_var2)] | |
| display_proj = display_proj[display_proj['Salary'].between(low_salary, high_salary)] | |
| if view_var2 == 'Advanced': | |
| display_proj = display_proj[['Player', 'Minutes Proj', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '4x%', '5x%', '6x%', 'GPP%', | |
| 'Own', 'Small_Own', 'Large_Own', 'Cash_Own', 'CPT_Own', 'LevX', 'ValX']] | |
| elif view_var2 == 'Simple': | |
| display_proj = display_proj[['Player', 'Position', 'Salary', 'Median', 'GPP%', 'Own']] | |
| export_data = raw_baselines.copy() | |
| export_data_pm = raw_baselines[['Player', 'Position', 'Team', 'Salary', 'Median', 'Own', 'CPT_Own']] | |
| export_data_pm = export_data_pm.rename(columns={'Own': 'ownership', 'Median': 'median', 'Player': 'player_names', 'Position': 'position', 'Team': 'team', 'Salary': 'salary', 'CPT_Own': 'captain ownership'}) | |
| # display_proj = display_proj.set_index('Player') | |
| st.session_state.display_proj = display_proj.set_index('Player', drop=True) | |
| reg_dl_col, pm_dl_col, blank_col = st.columns([2, 2, 6]) | |
| with reg_dl_col: | |
| st.download_button( | |
| label="Export ROO (Regular)", | |
| data=convert_df_to_csv(export_data), | |
| file_name='NBA_ROO_export.csv', | |
| mime='text/csv', | |
| ) | |
| with pm_dl_col: | |
| st.download_button( | |
| label="Export ROO (Portfolio Manager)", | |
| data=convert_df_to_csv(export_data_pm), | |
| file_name='NBA_ROO_export.csv', | |
| mime='text/csv', | |
| ) | |
| if 'display_proj' in st.session_state: | |
| if pos_var2 == 'All': | |
| st.session_state.display_proj = st.session_state.display_proj | |
| elif pos_var2 != 'All': | |
| st.session_state.display_proj = st.session_state.display_proj[st.session_state.display_proj['Position'].str.contains(pos_var2)] | |
| st.dataframe(st.session_state.display_proj.style.set_properties(**{'font-size': '6pt'}).background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(roo_format, precision=2), | |
| height=1000, use_container_width = True) | |
| with tab2: | |
| with st.expander("Info and Filters"): | |
| if st.button("Load/Reset Data", key='reset2'): | |
| st.cache_data.clear() | |
| dk_raw, fd_raw, dk_raw_sec, fd_raw_sec, roo_raw, sd_raw, dk_sd_raw, fd_sd_raw, timestamp = load_overall_stats('NBA') | |
| salary_dict = dict(zip(roo_raw.Player, roo_raw.Salary)) | |
| id_dict = dict(zip(roo_raw.Player, roo_raw.player_ID)) | |
| salary_dict_sd = dict(zip(sd_raw.Player, sd_raw.Salary)) | |
| dk_id_dict_sd = dict(zip(dk_sd_raw.Player, dk_sd_raw.player_ID)) | |
| fd_id_dict_sd = dict(zip(fd_sd_raw.Player, fd_sd_raw.player_ID)) | |
| dk_nba_lineups = pd.DataFrame(columns=dk_nba_columns) | |
| dk_nba_sd_lineups = pd.DataFrame(columns=dk_nba_sd_columns) | |
| fd_nba_lineups = pd.DataFrame(columns=fd_nba_columns) | |
| fd_nba_sd_lineups = pd.DataFrame(columns=fd_nba_sd_columns) | |
| dk_wnba_lineups = pd.DataFrame(columns=dk_wnba_columns) | |
| dk_wnba_sd_lineups = pd.DataFrame(columns=dk_wnba_sd_columns) | |
| fd_wnba_lineups = pd.DataFrame(columns=fd_wnba_columns) | |
| fd_wnba_sd_lineups = pd.DataFrame(columns=fd_wnba_sd_columns) | |
| t_stamp = f"Last Update: " + str(timestamp) + f" CST" | |
| for key in st.session_state.keys(): | |
| del st.session_state[key] | |
| col1, col2, col3, col4, col5 = st.columns(5) | |
| with col1: | |
| slate_var1 = st.radio("Which data are you loading?", ('Main Slate', 'Secondary')) | |
| with col2: | |
| slate_type_var1 = st.radio("What slate type are you working with?", ('Regular', 'Showdown')) | |
| with col3: | |
| lineup_num_var = st.number_input("How many lineups do you want to display?", min_value=1, max_value=1000, value=150, step=1) | |
| with col4: | |
| if site_var2 == 'Draftkings': | |
| if league_var == 'NBA': | |
| if slate_type_var1 == 'Regular': | |
| column_names = dk_nba_columns | |
| elif slate_type_var1 == 'Showdown': | |
| column_names = dk_nba_sd_columns | |
| elif league_var == 'WNBA': | |
| if slate_type_var1 == 'Regular': | |
| column_names = dk_wnba_columns | |
| elif slate_type_var1 == 'Showdown': | |
| column_names = dk_wnba_sd_columns | |
| player_var1 = st.radio("Do you want a frame with specific Players?", ('Full Slate', 'Specific Players'), key='player_var1') | |
| if player_var1 == 'Specific Players': | |
| player_var2 = st.multiselect('Which players do you want?', options = dk_raw['Player'].unique()) | |
| elif player_var1 == 'Full Slate': | |
| player_var2 = dk_raw.Player.values.tolist() | |
| elif site_var2 == 'Fanduel': | |
| if league_var == 'NBA': | |
| if slate_type_var1 == 'Regular': | |
| column_names = fd_nba_columns | |
| elif slate_type_var1 == 'Showdown': | |
| column_names = fd_nba_sd_columns | |
| elif league_var == 'WNBA': | |
| if slate_type_var1 == 'Regular': | |
| column_names = fd_wnba_columns | |
| elif slate_type_var1 == 'Showdown': | |
| column_names = fd_wnba_sd_columns | |
| player_var1 = st.radio("Do you want a frame with specific Players?", ('Full Slate', 'Specific Players'), key='player_var1') | |
| if player_var1 == 'Specific Players': | |
| player_var2 = st.multiselect('Which players do you want?', options = fd_raw['Player'].unique()) | |
| elif player_var1 == 'Full Slate': | |
| player_var2 = fd_raw.Player.values.tolist() | |
| with col5: | |
| if site_var2 == 'Draftkings': | |
| salary_min_var = st.number_input("Minimum salary used", min_value = 0, max_value = 50000, value = 49000, step = 100, key = 'salary_min_var') | |
| salary_max_var = st.number_input("Maximum salary used", min_value = 0, max_value = 50000, value = 50000, step = 100, key = 'salary_max_var') | |
| elif site_var2 == 'Fanduel': | |
| salary_min_var = st.number_input("Minimum salary used", min_value = 0, max_value = 40000, value = 39000, step = 100, key = 'salary_min_var') | |
| salary_max_var = st.number_input("Maximum salary used", min_value = 0, max_value = 40000, value = 40000, step = 100, key = 'salary_max_var') | |
| reg_dl_col, filtered_dl_col, blank_dl_col = st.columns([2, 2, 6]) | |
| with reg_dl_col: | |
| if st.button("Prepare full data export", key='data_export'): | |
| name_export = pd.DataFrame(st.session_state.working_seed.copy(), columns=column_names) | |
| data_export = pd.DataFrame(st.session_state.working_seed.copy(), columns=column_names) | |
| if site_var2 == 'Draftkings': | |
| if slate_type_var1 == 'Regular': | |
| if league_var == 'NBA': | |
| map_columns = ['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX'] | |
| elif league_var == 'WNBA': | |
| map_columns = ['G1', 'G2', 'F1', 'F2', 'F3', 'UTIL'] | |
| elif slate_type_var1 == 'Showdown': | |
| map_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'] | |
| for col_idx in map_columns: | |
| if slate_type_var1 == 'Regular': | |
| data_export[col_idx] = data_export[col_idx].map(id_dict) | |
| elif slate_type_var1 == 'Showdown': | |
| data_export[col_idx] = data_export[col_idx].map(dk_id_dict_sd) | |
| elif site_var2 == 'Fanduel': | |
| if slate_type_var1 == 'Regular': | |
| if league_var == 'NBA': | |
| map_columns = ['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C1', 'C2', 'UTIL'] | |
| elif league_var == 'WNBA': | |
| map_columns = ['G1', 'G2', 'G3', 'F1', 'F2', 'F3', 'F4'] | |
| elif slate_type_var1 == 'Showdown': | |
| map_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4'] | |
| for col_idx in map_columns: | |
| if slate_type_var1 == 'Regular': | |
| data_export[col_idx] = data_export[col_idx].map(id_dict) | |
| elif slate_type_var1 == 'Showdown': | |
| data_export[col_idx] = data_export[col_idx].map(fd_id_dict_sd) | |
| pm_name_export = name_export.drop(columns=['salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'], axis=1) | |
| pm_data_export = data_export.drop(columns=['salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'], axis=1) | |
| reg_opt_col, pm_opt_col = st.columns(2) | |
| with reg_opt_col: | |
| st.download_button( | |
| label="Export optimals set (IDs)", | |
| data=convert_df(data_export), | |
| file_name='NBA_optimals_export.csv', | |
| mime='text/csv', | |
| ) | |
| st.download_button( | |
| label="Export optimals set (Names)", | |
| data=convert_df(name_export), | |
| file_name='NBA_optimals_export.csv', | |
| mime='text/csv', | |
| ) | |
| with pm_opt_col: | |
| st.download_button( | |
| label="Portfolio Manager Export (IDs)", | |
| data=convert_pm_df(pm_data_export), | |
| file_name='NBA_optimals_export.csv', | |
| mime='text/csv', | |
| ) | |
| st.download_button( | |
| label="Portfolio Manager Export (Names)", | |
| data=convert_pm_df(pm_name_export), | |
| file_name='NBA_optimals_export.csv', | |
| mime='text/csv', | |
| ) | |
| with filtered_dl_col: | |
| if st.button("Prepare full data export (Filtered)", key='data_export_filtered'): | |
| name_export = pd.DataFrame(st.session_state.working_seed.copy(), columns=column_names) | |
| data_export = pd.DataFrame(st.session_state.working_seed.copy(), columns=column_names) | |
| if site_var2 == 'Draftkings': | |
| if slate_type_var1 == 'Regular': | |
| if league_var == 'NBA': | |
| map_columns = ['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX'] | |
| elif league_var == 'WNBA': | |
| map_columns = ['G1', 'G2', 'F1', 'F2', 'F3', 'UTIL'] | |
| elif slate_type_var1 == 'Showdown': | |
| map_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'] | |
| elif site_var2 == 'Fanduel': | |
| if slate_type_var1 == 'Regular': | |
| if league_var == 'NBA': | |
| map_columns = ['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C1', 'C2', 'UTIL'] | |
| elif league_var == 'WNBA': | |
| map_columns = ['G1', 'G2', 'G3', 'F1', 'F2', 'F3', 'F4'] | |
| elif slate_type_var1 == 'Showdown': | |
| map_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4'] | |
| for col_idx in map_columns: | |
| if slate_type_var1 == 'Regular': | |
| data_export[col_idx] = data_export[col_idx].map(id_dict) | |
| elif slate_type_var1 == 'Showdown': | |
| data_export[col_idx] = data_export[col_idx].map(fd_id_dict_sd) | |
| data_export = data_export[data_export['salary'] >= salary_min_var] | |
| data_export = data_export[data_export['salary'] <= salary_max_var] | |
| name_export = name_export[name_export['salary'] >= salary_min_var] | |
| name_export = name_export[name_export['salary'] <= salary_max_var] | |
| pm_name_export = name_export.drop(columns=['salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'], axis=1) | |
| pm_data_export = data_export.drop(columns=['salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'], axis=1) | |
| reg_opt_col, pm_opt_col = st.columns(2) | |
| with reg_opt_col: | |
| st.download_button( | |
| label="Export optimals set (IDs)", | |
| data=convert_df(data_export), | |
| file_name='NBA_optimals_export.csv', | |
| mime='text/csv', | |
| ) | |
| st.download_button( | |
| label="Export optimals set (Names)", | |
| data=convert_df(name_export), | |
| file_name='NBA_optimals_export.csv', | |
| mime='text/csv', | |
| ) | |
| with pm_opt_col: | |
| st.download_button( | |
| label="Portfolio Manager Export (IDs)", | |
| data=convert_pm_df(pm_data_export), | |
| file_name='NBA_optimals_export.csv', | |
| mime='text/csv', | |
| ) | |
| st.download_button( | |
| label="Portfolio Manager Export (Names)", | |
| data=convert_pm_df(pm_name_export), | |
| file_name='NBA_optimals_export.csv', | |
| mime='text/csv', | |
| ) | |
| if site_var2 == 'Draftkings': | |
| if 'working_seed' in st.session_state: | |
| st.session_state.working_seed = st.session_state.working_seed | |
| if player_var1 == 'Specific Players': | |
| st.session_state.working_seed = st.session_state.working_seed[np.equal.outer(st.session_state.working_seed, player_var2).any(axis=1).all(axis=1)] | |
| elif player_var1 == 'Full Slate': | |
| st.session_state.working_seed = st.session_state.working_seed | |
| st.session_state.data_export_display = pd.DataFrame(st.session_state.working_seed[0:lineup_num_var], columns=column_names) | |
| elif 'working_seed' not in st.session_state: | |
| if slate_type_var1 == 'Regular': | |
| st.session_state.working_seed = init_DK_lineups(slate_var1, league_var) | |
| elif slate_type_var1 == 'Showdown': | |
| st.session_state.working_seed = init_DK_SD_lineups(slate_var1, league_var) | |
| st.session_state.working_seed = st.session_state.working_seed | |
| if player_var1 == 'Specific Players': | |
| st.session_state.working_seed = st.session_state.working_seed[np.equal.outer(st.session_state.working_seed, player_var2).any(axis=1).all(axis=1)] | |
| elif player_var1 == 'Full Slate': | |
| if slate_type_var1 == 'Regular': | |
| st.session_state.working_seed = init_DK_lineups(slate_var1, league_var) | |
| elif slate_type_var1 == 'Showdown': | |
| st.session_state.working_seed = init_DK_SD_lineups(slate_var1, league_var) | |
| st.session_state.data_export_display = pd.DataFrame(st.session_state.working_seed[0:lineup_num_var], columns=column_names) | |
| elif site_var2 == 'Fanduel': | |
| if 'working_seed' in st.session_state: | |
| st.session_state.working_seed = st.session_state.working_seed | |
| if player_var1 == 'Specific Players': | |
| st.session_state.working_seed = st.session_state.working_seed[np.equal.outer(st.session_state.working_seed, player_var2).any(axis=1).all(axis=1)] | |
| elif player_var1 == 'Full Slate': | |
| st.session_state.working_seed = st.session_state.working_seed | |
| st.session_state.data_export_display = pd.DataFrame(st.session_state.working_seed[0:lineup_num_var], columns=column_names) | |
| elif 'working_seed' not in st.session_state: | |
| if slate_type_var1 == 'Regular': | |
| st.session_state.working_seed = init_FD_lineups(slate_var1, league_var) | |
| elif slate_type_var1 == 'Showdown': | |
| st.session_state.working_seed = init_FD_SD_lineups(slate_var1, league_var) | |
| st.session_state.working_seed = st.session_state.working_seed | |
| if player_var1 == 'Specific Players': | |
| st.session_state.working_seed = st.session_state.working_seed[np.equal.outer(st.session_state.working_seed, player_var2).any(axis=1).all(axis=1)] | |
| elif player_var1 == 'Full Slate': | |
| if slate_type_var1 == 'Regular': | |
| st.session_state.working_seed = init_FD_lineups(slate_var1, league_var) | |
| elif slate_type_var1 == 'Showdown': | |
| st.session_state.working_seed = init_FD_SD_lineups(slate_var1, league_var) | |
| st.session_state.data_export_display = pd.DataFrame(st.session_state.working_seed[0:lineup_num_var], columns=column_names) | |
| st.session_state.data_export_display = st.session_state.data_export_display[st.session_state.data_export_display['salary'].between(salary_min_var, salary_max_var)] | |
| export_file = st.session_state.data_export_display.copy() | |
| if site_var2 == 'Draftkings': | |
| if slate_type_var1 == 'Regular': | |
| for col_idx in range(8): | |
| export_file.iloc[:, col_idx] = export_file.iloc[:, col_idx].map(id_dict) | |
| elif slate_type_var1 == 'Showdown': | |
| for col_idx in range(6): | |
| export_file.iloc[:, col_idx] = export_file.iloc[:, col_idx].map(dk_id_dict_sd) | |
| elif site_var2 == 'Fanduel': | |
| if slate_type_var1 == 'Regular': | |
| for col_idx in range(9): | |
| export_file.iloc[:, col_idx] = export_file.iloc[:, col_idx].map(id_dict) | |
| elif slate_type_var1 == 'Showdown': | |
| for col_idx in range(6): | |
| export_file.iloc[:, col_idx] = export_file.iloc[:, col_idx].map(fd_id_dict_sd) | |
| with st.container(): | |
| if st.button("Reset Optimals", key='reset3'): | |
| for key in st.session_state.keys(): | |
| del st.session_state[key] | |
| if site_var2 == 'Draftkings': | |
| if league_var == 'NBA': | |
| if slate_type_var1 == 'Regular': | |
| st.session_state.working_seed = dk_nba_lineups.copy() | |
| elif slate_type_var1 == 'Showdown': | |
| st.session_state.working_seed = dk_nba_sd_lineups.copy() | |
| elif league_var == 'WNBA': | |
| if slate_type_var1 == 'Regular': | |
| st.session_state.working_seed = dk_wnba_lineups.copy() | |
| elif slate_type_var1 == 'Showdown': | |
| st.session_state.working_seed = dk_wnba_sd_lineups.copy() | |
| elif site_var2 == 'Fanduel': | |
| if league_var == 'NBA': | |
| if slate_type_var1 == 'Regular': | |
| st.session_state.working_seed = fd_nba_lineups.copy() | |
| elif slate_type_var1 == 'Showdown': | |
| st.session_state.working_seed = fd_nba_sd_lineups.copy() | |
| elif league_var == 'WNBA': | |
| if slate_type_var1 == 'Regular': | |
| st.session_state.working_seed = fd_wnba_lineups.copy() | |
| elif slate_type_var1 == 'Showdown': | |
| st.session_state.working_seed = fd_wnba_sd_lineups.copy() | |
| if 'data_export_display' in st.session_state: | |
| st.dataframe(st.session_state.data_export_display.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(precision=2), height=500, use_container_width = True) | |
| st.download_button( | |
| label="Export display optimals", | |
| data=convert_df(export_file), | |
| file_name='NBA_display_optimals.csv', | |
| mime='text/csv', | |
| ) | |
| with st.container(): | |
| if 'working_seed' in st.session_state: | |
| # Create a new dataframe with summary statistics | |
| if site_var2 == 'Draftkings': | |
| if league_var == 'NBA': | |
| if slate_type_var1 == 'Regular': | |
| summary_df = pd.DataFrame({ | |
| 'Metric': ['Min', 'Average', 'Max', 'STDdev'], | |
| 'Salary': [ | |
| np.min(st.session_state.working_seed[:,8]), | |
| np.mean(st.session_state.working_seed[:,8]), | |
| np.max(st.session_state.working_seed[:,8]), | |
| np.std(st.session_state.working_seed[:,8]) | |
| ], | |
| 'Proj': [ | |
| np.min(st.session_state.working_seed[:,9]), | |
| np.mean(st.session_state.working_seed[:,9]), | |
| np.max(st.session_state.working_seed[:,9]), | |
| np.std(st.session_state.working_seed[:,9]) | |
| ], | |
| 'Own': [ | |
| np.min(st.session_state.working_seed[:,14]), | |
| np.mean(st.session_state.working_seed[:,14]), | |
| np.max(st.session_state.working_seed[:,14]), | |
| np.std(st.session_state.working_seed[:,14]) | |
| ] | |
| }) | |
| elif slate_type_var1 == 'Showdown': | |
| summary_df = pd.DataFrame({ | |
| 'Metric': ['Min', 'Average', 'Max', 'STDdev'], | |
| 'Salary': [ | |
| np.min(st.session_state.working_seed[:,6]), | |
| np.mean(st.session_state.working_seed[:,6]), | |
| np.max(st.session_state.working_seed[:,6]), | |
| np.std(st.session_state.working_seed[:,6]) | |
| ], | |
| 'Proj': [ | |
| np.min(st.session_state.working_seed[:,7]), | |
| np.mean(st.session_state.working_seed[:,7]), | |
| np.max(st.session_state.working_seed[:,7]), | |
| np.std(st.session_state.working_seed[:,7]) | |
| ], | |
| 'Own': [ | |
| np.min(st.session_state.working_seed[:,12]), | |
| np.mean(st.session_state.working_seed[:,12]), | |
| np.max(st.session_state.working_seed[:,12]), | |
| np.std(st.session_state.working_seed[:,12]) | |
| ] | |
| }) | |
| elif league_var == 'WNBA': | |
| if slate_type_var1 == 'Regular': | |
| summary_df = pd.DataFrame({ | |
| 'Metric': ['Min', 'Average', 'Max', 'STDdev'], | |
| 'Salary': [ | |
| np.min(st.session_state.working_seed[:,6]), | |
| np.mean(st.session_state.working_seed[:,6]), | |
| np.max(st.session_state.working_seed[:,6]), | |
| np.std(st.session_state.working_seed[:,6]) | |
| ], | |
| 'Proj': [ | |
| np.min(st.session_state.working_seed[:,7]), | |
| np.mean(st.session_state.working_seed[:,7]), | |
| np.max(st.session_state.working_seed[:,7]), | |
| np.std(st.session_state.working_seed[:,7]) | |
| ], | |
| 'Own': [ | |
| np.min(st.session_state.working_seed[:,12]), | |
| np.mean(st.session_state.working_seed[:,12]), | |
| np.max(st.session_state.working_seed[:,12]), | |
| np.std(st.session_state.working_seed[:,12]) | |
| ] | |
| }) | |
| elif slate_type_var1 == 'Showdown': | |
| summary_df = pd.DataFrame({ | |
| 'Metric': ['Min', 'Average', 'Max', 'STDdev'], | |
| 'Salary': [ | |
| np.min(st.session_state.working_seed[:,6]), | |
| np.mean(st.session_state.working_seed[:,6]), | |
| np.max(st.session_state.working_seed[:,6]), | |
| np.std(st.session_state.working_seed[:,6]) | |
| ], | |
| 'Proj': [ | |
| np.min(st.session_state.working_seed[:,7]), | |
| np.mean(st.session_state.working_seed[:,7]), | |
| np.max(st.session_state.working_seed[:,7]), | |
| np.std(st.session_state.working_seed[:,7]) | |
| ], | |
| 'Own': [ | |
| np.min(st.session_state.working_seed[:,12]), | |
| np.mean(st.session_state.working_seed[:,12]), | |
| np.max(st.session_state.working_seed[:,12]), | |
| np.std(st.session_state.working_seed[:,12]) | |
| ] | |
| }) | |
| elif site_var2 == 'Fanduel': | |
| if league_var == 'NBA': | |
| if slate_type_var1 == 'Regular': | |
| summary_df = pd.DataFrame({ | |
| 'Metric': ['Min', 'Average', 'Max', 'STDdev'], | |
| 'Salary': [ | |
| np.min(st.session_state.working_seed[:,9]), | |
| np.mean(st.session_state.working_seed[:,9]), | |
| np.max(st.session_state.working_seed[:,9]), | |
| np.std(st.session_state.working_seed[:,9]) | |
| ], | |
| 'Proj': [ | |
| np.min(st.session_state.working_seed[:,10]), | |
| np.mean(st.session_state.working_seed[:,10]), | |
| np.max(st.session_state.working_seed[:,10]), | |
| np.std(st.session_state.working_seed[:,10]) | |
| ], | |
| 'Own': [ | |
| np.min(st.session_state.working_seed[:,15]), | |
| np.mean(st.session_state.working_seed[:,15]), | |
| np.max(st.session_state.working_seed[:,15]), | |
| np.std(st.session_state.working_seed[:,15]) | |
| ] | |
| }) | |
| elif slate_type_var1 == 'Showdown': | |
| summary_df = pd.DataFrame({ | |
| 'Metric': ['Min', 'Average', 'Max', 'STDdev'], | |
| 'Salary': [ | |
| np.min(st.session_state.working_seed[:,6]), | |
| np.mean(st.session_state.working_seed[:,6]), | |
| np.max(st.session_state.working_seed[:,6]), | |
| np.std(st.session_state.working_seed[:,6]) | |
| ], | |
| 'Proj': [ | |
| np.min(st.session_state.working_seed[:,7]), | |
| np.mean(st.session_state.working_seed[:,7]), | |
| np.max(st.session_state.working_seed[:,7]), | |
| np.std(st.session_state.working_seed[:,7]) | |
| ], | |
| 'Own': [ | |
| np.min(st.session_state.working_seed[:,12]), | |
| np.mean(st.session_state.working_seed[:,12]), | |
| np.max(st.session_state.working_seed[:,12]), | |
| np.std(st.session_state.working_seed[:,12]) | |
| ] | |
| }) | |
| elif league_var == 'WNBA': | |
| if slate_type_var1 == 'Regular': | |
| summary_df = pd.DataFrame({ | |
| 'Metric': ['Min', 'Average', 'Max', 'STDdev'], | |
| 'Salary': [ | |
| np.min(st.session_state.working_seed[:,7]), | |
| np.mean(st.session_state.working_seed[:,7]), | |
| np.max(st.session_state.working_seed[:,7]), | |
| np.std(st.session_state.working_seed[:,7]) | |
| ], | |
| 'Proj': [ | |
| np.min(st.session_state.working_seed[:,8]), | |
| np.mean(st.session_state.working_seed[:,8]), | |
| np.max(st.session_state.working_seed[:,8]), | |
| np.std(st.session_state.working_seed[:,8]) | |
| ], | |
| 'Own': [ | |
| np.min(st.session_state.working_seed[:,13]), | |
| np.mean(st.session_state.working_seed[:,13]), | |
| np.max(st.session_state.working_seed[:,13]), | |
| np.std(st.session_state.working_seed[:,13]) | |
| ] | |
| }) | |
| elif slate_type_var1 == 'Showdown': | |
| summary_df = pd.DataFrame({ | |
| 'Metric': ['Min', 'Average', 'Max', 'STDdev'], | |
| 'Salary': [ | |
| np.min(st.session_state.working_seed[:,6]), | |
| np.mean(st.session_state.working_seed[:,6]), | |
| np.max(st.session_state.working_seed[:,6]), | |
| np.std(st.session_state.working_seed[:,6]) | |
| ], | |
| 'Proj': [ | |
| np.min(st.session_state.working_seed[:,7]), | |
| np.mean(st.session_state.working_seed[:,7]), | |
| np.max(st.session_state.working_seed[:,7]), | |
| np.std(st.session_state.working_seed[:,7]) | |
| ], | |
| 'Own': [ | |
| np.min(st.session_state.working_seed[:,12]), | |
| np.mean(st.session_state.working_seed[:,12]), | |
| np.max(st.session_state.working_seed[:,12]), | |
| np.std(st.session_state.working_seed[:,12]) | |
| ] | |
| }) | |
| # Set the index of the summary dataframe as the "Metric" column | |
| summary_df = summary_df.set_index('Metric') | |
| # Display the summary dataframe | |
| st.subheader("Optimal Statistics") | |
| st.dataframe(summary_df.style.format({ | |
| 'Salary': '{:.2f}', | |
| 'Proj': '{:.2f}', | |
| 'Own': '{:.2f}' | |
| }).background_gradient(cmap='RdYlGn', axis=0, subset=['Salary', 'Proj', 'Own']), use_container_width=True) | |
| with st.container(): | |
| tab1, tab2 = st.tabs(["Display Frequency", "Seed Frame Frequency"]) | |
| with tab1: | |
| if 'data_export_display' in st.session_state: | |
| if league_var == 'NBA': | |
| if slate_type_var1 == 'Regular': | |
| if site_var2 == 'Draftkings': | |
| player_columns = st.session_state.data_export_display.iloc[:, :8] | |
| elif site_var2 == 'Fanduel': | |
| player_columns = st.session_state.data_export_display.iloc[:, :9] | |
| elif slate_type_var1 == 'Showdown': | |
| if site_var2 == 'Draftkings': | |
| player_columns = st.session_state.data_export_display.iloc[:, :5] | |
| elif site_var2 == 'Fanduel': | |
| player_columns = st.session_state.data_export_display.iloc[:, :5] | |
| elif league_var == 'WNBA': | |
| if slate_type_var1 == 'Regular': | |
| if site_var2 == 'Draftkings': | |
| player_columns = st.session_state.data_export_display.iloc[:, :7] | |
| elif site_var2 == 'Fanduel': | |
| player_columns = st.session_state.data_export_display.iloc[:, :8] | |
| elif slate_type_var1 == 'Showdown': | |
| if site_var2 == 'Draftkings': | |
| player_columns = st.session_state.data_export_display.iloc[:, :5] | |
| elif site_var2 == 'Fanduel': | |
| player_columns = st.session_state.data_export_display.iloc[:, :5] | |
| # Flatten the DataFrame and count unique values | |
| value_counts = player_columns.values.flatten().tolist() | |
| value_counts = pd.Series(value_counts).value_counts() | |
| percentages = (value_counts / lineup_num_var * 100).round(2) | |
| # Create a DataFrame with the results | |
| summary_df = pd.DataFrame({ | |
| 'Player': value_counts.index, | |
| 'Salary': [salary_dict.get(player, player) for player in value_counts.index], | |
| 'Frequency': value_counts.values, | |
| 'Percentage': percentages.values | |
| }) | |
| # Sort by frequency in descending order | |
| summary_df = summary_df.sort_values('Frequency', ascending=False) | |
| # Display the table | |
| st.write("Player Frequency Table:") | |
| st.dataframe(summary_df.style.format({'Percentage': '{:.2f}%'}, precision=2), height=500, use_container_width=True) | |
| st.download_button( | |
| label="Export player frequency", | |
| data=convert_df_to_csv(summary_df), | |
| file_name='NBA_player_frequency.csv', | |
| mime='text/csv', | |
| ) | |
| with tab2: | |
| if 'working_seed' in st.session_state: | |
| if league_var == 'NBA': | |
| if slate_type_var1 == 'Regular': | |
| if site_var2 == 'Draftkings': | |
| player_columns = st.session_state.working_seed[:, :8] | |
| elif site_var2 == 'Fanduel': | |
| player_columns = st.session_state.working_seed[:, :9] | |
| elif slate_type_var1 == 'Showdown': | |
| if site_var2 == 'Draftkings': | |
| player_columns = st.session_state.working_seed[:, :5] | |
| elif site_var2 == 'Fanduel': | |
| player_columns = st.session_state.working_seed[:, :5] | |
| elif league_var == 'WNBA': | |
| if slate_type_var1 == 'Regular': | |
| if site_var2 == 'Draftkings': | |
| player_columns = st.session_state.working_seed[:, :7] | |
| elif site_var2 == 'Fanduel': | |
| player_columns = st.session_state.working_seed[:, :8] | |
| elif slate_type_var1 == 'Showdown': | |
| if site_var2 == 'Draftkings': | |
| player_columns = st.session_state.working_seed[:, :5] | |
| elif site_var2 == 'Fanduel': | |
| player_columns = st.session_state.working_seed[:, :5] | |
| # Flatten the DataFrame and count unique values | |
| value_counts = player_columns.flatten().tolist() | |
| value_counts = pd.Series(value_counts).value_counts() | |
| percentages = (value_counts / len(st.session_state.working_seed) * 100).round(2) | |
| # Create a DataFrame with the results | |
| summary_df = pd.DataFrame({ | |
| 'Player': value_counts.index, | |
| 'Salary': [salary_dict.get(player, player) for player in value_counts.index], | |
| 'Frequency': value_counts.values, | |
| 'Percentage': percentages.values | |
| }) | |
| # Sort by frequency in descending order | |
| summary_df = summary_df.sort_values('Frequency', ascending=False) | |
| # Display the table | |
| st.write("Seed Frame Frequency Table:") | |
| st.dataframe(summary_df.style.format({'Percentage': '{:.2f}%'}, precision=2), height=500, use_container_width=True) | |
| st.download_button( | |
| label="Export seed frame frequency", | |
| data=convert_df_to_csv(summary_df), | |
| file_name='NBA_seed_frame_frequency.csv', | |
| mime='text/csv', | |
| ) | |