Update app.py

app.py

@@ -9,6 +9,8 @@ import numpy as np
 import pandas as pd
 import streamlit as st
 import gspread
+import random
+import gc
 
 @st.cache_resource
 def init_conn():
@@ -28,22 +30,17 @@ 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 = 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%}'}
+          gc_con = gspread.service_account_from_dict(credentials)
+          
+          return gc_con
 
-player_roo_format = {'Top_finish': '{:.2%}','Top_5_finish': '{:.2%}', 'Top_10_finish': '{:.2%}', '20+%': '{:.2%}', '2x%': '{:.2%}', '3x%': '{:.2%}',
-                   '4x%': '{:.2%}','GPP%': '{:.2%}'}
+gcservice_account = init_conn()
 
 freq_format = {'Proj Own': '{:.2%}', 'Exposure': '{:.2%}', 'Edge': '{:.2%}'}
 
 @st.cache_resource(ttl=600)
 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('SD_Projections')
     load_display = pd.DataFrame(worksheet.get_all_records())
     load_display.rename(columns={"PPR": "Median", "name": "Player"}, inplace = True)
@@ -51,13 +48,12 @@ def load_dk_player_projections():
     load_display['Ceiling'] = load_display['Median'] + (load_display['Median'] * .75)
     load_display.replace('', np.nan, inplace=True)
     raw_display = load_display.dropna(subset=['Median'])
-    del load_display
 
     return raw_display
 
 @st.cache_resource(ttl=600)
 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_SD_Projections')
     load_display = pd.DataFrame(worksheet.get_all_records())
     load_display.rename(columns={"Half_PPR": "Median", "name": "Player"}, inplace = True)
@@ -65,13 +61,12 @@ def load_fd_player_projections():
     load_display['Ceiling'] = load_display['Median'] + (load_display['Median'] * .75)
     load_display.replace('', np.nan, inplace=True)
     raw_display = load_display.dropna(subset=['Median'])
-    del load_display
 
     return raw_display
 
 @st.cache_resource(ttl=600)
 def load_dk_player_projections_2():
-    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('SD_Projections_2')
     load_display = pd.DataFrame(worksheet.get_all_records())
     load_display.rename(columns={"PPR": "Median", "name": "Player"}, inplace = True)
@@ -79,13 +74,12 @@ def load_dk_player_projections_2():
     load_display['Ceiling'] = load_display['Median'] + (load_display['Median'] * .75)
     load_display.replace('', np.nan, inplace=True)
     raw_display = load_display.dropna(subset=['Median'])
-    del load_display
 
     return raw_display
 
 @st.cache_resource(ttl=600)
 def load_fd_player_projections_2():
-    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_SD_Projections_2')
     load_display = pd.DataFrame(worksheet.get_all_records())
     load_display.rename(columns={"Half_PPR": "Median", "name": "Player"}, inplace = True)
@@ -93,60 +87,106 @@ def load_fd_player_projections_2():
     load_display['Ceiling'] = load_display['Median'] + (load_display['Median'] * .75)
     load_display.replace('', np.nan, inplace=True)
     raw_display = load_display.dropna(subset=['Median'])
-    del load_display
 
     return raw_display
 
-@st.cache_data
-def convert_df_to_csv(df):
-    return df.to_csv().encode('utf-8')
+dk_roo_raw = load_dk_player_projections()
+dk_roo_raw_2 = load_dk_player_projections_2()
+fd_roo_raw = load_fd_player_projections()
+fd_roo_raw_2 = load_fd_player_projections_2()
 
-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
+    
+    st.write('Creating Seed Frames')
+    
     while RunsVar <= seed_depth_def:
         if RunsVar <= 3:
             FieldStrength = Strength_var_def
-            RandomPortfolio, maps_dict = get_correlated_portfolio_for_sim(Total_Runs_def * .1)
-            FinalPortfolio = RandomPortfolio
-            FinalPortfolio2, maps_dict2 = get_uncorrelated_portfolio_for_sim(Total_Runs_def * .1)
-            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)
-            FinalPortfolio4, maps_dict4 = get_uncorrelated_portfolio_for_sim(Total_Runs_def * .1)
-            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)
-            FinalPortfolio4, maps_dict4 = get_uncorrelated_portfolio_for_sim(Total_Runs_def * .1)
-            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_overall_dfs(pos_players, table_name, dict_name, pos):
     pos_players = pos_players.sort_values(by='Value', ascending=False)
@@ -155,9 +195,6 @@ def create_overall_dfs(pos_players, table_name, dict_name, pos):
     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
 
 
@@ -176,7 +213,7 @@ def get_overall_merged_df():
     
     return df_out, ref_dict
 
-def create_random_portfolio(Total_Sample_Size):
+def create_random_portfolio(Total_Sample_Size, raw_baselines, field_growth):
     
             O_merge, full_pos_player_dict = get_overall_merged_df()
             Overall_Merge = O_merge[['Var', 'Player', 'Team', 'Salary', 'Median', 'Own']].copy()
@@ -201,11 +238,11 @@ def create_random_portfolio(Total_Sample_Size):
           
             return RandomPortfolio, maps_dict, ranges_dict, full_pos_player_dict
 
-def get_correlated_portfolio_for_sim(Total_Sample_Size):
+def get_correlated_portfolio_for_sim(Total_Sample_Size, sharp_split, field_growth):
     
-    sizesplit = round(Total_Sample_Size * .50)
+    sizesplit = round(Total_Sample_Size * sharp_split)
     
-    RandomPortfolio, maps_dict, ranges_dict, full_pos_player_dict = create_random_portfolio(sizesplit)
+    RandomPortfolio, maps_dict, ranges_dict, full_pos_player_dict = create_random_portfolio(sizesplit, raw_baselines, field_growth)
     
     RandomPortfolio['CPT'] = pd.Series(list(RandomPortfolio['CPT'].map(full_pos_player_dict['pos_dicts'][0])), dtype="string[pyarrow]")
     RandomPortfolio['FLEX1'] = pd.Series(list(RandomPortfolio['FLEX1'].map(full_pos_player_dict['pos_dicts'][0])), dtype="string[pyarrow]")
@@ -218,10 +255,6 @@ def get_correlated_portfolio_for_sim(Total_Sample_Size):
     RandomPortfolio = RandomPortfolio[RandomPortfolio['plyr_count'] == 7].drop(columns=['plyr_list','plyr_count']).\
         reset_index(drop=True)
         
-    del sizesplit
-    del full_pos_player_dict
-    del ranges_dict
-        
     RandomPortfolio['CPTs'] = RandomPortfolio['CPT'].map(maps_dict['Salary_map']).astype(np.int32) * 1.5
     RandomPortfolio['FLEX1s'] = RandomPortfolio['FLEX1'].map(maps_dict['Salary_map']).astype(np.int32)
     RandomPortfolio['FLEX2s'] = RandomPortfolio['FLEX2'].map(maps_dict['Salary_map']).astype(np.int32)
@@ -249,7 +282,6 @@ def get_correlated_portfolio_for_sim(Total_Sample_Size):
     portHeaderList.append('Own')
     
     RandomPortArray = RandomPortfolio.to_numpy()
-    del RandomPortfolio
     
     RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,7:13].astype(int))]
     RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,13:19].astype(np.double))]
@@ -258,9 +290,6 @@ def get_correlated_portfolio_for_sim(Total_Sample_Size):
     RandomPortArrayOut = np.delete(RandomPortArray, np.s_[7:25], axis=1)
     RandomPortfolioDF = pd.DataFrame(RandomPortArrayOut, columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', '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['CPT'].map(up_dict['Salary_map']) * 1.5,
@@ -300,11 +329,11 @@ def get_correlated_portfolio_for_sim(Total_Sample_Size):
     
     return RandomPortfolio, maps_dict
 
-def get_uncorrelated_portfolio_for_sim(Total_Sample_Size):
+def get_uncorrelated_portfolio_for_sim(Total_Sample_Size, sharp_split, field_growth):
     
-    sizesplit = round(Total_Sample_Size * .50)
+    sizesplit = round(Total_Sample_Size * (1-sharp_split))
     
-    RandomPortfolio, maps_dict, ranges_dict, full_pos_player_dict = create_random_portfolio(sizesplit)
+    RandomPortfolio, maps_dict, ranges_dict, full_pos_player_dict = create_random_portfolio(sizesplit, raw_baselines, field_growth)
     
     RandomPortfolio['CPT'] = pd.Series(list(RandomPortfolio['CPT'].map(full_pos_player_dict['pos_dicts'][0])), dtype="string[pyarrow]")
     RandomPortfolio['FLEX1'] = pd.Series(list(RandomPortfolio['FLEX1'].map(full_pos_player_dict['pos_dicts'][0])), dtype="string[pyarrow]")
@@ -317,10 +346,6 @@ def get_uncorrelated_portfolio_for_sim(Total_Sample_Size):
     RandomPortfolio = RandomPortfolio[RandomPortfolio['plyr_count'] == 7].drop(columns=['plyr_list','plyr_count']).\
         reset_index(drop=True)
         
-    del sizesplit
-    del full_pos_player_dict
-    del ranges_dict
-        
     RandomPortfolio['CPTs'] = RandomPortfolio['CPT'].map(maps_dict['Salary_map']).astype(np.int32) * 1.5
     RandomPortfolio['FLEX1s'] = RandomPortfolio['FLEX1'].map(maps_dict['Salary_map']).astype(np.int32)
     RandomPortfolio['FLEX2s'] = RandomPortfolio['FLEX2'].map(maps_dict['Salary_map']).astype(np.int32)
@@ -348,7 +373,6 @@ def get_uncorrelated_portfolio_for_sim(Total_Sample_Size):
     portHeaderList.append('Own')
     
     RandomPortArray = RandomPortfolio.to_numpy()
-    del RandomPortfolio
     
     RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,7:13].astype(int))]
     RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,13:19].astype(np.double))]
@@ -357,9 +381,6 @@ def get_uncorrelated_portfolio_for_sim(Total_Sample_Size):
     RandomPortArrayOut = np.delete(RandomPortArray, np.s_[7:25], axis=1)
     RandomPortfolioDF = pd.DataFrame(RandomPortArrayOut, columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', '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['CPT'].map(up_dict['Salary_map']) * 1.5,
@@ -399,14 +420,6 @@ def get_uncorrelated_portfolio_for_sim(Total_Sample_Size):
     
     return RandomPortfolio, maps_dict
 
-dk_roo_raw = load_dk_player_projections()
-dk_roo_raw_2 = load_dk_player_projections_2()
-fd_roo_raw = load_fd_player_projections()
-fd_roo_raw_2 = load_fd_player_projections_2()
-
-static_exposure = pd.DataFrame(columns=['Player', 'count'])
-overall_exposure = pd.DataFrame(columns=['Player', 'count'])
-
 tab1, tab2 = st.tabs(['Uploads', 'Contest Sim'])
 
 with tab1:
@@ -470,8 +483,6 @@ with tab1:
                                                 split_portfolio['FLEX4'].map(player_salary_dict),
                                                 split_portfolio['FLEX5'].map(player_salary_dict)])
                                       
-                                      del player_salary_dict
-                                      
                                       split_portfolio['Projection'] = sum([split_portfolio['CPT'].map(player_proj_dict) * 1.5,
                                                 split_portfolio['FLEX1'].map(player_proj_dict),
                                                 split_portfolio['FLEX2'].map(player_proj_dict),
@@ -479,8 +490,6 @@ with tab1:
                                                 split_portfolio['FLEX4'].map(player_proj_dict),
                                                 split_portfolio['FLEX5'].map(player_proj_dict)])
                                       
-                                      del player_proj_dict
-                                      
                                       split_portfolio['Ownership'] = sum([split_portfolio['CPT'].map(player_own_dict) / 4,
                                                 split_portfolio['FLEX1'].map(player_own_dict),
                                                 split_portfolio['FLEX2'].map(player_own_dict),
@@ -488,21 +497,6 @@ with tab1:
                                                 split_portfolio['FLEX4'].map(player_own_dict),
                                                 split_portfolio['FLEX5'].map(player_own_dict)])
                                       
-                                      del player_own_dict
-                                      
-                                      split_portfolio['CPT_team'] = split_portfolio['CPT'].map(player_team_dict)
-                                      split_portfolio['FLEX1_team'] = split_portfolio['FLEX1'].map(player_team_dict)
-                                      split_portfolio['FLEX2_team'] = split_portfolio['FLEX2'].map(player_team_dict)
-                                      split_portfolio['FLEX3_team'] = split_portfolio['FLEX3'].map(player_team_dict)
-                                      split_portfolio['FLEX4_team'] = split_portfolio['FLEX4'].map(player_team_dict)
-                                      split_portfolio['FLEX5_team'] = split_portfolio['FLEX5'].map(player_team_dict)
-        
-                                      split_portfolio = split_portfolio[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'Salary', 'Projection', 'Ownership', 'CPT_team',
-                                                                          'FLEX1_team', 'FLEX2_team', 'FLEX3_team', 'FLEX4_team', 'FLEX5_team']]
-        
-                                      split_portfolio['Main_Stack'] = 0
-                                      split_portfolio['Main_Stack_Size'] = 0
-                                      split_portfolio['Main_Stack_Size'] = 0
                                   except:
                                       portfolio_dataframe.columns=["CPT", "FLEX1", "FLEX2", "FLEX3", "FLEX4", "FLEX5"]
                                       split_portfolio = portfolio_dataframe
@@ -534,8 +528,6 @@ with tab1:
                                                 split_portfolio['FLEX4'].map(player_salary_dict),
                                                 split_portfolio['FLEX5'].map(player_salary_dict)])
                                       
-                                      del player_salary_dict
-                                      
                                       split_portfolio['Projection'] = sum([split_portfolio['CPT'].map(player_proj_dict) * 1.5,
                                                 split_portfolio['FLEX1'].map(player_proj_dict),
                                                 split_portfolio['FLEX2'].map(player_proj_dict),
@@ -543,8 +535,6 @@ with tab1:
                                                 split_portfolio['FLEX4'].map(player_proj_dict),
                                                 split_portfolio['FLEX5'].map(player_proj_dict)])
                                       
-                                      del player_proj_dict
-                                      
                                       split_portfolio['Ownership'] = sum([split_portfolio['CPT'].map(player_own_dict) / 4,
                                                 split_portfolio['FLEX1'].map(player_own_dict),
                                                 split_portfolio['FLEX2'].map(player_own_dict),
@@ -552,21 +542,6 @@ with tab1:
                                                 split_portfolio['FLEX4'].map(player_own_dict),
                                                 split_portfolio['FLEX5'].map(player_own_dict)])
                                       
-                                      del player_own_dict
-                                      
-                                      split_portfolio['CPT_team'] = split_portfolio['CPT'].map(player_team_dict)
-                                      split_portfolio['FLEX1_team'] = split_portfolio['FLEX1'].map(player_team_dict)
-                                      split_portfolio['FLEX2_team'] = split_portfolio['FLEX2'].map(player_team_dict)
-                                      split_portfolio['FLEX3_team'] = split_portfolio['FLEX3'].map(player_team_dict)
-                                      split_portfolio['FLEX4_team'] = split_portfolio['FLEX4'].map(player_team_dict)
-                                      split_portfolio['FLEX5_team'] = split_portfolio['FLEX5'].map(player_team_dict)
-        
-                                      split_portfolio = split_portfolio[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'Salary', 'Projection', 'Ownership', 'CPT_team',
-                                                                          'FLEX1_team', 'FLEX2_team', 'FLEX3_team', 'FLEX4_team', 'FLEX5_team']]
-        
-                                      split_portfolio['Main_Stack'] = 0
-                                      split_portfolio['Main_Stack_Size'] = 0
-                                      split_portfolio['Main_Stack_Size'] = 0
                               except:
                                   split_portfolio = portfolio_dataframe
                                   
@@ -591,8 +566,6 @@ with tab1:
                                             split_portfolio['FLEX4'].map(player_salary_dict),
                                             split_portfolio['FLEX5'].map(player_salary_dict)])
                                   
-                                  del player_salary_dict
-                                  
                                   split_portfolio['Projection'] = sum([split_portfolio['CPT'].map(player_proj_dict) * 1.5,
                                             split_portfolio['FLEX1'].map(player_proj_dict),
                                             split_portfolio['FLEX2'].map(player_proj_dict),
@@ -600,8 +573,6 @@ with tab1:
                                             split_portfolio['FLEX4'].map(player_proj_dict),
                                             split_portfolio['FLEX5'].map(player_proj_dict)])
                                   
-                                  del player_proj_dict
-                                  
                                   split_portfolio['Ownership'] = sum([split_portfolio['CPT'].map(player_own_dict) / 4,
                                             split_portfolio['FLEX1'].map(player_own_dict),
                                             split_portfolio['FLEX2'].map(player_own_dict),
@@ -609,96 +580,16 @@ with tab1:
                                             split_portfolio['FLEX4'].map(player_own_dict),
                                             split_portfolio['FLEX5'].map(player_own_dict)])
                                   
-                                  del player_own_dict
-                                  
-                                  split_portfolio['CPT_team'] = split_portfolio['CPT'].map(player_team_dict)
-                                  split_portfolio['FLEX1_team'] = split_portfolio['FLEX1'].map(player_team_dict)
-                                  split_portfolio['FLEX2_team'] = split_portfolio['FLEX2'].map(player_team_dict)
-                                  split_portfolio['FLEX3_team'] = split_portfolio['FLEX3'].map(player_team_dict)
-                                  split_portfolio['FLEX4_team'] = split_portfolio['FLEX4'].map(player_team_dict)
-                                  split_portfolio['FLEX5_team'] = split_portfolio['FLEX5'].map(player_team_dict)
-    
-                                  split_portfolio = split_portfolio[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'Salary', 'Projection', 'Ownership', 'CPT_team',
-                                                                      'FLEX1_team', 'FLEX2_team', 'FLEX3_team', 'FLEX4_team', 'FLEX5_team']]
-    
-                                  split_portfolio['Main_Stack'] = 0
-                                  split_portfolio['Main_Stack_Size'] = 0
-                                  split_portfolio['Main_Stack_Size'] = 0
                               
-                              for player_cols in split_portfolio.iloc[:, 0:6]:
-                                        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 static_col_raw
-                              del static_col
-    with st.container():
-          col1, col2 = st.columns([3, 3])
-          
-          if portfolio_file is not None:
-                    with col1:
-                              st.write(len(portfolio_dataframe))
-                              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[:, 0:6]:
-                              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))
-                    
-    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', 'CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'Salary', 'Main_Stack', 'Main_Stack_Size', 'Projection', 'Ownership']]
-                              hold_display = display_portfolio
-                              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, 5])
+    col1, col2 = st.columns([1, 7])
     with col1:
         if st.button("Load/Reset Data", key='reset1'):
               st.cache_data.clear()
+              for key in st.session_state.keys():
+                  del st.session_state[key]
               dk_roo_raw = load_dk_player_projections()
               dk_roo_raw_2 = load_dk_player_projections_2()
               fd_roo_raw = load_fd_player_projections()
@@ -720,10 +611,7 @@ with tab2:
                   raw_baselines = dk_roo_raw
               elif slate_var1 == 'Paydirt (Secondary)':
                   raw_baselines = dk_roo_raw_2
-        del dk_roo_raw
-        del dk_roo_raw_2
-        del fd_roo_raw
-        del fd_roo_raw_2
+                  
         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'))
         if insert_port1 == 'Yes':
@@ -736,103 +624,92 @@ with tab2:
         elif contest_var1 == 'Medium':
             Contest_Size = 2500
         elif contest_var1 == 'Large':
-            Contest_Size = 10000
-        linenum_var1 = 1000
+            Contest_Size = 5000
         strength_var1 = st.selectbox("How sharp is the field in the contest?", ('Not Very', 'Average', 'Very'))
         if strength_var1 == 'Not Very':
-            Strength_var = 1
+            sharp_split = .33
+            Strength_var = .50
             scaling_var = 5
         elif strength_var1 == 'Average':
-            Strength_var = .75
+            sharp_split = .50
+            Strength_var = .25
             scaling_var = 10
         elif strength_var1 == 'Very':
-            Strength_var = .5
+            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", key='sim1'):
-                try:
-                    del dst_freq
-                    del flex_freq
-                    del te_freq
-                    del wr_freq
-                    del rb_freq
-                    del qb_freq
-                    del player_freq
-                    del Sim_Winner_Export
-                    del Sim_Winner_Frame
-                except:
-                    pass
                 with st.container():
-                    st.write('Contest Simulation Starting')
-                    Total_Runs = 1000000
-                    seed_depth1 = 5
-                    Total_Runs = 2500000
-                    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'
+                    for key in st.session_state.keys():
+                        del st.session_state[key]
                     
                     if slate_var1 == 'User':
-                        OwnFrame = proj_dataframe
-                        if contest_var1 == 'Large':
-                            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%'] * (500 / 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%'] * (500 / OwnFrame['Own%'].sum())
-                        if contest_var1 == 'Small':
-                            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%'] * (500 / 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)
+                        
+                        # 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%'] * (500 / initial_proj['Own%'].sum())
                         
-                        del OwnFrame
+                        # 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
-                        drop_frame = initial_proj.drop_duplicates(subset = 'Player',keep = 'first')
-                        OwnFrame = drop_frame[['Player', 'Team', 'Position', 'Median', 'Own', 'Floor', 'Ceiling', 'Salary']]
-                        if contest_var1 == 'Large':
-                            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%'] * (500 / 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%'] * (500 / OwnFrame['Own%'].sum())
-                        if contest_var1 == 'Small':
-                            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%'] * (500 / OwnFrame['Own%'].sum())
-                        Overall_Proj  = OwnFrame[['Player', 'Team', 'Position', 'Median', 'Own', 'Floor', 'Ceiling', 'Salary']]
+                        # Copy only the necessary columns
+                        initial_proj = raw_baselines[['Player', 'Team', 'Position', 'Median', 'Own', 'Floor', 'Ceiling', 'Salary']]
                         
-                        del initial_proj
-                        del drop_frame
-                        del OwnFrame
+                        # 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)
+                        
+                        # 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%'] * (500 / 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[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5']]
@@ -856,9 +733,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()
@@ -866,8 +740,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
@@ -883,8 +755,6 @@ with tab2:
                     pos_players = flex_raw
                     pos_players.dropna(subset=['Median']).reset_index(drop=True)
                     pos_players = pos_players.reset_index(drop=True)
-                    
-                    del flex_raw
             
                     if insert_port == 1:
                         try:
@@ -916,7 +786,7 @@ with tab2:
                             
                             # Merge and update nerf_frame DataFrame
                             nerf_frame = pd.merge(cleaport_players, Overall_Proj, on='Player', how='left')
-                            nerf_frame[['Median', 'Floor', 'Ceiling', 'STDev']] *= 1
+                            nerf_frame[['Median', 'Floor', 'Ceiling', 'STDev']] *= .9
                             
                             del Raw_Portfolio
                         except:
@@ -932,7 +802,7 @@ with tab2:
                             
                             # Merge and update nerf_frame DataFrame
                             nerf_frame = pd.merge(cleaport_players, Overall_Proj, on='Player', how='left')
-                            nerf_frame[['Median', 'Floor', 'Ceiling', 'STDev']] *= 1
+                            nerf_frame[['Median', 'Floor', 'Ceiling', 'STDev']] *= .9
                             
                             st.table(nerf_frame)
     
@@ -973,133 +843,71 @@ with tab2:
                         'team_check_map':dict(zip(cleaport_players.Player,nerf_frame.Team))
                         }
                     
-                    del Overall_Proj
-                    del nerf_frame
+                    FinalPortfolio, maps_dict = run_seed_frame(5, Strength_var, strength_grow, Teams_used, 1000000, field_growth)
                     
-                    RunsVar = 1
-                    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(5000, FinalPortfolio, CleanPortfolio, maps_dict, up_dict, insert_port)
                     
-                    Sim_size = linenum_var1
-                    SimVar = 1
-                    Sim_Winners = []
-                    fp_array = FinalPortfolio.values
+                    # 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
+                    Sim_Winner_Frame['unique_id'] = Sim_Winner_Frame['Projection'].astype(str) + Sim_Winner_Frame['Salary'].astype(str) + Sim_Winner_Frame['Own'].astype(str)
+                    Sim_Winner_Frame = Sim_Winner_Frame.assign(win_count=Sim_Winner_Frame['unique_id'].map(Sim_Winner_Frame['unique_id'].value_counts()))
                     
-                    if insert_port == 1:
-                        up_array = CleanPortfolio.values
+                    # Type Casting
+                    type_cast_dict = {'Salary': int, 'Projection': np.float16, 'Fantasy': np.float16, 'GPP_Proj': np.float32}
+                    Sim_Winner_Frame = Sim_Winner_Frame.astype(type_cast_dict)
                     
-                    # Pre-vectorize functions
-                    vec_projection_map = np.vectorize(maps_dict['Projection_map'].__getitem__)
-                    vec_stdev_map = np.vectorize(maps_dict['STDev_map'].__getitem__)
+                    del FinalPortfolio, insert_port, type_cast_dict
                     
-                    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
-                    st.write('Contest simulation complete')
-    
-                    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
-                    Sim_Winner_Frame['Salary'] = Sim_Winner_Frame['Salary'].astype(int)
-                    Sim_Winner_Frame['Projection'] = Sim_Winner_Frame['Projection'].astype(np.float16)
-                    Sim_Winner_Frame['Fantasy'] = Sim_Winner_Frame['Fantasy'].astype(np.float16)
-                    Sim_Winner_Frame['GPP_Proj'] = Sim_Winner_Frame['GPP_Proj'].astype(np.float16)
-                    st.session_state.Sim_Winner_Frame = Sim_Winner_Frame.sort_values(by='GPP_Proj', ascending=False)
+                    # Sorting
+                    st.session_state.Sim_Winner_Frame = Sim_Winner_Frame.sort_values(by=['win_count', 'GPP_Proj'], ascending= [False, False]).copy().drop_duplicates(subset='unique_id').head(100)
+                    st.session_state.Sim_Winner_Frame.drop(columns='unique_id', inplace=True)
+                    
+                    # Data Copying
                     st.session_state.Sim_Winner_Export = Sim_Winner_Frame.copy()
                     
-                    del Sim_Winner_Frame
+                    # Data Copying
+                    st.session_state.Sim_Winner_Display = Sim_Winner_Frame.copy()
                     
-                    player_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,0:6].values, return_counts=True)),
+                    del Sim_Winner_Frame, Sim_Winners
+                    
+                    st.session_state.player_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Display.iloc[:,0:6].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']/(5000)
+                    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']]
+                                        st.session_state.player_freq['Team'] = st.session_state.player_freq['Team'].replace(item_list, team_list)
                     
-                    cpt_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,0:1].values, return_counts=True)),
+                    st.session_state.cpt_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Display.iloc[:,0:1].values, return_counts=True)),
                                                 columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
-                    cpt_freq['Freq'] = cpt_freq['Freq'].astype(int)
-                    cpt_freq['Position'] = cpt_freq['Player'].map(maps_dict['Pos_map'])
-                    cpt_freq['Salary'] = cpt_freq['Player'].map(maps_dict['Salary_map'])
-                    cpt_freq['Proj Own'] = (cpt_freq['Player'].map(maps_dict['Own_map']) / 4) / 100
-                    cpt_freq['Exposure'] = cpt_freq['Freq']/(Sim_size)
-                    cpt_freq['Edge'] = cpt_freq['Exposure'] - cpt_freq['Proj Own']
-                    cpt_freq['Team'] = cpt_freq['Player'].map(maps_dict['Team_map'])
+                    st.session_state.cpt_freq['Freq'] = st.session_state.cpt_freq['Freq'].astype(int)
+                    st.session_state.cpt_freq['Position'] = st.session_state.cpt_freq['Player'].map(maps_dict['Pos_map'])
+                    st.session_state.cpt_freq['Salary'] = st.session_state.cpt_freq['Player'].map(maps_dict['Salary_map'])
+                    st.session_state.cpt_freq['Proj Own'] = (st.session_state.cpt_freq['Player'].map(maps_dict['Own_map']) / 4) / 100
+                    st.session_state.cpt_freq['Exposure'] = st.session_state.cpt_freq['Freq']/5000
+                    st.session_state.cpt_freq['Edge'] = st.session_state.cpt_freq['Exposure'] - st.session_state.cpt_freq['Proj Own']
+                    st.session_state.cpt_freq['Team'] = st.session_state.cpt_freq['Player'].map(maps_dict['Team_map'])
                     for checkVar in range(len(team_list)):
-                                        cpt_freq['Team'] = cpt_freq['Team'].replace(item_list, team_list)
-    
-                    st.session_state.cpt_freq = cpt_freq[['Player', 'Position', 'Team', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
+                                        st.session_state.cpt_freq['Team'] = st.session_state.cpt_freq['Team'].replace(item_list, team_list)
                     
-                    flex_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,[1, 2, 3, 4, 5]].values, return_counts=True)),
+                    st.session_state.flex_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Display.iloc[:,[1, 2, 3, 4, 5]].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['Player'].map(maps_dict['Own_map']) / 4) / 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['Player'].map(maps_dict['Own_map']) / 4) / 100)
+                    st.session_state.flex_freq['Exposure'] = st.session_state.flex_freq['Freq']/5000
+                    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', 'Position', 'Team', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
-                    
-                    del fp_random
-                    del sample_arrays
-                    del final_array
-                    del fp_array
-                    try:
-                        del up_array
-                    except:
-                        pass
-                    del best_lineup
-                    del CleanPortfolio
-                    del FinalPortfolio
-                    del maps_dict
-                    del team_list
-                    del item_list
-                    del Sim_size
+                                        st.session_state.flex_freq['Team'] = st.session_state.flex_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':
@@ -1114,12 +922,12 @@ with tab2:
             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',
-                )
+               st.download_button(
+                   label="Export Full Frame",
+                   data=st.session_state.Sim_Winner_Export.to_csv().encode('utf-8'),
+                   file_name='NFL_consim_export.csv',
+                   mime='text/csv',
+               )
         
         with st.container():
                 tab1, tab2, tab3 = st.tabs(['Overall Exposures', 'CPT Exposures', 'FLEX Exposures'])
@@ -1128,7 +936,7 @@ with tab2:
                         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',
                         )
@@ -1137,7 +945,7 @@ with tab2:
                         st.dataframe(st.session_state.cpt_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.cpt_freq),
+                            data=st.session_state.cpt_freq.to_csv().encode('utf-8'),
                             file_name='cpt_freq_export.csv',
                             mime='text/csv',
                         )
@@ -1146,7 +954,15 @@ 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',
-                        )
+                        )
+del gcservice_account
+del dk_roo_raw, dk_roo_raw_2, fd_roo_raw, fd_roo_raw_2
+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
+
+gc.collect()