app.py

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"]
        db2 = client["MLB_DFS"]

        return db, db2
    
db, db2 = init_conn()

game_format = {'Win Percentage': '{:.2%}','First Inning Lead Percentage': '{:.2%}', 'Top Score': '{:.2%}',
              'Fifth Inning Lead Percentage': '{:.2%}', '8+ runs': '{:.2%}', 'DK LevX': '{:.2%}', 'FD 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']

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']
    fd_roo = roo_data[roo_data['Site'] == 'Fanduel']

    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', 'Slate', '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['Top Score'] = scoring_percentages['Top Score'].replace('', np.nan).astype(float)
    dk_hitters_only = dk_roo[dk_roo['pos_group'] != 'Pitchers']
    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']
    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)
    scoring_percentages['DK LevX'] = scoring_percentages['Top Score'].rank(pct=True).astype(float) - scoring_percentages['DK Own%'].rank(pct=True).astype(float)
    scoring_percentages['FD LevX'] = scoring_percentages['Top Score'].rank(pct=True).astype(float) - scoring_percentages['FD Own%'].rank(pct=True).astype(float)
    
    return roo_data, sd_roo_data, scoring_percentages, dk_roo, fd_roo

@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 = db2['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', 'Own']]
        elif slate_var == 'Secondary':
            collection = db2['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', 'Own']]
        elif slate_var == 'Auxiliary':
            collection = db2['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', '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']
                # 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']
                # 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']
                # 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 = db2['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', 'Own']]
            elif slate_var == 'Secondary':
                collection = db2['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', 'Own']]
            elif slate_var == 'Auxiliary':
                collection = db2['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', '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 = 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 = 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', 'All Games'), key='slate_var1')
            own_var1 = st.radio("How would you like to display team ownership?", ('Sum', 'Average'), key='own_var1')
    
    if slate_var1 == 'Main Slate':
        scoring_percentages = scoring_percentages[scoring_percentages['Slate'] == 'Main']
    elif slate_var1 != 'Main Slate':
        pass

    scoring_percentages = scoring_percentages.sort_values(by='8+ runs', ascending=False)
    scoring_percentages = scoring_percentages.drop('Slate', axis=1)
    
    if view_var == "Simple":
        scoring_percentages = scoring_percentages[['Names', 'Avg Score', '8+ runs', 'Win Percentage']]
        st.dataframe(scoring_percentages.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(game_format, precision=2), height=750, use_container_width = True, hide_index=True)
    elif view_var == "Advanced":
        st.dataframe(scoring_percentages.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(game_format, precision=2), height=750, use_container_width = True, hide_index=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 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'])

    if view_var == "Simple":
        try:
            player_roo_disp = player_roo_disp[['Player', 'Position', 'Salary', 'Median', 'Ceiling', 'Own%']]
            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, hide_index=True)
        except:
            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, hide_index=True)
    elif view_var == "Advanced":
        try:
            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, hide_index=True)
        except:
            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, hide_index=True)

with tab3:
    st.header("Optimals")
    with st.expander("Info and Filters"):
        with st.container():
            slate_type_var3 = st.radio("Which slate type are you loading?", ('Regular', 'Showdown'), key='slate_type_var3')
            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)
        lineup_num_var = st.number_input("How many lineups do you want to display?", min_value=1, max_value=1000, value=150, step=1)
        
        if slate_type_var3 == 'Regular':
                raw_baselines = roo_data
        elif slate_type_var3 == 'Showdown':
            raw_baselines = sd_roo_data
        
        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']))
            elif slate_type_var3 == 'Showdown':
                player_salaries = dict(zip(raw_baselines['Player'], raw_baselines['Salary']))
            # Get the minimum and maximum ownership values from dk_lineups
            min_own = np.min(dk_lineups[:,8])
            max_own = np.max(dk_lineups[:,8])
            column_names = dk_columns
            
            player_var1 = st.radio("Do you want a frame with specific Players?", ('Full Slate', 'Specific Players'), key='player_var1')
            if player_var1 == 'Specific Players':
                    player_var2 = st.multiselect('Which players do you want?', options = raw_baselines['Player'].unique())
            elif player_var1 == 'Full Slate':
                    player_var2 = raw_baselines.Player.values.tolist()
                    
        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']))
            elif slate_type_var3 == 'Showdown':
                player_salaries = dict(zip(raw_baselines['Player'], raw_baselines['Salary']))
            min_own = np.min(fd_lineups[:,8])
            max_own = np.max(fd_lineups[:,8])
            column_names = fd_columns
            
            player_var1 = st.radio("Do you want a frame with specific Players?", ('Full Slate', 'Specific Players'), key='player_var1')
            if player_var1 == 'Specific Players':
                    player_var2 = st.multiselect('Which players do you want?', options = raw_baselines['Player'].unique())
            elif player_var1 == 'Full Slate':
                    player_var2 = raw_baselines.Player.values.tolist()

        if st.button("Prepare data export", key='data_export'):
            data_export = st.session_state.working_seed.copy()
            # if site_var == 'Draftkings':
            #     for col_idx in range(6):
            #         data_export[:, col_idx] = np.array([id_dict.get(player, player) for player in data_export[:, col_idx]])
            # elif site_var == 'Fanduel':
            #     for col_idx in range(6):
            #         data_export[:, col_idx] = np.array([id_dict.get(player, player) for player in data_export[:, col_idx]])
            st.download_button(
                label="Export optimals set",
                data=convert_df(data_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)

    export_file = st.session_state.data_export_display.copy()
    # if site_var == 'Draftkings':
    #     for col_idx in range(6):
    #         export_file.iloc[:, col_idx] = export_file.iloc[:, col_idx].map(id_dict)
    # elif site_var == 'Fanduel':
    #     for col_idx in range(6):
    #         export_file.iloc[:, col_idx] = export_file.iloc[:, col_idx].map(id_dict)
            
    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",
            data=convert_df(export_file),
            file_name='MLB_display_optimals.csv',
            mime='text/csv',
        )
    
    with st.container():
        if 'working_seed' in st.session_state:
            # Create a new dataframe with summary statistics
            if site_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':
                    player_columns = st.session_state.data_export_display.iloc[:, :10]
                elif site_var == 'Fanduel':
                    player_columns = st.session_state.data_export_display.iloc[:, :9]
                
                # 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':
                    player_columns = st.session_state.working_seed[:, :10]
                elif site_var == 'Fanduel':
                    player_columns = st.session_state.working_seed[:, :9]
                
                # 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',
                )