Spaces:
Running
Running
James McCool
Update player statistics display to include 'Line' and 'PP Unit' fields in app.py
3b45c90
| import streamlit as st | |
| st.set_page_config(layout="wide") | |
| for name in dir(): | |
| if not name.startswith('_'): | |
| del globals()[name] | |
| import pulp | |
| import numpy as np | |
| import pandas as pd | |
| import streamlit as st | |
| import gspread | |
| import pymongo | |
| from itertools import combinations | |
| import math | |
| def init_conn(): | |
| uri = st.secrets['mongo_uri'] | |
| client = pymongo.MongoClient(uri, retryWrites=True, serverSelectionTimeoutMS=500000) | |
| db = client["NHL_Database"] | |
| return db | |
| db = init_conn() | |
| player_roo_format = {'Top_finish': '{:.2%}','Top_5_finish': '{:.2%}', 'Top_10_finish': '{:.2%}', '20+%': '{:.2%}', '2x%': '{:.2%}', '3x%': '{:.2%}', | |
| '4x%': '{:.2%}'} | |
| dk_columns = ['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', 'FLEX', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'] | |
| fd_columns = ['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'] | |
| dk_hb_columns = ['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', 'FLEX'] | |
| fd_hb_columns = ['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G'] | |
| dk_sd_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'] | |
| fd_sd_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'] | |
| showdown_selections = ['Showdown #1', 'Showdown #2', 'Showdown #3', 'Showdown #4', 'Showdown #5', 'Showdown #6', 'Showdown #7', 'Showdown #8', 'Showdown #9', 'Showdown #10', 'Showdown #11', 'Showdown #12', 'Showdown #13', 'Showdown #14', 'Showdown #15'] | |
| dk_db_showdown_selections = ['DK_NFL_SD_seed_frame_Showdown #1', 'DK_NFL_SD_seed_frame_Showdown #2', 'DK_NFL_SD_seed_frame_Showdown #3', 'DK_NFL_SD_seed_frame_Showdown #4', 'DK_NFL_SD_seed_frame_Showdown #5', 'DK_NFL_SD_seed_frame_Showdown #6', | |
| 'DK_NFL_SD_seed_frame_Showdown #7', 'DK_NFL_SD_seed_frame_Showdown #8', 'DK_NFL_SD_seed_frame_Showdown #9', 'DK_NFL_SD_seed_frame_Showdown #10', 'DK_NFL_SD_seed_frame_Showdown #11', 'DK_NFL_SD_seed_frame_Showdown #12', 'DK_NFL_SD_seed_frame_Showdown #13', | |
| 'DK_NFL_SD_seed_frame_Showdown #14', 'DK_NFL_SD_seed_frame_Showdown #15'] | |
| fd_db_showdown_selections = ['FD_NFL_SD_seed_frame_Showdown #1', 'FD_NFL_SD_seed_frame_Showdown #2', 'FD_NFL_SD_seed_frame_Showdown #3', 'FD_NFL_SD_seed_frame_Showdown #4', 'FD_NFL_SD_seed_frame_Showdown #5', 'FD_NFL_SD_seed_frame_Showdown #6', | |
| 'FD_NFL_SD_seed_frame_Showdown #7', 'FD_NFL_SD_seed_frame_Showdown #8', 'FD_NFL_SD_seed_frame_Showdown #9', 'FD_NFL_SD_seed_frame_Showdown #10', 'FD_NFL_SD_seed_frame_Showdown #11', 'FD_NFL_SD_seed_frame_Showdown #12', 'FD_NFL_SD_seed_frame_Showdown #13', | |
| 'FD_NFL_SD_seed_frame_Showdown #14', 'FD_NFL_SD_seed_frame_Showdown #15'] | |
| dk_showdown_db_translation = dict(zip(showdown_selections, dk_db_showdown_selections)) | |
| fd_showdown_db_translation = dict(zip(showdown_selections, fd_db_showdown_selections)) | |
| 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 player_stat_table(): | |
| collection = db["Player_Level_ROO"] | |
| cursor = collection.find() | |
| player_frame = pd.DataFrame(cursor) | |
| player_frame = player_frame[['Player', 'Position', 'Line', 'PP Unit', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '2x%', '3x%', '4x%', 'Own', | |
| 'Small Field Own%', 'Large Field Own%', 'Cash Own%', 'CPT_Own', 'Site', 'Type', 'Slate', 'player_id', 'timestamp']] | |
| collection = db["Player_Lines_ROO"] | |
| cursor = collection.find() | |
| line_frame = pd.DataFrame(cursor) | |
| line_frame = line_frame[['Player', 'SK1', 'SK2', 'SK3', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '50+%', '2x%', '3x%', '4x%', 'Own', 'Site', 'Type', 'Slate']] | |
| collection = db["Player_Powerplay_ROO"] | |
| cursor = collection.find() | |
| pp_frame = pd.DataFrame(cursor) | |
| pp_frame = pp_frame[['Player', 'SK1', 'SK2', 'SK3', 'SK4', 'SK5', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '75+%', '2x%', '3x%', '4x%', 'Own', 'Site', 'Type', 'Slate']] | |
| timestamp = player_frame['timestamp'].values[0] | |
| return player_frame, line_frame, pp_frame, timestamp | |
| def init_DK_lineups(type_var, slate_var, prio_var, prio_mix, db_translation, lineup_num, player_var2): | |
| if prio_var == 'Mix': | |
| prio_var = None | |
| if type_var == 'Regular': | |
| if slate_var == 'Main Slate': | |
| collection = db['DK_NHL_name_map'] | |
| cursor = collection.find() | |
| raw_data = pd.DataFrame(list(cursor)) | |
| names_dict = dict(zip(raw_data['key'], raw_data['value'])) | |
| collection = db['DK_NHL_seed_frame_Main Slate'] | |
| if prio_var == None: | |
| if player_var2 != []: | |
| player_columns = ['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', 'FLEX'] | |
| query_conditions = [] | |
| for player in player_var2: | |
| # Create a condition for each player to check if they appear in any column | |
| player_condition = {'$or': [{col: player} for col in player_columns]} | |
| query_conditions.append(player_condition) | |
| # Combine all player conditions with $or | |
| if query_conditions: | |
| filter_query = {'$or': query_conditions} | |
| cursor1 = collection.find(filter_query).limit(math.ceil(lineup_num * (prio_mix / 100))) | |
| cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100))) | |
| else: | |
| cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100))) | |
| cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100))) | |
| raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))]) | |
| else: | |
| cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100))) | |
| cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100))) | |
| raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))]) | |
| else: | |
| cursor = collection.find().sort(prio_var, -1).limit(lineup_num) | |
| raw_display = pd.DataFrame(list(cursor)) | |
| raw_display = raw_display.drop_duplicates(subset=['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', 'FLEX']) | |
| raw_display = raw_display[['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', 'FLEX', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']] | |
| dict_columns = ['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', 'FLEX'] | |
| # Map names | |
| raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict)) | |
| elif slate_var == 'Secondary Slate': | |
| collection = db['DK_NHL_Secondary_name_map'] | |
| cursor = collection.find() | |
| raw_data = pd.DataFrame(list(cursor)) | |
| names_dict = dict(zip(raw_data['key'], raw_data['value'])) | |
| collection = db['DK_NHL_seed_frame_Secondary Slate'] | |
| if prio_var == None: | |
| if player_var2 != []: | |
| player_columns = ['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', 'FLEX'] | |
| query_conditions = [] | |
| for player in player_var2: | |
| # Create a condition for each player to check if they appear in any column | |
| player_condition = {'$or': [{col: player} for col in player_columns]} | |
| query_conditions.append(player_condition) | |
| # Combine all player conditions with $or | |
| if query_conditions: | |
| filter_query = {'$or': query_conditions} | |
| cursor1 = collection.find(filter_query).limit(math.ceil(lineup_num * (prio_mix / 100))) | |
| cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100))) | |
| else: | |
| cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100))) | |
| cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100))) | |
| raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))]) | |
| else: | |
| cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100))) | |
| cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100))) | |
| raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))]) | |
| else: | |
| cursor = collection.find().sort(prio_var, -1).limit(lineup_num) | |
| raw_display = pd.DataFrame(list(cursor)) | |
| raw_display = raw_display.drop_duplicates(subset=['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', 'FLEX']) | |
| raw_display = raw_display[['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', 'FLEX', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']] | |
| dict_columns = ['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', 'FLEX'] | |
| # Map names | |
| raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict)) | |
| elif slate_var == 'Auxiliary Slate': | |
| collection = db['DK_NHL_Late_name_map'] | |
| cursor = collection.find() | |
| raw_data = pd.DataFrame(list(cursor)) | |
| names_dict = dict(zip(raw_data['key'], raw_data['value'])) | |
| collection = db['DK_NHL_seed_frame_Late Slate'] | |
| if prio_var == None: | |
| if player_var2 != []: | |
| player_columns = ['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', 'FLEX'] | |
| query_conditions = [] | |
| for player in player_var2: | |
| # Create a condition for each player to check if they appear in any column | |
| player_condition = {'$or': [{col: player} for col in player_columns]} | |
| query_conditions.append(player_condition) | |
| # Combine all player conditions with $or | |
| if query_conditions: | |
| filter_query = {'$or': query_conditions} | |
| cursor1 = collection.find(filter_query).limit(math.ceil(lineup_num * (prio_mix / 100))) | |
| cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100))) | |
| else: | |
| cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100))) | |
| cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100))) | |
| raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))]) | |
| else: | |
| cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100))) | |
| cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100))) | |
| raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))]) | |
| else: | |
| cursor = collection.find().sort(prio_var, -1).limit(lineup_num) | |
| raw_display = pd.DataFrame(list(cursor)) | |
| raw_display = raw_display.drop_duplicates(subset=['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', 'FLEX']) | |
| raw_display = raw_display[['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', 'FLEX', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']] | |
| dict_columns = ['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', 'FLEX'] | |
| # Map names | |
| raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict)) | |
| elif type_var == 'Showdown': | |
| collection = db[db_translation[slate_var]] | |
| if prio_var == None: | |
| if player_var2 != []: | |
| player_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'] | |
| query_conditions = [] | |
| for player in player_var2: | |
| # Create a condition for each player to check if they appear in any column | |
| player_condition = {'$or': [{col: player} for col in player_columns]} | |
| query_conditions.append(player_condition) | |
| # Combine all player conditions with $or | |
| if query_conditions: | |
| filter_query = {'$or': query_conditions} | |
| cursor1 = collection.find(filter_query).limit(math.ceil(lineup_num * (prio_mix / 100))) | |
| cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100))) | |
| else: | |
| cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100))) | |
| cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100))) | |
| raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))]) | |
| else: | |
| cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100))) | |
| cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100))) | |
| raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))]) | |
| else: | |
| cursor = collection.find().sort(prio_var, -1).limit(lineup_num) | |
| raw_display = pd.DataFrame(list(cursor)) | |
| raw_display = raw_display.drop_duplicates(subset=['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5']) | |
| 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(prio_var, prio_mix, lineup_num, player_var2, slate_var): | |
| if prio_var == 'Mix': | |
| prio_var = None | |
| if type_var == 'Regular': | |
| if slate_var == 'Main Slate': | |
| collection = db['FD_NHL_name_map'] | |
| cursor = collection.find() | |
| raw_data = pd.DataFrame(list(cursor)) | |
| names_dict = dict(zip(raw_data['key'], raw_data['value'])) | |
| collection = db['FD_NHL_seed_frame_Main Slate'] | |
| if prio_var == None: | |
| if player_var2 != []: | |
| player_columns = ['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G'] | |
| query_conditions = [] | |
| for player in player_var2: | |
| # Create a condition for each player to check if they appear in any column | |
| player_condition = {'$or': [{col: player} for col in player_columns]} | |
| query_conditions.append(player_condition) | |
| # Combine all player conditions with $or | |
| if query_conditions: | |
| filter_query = {'$or': query_conditions} | |
| cursor1 = collection.find(filter_query).limit(math.ceil(lineup_num * (prio_mix / 100))) | |
| cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100))) | |
| else: | |
| cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100))) | |
| cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100))) | |
| raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))]) | |
| else: | |
| cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100))) | |
| cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100))) | |
| raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))]) | |
| else: | |
| cursor = collection.find().sort(prio_var, -1).limit(lineup_num) | |
| raw_display = pd.DataFrame(list(cursor)) | |
| raw_display = raw_display.drop_duplicates(subset=['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G']) | |
| raw_display = raw_display[['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']] | |
| dict_columns = ['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G'] | |
| # Map names | |
| raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict)) | |
| elif slate_var == 'Secondary Slate': | |
| collection = db['FD_NHL_Secondary_name_map'] | |
| cursor = collection.find() | |
| raw_data = pd.DataFrame(list(cursor)) | |
| names_dict = dict(zip(raw_data['key'], raw_data['value'])) | |
| collection = db['FD_NHL_seed_frame_Secondary Slate'] | |
| if prio_var == None: | |
| if player_var2 != []: | |
| player_columns = ['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G'] | |
| query_conditions = [] | |
| for player in player_var2: | |
| # Create a condition for each player to check if they appear in any column | |
| player_condition = {'$or': [{col: player} for col in player_columns]} | |
| query_conditions.append(player_condition) | |
| # Combine all player conditions with $or | |
| if query_conditions: | |
| filter_query = {'$or': query_conditions} | |
| cursor1 = collection.find(filter_query).limit(math.ceil(lineup_num * (prio_mix / 100))) | |
| cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100))) | |
| else: | |
| cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100))) | |
| cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100))) | |
| raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))]) | |
| else: | |
| cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100))) | |
| cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100))) | |
| raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))]) | |
| else: | |
| cursor = collection.find().sort(prio_var, -1).limit(lineup_num) | |
| raw_display = pd.DataFrame(list(cursor)) | |
| raw_display = raw_display.drop_duplicates(subset=['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G']) | |
| raw_display = raw_display[['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']] | |
| dict_columns = ['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G'] | |
| # Map names | |
| raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict)) | |
| elif slate_var == 'Auxiliary Slate': | |
| collection = db['FD_NHL_Late_name_map'] | |
| cursor = collection.find() | |
| raw_data = pd.DataFrame(list(cursor)) | |
| names_dict = dict(zip(raw_data['key'], raw_data['value'])) | |
| collection = db['FD_NHL_seed_frame_Late Slate'] | |
| if prio_var == None: | |
| if player_var2 != []: | |
| player_columns = ['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G'] | |
| query_conditions = [] | |
| for player in player_var2: | |
| # Create a condition for each player to check if they appear in any column | |
| player_condition = {'$or': [{col: player} for col in player_columns]} | |
| query_conditions.append(player_condition) | |
| # Combine all player conditions with $or | |
| if query_conditions: | |
| filter_query = {'$or': query_conditions} | |
| cursor1 = collection.find(filter_query).limit(math.ceil(lineup_num * (prio_mix / 100))) | |
| cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100))) | |
| else: | |
| cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100))) | |
| cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100))) | |
| raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))]) | |
| else: | |
| cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100))) | |
| cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100))) | |
| raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))]) | |
| else: | |
| cursor = collection.find().sort(prio_var, -1).limit(lineup_num) | |
| raw_display = pd.DataFrame(list(cursor)) | |
| raw_display = raw_display.drop_duplicates(subset=['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G']) | |
| raw_display = raw_display[['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']] | |
| dict_columns = ['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G'] | |
| # Map names | |
| raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict)) | |
| elif type_var == 'Showdown': | |
| collection = db[db_translation[slate_var]] | |
| if prio_var == None: | |
| if player_var2 != []: | |
| player_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'] | |
| query_conditions = [] | |
| for player in player_var2: | |
| # Create a condition for each player to check if they appear in any column | |
| player_condition = {'$or': [{col: player} for col in player_columns]} | |
| query_conditions.append(player_condition) | |
| # Combine all player conditions with $or | |
| if query_conditions: | |
| filter_query = {'$or': query_conditions} | |
| cursor1 = collection.find(filter_query).limit(math.ceil(lineup_num * (prio_mix / 100))) | |
| cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100))) | |
| else: | |
| cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100))) | |
| cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100))) | |
| raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))]) | |
| else: | |
| cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100))) | |
| cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100))) | |
| raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))]) | |
| else: | |
| cursor = collection.find().sort(prio_var, -1).limit(lineup_num) | |
| raw_display = pd.DataFrame(list(cursor)) | |
| raw_display = raw_display.drop_duplicates(subset=['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5']) | |
| raw_display = raw_display[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']] | |
| FD_seed = raw_display.to_numpy() | |
| return FD_seed | |
| def convert_df_to_csv(df): | |
| return df.to_csv().encode('utf-8') | |
| def convert_df(array): | |
| array = pd.DataFrame(array, columns=column_names) | |
| return array.to_csv().encode('utf-8') | |
| def convert_pm_df(array): | |
| array = pd.DataFrame(array) | |
| return array.to_csv().encode('utf-8') | |
| def convert_hb_df(array, column_names): | |
| array = pd.DataFrame(array, columns=column_names) | |
| return array.to_csv().encode('utf-8') | |
| player_frame, line_frame, pp_frame, timestamp = player_stat_table() | |
| dk_id_map = dict(zip(player_frame[player_frame['Site'] == 'Draftkings']['Player'], player_frame[player_frame['Site'] == 'Draftkings']['player_id'])) | |
| fd_id_map = dict(zip(player_frame[player_frame['Site'] == 'Fanduel']['Player'], player_frame[player_frame['Site'] == 'Fanduel']['player_id'])) | |
| dk_sd_id_map = dict(zip(player_frame[player_frame['Site'] == 'Draftkings']['Player'], player_frame[player_frame['Site'] == 'Draftkings']['player_id'])) | |
| fd_sd_id_map = dict(zip(player_frame[player_frame['Site'] == 'Fanduel']['Player'], player_frame[player_frame['Site'] == 'Fanduel']['player_id'])) | |
| t_stamp = f"Last Update: " + str(timestamp) + f" CST" | |
| slate_names_dk = [] | |
| slate_name_lookup_dk = {} | |
| slate_names_fd = [] | |
| slate_name_lookup_fd = {} | |
| app_load_reset_column, app_view_site_column, = st.columns([1, 9]) | |
| with app_load_reset_column: | |
| if st.button("Load/Reset Data", key='reset_data_button'): | |
| st.cache_data.clear() | |
| player_frame, line_frame, pp_frame, timestamp = player_stat_table() | |
| dk_id_map = dict(zip(player_frame[player_frame['Site'] == 'Draftkings']['Player'], player_frame[player_frame['Site'] == 'Draftkings']['player_id'])) | |
| fd_id_map = dict(zip(player_frame[player_frame['Site'] == 'Fanduel']['Player'], player_frame[player_frame['Site'] == 'Fanduel']['player_id'])) | |
| dk_sd_id_map = dict(zip(player_frame[player_frame['Site'] == 'Draftkings']['Player'], player_frame[player_frame['Site'] == 'Draftkings']['player_id'])) | |
| fd_sd_id_map = dict(zip(player_frame[player_frame['Site'] == 'Fanduel']['Player'], player_frame[player_frame['Site'] == 'Fanduel']['player_id'])) | |
| dk_lineups = init_DK_lineups('Regular', 'Main Slate', 'proj', 50, dk_showdown_db_translation, 25000, []) | |
| fd_lineups = init_FD_lineups('proj', 50, 25000, [], 'Main Slate') | |
| for key in st.session_state.keys(): | |
| del st.session_state[key] | |
| with app_view_site_column: | |
| with st.container(): | |
| app_view_column, app_site_column, app_type_column, hatter_column = st.columns([3, 3, 3, 3]) | |
| with app_view_column: | |
| view_var = st.selectbox("Select view", ["Simple", "Advanced"], key='view_selectbox') | |
| with app_site_column: | |
| site_var = st.selectbox("What site do you want to view?", ('Draftkings', 'Fanduel'), key='site_selectbox') | |
| with app_type_column: | |
| type_var = st.selectbox("What type of data do you want to view?", ('Regular', 'Showdown'), key='type_selectbox') | |
| with hatter_column: | |
| hatter_var = st.selectbox("Flowchart:", ('No Hatter', 'Hatter'), key='hatter_selectbox') | |
| # selected_tab = st.segmented_control( | |
| # "Select Tab", | |
| # options=["Player Range of Outcomes", "Line Combo Range of Outcomes", "Power Play Range of Outcomes", "Optimals"], | |
| # selection_mode='single', | |
| # default='Player Range of Outcomes', | |
| # width='stretch', | |
| # label_visibility='collapsed', | |
| # key='tab_selector' | |
| # ) | |
| tab1, tab2, tab3, tab4 = st.tabs(["Player Range of Outcomes", "Line Combo Range of Outcomes", "Power Play Range of Outcomes", "Optimals"]) | |
| with tab1: | |
| with st.expander("Info and Filters"): | |
| with st.container(): | |
| st.info("Advanced view includes all stats and thresholds, simple includes just basic columns for ease of use on mobile") | |
| st.info(t_stamp) | |
| if st.button("Load/Reset Data", key='reset1'): | |
| st.cache_data.clear() | |
| player_frame, line_frame, pp_frame, timestamp = player_stat_table() | |
| dk_id_map = dict(zip(player_frame[player_frame['Site'] == 'Draftkings']['Player'], player_frame[player_frame['Site'] == 'Draftkings']['player_id'])) | |
| fd_id_map = dict(zip(player_frame[player_frame['Site'] == 'Fanduel']['Player'], player_frame[player_frame['Site'] == 'Fanduel']['player_id'])) | |
| dk_sd_id_map = dict(zip(player_frame[player_frame['Site'] == 'Draftkings']['Player'], player_frame[player_frame['Site'] == 'Draftkings']['player_id'])) | |
| fd_sd_id_map = dict(zip(player_frame[player_frame['Site'] == 'Fanduel']['Player'], player_frame[player_frame['Site'] == 'Fanduel']['player_id'])) | |
| dk_lineups = init_DK_lineups('Regular', 'Main Slate', 'proj', 50, dk_showdown_db_translation, 25000, []) | |
| fd_lineups = init_FD_lineups('proj', 50, 25000, [], 'Main Slate') | |
| t_stamp = f"Last Update: " + str(timestamp) + f" CST" | |
| slate_var1 = st.selectbox("Which slate would you like to view?", ('Main Slate', 'Secondary Slate', 'Auxiliary Slate'), key='slate_var1') | |
| split_var1 = st.radio("Would you like to view the whole slate or just specific games?", ('Full Slate Run', 'Specific Games'), key='split_var1') | |
| if split_var1 == 'Specific Games': | |
| team_var1 = st.multiselect('Which teams would you like to include in the ROO?', options = player_frame['Team'].unique(), key='team_var1') | |
| elif split_var1 == 'Full Slate Run': | |
| team_var1 = player_frame.Team.values.tolist() | |
| pos_split1 = st.radio("Are you viewing all positions, specific groups, or specific positions?", ('All Positions', 'Specific Positions'), key='pos_split1') | |
| if pos_split1 == 'Specific Positions': | |
| pos_var1 = st.multiselect('What Positions would you like to view?', options = ['C', 'W', 'D', 'G']) | |
| elif pos_split1 == 'All Positions': | |
| pos_var1 = 'All' | |
| sal_var1 = st.slider("Is there a certain price range you want to view?", 2000, 10000, (2000, 20000), key='sal_var1') | |
| final_Proj = player_frame[player_frame['Site'] == str(site_var)] | |
| final_Proj = final_Proj[final_Proj['Type'] == 'Basic'] | |
| final_Proj = final_Proj[final_Proj['Slate'] == slate_var1] | |
| final_Proj = final_Proj[player_frame['Team'].isin(team_var1)] | |
| final_Proj = final_Proj[final_Proj['Salary'] >= sal_var1[0]] | |
| final_Proj = final_Proj[final_Proj['Salary'] <= sal_var1[1]] | |
| if hatter_var == 'Hatter': | |
| final_Proj = final_Proj[final_Proj['Team'] == 'COL'] | |
| if pos_var1 != 'All': | |
| final_Proj = final_Proj[final_Proj['Position'].str.contains('|'.join(pos_var1))] | |
| final_Proj = final_Proj.sort_values(by='Median', ascending=False) | |
| if pos_var1 == 'All': | |
| final_Proj = final_Proj.sort_values(by='Median', ascending=False) | |
| if type_var == 'Regular': | |
| pm_export = final_Proj[['Player', 'Position', 'Team', 'Salary', 'Median', 'Own']] | |
| pm_export['captain ownership'] = pm_export['Own'] / 6 | |
| pm_export = pm_export.rename(columns={'Own': 'ownership', 'Median': 'median', 'Player': 'player_names', 'Position': 'position', 'Team': 'team', 'Salary': 'salary'}) | |
| elif type_var == 'Showdown': | |
| pm_export = final_Proj[['Player', 'Position', 'Team', 'Salary', 'Median', 'Own', 'CPT_Own']] | |
| pm_export['Salary'] = pm_export['Salary'] / 1.6 | |
| pm_export = pm_export.rename(columns={'Own': 'ownership', 'Median': 'median', 'Player': 'player_names', 'Position': 'position', 'Team': 'team', 'Salary': 'salary', 'CPT_Own': 'captain ownership'}) | |
| player_reg_dl_col, player_pm_dl_col, player_dl_blank_col = st.columns([2, 2, 10]) | |
| with player_reg_dl_col: | |
| st.download_button( | |
| label="Export ROO (Regular)", | |
| data=convert_df_to_csv(final_Proj), | |
| file_name='NHL_ROO_export.csv', | |
| mime='text/csv', | |
| ) | |
| with player_pm_dl_col: | |
| st.download_button( | |
| label="Export ROO (Portfolio Manager)", | |
| data=convert_df_to_csv(pm_export), | |
| file_name='NHL_ROO_export.csv', | |
| mime='text/csv', | |
| ) | |
| if view_var == 'Advanced': | |
| display_proj = final_Proj[['Player', 'Position', 'Line', 'PP Unit', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '2x%', '3x%', '4x%', | |
| 'Own', 'Small Field Own%', 'Large Field Own%', 'Cash Own%', 'CPT_Own']] | |
| elif view_var == 'Simple': | |
| display_proj = final_Proj[['Player', 'Position', 'Salary', 'Median', '3x%', 'Own']] | |
| st.dataframe(display_proj.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(player_roo_format, precision=2), height = 1000, use_container_width = True, hide_index=True) | |
| st.download_button( | |
| label="Export Tables", | |
| data=convert_df_to_csv(display_proj), | |
| file_name='NHL_player_export.csv', | |
| mime='text/csv', | |
| ) | |
| with tab2: | |
| with st.expander("Info and Filters"): | |
| with st.container(): | |
| st.info("Advanced view includes all stats and thresholds, simple includes just basic columns for ease of use on mobile") | |
| st.info(t_stamp) | |
| if st.button("Load/Reset Data", key='reset2'): | |
| st.cache_data.clear() | |
| player_frame, line_frame, pp_frame, timestamp = player_stat_table() | |
| dk_id_map = dict(zip(player_frame[player_frame['Site'] == 'Draftkings']['Player'], player_frame[player_frame['Site'] == 'Draftkings']['player_id'])) | |
| fd_id_map = dict(zip(player_frame[player_frame['Site'] == 'Fanduel']['Player'], player_frame[player_frame['Site'] == 'Fanduel']['player_id'])) | |
| dk_sd_id_map = dict(zip(player_frame[player_frame['Site'] == 'Draftkings']['Player'], player_frame[player_frame['Site'] == 'Draftkings']['player_id'])) | |
| fd_sd_id_map = dict(zip(player_frame[player_frame['Site'] == 'Fanduel']['Player'], player_frame[player_frame['Site'] == 'Fanduel']['player_id'])) | |
| dk_lineups = init_DK_lineups('Regular', 'Main Slate', 'proj', 50, dk_showdown_db_translation, 25000, []) | |
| fd_lineups = init_FD_lineups('proj', 50, 25000, [], 'Main Slate') | |
| t_stamp = f"Last Update: " + str(timestamp) + f" CST" | |
| slate_var2 = st.selectbox("Which slate would you like to view?", ('Main Slate', 'Secondary Slate', 'Auxiliary Slate'), key='slate_var2') | |
| sal_var2 = st.slider("Is there a certain price range you want to view?", 5000, 40000, (5000, 40000), key='sal_var2') | |
| final_line_combos = line_frame[line_frame['Site'] == str(site_var)] | |
| final_line_combos = final_line_combos[final_line_combos['Type'] == 'Basic'] | |
| final_line_combos = final_line_combos[final_line_combos['Slate'] == slate_var2] | |
| final_line_combos = final_line_combos[final_line_combos['Salary'] >= sal_var2[0]] | |
| final_line_combos = final_line_combos[final_line_combos['Salary'] <= sal_var2[1]] | |
| final_line_combos = final_line_combos.drop_duplicates(subset=['Player']) | |
| final_line_combos = final_line_combos.sort_values(by='Median', ascending=False) | |
| if hatter_var == 'Hatter': | |
| final_line_combos = final_line_combos[final_line_combos['Player'].str.contains('COL')] | |
| if view_var == 'Advanced': | |
| display_proj_lines = final_line_combos[['Player', 'SK1', 'SK2', 'SK3', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '50+%', '2x%', '3x%', '4x%', | |
| 'Own']] | |
| elif view_var == 'Simple': | |
| display_proj_lines = final_line_combos[['SK1', 'SK2', 'SK3', 'Salary', 'Median', '3x%', 'Own']] | |
| st.dataframe(display_proj_lines.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(player_roo_format, precision=2), height = 1000, use_container_width = True, hide_index=True) | |
| st.download_button( | |
| label="Export Tables", | |
| data=convert_df_to_csv(display_proj_lines), | |
| file_name='NHL_linecombos_export.csv', | |
| mime='text/csv', | |
| ) | |
| with tab3: | |
| with st.expander("Info and Filters"): | |
| with st.container(): | |
| st.info("Advanced view includes all stats and thresholds, simple includes just basic columns for ease of use on mobile") | |
| st.info(t_stamp) | |
| if st.button("Load/Reset Data", key='reset3'): | |
| st.cache_data.clear() | |
| player_frame, line_frame, pp_frame, timestamp = player_stat_table() | |
| dk_id_map = dict(zip(player_frame[player_frame['Site'] == 'Draftkings']['Player'], player_frame[player_frame['Site'] == 'Draftkings']['player_id'])) | |
| fd_id_map = dict(zip(player_frame[player_frame['Site'] == 'Fanduel']['Player'], player_frame[player_frame['Site'] == 'Fanduel']['player_id'])) | |
| dk_sd_id_map = dict(zip(player_frame[player_frame['Site'] == 'Draftkings']['Player'], player_frame[player_frame['Site'] == 'Draftkings']['player_id'])) | |
| fd_sd_id_map = dict(zip(player_frame[player_frame['Site'] == 'Fanduel']['Player'], player_frame[player_frame['Site'] == 'Fanduel']['player_id'])) | |
| dk_lineups = init_DK_lineups('Regular', 'Main Slate', 'proj', 50, dk_showdown_db_translation, 25000, []) | |
| fd_lineups = init_FD_lineups('proj', 50, 25000, [], 'Main Slate') | |
| t_stamp = f"Last Update: " + str(timestamp) + f" CST" | |
| slate_var3 = st.selectbox("Which slate would you like to view?", ('Main Slate', 'Secondary Slate', 'Auxiliary Slate'), key='slate_var3') | |
| sal_var3 = st.slider("Is there a certain price range you want to view?", 5000, 40000, (5000, 40000), key='sal_var3') | |
| final_pp_combos = pp_frame[pp_frame['Site'] == str(site_var)] | |
| final_pp_combos = final_pp_combos[final_pp_combos['Type'] == 'Basic'] | |
| final_pp_combos = final_pp_combos[final_pp_combos['Slate'] == slate_var3] | |
| final_pp_combos = final_pp_combos[final_pp_combos['Salary'] >= sal_var3[0]] | |
| final_pp_combos = final_pp_combos[final_pp_combos['Salary'] <= sal_var3[1]] | |
| final_pp_combos = final_pp_combos.drop_duplicates(subset=['Player']) | |
| final_pp_combos = final_pp_combos.sort_values(by='Median', ascending=False) | |
| if hatter_var == 'Hatter': | |
| final_pp_combos = final_pp_combos[final_pp_combos['Player'].str.contains('COL')] | |
| if view_var == 'Advanced': | |
| display_proj_pp = final_pp_combos[['Player', 'SK1', 'SK2', 'SK3', 'SK4', 'SK5', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '75+%', '2x%', '3x%', '4x%', | |
| 'Own']] | |
| elif view_var == 'Simple': | |
| display_proj_pp = final_pp_combos[['SK1', 'SK2', 'SK3', 'SK4', 'SK5', 'Salary', 'Median', '3x%', 'Own']] | |
| st.dataframe(display_proj_pp.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(precision=2), height = 1000, use_container_width = True, hide_index=True) | |
| st.download_button( | |
| label="Export Tables", | |
| data=convert_df_to_csv(display_proj_pp), | |
| file_name='NHL_powerplay_export.csv', | |
| mime='text/csv', | |
| ) | |
| with tab4: | |
| player_frame, line_frame, pp_frame, timestamp = player_stat_table() | |
| dk_id_map = dict(zip(player_frame[player_frame['Site'] == 'Draftkings']['Player'], player_frame[player_frame['Site'] == 'Draftkings']['player_id'])) | |
| fd_id_map = dict(zip(player_frame[player_frame['Site'] == 'Fanduel']['Player'], player_frame[player_frame['Site'] == 'Fanduel']['player_id'])) | |
| dk_sd_id_map = dict(zip(player_frame[player_frame['Site'] == 'Draftkings']['Player'], player_frame[player_frame['Site'] == 'Draftkings']['player_id'])) | |
| fd_sd_id_map = dict(zip(player_frame[player_frame['Site'] == 'Fanduel']['Player'], player_frame[player_frame['Site'] == 'Fanduel']['player_id'])) | |
| if type_var == 'Regular': | |
| t_stamp = f"Last Update: " + str(timestamp) + f" CST" | |
| elif type_var == 'Showdown': | |
| t_stamp = f"Last Update: " + str(timestamp) + f" CST" | |
| st.header("Optimals") | |
| with st.expander("Info and Filters"): | |
| st.info("These filters will display various optimals in the table below to pick from. If you want to export the entire set of 10,000 optimals, hit the 'Prepare full data export' button. If you would like to apply the filters here to the 10,000 optimals before you export, use the 'Prepare full data export (Filter)' button.") | |
| prio_col, optimals_site_col, optimals_macro_col, optimals_salary_col, optimals_stacks_col = st.columns(5) | |
| with prio_col: | |
| prio_var = st.radio("Which priority variable do you want to use?", ('proj', 'Own', 'Mix'), key='prio_var_radio') | |
| prio_mix = st.number_input("If Mix, what split of Projection/Ownership to dedicate to Projection?", min_value=0, max_value=100, value=50, step=1) | |
| lineup_num = st.number_input("How many lineups do you want to work with?", min_value=1000, max_value=50000, value=25000, step=100, key='lineup_download_var_input') | |
| with optimals_site_col: | |
| if type_var == 'Regular': | |
| if site_var == 'Draftkings': | |
| raw_baselines = player_frame[player_frame['Site'] == 'Draftkings'] | |
| elif site_var == 'Fanduel': | |
| raw_baselines = player_frame[player_frame['Site'] == 'Fanduel'] | |
| elif type_var == 'Showdown': | |
| if site_var == 'Draftkings': | |
| raw_baselines = player_frame[player_frame['Site'] == 'Draftkings'] | |
| elif site_var == 'Fanduel': | |
| raw_baselines = player_frame[player_frame['Site'] == 'Fanduel'] | |
| if site_var == 'Draftkings': | |
| slate_var4 = st.radio("Which slate data are you loading?", (['Main Slate', 'Secondary Slate', 'Auxiliary Slate']), key='slate_var4_radio') | |
| elif site_var == 'Fanduel': | |
| slate_var4 = st.radio("Which slate data are you loading?", (['Main Slate', 'Secondary Slate', 'Auxiliary Slate']), key='slate_var4_radio') | |
| with optimals_macro_col: | |
| lineup_num_var = st.number_input("How many lineups do you want to display?", min_value=1, max_value=1000, value=150, step=1, key='lineup_num_var_input') | |
| player_var2 = st.multiselect('Query for lineups including:', options = raw_baselines['Player'].unique(), key='player_var2_multiselect', default=[]) | |
| if type_var == 'Regular': | |
| if site_var == 'Draftkings': | |
| dk_lineups = init_DK_lineups(type_var, slate_var4, prio_var, prio_mix, dk_showdown_db_translation, lineup_num, player_var2) | |
| elif site_var == 'Fanduel': | |
| fd_lineups = init_FD_lineups(prio_var, prio_mix, lineup_num, player_var2, slate_var4) | |
| elif type_var == 'Showdown': | |
| if site_var == 'Draftkings': | |
| dk_lineups = init_DK_lineups(type_var, slate_name_lookup_dk[slate_var4], prio_var, prio_mix, dk_showdown_db_translation, lineup_num, player_var2) | |
| elif site_var == 'Fanduel': | |
| fd_lineups = init_FD_lineups(prio_var, prio_mix, lineup_num, player_var2, slate_var4) | |
| with optimals_salary_col: | |
| if site_var == 'Draftkings': | |
| salary_min_var = st.number_input("Minimum salary used", min_value = 0, max_value = 50000, value = 49000, step = 100, key = 'salary_min_var_dk') | |
| salary_max_var = st.number_input("Maximum salary used", min_value = 0, max_value = 50000, value = 50000, step = 100, key = 'salary_max_var_dk') | |
| elif site_var == 'Fanduel': | |
| salary_min_var = st.number_input("Minimum salary used", min_value = 0, max_value = 55000, value = 54000, step = 100, key = 'salary_min_var_fd') | |
| salary_max_var = st.number_input("Maximum salary used", min_value = 0, max_value = 55000, value = 55000, step = 100, key = 'salary_max_var_fd') | |
| with optimals_stacks_col: | |
| if site_var == 'Draftkings': | |
| min_stacks_var = st.number_input("Minimum stacks used", min_value = 0, max_value = 5, value = 1, step = 1, key = 'min_stacks_var_dk') | |
| max_stacks_var = st.number_input("Maximum stacks used", min_value = 0, max_value = 5, value = 5, step = 1, key = 'max_stacks_var_dk') | |
| elif site_var == 'Fanduel': | |
| min_stacks_var = st.number_input("Minimum stacks used", min_value = 0, max_value = 4, value = 1, step = 1, key = 'min_stacks_var_fd') | |
| max_stacks_var = st.number_input("Maximum stacks used", min_value = 0, max_value = 4, value = 4, step = 1, key = 'max_stacks_var_fd') | |
| if site_var == 'Draftkings': | |
| if type_var == 'Regular': | |
| ROO_slice = raw_baselines | |
| player_salaries = dict(zip(ROO_slice['Player'], ROO_slice['Salary'])) | |
| column_names = dk_columns | |
| elif type_var == 'Showdown': | |
| player_salaries = dict(zip(raw_baselines['Player'], raw_baselines['Salary'])) | |
| column_names = dk_sd_columns | |
| elif site_var == 'Fanduel': | |
| if type_var == 'Regular': | |
| ROO_slice = raw_baselines | |
| player_salaries = dict(zip(ROO_slice['Player'], ROO_slice['Salary'])) | |
| column_names = fd_columns | |
| elif type_var == 'Showdown': | |
| player_salaries = dict(zip(raw_baselines['Player'], raw_baselines['Salary'])) | |
| column_names = fd_sd_columns | |
| 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_button'): | |
| 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_var == 'Draftkings': | |
| if type_var == 'Regular': | |
| map_columns = ['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', 'FLEX'] | |
| for col_idx in map_columns: | |
| data_export[col_idx] = data_export[col_idx].map(dk_id_map) | |
| elif type_var == 'Showdown': | |
| map_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'] | |
| for col_idx in map_columns: | |
| data_export[col_idx] = data_export[col_idx].map(dk_sd_id_map) | |
| elif site_var == 'Fanduel': | |
| if type_var == 'Regular': | |
| map_columns = ['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G'] | |
| for col_idx in map_columns: | |
| data_export[col_idx] = data_export[col_idx].map(fd_id_map) | |
| elif type_var == 'Showdown': | |
| map_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'] | |
| for col_idx in map_columns: | |
| data_export[col_idx] = data_export[col_idx].map(fd_sd_id_map) | |
| 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='NHL_optimals_export.csv', | |
| mime='text/csv', | |
| key='export_optimals_ids_button' | |
| ) | |
| st.download_button( | |
| label="Export optimals set (Names)", | |
| data=convert_df(name_export), | |
| file_name='NHL_optimals_export.csv', | |
| mime='text/csv', | |
| key='export_optimals_names_button' | |
| ) | |
| with pm_opt_col: | |
| if site_var == 'Draftkings': | |
| if type_var == 'Regular': | |
| data_export = data_export.set_index('C1').drop(columns=['salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'], axis=1) | |
| elif type_var == 'Showdown': | |
| data_export = data_export.set_index('CPT').drop(columns=['salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'], axis=1) | |
| elif site_var == 'Fanduel': | |
| if type_var == 'Regular': | |
| data_export = data_export.set_index('C1').drop(columns=['salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'], axis=1) | |
| elif type_var == 'Showdown': | |
| data_export = data_export.set_index('CPT').drop(columns=['salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'], axis=1) | |
| st.download_button( | |
| label="Portfolio Manager Export (IDs)", | |
| data=convert_pm_df(data_export), | |
| file_name='NHL_optimals_export.csv', | |
| mime='text/csv', | |
| key='export_pm_ids_button' | |
| ) | |
| if site_var == 'Draftkings': | |
| if type_var == 'Regular': | |
| name_export = name_export.set_index('C1').drop(columns=['salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'], axis=1) | |
| elif type_var == 'Showdown': | |
| name_export = name_export.set_index('CPT').drop(columns=['salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'], axis=1) | |
| elif site_var == 'Fanduel': | |
| if type_var == 'Regular': | |
| name_export = name_export.set_index('C1').drop(columns=['salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'], axis=1) | |
| elif type_var == 'Showdown': | |
| name_export = name_export.set_index('CPT').drop(columns=['salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'], axis=1) | |
| st.download_button( | |
| label="Portfolio Manager Export (Names)", | |
| data=convert_pm_df(name_export), | |
| file_name='NHL_optimals_export.csv', | |
| mime='text/csv', | |
| key='export_pm_names_button' | |
| ) | |
| with filtered_dl_col: | |
| if st.button("Prepare full data export (Filtered)", key='data_export_filtered_button'): | |
| 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_var == 'Draftkings': | |
| if type_var == 'Regular': | |
| map_columns = ['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', 'FLEX'] | |
| for col_idx in map_columns: | |
| data_export[col_idx] = data_export[col_idx].map(dk_id_map) | |
| elif type_var == 'Showdown': | |
| map_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'] | |
| for col_idx in map_columns: | |
| data_export[col_idx] = data_export[col_idx].map(dk_sd_id_map) | |
| elif site_var == 'Fanduel': | |
| if type_var == 'Regular': | |
| map_columns = ['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G'] | |
| for col_idx in map_columns: | |
| data_export[col_idx] = data_export[col_idx].map(fd_id_map) | |
| elif type_var == 'Showdown': | |
| map_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'] | |
| for col_idx in map_columns: | |
| data_export[col_idx] = data_export[col_idx].map(fd_sd_id_map) | |
| data_export = data_export[data_export['salary'] >= salary_min_var] | |
| data_export = data_export[data_export['salary'] <= salary_max_var] | |
| data_export = data_export[data_export['Team_count'] >= min_stacks_var] | |
| data_export = data_export[data_export['Team_count'] <= max_stacks_var] | |
| name_export = name_export[name_export['salary'] >= salary_min_var] | |
| name_export = name_export[name_export['salary'] <= salary_max_var] | |
| name_export = name_export[name_export['Team_count'] >= min_stacks_var] | |
| name_export = name_export[name_export['Team_count'] <= max_stacks_var] | |
| 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='NHL_optimals_export.csv', | |
| mime='text/csv', | |
| key='export_filtered_optimals_ids_button' | |
| ) | |
| st.download_button( | |
| label="Export optimals set (Names)", | |
| data=convert_df(name_export), | |
| file_name='NHL_optimals_export.csv', | |
| mime='text/csv', | |
| key='export_filtered_optimals_names_button' | |
| ) | |
| with pm_opt_col: | |
| if site_var == 'Draftkings': | |
| if type_var == 'Regular': | |
| data_export = data_export.set_index('C1').drop(columns=['salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'], axis=1) | |
| elif type_var == 'Showdown': | |
| data_export = data_export.set_index('CPT').drop(columns=['salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'], axis=1) | |
| elif site_var == 'Fanduel': | |
| if type_var == 'Regular': | |
| data_export = data_export.set_index('C1').drop(columns=['salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'], axis=1) | |
| elif type_var == 'Showdown': | |
| data_export = data_export.set_index('CPT').drop(columns=['salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'], axis=1) | |
| st.download_button( | |
| label="Portfolio Manager Export (IDs)", | |
| data=convert_pm_df(data_export), | |
| file_name='NHL_optimals_export.csv', | |
| mime='text/csv', | |
| key='export_filtered_pm_ids_button' | |
| ) | |
| if site_var == 'Draftkings': | |
| if type_var == 'Regular': | |
| name_export = name_export.set_index('C1').drop(columns=['salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'], axis=1) | |
| elif type_var == 'Showdown': | |
| name_export = name_export.set_index('CPT').drop(columns=['salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'], axis=1) | |
| elif site_var == 'Fanduel': | |
| if type_var == 'Regular': | |
| name_export = name_export.set_index('C1').drop(columns=['salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'], axis=1) | |
| elif type_var == 'Showdown': | |
| name_export = name_export.set_index('CPT').drop(columns=['salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'], axis=1) | |
| st.download_button( | |
| label="Portfolio Manager Export (Names)", | |
| data=convert_pm_df(name_export), | |
| file_name='NHL_optimals_export.csv', | |
| mime='text/csv', | |
| key='export_filtered_pm_names_button' | |
| ) | |
| if site_var == 'Draftkings': | |
| if 'working_seed' in st.session_state: | |
| st.session_state.working_seed = st.session_state.working_seed | |
| if player_var2 != []: | |
| 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_var2 == []: | |
| st.session_state.working_seed = dk_lineups.copy() | |
| 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: | |
| st.session_state.working_seed = dk_lineups.copy() | |
| st.session_state.working_seed = st.session_state.working_seed | |
| if player_var2 != []: | |
| 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_var2 == []: | |
| st.session_state.working_seed = dk_lineups.copy() | |
| st.session_state.data_export_display = pd.DataFrame(st.session_state.working_seed[0:lineup_num_var], columns=column_names) | |
| elif site_var == 'Fanduel': | |
| if 'working_seed' in st.session_state: | |
| st.session_state.working_seed = st.session_state.working_seed | |
| if player_var2 != []: | |
| 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_var2 == []: | |
| st.session_state.working_seed = fd_lineups.copy() | |
| 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: | |
| st.session_state.working_seed = fd_lineups.copy() | |
| st.session_state.working_seed = st.session_state.working_seed | |
| if player_var2 != []: | |
| 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_var2 == []: | |
| st.session_state.working_seed = fd_lineups.copy() | |
| 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'] >= salary_min_var] | |
| st.session_state.data_export_display = st.session_state.data_export_display[st.session_state.data_export_display['salary'] <= salary_max_var] | |
| st.session_state.data_export_display = st.session_state.data_export_display[st.session_state.data_export_display['Team_count'] >= min_stacks_var] | |
| st.session_state.data_export_display = st.session_state.data_export_display[st.session_state.data_export_display['Team_count'] <= max_stacks_var] | |
| export_file = st.session_state.data_export_display.copy() | |
| name_export = st.session_state.data_export_display.copy() | |
| if site_var == 'Draftkings': | |
| if type_var == 'Regular': | |
| map_columns = ['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', 'FLEX'] | |
| for col_idx in map_columns: | |
| export_file[col_idx] = export_file[col_idx].map(dk_id_map) | |
| elif type_var == 'Showdown': | |
| map_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'] | |
| for col_idx in map_columns: | |
| export_file[col_idx] = export_file[col_idx].map(dk_sd_id_map) | |
| elif site_var == 'Fanduel': | |
| if type_var == 'Regular': | |
| map_columns = ['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G'] | |
| for col_idx in map_columns: | |
| export_file[col_idx] = export_file[col_idx].map(fd_id_map) | |
| elif type_var == 'Showdown': | |
| map_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'] | |
| for col_idx in map_columns: | |
| export_file[col_idx] = export_file[col_idx].map(fd_sd_id_map) | |
| with st.container(): | |
| if st.button("Reset Optimals", key='reset_optimals_button'): | |
| for key in st.session_state.keys(): | |
| del st.session_state[key] | |
| if site_var == 'Draftkings': | |
| st.session_state.working_seed = dk_lineups.copy() | |
| elif site_var == 'Fanduel': | |
| st.session_state.working_seed = fd_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 (IDs)", | |
| data=convert_df(export_file), | |
| file_name='NHL_display_optimals.csv', | |
| mime='text/csv', | |
| key='export_display_optimals_ids_button' | |
| ) | |
| st.download_button( | |
| label="Export display optimals (Names)", | |
| data=convert_df(name_export), | |
| file_name='NHL_display_optimals.csv', | |
| mime='text/csv', | |
| key='export_display_optimals_names_button' | |
| ) | |
| with st.container(): | |
| if type_var == 'Regular': | |
| if 'working_seed' in st.session_state: | |
| # Create a new dataframe with summary statistics | |
| if site_var == 'Draftkings': | |
| 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 site_var == 'Fanduel': | |
| 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 type_var == 'Showdown': | |
| if 'working_seed' in st.session_state: | |
| # Create a new dataframe with summary statistics | |
| if site_var == 'Draftkings': | |
| 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_var == 'Fanduel': | |
| 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(): | |
| display_freq_tab, seed_frame_freq_tab = st.tabs(["Display Frequency", "Seed Frame Frequency"]) | |
| with display_freq_tab: | |
| if 'data_export_display' in st.session_state: | |
| if site_var == 'Draftkings': | |
| if type_var == 'Regular': | |
| player_columns = st.session_state.data_export_display.iloc[:, :9] | |
| elif type_var == 'Showdown': | |
| player_columns = st.session_state.data_export_display.iloc[:, :6] | |
| elif site_var == 'Fanduel': | |
| if type_var == 'Regular': | |
| player_columns = st.session_state.data_export_display.iloc[:, :9] | |
| elif type_var == 'Showdown': | |
| player_columns = st.session_state.data_export_display.iloc[:, :6] | |
| # 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, | |
| 'Frequency': value_counts.values, | |
| 'Percentage': percentages.values | |
| }) | |
| # Sort by frequency in descending order | |
| summary_df['Salary'] = summary_df['Player'].map(player_salaries) | |
| summary_df = summary_df[['Player', 'Salary', 'Frequency', 'Percentage']] | |
| summary_df = summary_df.sort_values('Frequency', ascending=False) | |
| summary_df = summary_df.set_index('Player') | |
| # Display the table | |
| st.write("Player Frequency Table:") | |
| st.dataframe(summary_df.style.format({'Percentage': '{:.2f}%'}), height=500, use_container_width=True) | |
| st.download_button( | |
| label="Export player frequency", | |
| data=convert_df_to_csv(summary_df), | |
| file_name='NHL_player_frequency.csv', | |
| mime='text/csv', | |
| key='export_player_frequency_button' | |
| ) | |
| with seed_frame_freq_tab: | |
| if 'working_seed' in st.session_state: | |
| if site_var == 'Draftkings': | |
| if type_var == 'Regular': | |
| player_columns = st.session_state.working_seed[:, :9] | |
| elif type_var == 'Showdown': | |
| player_columns = st.session_state.working_seed[:, :6] | |
| elif site_var == 'Fanduel': | |
| if type_var == 'Regular': | |
| player_columns = st.session_state.working_seed[:, :9] | |
| elif type_var == 'Showdown': | |
| player_columns = st.session_state.working_seed[:, :6] | |
| # 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, | |
| 'Frequency': value_counts.values, | |
| 'Percentage': percentages.values | |
| }) | |
| # Sort by frequency in descending order | |
| summary_df['Salary'] = summary_df['Player'].map(player_salaries) | |
| summary_df = summary_df[['Player', 'Salary', 'Frequency', 'Percentage']] | |
| summary_df = summary_df.sort_values('Frequency', ascending=False) | |
| summary_df = summary_df.set_index('Player') | |
| # Display the table | |
| st.write("Seed Frame Frequency Table:") | |
| st.dataframe(summary_df.style.format({'Percentage': '{:.2f}%'}), height=500, use_container_width=True) | |
| st.download_button( | |
| label="Export seed frame frequency", | |
| data=convert_df_to_csv(summary_df), | |
| file_name='NHL_seed_frame_frequency.csv', | |
| mime='text/csv', | |
| key='export_seed_frame_frequency_button' | |
| ) |