Update app.py

app.py

@@ -5,15 +5,11 @@ for name in dir():
     if not name.startswith('_'):
         del globals()[name]
 
-import pulp
 import numpy as np
 import pandas as pd
 import streamlit as st
 import gspread
-import time
 import random
-import scipy.stats
-import os
 
 @st.cache_resource
 def init_conn():
@@ -38,30 +34,8 @@ def init_conn():
 
 gc = init_conn()
 
-game_format = {'Win Percentage': '{:.2%}','First Inning Lead Percentage': '{:.2%}',
-              'Fifth Inning Lead Percentage': '{:.2%}', '8+ runs': '{:.2%}', 'DK LevX': '{:.2%}', 'FD LevX': '{:.2%}'}
-
-player_roo_format = {'Top_finish': '{:.2%}','Top_5_finish': '{:.2%}', 'Top_10_finish': '{:.2%}', '20+%': '{:.2%}', '2x%': '{:.2%}', '3x%': '{:.2%}',
-                   '4x%': '{:.2%}','GPP%': '{:.2%}'}
-
 freq_format = {'Proj Own': '{:.2%}', 'Exposure': '{:.2%}', 'Edge': '{:.2%}'}
 
-@st.cache_resource(ttl = 300)
-def set_slate_teams():
-    sh = gc.open_by_url('https://docs.google.com/spreadsheets/d/1I_1Ve3F4tftgfLQQoRKOJ351XfEG48s36OxXUKxmgS8/edit#gid=1391856348')
-    worksheet = sh.worksheet('Site_Info')
-    raw_display = pd.DataFrame(worksheet.get_all_records())
-
-    return raw_display
-
-@st.cache_resource(ttl = 300)
-def player_stat_table():
-    sh = gc.open_by_url('https://docs.google.com/spreadsheets/d/1I_1Ve3F4tftgfLQQoRKOJ351XfEG48s36OxXUKxmgS8/edit#gid=1391856348')
-    worksheet = sh.worksheet('Player_Projections')
-    raw_display = pd.DataFrame(worksheet.get_all_records())
-
-    return raw_display
-
 @st.cache_resource(ttl = 300)
 def load_dk_player_projections():
     sh = gc.open_by_url('https://docs.google.com/spreadsheets/d/1I_1Ve3F4tftgfLQQoRKOJ351XfEG48s36OxXUKxmgS8/edit#gid=1391856348')
@@ -251,6 +225,8 @@ def create_random_portfolio(Total_Sample_Size, raw_baselines):
             RandomPortfolio = pd.DataFrame(np.hstack(all_choices), columns=['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST'])
             RandomPortfolio['User/Field'] = 0
             
+            del total_elements
+            del all_choices
             del O_merge
           
             return RandomPortfolio, maps_dict, ranges_dict, full_pos_player_dict
@@ -263,28 +239,6 @@ def get_correlated_portfolio_for_sim(Total_Sample_Size):
     stack_num = random.randint(1, 3)
     stacking_dict = create_stack_options(raw_baselines, stack_num)
     
-    # # Create a dictionary for mapping positions to their corresponding dictionaries
-    # dict_map = {
-    #     'QB': qb_dict,
-    #     'RB1': full_pos_player_dict['pos_dicts'][0],
-    #     'RB2': full_pos_player_dict['pos_dicts'][0],
-    #     'WR1': full_pos_player_dict['pos_dicts'][1],
-    #     'WR2': full_pos_player_dict['pos_dicts'][1],
-    #     'WR3': full_pos_player_dict['pos_dicts'][1],
-    #     'TE': full_pos_player_dict['pos_dicts'][2],
-    #     'FLEX': full_pos_player_dict['pos_dicts'][3],
-    #     'DST': def_dict
-    # }
-    
-    # # Apply mapping for each position
-    # for pos, mapping in dict_map.items():
-    #     RandomPortfolio[pos] = RandomPortfolio[pos].map(mapping).astype("string[pyarrow]")
-    
-    # # This part appears to be for filtering. Consider if it can be optimized depending on the data characteristics
-    # RandomPortfolio['plyr_list'] = RandomPortfolio.values.tolist()
-    # RandomPortfolio['plyr_count'] = RandomPortfolio['plyr_list'].apply(lambda x: len(set(x)))
-    # RandomPortfolio = RandomPortfolio[RandomPortfolio['plyr_count'] == 10].drop(columns=['plyr_list','plyr_count']).reset_index(drop=True)
-    
     RandomPortfolio['QB'] = pd.Series(list(RandomPortfolio['QB'].map(qb_dict)), dtype="string[pyarrow]")
     RandomPortfolio['RB1'] = pd.Series(list(RandomPortfolio['RB1'].map(full_pos_player_dict['pos_dicts'][0])), dtype="string[pyarrow]")
     RandomPortfolio['RB2'] = pd.Series(list(RandomPortfolio['RB2'].map(full_pos_player_dict['pos_dicts'][0])), dtype="string[pyarrow]")
@@ -305,8 +259,6 @@ def get_correlated_portfolio_for_sim(Total_Sample_Size):
     del stack_num
     del stacking_dict    
     
-    
-    
     RandomPortfolio['QBs'] = RandomPortfolio['QB'].map(maps_dict['Salary_map']).astype(np.int32)
     RandomPortfolio['RB1s'] = RandomPortfolio['RB1'].map(maps_dict['Salary_map']).astype(np.int32)
     RandomPortfolio['RB2s'] = RandomPortfolio['RB2'].map(maps_dict['Salary_map']).astype(np.int32)
@@ -512,11 +464,10 @@ def get_uncorrelated_portfolio_for_sim(Total_Sample_Size):
     
     return RandomPortfolio, maps_dict
 
-player_stats = player_stat_table()
+
 dk_roo_raw = load_dk_player_projections()
 fd_roo_raw = load_fd_player_projections()
 t_stamp = f"Last Update: " + str(dk_roo_raw['timestamp'][0]) + f" CST"
-site_slates = set_slate_teams()
 dkid_dict, fdid_dict = set_export_ids()
 
 static_exposure = pd.DataFrame(columns=['Player', 'count'])
@@ -815,6 +766,8 @@ with tab1:
                     overall_exposure = overall_exposure.sort_values(by='Exposure', ascending=False)
                     overall_exposure['Exposure'] = overall_exposure['Exposure'].astype(float).map(lambda n: '{:.2%}'.format(n))
                     
+                    del static_exposure
+                    
     with st.container():
           col1, col2 = st.columns([1, 6])
           
@@ -845,7 +798,6 @@ with tab2:
               dk_roo_raw = load_dk_player_projections()
               fd_roo_raw = load_fd_player_projections()
               t_stamp = f"Last Update: " + str(dk_roo_raw['timestamp'][0]) + f" CST"
-              site_slates = set_slate_teams()
               dkid_dict, fdid_dict = set_export_ids()
               
         slate_var1 = st.radio("Which data are you loading?", ('Main Slate', 'Secondary Slate', 'Thurs-Mon Slate', 'User'))
@@ -862,6 +814,8 @@ with tab2:
               elif slate_var1 != 'User':
                   raw_baselines = fd_roo_raw[fd_roo_raw['slate'] == str(slate_var1)]
                   raw_baselines = raw_baselines[raw_baselines['version'] == 'overall']
+        del dk_roo_raw
+        del fd_roo_raw
         st.info("If you are uploading a portfolio, note that there is an adjustments to projections and deviation mapping to prevent 'Projection Bias' and create a fair simulation")
         insert_port1 = st.selectbox("Are you uploading a portfolio?", ('No', 'Yes'), key='insert_port1')
         if insert_port1 == 'Yes':
@@ -889,26 +843,7 @@ with tab2:
             sharp_split = .75
             Strength_var = .01
             scaling_var = 15
-        if 'Sim_Winner_Display' not in st.session_state:
-            st.session_state.Sim_Winner_Display = pd.DataFrame(columns=['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'User/Field', 'Salary', 'Projection', 'Own', 'Fantasy', 'GPP_Proj'])
-        if 'Sim_Winner_Frame' not in st.session_state:
-            st.session_state.Sim_Winner_Frame = pd.DataFrame(columns=['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'User/Field', 'Salary', 'Projection', 'Own', 'Fantasy', 'GPP_Proj'])
-        if 'Sim_Winner_Export' not in st.session_state:
-            st.session_state.Sim_Winner_Export = pd.DataFrame(columns=['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'User/Field', 'Salary', 'Projection', 'Own', 'Fantasy', 'GPP_Proj'])
-        if 'player_freq' not in st.session_state: 
-            st.session_state.player_freq = pd.DataFrame(columns=['Player', 'Position', 'Team', 'Salary', 'Proj Own', 'Exposure', 'Edge'])
-        if 'qb_freq' not in st.session_state: 
-            st.session_state.qb_freq = pd.DataFrame(columns=['Player', 'Position', 'Team', 'Salary', 'Proj Own', 'Exposure', 'Edge'])
-        if 'rb_freq' not in st.session_state: 
-            st.session_state.rb_freq = pd.DataFrame(columns=['Player', 'Position', 'Team', 'Salary', 'Proj Own', 'Exposure', 'Edge'])
-        if 'wr_freq' not in st.session_state: 
-            st.session_state.wr_freq = pd.DataFrame(columns=['Player', 'Position', 'Team', 'Salary', 'Proj Own', 'Exposure', 'Edge'])
-        if 'te_freq' not in st.session_state: 
-            st.session_state.te_freq = pd.DataFrame(columns=['Player', 'Position', 'Team', 'Salary', 'Proj Own', 'Exposure', 'Edge'])
-        if 'flex_freq' not in st.session_state: 
-            st.session_state.flex_freq = pd.DataFrame(columns=['Player', 'Position', 'Team', 'Salary', 'Proj Own', 'Exposure', 'Edge'])
-        if 'dst_freq' not in st.session_state: 
-            st.session_state.dst_freq = pd.DataFrame(columns=['Player', 'Position', 'Team', 'Salary', 'Proj Own', 'Exposure', 'Edge'])
+
     with col2:
         with st.container():
             if st.button("Simulate Contest"):
@@ -926,6 +861,8 @@ with tab2:
                     pass
                 with st.container():
                     st.write('Contest Simulation Starting')
+                    for key in st.session_state.keys():
+                        del st.session_state[key]
                     seed_depth1 = 10
                     Total_Runs = 1000000
                     if Contest_Size <= 1000:
@@ -966,10 +903,11 @@ with tab2:
                             OwnFrame['Own'] = OwnFrame['Own%'] * (900 / OwnFrame['Own%'].sum())
                         Overall_Proj = OwnFrame[['Player', 'Team', 'Position', 'Median', 'Own', 'Salary']]
                         
+                        del proj_dataframe
                         del OwnFrame
                         
                     elif slate_var1 != 'User':
-                        initial_proj = raw_baselines
+                        initial_proj = raw_baselines.copy()
                         drop_frame = initial_proj.drop_duplicates(subset = 'Player',keep = 'first')
                         OwnFrame = drop_frame[['Player', 'Team', 'Position', 'Median', 'Own', 'Floor', 'Ceiling', 'Salary']]
                         if contest_var1 == 'Small':
@@ -989,6 +927,7 @@ with tab2:
                             OwnFrame['Own'] = OwnFrame['Own%'] * (900 / OwnFrame['Own%'].sum())
                         Overall_Proj = OwnFrame[['Player', 'Team', 'Position', 'Median', 'Own', 'Salary']]
                         
+                        del raw_baselines
                         del initial_proj
                         del drop_frame
                         del OwnFrame
@@ -1225,16 +1164,19 @@ with tab2:
                         SimVar += 1
     
                             
-                    # del smple_arrays
-                    # del smple_arrays1
-                    # del smple_arrays2
-                    # del final_array
-                    # del best_lineup
+                    del vec_projection_map
+                    del vec_stdev_map
+                    del sample_arrays
+                    del final_array
+                    del fp_array
+                    del fp_random
                     st.write('Contest simulation complete')
                     # Initial setup
                     Sim_Winner_Frame = pd.DataFrame(np.concatenate(Sim_Winners), columns=FinalPortfolio.columns.tolist() + ['Fantasy'])
                     Sim_Winner_Frame['GPP_Proj'] = (Sim_Winner_Frame['Projection'] + Sim_Winner_Frame['Fantasy']) / 2
                     
+                    del FinalPortfolio
+                    
                     # Type Casting
                     type_cast_dict = {'Salary': int, 'Projection': np.float16, 'Fantasy': np.float16, 'GPP_Proj': np.float16}
                     Sim_Winner_Frame = Sim_Winner_Frame.astype(type_cast_dict)
@@ -1245,6 +1187,8 @@ with tab2:
                     # Data Copying
                     st.session_state.Sim_Winner_Export = Sim_Winner_Frame.copy()
                     
+                    del Sim_Winner_Frame
+                    
                     # Conditional Replacement
                     columns_to_replace = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
                     
@@ -1253,11 +1197,14 @@ with tab2:
                     elif site_var1 == 'Fanduel':
                         replace_dict = fdid_dict
                     
+                    del dkid_dict
+                    del fdid_dict
+                    
                     for col in columns_to_replace:
                         st.session_state.Sim_Winner_Export[col].replace(replace_dict, inplace=True)
     
                     
-                    player_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,0:9].values, return_counts=True)),
+                    player_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,0:9].values, return_counts=True)),
                                                 columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
                     player_freq['Freq'] = player_freq['Freq'].astype(int)
                     player_freq['Position'] = player_freq['Player'].map(maps_dict['Pos_map'])
@@ -1270,8 +1217,9 @@ with tab2:
                                         player_freq['Team'] = player_freq['Team'].replace(item_list, team_list)
     
                     st.session_state.player_freq = player_freq[['Player', 'Position', 'Team', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
+                    del player_freq
                     
-                    qb_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,0:1].values, return_counts=True)),
+                    qb_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,0:1].values, return_counts=True)),
                                                 columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
                     qb_freq['Freq'] = qb_freq['Freq'].astype(int)
                     qb_freq['Position'] = qb_freq['Player'].map(maps_dict['Pos_map'])
@@ -1284,8 +1232,9 @@ with tab2:
                                         qb_freq['Team'] = qb_freq['Team'].replace(item_list, team_list)
     
                     st.session_state.qb_freq = qb_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
+                    del qb_freq
     
-                    rb_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,[1, 2]].values, return_counts=True)),
+                    rb_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,[1, 2]].values, return_counts=True)),
                                                columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
                     rb_freq['Freq'] = rb_freq['Freq'].astype(int)
                     rb_freq['Position'] = rb_freq['Player'].map(maps_dict['Pos_map'])
@@ -1298,8 +1247,9 @@ with tab2:
                                         rb_freq['Team'] = rb_freq['Team'].replace(item_list, team_list)
     
                     st.session_state.rb_freq = rb_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
+                    del rb_freq
                     
-                    wr_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,[3, 4, 5]].values, return_counts=True)),
+                    wr_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,[3, 4, 5]].values, return_counts=True)),
                                                columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
                     wr_freq['Freq'] = wr_freq['Freq'].astype(int)
                     wr_freq['Position'] = wr_freq['Player'].map(maps_dict['Pos_map'])
@@ -1312,8 +1262,9 @@ with tab2:
                                         wr_freq['Team'] = wr_freq['Team'].replace(item_list, team_list)
     
                     st.session_state.wr_freq = wr_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
+                    del wr_freq
                     
-                    te_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,[6]].values, return_counts=True)),
+                    te_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,[6]].values, return_counts=True)),
                                                columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
                     te_freq['Freq'] = te_freq['Freq'].astype(int)
                     te_freq['Position'] = te_freq['Player'].map(maps_dict['Pos_map'])
@@ -1326,8 +1277,9 @@ with tab2:
                                         te_freq['Team'] = te_freq['Team'].replace(item_list, team_list)
     
                     st.session_state.te_freq = te_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
+                    del te_freq
                     
-                    flex_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,[7]].values, return_counts=True)),
+                    flex_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,[7]].values, return_counts=True)),
                                                columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
                     flex_freq['Freq'] = flex_freq['Freq'].astype(int)
                     flex_freq['Position'] = flex_freq['Player'].map(maps_dict['Pos_map'])
@@ -1340,8 +1292,9 @@ with tab2:
                                         flex_freq['Team'] = flex_freq['Team'].replace(item_list, team_list)
     
                     st.session_state.flex_freq = flex_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
+                    del flex_freq
                     
-                    dst_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,8:9].values, return_counts=True)),
+                    dst_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,8:9].values, return_counts=True)),
                                                columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
                     dst_freq['Freq'] = dst_freq['Freq'].astype(int)
                     dst_freq['Position'] = dst_freq['Player'].map(maps_dict['Pos_map'])
@@ -1354,84 +1307,95 @@ with tab2:
                                         dst_freq['Team'] = dst_freq['Team'].replace(item_list, team_list)
     
                     st.session_state.dst_freq = dst_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
+                    del dst_freq
+                    del maps_dict
                 
         with st.container():
             simulate_container = st.empty()
-            player_split_var2 = st.radio("Are you wanting to isolate any lineups with specific players?", ('Full Players', 'Specific Players'))
-            if player_split_var2 == 'Specific Players':
-                      find_var2 = st.multiselect('Which players must be included in the lineups?', options = st.session_state.player_freq['Player'].unique())
-            elif player_split_var2 == 'Full Players':
-                      find_var2 = st.session_state.player_freq.Player.values.tolist()
-
-            if player_split_var2 == 'Specific Players':
-                      st.session_state.Sim_Winner_Display = st.session_state.Sim_Winner_Frame[np.equal.outer(st.session_state.Sim_Winner_Frame.to_numpy(copy=False),  find_var2).any(axis=1).all(axis=1)]
-            if player_split_var2 == 'Full Players':
-                      st.session_state.Sim_Winner_Display = st.session_state.Sim_Winner_Frame
-            st.dataframe(st.session_state.Sim_Winner_Display.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').background_gradient(cmap='RdYlGn_r', subset=['Own']).format(precision=2), use_container_width = True)
-        
-            st.download_button(
-                label="Export Tables",
-                data=convert_df_to_csv(st.session_state.Sim_Winner_Export),
-                file_name='NFL_consim_export.csv',
-                mime='text/csv',
-            )
+            if 'player_freq' in st.session_state: 
+                player_split_var2 = st.radio("Are you wanting to isolate any lineups with specific players?", ('Full Players', 'Specific Players'), key='player_split_var2')
+                if player_split_var2 == 'Specific Players':
+                          find_var2 = st.multiselect('Which players must be included in the lineups?', options = st.session_state.player_freq['Player'].unique())
+                elif player_split_var2 == 'Full Players':
+                          find_var2 = st.session_state.player_freq.Player.values.tolist()
+    
+                if player_split_var2 == 'Specific Players':
+                          st.session_state.Sim_Winner_Display = st.session_state.Sim_Winner_Frame[np.equal.outer(st.session_state.Sim_Winner_Frame.to_numpy(copy=False),  find_var2).any(axis=1).all(axis=1)]
+                if player_split_var2 == 'Full Players':
+                          st.session_state.Sim_Winner_Display = st.session_state.Sim_Winner_Frame
+            if 'Sim_Winner_Display' in st.session_state:
+                st.dataframe(st.session_state.Sim_Winner_Display.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').background_gradient(cmap='RdYlGn_r', subset=['Own']).format(precision=2), use_container_width = True)
+            if 'Sim_Winner_Export' in st.session_state:
+                st.download_button(
+                    label="Export Tables",
+                    data=convert_df_to_csv(st.session_state.Sim_Winner_Export),
+                    file_name='NFL_consim_export.csv',
+                    mime='text/csv',
+                )
         
         with st.container():
             freq_container = st.empty()
             tab1, tab2, tab3, tab4, tab5, tab6, tab7 = st.tabs(['Overall Exposures', 'QB Exposures', 'RB Exposures', 'WR Exposures', 'TE Exposures', 'FLEX Exposures', 'DST Exposures'])
             with tab1:
-                st.dataframe(st.session_state.player_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
-                st.download_button(
-                    label="Export Exposures",
-                    data=convert_df_to_csv(st.session_state.player_freq),
-                    file_name='player_freq_export.csv',
-                    mime='text/csv',
-                )
+                if 'player_freq' in st.session_state:
+                    st.dataframe(st.session_state.player_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
+                    st.download_button(
+                        label="Export Exposures",
+                        data=convert_df_to_csv(st.session_state.player_freq),
+                        file_name='player_freq_export.csv',
+                        mime='text/csv',
+                    )
             with tab2:
-                st.dataframe(st.session_state.qb_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
-                st.download_button(
-                    label="Export Exposures",
-                    data=convert_df_to_csv(st.session_state.qb_freq),
-                    file_name='qb_freq_export.csv',
-                    mime='text/csv',
-                )
+                if 'qb_freq' in st.session_state:
+                    st.dataframe(st.session_state.qb_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
+                    st.download_button(
+                        label="Export Exposures",
+                        data=convert_df_to_csv(st.session_state.qb_freq),
+                        file_name='qb_freq_export.csv',
+                        mime='text/csv',
+                    )
             with tab3:
-                st.dataframe(st.session_state.rb_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
-                st.download_button(
-                    label="Export Exposures",
-                    data=convert_df_to_csv(st.session_state.rb_freq),
-                    file_name='rb_freq_export.csv',
-                    mime='text/csv',
-                )
+                if 'rb_freq' in st.session_state:
+                    st.dataframe(st.session_state.rb_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
+                    st.download_button(
+                        label="Export Exposures",
+                        data=convert_df_to_csv(st.session_state.rb_freq),
+                        file_name='rb_freq_export.csv',
+                        mime='text/csv',
+                    )
             with tab4:
-                st.dataframe(st.session_state.wr_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
-                st.download_button(
-                    label="Export Exposures",
-                    data=convert_df_to_csv(st.session_state.wr_freq),
-                    file_name='wr_freq_export.csv',
-                    mime='text/csv',
-                )
+                if 'wr_freq' in st.session_state:
+                    st.dataframe(st.session_state.wr_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
+                    st.download_button(
+                        label="Export Exposures",
+                        data=convert_df_to_csv(st.session_state.wr_freq),
+                        file_name='wr_freq_export.csv',
+                        mime='text/csv',
+                    )
             with tab5:
-                st.dataframe(st.session_state.te_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
-                st.download_button(
-                    label="Export Exposures",
-                    data=convert_df_to_csv(st.session_state.te_freq),
-                    file_name='te_freq_export.csv',
-                    mime='text/csv',
-                )
+                if 'te_freq' in st.session_state:
+                    st.dataframe(st.session_state.te_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
+                    st.download_button(
+                        label="Export Exposures",
+                        data=convert_df_to_csv(st.session_state.te_freq),
+                        file_name='te_freq_export.csv',
+                        mime='text/csv',
+                    )
             with tab6:
-                st.dataframe(st.session_state.flex_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
-                st.download_button(
-                    label="Export Exposures",
-                    data=convert_df_to_csv(st.session_state.flex_freq),
-                    file_name='flex_freq_export.csv',
-                    mime='text/csv',
-                )
+                if 'flex_freq' in st.session_state:
+                    st.dataframe(st.session_state.flex_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
+                    st.download_button(
+                        label="Export Exposures",
+                        data=convert_df_to_csv(st.session_state.flex_freq),
+                        file_name='flex_freq_export.csv',
+                        mime='text/csv',
+                    )
             with tab7:
-                st.dataframe(st.session_state.dst_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
-                st.download_button(
-                    label="Export Exposures",
-                    data=convert_df_to_csv(st.session_state.dst_freq),
-                    file_name='dst_freq_export.csv',
-                    mime='text/csv',
-                )
+                if 'dst_freq' in st.session_state:
+                    st.dataframe(st.session_state.dst_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
+                    st.download_button(
+                        label="Export Exposures",
+                        data=convert_df_to_csv(st.session_state.dst_freq),
+                        file_name='dst_freq_export.csv',
+                        mime='text/csv',
+                    )