Implement initial project structure and setup

app.py

@@ -0,0 +1,770 @@
+import streamlit as st
+import numpy as np
+import pandas as pd
+import gspread
+import pymongo
+
+st.set_page_config(layout="wide")
+
+@st.cache_resource
+def init_conn():
+        uri = st.secrets['mongo_uri']
+        client = pymongo.MongoClient(uri, retryWrites=True, serverSelectionTimeoutMS=500000)
+        db = client["MLB_Database"]
+
+        return db
+    
+db = init_conn()
+
+game_format = {'Win%': '{:.2%}','First Inning Lead Percentage': '{:.2%}', 'Top Score': '{:.2%}',
+              'Fifth Inning Lead Percentage': '{:.2%}', '8+ Runs': '{:.2%}', 'LevX': '{:.2%}'}
+
+player_roo_format = {'Top_finish': '{:.2%}','Top_5_finish': '{:.2%}', 'Top_10_finish': '{:.2%}', '20+%': '{:.2%}', '2x%': '{:.2%}', '3x%': '{:.2%}',
+                   '4x%': '{:.2%}'}
+
+dk_columns = ['SP1', 'SP2', 'C', '1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']
+fd_columns = ['P', 'C_1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'UTIL', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']
+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', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']
+
+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;
+    }
+    div[data-baseweb="select"] > div {
+        background-color: #DAA520;
+        color: white;
+    }
+</style>""", unsafe_allow_html=True)
+
+@st.cache_resource(ttl = 60)
+def init_baselines():
+    collection = db["Player_Range_Of_Outcomes"] 
+    cursor = collection.find()
+    player_frame = pd.DataFrame(cursor)
+
+    roo_data = player_frame.drop(columns=['_id'])
+    roo_data['Salary'] = roo_data['Salary'].astype(int)
+    
+    dk_roo = roo_data[roo_data['Site'] == 'Draftkings']
+    dk_id_map = dict(zip(dk_roo['Player'], dk_roo['player_ID']))
+    fd_roo = roo_data[roo_data['Site'] == 'Fanduel']
+    fd_id_map = dict(zip(fd_roo['Player'], fd_roo['player_ID']))
+
+    collection = db["Player_SD_Range_Of_Outcomes"] 
+    cursor = collection.find()
+    player_frame = pd.DataFrame(cursor)
+
+    sd_roo_data = player_frame.drop(columns=['_id'])
+    sd_roo_data['Salary'] = sd_roo_data['Salary'].astype(int)
+    sd_roo_data = sd_roo_data.rename(columns={'Own': 'Own%'})
+
+    collection = db["Scoring_Percentages"] 
+    cursor = collection.find()
+    team_frame = pd.DataFrame(cursor)
+    scoring_percentages = team_frame.drop(columns=['_id'])
+    scoring_percentages = scoring_percentages[['Names', 'Avg First Inning', 'First Inning Lead Percentage', 'Avg Fifth Inning', 'Fifth Inning Lead Percentage', 'Avg Score', '8+ runs', 'Win Percentage',
+    'DK Main Slate', 'DK Secondary Slate', 'DK Turbo Slate', 'FD Main Slate', 'FD Secondary Slate', 'FD Turbo Slate', 'DK Main Top Score', 'FD Main Top Score', 'DK Secondary Top Score', 'FD Secondary Top Score',
+    'DK Turbo Top Score', 'FD Turbo Top Score']]
+    scoring_percentages['8+ runs'] = scoring_percentages['8+ runs'].replace('%', '', regex=True).astype(float)
+    scoring_percentages['Win Percentage'] = scoring_percentages['Win Percentage'].replace('%', '', regex=True).astype(float)
+    scoring_percentages['DK Main Top Score'] = scoring_percentages['DK Main Top Score'].replace('', np.nan).astype(float)
+    scoring_percentages['FD Main Top Score'] = scoring_percentages['FD Main Top Score'].replace('', np.nan).astype(float)
+    scoring_percentages['DK Secondary Top Score'] = scoring_percentages['DK Secondary Top Score'].replace('', np.nan).astype(float)
+    scoring_percentages['FD Secondary Top Score'] = scoring_percentages['FD Secondary Top Score'].replace('', np.nan).astype(float)
+    scoring_percentages['DK Turbo Top Score'] = scoring_percentages['DK Turbo Top Score'].replace('', np.nan).astype(float)
+    scoring_percentages['FD Turbo Top Score'] = scoring_percentages['FD Turbo Top Score'].replace('', np.nan).astype(float)
+    
+    return roo_data, sd_roo_data, scoring_percentages, dk_roo, fd_roo, dk_id_map, fd_id_map
+
+@st.cache_data(ttl = 60)
+def init_DK_lineups(type_var, slate_var):  
+    
+    if type_var == 'Regular':
+        if slate_var == 'Main':
+            collection = db['DK_MLB_name_map']
+            cursor = collection.find()
+            raw_data = pd.DataFrame(list(cursor))
+            names_dict = dict(zip(raw_data['key'], raw_data['value']))
+
+            collection = db['DK_MLB_seed_frame']
+            cursor = collection.find().limit(10000)
+
+            raw_display = pd.DataFrame(list(cursor))
+            raw_display = raw_display[['SP1', 'SP2', 'C', '1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
+            dict_columns = ['SP1', 'SP2', 'C', '1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3']
+            # Map names
+            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+        elif slate_var == 'Secondary':
+            collection = db['DK_MLB_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_MLB_Secondary_seed_frame']
+            cursor = collection.find().limit(10000)
+
+            raw_display = pd.DataFrame(list(cursor))
+            raw_display = raw_display[['SP1', 'SP2', 'C', '1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
+            dict_columns = ['SP1', 'SP2', 'C', '1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3']
+            # Map names
+            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+        elif slate_var == 'Auxiliary':
+            collection = db['DK_MLB_Turbo_name_map']
+            cursor = collection.find()
+            raw_data = pd.DataFrame(list(cursor))
+            names_dict = dict(zip(raw_data['key'], raw_data['value']))
+            
+            collection = db['DK_MLB_Turbo_seed_frame']
+            cursor = collection.find().limit(10000)
+
+            raw_display = pd.DataFrame(list(cursor))
+            raw_display = raw_display[['SP1', 'SP2', 'C', '1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
+            dict_columns = ['SP1', 'SP2', 'C', '1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3']
+            # Map names
+            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+    elif type_var == 'Showdown':
+        if slate_var == 'Main':
+            collection = db['DK_MLB_SD1_seed_frame']
+            cursor = collection.find().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']]
+        elif slate_var == 'Secondary':
+            collection = db['DK_MLB_SD2_seed_frame']
+            cursor = collection.find().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']]
+        elif slate_var == 'Auxiliary':
+            collection = db['DK_MLB_SD3_seed_frame']
+            cursor = collection.find().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
+
+@st.cache_data(ttl = 60)
+def init_FD_lineups(type_var,slate_var):  
+        
+        if type_var == 'Regular':
+            if slate_var == 'Main':
+                collection = db['FD_MLB_name_map']
+                cursor = collection.find()
+                raw_data = pd.DataFrame(list(cursor))
+                names_dict = dict(zip(raw_data['key'], raw_data['value']))
+
+                collection = db['FD_MLB_seed_frame']
+                cursor = collection.find().limit(10000)
+
+                raw_display = pd.DataFrame(list(cursor))
+                raw_display = raw_display[['P', 'C_1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'UTIL', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
+                dict_columns = ['P', 'C_1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'UTIL']
+                # Map names
+                raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+            elif slate_var == 'Secondary':
+                collection = db['FD_MLB_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_MLB_Secondary_seed_frame']
+                cursor = collection.find().limit(10000)
+
+                raw_display = pd.DataFrame(list(cursor))
+                raw_display = raw_display[['P', 'C_1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'UTIL', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
+                dict_columns = ['P', 'C_1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'UTIL']
+                # Map names
+                raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+            elif slate_var == 'Auxiliary':
+                collection = db['FD_MLB_Turbo_name_map']
+                cursor = collection.find()
+                raw_data = pd.DataFrame(list(cursor))
+                names_dict = dict(zip(raw_data['key'], raw_data['value']))
+
+                collection = db['FD_MLB_Turbo_seed_frame']
+                cursor = collection.find().limit(10000)
+            
+                raw_display = pd.DataFrame(list(cursor))
+                raw_display = raw_display[['P', 'C_1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'UTIL', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
+                dict_columns = ['P', 'C_1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'UTIL']
+                # Map names
+                raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+
+        elif type_var == 'Showdown':
+            if slate_var == 'Main':
+                collection = db['FD_MLB_SD1_seed_frame']
+                cursor = collection.find().limit(10000)
+
+                raw_display = pd.DataFrame(list(cursor))
+                raw_display = raw_display[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
+            elif slate_var == 'Secondary':
+                collection = db['FD_MLB_SD2_seed_frame']
+                cursor = collection.find().limit(10000)
+
+                raw_display = pd.DataFrame(list(cursor))
+                raw_display = raw_display[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
+            elif slate_var == 'Auxiliary':
+                collection = db['FD_MLB_SD3_seed_frame']
+                cursor = collection.find().limit(10000)
+            
+                raw_display = pd.DataFrame(list(cursor))
+                raw_display = raw_display[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
+    
+        FD_seed = raw_display.to_numpy()
+
+        return FD_seed
+
+@st.cache_data
+def convert_df_to_csv(df):
+    return df.to_csv().encode('utf-8')
+
+@st.cache_data
+def convert_df(array):
+    array = pd.DataFrame(array, columns=column_names)
+    return array.to_csv().encode('utf-8')
+
+col1, col2 = st.columns([1, 9])
+with col1:
+    if st.button("Load/Reset Data", key='reset'):
+        st.cache_data.clear()
+        roo_data, sd_roo_data, scoring_percentages, dk_roo, fd_roo, dk_id_map, fd_id_map = init_baselines()
+        hold_display = roo_data
+        dk_lineups = init_DK_lineups('Regular', 'Main')
+        fd_lineups = init_FD_lineups('Regular', 'Main')
+        for key in st.session_state.keys():
+            del st.session_state[key]
+with col2:
+    with st.container():
+        col1, col2 = st.columns([3, 3])
+        with col1:
+            view_var = st.selectbox("Select view", ["Simple", "Advanced"], key='view_var')
+        with col2:
+            site_var = st.selectbox("What site do you want to view?", ('Draftkings', 'Fanduel'), key='site_var')
+        
+
+tab1, tab2, tab3 = st.tabs(["Scoring Percentages", "Player ROO", "Optimals"])
+
+roo_data, sd_roo_data, scoring_percentages, dk_roo, fd_roo, dk_id_map, fd_id_map = init_baselines()
+hold_display = roo_data
+
+with tab1:
+    st.header("Scoring Percentages")
+    with st.expander("Info and Filters"):
+        with st.container():
+            slate_var1 = st.radio("Which data are you loading?", ('Main Slate', 'Secondary Slate', 'Turbo Slate'), key='slate_var1')
+            own_var1 = st.radio("How would you like to display team ownership?", ('Sum', 'Average'), key='own_var1')
+    
+    if site_var == 'Draftkings':
+        if slate_var1 == 'Main Slate':
+            scoring_percentages = scoring_percentages[scoring_percentages['DK Main Slate'] == 1]
+        elif slate_var1 == 'Secondary Slate':
+            scoring_percentages = scoring_percentages[scoring_percentages['DK Secondary Slate'] == 1]
+        elif slate_var1 == 'Turbo Slate':
+            scoring_percentages = scoring_percentages[scoring_percentages['DK Turbo Slate'] == 1]
+    elif site_var == 'Fanduel':
+        if slate_var1 == 'Main Slate':
+            scoring_percentages = scoring_percentages[scoring_percentages['FD Main Slate'] == 1]
+        elif slate_var1 == 'Secondary Slate':
+            scoring_percentages = scoring_percentages[scoring_percentages['FD Secondary Slate'] == 1]
+        elif slate_var1 == 'Turbo Slate':
+            scoring_percentages = scoring_percentages[scoring_percentages['FD Turbo Slate'] == 1]
+
+    dk_hitters_only = dk_roo[dk_roo['pos_group'] != 'Pitchers']
+    if slate_var1 == 'Main Slate':
+        dk_hitters_only = dk_hitters_only[dk_hitters_only['Slate'] == 'main_slate']
+    elif slate_var1 == 'Secondary Slate':
+        dk_hitters_only = dk_hitters_only[dk_hitters_only['Slate'] == 'secondary_slate']
+    elif slate_var1 == 'Turbo Slate':
+        dk_hitters_only = dk_hitters_only[dk_hitters_only['Slate'] == 'turbo_slate']
+    dk_hitters_only = dk_hitters_only.replace('CWS', 'CHW')
+    dk_team_ownership = dk_hitters_only.groupby('Team')['Own%'].sum().reset_index()
+    fd_hitters_only = fd_roo[fd_roo['pos_group'] != 'Pitchers']
+    if slate_var1 == 'Main Slate':
+        fd_hitters_only = fd_hitters_only[fd_hitters_only['Slate'] == 'main_slate']
+    elif slate_var1 == 'Secondary Slate':
+        fd_hitters_only = fd_hitters_only[fd_hitters_only['Slate'] == 'secondary_slate']
+    elif slate_var1 == 'Turbo Slate':
+        fd_hitters_only = fd_hitters_only[fd_hitters_only['Slate'] == 'turbo_slate']
+    fd_hitters_only = fd_hitters_only.replace('CWS', 'CHW')
+    fd_team_ownership = fd_hitters_only.groupby('Team')['Own%'].sum().reset_index()
+    scoring_percentages = scoring_percentages.merge(dk_team_ownership, left_on='Names', right_on='Team', how='left')
+    scoring_percentages.rename(columns={'Own%': 'DK Own%'}, inplace=True)
+    scoring_percentages.drop('Team', axis=1, inplace=True)
+    scoring_percentages = scoring_percentages.merge(fd_team_ownership, left_on='Names', right_on='Team', how='left')
+    scoring_percentages.rename(columns={'Own%': 'FD Own%'}, inplace=True)
+    scoring_percentages.drop('Team', axis=1, inplace=True)
+    if site_var == 'Draftkings':
+        if slate_var1 == 'Main Slate':
+            scoring_percentages['DK LevX'] = scoring_percentages['DK Main Top Score'].rank(pct=True).astype(float) - scoring_percentages['DK Own%'].rank(pct=True).astype(float)
+            scoring_percentages = scoring_percentages.rename(columns={'DK Main Top Score': 'Top Score'})
+            scoring_percentages = scoring_percentages.drop(['DK Main Slate', 'DK Secondary Slate', 'DK Turbo Slate', 'FD Main Slate', 'FD Secondary Slate', 'FD Turbo Slate', 'FD Main Top Score', 'DK Secondary Top Score', 'FD Secondary Top Score', 'DK Turbo Top Score', 'FD Turbo Top Score'], axis=1)
+        elif slate_var1 == 'Secondary Slate':
+            scoring_percentages['DK LevX'] = scoring_percentages['DK Secondary Top Score'].rank(pct=True).astype(float) - scoring_percentages['DK Own%'].rank(pct=True).astype(float)
+            scoring_percentages = scoring_percentages.rename(columns={'DK Secondary Top Score': 'Top Score'})
+            scoring_percentages = scoring_percentages.drop(['DK Main Slate', 'DK Secondary Slate', 'DK Turbo Slate', 'FD Main Slate', 'FD Secondary Slate', 'FD Turbo Slate', 'FD Main Top Score', 'DK Main Top Score', 'FD Secondary Top Score', 'DK Turbo Top Score', 'FD Turbo Top Score'], axis=1)
+        elif slate_var1 == 'Turbo Slate':
+            scoring_percentages['DK LevX'] = scoring_percentages['DK Turbo Top Score'].rank(pct=True).astype(float) - scoring_percentages['DK Own%'].rank(pct=True).astype(float)
+            scoring_percentages = scoring_percentages.rename(columns={'DK Turbo Top Score': 'Top Score'})
+            scoring_percentages = scoring_percentages.drop(['DK Main Slate', 'DK Secondary Slate', 'DK Turbo Slate', 'FD Main Slate', 'FD Secondary Slate', 'FD Turbo Slate', 'FD Main Top Score', 'DK Main Top Score', 'FD Secondary Top Score', 'DK Secondary Top Score', 'FD Turbo Top Score'], axis=1)
+    elif site_var == 'Fanduel':
+        if slate_var1 == 'Main Slate':
+            scoring_percentages['FD LevX'] = scoring_percentages['FD Main Top Score'].rank(pct=True).astype(float) - scoring_percentages['FD Own%'].rank(pct=True).astype(float)
+            scoring_percentages = scoring_percentages.rename(columns={'FD Main Top Score': 'Top Score'})
+            scoring_percentages = scoring_percentages.drop(['DK Main Slate', 'DK Secondary Slate', 'DK Turbo Slate', 'FD Main Slate', 'FD Secondary Slate', 'FD Turbo Slate', 'DK Main Top Score', 'DK Secondary Top Score', 'FD Secondary Top Score', 'DK Turbo Top Score', 'FD Turbo Top Score'], axis=1)
+        elif slate_var1 == 'Secondary Slate':
+            scoring_percentages['FD LevX'] = scoring_percentages['FD Secondary Top Score'].rank(pct=True).astype(float) - scoring_percentages['FD Own%'].rank(pct=True).astype(float)
+            scoring_percentages = scoring_percentages.rename(columns={'FD Secondary Top Score': 'Top Score'})
+            scoring_percentages = scoring_percentages.drop(['DK Main Slate', 'DK Secondary Slate', 'DK Turbo Slate', 'FD Main Slate', 'FD Secondary Slate', 'FD Turbo Slate', 'FD Main Top Score', 'DK Main Top Score', 'DK Secondary Top Score', 'DK Turbo Top Score', 'FD Turbo Top Score'], axis=1)
+        elif slate_var1 == 'Turbo Slate':
+            scoring_percentages['FD LevX'] = scoring_percentages['FD Turbo Top Score'].rank(pct=True).astype(float) - scoring_percentages['FD Own%'].rank(pct=True).astype(float)
+            scoring_percentages = scoring_percentages.rename(columns={'FD Turbo Top Score': 'Top Score'})
+            scoring_percentages = scoring_percentages.drop(['DK Main Slate', 'DK Secondary Slate', 'DK Turbo Slate', 'FD Main Slate', 'FD Secondary Slate', 'FD Turbo Slate', 'FD Main Top Score', 'DK Main Top Score', 'FD Secondary Top Score', 'DK Secondary Top Score', 'DK Turbo Top Score'], axis=1)
+    scoring_percentages = scoring_percentages.sort_values(by='8+ runs', ascending=False)
+    if site_var == 'Draftkings':
+        scoring_percentages = scoring_percentages.rename(columns={'DK LevX': 'LevX', 'DK Own%': 'Own%', 'Avg Score': 'Runs', 'Win Percentage': 'Win%', '8+ runs': '8+ Runs'})
+        scoring_percentages = scoring_percentages.drop(['FD Own%'], axis=1)
+    elif site_var == 'Fanduel':
+        scoring_percentages = scoring_percentages.rename(columns={'FD LevX': 'LevX', 'FD Own%': 'Own%', 'Avg Score': 'Runs', 'Win Percentage': 'Win%', '8+ runs': '8+ Runs'})
+        scoring_percentages = scoring_percentages.drop(['DK Own%'], axis=1)
+    
+    if view_var == "Simple":
+        scoring_percentages = scoring_percentages[['Names', 'Runs', '8+ Runs', 'Win%', 'LevX', 'Own%']]
+        scoring_percentages = scoring_percentages.set_index('Names', drop=True)
+        st.dataframe(scoring_percentages.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(game_format, precision=2), height=750, use_container_width = True)
+    elif view_var == "Advanced":
+        scoring_percentages = scoring_percentages.set_index('Names', drop=True)
+        st.dataframe(scoring_percentages.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(game_format, precision=2), height=750, use_container_width = True)
+
+with tab2:
+    st.header("Player ROO")
+    with st.expander("Info and Filters"):
+        with st.container():
+            slate_type_var2 = st.radio("Which slate type are you loading?", ('Regular', 'Showdown'), key='slate_type_var2')
+            slate_var2 = st.radio("Which slate data are you loading?", ('Main', 'Secondary', 'Auxiliary'), key='slate_var2')
+            group_var2 = st.radio("Which position group would you like to view?", ('All', 'Pitchers', 'Hitters'), key='group_var2')
+            team_var2 = st.selectbox("Which team would you like to view?",  ['All', 'Specific'], key='team_var2')
+            if team_var2 == 'Specific':
+                team_select2 = st.multiselect("Select your team(s)", roo_data['Team'].unique(), key='team_select2')
+            else:
+                team_select2 = None
+            pos_var2 = st.selectbox("Which position(s) would you like to view?",  ['All', 'Specific'], key='pos_var2')
+            if pos_var2 == 'Specific':
+                pos_select2 = st.multiselect("Select your position(s)", roo_data['Position'].unique(), key='pos_select2')
+            else:
+                pos_select2 = None
+    if slate_type_var2 == 'Regular':
+        if site_var == 'Draftkings':
+        
+            player_roo_raw = dk_roo.copy()
+
+            if group_var2 == 'All':
+                pass
+            elif group_var2 == 'Pitchers':
+                player_roo_raw = player_roo_raw[player_roo_raw['pos_group'] == 'Pitchers']
+            elif group_var2 == 'Hitters':
+                player_roo_raw = player_roo_raw[player_roo_raw['pos_group'] == 'Hitters']
+
+        elif site_var == 'Fanduel':
+            
+            player_roo_raw = fd_roo.copy()
+
+            if group_var2 == 'All':
+                pass
+            elif group_var2 == 'Pitchers':
+                player_roo_raw = player_roo_raw[player_roo_raw['pos_group'] == 'Pitchers']
+            elif group_var2 == 'Hitters':
+                player_roo_raw = player_roo_raw[player_roo_raw['pos_group'] == 'Hitters']
+        
+        if slate_var2 == 'Main':
+            player_roo_raw = player_roo_raw[player_roo_raw['Slate'] == 'main_slate']
+        elif slate_var2 == 'Secondary':
+            player_roo_raw = player_roo_raw[player_roo_raw['Slate'] == 'secondary_slate']
+        elif slate_var2 == 'Auxiliary':
+            player_roo_raw = player_roo_raw[player_roo_raw['Slate'] == 'turbo_slate']
+            
+    elif slate_type_var2 == 'Showdown':
+        player_roo_raw = sd_roo_data.copy()
+        if site_var == 'Draftkings':
+            player_roo_raw['site'] = 'Draftkings'
+        elif site_var == 'Fanduel':
+            player_roo_raw['site'] = 'Fanduel'
+
+        if slate_var2 == 'Main':
+            player_roo_raw = player_roo_raw[player_roo_raw['slate'] == 'DK SD1']
+        elif slate_var2 == 'Secondary':
+            player_roo_raw = player_roo_raw[player_roo_raw['slate'] == 'DK SD2']
+        elif slate_var2 == 'Auxiliary':
+            player_roo_raw = player_roo_raw[player_roo_raw['slate'] == 'DK SD3']
+    
+    if team_select2:
+        player_roo_raw = player_roo_raw[player_roo_raw['Team'].isin(team_select2)]
+    if pos_select2:
+        position_mask = player_roo_raw['Position'].apply(lambda x: any(pos in x for pos in pos_select2))
+        player_roo_raw = player_roo_raw[position_mask]
+    
+    player_roo_disp = player_roo_raw
+    
+    if slate_type_var2 == 'Regular':
+        player_roo_disp = player_roo_disp.drop(columns=['Site', 'Slate', 'pos_group', 'timestamp', 'player_ID'])
+    elif slate_type_var2 == 'Showdown':
+        player_roo_disp = player_roo_disp.drop(columns=['site', 'slate', 'version', 'timestamp'])
+    
+    player_roo_disp = player_roo_disp.drop_duplicates(subset=['Player'])
+
+    if view_var == "Simple":
+        try:
+            player_roo_disp = player_roo_disp[['Player', 'Position', 'Team', 'Salary', 'Median', 'Ceiling', 'Own%']]
+            player_roo_disp = player_roo_disp.set_index('Player', drop=True)
+            st.dataframe(player_roo_disp.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(player_roo_format, precision=2), height=750, use_container_width = True)
+        except:
+            player_roo_disp = player_roo_disp.set_index('Player', drop=True)
+            st.dataframe(player_roo_disp.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(player_roo_format, precision=2), height=750, use_container_width = True)
+            
+    elif view_var == "Advanced":
+        try:
+            player_roo_disp = player_roo_disp.set_index('Player', drop=True)
+            st.dataframe(player_roo_disp.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(player_roo_format, precision=2), height=750, use_container_width = True)
+        except:
+            player_roo_disp = player_roo_disp.set_index('Player', drop=True)
+            st.dataframe(player_roo_disp.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(player_roo_format, precision=2), height=750, use_container_width = True)
+
+with tab3:
+    st.header("Optimals")
+    with st.expander("Info and Filters"):
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            slate_type_var3 = st.radio("Which slate type are you loading?", ('Regular', 'Showdown'), key='slate_type_var3')
+            if slate_type_var3 == 'Regular':
+                raw_baselines = roo_data
+            elif slate_type_var3 == 'Showdown':
+                raw_baselines = sd_roo_data
+            slate_var3 = st.radio("Which slate data are you loading?", ('Main', 'Secondary', 'Auxiliary'), key='slate_var3')
+            if slate_type_var3 == 'Regular':
+                if site_var == 'Draftkings':
+                    dk_lineups = init_DK_lineups(slate_type_var3, slate_var3)
+                elif site_var == 'Fanduel':
+                    fd_lineups = init_FD_lineups(slate_type_var3, slate_var3)
+            elif slate_type_var3 == 'Showdown':
+                if site_var == 'Draftkings':
+                    dk_lineups = init_DK_lineups(slate_type_var3, slate_var3)
+                elif site_var == 'Fanduel':
+                    fd_lineups = init_FD_lineups(slate_type_var3, slate_var3)
+        with col2:
+            lineup_num_var = st.number_input("How many lineups do you want to display?", min_value=1, max_value=1000, value=150, step=1)
+            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 = raw_baselines['Player'].unique())
+            elif player_var1 == 'Full Slate':
+                    player_var2 = raw_baselines.Player.values.tolist()
+        with col3:
+            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')
+                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_var == 'Fanduel':
+                salary_min_var = st.number_input("Minimum salary used", min_value = 0, max_value = 35000, value = 34000, step = 100, key = 'salary_min_var')
+                salary_max_var = st.number_input("Maximum salary used", min_value = 0, max_value = 35000, value = 35000, step = 100, key = 'salary_max_var')
+        
+        
+        if site_var == 'Draftkings':
+            if slate_type_var3 == 'Regular':
+                ROO_slice = raw_baselines[raw_baselines['Site'] == 'Draftkings']
+                player_salaries = dict(zip(ROO_slice['Player'], ROO_slice['Salary']))
+                column_names = dk_columns
+            elif slate_type_var3 == 'Showdown':
+                player_salaries = dict(zip(raw_baselines['Player'], raw_baselines['Salary']))
+                column_names = dk_sd_columns
+            # Get the minimum and maximum ownership values from dk_lineups
+            min_own = np.min(dk_lineups[:,12])
+            max_own = np.max(dk_lineups[:,12])
+            
+                    
+        elif site_var == 'Fanduel':
+            raw_baselines = hold_display
+            if slate_type_var3 == 'Regular':
+                ROO_slice = raw_baselines[raw_baselines['Site'] == 'Fanduel']
+                player_salaries = dict(zip(ROO_slice['Player'], ROO_slice['Salary']))
+                column_names = fd_columns
+            elif slate_type_var3 == 'Showdown':
+                player_salaries = dict(zip(raw_baselines['Player'], raw_baselines['Salary']))
+                column_names = fd_sd_columns
+            # Get the minimum and maximum ownership values from dk_lineups
+            min_own = np.min(fd_lineups[:,11])
+            max_own = np.max(fd_lineups[:,11])
+
+        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_var == 'Draftkings':
+                if slate_type_var3 == 'Regular':
+                    map_columns = ['SP1', 'SP2', 'C', '1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3']
+                elif slate_type_var3 == '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_id_map)
+            elif site_var == 'Fanduel':
+                if slate_type_var3 == 'Regular':
+                    map_columns = ['P', 'C_1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'UTIL']
+                elif slate_type_var3 == 'Showdown':
+                    map_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4']
+                for col_idx in map_columns:
+                    data_export[col_idx] = data_export[col_idx].map(fd_id_map)
+            st.download_button(
+                label="Export optimals set (IDs)",
+                data=convert_df(data_export),
+                file_name='MLB_optimals_export.csv',
+                mime='text/csv',
+            )
+            st.download_button(
+                label="Export optimals set (Names)",
+                data=convert_df(name_export),
+                file_name='MLB_optimals_export.csv',
+                mime='text/csv',
+            )
+        
+    if site_var == '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 = 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_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 = 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_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 = 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_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 = 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]
+    export_file = st.session_state.data_export_display.copy()
+    name_export = st.session_state.data_export_display.copy()
+    if site_var == 'Draftkings':
+        if slate_type_var3 == 'Regular':
+            map_columns = ['SP1', 'SP2', 'C', '1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3']
+        elif slate_type_var3 == '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_id_map)
+    elif site_var == 'Fanduel':
+        if slate_type_var3 == 'Regular':
+            map_columns = ['P', 'C_1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'UTIL']
+        elif slate_type_var3 == 'Showdown':
+            map_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4']
+        for col_idx in map_columns:
+            export_file[col_idx] = export_file[col_idx].map(fd_id_map)
+            
+    with st.container():
+        if st.button("Reset Optimals", key='reset3'):
+            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='MLB_display_optimals.csv',
+            mime='text/csv',
+        )
+        st.download_button(
+            label="Export display optimals (Names)",
+            data=convert_df(name_export),
+            file_name='MLB_display_optimals.csv',
+            mime='text/csv',
+        )
+    
+    with st.container():
+        if slate_type_var3 == '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[:,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])
+                        ],
+                        'Proj': [
+                            np.min(st.session_state.working_seed[:,11]),
+                            np.mean(st.session_state.working_seed[:,11]),
+                            np.max(st.session_state.working_seed[:,11]),
+                            np.std(st.session_state.working_seed[:,11])
+                        ],
+                        'Own': [
+                            np.min(st.session_state.working_seed[:,16]),
+                            np.mean(st.session_state.working_seed[:,16]),
+                            np.max(st.session_state.working_seed[:,16]),
+                            np.std(st.session_state.working_seed[:,16])
+                        ]
+                    })
+                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])
+                        ]
+                    })
+
+                # 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 site_var == 'Draftkings':
+                    if slate_type_var3 == 'Regular':
+                        player_columns = st.session_state.data_export_display.iloc[:, :10]
+                    elif slate_type_var3 == 'Showdown':
+                        player_columns = st.session_state.data_export_display.iloc[:, :6]
+                elif site_var == 'Fanduel':
+                    if slate_type_var3 == 'Regular':
+                        player_columns = st.session_state.data_export_display.iloc[:, :9]
+                    elif slate_type_var3 == 'Showdown':
+                        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,
+                    '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='MLB_player_frequency.csv',
+                    mime='text/csv',
+                )
+        with tab2:
+            if 'working_seed' in st.session_state:
+                if site_var == 'Draftkings':
+                    if slate_type_var3 == 'Regular':
+                        player_columns = st.session_state.working_seed[:, :10]
+                    elif slate_type_var3 == 'Showdown':
+                        player_columns = st.session_state.working_seed[:, :7]
+                elif site_var == 'Fanduel':
+                    if slate_type_var3 == 'Regular':
+                        player_columns = st.session_state.working_seed[:, :9]
+                    elif slate_type_var3 == '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='MLB_seed_frame_frequency.csv',
+                    mime='text/csv',
+                )

app.yaml

@@ -0,0 +1,10 @@
+runtime: python
+env: flex
+
+runtime_config:
+  python_version: 3
+
+entrypoint: streamlit run streamlit-app.py --server.port $PORT
+
+automatic_scaling:
+  max_num_instances: 200

requirements.txt

@@ -0,0 +1,9 @@
+streamlit
+gspread
+openpyxl
+matplotlib
+pulp
+docker
+plotly
+scipy
+pymongo