Update app.py

app.py

@@ -29,38 +29,37 @@ def init_conn():
             "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/gspread-connection%40sheets-api-connect-378620.iam.gserviceaccount.com"
           }
 
-          gc = gspread.service_account_from_dict(credentials)
-          return gc
+          gc_con = gspread.service_account_from_dict(credentials)
+          
+          return gc_con
 
-gc = init_conn()
+gcservice_account = init_conn()
 
 freq_format = {'Proj Own': '{:.2%}', 'Exposure': '{:.2%}', 'Edge': '{:.2%}'}
 
 @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')
+    sh = gcservice_account.open_by_url('https://docs.google.com/spreadsheets/d/1I_1Ve3F4tftgfLQQoRKOJ351XfEG48s36OxXUKxmgS8/edit#gid=1391856348')
     worksheet = sh.worksheet('DK_ROO')
     load_display = pd.DataFrame(worksheet.get_all_records())
     load_display.replace('', np.nan, inplace=True)
     raw_display = load_display.dropna(subset=['Median'])
-    del load_display
 
     return raw_display
 
 @st.cache_resource(ttl = 300)
 def load_fd_player_projections():
-    sh = gc.open_by_url('https://docs.google.com/spreadsheets/d/1I_1Ve3F4tftgfLQQoRKOJ351XfEG48s36OxXUKxmgS8/edit#gid=1391856348')
+    sh = gcservice_account.open_by_url('https://docs.google.com/spreadsheets/d/1I_1Ve3F4tftgfLQQoRKOJ351XfEG48s36OxXUKxmgS8/edit#gid=1391856348')
     worksheet = sh.worksheet('FD_ROO')
     load_display = pd.DataFrame(worksheet.get_all_records())
     load_display.replace('', np.nan, inplace=True)
     raw_display = load_display.dropna(subset=['Median'])
-    del load_display
 
     return raw_display
 
 @st.cache_resource(ttl = 300)
 def set_export_ids():
-    sh = gc.open_by_url('https://docs.google.com/spreadsheets/d/1I_1Ve3F4tftgfLQQoRKOJ351XfEG48s36OxXUKxmgS8/edit#gid=1391856348')
+    sh = gcservice_account.open_by_url('https://docs.google.com/spreadsheets/d/1I_1Ve3F4tftgfLQQoRKOJ351XfEG48s36OxXUKxmgS8/edit#gid=1391856348')
     worksheet = sh.worksheet('DK_ROO')
     load_display = pd.DataFrame(worksheet.get_all_records())
     load_display.replace('', np.nan, inplace=True)
@@ -72,61 +71,104 @@ def set_export_ids():
     load_display.replace('', np.nan, inplace=True)
     raw_display = load_display.dropna(subset=['Median'])
     fd_ids = dict(zip(raw_display['Player'], raw_display['player_id']))
-    
-    del load_display
-    del raw_display
 
     return dk_ids, fd_ids
 
-@st.cache_data
-def convert_df_to_csv(df):
-    return df.to_csv().encode('utf-8')
+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"
+dkid_dict, fdid_dict = set_export_ids()
 
-def run_seed_frame(seed_depth1, Strength_var, strength_grow, Teams_used, Total_Runs):
+static_exposure = pd.DataFrame(columns=['Player', 'count'])
+overall_exposure = pd.DataFrame(columns=['Player', 'count'])
+    
+def sim_contest(Sim_size, FinalPortfolio, CleanPortfolio, maps_dict, up_dict, insert_port):
+    SimVar = 1
+    Sim_Winners = []
+    fp_array = FinalPortfolio.values
+    
+    if insert_port == 1:
+        up_array = CleanPortfolio.values
+    
+    # Pre-vectorize functions
+    vec_projection_map = np.vectorize(maps_dict['Projection_map'].__getitem__)
+    vec_stdev_map = np.vectorize(maps_dict['STDev_map'].__getitem__)
+    
+    if insert_port == 1:
+        vec_up_projection_map = np.vectorize(up_dict['Projection_map'].__getitem__)
+        vec_up_stdev_map = np.vectorize(up_dict['STDev_map'].__getitem__)
+    
+    st.write('Simulating contest on frames')
+    
+    while SimVar <= Sim_size:
+        if insert_port == 1:
+            fp_random = fp_array[np.random.choice(fp_array.shape[0], Contest_Size-len(CleanPortfolio))]
+        elif insert_port == 0:
+            fp_random = fp_array[np.random.choice(fp_array.shape[0], Contest_Size)]
+            
+        sample_arrays1 = np.c_[
+            fp_random, 
+            np.sum(np.random.normal(
+                loc=vec_projection_map(fp_random[:, :-5]),
+                scale=vec_stdev_map(fp_random[:, :-5])),
+            axis=1)
+        ]
+
+        if insert_port == 1:
+            sample_arrays2 = np.c_[
+                up_array, 
+                np.sum(np.random.normal(
+                    loc=vec_up_projection_map(up_array[:, :-5]),
+                    scale=vec_up_stdev_map(up_array[:, :-5])),
+                axis=1)
+            ]
+            sample_arrays = np.vstack((sample_arrays1, sample_arrays2))
+        else:
+            sample_arrays = sample_arrays1
+
+        final_array = sample_arrays[sample_arrays[:, 10].argsort()[::-1]]
+        best_lineup = final_array[final_array[:, -1].argsort(kind='stable')[::-1][:1]]
+        Sim_Winners.append(best_lineup)
+        SimVar += 1
+        
+    return Sim_Winners
+
+def run_seed_frame(seed_depth1, Strength_var, strength_grow, Teams_used, Total_Runs, field_growth):
     RunsVar = 1
     seed_depth_def = seed_depth1
     Strength_var_def = Strength_var
     strength_grow_def = strength_grow
     Teams_used_def = Teams_used
     Total_Runs_def = Total_Runs
+    
     while RunsVar <= seed_depth_def:
         if RunsVar <= 3:
             FieldStrength = Strength_var_def
-            FinalPortfolio, maps_dict = get_correlated_portfolio_for_sim(Total_Runs_def * .1, sharp_split)
-            FinalPortfolio2, maps_dict2 = get_uncorrelated_portfolio_for_sim(Total_Runs_def * .1, sharp_split)
-            FinalPortfolio = pd.concat([FinalPortfolio, FinalPortfolio2], axis=0)
+            FinalPortfolio, maps_dict = get_correlated_portfolio_for_sim(Total_Runs_def * .25, sharp_split, field_growth)
+            FinalPortfolio2, maps_dict2 = get_uncorrelated_portfolio_for_sim(Total_Runs_def * .25, sharp_split, field_growth)
+            FinalPortfolio_init = pd.concat([FinalPortfolio, FinalPortfolio2], axis=0)
             maps_dict.update(maps_dict2)
-            del FinalPortfolio2
-            del maps_dict2
         elif RunsVar > 3 and RunsVar <= 4:
             FieldStrength += (strength_grow_def + ((30 - len(Teams_used_def)) * .001))
-            FinalPortfolio3, maps_dict3 = get_correlated_portfolio_for_sim(Total_Runs_def * .1, sharp_split)
-            FinalPortfolio4, maps_dict4 = get_uncorrelated_portfolio_for_sim(Total_Runs_def * .1, sharp_split)
-            FinalPortfolio = pd.concat([FinalPortfolio, FinalPortfolio3], axis=0)
-            FinalPortfolio = pd.concat([FinalPortfolio, FinalPortfolio4], axis=0)
-            FinalPortfolio = FinalPortfolio.drop_duplicates(subset = ['Projection', 'Own'],keep = 'last').reset_index(drop = True)
+            FinalPortfolio3, maps_dict3 = get_correlated_portfolio_for_sim(Total_Runs_def * .25, sharp_split, field_growth)
+            FinalPortfolio4, maps_dict4 = get_uncorrelated_portfolio_for_sim(Total_Runs_def * .25, sharp_split, field_growth)
+            FinalPortfolio_merge_3 = pd.concat([FinalPortfolio_init, FinalPortfolio3], axis=0)
+            FinalPortfolio_merge_4 = pd.concat([FinalPortfolio_merge_3, FinalPortfolio4], axis=0)
+            FinalPortfolio_step_2 = FinalPortfolio_merge_4.drop_duplicates(subset = ['Projection', 'Own'],keep = 'last').reset_index(drop = True)
             maps_dict.update(maps_dict3)
             maps_dict.update(maps_dict4)
-            del FinalPortfolio3
-            del maps_dict3
-            del FinalPortfolio4
-            del maps_dict4
         elif RunsVar > 4:
             FieldStrength = 1
-            FinalPortfolio3, maps_dict3 = get_correlated_portfolio_for_sim(Total_Runs_def * .1, sharp_split)
-            FinalPortfolio4, maps_dict4 = get_uncorrelated_portfolio_for_sim(Total_Runs_def * .1, sharp_split)
-            FinalPortfolio = pd.concat([FinalPortfolio, FinalPortfolio3], axis=0)
-            FinalPortfolio = pd.concat([FinalPortfolio, FinalPortfolio4], axis=0)
-            FinalPortfolio = FinalPortfolio.drop_duplicates(subset = ['Projection', 'Own'],keep = 'last').reset_index(drop = True)
-            maps_dict.update(maps_dict3)
-            maps_dict.update(maps_dict4)
-            del FinalPortfolio3
-            del maps_dict3
-            del FinalPortfolio4
-            del maps_dict4
+            FinalPortfolio5, maps_dict5 = get_correlated_portfolio_for_sim(Total_Runs_def * .25, sharp_split, field_growth)
+            FinalPortfolio6, maps_dict6 = get_uncorrelated_portfolio_for_sim(Total_Runs_def * .25, sharp_split, field_growth)
+            FinalPortfolio_merge_5 = pd.concat([FinalPortfolio_step_2, FinalPortfolio5], axis=0)
+            FinalPortfolio_merge_6 = pd.concat([FinalPortfolio_merge_5, FinalPortfolio6], axis=0)
+            FinalPortfolio_export = FinalPortfolio_merge_6.drop_duplicates(subset = ['Projection', 'Own'],keep = 'last').reset_index(drop = True)
+            maps_dict.update(maps_dict5)
+            maps_dict.update(maps_dict6)
         RunsVar += 1
-        
-    return FinalPortfolio, maps_dict
+    
+    return FinalPortfolio_export, maps_dict
 
 def create_stack_options(player_data, wr_var):
         merged_frame = pd.DataFrame(columns = ['QB', 'Player'])
@@ -142,9 +184,6 @@ def create_stack_options(player_data, wr_var):
         merged_frame = merged_frame.reset_index()
         correl_dict = dict(zip(merged_frame.QB, merged_frame.Player))
         
-        del merged_frame
-        del data_raw
-    
         return correl_dict
 
 def create_overall_dfs(pos_players, table_name, dict_name, pos):
@@ -154,17 +193,11 @@ def create_overall_dfs(pos_players, table_name, dict_name, pos):
         overall_table_name = table_name_raw.head(round(len(table_name_raw)))
         overall_table_name = overall_table_name.assign(Var = range(0,len(overall_table_name)))
         overall_dict_name = pd.Series(overall_table_name.Player.values, index=overall_table_name.Var).to_dict()
-        
-        del pos_players
-        del table_name_raw
     elif pos != "FLEX":
         table_name_raw = pos_players[pos_players['Position'].str.contains(pos)].reset_index(drop=True)
         overall_table_name = table_name_raw.head(round(len(table_name_raw)))
         overall_table_name = overall_table_name.assign(Var = range(0,len(overall_table_name)))
         overall_dict_name = pd.Series(overall_table_name.Player.values, index=overall_table_name.Var).to_dict()
-        
-        del pos_players
-        del table_name_raw
     
     return overall_table_name, overall_dict_name
 
@@ -182,17 +215,20 @@ def get_overall_merged_df():
         
     df_out = pd.concat(ref_dict['pos_dfs'], ignore_index=True)
     
-    return df_out, ref_dict
+    return ref_dict
 
 def calculate_range_var(count, min_val, FieldStrength, field_growth):
     var = round(len(count[0]) * FieldStrength)
     var = max(var, min_val)
     var += round(field_growth)
+    
     return min(var, len(count[0]))
 
-def create_random_portfolio(Total_Sample_Size, raw_baselines):
+def create_random_portfolio(Total_Sample_Size, raw_baselines, field_growth):
+            
+            st.write('Creating Seed Frames')
     
-            O_merge, full_pos_player_dict = get_overall_merged_df()
+            full_pos_player_dict = get_overall_merged_df()
             max_var = len(raw_baselines[raw_baselines['Position'] == 'QB'])
           
             field_growth_rounded = round(field_growth)
@@ -211,9 +247,6 @@ def create_random_portfolio(Total_Sample_Size, raw_baselines):
             elif max_var > 16:
                 ranges_dict['qb_range'] = round(max_var / 2)
                 ranges_dict['dst_range'] = round(max_var)
-            # Generate unique ranges
-            # for key, value in ranges_dict.items():
-            #     ranges_dict[f"{key}_Uniques"] = list(range(0, value, 1))
             
             # Generate random portfolios
             rng = np.random.default_rng()
@@ -223,19 +256,14 @@ def create_random_portfolio(Total_Sample_Size, raw_baselines):
             all_choices = [rng.choice(ranges_dict[f"{key}_range"], size=(Total_Sample_Size, elem)) for key, elem in zip(keys, total_elements)]
             RandomPortfolio = pd.DataFrame(np.hstack(all_choices), columns=['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST'])
             RandomPortfolio['User/Field'] = 0
-            
-            del rng
-            del total_elements
-            del all_choices
-            del O_merge
           
             return RandomPortfolio, maps_dict, ranges_dict, full_pos_player_dict
 
-def get_correlated_portfolio_for_sim(Total_Sample_Size, sharp_split):
+def get_correlated_portfolio_for_sim(Total_Sample_Size, sharp_split, field_growth):
     
     sizesplit = round(Total_Sample_Size * sharp_split)
     
-    RandomPortfolio, maps_dict, ranges_dict, full_pos_player_dict = create_random_portfolio(sizesplit, raw_baselines)
+    RandomPortfolio, maps_dict, ranges_dict, full_pos_player_dict = create_random_portfolio(sizesplit, raw_baselines, field_growth)
     stack_num = random.randint(1, 3)
     stacking_dict = create_stack_options(raw_baselines, stack_num)
     
@@ -253,12 +281,6 @@ def get_correlated_portfolio_for_sim(Total_Sample_Size, sharp_split):
     RandomPortfolio = RandomPortfolio[RandomPortfolio['plyr_count'] == 10].drop(columns=['plyr_list','plyr_count']).\
         reset_index(drop=True)
     
-    del sizesplit
-    del full_pos_player_dict
-    del ranges_dict
-    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)
@@ -290,7 +312,6 @@ def get_correlated_portfolio_for_sim(Total_Sample_Size, sharp_split):
     RandomPortfolio['DSTo'] = RandomPortfolio['DST'].map(maps_dict['Own_map']).astype(np.float16)
     
     RandomPortArray = RandomPortfolio.to_numpy()
-    del RandomPortfolio
     
     RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,10:19].astype(int))]
     RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,19:28].astype(np.double))]
@@ -299,8 +320,6 @@ def get_correlated_portfolio_for_sim(Total_Sample_Size, sharp_split):
     RandomPortArrayOut = np.delete(RandomPortArray, np.s_[10:37], axis=1)
     RandomPortfolioDF = pd.DataFrame(RandomPortArrayOut, columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'User/Field', 'Salary', 'Projection', 'Own'])
     RandomPortfolioDF = RandomPortfolioDF.sort_values(by=Sim_function, ascending=False)
-    del RandomPortArray
-    del RandomPortArrayOut
     
     if insert_port == 1:
         CleanPortfolio['Salary'] = sum([CleanPortfolio['QB'].map(maps_dict['Salary_map']),
@@ -345,17 +364,15 @@ def get_correlated_portfolio_for_sim(Total_Sample_Size, sharp_split):
     
     RandomPortfolio = RandomPortfolioDF.sort_values(by=Sim_function, ascending=False)
     
-    del RandomPortfolioDF
-    
     RandomPortfolio = RandomPortfolio[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'User/Field', 'Salary', 'Projection', 'Own']]
     
     return RandomPortfolio, maps_dict
           
-def get_uncorrelated_portfolio_for_sim(Total_Sample_Size, sharp_split):
+def get_uncorrelated_portfolio_for_sim(Total_Sample_Size, sharp_split, field_growth):
     
     sizesplit = round(Total_Sample_Size * (1-sharp_split))
 
-    RandomPortfolio, maps_dict, ranges_dict, full_pos_player_dict = create_random_portfolio(sizesplit, raw_baselines)
+    RandomPortfolio, maps_dict, ranges_dict, full_pos_player_dict = create_random_portfolio(sizesplit, raw_baselines, field_growth)
           
     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]")
@@ -371,10 +388,6 @@ def get_uncorrelated_portfolio_for_sim(Total_Sample_Size, sharp_split):
     RandomPortfolio = RandomPortfolio[RandomPortfolio['plyr_count'] == 10].drop(columns=['plyr_list','plyr_count']).\
         reset_index(drop=True)
     
-    del sizesplit
-    del full_pos_player_dict
-    del ranges_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)
@@ -406,7 +419,6 @@ def get_uncorrelated_portfolio_for_sim(Total_Sample_Size, sharp_split):
     RandomPortfolio['DSTo'] = RandomPortfolio['DST'].map(maps_dict['Own_map']).astype(np.float16)
     
     RandomPortArray = RandomPortfolio.to_numpy()
-    del RandomPortfolio
     
     RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,10:19].astype(int))]
     RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,19:28].astype(np.double))]
@@ -415,9 +427,6 @@ def get_uncorrelated_portfolio_for_sim(Total_Sample_Size, sharp_split):
     RandomPortArrayOut = np.delete(RandomPortArray, np.s_[10:37], axis=1)
     RandomPortfolioDF = pd.DataFrame(RandomPortArrayOut, columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'User/Field', 'Salary', 'Projection', 'Own'])
     RandomPortfolioDF = RandomPortfolioDF.sort_values(by=Sim_function, ascending=False)
-    del RandomPortArray
-    del RandomPortArrayOut
-    # st.table(RandomPortfolioDF.head(50))
           
     if insert_port == 1:
         CleanPortfolio['Salary'] = sum([CleanPortfolio['QB'].map(maps_dict['Salary_map']),
@@ -464,19 +473,8 @@ def get_uncorrelated_portfolio_for_sim(Total_Sample_Size, sharp_split):
     
     RandomPortfolio = RandomPortfolio[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'User/Field', 'Salary', 'Projection', 'Own']]
     
-    del RandomPortfolioDF
-    
     return RandomPortfolio, maps_dict
 
-
-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"
-dkid_dict, fdid_dict = set_export_ids()
-
-static_exposure = pd.DataFrame(columns=['Player', 'count'])
-overall_exposure = pd.DataFrame(columns=['Player', 'count'])
-
 tab1, tab2 = st.tabs(['Uploads', 'Contest Sim'])
 
 with tab1:
@@ -509,7 +507,6 @@ with tab1:
                               player_salary_dict = dict(zip(proj_dataframe.Player, proj_dataframe.Salary))
                               player_proj_dict = dict(zip(proj_dataframe.Player, proj_dataframe.Median))
                               player_own_dict = dict(zip(proj_dataframe.Player, proj_dataframe.Own))
-                              player_team_dict = dict(zip(proj_dataframe.Player, proj_dataframe.Team))
                               
           with col2:
                     st.info("The Portfolio file must contain only columns in order and explicitly named: 'QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', and 'DST'. Upload your projections first to avoid an error message.")
@@ -577,23 +574,6 @@ with tab1:
                                               split_portfolio['TE'].map(player_own_dict),
                                               split_portfolio['FLEX'].map(player_own_dict),
                                               split_portfolio['DST'].map(player_own_dict)])
-                                    
-                                    split_portfolio['QB_team'] = split_portfolio['QB'].map(player_team_dict)
-                                    split_portfolio['RB1_team'] = split_portfolio['RB1'].map(player_team_dict)
-                                    split_portfolio['RB2_team'] = split_portfolio['RB2'].map(player_team_dict)
-                                    split_portfolio['WR1_team'] = split_portfolio['WR1'].map(player_team_dict)
-                                    split_portfolio['WR2_team'] = split_portfolio['WR2'].map(player_team_dict)
-                                    split_portfolio['WR3_team'] = split_portfolio['WR3'].map(player_team_dict)
-                                    split_portfolio['TE_team'] = split_portfolio['TE'].map(player_team_dict)
-                                    split_portfolio['FLEX_team'] = split_portfolio['FLEX'].map(player_team_dict)
-                                    split_portfolio['DST_team'] = split_portfolio['DST'].map(player_team_dict)
-      
-                                    split_portfolio = split_portfolio[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'Salary', 'Projection', 'Ownership', 'QB_team',
-                                                                        'RB1_team', 'RB2_team', 'WR1_team', 'WR2_team', 'WR3_team', 'TE_team', 'FLEX_team', 'DST_team']]
-      
-                                    split_portfolio['Main_Stack'] = split_portfolio.iloc[:, 15:19].apply(lambda row: row.value_counts().nlargest(2).index[0],axis=1)
-                                    split_portfolio['Main_Stack_Size'] = split_portfolio.iloc[:, 15:19].apply(lambda row: row.value_counts().nlargest(2).values[0],axis=1)
-                                    split_portfolio['Main_Stack_Size'] = split_portfolio['Main_Stack_Size'] - 1
                                 
                                 
                                 except:
@@ -650,23 +630,6 @@ with tab1:
                                               split_portfolio['TE'].map(player_own_dict),
                                               split_portfolio['FLEX'].map(player_own_dict),
                                               split_portfolio['DST'].map(player_own_dict)])
-                                    
-                                    split_portfolio['QB_team'] = split_portfolio['QB'].map(player_team_dict)
-                                    split_portfolio['RB1_team'] = split_portfolio['RB1'].map(player_team_dict)
-                                    split_portfolio['RB2_team'] = split_portfolio['RB2'].map(player_team_dict)
-                                    split_portfolio['WR1_team'] = split_portfolio['WR1'].map(player_team_dict)
-                                    split_portfolio['WR2_team'] = split_portfolio['WR2'].map(player_team_dict)
-                                    split_portfolio['WR3_team'] = split_portfolio['WR3'].map(player_team_dict)
-                                    split_portfolio['TE_team'] = split_portfolio['TE'].map(player_team_dict)
-                                    split_portfolio['FLEX_team'] = split_portfolio['FLEX'].map(player_team_dict)
-                                    split_portfolio['DST_team'] = split_portfolio['DST'].map(player_team_dict)
-      
-                                    split_portfolio = split_portfolio[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'Salary', 'Projection', 'Ownership', 'QB_team',
-                                                                        'RB1_team', 'RB2_team', 'WR1_team', 'WR2_team', 'WR3_team', 'TE_team', 'FLEX_team', 'DST_team']]
-      
-                                    split_portfolio['Main_Stack'] = split_portfolio.iloc[:, 15:19].apply(lambda row: row.value_counts().nlargest(2).index[0],axis=1)
-                                    split_portfolio['Main_Stack_Size'] = split_portfolio.iloc[:, 15:19].apply(lambda row: row.value_counts().nlargest(2).values[0],axis=1)
-                                    split_portfolio['Main_Stack_Size'] = split_portfolio['Main_Stack_Size'] - 1
                                   
                             except:
                                  split_portfolio = portfolio_dataframe
@@ -700,97 +663,9 @@ with tab1:
                                            split_portfolio['TE'].map(player_own_dict),
                                            split_portfolio['FLEX'].map(player_own_dict),
                                            split_portfolio['DST'].map(player_own_dict)])
- 
-                            split_portfolio['QB_team'] = split_portfolio['QB'].map(player_team_dict)
-                            split_portfolio['RB1_team'] = split_portfolio['RB1'].map(player_team_dict)
-                            split_portfolio['RB2_team'] = split_portfolio['RB2'].map(player_team_dict)
-                            split_portfolio['WR1_team'] = split_portfolio['WR1'].map(player_team_dict)
-                            split_portfolio['WR2_team'] = split_portfolio['WR2'].map(player_team_dict)
-                            split_portfolio['WR3_team'] = split_portfolio['WR3'].map(player_team_dict)
-                            split_portfolio['TE_team'] = split_portfolio['TE'].map(player_team_dict)
-                            split_portfolio['FLEX_team'] = split_portfolio['FLEX'].map(player_team_dict)
-                            split_portfolio['DST_team'] = split_portfolio['DST'].map(player_team_dict)
-  
-                            split_portfolio = split_portfolio[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'Salary', 'Projection', 'Ownership', 'QB_team',
-                                                                'RB1_team', 'RB2_team', 'WR1_team', 'WR2_team', 'WR3_team', 'TE_team', 'FLEX_team', 'DST_team']]
-  
-                            split_portfolio['Main_Stack'] = split_portfolio.iloc[:, 15:19].apply(lambda row: row.value_counts().nlargest(2).index[0],axis=1)
-                            split_portfolio['Main_Stack_Size'] = split_portfolio.iloc[:, 15:19].apply(lambda row: row.value_counts().nlargest(2).values[0],axis=1)
-                            split_portfolio['Main_Stack_Size'] = split_portfolio['Main_Stack_Size'] - 1
-                              
-                            for player_cols in split_portfolio.iloc[:, :9]:
-                                      static_col_raw = split_portfolio[player_cols].value_counts()
-                                      static_col = static_col_raw.to_frame()
-                                      static_col.reset_index(inplace=True)
-                                      static_col.columns = ['Player', 'count']
-                                      static_exposure = pd.concat([static_exposure, static_col], ignore_index=True)
-                            static_exposure['Exposure'] = static_exposure['count'] / len(split_portfolio)
-                            static_exposure = static_exposure[['Player', 'Exposure']]
+                                 
+                            gc.collect() 
                             
-                            del player_salary_dict
-                            del player_proj_dict
-                            del player_own_dict
-                            del player_team_dict
-                            del static_col_raw
-                            del static_col
-    with st.container():
-          col1, col2 = st.columns([3, 3])
-          
-          if portfolio_file is not None:
-                    with col1:
-                              team_split_var1 = st.radio("Are you wanting to isolate any lineups with specific main stacks?", ('Full Portfolio', 'Specific Stacks'))
-                              if team_split_var1 == 'Specific Stacks':
-                                        team_var1 = st.multiselect('Which main stacks would you like to include in the Portfolio?', options = split_portfolio['Main_Stack'].unique())
-                              elif team_split_var1 == 'Full Portfolio':
-                                        team_var1 = split_portfolio.Main_Stack.values.tolist()
-                    with col2:
-                              player_split_var1 = st.radio("Are you wanting to isolate any lineups with specific players?", ('Full Players', 'Specific Players'))
-                              if player_split_var1 == 'Specific Players':
-                                        find_var1 = st.multiselect('Which players must be included in the lineups?', options = static_exposure['Player'].unique())
-                              elif player_split_var1 == 'Full Players':
-                                        find_var1 = static_exposure.Player.values.tolist()
-
-                    split_portfolio = split_portfolio[split_portfolio['Main_Stack'].isin(team_var1)]
-                    if player_split_var1 == 'Specific Players':
-                              split_portfolio = split_portfolio[np.equal.outer(split_portfolio.to_numpy(copy=False),  find_var1).any(axis=1).all(axis=1)]
-                    elif player_split_var1 == 'Full Players':
-                              split_portfolio = split_portfolio
-
-                    for player_cols in split_portfolio.iloc[:, :9]:
-                              exposure_col_raw = split_portfolio[player_cols].value_counts()
-                              exposure_col = exposure_col_raw.to_frame()
-                              exposure_col.reset_index(inplace=True)
-                              exposure_col.columns = ['Player', 'count']
-                              overall_exposure = pd.concat([overall_exposure, exposure_col], ignore_index=True)
-                    overall_exposure['Exposure'] = overall_exposure['count'] / len(split_portfolio)
-                    overall_exposure = overall_exposure.groupby('Player').sum()
-                    overall_exposure.reset_index(inplace=True)
-                    overall_exposure = overall_exposure[['Player', 'Exposure']]
-                    overall_exposure = overall_exposure.set_index('Player')
-                    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])
-          
-          with col1:
-                    if portfolio_file is not None:
-                              st.header('Exposure View')
-                              st.dataframe(overall_exposure)
-
-          with col2:
-                    if portfolio_file is not None:
-                              st.header('Portfolio View')
-                              split_portfolio = split_portfolio.reset_index()
-                              split_portfolio['Lineup'] = split_portfolio['index'] + 1
-                              display_portfolio = split_portfolio[['Lineup', 'QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'Salary', 'Main_Stack', 'Main_Stack_Size', 'Projection', 'Ownership']]
-                              display_portfolio = display_portfolio.set_index('Lineup')
-                              st.dataframe(display_portfolio.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').background_gradient(cmap='RdYlGn_r', subset=['Ownership']).format(precision=2))
-                              del split_portfolio
-                              del exposure_col_raw
-                              del exposure_col
 with tab2:
     col1, col2 = st.columns([1, 7])
     with col1:
@@ -818,8 +693,7 @@ 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':
@@ -833,7 +707,6 @@ with tab2:
             Contest_Size = 5000
         elif contest_var1 == 'Large':
             Contest_Size = 10000
-        linenum_var1 = 2500
         strength_var1 = st.selectbox("How sharp is the field in the contest?", ('Not Very', 'Average', 'Very'))
         if strength_var1 == 'Not Very':
             sharp_split = .33
@@ -847,81 +720,78 @@ with tab2:
             sharp_split = .75
             Strength_var = .01
             scaling_var = 15
+        
+        Sort_function = 'Median'
+        Sim_function = 'Projection'
+        
+        if Contest_Size <= 1000:
+            strength_grow = .01
+        elif Contest_Size > 1000 and Contest_Size <= 2500:
+            strength_grow = .025
+        elif Contest_Size > 2500 and Contest_Size <= 5000:
+            strength_grow = .05
+        elif Contest_Size > 5000 and Contest_Size <= 20000:
+            strength_grow = .075
+        elif Contest_Size > 20000:
+            strength_grow = .1
+            
+        field_growth = 100 * strength_grow
 
     with col2:
         with st.container():
             if st.button("Simulate Contest"):
                 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:
-                        strength_grow = .01
-                    elif Contest_Size > 1000 and Contest_Size <= 2500:
-                        strength_grow = .025
-                    elif Contest_Size > 2500 and Contest_Size <= 5000:
-                        strength_grow = .05
-                    elif Contest_Size > 5000 and Contest_Size <= 20000:
-                        strength_grow = .075
-                    elif Contest_Size > 20000:
-                        strength_grow = .1
-                        
-                    field_growth = 100 * strength_grow
-            
-                    Sort_function = 'Median'
-                    if Sort_function == 'Median':
-                        Sim_function = 'Projection'
-                    elif Sort_function == 'Own':
-                        Sim_function = 'Own'
                     
                     if slate_var1 == 'User':
-                        OwnFrame = proj_dataframe.copy()
-                        if contest_var1 == 'Small':
-                            OwnFrame['Own%'] = np.where((OwnFrame['Position'] == 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (10 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean(), OwnFrame['Own'])
-                            OwnFrame['Own%'] = np.where((OwnFrame['Position'] != 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (5 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean(), OwnFrame['Own%'])
-                            OwnFrame['Own%'] = np.where(OwnFrame['Own%'] > 75, 75, OwnFrame['Own%'])
-                            OwnFrame['Own'] = OwnFrame['Own%'] * (900 / OwnFrame['Own%'].sum())
-                        if contest_var1 == 'Medium':
-                            OwnFrame['Own%'] = np.where((OwnFrame['Position'] == 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (6 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean(), OwnFrame['Own'])
-                            OwnFrame['Own%'] = np.where((OwnFrame['Position'] != 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (3 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean(), OwnFrame['Own%'])
-                            OwnFrame['Own%'] = np.where(OwnFrame['Own%'] > 75, 75, OwnFrame['Own%'])
-                            OwnFrame['Own'] = OwnFrame['Own%'] * (900 / OwnFrame['Own%'].sum())
-                        if contest_var1 == 'Large':
-                            OwnFrame['Own%'] = np.where((OwnFrame['Position'] == 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (3 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean(), OwnFrame['Own'])
-                            OwnFrame['Own%'] = np.where((OwnFrame['Position'] != 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (1.5 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean(), OwnFrame['Own%'])
-                            OwnFrame['Own%'] = np.where(OwnFrame['Own%'] > 75, 75, OwnFrame['Own%'])
-                            OwnFrame['Own'] = OwnFrame['Own%'] * (900 / OwnFrame['Own%'].sum())
-                        Overall_Proj = OwnFrame[['Player', 'Team', 'Position', 'Median', 'Own', 'Salary']]
+                        initial_proj = proj_dataframe[['Player', 'Team', 'Position', 'Median', 'Own', 'Floor', 'Ceiling', 'Salary']]
+                        
+                        # Define the calculation to be applied
+                        def calculate_own(position, own, mean_own, factor, max_own=75):
+                            return np.where((position == 'QB') & (own - mean_own >= 0),
+                                            own * (factor * (own - mean_own) / 100) + mean_own,
+                                            own)
                         
-                        del proj_dataframe
-                        del OwnFrame
+                        # Set the factors based on the contest_var1
+                        factor_qb, factor_other = {
+                            'Small': (10, 5),
+                            'Medium': (6, 3),
+                            'Large': (3, 1.5),
+                        }[contest_var1]
+                        
+                        # Apply the calculation to the DataFrame
+                        initial_proj['Own%'] = initial_proj.apply(lambda row: calculate_own(row['Position'], row['Own'], initial_proj.loc[initial_proj['Position'] == row['Position'], 'Own'].mean(), factor_qb if row['Position'] == 'QB' else factor_other), axis=1)
+                        initial_proj['Own%'] = initial_proj['Own%'].clip(upper=75)
+                        initial_proj['Own'] = initial_proj['Own%'] * (900 / initial_proj['Own%'].sum())
+                        
+                        # Drop unnecessary columns and create the final DataFrame
+                        Overall_Proj = initial_proj[['Player', 'Team', 'Position', 'Median', 'Own', 'Salary']]
                         
                     elif slate_var1 != 'User':
-                        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':
-                            OwnFrame['Own%'] = np.where((OwnFrame['Position'] == 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (10 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean(), OwnFrame['Own'])
-                            OwnFrame['Own%'] = np.where((OwnFrame['Position'] != 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (5 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean(), OwnFrame['Own%'])
-                            OwnFrame['Own%'] = np.where(OwnFrame['Own%'] > 75, 75, OwnFrame['Own%'])
-                            OwnFrame['Own'] = OwnFrame['Own%'] * (900 / OwnFrame['Own%'].sum())
-                        if contest_var1 == 'Medium':
-                            OwnFrame['Own%'] = np.where((OwnFrame['Position'] == 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (6 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean(), OwnFrame['Own'])
-                            OwnFrame['Own%'] = np.where((OwnFrame['Position'] != 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (3 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean(), OwnFrame['Own%'])
-                            OwnFrame['Own%'] = np.where(OwnFrame['Own%'] > 75, 75, OwnFrame['Own%'])
-                            OwnFrame['Own'] = OwnFrame['Own%'] * (900 / OwnFrame['Own%'].sum())
-                        if contest_var1 == 'Large':
-                            OwnFrame['Own%'] = np.where((OwnFrame['Position'] == 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (3 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean(), OwnFrame['Own'])
-                            OwnFrame['Own%'] = np.where((OwnFrame['Position'] != 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (1.5 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean(), OwnFrame['Own%'])
-                            OwnFrame['Own%'] = np.where(OwnFrame['Own%'] > 75, 75, OwnFrame['Own%'])
-                            OwnFrame['Own'] = OwnFrame['Own%'] * (900 / OwnFrame['Own%'].sum())
-                        Overall_Proj = OwnFrame[['Player', 'Team', 'Position', 'Median', 'Own', 'Salary']]
+                        # Copy only the necessary columns
+                        initial_proj = raw_baselines[['Player', 'Team', 'Position', 'Median', 'Own', 'Floor', 'Ceiling', 'Salary']]
+                        
+                        # Define the calculation to be applied
+                        def calculate_own(position, own, mean_own, factor, max_own=75):
+                            return np.where((position == 'QB') & (own - mean_own >= 0),
+                                            own * (factor * (own - mean_own) / 100) + mean_own,
+                                            own)
                         
-                        del initial_proj
-                        del drop_frame
-                        del OwnFrame
+                        # Set the factors based on the contest_var1
+                        factor_qb, factor_other = {
+                            'Small': (10, 5),
+                            'Medium': (6, 3),
+                            'Large': (3, 1.5),
+                        }[contest_var1]
+                        
+                        # Apply the calculation to the DataFrame
+                        initial_proj['Own%'] = initial_proj.apply(lambda row: calculate_own(row['Position'], row['Own'], initial_proj.loc[initial_proj['Position'] == row['Position'], 'Own'].mean(), factor_qb if row['Position'] == 'QB' else factor_other), axis=1)
+                        initial_proj['Own%'] = initial_proj['Own%'].clip(upper=75)
+                        initial_proj['Own'] = initial_proj['Own%'] * (900 / initial_proj['Own%'].sum())
+                        
+                        # Drop unnecessary columns and create the final DataFrame
+                        Overall_Proj = initial_proj[['Player', 'Team', 'Position', 'Median', 'Own', 'Salary']]
                     
                     if insert_port == 1:
                         UserPortfolio = portfolio_dataframe[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']]
@@ -945,9 +815,6 @@ with tab2:
                     Teams_used['team_item'] = Teams_used['index'] + 1
                     Teams_used = Teams_used.drop(columns=['index'])
                     Teams_used_dictraw = Teams_used.drop(columns=['team_item'])
-                    # Teams_used_dict = Teams_used_dictraw.to_dict()
-                    
-                    del Teams_used_dictraw
             
                     team_list = Teams_used['Team'].to_list()
                     item_list = Teams_used['team_item'].to_list()
@@ -955,8 +822,6 @@ with tab2:
                     FieldStrength_raw = Strength_var + ((30 - len(Teams_used)) * .01)
                     FieldStrength = FieldStrength_raw - (FieldStrength_raw * (20000 / Contest_Size))
                     
-                    del FieldStrength_raw
-                    
                     if FieldStrength < 0:
                         FieldStrength = Strength_var
                     field_split = Strength_var
@@ -1000,12 +865,6 @@ with tab2:
                     pos_players = pd.concat([rbs_raw, wrs_raw, tes_raw])
                     pos_players.dropna(subset=['Median']).reset_index(drop=True)
                     pos_players = pos_players.reset_index(drop=True)
-                    
-                    del qbs_raw
-                    del defs_raw
-                    del rbs_raw
-                    del wrs_raw
-                    del tes_raw
             
                     if insert_port == 1:
                         try:
@@ -1025,8 +884,6 @@ with tab2:
                             CleanPortfolio['User/Field'] = CleanPortfolio['index'] + 1
                             CleanPortfolio.drop(columns=['index'], inplace=True)
                             
-                            del positions
-                            
                             CleanPortfolio.replace('', np.nan, inplace=True)
                             CleanPortfolio.dropna(subset=['QB'], inplace=True)
                             
@@ -1041,7 +898,6 @@ with tab2:
                             nerf_frame = pd.merge(cleaport_players, Overall_Proj, on='Player', how='left')
                             for col in ['Median', 'Floor', 'Ceiling', 'STDev']:
                                 nerf_frame[col] *= 0.90
-                            del Raw_Portfolio
                         except:
                             CleanPortfolio = UserPortfolio.reset_index()
                             CleanPortfolio['User/Field'] = CleanPortfolio['index'] + 1
@@ -1069,7 +925,7 @@ with tab2:
                                                    columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
                         cleaport_players['Freq'] = cleaport_players['Freq'].astype(int)
                         nerf_frame = Overall_Proj
-                        
+                    
                     ref_dict = {
                         'pos':['RB', 'WR', 'TE', 'FLEX'],
                         'pos_dfs':['RB_Table', 'WR_Table', 'TE_Table', 'FLEX_Table'],
@@ -1100,94 +956,25 @@ with tab2:
                         'team_check_map':dict(zip(cleaport_players.Player,nerf_frame.Team))
                         }
                     
-                    del cleaport_players
-                    del Overall_Proj
-                    del nerf_frame
+                    FinalPortfolio, maps_dict = run_seed_frame(10, Strength_var, strength_grow, Teams_used, 1000000, field_growth)
                     
-                    st.write('Seed frame creation')
-                    FinalPortfolio, maps_dict = run_seed_frame(seed_depth1, Strength_var, strength_grow, Teams_used, Total_Runs)
+                    Sim_Winners = sim_contest(2500, FinalPortfolio, CleanPortfolio, maps_dict, up_dict, insert_port)
                     
-                    Sim_size = linenum_var1
-                    SimVar = 1
-                    Sim_Winners = []
-                    fp_array = FinalPortfolio.values
-                    
-                    if insert_port == 1:
-                        up_array = CleanPortfolio.values
-                    
-                    # Pre-vectorize functions
-                    vec_projection_map = np.vectorize(maps_dict['Projection_map'].__getitem__)
-                    vec_stdev_map = np.vectorize(maps_dict['STDev_map'].__getitem__)
-                    
-                    if insert_port == 1:
-                        vec_up_projection_map = np.vectorize(up_dict['Projection_map'].__getitem__)
-                        vec_up_stdev_map = np.vectorize(up_dict['STDev_map'].__getitem__)
-                    
-                    st.write('Simulating contest on frames')
-                    
-                    while SimVar <= Sim_size:
-                        if insert_port == 1:
-                            fp_random = fp_array[np.random.choice(fp_array.shape[0], Contest_Size-len(CleanPortfolio))]
-                        elif insert_port == 0:
-                            fp_random = fp_array[np.random.choice(fp_array.shape[0], Contest_Size)]
-                            
-                        sample_arrays1 = np.c_[
-                            fp_random, 
-                            np.sum(np.random.normal(
-                                loc=vec_projection_map(fp_random[:, :-5]),
-                                scale=vec_stdev_map(fp_random[:, :-5])),
-                            axis=1)
-                        ]
-                
-                        if insert_port == 1:
-                            sample_arrays2 = np.c_[
-                                up_array, 
-                                np.sum(np.random.normal(
-                                    loc=vec_up_projection_map(up_array[:, :-5]),
-                                    scale=vec_up_stdev_map(up_array[:, :-5])),
-                                axis=1)
-                            ]
-                            sample_arrays = np.vstack((sample_arrays1, sample_arrays2))
-                        else:
-                            sample_arrays = sample_arrays1
-                
-                        final_array = sample_arrays[sample_arrays[:, 10].argsort()[::-1]]
-                        best_lineup = final_array[final_array[:, -1].argsort(kind='stable')[::-1][:1]]
-                        Sim_Winners.append(best_lineup)
-                        SimVar += 1
-                    
-                    del SimVar
-                    del ref_dict, up_dict
-                    del linenum_var1, UserPortfolio
-                    try:
-                        del up_array
-                    except:
-                        pass
-                    del CleanPortfolio
-                    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)
                     
+                    del FinalPortfolio, insert_port, type_cast_dict
+                    
                     # Sorting
                     st.session_state.Sim_Winner_Frame = Sim_Winner_Frame.sort_values(by='GPP_Proj', ascending=False)
                     
                     # Data Copying
-                    st.session_state.Sim_Winner_Export = Sim_Winner_Frame.copy()
-                    
-                    del Sim_Winner_Frame
+                    st.session_state.Sim_Winner_Export = Sim_Winner_Frame
                     
                     # Conditional Replacement
                     columns_to_replace = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
@@ -1197,124 +984,96 @@ 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)
+                    
+                    del replace_dict, Sim_Winner_Frame, Sim_Winners
      
-                    player_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,0:9].values, return_counts=True)),
+                    st.session_state.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'])
-                    player_freq['Salary'] = player_freq['Player'].map(maps_dict['Salary_map'])
-                    player_freq['Proj Own'] = player_freq['Player'].map(maps_dict['Own_map']) / 100
-                    player_freq['Exposure'] = player_freq['Freq']/(Sim_size)
-                    player_freq['Edge'] = player_freq['Exposure'] - player_freq['Proj Own']
-                    player_freq['Team'] = player_freq['Player'].map(maps_dict['Team_map'])
+                    st.session_state.player_freq['Freq'] = st.session_state.player_freq['Freq'].astype(int)
+                    st.session_state.player_freq['Position'] = st.session_state.player_freq['Player'].map(maps_dict['Pos_map'])
+                    st.session_state.player_freq['Salary'] = st.session_state.player_freq['Player'].map(maps_dict['Salary_map'])
+                    st.session_state.player_freq['Proj Own'] = st.session_state.player_freq['Player'].map(maps_dict['Own_map']) / 100
+                    st.session_state.player_freq['Exposure'] = st.session_state.player_freq['Freq']/(2500)
+                    st.session_state.player_freq['Edge'] = st.session_state.player_freq['Exposure'] - st.session_state.player_freq['Proj Own']
+                    st.session_state.player_freq['Team'] = st.session_state.player_freq['Player'].map(maps_dict['Team_map'])
                     for checkVar in range(len(team_list)):
-                                        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
+                                        st.session_state.player_freq['Team'] = st.session_state.player_freq['Team'].replace(item_list, team_list)
                     
-                    qb_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,0:1].values, return_counts=True)),
+                    st.session_state.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'])
-                    qb_freq['Salary'] = qb_freq['Player'].map(maps_dict['Salary_map'])
-                    qb_freq['Proj Own'] = qb_freq['Player'].map(maps_dict['Own_map']) / 100
-                    qb_freq['Exposure'] = qb_freq['Freq']/(Sim_size)
-                    qb_freq['Edge'] = qb_freq['Exposure'] - qb_freq['Proj Own']
-                    qb_freq['Team'] = qb_freq['Player'].map(maps_dict['Team_map'])
+                    st.session_state.qb_freq['Freq'] = st.session_state.qb_freq['Freq'].astype(int)
+                    st.session_state.qb_freq['Position'] = st.session_state.qb_freq['Player'].map(maps_dict['Pos_map'])
+                    st.session_state.qb_freq['Salary'] = st.session_state.qb_freq['Player'].map(maps_dict['Salary_map'])
+                    st.session_state.qb_freq['Proj Own'] = st.session_state.qb_freq['Player'].map(maps_dict['Own_map']) / 100
+                    st.session_state.qb_freq['Exposure'] = st.session_state.qb_freq['Freq']/(2500)
+                    st.session_state.qb_freq['Edge'] = st.session_state.qb_freq['Exposure'] - st.session_state.qb_freq['Proj Own']
+                    st.session_state.qb_freq['Team'] = st.session_state.qb_freq['Player'].map(maps_dict['Team_map'])
                     for checkVar in range(len(team_list)):
-                                        qb_freq['Team'] = qb_freq['Team'].replace(item_list, team_list)
+                                        st.session_state.qb_freq['Team'] = st.session_state.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(st.session_state.Sim_Winner_Frame.iloc[:,[1, 2]].values, return_counts=True)),
+                    st.session_state.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'])
-                    rb_freq['Salary'] = rb_freq['Player'].map(maps_dict['Salary_map'])
-                    rb_freq['Proj Own'] = rb_freq['Player'].map(maps_dict['Own_map']) / 100
-                    rb_freq['Exposure'] = rb_freq['Freq']/Sim_size
-                    rb_freq['Edge'] = rb_freq['Exposure'] - rb_freq['Proj Own']
-                    rb_freq['Team'] = rb_freq['Player'].map(maps_dict['Team_map'])
+                    st.session_state.rb_freq['Freq'] = st.session_state.rb_freq['Freq'].astype(int)
+                    st.session_state.rb_freq['Position'] = st.session_state.rb_freq['Player'].map(maps_dict['Pos_map'])
+                    st.session_state.rb_freq['Salary'] = st.session_state.rb_freq['Player'].map(maps_dict['Salary_map'])
+                    st.session_state.rb_freq['Proj Own'] = st.session_state.rb_freq['Player'].map(maps_dict['Own_map']) / 100
+                    st.session_state.rb_freq['Exposure'] = st.session_state.rb_freq['Freq']/2500
+                    st.session_state.rb_freq['Edge'] = st.session_state.rb_freq['Exposure'] - st.session_state.rb_freq['Proj Own']
+                    st.session_state.rb_freq['Team'] = st.session_state.rb_freq['Player'].map(maps_dict['Team_map'])
                     for checkVar in range(len(team_list)):
-                                        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
+                                        st.session_state.rb_freq['Team'] = st.session_state.rb_freq['Team'].replace(item_list, team_list)
                     
-                    wr_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,[3, 4, 5]].values, return_counts=True)),
+                    st.session_state.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'])
-                    wr_freq['Salary'] = wr_freq['Player'].map(maps_dict['Salary_map'])
-                    wr_freq['Proj Own'] = wr_freq['Player'].map(maps_dict['Own_map']) / 100
-                    wr_freq['Exposure'] = wr_freq['Freq']/Sim_size
-                    wr_freq['Edge'] = wr_freq['Exposure'] - wr_freq['Proj Own']
-                    wr_freq['Team'] = wr_freq['Player'].map(maps_dict['Team_map'])
+                    st.session_state.wr_freq['Freq'] = st.session_state.wr_freq['Freq'].astype(int)
+                    st.session_state.wr_freq['Position'] = st.session_state.wr_freq['Player'].map(maps_dict['Pos_map'])
+                    st.session_state.wr_freq['Salary'] = st.session_state.wr_freq['Player'].map(maps_dict['Salary_map'])
+                    st.session_state.wr_freq['Proj Own'] = st.session_state.wr_freq['Player'].map(maps_dict['Own_map']) / 100
+                    st.session_state.wr_freq['Exposure'] = st.session_state.wr_freq['Freq']/2500
+                    st.session_state.wr_freq['Edge'] = st.session_state.wr_freq['Exposure'] - st.session_state.wr_freq['Proj Own']
+                    st.session_state.wr_freq['Team'] = st.session_state.wr_freq['Player'].map(maps_dict['Team_map'])
                     for checkVar in range(len(team_list)):
-                                        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
+                                        st.session_state.wr_freq['Team'] = st.session_state.wr_freq['Team'].replace(item_list, team_list)
                     
-                    te_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,[6]].values, return_counts=True)),
+                    st.session_state.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'])
-                    te_freq['Salary'] = te_freq['Player'].map(maps_dict['Salary_map'])
-                    te_freq['Proj Own'] = te_freq['Player'].map(maps_dict['Own_map']) / 100
-                    te_freq['Exposure'] = te_freq['Freq']/Sim_size
-                    te_freq['Edge'] = te_freq['Exposure'] - te_freq['Proj Own']
-                    te_freq['Team'] = te_freq['Player'].map(maps_dict['Team_map'])
+                    st.session_state.te_freq['Freq'] = st.session_state.te_freq['Freq'].astype(int)
+                    st.session_state.te_freq['Position'] = st.session_state.te_freq['Player'].map(maps_dict['Pos_map'])
+                    st.session_state.te_freq['Salary'] = st.session_state.te_freq['Player'].map(maps_dict['Salary_map'])
+                    st.session_state.te_freq['Proj Own'] = st.session_state.te_freq['Player'].map(maps_dict['Own_map']) / 100
+                    st.session_state.te_freq['Exposure'] = st.session_state.te_freq['Freq']/2500
+                    st.session_state.te_freq['Edge'] = st.session_state.te_freq['Exposure'] - st.session_state.te_freq['Proj Own']
+                    st.session_state.te_freq['Team'] = st.session_state.te_freq['Player'].map(maps_dict['Team_map'])
                     for checkVar in range(len(team_list)):
-                                        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
+                                        st.session_state.te_freq['Team'] = st.session_state.te_freq['Team'].replace(item_list, team_list)
                     
-                    flex_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,[7]].values, return_counts=True)),
+                    st.session_state.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'])
-                    flex_freq['Salary'] = flex_freq['Player'].map(maps_dict['Salary_map'])
-                    flex_freq['Proj Own'] = flex_freq['Player'].map(maps_dict['Own_map']) / 100
-                    flex_freq['Exposure'] = flex_freq['Freq']/Sim_size
-                    flex_freq['Edge'] = flex_freq['Exposure'] - flex_freq['Proj Own']
-                    flex_freq['Team'] = flex_freq['Player'].map(maps_dict['Team_map'])
+                    st.session_state.flex_freq['Freq'] = st.session_state.flex_freq['Freq'].astype(int)
+                    st.session_state.flex_freq['Position'] = st.session_state.flex_freq['Player'].map(maps_dict['Pos_map'])
+                    st.session_state.flex_freq['Salary'] = st.session_state.flex_freq['Player'].map(maps_dict['Salary_map'])
+                    st.session_state.flex_freq['Proj Own'] = st.session_state.flex_freq['Player'].map(maps_dict['Own_map']) / 100
+                    st.session_state.flex_freq['Exposure'] = st.session_state.flex_freq['Freq']/2500
+                    st.session_state.flex_freq['Edge'] = st.session_state.flex_freq['Exposure'] - st.session_state.flex_freq['Proj Own']
+                    st.session_state.flex_freq['Team'] = st.session_state.flex_freq['Player'].map(maps_dict['Team_map'])
                     for checkVar in range(len(team_list)):
-                                        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
+                                        st.session_state.flex_freq['Team'] = st.session_state.flex_freq['Team'].replace(item_list, team_list)
                     
-                    dst_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,8:9].values, return_counts=True)),
+                    st.session_state.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'])
-                    dst_freq['Salary'] = dst_freq['Player'].map(maps_dict['Salary_map'])
-                    dst_freq['Proj Own'] = dst_freq['Player'].map(maps_dict['Own_map']) / 100
-                    dst_freq['Exposure'] = dst_freq['Freq']/Sim_size
-                    dst_freq['Edge'] = dst_freq['Exposure'] - dst_freq['Proj Own']
-                    dst_freq['Team'] = dst_freq['Player'].map(maps_dict['Team_map'])
+                    st.session_state.dst_freq['Freq'] = st.session_state.dst_freq['Freq'].astype(int)
+                    st.session_state.dst_freq['Position'] = st.session_state.dst_freq['Player'].map(maps_dict['Pos_map'])
+                    st.session_state.dst_freq['Salary'] = st.session_state.dst_freq['Player'].map(maps_dict['Salary_map'])
+                    st.session_state.dst_freq['Proj Own'] = st.session_state.dst_freq['Player'].map(maps_dict['Own_map']) / 100
+                    st.session_state.dst_freq['Exposure'] = st.session_state.dst_freq['Freq']/2500
+                    st.session_state.dst_freq['Edge'] = st.session_state.dst_freq['Exposure'] - st.session_state.dst_freq['Proj Own']
+                    st.session_state.dst_freq['Team'] = st.session_state.dst_freq['Player'].map(maps_dict['Team_map'])
                     for checkVar in range(len(team_list)):
-                                        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 Sim_size
-                    del maps_dict
-                    del team_list
-                    del item_list
+                                        st.session_state.dst_freq['Team'] = st.session_state.dst_freq['Team'].replace(item_list, team_list)
                     
         with st.container():
-            simulate_container = st.empty()
             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':
@@ -1323,7 +1082,7 @@ with tab2:
                           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)]
+                          st.session_state.Sim_Winner_Display = st.session_state.Sim_Winner_Frame[np.equal.outer(st.session_state.Sim_Winner_Frame.to_numpy(), 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:
@@ -1331,20 +1090,19 @@ with tab2:
             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),
+                    data=st.session_state.Sim_Winner_Export.to_csv().encode('utf-8'),
                     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:
                 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),
+                        data=st.session_state.player_freq.to_csv().encode('utf-8'),
                         file_name='player_freq_export.csv',
                         mime='text/csv',
                     )
@@ -1353,7 +1111,7 @@ 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),
+                        data=st.session_state.qb_freq.to_csv().encode('utf-8'),
                         file_name='qb_freq_export.csv',
                         mime='text/csv',
                     )
@@ -1362,7 +1120,7 @@ with tab2:
                     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),
+                        data=st.session_state.rb_freq.to_csv().encode('utf-8'),
                         file_name='rb_freq_export.csv',
                         mime='text/csv',
                     )
@@ -1371,7 +1129,7 @@ with tab2:
                     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),
+                        data=st.session_state.wr_freq.to_csv().encode('utf-8'),
                         file_name='wr_freq_export.csv',
                         mime='text/csv',
                     )
@@ -1380,7 +1138,7 @@ with tab2:
                     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),
+                        data=st.session_state.te_freq.to_csv().encode('utf-8'),
                         file_name='te_freq_export.csv',
                         mime='text/csv',
                     )
@@ -1389,7 +1147,7 @@ with tab2:
                     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),
+                        data=st.session_state.flex_freq.to_csv().encode('utf-8'),
                         file_name='flex_freq_export.csv',
                         mime='text/csv',
                     )
@@ -1398,7 +1156,16 @@ with tab2:
                     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),
+                        data=st.session_state.dst_freq.to_csv().encode('utf-8'),
                         file_name='dst_freq_export.csv',
                         mime='text/csv',
-                    )
+                    )
+
+del gcservice_account
+del dk_roo_raw, fd_roo_raw
+del t_stamp
+del dkid_dict, fdid_dict
+del static_exposure, overall_exposure
+del insert_port1, Contest_Size, sharp_split, Strength_var, scaling_var, Sort_function, Sim_function, strength_grow, field_growth
+del raw_baselines
+del freq_format