app.py

import streamlit as st
import numpy as np
import pandas as pd
import gspread
import plotly.express as px
st.set_page_config(layout="wide")

@st.cache_resource
def init_conn():
          scope = ['https://www.googleapis.com/auth/spreadsheets',
                    "https://www.googleapis.com/auth/drive"]
          
          credentials = {
            "type": "service_account",
            "project_id": "sheets-api-connect-378620",
            "private_key_id": "1005124050c80d085e2c5b344345715978dd9cc9",
            "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCtKa01beXwc88R\nnPZVQTNPVQuBnbwoOfc66gW3547ja/UEyIGAF112dt/VqHprRafkKGmlg55jqJNt\na4zceLKV+wTm7vBu7lDISTJfGzCf2TrxQYNqwMKE2LOjI69dBM8u4Dcb4k0wcp9v\ntW1ZzLVVuwTvmrg7JBHjiSaB+x5wxm/r3FOiJDXdlAgFlytzqgcyeZMJVKKBQHyJ\njEGg/1720A0numuOCt71w/2G0bDmijuj1e6tH32MwRWcvRNZ19K9ssyDz2S9p68s\nYDhIxX69OWxwScTIHLY6J2t8txf/XMivL/636fPlDADvBEVTdlT606n8CcKUVQeq\npUVdG+lfAgMBAAECggEAP38SUA7B69eTfRpo658ycOs3Amr0JW4H/bb1rNeAul0K\nZhwd/HnU4E07y81xQmey5kN5ZeNrD5EvqkZvSyMJHV0EEahZStwhjCfnDB/cxyix\nZ+kFhv4y9eK+kFpUAhBy5nX6T0O+2T6WvzAwbmbVsZ+X8kJyPuF9m8ldcPlD0sce\ntj8NwVq1ys52eosqs7zi2vjt+eMcaY393l4ls+vNq8Yf27cfyFw45W45CH/97/Nu\n5AmuzlCOAfFF+z4OC5g4rei4E/Qgpxa7/uom+BVfv9G0DIGW/tU6Sne0+37uoGKt\nW6DzhgtebUtoYkG7ZJ05BTXGp2lwgVcNRoPwnKJDxQKBgQDT5wYPUBDW+FHbvZSp\nd1m1UQuXyerqOTA9smFaM8sr/UraeH85DJPEIEk8qsntMBVMhvD3Pw8uIUeFNMYj\naLmZFObsL+WctepXrVo5NB6RtLB/jZYxiKMatMLUJIYtcKIp+2z/YtKiWcLnwotB\nWdCjVnPTxpkurmF2fWP/eewZ+wKBgQDRMtJg7etjvKyjYNQ5fARnCc+XsI3gkBe1\nX9oeXfhyfZFeBXWnZzN1ITgFHplDznmBdxAyYGiQdbbkdKQSghviUQ0igBvoDMYy\n1rWcy+a17Mj98uyNEfmb3X2cC6WpvOZaGHwg9+GY67BThwI3FqHIbyk6Ko09WlTX\nQpRQjMzU7QKBgAfi1iflu+q0LR+3a3vvFCiaToskmZiD7latd9AKk2ocsBd3Woy9\n+hXXecJHPOKV4oUJlJgvAZqe5HGBqEoTEK0wyPNLSQlO/9ypd+0fEnArwFHO7CMF\nycQprAKHJXM1eOOFFuZeQCaInqdPZy1UcV5Szla4UmUZWkk1m24blHzXAoGBAMcA\nyH4qdbxX9AYrC1dvsSRvgcnzytMvX05LU0uF6tzGtG0zVlub4ahvpEHCfNuy44UT\nxRWW/oFFaWjjyFxO5sWggpUqNuHEnRopg3QXx22SRRTGbN45li/+QAocTkgsiRh1\nqEcYZsO4mPCsQqAy6E2p6RcK+Xa+omxvSnVhq0x1AoGAKr8GdkCl4CF6rieLMAQ7\nLNBuuoYGaHoh8l5E2uOQpzwxVy/nMBcAv+2+KqHEzHryUv1owOi6pMLv7A9mTFoS\n18B0QRLuz5fSOsVnmldfC9fpUc6H8cH1SINZpzajqQA74bPwELJjnzrCnH79TnHG\nJuElxA33rFEjbgbzdyrE768=\n-----END PRIVATE KEY-----\n",
            "client_email": "gspread-connection@sheets-api-connect-378620.iam.gserviceaccount.com",
            "client_id": "106625872877651920064",
            "auth_uri": "https://accounts.google.com/o/oauth2/auth",
            "token_uri": "https://oauth2.googleapis.com/token",
            "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
            "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/gspread-connection%40sheets-api-connect-378620.iam.gserviceaccount.com"
          }

          gc = gspread.service_account_from_dict(credentials)
          return gc

gspreadcon = init_conn()

game_format = {'Win%': '{:.2%}', 'Vegas': '{:.2%}', 'Win% Diff': '{:.2%}'}
american_format = {'First Inning Lead Percentage': '{:.2%}', 'Fifth Inning Lead Percentage': '{:.2%}'}

master_hold = 'https://docs.google.com/spreadsheets/d/1I_1Ve3F4tftgfLQQoRKOJ351XfEG48s36OxXUKxmgS8/edit#gid=694077504'

@st.cache_resource(ttl=299)
def init_baselines():
    sh = gspreadcon.open_by_url(master_hold)
    worksheet = sh.worksheet('Game_Betting')
    raw_display = pd.DataFrame(worksheet.get_all_records())
    raw_display.replace('#DIV/0!', np.nan, inplace=True)
    game_model = raw_display.copy()
    
    worksheet = sh.worksheet('Prop_Table')
    raw_display = pd.DataFrame(worksheet.get_all_records())
    raw_display.replace('', np.nan, inplace=True)
    overall_stats = raw_display.dropna()
    
    worksheet = sh.worksheet('prop_frame')
    raw_display = pd.DataFrame(worksheet.get_all_records())
    raw_display.replace('', np.nan, inplace=True)
    prop_trends = raw_display.copy()
    
    worksheet = sh.worksheet('DK_ROO')
    timestamp = worksheet.acell('U2').value
    
    worksheet = sh.worksheet('prop_frame')
    raw_display = pd.DataFrame(worksheet.get_all_records())
    raw_display.replace('', np.nan, inplace=True)
    raw_display.replace('#DIV/0!', np.nan, inplace=True)
    prop_frame = raw_display.copy()
    
    worksheet = sh.worksheet('Pick6_ingest')
    raw_display = pd.DataFrame(worksheet.get_all_records())
    raw_display.replace('', np.nan, inplace=True)
    pick_frame = raw_display.dropna(subset='Player')

    return game_model, overall_stats, timestamp, prop_frame, prop_trends, pick_frame

game_model, overall_stats, timestamp, prop_frame, prop_trends, pick_frame = init_baselines()
qb_stats = overall_stats.loc[overall_stats['Position'] == 'QB']
non_qb_stats = overall_stats.loc[overall_stats['Position'] != 'QB']
team_dict = dict(zip(prop_frame['Player'], prop_frame['Team']))
t_stamp = f"Last Update: " + str(timestamp) + f" CST"

prop_table_options = ['NFL_GAME_PLAYER_RUSHING_YARDS', 'NFL_GAME_PLAYER_RECEIVING_YARDS', 'NFL_GAME_PLAYER_PASSING_YARDS', 'NFL_GAME_PLAYER_RECEIVING_RECEPTIONS', 'NFL_GAME_PLAYER_RUSHING_ATTEMPTS', 'NFL_GAME_PLAYER_PASSING_ATTEMPTS']
prop_format = {'L3 Success': '{:.2%}', 'L6_Success': '{:.2%}', 'L10_success': '{:.2%}', 'Trending Over': '{:.2%}', 'Trending Under': '{:.2%}',
               'Implied Over': '{:.2%}', 'Implied Under': '{:.2%}', 'Over Edge': '{:.2%}', 'Under Edge': '{:.2%}'}
all_sim_vars = ['NFL_GAME_PLAYER_PASSING_YARDS', 'NFL_GAME_PLAYER_RUSHING_YARDS', 'NFL_GAME_PLAYER_RECEIVING_YARDS', 'NFL_GAME_PLAYER_RECEIVING_RECEPTIONS', 'NFL_GAME_PLAYER_RUSHING_ATTEMPTS', 'NFL_GAME_PLAYER_PASSING_ATTEMPTS']
sim_all_hold = pd.DataFrame(columns=['Player', 'Team', 'Prop type', 'Prop', 'Mean_Outcome', 'Imp Over', 'Over%', 'Imp Under', 'Under%', 'Bet?', 'Edge'])

tab1, tab2, tab3, tab4, tab5, tab6 = st.tabs(["Game Betting Model", "QB Projections", "RB/WR/TE Projections", "Player Prop Trends", "Player Prop Simulations", "Stat Specific Simulations"])

def convert_df_to_csv(df):
    return df.to_csv().encode('utf-8')

with tab1:
    st.info(t_stamp)
    if st.button("Reset Data", key='reset1'):
              st.cache_data.clear()
              game_model, overall_stats, timestamp, prop_frame, prop_trends, pick_frame = init_baselines()
              qb_stats = overall_stats.loc[overall_stats['Position'] == 'QB']
              non_qb_stats = overall_stats.loc[overall_stats['Position'] != 'QB']
              team_dict = dict(zip(prop_frame['Player'], prop_frame['Team']))
              t_stamp = f"Last Update: " + str(timestamp) + f" CST"
    line_var1 = st.radio('How would you like to display odds?', options = ['Percentage', 'American'], key='line_var1')
    team_frame = game_model
    if line_var1 == 'Percentage':
        team_frame = team_frame[['Team', 'Opp', 'Win%', 'Vegas', 'Win% Diff', 'PD Spread', 'Vegas Spread', 'Spread Diff']]
        team_frame = team_frame.set_index('Team')
        st.dataframe(team_frame.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(game_format, precision=2), use_container_width = True)
    if line_var1 == 'American':
        team_frame = team_frame[['Team', 'Opp', 'Win Line', 'Vegas Line', 'Line Diff', 'PD Spread', 'Vegas Spread', 'Spread Diff']]
        team_frame = team_frame.set_index('Team')
        st.dataframe(team_frame.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(precision=2), height = 1000, use_container_width = True)
    
    st.download_button(
        label="Export Team Model",
        data=convert_df_to_csv(team_frame),
        file_name='NFL_team_betting_export.csv',
        mime='text/csv',
        key='team_export',
    )

with tab2:
    st.info(t_stamp)
    if st.button("Reset Data", key='reset2'):
              st.cache_data.clear()
              game_model, overall_stats, timestamp, prop_frame, prop_trends, pick_frame = init_baselines()
              qb_stats = overall_stats.loc[overall_stats['Position'] == 'QB']
              non_qb_stats = overall_stats.loc[overall_stats['Position'] != 'QB']
              team_dict = dict(zip(prop_frame['Player'], prop_frame['Team']))
              t_stamp = f"Last Update: " + str(timestamp) + f" CST"
    split_var1 = st.radio("Would you like to view all teams or specific ones?", ('All', 'Specific Teams'), key='split_var1')
    if split_var1 == 'Specific Teams':
        team_var1 = st.multiselect('Which teams would you like to include in the tables?', options = qb_stats['Team'].unique(), key='team_var1')
    elif split_var1 == 'All':
        team_var1 = qb_stats.Team.values.tolist()
    qb_stats = qb_stats[qb_stats['Team'].isin(team_var1)]
    qb_stats_disp = qb_stats.set_index('Player')
    qb_stats_disp = qb_stats_disp.sort_values(by='PPR', ascending=False)
    st.dataframe(qb_stats_disp.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(precision=2), height = 1000, use_container_width = True)
    st.download_button(
        label="Export Prop Model",
        data=convert_df_to_csv(qb_stats_disp),
        file_name='NFL_qb_stats_export.csv',
        mime='text/csv',
        key='NFL_qb_stats_export',
    )

with tab3:
    st.info(t_stamp)
    if st.button("Reset Data", key='reset3'):
              st.cache_data.clear()
              game_model, overall_stats, timestamp, prop_frame, prop_trends, pick_frame = init_baselines()
              qb_stats = overall_stats.loc[overall_stats['Position'] == 'QB']
              non_qb_stats = overall_stats.loc[overall_stats['Position'] != 'QB']
              team_dict = dict(zip(prop_frame['Player'], prop_frame['Team']))
              t_stamp = f"Last Update: " + str(timestamp) + f" CST"
    split_var2 = st.radio("Would you like to view all teams or specific ones?", ('All', 'Specific Teams'), key='split_var2')
    if split_var2 == 'Specific Teams':
        team_var2 = st.multiselect('Which teams would you like to include in the tables?', options = non_qb_stats['Team'].unique(), key='team_var2')
    elif split_var2 == 'All':
        team_var2 = non_qb_stats.Team.values.tolist()
    non_qb_stats = non_qb_stats[non_qb_stats['Team'].isin(team_var2)]
    non_qb_stats_disp = non_qb_stats.set_index('Player')
    non_qb_stats_disp = non_qb_stats_disp.sort_values(by='PPR', ascending=False)
    st.dataframe(non_qb_stats_disp.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(precision=2), height = 1000, use_container_width = True)
    st.download_button(
        label="Export Prop Model",
        data=convert_df_to_csv(non_qb_stats_disp),
        file_name='NFL_nonqb_stats_export.csv',
        mime='text/csv',
        key='NFL_nonqb_stats_export',
    )
    
with tab4:
    st.info(t_stamp)
    if st.button("Reset Data", key='reset4'):
              st.cache_data.clear()
              game_model, overall_stats, timestamp, prop_frame, prop_trends, pick_frame = init_baselines()
              qb_stats = overall_stats.loc[overall_stats['Position'] == 'QB']
              non_qb_stats = overall_stats.loc[overall_stats['Position'] != 'QB']
              team_dict = dict(zip(prop_frame['Player'], prop_frame['Team']))
              t_stamp = f"Last Update: " + str(timestamp) + f" CST"
    split_var5 = st.radio("Would you like to view all teams or specific ones?", ('All', 'Specific Teams'), key='split_var5')
    if split_var5 == 'Specific Teams':
        team_var5 = st.multiselect('Which teams would you like to include in the tables?', options = prop_trends['Team'].unique(), key='team_var5')
    elif split_var5 == 'All':
        team_var5 = prop_trends.Team.values.tolist()
    prop_type_var2 = st.selectbox('Select type of prop are you wanting to view', options = prop_table_options)
    book_var2 = st.selectbox('Select type of book do you want to view?', options = ['FANDUEL', 'BET365', 'DRAFTKINGS', 'CONSENSUS'])
    prop_frame_disp = prop_trends[prop_trends['Team'].isin(team_var5)]
    prop_frame_disp = prop_frame_disp[prop_frame_disp['book'] == book_var2]
    prop_frame_disp = prop_frame_disp[prop_frame_disp['prop_type'] == prop_type_var2]
    prop_frame_disp = prop_frame_disp.set_index('Player')
    prop_frame_disp = prop_frame_disp.sort_values(by='Trending Over', ascending=False)
    st.dataframe(prop_frame_disp.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(prop_format, precision=2), height = 1000, use_container_width = True)
    st.download_button(
        label="Export Prop Trends Model",
        data=convert_df_to_csv(prop_frame_disp),
        file_name='NFL_prop_trends_export.csv',
        mime='text/csv',
    )

with tab5:
    st.info(t_stamp)
    if st.button("Reset Data", key='reset5'):
              st.cache_data.clear()
              game_model, overall_stats, timestamp, prop_frame, prop_trends, pick_frame = init_baselines()
              qb_stats = overall_stats.loc[overall_stats['Position'] == 'QB']
              non_qb_stats = overall_stats.loc[overall_stats['Position'] != 'QB']
              team_dict = dict(zip(prop_frame['Player'], prop_frame['Team']))
              t_stamp = f"Last Update: " + str(timestamp) + f" CST"
    col1, col2 = st.columns([1, 5])
    
    with col2:
        df_hold_container = st.empty()
        info_hold_container = st.empty()
        plot_hold_container = st.empty()
    
    with col1:
        player_check = st.selectbox('Select player to simulate props', options = overall_stats['Player'].unique())
        prop_type_var = st.selectbox('Select type of prop to simulate', options = ['Pass Yards', 'Pass TDs', 'Rush Yards', 'Rush TDs', 'Receptions', 'Rec Yards', 'Rec TDs', 'Fantasy', 'FD Fantasy', 'PrizePicks'])

        ou_var = st.selectbox('Select wether it is an over or under', options = ['Over', 'Under'])
        if prop_type_var == 'Pass Yards':
            prop_var = st.number_input('Type in the prop offered (i.e 5.5)', min_value = 100.0, max_value = 400.5, value = 250.5, step = .5)
        elif prop_type_var == 'Pass TDs':
            prop_var = st.number_input('Type in the prop offered (i.e 5.5)', min_value = 0.0, max_value = 5.5, value = 1.5, step = .5)
        elif prop_type_var == 'Rush Yards':
            prop_var = st.number_input('Type in the prop offered (i.e 5.5)', min_value = 0.0, max_value = 155.5, value = 25.5, step = .5)
        elif prop_type_var == 'Rush TDs':
            prop_var = st.number_input('Type in the prop offered (i.e 5.5)', min_value = 0.0, max_value = 5.5, value = 1.5, step = .5)
        elif prop_type_var == 'Receptions':
            prop_var = st.number_input('Type in the prop offered (i.e 5.5)', min_value = 0.0, max_value = 15.5, value = 5.5, step = .5)
        elif prop_type_var == 'Rec Yards':
            prop_var = st.number_input('Type in the prop offered (i.e 5.5)', min_value = 0.0, max_value = 155.5, value = 25.5, step = .5)
        elif prop_type_var == 'Rec TDs':
            prop_var = st.number_input('Type in the prop offered (i.e 5.5)', min_value = 0.0, max_value = 5.5, value = 1.5, step = .5)
        elif prop_type_var == 'Fantasy':
            prop_var = st.number_input('Type in the prop offered (i.e 5.5)', min_value = 0.0, max_value = 50.5, value = 10.5, step = .5)
        elif prop_type_var == 'FD Fantasy':
            prop_var = st.number_input('Type in the prop offered (i.e 5.5)', min_value = 0.0, max_value = 50.5, value = 10.5, step = .5)
        elif prop_type_var == 'PrizePicks':
            prop_var = st.number_input('Type in the prop offered (i.e 5.5)', min_value = 0.0, max_value = 50.5, value = 10.5, step = .5)
        line_var = st.number_input('Type in the line on the prop (i.e. -120)', min_value = -1000, max_value = 1000, value = -150, step = 1)
        line_var = line_var + 1

        if st.button('Simulate Prop'):
            with col2:
                   
                    with df_hold_container.container():

                        df = overall_stats

                        total_sims = 5000

                        df.replace("", 0, inplace=True)

                        player_var = df.loc[df['Player'] == player_check]
                        player_var = player_var.reset_index()
                        
                        if prop_type_var == 'Pass Yards':
                            df['Median'] = df['pass_yards']
                        elif prop_type_var == 'Pass TDs':
                            df['Median'] = df['pass_tds']
                        elif prop_type_var == 'Rush Yards':
                            df['Median'] = df['rush_yards']
                        elif prop_type_var == 'Rush TDs':
                            df['Median'] = df['rush_tds']
                        elif prop_type_var == 'Receptions':
                            df['Median'] = df['rec']
                        elif prop_type_var == 'Rec Yards':
                            df['Median'] = df['rec_yards']
                        elif prop_type_var == 'Rec TDs':
                            df['Median'] = df['rec_tds']
                        elif prop_type_var == 'Fantasy':
                            df['Median'] = df['PPR']
                        elif prop_type_var == 'FD Fantasy':
                            df['Median'] = df['Half_PPF']
                        elif prop_type_var == 'PrizePicks':
                            df['Median'] = df['Half_PPF']

                        flex_file = df
                        flex_file['Floor'] = flex_file['Median'] * .25
                        flex_file['Ceiling'] = flex_file['Median'] + (flex_file['Median'] * 1.75)
                        flex_file['STD'] = flex_file['Median'] / 4
                        flex_file = flex_file[['Player', 'Floor', 'Median', 'Ceiling', 'STD']]

                        hold_file = flex_file
                        overall_file = flex_file
                        salary_file = flex_file

                        overall_players = overall_file[['Player']]

                        for x in range(0,total_sims):
                            overall_file[x] = np.random.normal(overall_file['Median'],overall_file['STD'])

                        overall_file=overall_file.drop(['Player', 'Floor', 'Median', 'Ceiling', 'STD'], axis=1)
                        overall_file.astype('int').dtypes

                        players_only = hold_file[['Player']]

                        player_outcomes = pd.merge(players_only, overall_file, left_index=True, right_index=True)

                        players_only['Mean_Outcome'] = overall_file.mean(axis=1)
                        players_only['10%'] = overall_file.quantile(0.1, axis=1)
                        players_only['90%'] = overall_file.quantile(0.9, axis=1)
                        if ou_var == 'Over':
                            players_only['beat_prop'] = overall_file[overall_file > prop_var].count(axis=1)/float(total_sims)
                        elif ou_var == 'Under':
                            players_only['beat_prop'] = (overall_file[overall_file < prop_var].count(axis=1)/float(total_sims))

                        players_only['implied_odds'] = np.where(line_var <= 0, (-(line_var)/((-(line_var))+100)), 100/(line_var+100))

                        players_only['Player'] = hold_file[['Player']]

                        final_outcomes = players_only[['Player', '10%', 'Mean_Outcome', '90%', 'implied_odds', 'beat_prop']]
                        final_outcomes['Bet?'] = np.where(final_outcomes['beat_prop'] - final_outcomes['implied_odds'] >= .10, "Bet", "No Bet")
                        final_outcomes = final_outcomes.loc[final_outcomes['Player'] == player_check]
                        player_outcomes = player_outcomes.loc[player_outcomes['Player'] == player_check]
                        player_outcomes = player_outcomes.drop(columns=['Player']).transpose()
                        player_outcomes = player_outcomes.reset_index()
                        player_outcomes.columns = ['Instance', 'Outcome']

                        x1 = player_outcomes.Outcome.to_numpy()

                        print(x1)

                        hist_data = [x1]

                        group_labels = ['player outcomes']

                        fig = px.histogram(
                                player_outcomes, x='Outcome')
                        fig.add_vline(x=prop_var, line_dash="dash", line_color="green")

                        with df_hold_container:
                            df_hold_container = st.empty()
                            format_dict = {'10%': '{:.2f}', 'Mean_Outcome': '{:.2f}','90%': '{:.2f}', 'beat_prop': '{:.2%}','implied_odds': '{:.2%}'}
                            st.dataframe(final_outcomes.style.format(format_dict), use_container_width = True)

                        with info_hold_container:
                            st.info('The Y-axis is the percent of times in simulations that the player reaches certain thresholds, while the X-axis is the threshold to be met. The Green dotted line is the prop you entered. You can hover over any spot and see the percent to reach that mark.')

                        with plot_hold_container:
                            st.dataframe(player_outcomes, use_container_width = True)
                            plot_hold_container = st.empty()
                            st.plotly_chart(fig, use_container_width=True)

with tab6:
    st.info(t_stamp)
    st.info('The Over and Under percentages are a compositve percentage based on simulations, historical performance, and implied probabilities, and may be different than you would expect based purely on the median projection. Likewise, the Edge of a bet is not the only indicator of if you should make the bet or not as the suggestion is using a base acceptable threshold to determine how much edge you should have for each stat category.')
    if st.button("Reset Data/Load Data", key='reset6'):
              st.cache_data.clear()
              game_model, overall_stats, timestamp, prop_frame, prop_trends, pick_frame = init_baselines()
              qb_stats = overall_stats.loc[overall_stats['Position'] == 'QB']
              non_qb_stats = overall_stats.loc[overall_stats['Position'] != 'QB']
              team_dict = dict(zip(prop_frame['Player'], prop_frame['Team']))
              t_stamp = f"Last Update: " + str(timestamp) + f" CST"
    col1, col2 = st.columns([1, 5])
    
    with col2:
        df_hold_container = st.empty()
        info_hold_container = st.empty()
        plot_hold_container = st.empty()
        export_container = st.empty()
    
    with col1:
        game_select_var = st.selectbox('Select prop source', options = ['Aggregate', 'Pick6'])
        if game_select_var == 'Aggregate':
            prop_df = prop_frame[['Player', 'book', 'over_prop', 'over_line', 'under_line', 'prop_type']]
        elif game_select_var == 'Pick6':
            prop_df = pick_frame[['Full_name', 'book', 'over_prop', 'over_line', 'under_line', 'prop_type']]
            prop_df.rename(columns={"Full_name": "Player"}, inplace = True)
        st.download_button(
            label="Download Prop Source",
            data=convert_df_to_csv(prop_df),
            file_name='Nba_prop_source.csv',
            mime='text/csv',
            key='prop_source',
        )
        prop_type_var = st.selectbox('Select prop category', options = ['All Props', 'pass_yards', 'rush_yards', 'rec_yards', 'receptions', 'rush_attempts'])

        if st.button('Simulate Prop Category'):
            with col2:
                   
                    with df_hold_container.container():
                        if prop_type_var == 'All Props':
                            for prop in all_sim_vars:
                                
                                if game_select_var == 'Aggregate':
                                    prop_df = prop_frame[['Player', 'book', 'over_prop', 'over_line', 'under_line', 'prop_type']]
                                elif game_select_var == 'Pick6':
                                    prop_df = pick_frame[['Full_name', 'book', 'over_prop', 'over_line', 'under_line', 'prop_type']]
                                    prop_df.rename(columns={"Full_name": "Player"}, inplace = True)
                                prop_df = prop_df.loc[prop_df['prop_type'] == prop]
                                prop_df = prop_df[~((prop_df['over_prop'] < 10) & (prop_df['prop_type'] == 'NFL_GAME_PLAYER_RUSHING_YARDS'))]
                                prop_df = prop_df[prop_df['book'].isin(['FANDUEL', 'DRAFTKINGS', 'BET365', 'CONSENSUS'])]
                                prop_df = prop_df[['Player', 'book', 'over_prop', 'over_line', 'under_line']]
                                prop_df.rename(columns={"over_prop": "Prop"}, inplace = True)
                                prop_df = prop_df.loc[prop_df['Prop'] != 0]
                                st.table(prop_df)
                                prop_df['Over'] = 1 / prop_df['over_line']
                                prop_df['Under'] = 1 / prop_df['under_line']
                                df = pd.merge(overall_stats, prop_df, how='left', left_on=['Player'], right_on = ['Player'])
                                
                                prop_dict = dict(zip(df.Player, df.Prop))
                                book_dict = dict(zip(df.Player, df.book))
                                over_dict = dict(zip(df.Player, df.Over))
                                under_dict = dict(zip(df.Player, df.Under))
                                
                                total_sims = 5000
        
                                df.replace("", 0, inplace=True)
        
                                if prop == "pass_yards":
                                    df['Median'] = df['NFL_GAME_PLAYER_PASSING_YARDS']
                                elif prop == "rush_yards":
                                    df['Median'] = df['NFL_GAME_PLAYER_RUSHING_YARDS']
                                elif prop == "rec_yards":
                                    df['Median'] = df['NFL_GAME_PLAYER_RECEIVING_YARDS']
                                elif prop == "receptions":
                                    df['Median'] = df['NFL_GAME_PLAYER_RECEIVING_RECEPTIONS']
                                elif prop == "rush_attempts":
                                    df['Median'] = df['NFL_GAME_PLAYER_RUSHING_ATTEMPTS']
        
                                flex_file = df
                                flex_file['Floor'] = flex_file['Median'] * .25
                                flex_file['Ceiling'] = flex_file['Median'] + (flex_file['Median'] * 1.75)
                                flex_file['STD'] = flex_file['Median'] / 4
                                flex_file['Prop'] = flex_file['Player'].map(prop_dict)
                                flex_file = flex_file[['Player', 'book', 'Prop', 'Floor', 'Median', 'Ceiling', 'STD']]
        
                                hold_file = flex_file
                                overall_file = flex_file
                                prop_file = flex_file
                                      
                                overall_players = overall_file[['Player']]
        
                                for x in range(0,total_sims):    
                                    prop_file[x] = prop_file['Prop']
        
                                prop_file = prop_file.drop(['Player', 'book', 'Prop', 'Floor', 'Median', 'Ceiling', 'STD'], axis=1)
        
                                for x in range(0,total_sims):
                                    overall_file[x] = np.random.normal(overall_file['Median'],overall_file['STD'])
        
                                overall_file=overall_file.drop(['Player', 'Prop', 'Floor', 'Median', 'Ceiling', 'STD'], axis=1)
        
                                players_only = hold_file[['Player']]
        
                                player_outcomes = pd.merge(players_only, overall_file, left_index=True, right_index=True)
        
                                prop_check = (overall_file - prop_file)
        
                                players_only['Mean_Outcome'] = overall_file.mean(axis=1)
                                players_only['10%'] = overall_file.quantile(0.1, axis=1)
                                players_only['90%'] = overall_file.quantile(0.9, axis=1)
                                players_only['Over'] = prop_check[prop_check > 0].count(axis=1)/float(total_sims)
                                players_only['Imp Over'] = players_only['Player'].map(over_dict)
                                players_only['Over%'] = players_only[["Over", "Imp Over"]].mean(axis=1)
                                players_only['Under'] = prop_check[prop_check < 0].count(axis=1)/float(total_sims)
                                players_only['Imp Under'] = players_only['Player'].map(under_dict)
                                players_only['Under%'] = players_only[["Under", "Imp Under"]].mean(axis=1)
                                players_only['Prop'] = players_only['Player'].map(prop_dict)
                                players_only['Book'] = players_only['Player'].map(book_dict)
                                players_only['Prop_avg'] = players_only['Prop'].mean() / 100
                                players_only['prop_threshold'] = .10
                                players_only = players_only.loc[players_only['Mean_Outcome'] > 0]
                                players_only['Over_diff'] = players_only['Over%'] - players_only['Imp Over']
                                players_only['Under_diff'] = players_only['Under%'] - players_only['Imp Under']
                                players_only['Bet_check'] = np.where(players_only['Over_diff'] > players_only['Under_diff'], players_only['Over_diff'] , players_only['Under_diff'])
                                players_only['Bet_suggest'] = np.where(players_only['Over_diff'] > players_only['Under_diff'], "Over" , "Under")
                                players_only['Bet?'] = np.where(players_only['Bet_check'] >= players_only['prop_threshold'], players_only['Bet_suggest'], "No Bet")
                                players_only['Edge'] = players_only['Bet_check']
                                players_only['Prop type'] = prop
        
                                players_only['Player'] = hold_file[['Player']]
                                players_only['Team'] = players_only['Player'].map(team_dict)
        
                                leg_outcomes = players_only[['Player', 'Team', 'Book', 'Prop type', 'Prop', 'Mean_Outcome', 'Imp Over', 'Over%', 'Imp Under', 'Under%', 'Bet?', 'Edge']]
                                sim_all_hold = pd.concat([sim_all_hold, leg_outcomes], ignore_index=True)
                                
                                final_outcomes = sim_all_hold
                                
                        elif prop_type_var != 'All Props':
                            
                            if game_select_var == 'Aggregate':
                                prop_df = prop_frame[['Player', 'book', 'over_prop', 'over_line', 'under_line', 'prop_type']]
                            elif game_select_var == 'Pick6':
                                prop_df = pick_frame[['Full_name', 'book', 'over_prop', 'over_line', 'under_line', 'prop_type']]
                                prop_df.rename(columns={"Full_name": "Player"}, inplace = True)
                            
                            if prop_type_var == "pass_yards":
                                prop_df = prop_df.loc[prop_df['prop_type'] == 'NFL_GAME_PLAYER_PASSING_YARDS']
                                prop_df = prop_df[['Player', 'book', 'over_prop', 'over_line', 'under_line']]
                                prop_df = prop_df[prop_df['book'].isin(['FANDUEL', 'DRAFTKINGS', 'BET365', 'CONSENSUS'])]
                                prop_df.rename(columns={"over_prop": "Prop"}, inplace = True)
                                prop_df = prop_df.loc[prop_df['Prop'] != 0]
                                st.table(prop_df)
                                prop_df['Over'] = 1 / prop_df['over_line']
                                prop_df['Under'] = 1 / prop_df['under_line']
                                df = pd.merge(overall_stats, prop_df, how='left', left_on=['Player'], right_on = ['Player'])
                            elif prop_type_var == "rush_yards":
                                prop_df = prop_df.loc[prop_df['prop_type'] == 'NFL_GAME_PLAYER_RUSHING_YARDS']
                                prop_df = prop_df[~((prop_df['over_prop'] < 10) & (prop_df['prop_type'] == 'NFL_GAME_PLAYER_RUSHING_YARDS'))]
                                prop_df = prop_df[['Player', 'book', 'over_prop', 'over_line', 'under_line']]
                                prop_df = prop_df[prop_df['book'].isin(['FANDUEL', 'DRAFTKINGS', 'BET365', 'CONSENSUS'])]
                                prop_df.rename(columns={"over_prop": "Prop"}, inplace = True)
                                prop_df = prop_df.loc[prop_df['Prop'] != 0]
                                st.table(prop_df)
                                prop_df['Over'] = 1 / prop_df['over_line']
                                prop_df['Under'] = 1 / prop_df['under_line']
                                df = pd.merge(overall_stats, prop_df, how='left', left_on=['Player'], right_on = ['Player'])
                            elif prop_type_var == "rec_yards":
                                prop_df = prop_df.loc[prop_df['prop_type'] == 'NFL_GAME_PLAYER_RECEIVING_YARDS']
                                prop_df = prop_df[['Player', 'book', 'over_prop', 'over_line', 'under_line']]
                                prop_df = prop_df[prop_df['book'].isin(['FANDUEL', 'DRAFTKINGS', 'BET365', 'CONSENSUS'])]
                                prop_df.rename(columns={"over_prop": "Prop"}, inplace = True)
                                prop_df = prop_df.loc[prop_df['Prop'] != 0]
                                st.table(prop_df)
                                prop_df['Over'] = 1 / prop_df['over_line']
                                prop_df['Under'] = 1 / prop_df['under_line']
                                df = pd.merge(overall_stats, prop_df, how='left', left_on=['Player'], right_on = ['Player'])
                            elif prop_type_var == "receptions":
                                prop_df = prop_df.loc[prop_df['prop_type'] == 'NFL_GAME_PLAYER_RECEIVING_RECEPTIONS']
                                prop_df = prop_df[['Player', 'book', 'over_prop', 'over_line', 'under_line']]
                                prop_df = prop_df[prop_df['book'].isin(['FANDUEL', 'DRAFTKINGS', 'BET365', 'CONSENSUS'])]
                                prop_df.rename(columns={"over_prop": "Prop"}, inplace = True)
                                prop_df = prop_df.loc[prop_df['Prop'] != 0]
                                st.table(prop_df)
                                prop_df['Over'] = 1 / prop_df['over_line']
                                prop_df['Under'] = 1 / prop_df['under_line']
                                df = pd.merge(overall_stats, prop_df, how='left', left_on=['Player'], right_on = ['Player'])
                            elif prop_type_var == "rush_attempts":
                                prop_df = prop_df.loc[prop_df['prop_type'] == 'NFL_GAME_PLAYER_RUSHING_ATTEMPTS']
                                prop_df = prop_df[['Player', 'book', 'over_prop', 'over_line', 'under_line']]
                                prop_df = prop_df[prop_df['book'].isin(['FANDUEL', 'DRAFTKINGS', 'BET365', 'CONSENSUS'])]
                                prop_df.rename(columns={"over_prop": "Prop"}, inplace = True)
                                prop_df = prop_df.loc[prop_df['Prop'] != 0]
                                st.table(prop_df)
                                prop_df['Over'] = 1 / prop_df['over_line']
                                prop_df['Under'] = 1 / prop_df['under_line']
                                df = pd.merge(overall_stats, prop_df, how='left', left_on=['Player'], right_on = ['Player'])
                            elif prop_type_var == "pass_attempts":
                                prop_df = prop_df.loc[prop_df['prop_type'] == 'NFL_GAME_PLAYER_PASSING_ATTEMPTS']
                                prop_df = prop_df[['Player', 'book', 'over_prop', 'over_line', 'under_line']]
                                prop_df = prop_df[prop_df['book'].isin(['FANDUEL', 'DRAFTKINGS', 'BET365', 'CONSENSUS'])]
                                prop_df.rename(columns={"over_prop": "Prop"}, inplace = True)
                                prop_df = prop_df.loc[prop_df['Prop'] != 0]
                                st.table(prop_df)
                                prop_df['Over'] = 1 / prop_df['over_line']
                                prop_df['Under'] = 1 / prop_df['under_line']
                                df = pd.merge(overall_stats, prop_df, how='left', left_on=['Player'], right_on = ['Player'])
                            elif prop_type_var == "pass_completions":
                                prop_df = prop_df.loc[prop_df['prop_type'] == 'NFL_GAME_PLAYER_PASSING_COMPLETIONS']
                                prop_df = prop_df[['Player', 'book', 'over_prop', 'over_line', 'under_line']]
                                prop_df = prop_df[prop_df['book'].isin(['FANDUEL', 'DRAFTKINGS', 'BET365', 'CONSENSUS'])]
                                prop_df.rename(columns={"over_prop": "Prop"}, inplace = True)
                                prop_df = prop_df.loc[prop_df['Prop'] != 0]
                                st.table(prop_df)
                                prop_df['Over'] = 1 / prop_df['over_line']
                                prop_df['Under'] = 1 / prop_df['under_line']
                                df = pd.merge(overall_stats, prop_df, how='left', left_on=['Player'], right_on = ['Player'])
                            
                            prop_dict = dict(zip(df.Player, df.Prop))
                            book_dict = dict(zip(df.Player, df.book))
                            over_dict = dict(zip(df.Player, df.Over))
                            under_dict = dict(zip(df.Player, df.Under))
                            
                            total_sims = 5000
    
                            df.replace("", 0, inplace=True)
                            
                            if prop_type_var == "pass_yards":
                                df['Median'] = df['pass_yards']
                            elif prop_type_var == "rush_yards":
                                df['Median'] = df['rush_yards']
                            elif prop_type_var == "rec_yards":
                                df['Median'] = df['rec_yards']
                            elif prop_type_var == "receptions":
                                df['Median'] = df['rec']
                            elif prop_type_var == "rush_attempts":
                                df['Median'] = df['rush_att']
    
                            flex_file = df
                            flex_file['Floor'] = flex_file['Median'] * .25
                            flex_file['Ceiling'] = flex_file['Median'] + (flex_file['Median'] * 1.75)
                            flex_file['STD'] = flex_file['Median'] / 4
                            flex_file['Prop'] = flex_file['Player'].map(prop_dict)
                            flex_file = flex_file[['Player', 'book', 'Prop', 'Floor', 'Median', 'Ceiling', 'STD']]
    
                            hold_file = flex_file
                            overall_file = flex_file
                            prop_file = flex_file
                                  
                            overall_players = overall_file[['Player']]
    
                            for x in range(0,total_sims):    
                                prop_file[x] = prop_file['Prop']
    
                            prop_file = prop_file.drop(['Player', 'book', 'Prop', 'Floor', 'Median', 'Ceiling', 'STD'], axis=1)
    
                            for x in range(0,total_sims):
                                overall_file[x] = np.random.normal(overall_file['Median'],overall_file['STD'])
    
                            overall_file=overall_file.drop(['Player', 'book', 'Prop', 'Floor', 'Median', 'Ceiling', 'STD'], axis=1)
    
                            players_only = hold_file[['Player']]
    
                            player_outcomes = pd.merge(players_only, overall_file, left_index=True, right_index=True)
    
                            prop_check = (overall_file - prop_file)
    
                            players_only['Mean_Outcome'] = overall_file.mean(axis=1)
                            players_only['10%'] = overall_file.quantile(0.1, axis=1)
                            players_only['90%'] = overall_file.quantile(0.9, axis=1)
                            players_only['Over'] = prop_check[prop_check > 0].count(axis=1)/float(total_sims)
                            players_only['Imp Over'] = players_only['Player'].map(over_dict)
                            players_only['Over%'] = players_only[["Over", "Imp Over"]].mean(axis=1)
                            players_only['Under'] = prop_check[prop_check < 0].count(axis=1)/float(total_sims)
                            players_only['Imp Under'] = players_only['Player'].map(under_dict)
                            players_only['Under%'] = players_only[["Under", "Imp Under"]].mean(axis=1)
                            players_only['Book'] = players_only['Player'].map(book_dict)
                            players_only['Prop'] = players_only['Player'].map(prop_dict)
                            players_only['Prop_avg'] = players_only['Prop'].mean() / 100
                            players_only['prop_threshold'] = .10
                            players_only = players_only.loc[players_only['Mean_Outcome'] > 0]
                            players_only['Over_diff'] = players_only['Over%'] - players_only['Imp Over']
                            players_only['Under_diff'] = players_only['Under%'] - players_only['Imp Under']
                            players_only['Bet_check'] = np.where(players_only['Over_diff'] > players_only['Under_diff'], players_only['Over_diff'] , players_only['Under_diff'])
                            players_only['Bet_suggest'] = np.where(players_only['Over_diff'] > players_only['Under_diff'], "Over" , "Under")
                            players_only['Bet?'] = np.where(players_only['Bet_check'] >= players_only['prop_threshold'], players_only['Bet_suggest'], "No Bet")
                            players_only['Edge'] = players_only['Bet_check']
    
                            players_only['Player'] = hold_file[['Player']]
                            players_only['Team'] = players_only['Player'].map(team_dict)
    
                            final_outcomes = players_only[['Player', 'Team', 'Book', 'Prop', 'Mean_Outcome', 'Imp Over', 'Over%', 'Imp Under', 'Under%', 'Bet?', 'Edge']]
                        
                        final_outcomes = final_outcomes.sort_values(by='Edge', ascending=False)

                        with df_hold_container:
                            df_hold_container = st.empty()
                            st.dataframe(final_outcomes.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(precision=2), use_container_width = True)
                        with export_container:
                            export_container = st.empty()
                            st.download_button(
                                label="Export Projections",
                                data=convert_df_to_csv(final_outcomes),
                                file_name='NFL_prop_proj.csv',
                                mime='text/csv',
                                key='prop_proj',
                            )