Comment out data retrieval and processing logic in app.py for prop, betsheet, and pick frames, while adding a warning message for users regarding the prop frame source being down. This simplifies the current data handling structure and prepares for future updates.

app.py

@@ -93,23 +93,27 @@ def init_baselines():
         raw_display = pd.DataFrame(cursor)
         team_frame = raw_display.drop_duplicates(subset='Names')
         
-        collection = db['Prop_Trends']
-        cursor = collection.find()
-        raw_display = pd.DataFrame(cursor)
-        raw_display.replace('', np.nan, inplace=True)
-        prop_frame = raw_display.dropna(subset='Team')
+        # collection = db['Prop_Trends']
+        # cursor = collection.find()
+        # raw_display = pd.DataFrame(cursor)
+        # raw_display.replace('', np.nan, inplace=True)
+        # prop_frame = raw_display.dropna(subset='Team')
         
-        sh = gc.open_by_url(master_hold)
-        worksheet = sh.worksheet('Prop_results')
-        raw_display = pd.DataFrame(worksheet.get_all_records())
-        raw_display.replace('', np.nan, inplace=True)
-        betsheet_frame = raw_display.dropna(subset='proj')
+        # sh = gc.open_by_url(master_hold)
+        # worksheet = sh.worksheet('Prop_results')
+        # raw_display = pd.DataFrame(worksheet.get_all_records())
+        # raw_display.replace('', np.nan, inplace=True)
+        # betsheet_frame = raw_display.dropna(subset='proj')
         
-        collection = db['Pick6_Trends']
-        cursor = collection.find()
-        raw_display = pd.DataFrame(cursor)
-        raw_display.replace('', np.nan, inplace=True)
-        pick_frame = raw_display.dropna(subset='Player')
+        # collection = db['Pick6_Trends']
+        # cursor = collection.find()
+        # raw_display = pd.DataFrame(cursor)
+        # raw_display.replace('', np.nan, inplace=True)
+        # pick_frame = raw_display.dropna(subset='Player')
+
+        prop_frame = pd.DataFrame()
+        betsheet_frame = pd.DataFrame()
+        pick_frame = pd.DataFrame()
         
         return pitcher_stats, hitter_stats, team_frame, prop_frame, betsheet_frame, pick_frame
 
@@ -349,276 +353,277 @@ with tab4:
                             st.plotly_chart(fig, use_container_width=True)
 
 with tab5:
-    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='reset5'):
-              st.cache_data.clear()
-              pitcher_stats, hitter_stats, team_frame, prop_frame, pick_frame = init_baselines()
-    col1, col2 = st.columns([1, 5])
+    st.warning("The prop frame source is currently down, apologies for the inconvenience")
+    # 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='reset5'):
+    #           st.cache_data.clear()
+    #           pitcher_stats, hitter_stats, team_frame, prop_frame, pick_frame = init_baselines()
+    # 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 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 = ['Draftkings', 'Pick6'])
-        if game_select_var == 'Draftkings':
-            prop_df = prop_frame[['Player', 'over_prop', 'over_line', 'under_line', 'prop_type']]
-            working_source = prop_frame.copy
-        elif game_select_var == 'Pick6':
-            prop_df = pick_frame[['Player', 'over_prop', 'over_line', 'under_line', 'prop_type']]
-            working_source = pick_frame.copy()
-        st.download_button(
-            label="Download Prop Source",
-            data=convert_df_to_csv(prop_df),
-            file_name='MLB_prop_source.csv',
-            mime='text/csv',
-            key='prop_source',
-        )
-        prop_type_var = st.selectbox('Select prop category', options = ['Strikeouts (Pitchers)', 'Total Outs (Pitchers)', 'Earned Runs (Pitchers)', 'Hits Against (Pitchers)',
-                                                                        'Walks Allowed (Pitchers)', 'Total Bases (Hitters)', 'Stolen Bases (Hitters)', 'Walks (Hitters)'])
-
-        if st.button('Simulate Prop Category'):
-            with col2:
+    # with col1:
+    #     game_select_var = st.selectbox('Select prop source', options = ['Draftkings', 'Pick6'])
+    #     if game_select_var == 'Draftkings':
+    #         prop_df = prop_frame[['Player', 'over_prop', 'over_line', 'under_line', 'prop_type']]
+    #         working_source = prop_frame.copy
+    #     elif game_select_var == 'Pick6':
+    #         prop_df = pick_frame[['Player', 'over_prop', 'over_line', 'under_line', 'prop_type']]
+    #         working_source = pick_frame.copy()
+    #     st.download_button(
+    #         label="Download Prop Source",
+    #         data=convert_df_to_csv(prop_df),
+    #         file_name='MLB_prop_source.csv',
+    #         mime='text/csv',
+    #         key='prop_source',
+    #     )
+    #     prop_type_var = st.selectbox('Select prop category', options = ['Strikeouts (Pitchers)', 'Total Outs (Pitchers)', 'Earned Runs (Pitchers)', 'Hits Against (Pitchers)',
+    #                                                                     'Walks Allowed (Pitchers)', 'Total Bases (Hitters)', 'Stolen Bases (Hitters)', 'Walks (Hitters)'])
+
+    #     if st.button('Simulate Prop Category'):
+    #         with col2:
                    
-                    with df_hold_container.container():
-
-                        if prop_type_var == "Strikeouts (Pitchers)":
-                            player_df = pitcher_stats
-                            prop_df = prop_frame[prop_frame['prop_type'] == 'pitcher_strikeouts']
-                            prop_df = prop_df[['Player', 'over_prop', 'over_line', 'under_line']]
-                            prop_df.rename(columns={"over_prop": "Prop"}, inplace = True)
-                            prop_df = prop_df.loc[prop_df['Prop'] != 0]
-                            prop_df['Over'] = np.where(prop_df['over_line'] < 0, (-(prop_df['over_line'])/((-(prop_df['over_line']))+100)), 100/(prop_df['over_line']+100))
-                            prop_df['Under'] = np.where(prop_df['under_line'] < 0, (-(prop_df['under_line'])/((-(prop_df['under_line']))+100)), 100/(prop_df['under_line']+100))
-                            df = pd.merge(player_df, prop_df, how='left', left_on=['Player'], right_on = ['Player'])
-                        elif prop_type_var == "Total Outs (Pitchers)":
-                            player_df = pitcher_stats
-                            prop_df = prop_frame[prop_frame['prop_type'] == 'pitcher_outs']
-                            prop_df = prop_df[['Player', 'over_prop', 'over_line', 'under_line']]
-                            prop_df.rename(columns={"over_prop": "Prop"}, inplace = True)   
-                            prop_df = prop_df.loc[prop_df['Prop'] != 0]
-                            prop_df['Over'] = np.where(prop_df['over_line'] < 0, (-(prop_df['over_line'])/((-(prop_df['over_line']))+100)), 100/(prop_df['over_line']+100))
-                            prop_df['Under'] = np.where(prop_df['under_line'] < 0, (-(prop_df['under_line'])/((-(prop_df['under_line']))+100)), 100/(prop_df['under_line']+100))
-                            df = pd.merge(player_df, prop_df, how='left', left_on=['Player'], right_on = ['Player'])
-                        elif prop_type_var == "Earned Runs (Pitchers)":
-                            player_df = pitcher_stats
-                            prop_df = prop_frame[prop_frame['prop_type'] == 'pitcher_earned_runs']
-                            prop_df = prop_df[['Player', 'over_prop', 'over_line', 'under_line']]
-                            prop_df.rename(columns={"over_prop": "Prop"}, inplace = True)   
-                            prop_df = prop_df.loc[prop_df['Prop'] != 0]
-                            prop_df['Over'] = np.where(prop_df['over_line'] < 0, (-(prop_df['over_line'])/((-(prop_df['over_line']))+100)), 100/(prop_df['over_line']+100))
-                            prop_df['Under'] = np.where(prop_df['under_line'] < 0, (-(prop_df['under_line'])/((-(prop_df['under_line']))+100)), 100/(prop_df['under_line']+100))
-                            df = pd.merge(player_df, prop_df, how='left', left_on=['Player'], right_on = ['Player'])
-                        elif prop_type_var == "Hits Against (Pitchers)":
-                            player_df = pitcher_stats
-                            prop_df = prop_frame[prop_frame['prop_type'] == 'pitcher_hits_allowed']
-                            prop_df = prop_df[['Player', 'over_prop', 'over_line', 'under_line']]
-                            prop_df.rename(columns={"over_prop": "Prop"}, inplace = True)   
-                            prop_df = prop_df.loc[prop_df['Prop'] != 0]
-                            prop_df['Over'] = np.where(prop_df['over_line'] < 0, (-(prop_df['over_line'])/((-(prop_df['over_line']))+100)), 100/(prop_df['over_line']+100))
-                            prop_df['Under'] = np.where(prop_df['under_line'] < 0, (-(prop_df['under_line'])/((-(prop_df['under_line']))+100)), 100/(prop_df['under_line']+100))
-                            df = pd.merge(player_df, prop_df, how='left', left_on=['Player'], right_on = ['Player'])
-                        elif prop_type_var == "Walks Allowed (Pitchers)":
-                            player_df = pitcher_stats
-                            prop_df = prop_frame[prop_frame['prop_type'] == 'pitcher_walks']
-                            prop_df = prop_df[['Player', 'over_prop', 'over_line', 'under_line']]
-                            prop_df.rename(columns={"over_prop": "Prop"}, inplace = True)   
-                            prop_df = prop_df.loc[prop_df['Prop'] != 0]
-                            prop_df['Over'] = np.where(prop_df['over_line'] < 0, (-(prop_df['over_line'])/((-(prop_df['over_line']))+100)), 100/(prop_df['over_line']+100))
-                            prop_df['Under'] = np.where(prop_df['under_line'] < 0, (-(prop_df['under_line'])/((-(prop_df['under_line']))+100)), 100/(prop_df['under_line']+100))
-                            df = pd.merge(player_df, prop_df, how='left', left_on=['Player'], right_on = ['Player'])
-                        elif prop_type_var == "Total Bases (Hitters)":
-                            player_df = hitter_stats
-                            prop_df = prop_frame[prop_frame['prop_type'] == 'batter_total_bases']
-                            prop_df = prop_df[['Player', 'over_prop', 'over_line', 'under_line']]
-                            prop_df.rename(columns={"over_prop": "Prop"}, inplace = True)
-                            prop_df = prop_df.loc[prop_df['Prop'] != 0]
-                            prop_df['Over'] = np.where(prop_df['over_line'] < 0, (-(prop_df['over_line'])/((-(prop_df['over_line']))+100)), 100/(prop_df['over_line']+100))
-                            prop_df['Under'] = np.where(prop_df['under_line'] < 0, (-(prop_df['under_line'])/((-(prop_df['under_line']))+100)), 100/(prop_df['under_line']+100))
-                            df = pd.merge(player_df, prop_df, how='left', left_on=['Player'], right_on = ['Player'])
-                        elif prop_type_var == "Stolen Bases (Hitters)":
-                            player_df = hitter_stats
-                            prop_df = prop_frame[prop_frame['prop_type'] == 'batter_stolen_bases']
-                            prop_df = prop_df[['Player', 'over_prop', 'over_line', 'under_line']]
-                            prop_df.rename(columns={"over_prop": "Prop"}, inplace = True)
-                            prop_df = prop_df.loc[prop_df['Prop'] != 0]
-                            prop_df['Over'] = np.where(prop_df['over_line'] < 0, (-(prop_df['over_line'])/((-(prop_df['over_line']))+100)), 100/(prop_df['over_line']+100))
-                            prop_df['Under'] = np.where(prop_df['under_line'] < 0, (-(prop_df['under_line'])/((-(prop_df['under_line']))+100)), 100/(prop_df['under_line']+100))
-                            df = pd.merge(player_df, prop_df, how='left', left_on=['Player'], right_on = ['Player'])
-                        elif prop_type_var == "Hits (Hitters)":
-                            player_df = hitter_stats
-                            prop_df = prop_frame[prop_frame['prop_type'] == 'batter_hits']
-                            prop_df = prop_df[['Player', 'over_prop', 'over_line', 'under_line']]
-                            prop_df.rename(columns={"over_prop": "Prop"}, inplace = True)
-                            prop_df = prop_df.loc[prop_df['Prop'] != 0]
-                            prop_df['Over'] = np.where(prop_df['over_line'] < 0, (-(prop_df['over_line'])/((-(prop_df['over_line']))+100)), 100/(prop_df['over_line']+100))
-                            prop_df['Under'] = np.where(prop_df['under_line'] < 0, (-(prop_df['under_line'])/((-(prop_df['under_line']))+100)), 100/(prop_df['under_line']+100))
-                            df = pd.merge(player_df, prop_df, how='left', left_on=['Player'], right_on = ['Player'])
-                        elif prop_type_var == "Walks (Hitters)":
-                            player_df = hitter_stats
-                            prop_df = prop_frame[prop_frame['prop_type'] == 'batter_walks']
-                            prop_df = prop_df[['Player', 'over_prop', 'over_line', 'under_line']]
-                            prop_df.rename(columns={"over_prop": "Prop"}, inplace = True)
-                            prop_df = prop_df.loc[prop_df['Prop'] != 0]
-                            prop_df['Over'] = np.where(prop_df['over_line'] < 0, (-(prop_df['over_line'])/((-(prop_df['over_line']))+100)), 100/(prop_df['over_line']+100))
-                            prop_df['Under'] = np.where(prop_df['under_line'] < 0, (-(prop_df['under_line'])/((-(prop_df['under_line']))+100)), 100/(prop_df['under_line']+100))
-                            df = pd.merge(player_df, prop_df, how='left', left_on=['Player'], right_on = ['Player'])
+    #                 with df_hold_container.container():
+
+    #                     if prop_type_var == "Strikeouts (Pitchers)":
+    #                         player_df = pitcher_stats
+    #                         prop_df = prop_frame[prop_frame['prop_type'] == 'pitcher_strikeouts']
+    #                         prop_df = prop_df[['Player', 'over_prop', 'over_line', 'under_line']]
+    #                         prop_df.rename(columns={"over_prop": "Prop"}, inplace = True)
+    #                         prop_df = prop_df.loc[prop_df['Prop'] != 0]
+    #                         prop_df['Over'] = np.where(prop_df['over_line'] < 0, (-(prop_df['over_line'])/((-(prop_df['over_line']))+100)), 100/(prop_df['over_line']+100))
+    #                         prop_df['Under'] = np.where(prop_df['under_line'] < 0, (-(prop_df['under_line'])/((-(prop_df['under_line']))+100)), 100/(prop_df['under_line']+100))
+    #                         df = pd.merge(player_df, prop_df, how='left', left_on=['Player'], right_on = ['Player'])
+    #                     elif prop_type_var == "Total Outs (Pitchers)":
+    #                         player_df = pitcher_stats
+    #                         prop_df = prop_frame[prop_frame['prop_type'] == 'pitcher_outs']
+    #                         prop_df = prop_df[['Player', 'over_prop', 'over_line', 'under_line']]
+    #                         prop_df.rename(columns={"over_prop": "Prop"}, inplace = True)   
+    #                         prop_df = prop_df.loc[prop_df['Prop'] != 0]
+    #                         prop_df['Over'] = np.where(prop_df['over_line'] < 0, (-(prop_df['over_line'])/((-(prop_df['over_line']))+100)), 100/(prop_df['over_line']+100))
+    #                         prop_df['Under'] = np.where(prop_df['under_line'] < 0, (-(prop_df['under_line'])/((-(prop_df['under_line']))+100)), 100/(prop_df['under_line']+100))
+    #                         df = pd.merge(player_df, prop_df, how='left', left_on=['Player'], right_on = ['Player'])
+    #                     elif prop_type_var == "Earned Runs (Pitchers)":
+    #                         player_df = pitcher_stats
+    #                         prop_df = prop_frame[prop_frame['prop_type'] == 'pitcher_earned_runs']
+    #                         prop_df = prop_df[['Player', 'over_prop', 'over_line', 'under_line']]
+    #                         prop_df.rename(columns={"over_prop": "Prop"}, inplace = True)   
+    #                         prop_df = prop_df.loc[prop_df['Prop'] != 0]
+    #                         prop_df['Over'] = np.where(prop_df['over_line'] < 0, (-(prop_df['over_line'])/((-(prop_df['over_line']))+100)), 100/(prop_df['over_line']+100))
+    #                         prop_df['Under'] = np.where(prop_df['under_line'] < 0, (-(prop_df['under_line'])/((-(prop_df['under_line']))+100)), 100/(prop_df['under_line']+100))
+    #                         df = pd.merge(player_df, prop_df, how='left', left_on=['Player'], right_on = ['Player'])
+    #                     elif prop_type_var == "Hits Against (Pitchers)":
+    #                         player_df = pitcher_stats
+    #                         prop_df = prop_frame[prop_frame['prop_type'] == 'pitcher_hits_allowed']
+    #                         prop_df = prop_df[['Player', 'over_prop', 'over_line', 'under_line']]
+    #                         prop_df.rename(columns={"over_prop": "Prop"}, inplace = True)   
+    #                         prop_df = prop_df.loc[prop_df['Prop'] != 0]
+    #                         prop_df['Over'] = np.where(prop_df['over_line'] < 0, (-(prop_df['over_line'])/((-(prop_df['over_line']))+100)), 100/(prop_df['over_line']+100))
+    #                         prop_df['Under'] = np.where(prop_df['under_line'] < 0, (-(prop_df['under_line'])/((-(prop_df['under_line']))+100)), 100/(prop_df['under_line']+100))
+    #                         df = pd.merge(player_df, prop_df, how='left', left_on=['Player'], right_on = ['Player'])
+    #                     elif prop_type_var == "Walks Allowed (Pitchers)":
+    #                         player_df = pitcher_stats
+    #                         prop_df = prop_frame[prop_frame['prop_type'] == 'pitcher_walks']
+    #                         prop_df = prop_df[['Player', 'over_prop', 'over_line', 'under_line']]
+    #                         prop_df.rename(columns={"over_prop": "Prop"}, inplace = True)   
+    #                         prop_df = prop_df.loc[prop_df['Prop'] != 0]
+    #                         prop_df['Over'] = np.where(prop_df['over_line'] < 0, (-(prop_df['over_line'])/((-(prop_df['over_line']))+100)), 100/(prop_df['over_line']+100))
+    #                         prop_df['Under'] = np.where(prop_df['under_line'] < 0, (-(prop_df['under_line'])/((-(prop_df['under_line']))+100)), 100/(prop_df['under_line']+100))
+    #                         df = pd.merge(player_df, prop_df, how='left', left_on=['Player'], right_on = ['Player'])
+    #                     elif prop_type_var == "Total Bases (Hitters)":
+    #                         player_df = hitter_stats
+    #                         prop_df = prop_frame[prop_frame['prop_type'] == 'batter_total_bases']
+    #                         prop_df = prop_df[['Player', 'over_prop', 'over_line', 'under_line']]
+    #                         prop_df.rename(columns={"over_prop": "Prop"}, inplace = True)
+    #                         prop_df = prop_df.loc[prop_df['Prop'] != 0]
+    #                         prop_df['Over'] = np.where(prop_df['over_line'] < 0, (-(prop_df['over_line'])/((-(prop_df['over_line']))+100)), 100/(prop_df['over_line']+100))
+    #                         prop_df['Under'] = np.where(prop_df['under_line'] < 0, (-(prop_df['under_line'])/((-(prop_df['under_line']))+100)), 100/(prop_df['under_line']+100))
+    #                         df = pd.merge(player_df, prop_df, how='left', left_on=['Player'], right_on = ['Player'])
+    #                     elif prop_type_var == "Stolen Bases (Hitters)":
+    #                         player_df = hitter_stats
+    #                         prop_df = prop_frame[prop_frame['prop_type'] == 'batter_stolen_bases']
+    #                         prop_df = prop_df[['Player', 'over_prop', 'over_line', 'under_line']]
+    #                         prop_df.rename(columns={"over_prop": "Prop"}, inplace = True)
+    #                         prop_df = prop_df.loc[prop_df['Prop'] != 0]
+    #                         prop_df['Over'] = np.where(prop_df['over_line'] < 0, (-(prop_df['over_line'])/((-(prop_df['over_line']))+100)), 100/(prop_df['over_line']+100))
+    #                         prop_df['Under'] = np.where(prop_df['under_line'] < 0, (-(prop_df['under_line'])/((-(prop_df['under_line']))+100)), 100/(prop_df['under_line']+100))
+    #                         df = pd.merge(player_df, prop_df, how='left', left_on=['Player'], right_on = ['Player'])
+    #                     elif prop_type_var == "Hits (Hitters)":
+    #                         player_df = hitter_stats
+    #                         prop_df = prop_frame[prop_frame['prop_type'] == 'batter_hits']
+    #                         prop_df = prop_df[['Player', 'over_prop', 'over_line', 'under_line']]
+    #                         prop_df.rename(columns={"over_prop": "Prop"}, inplace = True)
+    #                         prop_df = prop_df.loc[prop_df['Prop'] != 0]
+    #                         prop_df['Over'] = np.where(prop_df['over_line'] < 0, (-(prop_df['over_line'])/((-(prop_df['over_line']))+100)), 100/(prop_df['over_line']+100))
+    #                         prop_df['Under'] = np.where(prop_df['under_line'] < 0, (-(prop_df['under_line'])/((-(prop_df['under_line']))+100)), 100/(prop_df['under_line']+100))
+    #                         df = pd.merge(player_df, prop_df, how='left', left_on=['Player'], right_on = ['Player'])
+    #                     elif prop_type_var == "Walks (Hitters)":
+    #                         player_df = hitter_stats
+    #                         prop_df = prop_frame[prop_frame['prop_type'] == 'batter_walks']
+    #                         prop_df = prop_df[['Player', 'over_prop', 'over_line', 'under_line']]
+    #                         prop_df.rename(columns={"over_prop": "Prop"}, inplace = True)
+    #                         prop_df = prop_df.loc[prop_df['Prop'] != 0]
+    #                         prop_df['Over'] = np.where(prop_df['over_line'] < 0, (-(prop_df['over_line'])/((-(prop_df['over_line']))+100)), 100/(prop_df['over_line']+100))
+    #                         prop_df['Under'] = np.where(prop_df['under_line'] < 0, (-(prop_df['under_line'])/((-(prop_df['under_line']))+100)), 100/(prop_df['under_line']+100))
+    #                         df = pd.merge(player_df, prop_df, how='left', left_on=['Player'], right_on = ['Player'])
                         
-                        prop_dict = dict(zip(df.Player, df.Prop))
-                        over_dict = dict(zip(df.Player, df.Over))
-                        under_dict = dict(zip(df.Player, df.Under))
+    #                     prop_dict = dict(zip(df.Player, df.Prop))
+    #                     over_dict = dict(zip(df.Player, df.Over))
+    #                     under_dict = dict(zip(df.Player, df.Under))
                         
-                        total_sims = 1000
-
-                        df.replace("", 0, inplace=True)
-
-                        if prop_type_var == "Strikeouts (Pitchers)":
-                            df['Median'] = df['Ks']
-                        elif prop_type_var == "Earned Runs (Pitchers)":
-                            df['Median'] = df['ERs']
-                        elif prop_type_var == "Total Outs (Pitchers)":
-                            df['Median'] = df['Outs']
-                        elif prop_type_var == "Hits Against (Pitchers)":
-                            df['Median'] = df['Hits']
-                        elif prop_type_var == "Walks Allowed (Pitchers)":
-                            df['Median'] = df['BB']
-                        elif prop_type_var == "Total Bases (Hitters)":
-                            df['Median'] = df['Total Bases']
-                        elif prop_type_var == "Stolen Bases (Hitters)":
-                            df['Median'] = df['Steals']
-                        elif prop_type_var == "Hits (Hitters)":
-                            df['Median'] = df['Hits']
-                        elif prop_type_var == "Walks (Hitters)":
-                            df['Median'] = df['Walks']
-
-                        flex_file = df
-                        if prop_type_var == 'Strikeouts (Pitchers)':
-                            flex_file['Floor'] = flex_file['Median'] * .20
-                            flex_file['Ceiling'] = flex_file['Median'] * 1.8
-                            flex_file['STD'] = flex_file['Median'] / 4
-                            flex_file['Prop'] = flex_file['Player'].map(prop_dict)
-                            flex_file = flex_file[['Player', 'Prop', 'Floor', 'Median', 'Ceiling', 'STD']]
-
-                        elif prop_type_var == 'Total Outs (Pitchers)':
-                            flex_file['Floor'] = flex_file['Median'] * .20
-                            flex_file['Ceiling'] = flex_file['Median'] * 1.8
-                            flex_file['STD'] = flex_file['Median'] / 4
-                            flex_file['Prop'] = flex_file['Player'].map(prop_dict)
-                            flex_file = flex_file[['Player', 'Prop', 'Floor', 'Median', 'Ceiling', 'STD']]
+    #                     total_sims = 1000
+
+    #                     df.replace("", 0, inplace=True)
+
+    #                     if prop_type_var == "Strikeouts (Pitchers)":
+    #                         df['Median'] = df['Ks']
+    #                     elif prop_type_var == "Earned Runs (Pitchers)":
+    #                         df['Median'] = df['ERs']
+    #                     elif prop_type_var == "Total Outs (Pitchers)":
+    #                         df['Median'] = df['Outs']
+    #                     elif prop_type_var == "Hits Against (Pitchers)":
+    #                         df['Median'] = df['Hits']
+    #                     elif prop_type_var == "Walks Allowed (Pitchers)":
+    #                         df['Median'] = df['BB']
+    #                     elif prop_type_var == "Total Bases (Hitters)":
+    #                         df['Median'] = df['Total Bases']
+    #                     elif prop_type_var == "Stolen Bases (Hitters)":
+    #                         df['Median'] = df['Steals']
+    #                     elif prop_type_var == "Hits (Hitters)":
+    #                         df['Median'] = df['Hits']
+    #                     elif prop_type_var == "Walks (Hitters)":
+    #                         df['Median'] = df['Walks']
+
+    #                     flex_file = df
+    #                     if prop_type_var == 'Strikeouts (Pitchers)':
+    #                         flex_file['Floor'] = flex_file['Median'] * .20
+    #                         flex_file['Ceiling'] = flex_file['Median'] * 1.8
+    #                         flex_file['STD'] = flex_file['Median'] / 4
+    #                         flex_file['Prop'] = flex_file['Player'].map(prop_dict)
+    #                         flex_file = flex_file[['Player', 'Prop', 'Floor', 'Median', 'Ceiling', 'STD']]
+
+    #                     elif prop_type_var == 'Total Outs (Pitchers)':
+    #                         flex_file['Floor'] = flex_file['Median'] * .20
+    #                         flex_file['Ceiling'] = flex_file['Median'] * 1.8
+    #                         flex_file['STD'] = flex_file['Median'] / 4
+    #                         flex_file['Prop'] = flex_file['Player'].map(prop_dict)
+    #                         flex_file = flex_file[['Player', 'Prop', 'Floor', 'Median', 'Ceiling', 'STD']]
                         
-                        elif prop_type_var == 'Earned Runs (Pitchers)':
-                            flex_file['Floor'] = flex_file['Median'] * .20
-                            flex_file['Ceiling'] = flex_file['Median'] * 1.8
-                            flex_file['STD'] = flex_file['Median'] / 4
-                            flex_file['Prop'] = flex_file['Player'].map(prop_dict)
-                            flex_file = flex_file[['Player', 'Prop', 'Floor', 'Median', 'Ceiling', 'STD']]
+    #                     elif prop_type_var == 'Earned Runs (Pitchers)':
+    #                         flex_file['Floor'] = flex_file['Median'] * .20
+    #                         flex_file['Ceiling'] = flex_file['Median'] * 1.8
+    #                         flex_file['STD'] = flex_file['Median'] / 4
+    #                         flex_file['Prop'] = flex_file['Player'].map(prop_dict)
+    #                         flex_file = flex_file[['Player', 'Prop', 'Floor', 'Median', 'Ceiling', 'STD']]
                         
-                        elif prop_type_var == 'Hits Against (Pitchers)':
-                            flex_file['Floor'] = flex_file['Median'] * .20
-                            flex_file['Ceiling'] = flex_file['Median'] * 1.8
-                            flex_file['STD'] = flex_file['Median'] / 4
-                            flex_file['Prop'] = flex_file['Player'].map(prop_dict)
-                            flex_file = flex_file[['Player', 'Prop', 'Floor', 'Median', 'Ceiling', 'STD']]
+    #                     elif prop_type_var == 'Hits Against (Pitchers)':
+    #                         flex_file['Floor'] = flex_file['Median'] * .20
+    #                         flex_file['Ceiling'] = flex_file['Median'] * 1.8
+    #                         flex_file['STD'] = flex_file['Median'] / 4
+    #                         flex_file['Prop'] = flex_file['Player'].map(prop_dict)
+    #                         flex_file = flex_file[['Player', 'Prop', 'Floor', 'Median', 'Ceiling', 'STD']]
                         
-                        elif prop_type_var == 'Walks Allowed (Pitchers)':
-                            flex_file['Floor'] = flex_file['Median'] * .20
-                            flex_file['Ceiling'] = flex_file['Median'] * 1.8
-                            flex_file['STD'] = flex_file['Median'] / 4
-                            flex_file['Prop'] = flex_file['Player'].map(prop_dict)
-                            flex_file = flex_file[['Player', 'Prop', 'Floor', 'Median', 'Ceiling', 'STD']]
-
-                        elif prop_type_var == 'Total Bases (Hitters)':
-                            flex_file['Floor'] = np.where((prop_type_var == "Fantasy") | (prop_type_var == "FD_Fantasy") | (prop_type_var == "PrizePicks"), flex_file['Median'] * .20, 0)
-                            flex_file['Ceiling'] = np.where((prop_type_var == "Fantasy") | (prop_type_var == "FD_Fantasy") | (prop_type_var == "PrizePicks"), flex_file['Median'] * 1.8, flex_file['Median'] * 4)
-                            flex_file['STD'] = flex_file['Median'] / 1.5
-                            flex_file['Prop'] = flex_file['Player'].map(prop_dict)
-                            flex_file = flex_file[['Player', 'Prop', 'Floor', 'Median', 'Ceiling', 'STD']]
-
-                        elif prop_type_var == 'Stolen Bases (Hitters)':
-                            flex_file['Floor'] = np.where((prop_type_var == "Fantasy") | (prop_type_var == "FD_Fantasy") | (prop_type_var == "PrizePicks"), flex_file['Median'] * .20, 0)
-                            flex_file['Ceiling'] = np.where((prop_type_var == "Fantasy") | (prop_type_var == "FD_Fantasy") | (prop_type_var == "PrizePicks"), flex_file['Median'] * 1.8, flex_file['Median'] * 4)
-                            flex_file['STD'] = flex_file['Median'] / 1.5
-                            flex_file['Prop'] = flex_file['Player'].map(prop_dict)
-                            flex_file = flex_file[['Player', 'Prop', 'Floor', 'Median', 'Ceiling', 'STD']]
+    #                     elif prop_type_var == 'Walks Allowed (Pitchers)':
+    #                         flex_file['Floor'] = flex_file['Median'] * .20
+    #                         flex_file['Ceiling'] = flex_file['Median'] * 1.8
+    #                         flex_file['STD'] = flex_file['Median'] / 4
+    #                         flex_file['Prop'] = flex_file['Player'].map(prop_dict)
+    #                         flex_file = flex_file[['Player', 'Prop', 'Floor', 'Median', 'Ceiling', 'STD']]
+
+    #                     elif prop_type_var == 'Total Bases (Hitters)':
+    #                         flex_file['Floor'] = np.where((prop_type_var == "Fantasy") | (prop_type_var == "FD_Fantasy") | (prop_type_var == "PrizePicks"), flex_file['Median'] * .20, 0)
+    #                         flex_file['Ceiling'] = np.where((prop_type_var == "Fantasy") | (prop_type_var == "FD_Fantasy") | (prop_type_var == "PrizePicks"), flex_file['Median'] * 1.8, flex_file['Median'] * 4)
+    #                         flex_file['STD'] = flex_file['Median'] / 1.5
+    #                         flex_file['Prop'] = flex_file['Player'].map(prop_dict)
+    #                         flex_file = flex_file[['Player', 'Prop', 'Floor', 'Median', 'Ceiling', 'STD']]
+
+    #                     elif prop_type_var == 'Stolen Bases (Hitters)':
+    #                         flex_file['Floor'] = np.where((prop_type_var == "Fantasy") | (prop_type_var == "FD_Fantasy") | (prop_type_var == "PrizePicks"), flex_file['Median'] * .20, 0)
+    #                         flex_file['Ceiling'] = np.where((prop_type_var == "Fantasy") | (prop_type_var == "FD_Fantasy") | (prop_type_var == "PrizePicks"), flex_file['Median'] * 1.8, flex_file['Median'] * 4)
+    #                         flex_file['STD'] = flex_file['Median'] / 1.5
+    #                         flex_file['Prop'] = flex_file['Player'].map(prop_dict)
+    #                         flex_file = flex_file[['Player', 'Prop', 'Floor', 'Median', 'Ceiling', 'STD']]
                         
-                        elif prop_type_var == 'Hits (Hitters)':
-                            flex_file['Floor'] = np.where((prop_type_var == "Fantasy") | (prop_type_var == "FD_Fantasy") | (prop_type_var == "PrizePicks"), flex_file['Median'] * .20, 0)
-                            flex_file['Ceiling'] = np.where((prop_type_var == "Fantasy") | (prop_type_var == "FD_Fantasy") | (prop_type_var == "PrizePicks"), flex_file['Median'] * 1.8, flex_file['Median'] * 4)
-                            flex_file['STD'] = flex_file['Median'] / 1.5
-                            flex_file['Prop'] = flex_file['Player'].map(prop_dict)
-                            flex_file = flex_file[['Player', 'Prop', 'Floor', 'Median', 'Ceiling', 'STD']]
+    #                     elif prop_type_var == 'Hits (Hitters)':
+    #                         flex_file['Floor'] = np.where((prop_type_var == "Fantasy") | (prop_type_var == "FD_Fantasy") | (prop_type_var == "PrizePicks"), flex_file['Median'] * .20, 0)
+    #                         flex_file['Ceiling'] = np.where((prop_type_var == "Fantasy") | (prop_type_var == "FD_Fantasy") | (prop_type_var == "PrizePicks"), flex_file['Median'] * 1.8, flex_file['Median'] * 4)
+    #                         flex_file['STD'] = flex_file['Median'] / 1.5
+    #                         flex_file['Prop'] = flex_file['Player'].map(prop_dict)
+    #                         flex_file = flex_file[['Player', 'Prop', 'Floor', 'Median', 'Ceiling', 'STD']]
                         
-                        elif prop_type_var == 'Walks (Hitters)':
-                            flex_file['Floor'] = np.where((prop_type_var == "Fantasy") | (prop_type_var == "FD_Fantasy") | (prop_type_var == "PrizePicks"), flex_file['Median'] * .20, 0)
-                            flex_file['Ceiling'] = np.where((prop_type_var == "Fantasy") | (prop_type_var == "FD_Fantasy") | (prop_type_var == "PrizePicks"), flex_file['Median'] * 1.8, flex_file['Median'] * 4)
-                            flex_file['STD'] = flex_file['Median'] / 1.5
-                            flex_file['Prop'] = flex_file['Player'].map(prop_dict)
-                            flex_file = flex_file[['Player', 'Prop', 'Floor', 'Median', 'Ceiling', 'STD']]
-
-                        hold_file = flex_file
-                        overall_file = flex_file
-                        prop_file = flex_file
+    #                     elif prop_type_var == 'Walks (Hitters)':
+    #                         flex_file['Floor'] = np.where((prop_type_var == "Fantasy") | (prop_type_var == "FD_Fantasy") | (prop_type_var == "PrizePicks"), flex_file['Median'] * .20, 0)
+    #                         flex_file['Ceiling'] = np.where((prop_type_var == "Fantasy") | (prop_type_var == "FD_Fantasy") | (prop_type_var == "PrizePicks"), flex_file['Median'] * 1.8, flex_file['Median'] * 4)
+    #                         flex_file['STD'] = flex_file['Median'] / 1.5
+    #                         flex_file['Prop'] = flex_file['Player'].map(prop_dict)
+    #                         flex_file = flex_file[['Player', 'Prop', 'Floor', 'Median', 'Ceiling', 'STD']]
+
+    #                     hold_file = flex_file
+    #                     overall_file = flex_file
+    #                     prop_file = flex_file
                               
-                        overall_players = overall_file[['Player']]
+    #                     overall_players = overall_file[['Player']]
 
-                        for x in range(0,total_sims):    
-                            prop_file[x] = prop_file['Prop']
+    #                     for x in range(0,total_sims):    
+    #                         prop_file[x] = prop_file['Prop']
 
-                        prop_file = prop_file.drop(['Player', 'Prop', 'Floor', 'Median', 'Ceiling', 'STD'], axis=1)
+    #                     prop_file = prop_file.drop(['Player', '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'])
+    #                     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)
+    #                     overall_file=overall_file.drop(['Player', 'Prop', 'Floor', 'Median', 'Ceiling', 'STD'], axis=1)
 
-                        players_only = hold_file[['Player']]
+    #                     players_only = hold_file[['Player']]
 
-                        player_outcomes = pd.merge(players_only, overall_file, left_index=True, right_index=True)
+    #                     player_outcomes = pd.merge(players_only, overall_file, left_index=True, right_index=True)
 
-                        prop_check = (overall_file - prop_file)
+    #                     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['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['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['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['Player'] = hold_file[['Player']]
 
-                        final_outcomes = players_only[['Player', 'Prop', 'Mean_Outcome', 'Imp Over', 'Over%', 'Imp Under', 'Under%', 'Bet?', 'Edge']]
+    #                     final_outcomes = players_only[['Player', 'Prop', 'Mean_Outcome', 'Imp Over', 'Over%', 'Imp Under', 'Under%', 'Bet?', 'Edge']]
                         
-                        final_outcomes = final_outcomes.sort_values(by='Edge', ascending=False)
+    #                     final_outcomes = final_outcomes.sort_values(by='Edge', ascending=False)
                     
-                        final_outcomes = final_outcomes.set_index('Player')
-
-                        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='MLB_DFS_prop_proj.csv',
-                                mime='text/csv',
-                                key='prop_proj',
-                            )
+    #                     final_outcomes = final_outcomes.set_index('Player')
+
+    #                     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='MLB_DFS_prop_proj.csv',
+    #                             mime='text/csv',
+    #                             key='prop_proj',
+    #                         )
 
 with tab6:
     st.info("This sheet is currently under reconstruction, it'll be back soon!")