Update app.py

app.py

@@ -30,6 +30,7 @@ def init_conn():
           }
 
           gc_con = gspread.service_account_from_dict(credentials)
+          
           return gc_con
 
 gcservice_account = init_conn()
@@ -73,10 +74,14 @@ def set_export_ids():
 
     return dk_ids, fd_ids
 
-@st.cache_data
-def convert_df_to_csv(df):
-    return df.to_csv().encode('utf-8')
+dk_roo_raw = load_dk_player_projections()
+fd_roo_raw = load_fd_player_projections()
+t_stamp = f"Last Update: " + str(dk_roo_raw['timestamp'][0]) + f" CST"
+dkid_dict, fdid_dict = set_export_ids()
 
+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 = []
@@ -138,14 +143,14 @@ def run_seed_frame(seed_depth1, Strength_var, strength_grow, Teams_used, Total_R
     while RunsVar <= seed_depth_def:
         if RunsVar <= 3:
             FieldStrength = Strength_var_def
-            FinalPortfolio, maps_dict = get_correlated_portfolio_for_sim(Total_Runs_def * .1, sharp_split, field_growth)
-            FinalPortfolio2, maps_dict2 = get_uncorrelated_portfolio_for_sim(Total_Runs_def * .1, sharp_split, field_growth)
+            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)
         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, field_growth)
-            FinalPortfolio4, maps_dict4 = get_uncorrelated_portfolio_for_sim(Total_Runs_def * .1, sharp_split, field_growth)
+            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)
@@ -153,8 +158,8 @@ def run_seed_frame(seed_depth1, Strength_var, strength_grow, Teams_used, Total_R
             maps_dict.update(maps_dict4)
         elif RunsVar > 4:
             FieldStrength = 1
-            FinalPortfolio5, maps_dict5 = get_correlated_portfolio_for_sim(Total_Runs_def * .1, sharp_split, field_growth)
-            FinalPortfolio6, maps_dict6 = get_uncorrelated_portfolio_for_sim(Total_Runs_def * .1, sharp_split, field_growth)
+            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)
@@ -209,7 +214,7 @@ def get_overall_merged_df():
         
     df_out = pd.concat(ref_dict['pos_dfs'], ignore_index=True)
     
-    return df_out, ref_dict
+    return ref_dict
 
 def calculate_range_var(count, min_val, FieldStrength, field_growth):
     var = round(len(count[0]) * FieldStrength)
@@ -220,7 +225,7 @@ def calculate_range_var(count, min_val, FieldStrength, field_growth):
 
 def create_random_portfolio(Total_Sample_Size, raw_baselines, field_growth):
     
-            O_merge, full_pos_player_dict = get_overall_merged_df()
+            full_pos_player_dict = get_overall_merged_df()
             max_var = len(raw_baselines[raw_baselines['Position'] == 'QB'])
           
             field_growth_rounded = round(field_growth)
@@ -467,14 +472,6 @@ def get_uncorrelated_portfolio_for_sim(Total_Sample_Size, sharp_split, field_gro
     
     return RandomPortfolio, maps_dict
 
-dk_roo_raw = load_dk_player_projections()
-fd_roo_raw = load_fd_player_projections()
-t_stamp = f"Last Update: " + str(dk_roo_raw['timestamp'][0]) + f" CST"
-dkid_dict, fdid_dict = set_export_ids()
-
-static_exposure = pd.DataFrame(columns=['Player', 'count'])
-overall_exposure = pd.DataFrame(columns=['Player', 'count'])
-
 tab1, tab2 = st.tabs(['Uploads', 'Contest Sim'])
 
 with tab1:
@@ -507,7 +504,6 @@ with tab1:
                               player_salary_dict = dict(zip(proj_dataframe.Player, proj_dataframe.Salary))
                               player_proj_dict = dict(zip(proj_dataframe.Player, proj_dataframe.Median))
                               player_own_dict = dict(zip(proj_dataframe.Player, proj_dataframe.Own))
-                              player_team_dict = dict(zip(proj_dataframe.Player, proj_dataframe.Team))
                               
           with col2:
                     st.info("The Portfolio file must contain only columns in order and explicitly named: 'QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', and 'DST'. Upload your projections first to avoid an error message.")
@@ -575,23 +571,6 @@ with tab1:
                                               split_portfolio['TE'].map(player_own_dict),
                                               split_portfolio['FLEX'].map(player_own_dict),
                                               split_portfolio['DST'].map(player_own_dict)])
-                                    
-                                    split_portfolio['QB_team'] = split_portfolio['QB'].map(player_team_dict)
-                                    split_portfolio['RB1_team'] = split_portfolio['RB1'].map(player_team_dict)
-                                    split_portfolio['RB2_team'] = split_portfolio['RB2'].map(player_team_dict)
-                                    split_portfolio['WR1_team'] = split_portfolio['WR1'].map(player_team_dict)
-                                    split_portfolio['WR2_team'] = split_portfolio['WR2'].map(player_team_dict)
-                                    split_portfolio['WR3_team'] = split_portfolio['WR3'].map(player_team_dict)
-                                    split_portfolio['TE_team'] = split_portfolio['TE'].map(player_team_dict)
-                                    split_portfolio['FLEX_team'] = split_portfolio['FLEX'].map(player_team_dict)
-                                    split_portfolio['DST_team'] = split_portfolio['DST'].map(player_team_dict)
-      
-                                    split_portfolio = split_portfolio[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'Salary', 'Projection', 'Ownership', 'QB_team',
-                                                                        'RB1_team', 'RB2_team', 'WR1_team', 'WR2_team', 'WR3_team', 'TE_team', 'FLEX_team', 'DST_team']]
-      
-                                    split_portfolio['Main_Stack'] = split_portfolio.iloc[:, 15:19].apply(lambda row: row.value_counts().nlargest(2).index[0],axis=1)
-                                    split_portfolio['Main_Stack_Size'] = split_portfolio.iloc[:, 15:19].apply(lambda row: row.value_counts().nlargest(2).values[0],axis=1)
-                                    split_portfolio['Main_Stack_Size'] = split_portfolio['Main_Stack_Size'] - 1
                                 
                                 
                                 except:
@@ -648,23 +627,6 @@ with tab1:
                                               split_portfolio['TE'].map(player_own_dict),
                                               split_portfolio['FLEX'].map(player_own_dict),
                                               split_portfolio['DST'].map(player_own_dict)])
-                                    
-                                    split_portfolio['QB_team'] = split_portfolio['QB'].map(player_team_dict)
-                                    split_portfolio['RB1_team'] = split_portfolio['RB1'].map(player_team_dict)
-                                    split_portfolio['RB2_team'] = split_portfolio['RB2'].map(player_team_dict)
-                                    split_portfolio['WR1_team'] = split_portfolio['WR1'].map(player_team_dict)
-                                    split_portfolio['WR2_team'] = split_portfolio['WR2'].map(player_team_dict)
-                                    split_portfolio['WR3_team'] = split_portfolio['WR3'].map(player_team_dict)
-                                    split_portfolio['TE_team'] = split_portfolio['TE'].map(player_team_dict)
-                                    split_portfolio['FLEX_team'] = split_portfolio['FLEX'].map(player_team_dict)
-                                    split_portfolio['DST_team'] = split_portfolio['DST'].map(player_team_dict)
-      
-                                    split_portfolio = split_portfolio[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'Salary', 'Projection', 'Ownership', 'QB_team',
-                                                                        'RB1_team', 'RB2_team', 'WR1_team', 'WR2_team', 'WR3_team', 'TE_team', 'FLEX_team', 'DST_team']]
-      
-                                    split_portfolio['Main_Stack'] = split_portfolio.iloc[:, 15:19].apply(lambda row: row.value_counts().nlargest(2).index[0],axis=1)
-                                    split_portfolio['Main_Stack_Size'] = split_portfolio.iloc[:, 15:19].apply(lambda row: row.value_counts().nlargest(2).values[0],axis=1)
-                                    split_portfolio['Main_Stack_Size'] = split_portfolio['Main_Stack_Size'] - 1
                                   
                             except:
                                  split_portfolio = portfolio_dataframe
@@ -698,87 +660,9 @@ with tab1:
                                            split_portfolio['TE'].map(player_own_dict),
                                            split_portfolio['FLEX'].map(player_own_dict),
                                            split_portfolio['DST'].map(player_own_dict)])
- 
-                            split_portfolio['QB_team'] = split_portfolio['QB'].map(player_team_dict)
-                            split_portfolio['RB1_team'] = split_portfolio['RB1'].map(player_team_dict)
-                            split_portfolio['RB2_team'] = split_portfolio['RB2'].map(player_team_dict)
-                            split_portfolio['WR1_team'] = split_portfolio['WR1'].map(player_team_dict)
-                            split_portfolio['WR2_team'] = split_portfolio['WR2'].map(player_team_dict)
-                            split_portfolio['WR3_team'] = split_portfolio['WR3'].map(player_team_dict)
-                            split_portfolio['TE_team'] = split_portfolio['TE'].map(player_team_dict)
-                            split_portfolio['FLEX_team'] = split_portfolio['FLEX'].map(player_team_dict)
-                            split_portfolio['DST_team'] = split_portfolio['DST'].map(player_team_dict)
-  
-                            split_portfolio = split_portfolio[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'Salary', 'Projection', 'Ownership', 'QB_team',
-                                                                'RB1_team', 'RB2_team', 'WR1_team', 'WR2_team', 'WR3_team', 'TE_team', 'FLEX_team', 'DST_team']]
-  
-                            split_portfolio['Main_Stack'] = split_portfolio.iloc[:, 15:19].apply(lambda row: row.value_counts().nlargest(2).index[0],axis=1)
-                            split_portfolio['Main_Stack_Size'] = split_portfolio.iloc[:, 15:19].apply(lambda row: row.value_counts().nlargest(2).values[0],axis=1)
-                            split_portfolio['Main_Stack_Size'] = split_portfolio['Main_Stack_Size'] - 1
-                              
-                            for player_cols in split_portfolio.iloc[:, :9]:
-                                      static_col_raw = split_portfolio[player_cols].value_counts()
-                                      static_col = static_col_raw.to_frame()
-                                      static_col.reset_index(inplace=True)
-                                      static_col.columns = ['Player', 'count']
-                                      static_exposure = pd.concat([static_exposure, static_col], ignore_index=True)
-                            static_exposure['Exposure'] = static_exposure['count'] / len(split_portfolio)
-                            static_exposure = static_exposure[['Player', 'Exposure']]
+                                 
+                            gc.collect() 
                             
-    with st.container():
-          col1, col2 = st.columns([3, 3])
-          
-          if portfolio_file is not None:
-                    with col1:
-                              team_split_var1 = st.radio("Are you wanting to isolate any lineups with specific main stacks?", ('Full Portfolio', 'Specific Stacks'))
-                              if team_split_var1 == 'Specific Stacks':
-                                        team_var1 = st.multiselect('Which main stacks would you like to include in the Portfolio?', options = split_portfolio['Main_Stack'].unique())
-                              elif team_split_var1 == 'Full Portfolio':
-                                        team_var1 = split_portfolio.Main_Stack.values.tolist()
-                    with col2:
-                              player_split_var1 = st.radio("Are you wanting to isolate any lineups with specific players?", ('Full Players', 'Specific Players'))
-                              if player_split_var1 == 'Specific Players':
-                                        find_var1 = st.multiselect('Which players must be included in the lineups?', options = static_exposure['Player'].unique())
-                              elif player_split_var1 == 'Full Players':
-                                        find_var1 = static_exposure.Player.values.tolist()
-
-                    split_portfolio = split_portfolio[split_portfolio['Main_Stack'].isin(team_var1)]
-                    if player_split_var1 == 'Specific Players':
-                              split_portfolio = split_portfolio[np.equal.outer(split_portfolio.to_numpy(copy=False),  find_var1).any(axis=1).all(axis=1)]
-                    elif player_split_var1 == 'Full Players':
-                              split_portfolio = split_portfolio
-
-                    for player_cols in split_portfolio.iloc[:, :9]:
-                              exposure_col_raw = split_portfolio[player_cols].value_counts()
-                              exposure_col = exposure_col_raw.to_frame()
-                              exposure_col.reset_index(inplace=True)
-                              exposure_col.columns = ['Player', 'count']
-                              overall_exposure = pd.concat([overall_exposure, exposure_col], ignore_index=True)
-                    overall_exposure['Exposure'] = overall_exposure['count'] / len(split_portfolio)
-                    overall_exposure = overall_exposure.groupby('Player').sum()
-                    overall_exposure.reset_index(inplace=True)
-                    overall_exposure = overall_exposure[['Player', 'Exposure']]
-                    overall_exposure = overall_exposure.set_index('Player')
-                    overall_exposure = overall_exposure.sort_values(by='Exposure', ascending=False)
-                    overall_exposure['Exposure'] = overall_exposure['Exposure'].astype(float).map(lambda n: '{:.2%}'.format(n))
-                    
-    with st.container():
-          col1, col2 = st.columns([1, 6])
-          
-          with col1:
-                    if portfolio_file is not None:
-                              st.header('Exposure View')
-                              st.dataframe(overall_exposure)
-
-          with col2:
-                    if portfolio_file is not None:
-                              st.header('Portfolio View')
-                              split_portfolio = split_portfolio.reset_index()
-                              split_portfolio['Lineup'] = split_portfolio['index'] + 1
-                              display_portfolio = split_portfolio[['Lineup', 'QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'Salary', 'Main_Stack', 'Main_Stack_Size', 'Projection', 'Ownership']]
-                              display_portfolio = display_portfolio.set_index('Lineup')
-                              st.dataframe(display_portfolio.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').background_gradient(cmap='RdYlGn_r', subset=['Ownership']).format(precision=2))
-
 with tab2:
     col1, col2 = st.columns([1, 7])
     with col1:
@@ -796,7 +680,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']].copy()
+                  raw_baselines = proj_dataframe[['Player', 'Salary', 'Position', 'Team', 'Opp', 'Median', 'Own']]
               elif slate_var1 != 'User':
                   raw_baselines = dk_roo_raw[dk_roo_raw['slate'] == str(slate_var1)]
                   raw_baselines = raw_baselines[raw_baselines['version'] == 'overall']
@@ -854,12 +738,11 @@ with tab2:
         with st.container():
             if st.button("Simulate Contest"):
                 with st.container():
-                    st.write('Contest Simulation Starting')
                     for key in st.session_state.keys():
                         del st.session_state[key]
                     
                     if slate_var1 == 'User':
-                        initial_proj = proj_dataframe[['Player', 'Team', 'Position', 'Median', 'Own', 'Floor', 'Ceiling', 'Salary']].copy()
+                        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):
@@ -884,7 +767,7 @@ with tab2:
                         
                     elif slate_var1 != 'User':
                         # Copy only the necessary columns
-                        initial_proj = raw_baselines[['Player', 'Team', 'Position', 'Median', 'Own', 'Floor', 'Ceiling', 'Salary']].copy()
+                        initial_proj = raw_baselines[['Player', 'Team', 'Position', 'Median', 'Own', 'Floor', 'Ceiling', 'Salary']]
                         
                         # Define the calculation to be applied
                         def calculate_own(position, own, mean_own, factor, max_own=75):
@@ -1070,12 +953,10 @@ with tab2:
                         'team_check_map':dict(zip(cleaport_players.Player,nerf_frame.Team))
                         }
                     
-                    st.write('Seed frame creation')
                     FinalPortfolio, maps_dict = run_seed_frame(10, Strength_var, strength_grow, Teams_used, 1000000, field_growth)
                     
                     Sim_Winners = sim_contest(2500, FinalPortfolio, CleanPortfolio, maps_dict, up_dict, insert_port)
-                        
-                    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
@@ -1084,11 +965,13 @@ with tab2:
                     type_cast_dict = {'Salary': int, 'Projection': np.float16, 'Fantasy': np.float16, 'GPP_Proj': np.float16}
                     Sim_Winner_Frame = Sim_Winner_Frame.astype(type_cast_dict)
                     
+                    del FinalPortfolio, insert_port, type_cast_dict
+                    
                     # Sorting
                     st.session_state.Sim_Winner_Frame = Sim_Winner_Frame.sort_values(by='GPP_Proj', ascending=False)
                     
                     # Data Copying
-                    st.session_state.Sim_Winner_Export = Sim_Winner_Frame.copy()
+                    st.session_state.Sim_Winner_Export = Sim_Winner_Frame
                     
                     # Conditional Replacement
                     columns_to_replace = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
@@ -1100,107 +983,94 @@ with tab2:
                     
                     for col in columns_to_replace:
                         st.session_state.Sim_Winner_Export[col].replace(replace_dict, inplace=True)
+                    
+                    del replace_dict, Sim_Winner_Frame, Sim_Winners
      
-                    player_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,0:9].values, return_counts=True)),
+                    st.session_state.player_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,0:9].values, return_counts=True)),
                                                 columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
-                    player_freq['Freq'] = player_freq['Freq'].astype(int)
-                    player_freq['Position'] = player_freq['Player'].map(maps_dict['Pos_map'])
-                    player_freq['Salary'] = player_freq['Player'].map(maps_dict['Salary_map'])
-                    player_freq['Proj Own'] = player_freq['Player'].map(maps_dict['Own_map']) / 100
-                    player_freq['Exposure'] = player_freq['Freq']/(2500)
-                    player_freq['Edge'] = player_freq['Exposure'] - player_freq['Proj Own']
-                    player_freq['Team'] = player_freq['Player'].map(maps_dict['Team_map'])
+                    st.session_state.player_freq['Freq'] = st.session_state.player_freq['Freq'].astype(int)
+                    st.session_state.player_freq['Position'] = st.session_state.player_freq['Player'].map(maps_dict['Pos_map'])
+                    st.session_state.player_freq['Salary'] = st.session_state.player_freq['Player'].map(maps_dict['Salary_map'])
+                    st.session_state.player_freq['Proj Own'] = st.session_state.player_freq['Player'].map(maps_dict['Own_map']) / 100
+                    st.session_state.player_freq['Exposure'] = st.session_state.player_freq['Freq']/(2500)
+                    st.session_state.player_freq['Edge'] = st.session_state.player_freq['Exposure'] - st.session_state.player_freq['Proj Own']
+                    st.session_state.player_freq['Team'] = st.session_state.player_freq['Player'].map(maps_dict['Team_map'])
                     for checkVar in range(len(team_list)):
-                                        player_freq['Team'] = player_freq['Team'].replace(item_list, team_list)
-    
-                    st.session_state.player_freq = player_freq[['Player', 'Position', 'Team', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
+                                        st.session_state.player_freq['Team'] = st.session_state.player_freq['Team'].replace(item_list, team_list)
                     
-                    qb_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,0:1].values, return_counts=True)),
+                    st.session_state.qb_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,0:1].values, return_counts=True)),
                                                 columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
-                    qb_freq['Freq'] = qb_freq['Freq'].astype(int)
-                    qb_freq['Position'] = qb_freq['Player'].map(maps_dict['Pos_map'])
-                    qb_freq['Salary'] = qb_freq['Player'].map(maps_dict['Salary_map'])
-                    qb_freq['Proj Own'] = qb_freq['Player'].map(maps_dict['Own_map']) / 100
-                    qb_freq['Exposure'] = qb_freq['Freq']/(2500)
-                    qb_freq['Edge'] = qb_freq['Exposure'] - qb_freq['Proj Own']
-                    qb_freq['Team'] = qb_freq['Player'].map(maps_dict['Team_map'])
+                    st.session_state.qb_freq['Freq'] = st.session_state.qb_freq['Freq'].astype(int)
+                    st.session_state.qb_freq['Position'] = st.session_state.qb_freq['Player'].map(maps_dict['Pos_map'])
+                    st.session_state.qb_freq['Salary'] = st.session_state.qb_freq['Player'].map(maps_dict['Salary_map'])
+                    st.session_state.qb_freq['Proj Own'] = st.session_state.qb_freq['Player'].map(maps_dict['Own_map']) / 100
+                    st.session_state.qb_freq['Exposure'] = st.session_state.qb_freq['Freq']/(2500)
+                    st.session_state.qb_freq['Edge'] = st.session_state.qb_freq['Exposure'] - st.session_state.qb_freq['Proj Own']
+                    st.session_state.qb_freq['Team'] = st.session_state.qb_freq['Player'].map(maps_dict['Team_map'])
                     for checkVar in range(len(team_list)):
-                                        qb_freq['Team'] = qb_freq['Team'].replace(item_list, team_list)
-    
-                    st.session_state.qb_freq = qb_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
+                                        st.session_state.qb_freq['Team'] = st.session_state.qb_freq['Team'].replace(item_list, team_list)
     
-                    rb_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,[1, 2]].values, return_counts=True)),
+                    st.session_state.rb_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,[1, 2]].values, return_counts=True)),
                                                columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
-                    rb_freq['Freq'] = rb_freq['Freq'].astype(int)
-                    rb_freq['Position'] = rb_freq['Player'].map(maps_dict['Pos_map'])
-                    rb_freq['Salary'] = rb_freq['Player'].map(maps_dict['Salary_map'])
-                    rb_freq['Proj Own'] = rb_freq['Player'].map(maps_dict['Own_map']) / 100
-                    rb_freq['Exposure'] = rb_freq['Freq']/2500
-                    rb_freq['Edge'] = rb_freq['Exposure'] - rb_freq['Proj Own']
-                    rb_freq['Team'] = rb_freq['Player'].map(maps_dict['Team_map'])
+                    st.session_state.rb_freq['Freq'] = st.session_state.rb_freq['Freq'].astype(int)
+                    st.session_state.rb_freq['Position'] = st.session_state.rb_freq['Player'].map(maps_dict['Pos_map'])
+                    st.session_state.rb_freq['Salary'] = st.session_state.rb_freq['Player'].map(maps_dict['Salary_map'])
+                    st.session_state.rb_freq['Proj Own'] = st.session_state.rb_freq['Player'].map(maps_dict['Own_map']) / 100
+                    st.session_state.rb_freq['Exposure'] = st.session_state.rb_freq['Freq']/2500
+                    st.session_state.rb_freq['Edge'] = st.session_state.rb_freq['Exposure'] - st.session_state.rb_freq['Proj Own']
+                    st.session_state.rb_freq['Team'] = st.session_state.rb_freq['Player'].map(maps_dict['Team_map'])
                     for checkVar in range(len(team_list)):
-                                        rb_freq['Team'] = rb_freq['Team'].replace(item_list, team_list)
-    
-                    st.session_state.rb_freq = rb_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
+                                        st.session_state.rb_freq['Team'] = st.session_state.rb_freq['Team'].replace(item_list, team_list)
                     
-                    wr_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,[3, 4, 5]].values, return_counts=True)),
+                    st.session_state.wr_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,[3, 4, 5]].values, return_counts=True)),
                                                columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
-                    wr_freq['Freq'] = wr_freq['Freq'].astype(int)
-                    wr_freq['Position'] = wr_freq['Player'].map(maps_dict['Pos_map'])
-                    wr_freq['Salary'] = wr_freq['Player'].map(maps_dict['Salary_map'])
-                    wr_freq['Proj Own'] = wr_freq['Player'].map(maps_dict['Own_map']) / 100
-                    wr_freq['Exposure'] = wr_freq['Freq']/2500
-                    wr_freq['Edge'] = wr_freq['Exposure'] - wr_freq['Proj Own']
-                    wr_freq['Team'] = wr_freq['Player'].map(maps_dict['Team_map'])
+                    st.session_state.wr_freq['Freq'] = st.session_state.wr_freq['Freq'].astype(int)
+                    st.session_state.wr_freq['Position'] = st.session_state.wr_freq['Player'].map(maps_dict['Pos_map'])
+                    st.session_state.wr_freq['Salary'] = st.session_state.wr_freq['Player'].map(maps_dict['Salary_map'])
+                    st.session_state.wr_freq['Proj Own'] = st.session_state.wr_freq['Player'].map(maps_dict['Own_map']) / 100
+                    st.session_state.wr_freq['Exposure'] = st.session_state.wr_freq['Freq']/2500
+                    st.session_state.wr_freq['Edge'] = st.session_state.wr_freq['Exposure'] - st.session_state.wr_freq['Proj Own']
+                    st.session_state.wr_freq['Team'] = st.session_state.wr_freq['Player'].map(maps_dict['Team_map'])
                     for checkVar in range(len(team_list)):
-                                        wr_freq['Team'] = wr_freq['Team'].replace(item_list, team_list)
-    
-                    st.session_state.wr_freq = wr_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
+                                        st.session_state.wr_freq['Team'] = st.session_state.wr_freq['Team'].replace(item_list, team_list)
                     
-                    te_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,[6]].values, return_counts=True)),
+                    st.session_state.te_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,[6]].values, return_counts=True)),
                                                columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
-                    te_freq['Freq'] = te_freq['Freq'].astype(int)
-                    te_freq['Position'] = te_freq['Player'].map(maps_dict['Pos_map'])
-                    te_freq['Salary'] = te_freq['Player'].map(maps_dict['Salary_map'])
-                    te_freq['Proj Own'] = te_freq['Player'].map(maps_dict['Own_map']) / 100
-                    te_freq['Exposure'] = te_freq['Freq']/2500
-                    te_freq['Edge'] = te_freq['Exposure'] - te_freq['Proj Own']
-                    te_freq['Team'] = te_freq['Player'].map(maps_dict['Team_map'])
+                    st.session_state.te_freq['Freq'] = st.session_state.te_freq['Freq'].astype(int)
+                    st.session_state.te_freq['Position'] = st.session_state.te_freq['Player'].map(maps_dict['Pos_map'])
+                    st.session_state.te_freq['Salary'] = st.session_state.te_freq['Player'].map(maps_dict['Salary_map'])
+                    st.session_state.te_freq['Proj Own'] = st.session_state.te_freq['Player'].map(maps_dict['Own_map']) / 100
+                    st.session_state.te_freq['Exposure'] = st.session_state.te_freq['Freq']/2500
+                    st.session_state.te_freq['Edge'] = st.session_state.te_freq['Exposure'] - st.session_state.te_freq['Proj Own']
+                    st.session_state.te_freq['Team'] = st.session_state.te_freq['Player'].map(maps_dict['Team_map'])
                     for checkVar in range(len(team_list)):
-                                        te_freq['Team'] = te_freq['Team'].replace(item_list, team_list)
-    
-                    st.session_state.te_freq = te_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
+                                        st.session_state.te_freq['Team'] = st.session_state.te_freq['Team'].replace(item_list, team_list)
                     
-                    flex_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,[7]].values, return_counts=True)),
+                    st.session_state.flex_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,[7]].values, return_counts=True)),
                                                columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
-                    flex_freq['Freq'] = flex_freq['Freq'].astype(int)
-                    flex_freq['Position'] = flex_freq['Player'].map(maps_dict['Pos_map'])
-                    flex_freq['Salary'] = flex_freq['Player'].map(maps_dict['Salary_map'])
-                    flex_freq['Proj Own'] = flex_freq['Player'].map(maps_dict['Own_map']) / 100
-                    flex_freq['Exposure'] = flex_freq['Freq']/2500
-                    flex_freq['Edge'] = flex_freq['Exposure'] - flex_freq['Proj Own']
-                    flex_freq['Team'] = flex_freq['Player'].map(maps_dict['Team_map'])
+                    st.session_state.flex_freq['Freq'] = st.session_state.flex_freq['Freq'].astype(int)
+                    st.session_state.flex_freq['Position'] = st.session_state.flex_freq['Player'].map(maps_dict['Pos_map'])
+                    st.session_state.flex_freq['Salary'] = st.session_state.flex_freq['Player'].map(maps_dict['Salary_map'])
+                    st.session_state.flex_freq['Proj Own'] = st.session_state.flex_freq['Player'].map(maps_dict['Own_map']) / 100
+                    st.session_state.flex_freq['Exposure'] = st.session_state.flex_freq['Freq']/2500
+                    st.session_state.flex_freq['Edge'] = st.session_state.flex_freq['Exposure'] - st.session_state.flex_freq['Proj Own']
+                    st.session_state.flex_freq['Team'] = st.session_state.flex_freq['Player'].map(maps_dict['Team_map'])
                     for checkVar in range(len(team_list)):
-                                        flex_freq['Team'] = flex_freq['Team'].replace(item_list, team_list)
-    
-                    st.session_state.flex_freq = flex_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
+                                        st.session_state.flex_freq['Team'] = st.session_state.flex_freq['Team'].replace(item_list, team_list)
                     
-                    dst_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,8:9].values, return_counts=True)),
+                    st.session_state.dst_freq = pd.DataFrame(np.column_stack(np.unique(st.session_state.Sim_Winner_Frame.iloc[:,8:9].values, return_counts=True)),
                                                columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
-                    dst_freq['Freq'] = dst_freq['Freq'].astype(int)
-                    dst_freq['Position'] = dst_freq['Player'].map(maps_dict['Pos_map'])
-                    dst_freq['Salary'] = dst_freq['Player'].map(maps_dict['Salary_map'])
-                    dst_freq['Proj Own'] = dst_freq['Player'].map(maps_dict['Own_map']) / 100
-                    dst_freq['Exposure'] = dst_freq['Freq']/2500
-                    dst_freq['Edge'] = dst_freq['Exposure'] - dst_freq['Proj Own']
-                    dst_freq['Team'] = dst_freq['Player'].map(maps_dict['Team_map'])
+                    st.session_state.dst_freq['Freq'] = st.session_state.dst_freq['Freq'].astype(int)
+                    st.session_state.dst_freq['Position'] = st.session_state.dst_freq['Player'].map(maps_dict['Pos_map'])
+                    st.session_state.dst_freq['Salary'] = st.session_state.dst_freq['Player'].map(maps_dict['Salary_map'])
+                    st.session_state.dst_freq['Proj Own'] = st.session_state.dst_freq['Player'].map(maps_dict['Own_map']) / 100
+                    st.session_state.dst_freq['Exposure'] = st.session_state.dst_freq['Freq']/2500
+                    st.session_state.dst_freq['Edge'] = st.session_state.dst_freq['Exposure'] - st.session_state.dst_freq['Proj Own']
+                    st.session_state.dst_freq['Team'] = st.session_state.dst_freq['Player'].map(maps_dict['Team_map'])
                     for checkVar in range(len(team_list)):
-                                        dst_freq['Team'] = dst_freq['Team'].replace(item_list, team_list)
-    
-                    st.session_state.dst_freq = dst_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
+                                        st.session_state.dst_freq['Team'] = st.session_state.dst_freq['Team'].replace(item_list, team_list)
                     
         with st.container():
-            simulate_container = st.empty()
             if 'player_freq' in st.session_state: 
                 player_split_var2 = st.radio("Are you wanting to isolate any lineups with specific players?", ('Full Players', 'Specific Players'), key='player_split_var2')
                 if player_split_var2 == 'Specific Players':
@@ -1209,7 +1079,7 @@ with tab2:
                           find_var2 = st.session_state.player_freq.Player.values.tolist()
     
                 if player_split_var2 == 'Specific Players':
-                          st.session_state.Sim_Winner_Display = st.session_state.Sim_Winner_Frame[np.equal.outer(st.session_state.Sim_Winner_Frame.to_numpy(copy=False),  find_var2).any(axis=1).all(axis=1)]
+                          st.session_state.Sim_Winner_Display = st.session_state.Sim_Winner_Frame[np.equal.outer(st.session_state.Sim_Winner_Frame.to_numpy(), find_var2).any(axis=1).all(axis=1)]
                 if player_split_var2 == 'Full Players':
                           st.session_state.Sim_Winner_Display = st.session_state.Sim_Winner_Frame
             if 'Sim_Winner_Display' in st.session_state:
@@ -1217,20 +1087,19 @@ with tab2:
             if 'Sim_Winner_Export' in st.session_state:
                 st.download_button(
                     label="Export Tables",
-                    data=convert_df_to_csv(st.session_state.Sim_Winner_Export),
+                    data=st.session_state.Sim_Winner_Export.to_csv().encode('utf-8'),
                     file_name='NFL_consim_export.csv',
                     mime='text/csv',
                 )
         
         with st.container():
-            freq_container = st.empty()
             tab1, tab2, tab3, tab4, tab5, tab6, tab7 = st.tabs(['Overall Exposures', 'QB Exposures', 'RB Exposures', 'WR Exposures', 'TE Exposures', 'FLEX Exposures', 'DST Exposures'])
             with tab1:
                 if 'player_freq' in st.session_state:
                     st.dataframe(st.session_state.player_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
                     st.download_button(
                         label="Export Exposures",
-                        data=convert_df_to_csv(st.session_state.player_freq),
+                        data=st.session_state.player_freq.to_csv().encode('utf-8'),
                         file_name='player_freq_export.csv',
                         mime='text/csv',
                     )
@@ -1239,7 +1108,7 @@ with tab2:
                     st.dataframe(st.session_state.qb_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
                     st.download_button(
                         label="Export Exposures",
-                        data=convert_df_to_csv(st.session_state.qb_freq),
+                        data=st.session_state.qb_freq.to_csv().encode('utf-8'),
                         file_name='qb_freq_export.csv',
                         mime='text/csv',
                     )
@@ -1248,7 +1117,7 @@ with tab2:
                     st.dataframe(st.session_state.rb_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
                     st.download_button(
                         label="Export Exposures",
-                        data=convert_df_to_csv(st.session_state.rb_freq),
+                        data=st.session_state.rb_freq.to_csv().encode('utf-8'),
                         file_name='rb_freq_export.csv',
                         mime='text/csv',
                     )
@@ -1257,7 +1126,7 @@ with tab2:
                     st.dataframe(st.session_state.wr_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
                     st.download_button(
                         label="Export Exposures",
-                        data=convert_df_to_csv(st.session_state.wr_freq),
+                        data=st.session_state.wr_freq.to_csv().encode('utf-8'),
                         file_name='wr_freq_export.csv',
                         mime='text/csv',
                     )
@@ -1266,7 +1135,7 @@ with tab2:
                     st.dataframe(st.session_state.te_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
                     st.download_button(
                         label="Export Exposures",
-                        data=convert_df_to_csv(st.session_state.te_freq),
+                        data=st.session_state.te_freq.to_csv().encode('utf-8'),
                         file_name='te_freq_export.csv',
                         mime='text/csv',
                     )
@@ -1275,7 +1144,7 @@ with tab2:
                     st.dataframe(st.session_state.flex_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
                     st.download_button(
                         label="Export Exposures",
-                        data=convert_df_to_csv(st.session_state.flex_freq),
+                        data=st.session_state.flex_freq.to_csv().encode('utf-8'),
                         file_name='flex_freq_export.csv',
                         mime='text/csv',
                     )
@@ -1284,7 +1153,7 @@ with tab2:
                     st.dataframe(st.session_state.dst_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
                     st.download_button(
                         label="Export Exposures",
-                        data=convert_df_to_csv(st.session_state.dst_freq),
+                        data=st.session_state.dst_freq.to_csv().encode('utf-8'),
                         file_name='dst_freq_export.csv',
                         mime='text/csv',
                     )
@@ -1295,4 +1164,5 @@ del t_stamp
 del dkid_dict, fdid_dict
 del static_exposure, overall_exposure
 del insert_port1, Contest_Size, sharp_split, Strength_var, scaling_var, Sort_function, Sim_function, strength_grow, field_growth
-del raw_baselines
+del raw_baselines
+del freq_format