Initial commit and dockerization

.streamlit/secrets.toml

@@ -0,0 +1 @@
+mongo_uri = "mongodb+srv://multichem:Xr1q5wZdXPbxdUmJ@testcluster.lgwtp5i.mongodb.net/?retryWrites=true&w=majority&appName=TestCluster"

Dockerfile

@@ -5,11 +5,24 @@ WORKDIR /app
 RUN apt-get update && apt-get install -y \
     build-essential \
     curl \
+    software-properties-common \
     git \
     && rm -rf /var/lib/apt/lists/*
 
 COPY requirements.txt ./
 COPY src/ ./src/
+COPY .streamlit/ ./.streamlit/
+
+
+
+ENV MONGO_URI="mongodb+srv://multichem:Xr1q5wZdXPbxdUmJ@testcluster.lgwtp5i.mongodb.net/?retryWrites=true&w=majority&appName=TestCluster"
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user\
+	PATH=/home/user/.local/bin:$PATH
+WORKDIR $HOME/app
+RUN pip install --no-cache-dir --upgrade pip
+COPY --chown=user . $HOME/app
 
 RUN pip3 install -r requirements.txt
 

requirements.txt

@@ -1,3 +1,8 @@
-altair
-pandas
-streamlit
+streamlit
+openpyxl
+matplotlib
+pulp
+docker
+plotly
+scipy
+pymongo

src/database.py

@@ -0,0 +1,17 @@
+import streamlit as st
+from pymongo import MongoClient
+import os
+
+@st.cache_resource
+def init_conn():
+    uri = os.getenv('MONGO_URI')
+    if not uri:
+        uri = st.secrets['mongo_uri']
+    client = MongoClient(uri, retryWrites=True, serverSelectionTimeoutMS=100000)
+    dfs_db = client["NFL_Database"]
+    props_db = client["Props_DB"]
+
+    return props_db, dfs_db
+
+# Initialize the database connection
+props_db, dfs_db = init_conn()

src/streamlit_app.py

@@ -1,40 +1,822 @@
-import altair as alt
+import streamlit as st
 import numpy as np
+from numpy import where as np_where
 import pandas as pd
-import streamlit as st
+import plotly.express as px
+import scipy.stats as stats
+st.set_page_config(layout="wide")
+
+from database import props_db, dfs_db
+
+game_format = {'Win%': '{:.2%}', 'Vegas': '{:.2%}', 'Win% Diff': '{:.2%}'}
+american_format = {'First Inning Lead Percentage': '{:.2%}', 'Fifth Inning Lead Percentage': '{:.2%}'}
+
+st.markdown("""
+<style>
+    /* Tab styling */
+    .stElementContainer [data-baseweb="button-group"] {
+        gap: 2.000rem;
+        padding: 4px;
+    }
+    .stElementContainer [kind="segmented_control"] {
+        height: 2.000rem;
+        white-space: pre-wrap;
+        background-color: #68B1E7;
+        color: white;
+        border-radius: 20px;
+        gap: 1px;
+        padding: 10px 20px;
+        font-weight: bold;
+        transition: all 0.3s ease;
+    }
+    .stElementContainer [kind="segmented_controlActive"] {
+        height: 3.000rem;
+        background-color: #68B1E7;
+        border: 3px solid #4FB286;
+        border-radius: 10px;
+        color: black;
+    }
+    .stElementContainer [kind="segmented_control"]:hover {
+        background-color: #4FB286;
+        cursor: pointer;
+    }
+
+    div[data-baseweb="select"] > div {
+        background-color: #68B1E7;
+        color: white;
+    }
+
+</style>""", unsafe_allow_html=True)
+
+def calculate_poisson(row):
+    mean_val = row['Mean_Outcome']
+    threshold = row['Prop']
+    cdf_value = stats.poisson.cdf(threshold, mean_val)
+    probability = 1 - cdf_value
+    return probability
+
+@st.cache_resource(ttl=600)
+def init_baselines():
+    collection = dfs_db["Game_Betting_Model"] 
+    cursor = collection.find()
+    raw_display = pd.DataFrame(list(cursor))
+    game_model = raw_display[['Team', 'Opp', 'Win%', 'Vegas', 'Win% Diff', 'Win Line', 'Vegas Line', 'Line Diff', 'PD Spread', 'Vegas Spread', 'Spread Diff']]
+    
+    collection = dfs_db["Player_Stats"] 
+    cursor = collection.find()
+    raw_display = pd.DataFrame(list(cursor))
+    overall_stats = raw_display[['Player', 'Position', 'Team', 'Opp', 'rush_att', 'rec', 'dropbacks', 'rush_yards', 'rush_tds', 'rec_yards', 'rec_tds', 'pass_att', 'pass_yards', 'pass_tds', 'PPR', 'Half_PPR']]
+    
+    collection = dfs_db["Prop_Trends"] 
+    cursor = collection.find()
+    raw_display = pd.DataFrame(list(cursor))
+    prop_trends = raw_display[['Player', 'over_prop', 'over_line', 'under_prop', 'under_line', 'book', 'prop_type', 'No Vig', 'Team', 'L3 Success', 'L6_Success', 'L10_success', 'L6 Avg', 'Projection',
+                               'Proj Diff', 'Implied Over', 'Trending Over', 'Over Edge', 'Implied Under', 'Trending Under', 'Under Edge']]
+    
+    collection = dfs_db["DK_NFL_ROO"] 
+    cursor = collection.find()
+
+    raw_display = pd.DataFrame(list(cursor))
+    raw_display = raw_display[['Player', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '2x%', '3x%', '4x%',
+                               'Own', 'Small_Field_Own', 'Large_Field_Own', 'Cash_Field_Own', 'CPT_Own', 'LevX', 'version', 'slate', 'timestamp', 'player_ID', 'site']]
+    load_display = raw_display[raw_display['Position'] != 'K']
+    timestamp = load_display['timestamp'][0]
+    
+    collection = dfs_db["Prop_Trends"] 
+    cursor = collection.find()
+    raw_display = pd.DataFrame(list(cursor))
+    prop_frame = raw_display[['Player', 'over_prop', 'over_line', 'under_prop', 'under_line', 'book', 'prop_type', 'No Vig', 'Team', 'L3 Success', 'L6_Success', 'L10_success', 'L6 Avg', 'Projection',
+                               'Proj Diff', 'Implied Over', 'Trending Over', 'Over Edge', 'Implied Under', 'Trending Under', 'Under Edge']]
+    
+    collection = dfs_db['Pick6_Trends']
+    cursor = collection.find()
+    raw_display = pd.DataFrame(list(cursor))
+    pick_frame = raw_display[['Player', 'over_prop', 'over_line', 'under_prop', 'under_line', 'book', 'prop_type', 'No Vig', 'Team', 'L3 Success', 'L6_Success', 'L10_success', 'L6 Avg', 'Projection',
+                               'Proj Diff', 'Implied Over', 'Trending Over', 'Over Edge', 'Implied Under', 'Trending Under', 'Under Edge', 'last_name', 'P6_name', 'Full_name']]
+
+    collection = props_db["NFL_Props"] 
+    cursor = collection.find()
+
+    raw_display = pd.DataFrame(list(cursor))
+    market_props = raw_display[['Name', 'Position', 'Projection', 'PropType', 'OddsType', 'over_pay', 'under_pay']]
+    market_props['over_prop'] = market_props['Projection']
+    market_props['over_line'] = market_props['over_pay'].apply(lambda x: (x - 1) * 100 if x >= 2.0 else -100 / (x - 1))
+    market_props['under_prop'] = market_props['Projection']
+    market_props['under_line'] = market_props['under_pay'].apply(lambda x: (x - 1) * 100 if x >= 2.0 else -100 / (x - 1))
+
+    return game_model, overall_stats, timestamp, prop_frame, prop_trends, pick_frame, market_props
+
+def calculate_no_vig(row):
+    def implied_probability(american_odds):
+        if american_odds < 0:
+            return (-american_odds) / ((-american_odds) + 100)
+        else:
+            return 100 / (american_odds + 100)
+
+    over_line = row['over_line']
+    under_line = row['under_line']
+    over_prop = row['over_prop']
+    
+    over_prob = implied_probability(over_line)
+    under_prob = implied_probability(under_line)
+    
+    total_prob = over_prob + under_prob
+    no_vig_prob = (over_prob / total_prob + 0.5) * over_prop
+    
+    return no_vig_prob
+
+def convert_df_to_csv(df):
+    return df.to_csv().encode('utf-8')
+
+game_model, overall_stats, timestamp, prop_frame, prop_trends, pick_frame, market_props = init_baselines()
+qb_stats = overall_stats[overall_stats['Position'] == 'QB']
+qb_stats = qb_stats.drop_duplicates(subset=['Player', 'Position'])
+non_qb_stats = overall_stats[overall_stats['Position'] != 'QB']
+non_qb_stats = non_qb_stats.drop_duplicates(subset=['Player', 'Position'])
+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_PASSING_YARDS', 'NFL_GAME_PLAYER_RUSHING_YARDS', 'NFL_GAME_PLAYER_PASSING_ATTEMPTS', 'NFL_GAME_PLAYER_PASSING_TOUCHDOWNS', 'NFL_GAME_PLAYER_PASSING_COMPLETIONS', 'NFL_GAME_PLAYER_RUSHING_ATTEMPTS',
+                      'NFL_GAME_PLAYER_RECEIVING_RECEPTIONS', 'NFL_GAME_PLAYER_RECEIVING_YARDS', 'NFL_GAME_PLAYER_RECEIVING_TOUCHDOWNS']
+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_PASSING_ATTEMPTS', 'NFL_GAME_PLAYER_PASSING_TOUCHDOWNS', 'NFL_GAME_PLAYER_PASSING_COMPLETIONS', 'NFL_GAME_PLAYER_RUSHING_ATTEMPTS',
+                      'NFL_GAME_PLAYER_RECEIVING_RECEPTIONS', 'NFL_GAME_PLAYER_RECEIVING_YARDS', 'NFL_GAME_PLAYER_RECEIVING_TOUCHDOWNS']
+pick6_sim_vars = ['Rush + Rec Yards', 'Rush + Rec TDs', 'Passing Yards', 'Passing Attempts', 'Passing TDs', 'Completions', 'Rushing Yards', 'Receptions', 'Receiving Yards']
+sim_all_hold = pd.DataFrame(columns=['Player', 'Team', 'Book', 'Prop Type', 'Prop', 'Mean_Outcome', 'Imp Over', 'Trending Over', 'Over%', 'Imp Under', 'Trending Under', 'Under%', 'Bet?', 'Edge'])
+
+selected_tab = st.segmented_control(
+    "Select Tab",
+    options=["Game Betting Model", 'Prop Market', "QB Projections", "RB/WR/TE Projections", "Player Prop Trends", "Player Prop Simulations", "Stat Specific Simulations"],
+    selection_mode='single',
+    default='Game Betting Model',
+    width='stretch',
+    label_visibility='collapsed',
+    key='tab_selector'
+)
+
+if selected_tab == 'Game Betting Model':
+    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, market_props = init_baselines()
+              qb_stats = overall_stats[overall_stats['Position'] == 'QB']
+              qb_stats = qb_stats.drop_duplicates(subset=['Player', 'Position'])
+              non_qb_stats = overall_stats[overall_stats['Position'] != 'QB']
+              non_qb_stats = non_qb_stats.drop_duplicates(subset=['Player', 'Position'])
+              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')
+        try:
+            st.dataframe(team_frame.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(game_format, precision=2), use_container_width = True)
+        except:
+            st.dataframe(team_frame.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').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',
+    )
+
+if selected_tab == 'Prop Market':
+    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, market_props = init_baselines()
+              qb_stats = overall_stats[overall_stats['Position'] == 'QB']
+              qb_stats = qb_stats.drop_duplicates(subset=['Player', 'Position'])
+              non_qb_stats = overall_stats[overall_stats['Position'] != 'QB']
+              non_qb_stats = non_qb_stats.drop_duplicates(subset=['Player', 'Position'])
+              team_dict = dict(zip(prop_frame['Player'], prop_frame['Team']))
+              t_stamp = f"Last Update: " + str(timestamp) + f" CST"
+    market_type = st.selectbox('Select type of prop are you wanting to view', options = prop_table_options, key = 'market_type_key')
+    disp_market = market_props.copy()
+    disp_market = disp_market[disp_market['PropType'] == market_type]
+    disp_market['No_Vig_Prop'] = disp_market.apply(calculate_no_vig, axis=1)
+    fanduel_frame = disp_market[disp_market['OddsType'] == 'FANDUEL']
+    fanduel_dict = dict(zip(fanduel_frame['Name'], fanduel_frame['No_Vig_Prop']))
+    draftkings_frame = disp_market[disp_market['OddsType'] == 'DRAFTKINGS']
+    draftkings_dict = dict(zip(draftkings_frame['Name'], draftkings_frame['No_Vig_Prop']))
+    mgm_frame = disp_market[disp_market['OddsType'] == 'MGM']
+    mgm_dict = dict(zip(mgm_frame['Name'], mgm_frame['No_Vig_Prop']))
+    bet365_frame = disp_market[disp_market['OddsType'] == 'BET_365']
+    bet365_dict = dict(zip(bet365_frame['Name'], bet365_frame['No_Vig_Prop']))
+
+    disp_market['FANDUEL'] = disp_market['Name'].map(fanduel_dict)
+    disp_market['DRAFTKINGS'] = disp_market['Name'].map(draftkings_dict)
+    disp_market['MGM'] = disp_market['Name'].map(mgm_dict)
+    disp_market['BET365'] = disp_market['Name'].map(bet365_dict)
+
+    disp_market = disp_market[['Name', 'Position','FANDUEL', 'DRAFTKINGS', 'MGM', 'BET365']]
+    disp_market = disp_market.drop_duplicates(subset=['Name'], keep='first', ignore_index=True)
+
+    st.dataframe(disp_market.style.background_gradient(axis=1, subset=['FANDUEL', 'DRAFTKINGS', 'MGM', 'BET365'], cmap='RdYlGn').format(prop_format, precision=2), height = 1000, use_container_width = True)
+    st.download_button(
+        label="Export Market Props",
+        data=convert_df_to_csv(disp_market),
+        file_name='NFL_market_props_export.csv',
+        mime='text/csv',
+    )
+
+if selected_tab == 'QB Projections':
+    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, market_props = init_baselines()
+              qb_stats = overall_stats[overall_stats['Position'] == 'QB']
+              qb_stats = qb_stats.drop_duplicates(subset=['Player', 'Position'])
+              non_qb_stats = overall_stats[overall_stats['Position'] != 'QB']
+              non_qb_stats = non_qb_stats.drop_duplicates(subset=['Player', 'Position'])
+              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',
+    )
+
+if selected_tab == 'RB/WR/TE Projections':
+    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, market_props = init_baselines()
+              qb_stats = overall_stats[overall_stats['Position'] == 'QB']
+              qb_stats = qb_stats.drop_duplicates(subset=['Player', 'Position'])
+              non_qb_stats = overall_stats[overall_stats['Position'] != 'QB']
+              non_qb_stats = non_qb_stats.drop_duplicates(subset=['Player', 'Position'])
+              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',
+    )
+
+if selected_tab == 'Player Prop Trends':
+    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, market_props = init_baselines()
+              qb_stats = overall_stats[overall_stats['Position'] == 'QB']
+              qb_stats = qb_stats.drop_duplicates(subset=['Player', 'Position'])
+              non_qb_stats = overall_stats[overall_stats['Position'] != 'QB']
+              non_qb_stats = non_qb_stats.drop_duplicates(subset=['Player', 'Position'])
+              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',
+    )
+
+if selected_tab == 'Player Prop Simulations':
+    st.info(t_stamp)
+    if st.button("Reset Data", key='reset6'):
+              st.cache_data.clear()
+              game_model, overall_stats, timestamp, prop_frame, prop_trends, pick_frame, market_props = init_baselines()
+              qb_stats = overall_stats[overall_stats['Position'] == 'QB']
+              qb_stats = qb_stats.drop_duplicates(subset=['Player', 'Position'])
+              non_qb_stats = overall_stats[overall_stats['Position'] != 'QB']
+              non_qb_stats = non_qb_stats.drop_duplicates(subset=['Player', 'Position'])
+              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[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['Prop'] = prop_var
+                        players_only['poisson_var'] = players_only.apply(calculate_poisson, 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'] = np.where(players_only['Prop'] <= 3, players_only['poisson_var'], overall_file[overall_file > prop_var].count(axis=1)/float(total_sims))
+                        elif ou_var == 'Under':
+                            players_only['beat_prop'] = np.where(players_only['Prop'] <= 3, 1 - players_only['poisson_var'], (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[final_outcomes['Player'] == player_check]
+                        player_outcomes = player_outcomes[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)
+
+if selected_tab == 'Stat Specific Simulations':
+    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='reset7'):
+              st.cache_data.clear()
+              game_model, overall_stats, timestamp, prop_frame, prop_trends, pick_frame, market_props = init_baselines()
+              qb_stats = overall_stats[overall_stats['Position'] == 'QB']
+              qb_stats = qb_stats.drop_duplicates(subset=['Player', 'Position'])
+              non_qb_stats = overall_stats[overall_stats['Position'] != 'QB']
+              non_qb_stats = non_qb_stats.drop_duplicates(subset=['Player', 'Position'])
+              team_dict = dict(zip(prop_frame['Player'], prop_frame['Team']))
+              t_stamp = f"Last Update: " + str(timestamp) + f" CST"
+        
+    settings_container = st.empty()
+    df_hold_container = st.empty()
+    export_container = st.empty()
+
+    with settings_container.container():
+        col1, col2, col3, col4 = st.columns([3, 3, 3, 3])
+        with col1:
+            game_select_var = st.selectbox('Select prop source', options = ['Aggregate', 'Pick6'])
+        with col2:
+            book_select_var = st.selectbox('Select book', options = ['ALL', 'BET_365', 'DRAFTKINGS', 'FANDUEL', 'MGM', 'UNIBET', 'WILLIAM_HILL'])
+            if book_select_var == 'ALL':
+                book_selections = ['BET_365', 'DRAFTKINGS', 'FANDUEL', 'MGM', 'UNIBET', 'WILLIAM_HILL']
+            else:
+                book_selections = [book_select_var]
+            if game_select_var == 'Aggregate':
+                prop_df = prop_frame[['Player', 'book', 'over_prop', 'over_line', 'under_line', 'prop_type', 'Trending Over', 'Trending Under']]
+            elif game_select_var == 'Pick6':
+                prop_df = pick_frame[['Player', 'book', 'over_prop', 'over_line', 'under_line', 'prop_type', 'Trending Over', 'Trending Under']]
+                book_selections = ['Pick6']
+        with col3:
+            if game_select_var == 'Aggregate':
+                prop_type_var = st.selectbox('Select prop category', options = ['All Props', 'NFL_GAME_PLAYER_PASSING_YARDS', 'NFL_GAME_PLAYER_RUSHING_YARDS', 'NFL_GAME_PLAYER_PASSING_ATTEMPTS', 'NFL_GAME_PLAYER_PASSING_TOUCHDOWNS', 'NFL_GAME_PLAYER_RUSHING_ATTEMPTS',
+                                                'NFL_GAME_PLAYER_RECEIVING_RECEPTIONS', 'NFL_GAME_PLAYER_RECEIVING_YARDS', 'NFL_GAME_PLAYER_RECEIVING_TOUCHDOWNS'])
+            elif game_select_var == 'Pick6':
+                prop_type_var = st.selectbox('Select prop category', options = ['All Props', 'Rush + Rec Yards', 'Rush + Rec TDs', 'Passing Yards', 'Passing Attempts', 'Passing TDs', 'Rushing Attempts', 'Rushing Yards', 'Receptions', 'Receiving Yards', 'Receiving TDs'])
+        with col4:
+            st.download_button(
+                label="Download Prop Source",
+                data=convert_df_to_csv(prop_df),
+                file_name='NFL_prop_source.csv',
+                mime='text/csv',
+                key='prop_source',
+            )
+
+    if st.button('Simulate Prop Category'):
+                
+        with df_hold_container.container():
+            if prop_type_var == 'All Props':
+                if game_select_var == 'Aggregate':
+                    prop_df_raw = prop_frame[['Player', 'book', 'over_prop', 'over_line', 'under_line', 'prop_type', 'Trending Over', 'Trending Under']]
+                    sim_vars = ['NFL_GAME_PLAYER_PASSING_YARDS', 'NFL_GAME_PLAYER_RUSHING_YARDS', 'NFL_GAME_PLAYER_PASSING_ATTEMPTS', 'NFL_GAME_PLAYER_PASSING_TOUCHDOWNS', 'NFL_GAME_PLAYER_RUSHING_ATTEMPTS',
+                                'NFL_GAME_PLAYER_RECEIVING_RECEPTIONS', 'NFL_GAME_PLAYER_RECEIVING_YARDS', 'NFL_GAME_PLAYER_RECEIVING_TOUCHDOWNS']
+                elif game_select_var == 'Pick6':
+                    prop_df_raw = pick_frame[['Player', 'book', 'over_prop', 'over_line', 'under_line', 'prop_type', 'Trending Over', 'Trending Under']]
+                    sim_vars = ['Rush + Rec Yards', 'Rush + Rec TDs', 'Passing Yards', 'Passing Attempts', 'Passing TDs', 'Rushing Attempts', 'Rushing Yards', 'Receptions', 'Receiving Yards', 'Receiving TDs']
+                
+                player_df = overall_stats.copy()
+                
+                for prop in sim_vars:
+                        
+                    for books in book_selections:
+                        prop_df = prop_df_raw[prop_df_raw['book'] == books]
+                        prop_df = prop_df[prop_df['prop_type'] == prop]
+                        prop_df = prop_df[~((prop_df['over_prop'] < 15) & (prop_df['prop_type'] == 'NFL_GAME_PLAYER_RUSHING_YARDS'))]
+                        prop_df = prop_df[['Player', 'book', 'over_prop', 'over_line', 'under_line', 'prop_type', 'Trending Over', 'Trending Under']]
+                        prop_df.rename(columns={"over_prop": "Prop"}, inplace = True)
+                        prop_df['Over'] = 1 / prop_df['over_line']
+                        prop_df['Under'] = 1 / prop_df['under_line']
+
+                        prop_dict = dict(zip(prop_df.Player, prop_df.Prop))
+                        prop_type_dict = dict(zip(prop_df.Player, prop_df.prop_type))
+                        book_dict = dict(zip(prop_df.Player, prop_df.book))
+                        over_dict = dict(zip(prop_df.Player, prop_df.Over))
+                        under_dict = dict(zip(prop_df.Player, prop_df.Under))
+                        trending_over_dict = dict(zip(prop_df.Player, prop_df['Trending Over']))
+                        trending_under_dict = dict(zip(prop_df.Player, prop_df['Trending Under']))
+
+                        player_df['book'] = player_df['Player'].map(book_dict)
+                        player_df['Prop'] = player_df['Player'].map(prop_dict)
+                        player_df['prop_type'] = player_df['Player'].map(prop_type_dict)
+                        player_df['Trending Over'] = player_df['Player'].map(trending_over_dict)
+                        player_df['Trending Under'] = player_df['Player'].map(trending_under_dict)
+
+                        df = player_df.reset_index(drop=True)
+
+                        team_dict = dict(zip(df.Player, df.Team))
+                        
+                        total_sims = 1000
+
+                        df.replace("", 0, inplace=True)
+                        
+                        if prop == "NFL_GAME_PLAYER_PASSING_YARDS" or prop == "Passing Yards":
+                            df['Median'] = df['pass_yards']
+                        elif prop == "NFL_GAME_PLAYER_RUSHING_YARDS" or prop == "Rushing Yards":
+                            df['Median'] = df['rush_yards']
+                        elif prop == "NFL_GAME_PLAYER_PASSING_ATTEMPTS" or prop == "Passing Attempts":
+                            df['Median'] = df['pass_att']
+                        elif prop == "NFL_GAME_PLAYER_PASSING_TOUCHDOWNS" or prop == "Passing TDs":
+                            df['Median'] = df['pass_tds']
+                        elif prop == "NFL_GAME_PLAYER_RUSHING_ATTEMPTS" or prop == "Rushing Attempts":
+                            df['Median'] = df['rush_att']
+                        elif prop == "NFL_GAME_PLAYER_RECEIVING_RECEPTIONS" or prop == "Receptions":
+                            df['Median'] = df['rec']
+                        elif prop == "NFL_GAME_PLAYER_RECEIVING_YARDS" or prop == "Receiving Yards":
+                            df['Median'] = df['rec_yards']
+                        elif prop == "NFL_GAME_PLAYER_RECEIVING_TOUCHDOWNS" or prop == "Receiving TDs":
+                            df['Median'] = df['rec_tds']
+                        elif prop == "Rush + Rec Yards":
+                            df['Median'] = df['rush_yards'] + df['rec_yards']
+                        elif prop == "Rush + Rec TDs":
+                            df['Median'] = df['rush_tds'] + df['rec_tds']
+                            
+                        flex_file = df.copy()
+                        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.copy()
+                        overall_file = flex_file.copy()
+                        prop_file = flex_file.copy()
+                                
+                        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['Book'] = players_only['Player'].map(book_dict)
+                        players_only['Prop'] = players_only['Player'].map(prop_dict)
+                        players_only['Trending Over'] = players_only['Player'].map(trending_over_dict)
+                        players_only['Trending Under'] = players_only['Player'].map(trending_under_dict)
+                        players_only['poisson_var'] = players_only.apply(calculate_poisson, 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'] = np_where(players_only['Prop'] <= 3, players_only['poisson_var'], 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", "Trending Over"]].mean(axis=1)
+                        players_only['Under'] = np_where(players_only['Prop'] <= 3, 1 - players_only['poisson_var'], 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", "Trending Under"]].mean(axis=1)
+                        players_only['Prop_avg'] = players_only['Prop'].mean() / 100
+                        players_only['prop_threshold'] = .10
+                        players_only = players_only[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', 'Trending Over', 'Over%', 'Imp Under', 'Trending Under', 'Under%', 'Bet?', 'Edge']]
+                        sim_all_hold = pd.concat([sim_all_hold, leg_outcomes], ignore_index=True)
+                        
+                        final_outcomes = sim_all_hold
+                        st.write(f'finished {prop} for {books}')
+                    
+            elif prop_type_var != 'All Props':
+
+                player_df = overall_stats.copy()
+
+                if game_select_var == 'Aggregate':
+                    prop_df_raw = prop_frame[['Player', 'book', 'over_prop', 'over_line', 'under_line', 'prop_type', 'Trending Over', 'Trending Under']]
+                elif game_select_var == 'Pick6':
+                    prop_df_raw = pick_frame[['Player', 'book', 'over_prop', 'over_line', 'under_line', 'prop_type', 'Trending Over', 'Trending Under']]
+                    
+                for books in book_selections:
+                    prop_df = prop_df_raw[prop_df_raw['book'] == books]
+                    
+                    if prop_type_var == "NFL_GAME_PLAYER_PASSING_YARDS":
+                        prop_df = prop_df[prop_df['prop_type'] == 'NFL_GAME_PLAYER_PASSING_YARDS']
+                    elif prop_type_var == "Passing Yards":
+                        prop_df = prop_df[prop_df['prop_type'] == 'Passing Yards']
+                    elif prop_type_var == "NFL_GAME_PLAYER_RUSHING_YARDS":
+                        prop_df = prop_df[prop_df['prop_type'] == 'NFL_GAME_PLAYER_RUSHING_YARDS']
+                    elif prop_type_var == "Rushing Yards":
+                        prop_df = prop_df[prop_df['prop_type'] == 'Rushing Yards']
+                    elif prop_type_var == "NFL_GAME_PLAYER_PASSING_ATTEMPTS":
+                        prop_df = prop_df[prop_df['prop_type'] == 'NFL_GAME_PLAYER_PASSING_ATTEMPTS']
+                    elif prop_type_var == "Passing Attempts":
+                        prop_df = prop_df[prop_df['prop_type'] == 'Passing Attempts']
+                    elif prop_type_var == "NFL_GAME_PLAYER_PASSING_TOUCHDOWNS":
+                        prop_df = prop_df[prop_df['prop_type'] == 'NFL_GAME_PLAYER_PASSING_TOUCHDOWNS']
+                    elif prop_type_var == "Passing TDs":
+                        prop_df = prop_df[prop_df['prop_type'] == 'Passing TDs']
+                    elif prop_type_var == "NFL_GAME_PLAYER_RUSHING_ATTEMPTS":
+                        prop_df = prop_df[prop_df['prop_type'] == 'NFL_GAME_PLAYER_RUSHING_ATTEMPTS']
+                    elif prop_type_var == "Rushing Attempts":
+                        prop_df = prop_df[prop_df['prop_type'] == 'Rushing Attempts']
+                    elif prop_type_var == "NFL_GAME_PLAYER_RECEIVING_RECEPTIONS":
+                        prop_df = prop_df[prop_df['prop_type'] == 'NFL_GAME_PLAYER_RECEIVING_RECEPTIONS']
+                    elif prop_type_var == "Receptions":
+                        prop_df = prop_df[prop_df['prop_type'] == 'Receptions']
+                    elif prop_type_var == "NFL_GAME_PLAYER_RECEIVING_YARDS":
+                        prop_df = prop_df[prop_df['prop_type'] == 'NFL_GAME_PLAYER_RECEIVING_YARDS']
+                    elif prop_type_var == "Receiving Yards":
+                        prop_df = prop_df[prop_df['prop_type'] == 'Receiving Yards']
+                    elif prop_type_var == "NFL_GAME_PLAYER_RECEIVING_TOUCHDOWNS":
+                        prop_df = prop_df[prop_df['prop_type'] == 'NFL_GAME_PLAYER_RECEIVING_TOUCHDOWNS']
+                    elif prop_type_var == "Receiving TDs":
+                        prop_df = prop_df[prop_df['prop_type'] == 'Receiving TDs']
+                    elif prop_type_var == "Rush + Rec Yards":
+                        prop_df = prop_df[prop_df['prop_type'] == 'Rush + Rec Yards']
+                    elif prop_type_var == "Rush + Rec TDs":
+                        prop_df = prop_df[prop_df['prop_type'] == 'Rush + Rec TDs']
+
+                    prop_df = prop_df[['Player', 'book', 'over_prop', 'over_line', 'under_line', 'prop_type', 'Trending Over', 'Trending Under']]
+                    prop_df = prop_df.rename(columns={"over_prop": "Prop"})
+                    prop_df['Over'] = 1 / prop_df['over_line']
+                    prop_df['Under'] = 1 / prop_df['under_line']
+
+                    prop_dict = dict(zip(prop_df.Player, prop_df.Prop))
+                    prop_type_dict = dict(zip(prop_df.Player, prop_df.prop_type))
+                    book_dict = dict(zip(prop_df.Player, prop_df.book))
+                    over_dict = dict(zip(prop_df.Player, prop_df.Over))
+                    under_dict = dict(zip(prop_df.Player, prop_df.Under))
+                    trending_over_dict = dict(zip(prop_df.Player, prop_df['Trending Over']))
+                    trending_under_dict = dict(zip(prop_df.Player, prop_df['Trending Under']))
+
+                    player_df['book'] = player_df['Player'].map(book_dict)
+                    player_df['Prop'] = player_df['Player'].map(prop_dict)
+                    player_df['prop_type'] = player_df['Player'].map(prop_type_dict)
+                    player_df['Trending Over'] = player_df['Player'].map(trending_over_dict)
+                    player_df['Trending Under'] = player_df['Player'].map(trending_under_dict)
+
+                    df = player_df.reset_index(drop=True)
+
+                    team_dict = dict(zip(df.Player, df.Team))
+                    
+                    total_sims = 1000
+
+                    df.replace("", 0, inplace=True)
+                    
+                    if prop_type_var == "NFL_GAME_PLAYER_PASSING_YARDS" or prop_type_var == "Passing Yards":
+                        df['Median'] = df['pass_yards']
+                    elif prop_type_var == "NFL_GAME_PLAYER_RUSHING_YARDS" or prop_type_var == "Rushing Yards":
+                        df['Median'] = df['rush_yards']
+                    elif prop_type_var == "NFL_GAME_PLAYER_PASSING_ATTEMPTS" or prop_type_var == "Passing Attempts":
+                        df['Median'] = df['pass_att']
+                    elif prop_type_var == "NFL_GAME_PLAYER_PASSING_TOUCHDOWNS" or prop_type_var == "Passing TDs":
+                        df['Median'] = df['pass_tds']
+                    elif prop_type_var == "NFL_GAME_PLAYER_RUSHING_ATTEMPTS" or prop_type_var == "Rushing Attempts":
+                        df['Median'] = df['rush_att']
+                    elif prop_type_var == "NFL_GAME_PLAYER_RECEIVING_RECEPTIONS" or prop_type_var == "Receptions":
+                        df['Median'] = df['rec']
+                    elif prop_type_var == "NFL_GAME_PLAYER_RECEIVING_YARDS" or prop_type_var == "Receiving Yards":
+                        df['Median'] = df['rec_yards']
+                    elif prop_type_var == "NFL_GAME_PLAYER_RECEIVING_TOUCHDOWNS" or prop_type_var == "Receiving TDs":
+                        df['Median'] = df['rec_tds']
+                    elif prop_type_var == "Rush + Rec Yards":
+                        df['Median'] = df['rush_yards'] + df['rec_yards']
+                    elif prop_type_var == "Rush + Rec TDs":
+                        df['Median'] = df['rush_tds'] + df['rec_tds']
+
+                    flex_file = df.copy()
+                    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.copy()
+                    overall_file = flex_file.copy()
+                    prop_file = flex_file.copy()
+                            
+                    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['Book'] = players_only['Player'].map(book_dict)
+                    players_only['Prop'] = players_only['Player'].map(prop_dict)
+                    players_only['Trending Over'] = players_only['Player'].map(trending_over_dict)
+                    players_only['Trending Under'] = players_only['Player'].map(trending_under_dict)
+                    players_only['poisson_var'] = players_only.apply(calculate_poisson, 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'] = np_where(players_only['Prop'] <= 3, players_only['poisson_var'], 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", "Trending Over"]].mean(axis=1)
+                    players_only['Under'] = np_where(players_only['Prop'] <= 3, 1 - players_only['poisson_var'], 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", "Trending Under"]].mean(axis=1)
+                    players_only['Prop_avg'] = players_only['Prop'].mean() / 100
+                    players_only['prop_threshold'] = .10
+                    players_only = players_only[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_type_var
+
+                    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', 'Trending Over', 'Over%', 'Imp Under', 'Trending Under', 'Under%', 'Bet?', 'Edge']]
+                    sim_all_hold = pd.concat([sim_all_hold, leg_outcomes], ignore_index=True)
+                    
+                    final_outcomes = sim_all_hold
+                    st.write(f'finished {prop_type_var} for {books}')
+            
+            final_outcomes = final_outcomes.dropna()
+            if game_select_var == 'Pick6':
+                final_outcomes = final_outcomes.drop_duplicates(subset=['Player', 'Prop Type'])
+            final_outcomes = final_outcomes.sort_values(by='Edge', ascending=False)
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+            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',
+                )