Update app.py

app.py

@@ -43,7 +43,6 @@ def load_dk_player_projections():
     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
 
@@ -54,7 +53,6 @@ def load_fd_player_projections():
     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
 
@@ -72,9 +70,6 @@ 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
 
@@ -96,8 +91,6 @@ def run_seed_frame(seed_depth1, Strength_var, strength_grow, Teams_used, Total_R
             FinalPortfolio2, maps_dict2 = get_uncorrelated_portfolio_for_sim(Total_Runs_def * .1, sharp_split)
             FinalPortfolio = 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)
@@ -107,10 +100,6 @@ def run_seed_frame(seed_depth1, Strength_var, strength_grow, Teams_used, Total_R
             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
         elif RunsVar > 4:
             FieldStrength = 1
             FinalPortfolio3, maps_dict3 = get_correlated_portfolio_for_sim(Total_Runs_def * .1, sharp_split)
@@ -120,12 +109,8 @@ def run_seed_frame(seed_depth1, Strength_var, strength_grow, Teams_used, Total_R
             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
         RunsVar += 1
-        
+    
     return FinalPortfolio, maps_dict
 
 def create_stack_options(player_data, wr_var):
@@ -142,9 +127,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 +136,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
 
@@ -188,6 +164,7 @@ 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):
@@ -211,9 +188,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,11 +197,6 @@ 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
 
@@ -253,12 +222,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 +253,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 +261,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,8 +305,6 @@ 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
@@ -371,10 +329,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 +360,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 +368,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,8 +414,6 @@ 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
 
 
@@ -727,12 +675,6 @@ with tab1:
                             static_exposure['Exposure'] = static_exposure['count'] / len(split_portfolio)
                             static_exposure = static_exposure[['Player', 'Exposure']]
                             
-                            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])
           
@@ -770,8 +712,6 @@ with tab1:
                     overall_exposure = overall_exposure.sort_values(by='Exposure', ascending=False)
                     overall_exposure['Exposure'] = overall_exposure['Exposure'].astype(float).map(lambda n: '{:.2%}'.format(n))
                     
-                    del static_exposure
-                    
     with st.container():
           col1, col2 = st.columns([1, 6])
           
@@ -788,9 +728,7 @@ with tab1:
                               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:
@@ -808,7 +746,7 @@ with tab2:
         site_var1 = st.radio("What site are you working with?", ('Draftkings', 'Fanduel'))
         if site_var1 == 'Draftkings':
               if slate_var1 == 'User':
-                  raw_baselines = proj_dataframe[['Player', 'Salary', 'Position', 'Team', 'Opp', 'Median', 'Own']]
+                  raw_baselines = proj_dataframe[['Player', 'Salary', 'Position', 'Team', 'Opp', 'Median', 'Own']].copy()
               elif slate_var1 != 'User':
                   raw_baselines = dk_roo_raw[dk_roo_raw['slate'] == str(slate_var1)]
                   raw_baselines = raw_baselines[raw_baselines['version'] == 'overall']
@@ -818,8 +756,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':
@@ -877,51 +814,53 @@ with tab2:
                         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']].copy()
+                        
+                        # 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]
                         
-                        del proj_dataframe
-                        del OwnFrame
+                        # 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']].copy()
+                        
+                        # 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]
                         
-                        del initial_proj
-                        del drop_frame
-                        del OwnFrame
+                        # 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 +884,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 +891,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 +934,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 +953,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 +967,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
@@ -1100,10 +1025,6 @@ with tab2:
                         'team_check_map':dict(zip(cleaport_players.Player,nerf_frame.Team))
                         }
                     
-                    del cleaport_players
-                    del Overall_Proj
-                    del nerf_frame
-                    
                     st.write('Seed frame creation')
                     FinalPortfolio, maps_dict = run_seed_frame(seed_depth1, Strength_var, strength_grow, Teams_used, Total_Runs)
                     
@@ -1155,28 +1076,12 @@ with tab2:
                         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)
@@ -1187,8 +1092,6 @@ with tab2:
                     # Data Copying
                     st.session_state.Sim_Winner_Export = Sim_Winner_Frame.copy()
                     
-                    del Sim_Winner_Frame
-                    
                     # Conditional Replacement
                     columns_to_replace = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
                     
@@ -1197,9 +1100,6 @@ 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)
      
@@ -1216,7 +1116,6 @@ with tab2:
                                         player_freq['Team'] = player_freq['Team'].replace(item_list, team_list)
     
                     st.session_state.player_freq = player_freq[['Player', 'Position', 'Team', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
-                    del player_freq
                     
                     qb_freq = pd.DataFrame(np.column_stack(np.unique(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)
@@ -1231,7 +1130,6 @@ with tab2:
                                         qb_freq['Team'] = qb_freq['Team'].replace(item_list, team_list)
     
                     st.session_state.qb_freq = qb_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
-                    del qb_freq
     
                     rb_freq = pd.DataFrame(np.column_stack(np.unique(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)
@@ -1246,7 +1144,6 @@ with tab2:
                                         rb_freq['Team'] = rb_freq['Team'].replace(item_list, team_list)
     
                     st.session_state.rb_freq = rb_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
-                    del rb_freq
                     
                     wr_freq = pd.DataFrame(np.column_stack(np.unique(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)
@@ -1261,7 +1158,6 @@ with tab2:
                                         wr_freq['Team'] = wr_freq['Team'].replace(item_list, team_list)
     
                     st.session_state.wr_freq = wr_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
-                    del wr_freq
                     
                     te_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,[6]].values, return_counts=True)),
                                                columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
@@ -1276,7 +1172,6 @@ with tab2:
                                         te_freq['Team'] = te_freq['Team'].replace(item_list, team_list)
     
                     st.session_state.te_freq = te_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
-                    del te_freq
                     
                     flex_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,[7]].values, return_counts=True)),
                                                columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
@@ -1291,7 +1186,6 @@ with tab2:
                                         flex_freq['Team'] = flex_freq['Team'].replace(item_list, team_list)
     
                     st.session_state.flex_freq = flex_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
-                    del flex_freq
                     
                     dst_freq = pd.DataFrame(np.column_stack(np.unique(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)
@@ -1306,12 +1200,6 @@ with tab2:
                                         dst_freq['Team'] = dst_freq['Team'].replace(item_list, team_list)
     
                     st.session_state.dst_freq = dst_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
-                    del dst_freq
-                    
-                    del Sim_size
-                    del maps_dict
-                    del team_list
-                    del item_list
                     
         with st.container():
             simulate_container = st.empty()
@@ -1401,4 +1289,11 @@ with tab2:
                         data=convert_df_to_csv(st.session_state.dst_freq),
                         file_name='dst_freq_export.csv',
                         mime='text/csv',
-                    )
+                    )
+
+del gc
+del dk_roo_raw, fd_roo_raw
+del t_stamp
+del dkid_dict, fdid_dict
+for key in st.session_state.keys():
+    del st.session_state[key]