Update app.py

app.py

@@ -46,64 +46,6 @@ player_roo_format = {'Top_finish': '{:.2%}','Top_5_finish': '{:.2%}', 'Top_10_fi
 
 freq_format = {'Proj Own': '{:.2%}', 'Exposure': '{:.2%}', 'Edge': '{:.2%}'}
 
-@st.cache_resource(ttl = 60)
-def set_slate_teams():
-    sh = gc.open_by_url('https://docs.google.com/spreadsheets/d/1I_1Ve3F4tftgfLQQoRKOJ351XfEG48s36OxXUKxmgS8/edit#gid=1391856348')
-    worksheet = sh.worksheet('Site_Info')
-    raw_display = pd.DataFrame(worksheet.get_all_records())
-
-    return raw_display
-
-@st.cache_resource(ttl = 60)
-def player_stat_table():
-    sh = gc.open_by_url('https://docs.google.com/spreadsheets/d/1I_1Ve3F4tftgfLQQoRKOJ351XfEG48s36OxXUKxmgS8/edit#gid=1391856348')
-    worksheet = sh.worksheet('Player_Projections')
-    raw_display = pd.DataFrame(worksheet.get_all_records())
-
-    return raw_display
-
-@st.cache_resource(ttl = 60)
-def load_dk_player_projections():
-    sh = gc.open_by_url('https://docs.google.com/spreadsheets/d/1I_1Ve3F4tftgfLQQoRKOJ351XfEG48s36OxXUKxmgS8/edit#gid=1391856348')
-    worksheet = sh.worksheet('DK_ROO')
-    load_display = pd.DataFrame(worksheet.get_all_records())
-    load_display.replace('', np.nan, inplace=True)
-    raw_display = load_display.dropna(subset=['Median'])
-    del load_display
-
-    return raw_display
-
-@st.cache_resource(ttl = 60)
-def load_fd_player_projections():
-    sh = gc.open_by_url('https://docs.google.com/spreadsheets/d/1I_1Ve3F4tftgfLQQoRKOJ351XfEG48s36OxXUKxmgS8/edit#gid=1391856348')
-    worksheet = sh.worksheet('FD_ROO')
-    load_display = pd.DataFrame(worksheet.get_all_records())
-    load_display.replace('', np.nan, inplace=True)
-    raw_display = load_display.dropna(subset=['Median'])
-    del load_display
-
-    return raw_display
-
-@st.cache_resource(ttl = 60)
-def set_export_ids():
-    sh = gc.open_by_url('https://docs.google.com/spreadsheets/d/1I_1Ve3F4tftgfLQQoRKOJ351XfEG48s36OxXUKxmgS8/edit#gid=1391856348')
-    worksheet = sh.worksheet('DK_ROO')
-    load_display = pd.DataFrame(worksheet.get_all_records())
-    load_display.replace('', np.nan, inplace=True)
-    raw_display = load_display.dropna(subset=['Median'])
-    dk_ids = dict(zip(raw_display['Player'], raw_display['player_id']))
-    
-    worksheet = sh.worksheet('FD_ROO')
-    load_display = pd.DataFrame(worksheet.get_all_records())
-    load_display.replace('', np.nan, inplace=True)
-    raw_display = load_display.dropna(subset=['Median'])
-    fd_ids = dict(zip(raw_display['Player'], raw_display['player_id']))
-    
-    del load_display
-    del raw_display
-
-    return dk_ids, fd_ids
-
 @st.cache_data
 def convert_df_to_csv(df):
     return df.to_csv().encode('utf-8')
@@ -198,12 +140,12 @@ def create_overall_dfs(pos_players, table_name, dict_name, pos):
 
 def get_overall_merged_df():
     ref_dict = {
-        'pos':['RB', 'WR', 'TE', 'FLEX'],
-        'pos_dfs':['RB_Table', 'WR_Table', 'TE_Table', 'FLEX_Table'],
-        'pos_dicts':['rb_dict', 'wr_dict', 'te_dict', 'flex_dict']
+        'pos':['RB', 'WR', 'FLEX'],
+        'pos_dfs':['RB_Table', 'WR_Table', 'FLEX_Table'],
+        'pos_dicts':['rb_dict', 'wr_dict', 'flex_dict']
         }
     
-    for i in range(0,4):
+    for i in range(0,3):
         ref_dict['pos_dfs'][i], ref_dict['pos_dicts'][i] =\
             create_overall_dfs(pos_players, ref_dict['pos_dfs'][i], ref_dict['pos_dicts'][i], ref_dict['pos'][i])
         
@@ -226,7 +168,7 @@ def create_random_portfolio(Total_Sample_Size, raw_baselines):
             ranges_dict = {}
             
             # Calculate ranges
-            for df, dict_val, min_val, key in zip(ref_dict['pos_dfs'], ref_dict['pos_dicts'], [10, 20, 30, 10], ['RB', 'WR', 'TE', 'FLEX']):
+            for df, dict_val, min_val, key in zip(ref_dict['pos_dfs'], ref_dict['pos_dicts'], [10, 20, 30], ['RB', 'WR', 'FLEX']):
                 count = create_overall_dfs(pos_players, df, dict_val, key)
                 ranges_dict[f"{key.lower()}_range"] = calculate_range_var(count, min_val, FieldStrength, field_growth_rounded)
             if max_var <= 10:
@@ -244,11 +186,11 @@ def create_random_portfolio(Total_Sample_Size, raw_baselines):
             
             # Generate random portfolios
             rng = np.random.default_rng()
-            total_elements = [1, 2, 3, 1, 1, 1]
-            keys = ['qb', 'rb', 'wr', 'te', 'flex', 'dst']
+            total_elements = [1, 1, 2, 2, 1]
+            keys = ['qb', 'rb', 'wr', 'flex', 'dst']
             
             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 = pd.DataFrame(np.hstack(all_choices), columns=['QB', 'RB1', 'WR1', 'WR2', 'FLEX1', 'FLEX2', 'DST'])
             RandomPortfolio['User/Field'] = 0
             
             del O_merge
@@ -263,40 +205,16 @@ def get_correlated_portfolio_for_sim(Total_Sample_Size):
     stack_num = random.randint(1, 3)
     stacking_dict = create_stack_options(raw_baselines, stack_num)
     
-    # # Create a dictionary for mapping positions to their corresponding dictionaries
-    # dict_map = {
-    #     'QB': qb_dict,
-    #     'RB1': full_pos_player_dict['pos_dicts'][0],
-    #     'RB2': full_pos_player_dict['pos_dicts'][0],
-    #     'WR1': full_pos_player_dict['pos_dicts'][1],
-    #     'WR2': full_pos_player_dict['pos_dicts'][1],
-    #     'WR3': full_pos_player_dict['pos_dicts'][1],
-    #     'TE': full_pos_player_dict['pos_dicts'][2],
-    #     'FLEX': full_pos_player_dict['pos_dicts'][3],
-    #     'DST': def_dict
-    # }
-    
-    # # Apply mapping for each position
-    # for pos, mapping in dict_map.items():
-    #     RandomPortfolio[pos] = RandomPortfolio[pos].map(mapping).astype("string[pyarrow]")
-    
-    # # This part appears to be for filtering. Consider if it can be optimized depending on the data characteristics
-    # RandomPortfolio['plyr_list'] = RandomPortfolio.values.tolist()
-    # RandomPortfolio['plyr_count'] = RandomPortfolio['plyr_list'].apply(lambda x: len(set(x)))
-    # RandomPortfolio = RandomPortfolio[RandomPortfolio['plyr_count'] == 10].drop(columns=['plyr_list','plyr_count']).reset_index(drop=True)
-    
     RandomPortfolio['QB'] = pd.Series(list(RandomPortfolio['QB'].map(qb_dict)), dtype="string[pyarrow]")
     RandomPortfolio['RB1'] = pd.Series(list(RandomPortfolio['RB1'].map(full_pos_player_dict['pos_dicts'][0])), dtype="string[pyarrow]")
-    RandomPortfolio['RB2'] = pd.Series(list(RandomPortfolio['RB2'].map(full_pos_player_dict['pos_dicts'][0])), dtype="string[pyarrow]")
     RandomPortfolio['WR1'] = pd.Series(list(RandomPortfolio['QB'].map(stacking_dict)), dtype="string[pyarrow]")
     RandomPortfolio['WR2'] = pd.Series(list(RandomPortfolio['WR2'].map(full_pos_player_dict['pos_dicts'][1])), dtype="string[pyarrow]")
-    RandomPortfolio['WR3'] = pd.Series(list(RandomPortfolio['WR3'].map(full_pos_player_dict['pos_dicts'][1])), dtype="string[pyarrow]")
-    RandomPortfolio['TE'] = pd.Series(list(RandomPortfolio['TE'].map(full_pos_player_dict['pos_dicts'][2])), dtype="string[pyarrow]")
-    RandomPortfolio['FLEX'] = pd.Series(list(RandomPortfolio['FLEX'].map(full_pos_player_dict['pos_dicts'][3])), dtype="string[pyarrow]")
+    RandomPortfolio['FLEX1'] = pd.Series(list(RandomPortfolio['FLEX1'].map(full_pos_player_dict['pos_dicts'][2])), dtype="string[pyarrow]")
+    RandomPortfolio['FLEX2'] = pd.Series(list(RandomPortfolio['FLEX2'].map(full_pos_player_dict['pos_dicts'][2])), dtype="string[pyarrow]")
     RandomPortfolio['DST'] = pd.Series(list(RandomPortfolio['DST'].map(def_dict)), dtype="string[pyarrow]")
     RandomPortfolio['plyr_list'] = RandomPortfolio[RandomPortfolio.columns.values.tolist()].values.tolist()
     RandomPortfolio['plyr_count'] = RandomPortfolio['plyr_list'].apply(lambda x: len(set(x)))
-    RandomPortfolio = RandomPortfolio[RandomPortfolio['plyr_count'] == 10].drop(columns=['plyr_list','plyr_count']).\
+    RandomPortfolio = RandomPortfolio[RandomPortfolio['plyr_count'] == 8].drop(columns=['plyr_list','plyr_count']).\
         reset_index(drop=True)
     
     del sizesplit
@@ -304,48 +222,40 @@ def get_correlated_portfolio_for_sim(Total_Sample_Size):
     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)
     RandomPortfolio['WR1s'] = RandomPortfolio['WR1'].map(maps_dict['Salary_map']).astype(np.int32)
     RandomPortfolio['WR2s'] = RandomPortfolio['WR2'].map(maps_dict['Salary_map']).astype(np.int32)
-    RandomPortfolio['WR3s'] = RandomPortfolio['WR3'].map(maps_dict['Salary_map']).astype(np.int32)
-    RandomPortfolio['TEs'] = RandomPortfolio['TE'].map(maps_dict['Salary_map']).astype(np.int32)
-    RandomPortfolio['FLEXs'] = RandomPortfolio['FLEX'].map(maps_dict['Salary_map']).astype(np.int32)
+    RandomPortfolio['FLEX1s'] = RandomPortfolio['FLEX1'].map(maps_dict['Salary_map']).astype(np.int32)
+    RandomPortfolio['FLEX2s'] = RandomPortfolio['FLEX2'].map(maps_dict['Salary_map']).astype(np.int32)
     RandomPortfolio['DSTs'] = RandomPortfolio['DST'].map(maps_dict['Salary_map']).astype(np.int32)
     
     RandomPortfolio['QBp'] = RandomPortfolio['QB'].map(maps_dict['Projection_map']).astype(np.float16)
     RandomPortfolio['RB1p'] = RandomPortfolio['RB1'].map(maps_dict['Projection_map']).astype(np.float16)
-    RandomPortfolio['RB2p'] = RandomPortfolio['RB2'].map(maps_dict['Projection_map']).astype(np.float16)
     RandomPortfolio['WR1p'] = RandomPortfolio['WR1'].map(maps_dict['Projection_map']).astype(np.float16)
     RandomPortfolio['WR2p'] = RandomPortfolio['WR2'].map(maps_dict['Projection_map']).astype(np.float16)
-    RandomPortfolio['WR3p'] = RandomPortfolio['WR3'].map(maps_dict['Projection_map']).astype(np.float16)
-    RandomPortfolio['TEp'] = RandomPortfolio['TE'].map(maps_dict['Projection_map']).astype(np.float16)
-    RandomPortfolio['FLEXp'] = RandomPortfolio['FLEX'].map(maps_dict['Projection_map']).astype(np.float16)
+    RandomPortfolio['FLEX1p'] = RandomPortfolio['FLEX1'].map(maps_dict['Projection_map']).astype(np.float16)
+    RandomPortfolio['FLEX2p'] = RandomPortfolio['FLEX2'].map(maps_dict['Projection_map']).astype(np.float16)
     RandomPortfolio['DSTp'] = RandomPortfolio['DST'].map(maps_dict['Projection_map']).astype(np.float16)
     
     RandomPortfolio['QBo'] = RandomPortfolio['QB'].map(maps_dict['Own_map']).astype(np.float16)
     RandomPortfolio['RB1o'] = RandomPortfolio['RB1'].map(maps_dict['Own_map']).astype(np.float16)
-    RandomPortfolio['RB2o'] = RandomPortfolio['RB2'].map(maps_dict['Own_map']).astype(np.float16)
     RandomPortfolio['WR1o'] = RandomPortfolio['WR1'].map(maps_dict['Own_map']).astype(np.float16)
     RandomPortfolio['WR2o'] = RandomPortfolio['WR2'].map(maps_dict['Own_map']).astype(np.float16)
-    RandomPortfolio['WR3o'] = RandomPortfolio['WR3'].map(maps_dict['Own_map']).astype(np.float16)
-    RandomPortfolio['TEo'] = RandomPortfolio['TE'].map(maps_dict['Own_map']).astype(np.float16)
-    RandomPortfolio['FLEXo'] = RandomPortfolio['FLEX'].map(maps_dict['Own_map']).astype(np.float16)
+    RandomPortfolio['FLEX1o'] = RandomPortfolio['FLEX1'].map(maps_dict['Own_map']).astype(np.float16)
+    RandomPortfolio['FLEX2o'] = RandomPortfolio['FLEX2'].map(maps_dict['Own_map']).astype(np.float16)
     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))]
-    RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,28:37].astype(np.double))]
+    RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,8:17].astype(int))]
+    RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,17:26].astype(np.double))]
+    RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,26:35].astype(np.double))]
     
-    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'])
+    RandomPortArrayOut = np.delete(RandomPortArray, np.s_[8:35], axis=1)
+    RandomPortfolioDF = pd.DataFrame(RandomPortArrayOut, columns = ['QB', 'RB1', 'WR1', 'WR2', 'FLEX1', 'FLEX2', 'DST', 'User/Field', 'Salary', 'Projection', 'Own'])
     RandomPortfolioDF = RandomPortfolioDF.sort_values(by=Sim_function, ascending=False)
     del RandomPortArray
     del RandomPortArrayOut
@@ -353,47 +263,38 @@ def get_correlated_portfolio_for_sim(Total_Sample_Size):
     if insert_port == 1:
         CleanPortfolio['Salary'] = sum([CleanPortfolio['QB'].map(maps_dict['Salary_map']),
                                         CleanPortfolio['RB1'].map(maps_dict['Salary_map']),
-                                        CleanPortfolio['RB2'].map(maps_dict['Salary_map']),
                                         CleanPortfolio['WR1'].map(maps_dict['Salary_map']),
                                         CleanPortfolio['WR2'].map(maps_dict['Salary_map']),
-                                        CleanPortfolio['WR3'].map(maps_dict['Salary_map']),
-                                        CleanPortfolio['TE'].map(maps_dict['Salary_map']),
-                                        CleanPortfolio['FLEX'].map(maps_dict['Salary_map']),
+                                        CleanPortfolio['FLEX1'].map(maps_dict['Salary_map']),
+                                        CleanPortfolio['FLEX2'].map(maps_dict['Salary_map']),
                                         CleanPortfolio['DST'].map(maps_dict['Salary_map'])
                                         ]).astype(np.int16)
     if insert_port == 1:
         CleanPortfolio['Projection'] = sum([CleanPortfolio['QB'].map(up_dict['Projection_map']),
                                             CleanPortfolio['RB1'].map(up_dict['Projection_map']),
-                                            CleanPortfolio['RB2'].map(up_dict['Projection_map']),
                                             CleanPortfolio['WR1'].map(up_dict['Projection_map']),
                                             CleanPortfolio['WR2'].map(up_dict['Projection_map']),
-                                            CleanPortfolio['WR3'].map(up_dict['Projection_map']),
-                                            CleanPortfolio['TE'].map(up_dict['Projection_map']),
-                                            CleanPortfolio['FLEX'].map(up_dict['Projection_map']),
+                                            CleanPortfolio['FLEX1'].map(up_dict['Projection_map']),
+                                            CleanPortfolio['FLEX2'].map(up_dict['Projection_map']),
                                             CleanPortfolio['DST'].map(up_dict['Projection_map'])
                                             ]).astype(np.float16)
     if insert_port == 1:
         CleanPortfolio['Own'] = sum([CleanPortfolio['QB'].map(maps_dict['Own_map']),
                                     CleanPortfolio['RB1'].map(maps_dict['Own_map']),
-                                    CleanPortfolio['RB2'].map(maps_dict['Own_map']),
                                     CleanPortfolio['WR1'].map(maps_dict['Own_map']),
                                     CleanPortfolio['WR2'].map(maps_dict['Own_map']),
-                                    CleanPortfolio['WR3'].map(maps_dict['Own_map']),
-                                    CleanPortfolio['TE'].map(maps_dict['Own_map']),
-                                    CleanPortfolio['FLEX'].map(maps_dict['Own_map']),
+                                    CleanPortfolio['FLEX1'].map(maps_dict['Own_map']),
+                                    CleanPortfolio['FLEX2'].map(maps_dict['Own_map']),
                                     CleanPortfolio['DST'].map(maps_dict['Own_map'])
                                     ]).astype(np.float16)
     
     if site_var1 == 'Draftkings':
         RandomPortfolioDF = RandomPortfolioDF[RandomPortfolioDF['Salary'] <= 50000].reset_index(drop=True)
         RandomPortfolioDF = RandomPortfolioDF[RandomPortfolioDF['Salary'] >= (49500 - (5000 * (1 - (len(Teams_used) / 32)))) - (FieldStrength * 1000)].reset_index(drop=True)
-    elif site_var1 == 'Fanduel':
-        RandomPortfolioDF = RandomPortfolioDF[RandomPortfolioDF['Salary'] <= 60000].reset_index(drop=True)
-        RandomPortfolioDF = RandomPortfolioDF[RandomPortfolioDF['Salary'] >= (59500 - (5000 * (1 - (len(Teams_used) / 32)))) - (FieldStrength * 1000)].reset_index(drop=True)
     
     RandomPortfolio = RandomPortfolioDF.sort_values(by=Sim_function, ascending=False)
     
-    RandomPortfolio = RandomPortfolio[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'User/Field', 'Salary', 'Projection', 'Own']]
+    RandomPortfolio = RandomPortfolio[['QB', 'RB1', 'WR1', 'WR2', 'FLEX1', 'FLEX2', 'DST', 'User/Field', 'Salary', 'Projection', 'Own']]
     
     return RandomPortfolio, maps_dict
           
@@ -405,120 +306,95 @@ def get_uncorrelated_portfolio_for_sim(Total_Sample_Size):
           
     RandomPortfolio['QB'] = pd.Series(list(RandomPortfolio['QB'].map(qb_dict)), dtype="string[pyarrow]")
     RandomPortfolio['RB1'] = pd.Series(list(RandomPortfolio['RB1'].map(full_pos_player_dict['pos_dicts'][0])), dtype="string[pyarrow]")
-    RandomPortfolio['RB2'] = pd.Series(list(RandomPortfolio['RB2'].map(full_pos_player_dict['pos_dicts'][0])), dtype="string[pyarrow]")
     RandomPortfolio['WR1'] = pd.Series(list(RandomPortfolio['WR1'].map(full_pos_player_dict['pos_dicts'][1])), dtype="string[pyarrow]")
     RandomPortfolio['WR2'] = pd.Series(list(RandomPortfolio['WR2'].map(full_pos_player_dict['pos_dicts'][1])), dtype="string[pyarrow]")
-    RandomPortfolio['WR3'] = pd.Series(list(RandomPortfolio['WR3'].map(full_pos_player_dict['pos_dicts'][1])), dtype="string[pyarrow]")
-    RandomPortfolio['TE'] = pd.Series(list(RandomPortfolio['TE'].map(full_pos_player_dict['pos_dicts'][2])), dtype="string[pyarrow]")
-    RandomPortfolio['FLEX'] = pd.Series(list(RandomPortfolio['FLEX'].map(full_pos_player_dict['pos_dicts'][3])), dtype="string[pyarrow]")
+    RandomPortfolio['FLEX1'] = pd.Series(list(RandomPortfolio['FLEX1'].map(full_pos_player_dict['pos_dicts'][2])), dtype="string[pyarrow]")
+    RandomPortfolio['FLEX2'] = pd.Series(list(RandomPortfolio['FLEX2'].map(full_pos_player_dict['pos_dicts'][2])), dtype="string[pyarrow]")
     RandomPortfolio['DST'] = pd.Series(list(RandomPortfolio['DST'].map(def_dict)), dtype="string[pyarrow]")
     RandomPortfolio['plyr_list'] = RandomPortfolio[RandomPortfolio.columns.values.tolist()].values.tolist()
     RandomPortfolio['plyr_count'] = RandomPortfolio['plyr_list'].apply(lambda x: len(set(x)))
-    RandomPortfolio = RandomPortfolio[RandomPortfolio['plyr_count'] == 10].drop(columns=['plyr_list','plyr_count']).\
+    RandomPortfolio = RandomPortfolio[RandomPortfolio['plyr_count'] == 8].drop(columns=['plyr_list','plyr_count']).\
         reset_index(drop=True)
     
     del sizesplit
     del full_pos_player_dict
-    del ranges_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)
     RandomPortfolio['WR1s'] = RandomPortfolio['WR1'].map(maps_dict['Salary_map']).astype(np.int32)
     RandomPortfolio['WR2s'] = RandomPortfolio['WR2'].map(maps_dict['Salary_map']).astype(np.int32)
-    RandomPortfolio['WR3s'] = RandomPortfolio['WR3'].map(maps_dict['Salary_map']).astype(np.int32)
-    RandomPortfolio['TEs'] = RandomPortfolio['TE'].map(maps_dict['Salary_map']).astype(np.int32)
-    RandomPortfolio['FLEXs'] = RandomPortfolio['FLEX'].map(maps_dict['Salary_map']).astype(np.int32)
+    RandomPortfolio['FLEX1s'] = RandomPortfolio['FLEX1'].map(maps_dict['Salary_map']).astype(np.int32)
+    RandomPortfolio['FLEX2s'] = RandomPortfolio['FLEX2'].map(maps_dict['Salary_map']).astype(np.int32)
     RandomPortfolio['DSTs'] = RandomPortfolio['DST'].map(maps_dict['Salary_map']).astype(np.int32)
     
     RandomPortfolio['QBp'] = RandomPortfolio['QB'].map(maps_dict['Projection_map']).astype(np.float16)
     RandomPortfolio['RB1p'] = RandomPortfolio['RB1'].map(maps_dict['Projection_map']).astype(np.float16)
-    RandomPortfolio['RB2p'] = RandomPortfolio['RB2'].map(maps_dict['Projection_map']).astype(np.float16)
     RandomPortfolio['WR1p'] = RandomPortfolio['WR1'].map(maps_dict['Projection_map']).astype(np.float16)
     RandomPortfolio['WR2p'] = RandomPortfolio['WR2'].map(maps_dict['Projection_map']).astype(np.float16)
-    RandomPortfolio['WR3p'] = RandomPortfolio['WR3'].map(maps_dict['Projection_map']).astype(np.float16)
-    RandomPortfolio['TEp'] = RandomPortfolio['TE'].map(maps_dict['Projection_map']).astype(np.float16)
-    RandomPortfolio['FLEXp'] = RandomPortfolio['FLEX'].map(maps_dict['Projection_map']).astype(np.float16)
+    RandomPortfolio['FLEX1p'] = RandomPortfolio['FLEX1'].map(maps_dict['Projection_map']).astype(np.float16)
+    RandomPortfolio['FLEX2p'] = RandomPortfolio['FLEX2'].map(maps_dict['Projection_map']).astype(np.float16)
     RandomPortfolio['DSTp'] = RandomPortfolio['DST'].map(maps_dict['Projection_map']).astype(np.float16)
     
     RandomPortfolio['QBo'] = RandomPortfolio['QB'].map(maps_dict['Own_map']).astype(np.float16)
     RandomPortfolio['RB1o'] = RandomPortfolio['RB1'].map(maps_dict['Own_map']).astype(np.float16)
-    RandomPortfolio['RB2o'] = RandomPortfolio['RB2'].map(maps_dict['Own_map']).astype(np.float16)
     RandomPortfolio['WR1o'] = RandomPortfolio['WR1'].map(maps_dict['Own_map']).astype(np.float16)
     RandomPortfolio['WR2o'] = RandomPortfolio['WR2'].map(maps_dict['Own_map']).astype(np.float16)
-    RandomPortfolio['WR3o'] = RandomPortfolio['WR3'].map(maps_dict['Own_map']).astype(np.float16)
-    RandomPortfolio['TEo'] = RandomPortfolio['TE'].map(maps_dict['Own_map']).astype(np.float16)
-    RandomPortfolio['FLEXo'] = RandomPortfolio['FLEX'].map(maps_dict['Own_map']).astype(np.float16)
+    RandomPortfolio['FLEX1o'] = RandomPortfolio['FLEX1'].map(maps_dict['Own_map']).astype(np.float16)
+    RandomPortfolio['FLEX2o'] = RandomPortfolio['FLEX2'].map(maps_dict['Own_map']).astype(np.float16)
     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))]
-    RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,28:37].astype(np.double))]
+    RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,8:17].astype(int))]
+    RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,17:26].astype(np.double))]
+    RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,26:35].astype(np.double))]
     
-    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'])
+    RandomPortArrayOut = np.delete(RandomPortArray, np.s_[8:35], axis=1)
+    RandomPortfolioDF = pd.DataFrame(RandomPortArrayOut, columns = ['QB', 'RB1', 'WR1', 'WR2', 'FLEX1', 'FLEX2', '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']),
                                         CleanPortfolio['RB1'].map(maps_dict['Salary_map']),
-                                        CleanPortfolio['RB2'].map(maps_dict['Salary_map']),
                                         CleanPortfolio['WR1'].map(maps_dict['Salary_map']),
                                         CleanPortfolio['WR2'].map(maps_dict['Salary_map']),
-                                        CleanPortfolio['WR3'].map(maps_dict['Salary_map']),
-                                        CleanPortfolio['TE'].map(maps_dict['Salary_map']),
-                                        CleanPortfolio['FLEX'].map(maps_dict['Salary_map']),
+                                        CleanPortfolio['FLEX1'].map(maps_dict['Salary_map']),
+                                        CleanPortfolio['FLEX2'].map(maps_dict['Salary_map']),
                                         CleanPortfolio['DST'].map(maps_dict['Salary_map'])
                                         ]).astype(np.int16)
     if insert_port == 1:
         CleanPortfolio['Projection'] = sum([CleanPortfolio['QB'].map(up_dict['Projection_map']),
                                             CleanPortfolio['RB1'].map(up_dict['Projection_map']),
-                                            CleanPortfolio['RB2'].map(up_dict['Projection_map']),
                                             CleanPortfolio['WR1'].map(up_dict['Projection_map']),
                                             CleanPortfolio['WR2'].map(up_dict['Projection_map']),
-                                            CleanPortfolio['WR3'].map(up_dict['Projection_map']),
-                                            CleanPortfolio['TE'].map(up_dict['Projection_map']),
-                                            CleanPortfolio['FLEX'].map(up_dict['Projection_map']),
+                                            CleanPortfolio['FLEX1'].map(up_dict['Projection_map']),
+                                            CleanPortfolio['FLEX2'].map(up_dict['Projection_map']),
                                             CleanPortfolio['DST'].map(up_dict['Projection_map'])
                                             ]).astype(np.float16)
     if insert_port == 1:
         CleanPortfolio['Own'] = sum([CleanPortfolio['QB'].map(maps_dict['Own_map']),
                                     CleanPortfolio['RB1'].map(maps_dict['Own_map']),
-                                    CleanPortfolio['RB2'].map(maps_dict['Own_map']),
                                     CleanPortfolio['WR1'].map(maps_dict['Own_map']),
                                     CleanPortfolio['WR2'].map(maps_dict['Own_map']),
-                                    CleanPortfolio['WR3'].map(maps_dict['Own_map']),
-                                    CleanPortfolio['TE'].map(maps_dict['Own_map']),
-                                    CleanPortfolio['FLEX'].map(maps_dict['Own_map']),
+                                    CleanPortfolio['FLEX1'].map(maps_dict['Own_map']),
+                                    CleanPortfolio['FLEX2'].map(maps_dict['Own_map']),
                                     CleanPortfolio['DST'].map(maps_dict['Own_map'])
                                     ]).astype(np.float16)
     
     if site_var1 == 'Draftkings':
         RandomPortfolioDF = RandomPortfolioDF[RandomPortfolioDF['Salary'] <= 50000].reset_index(drop=True)
         RandomPortfolioDF = RandomPortfolioDF[RandomPortfolioDF['Salary'] >= (49500 - (5000 * (1 - (len(Teams_used) / 32)))) - (FieldStrength * 1000)].reset_index(drop=True)
-    elif site_var1 == 'Fanduel':
-        RandomPortfolioDF = RandomPortfolioDF[RandomPortfolioDF['Salary'] <= 60000].reset_index(drop=True)
-        RandomPortfolioDF = RandomPortfolioDF[RandomPortfolioDF['Salary'] >= (59500 - (5000 * (1 - (len(Teams_used) / 32)))) - (FieldStrength * 1000)].reset_index(drop=True)
     
     RandomPortfolio = RandomPortfolioDF.sort_values(by=Sim_function, ascending=False)
     
-    RandomPortfolio = RandomPortfolio[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'User/Field', 'Salary', 'Projection', 'Own']]
+    RandomPortfolio = RandomPortfolio[['QB', 'RB1', 'WR1', 'WR2', 'FLEX1', 'FLEX2', 'DST', 'User/Field', 'Salary', 'Projection', 'Own']]
     
     return RandomPortfolio, maps_dict
 
-player_stats = player_stat_table()
-dk_roo_raw = load_dk_player_projections()
-fd_roo_raw = load_fd_player_projections()
-t_stamp = f"Last Update: " + str(dk_roo_raw['timestamp'][0]) + f" CST"
-site_slates = set_slate_teams()
-dkid_dict, fdid_dict = set_export_ids()
-
 static_exposure = pd.DataFrame(columns=['Player', 'count'])
 overall_exposure = pd.DataFrame(columns=['Player', 'count'])
 
@@ -557,7 +433,7 @@ with tab1:
                               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.")
+                    st.info("The Portfolio file must contain only columns in order and explicitly named: 'QB', 'RB1', 'WR1', 'WR2', 'FLEX1', 'FLEX2', and 'DST'. Upload your projections first to avoid an error message.")
                     portfolio_file = st.file_uploader("Upload Portfolio File", key = 'portfolio_uploader')
 
                     if portfolio_file is not None:
@@ -569,201 +445,158 @@ with tab1:
                               
                             try:
                                 try:
-                                    portfolio_dataframe.columns=["QB", "RB1", "RB2", "WR1", "WR2", "WR3", "TE", "FLEX", "DST"]
+                                    portfolio_dataframe.columns=["QB", "RB1", "WR1", "WR2", "FLEX1", "FLEX2", "DST"]
                                     split_portfolio = portfolio_dataframe
                                     split_portfolio[['QB', 'QB_ID']] = split_portfolio.QB.str.split("(", n=1, expand = True)
                                     split_portfolio[['RB1', 'RB1_ID']] = split_portfolio.RB1.str.split("(", n=1, expand = True)
-                                    split_portfolio[['RB2', 'RB2_ID']] = split_portfolio.RB2.str.split("(", n=1, expand = True)
                                     split_portfolio[['WR1', 'WR1_ID']] = split_portfolio.WR1.str.split("(", n=1, expand = True)
                                     split_portfolio[['WR2', 'WR2_ID']] = split_portfolio.WR2.str.split("(", n=1, expand = True)
-                                    split_portfolio[['WR3', 'WR3_ID']] = split_portfolio.WR3.str.split("(", n=1, expand = True)
-                                    split_portfolio[['TE', 'TE_ID']] = split_portfolio.TE.str.split("(", n=1, expand = True)
-                                    split_portfolio[['FLEX', 'FLEX_ID']] = split_portfolio.FLEX.str.split("(", n=1, expand = True)
+                                    split_portfolio[['FLEX1', 'FLEX1_ID']] = split_portfolio.FLEX1.str.split("(", n=1, expand = True)
+                                    split_portfolio[['FLEX2', 'FLEX2_ID']] = split_portfolio.FLEX2.str.split("(", n=1, expand = True)
                                     split_portfolio[['DST', 'DST_ID']] = split_portfolio.DST.str.split("(", n=1, expand = True)
       
                                     split_portfolio['QB'] = split_portfolio['QB'].str.strip()
                                     split_portfolio['RB1'] = split_portfolio['RB1'].str.strip()
-                                    split_portfolio['RB2'] = split_portfolio['RB2'].str.strip()
                                     split_portfolio['WR1'] = split_portfolio['WR1'].str.strip()
                                     split_portfolio['WR2'] = split_portfolio['WR2'].str.strip()
-                                    split_portfolio['WR3'] = split_portfolio['WR3'].str.strip()
-                                    split_portfolio['TE'] = split_portfolio['TE'].str.strip()
-                                    split_portfolio['FLEX'] = split_portfolio['FLEX'].str.strip()
+                                    split_portfolio['FLEX1'] = split_portfolio['FLEX1'].str.strip()
+                                    split_portfolio['FLEX2'] = split_portfolio['FLEX2'].str.strip()
                                     split_portfolio['DST'] = split_portfolio['DST'].str.strip()
                                     
                                     st.table(split_portfolio.head(10))
       
                                     split_portfolio['Salary'] = sum([split_portfolio['QB'].map(player_salary_dict),
                                               split_portfolio['RB1'].map(player_salary_dict),
-                                              split_portfolio['RB2'].map(player_salary_dict),
                                               split_portfolio['WR1'].map(player_salary_dict),
                                               split_portfolio['WR2'].map(player_salary_dict),
-                                              split_portfolio['WR3'].map(player_salary_dict),
-                                              split_portfolio['TE'].map(player_salary_dict),
-                                              split_portfolio['FLEX'].map(player_salary_dict),
+                                              split_portfolio['FLEX1'].map(player_salary_dict),
+                                              split_portfolio['FLEX2'].map(player_salary_dict),
                                               split_portfolio['DST'].map(player_salary_dict)])
                                     
                                     split_portfolio['Projection'] = sum([split_portfolio['QB'].map(player_proj_dict),
                                               split_portfolio['RB1'].map(player_proj_dict),
-                                              split_portfolio['RB2'].map(player_proj_dict),
                                               split_portfolio['WR1'].map(player_proj_dict),
                                               split_portfolio['WR2'].map(player_proj_dict),
-                                              split_portfolio['WR3'].map(player_proj_dict),
-                                              split_portfolio['TE'].map(player_proj_dict),
-                                              split_portfolio['FLEX'].map(player_proj_dict),
+                                              split_portfolio['FLEX1'].map(player_proj_dict),
+                                              split_portfolio['FLEX2'].map(player_proj_dict),
                                               split_portfolio['DST'].map(player_proj_dict)])
                                     
                                     split_portfolio['Ownership'] = sum([split_portfolio['QB'].map(player_own_dict),
                                               split_portfolio['RB1'].map(player_own_dict),
-                                              split_portfolio['RB2'].map(player_own_dict),
                                               split_portfolio['WR1'].map(player_own_dict),
                                               split_portfolio['WR2'].map(player_own_dict),
-                                              split_portfolio['WR3'].map(player_own_dict),
-                                              split_portfolio['TE'].map(player_own_dict),
-                                              split_portfolio['FLEX'].map(player_own_dict),
+                                              split_portfolio['FLEX1'].map(player_own_dict),
+                                              split_portfolio['FLEX2'].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['FLEX1_team'] = split_portfolio['FLEX1'].map(player_team_dict)
+                                    split_portfolio['FLEX2_team'] = split_portfolio['FLEX2'].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
+                                    split_portfolio = split_portfolio[['QB', 'RB1', 'WR1', 'WR2', 'FLEX1', 'FLEX2', 'DST', 'Salary', 'Projection', 'Ownership', 'QB_team',
+                                                                        'RB1_team', 'WR1_team', 'WR2_team', 'FLEX1_team', 'FLEX2_team', 'DST_team']]
                                 
                                 
                                 except:
-                                    portfolio_dataframe.columns=["QB", "RB1", "RB2", "WR1", "WR2", "WR3", "TE", "FLEX", "DST"]
+                                    portfolio_dataframe.columns=["QB", "RB1", "WR1", "WR2", "FLEX1", "FLEX2", "DST"]
                                     
                                     split_portfolio = portfolio_dataframe
                                     split_portfolio[['QB_ID', 'QB']] = split_portfolio.QB.str.split(":", n=1, expand = True)
                                     split_portfolio[['RB1_ID', 'RB1']] = split_portfolio.RB1.str.split(":", n=1, expand = True)
-                                    split_portfolio[['RB2_ID', 'RB2']] = split_portfolio.RB2.str.split(":", n=1, expand = True)
                                     split_portfolio[['WR1_ID', 'WR1']] = split_portfolio.WR1.str.split(":", n=1, expand = True)
                                     split_portfolio[['WR2_ID', 'WR2']] = split_portfolio.WR2.str.split(":", n=1, expand = True)
-                                    split_portfolio[['WR3_ID', 'WR3']] = split_portfolio.WR3.str.split(":", n=1, expand = True)
-                                    split_portfolio[['TE_ID', 'TE']] = split_portfolio.TE.str.split(":", n=1, expand = True)
-                                    split_portfolio[['FLEX_ID', 'FLEX']] = split_portfolio.FLEX.str.split(":", n=1, expand = True)
+                                    split_portfolio[['FLEX1_ID', 'TE']] = split_portfolio.FLEX1.str.split(":", n=1, expand = True)
+                                    split_portfolio[['FLEX2_ID', 'FLEX']] = split_portfolio.FLEX2.str.split(":", n=1, expand = True)
                                     split_portfolio[['DST_ID', 'DST']] = split_portfolio.DST.str.split(":", n=1, expand = True)
                                     
                                     split_portfolio['QB'] = split_portfolio['QB'].str.strip()
                                     split_portfolio['RB1'] = split_portfolio['RB1'].str.strip()
-                                    split_portfolio['RB2'] = split_portfolio['RB2'].str.strip()
                                     split_portfolio['WR1'] = split_portfolio['WR1'].str.strip()
                                     split_portfolio['WR2'] = split_portfolio['WR2'].str.strip()
-                                    split_portfolio['WR3'] = split_portfolio['WR3'].str.strip()
-                                    split_portfolio['TE'] = split_portfolio['TE'].str.strip()
-                                    split_portfolio['FLEX'] = split_portfolio['FLEX'].str.strip()
+                                    split_portfolio['FLEX1'] = split_portfolio['FLEX1'].str.strip()
+                                    split_portfolio['FLEX2'] = split_portfolio['FLEX2'].str.strip()
                                     split_portfolio['DST'] = split_portfolio['DST'].str.strip()
       
                                     split_portfolio['Salary'] = sum([split_portfolio['QB'].map(player_salary_dict),
                                               split_portfolio['RB1'].map(player_salary_dict),
-                                              split_portfolio['RB2'].map(player_salary_dict),
                                               split_portfolio['WR1'].map(player_salary_dict),
                                               split_portfolio['WR2'].map(player_salary_dict),
-                                              split_portfolio['WR3'].map(player_salary_dict),
-                                              split_portfolio['TE'].map(player_salary_dict),
-                                              split_portfolio['FLEX'].map(player_salary_dict),
+                                              split_portfolio['FLEX1'].map(player_salary_dict),
+                                              split_portfolio['FLEX2'].map(player_salary_dict),
                                               split_portfolio['DST'].map(player_salary_dict)])
                                     
                                     split_portfolio['Projection'] = sum([split_portfolio['QB'].map(player_proj_dict),
                                               split_portfolio['RB1'].map(player_proj_dict),
-                                              split_portfolio['RB2'].map(player_proj_dict),
                                               split_portfolio['WR1'].map(player_proj_dict),
                                               split_portfolio['WR2'].map(player_proj_dict),
-                                              split_portfolio['WR3'].map(player_proj_dict),
-                                              split_portfolio['TE'].map(player_proj_dict),
-                                              split_portfolio['FLEX'].map(player_proj_dict),
+                                              split_portfolio['FLEX1'].map(player_proj_dict),
+                                              split_portfolio['FLEX2'].map(player_proj_dict),
                                               split_portfolio['DST'].map(player_proj_dict)])
                                                                     
                                     st.table(split_portfolio.head(10))
                                     split_portfolio['Ownership'] = sum([split_portfolio['QB'].map(player_own_dict),
                                               split_portfolio['RB1'].map(player_own_dict),
-                                              split_portfolio['RB2'].map(player_own_dict),
                                               split_portfolio['WR1'].map(player_own_dict),
                                               split_portfolio['WR2'].map(player_own_dict),
-                                              split_portfolio['WR3'].map(player_own_dict),
-                                              split_portfolio['TE'].map(player_own_dict),
-                                              split_portfolio['FLEX'].map(player_own_dict),
+                                              split_portfolio['FLEX1'].map(player_own_dict),
+                                              split_portfolio['FLEX2'].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['FLEX1_team'] = split_portfolio['FLEX1'].map(player_team_dict)
+                                    split_portfolio['FLEX2_team'] = split_portfolio['FLEX2'].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
+                                    split_portfolio = split_portfolio[['QB', 'RB1', 'WR1', 'WR2', 'FLEX1', 'FLEX2', 'DST', 'Salary', 'Projection', 'Ownership', 'QB_team',
+                                                                        'RB1_team', 'WR1_team', 'WR2_team', 'FLEX1_team', 'FLEX2_team', 'DST_team']]
                                   
                             except:
                                  split_portfolio = portfolio_dataframe
                                 
                                  split_portfolio['Salary'] = sum([split_portfolio['QB'].map(player_salary_dict),
                                            split_portfolio['RB1'].map(player_salary_dict),
-                                           split_portfolio['RB2'].map(player_salary_dict),
                                            split_portfolio['WR1'].map(player_salary_dict),
                                            split_portfolio['WR2'].map(player_salary_dict),
-                                           split_portfolio['WR3'].map(player_salary_dict),
-                                           split_portfolio['TE'].map(player_salary_dict),
-                                           split_portfolio['FLEX'].map(player_salary_dict),
+                                           split_portfolio['FLEX1'].map(player_salary_dict),
+                                           split_portfolio['FLEX2'].map(player_salary_dict),
                                            split_portfolio['DST'].map(player_salary_dict)])
                                 
                                  split_portfolio['Projection'] = sum([split_portfolio['QB'].map(player_proj_dict),
                                            split_portfolio['RB1'].map(player_proj_dict),
-                                           split_portfolio['RB2'].map(player_proj_dict),
                                            split_portfolio['WR1'].map(player_proj_dict),
                                            split_portfolio['WR2'].map(player_proj_dict),
-                                           split_portfolio['WR3'].map(player_proj_dict),
-                                           split_portfolio['TE'].map(player_proj_dict),
-                                           split_portfolio['FLEX'].map(player_proj_dict),
+                                           split_portfolio['FLEX1'].map(player_proj_dict),
+                                           split_portfolio['FLEX2'].map(player_proj_dict),
                                            split_portfolio['DST'].map(player_proj_dict)])
                                 
                                  split_portfolio['Ownership'] = sum([split_portfolio['QB'].map(player_own_dict),
                                            split_portfolio['RB1'].map(player_own_dict),
-                                           split_portfolio['RB2'].map(player_own_dict),
                                            split_portfolio['WR1'].map(player_own_dict),
                                            split_portfolio['WR2'].map(player_own_dict),
-                                           split_portfolio['WR3'].map(player_own_dict),
-                                           split_portfolio['TE'].map(player_own_dict),
-                                           split_portfolio['FLEX'].map(player_own_dict),
+                                           split_portfolio['FLEX1'].map(player_own_dict),
+                                           split_portfolio['FLEX2'].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['FLEX1_team'] = split_portfolio['FLEX1'].map(player_team_dict)
+                            split_portfolio['FLEX2_team'] = split_portfolio['FLEX2'].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
+                            split_portfolio = split_portfolio[['QB', 'RB1', 'WR1', 'WR2', 'FLEX1', 'FLEX2', 'DST', 'Salary', 'Projection', 'Ownership', 'QB_team',
+                                                                'RB1_team', 'WR1_team', 'WR2_team', 'FLEX1_team', 'FLEX2_team', 'DST_team']]
                               
-                            for player_cols in split_portfolio.iloc[:, :9]:
+                            for player_cols in split_portfolio.iloc[:, :7]:
                                       static_col_raw = split_portfolio[player_cols].value_counts()
                                       static_col = static_col_raw.to_frame()
                                       static_col.reset_index(inplace=True)
@@ -782,26 +615,9 @@ with tab1:
           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
+                    split_portfolio = split_portfolio
 
-                    for player_cols in split_portfolio.iloc[:, :9]:
+                    for player_cols in split_portfolio.iloc[:, :7]:
                               exposure_col_raw = split_portfolio[player_cols].value_counts()
                               exposure_col = exposure_col_raw.to_frame()
                               exposure_col.reset_index(inplace=True)
@@ -828,7 +644,7 @@ with tab1:
                               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 = split_portfolio[['Lineup', 'QB', 'RB1', 'WR1', 'WR2', 'FLEX1', 'FLEX2', 'DST', 'Salary', '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
@@ -837,29 +653,10 @@ with tab1:
 with tab2:
     col1, col2 = st.columns([1, 7])
     with col1:
-        st.info(t_stamp)
-        if st.button("Load/Reset Data", key='reset1'):
-              st.cache_data.clear()
-              dk_roo_raw = load_dk_player_projections()
-              fd_roo_raw = load_fd_player_projections()
-              t_stamp = f"Last Update: " + str(dk_roo_raw['timestamp'][0]) + f" CST"
-              site_slates = set_slate_teams()
-              dkid_dict, fdid_dict = set_export_ids()
               
-        slate_var1 = st.radio("Which data are you loading?", ('Main Slate', 'Secondary Slate', 'Thurs-Mon Slate', 'User'))
-        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']]
-              elif slate_var1 != 'User':
-                  raw_baselines = dk_roo_raw[dk_roo_raw['slate'] == str(slate_var1)]
-                  raw_baselines = raw_baselines[raw_baselines['version'] == 'overall']
-        elif site_var1 == 'Fanduel':
-              if slate_var1 == 'User':
-                  raw_baselines = proj_dataframe
-              elif slate_var1 != 'User':
-                  raw_baselines = fd_roo_raw[fd_roo_raw['slate'] == str(slate_var1)]
-                  raw_baselines = raw_baselines[raw_baselines['version'] == 'overall']
+        slate_var1 = 'User'
+        site_var1 = 'Draftkings'
+        raw_baselines = proj_dataframe[['Player', 'Salary', 'Position', 'Team', 'Opp', 'Median', 'Own']]
         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':
@@ -931,45 +728,20 @@ with tab2:
                         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())
+                        OwnFrame['Own'] = OwnFrame['Own%'] * (700 / 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())
+                        OwnFrame['Own'] = OwnFrame['Own%'] * (700 / 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())
+                        OwnFrame['Own'] = OwnFrame['Own%'] * (700 / OwnFrame['Own%'].sum())
                     Overall_Proj = OwnFrame[['Player', 'Team', 'Position', 'Median', 'Own', 'Salary']]
                     
                     del OwnFrame
-                    
-                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 == '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']]
-                    
-                    del initial_proj
-                    del drop_frame
-                    del OwnFrame
                 
                 if insert_port == 1:
                     UserPortfolio = portfolio_dataframe[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']]
@@ -1039,13 +811,8 @@ with tab2:
                 wrs_raw.dropna(subset=['Median']).reset_index(drop=True)
                 wrs_raw = wrs_raw.reset_index(drop=True)
                 wrs_raw = wrs_raw.sort_values(by=['Own', 'Median'], ascending=False)
-                
-                tes_raw = Overall_Proj[Overall_Proj.Position == 'TE']
-                tes_raw.dropna(subset=['Median']).reset_index(drop=True)
-                tes_raw = tes_raw.reset_index(drop=True)
-                tes_raw = tes_raw.sort_values(by=['Own', 'Value'], ascending=False)
         
-                pos_players = pd.concat([rbs_raw, wrs_raw, tes_raw])
+                pos_players = pd.concat([rbs_raw, wrs_raw])
                 pos_players.dropna(subset=['Median']).reset_index(drop=True)
                 pos_players = pos_players.reset_index(drop=True)
                 
@@ -1053,7 +820,6 @@ with tab2:
                 del defs_raw
                 del rbs_raw
                 del wrs_raw
-                del tes_raw
         
                 if insert_port == 1:
                     try:
@@ -1061,7 +827,7 @@ with tab2:
                         Raw_Portfolio = pd.DataFrame()
                         
                         # Loop through each position and split the data accordingly
-                        positions = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
+                        positions = ['QB', 'RB1', 'WR1', 'WR2', 'FLEX1', 'FLEX2', 'DST']
                         for pos in positions:
                             temp_df = UserPortfolio[pos].str.split("(", n=1, expand=True)
                             temp_df.columns = [pos, 'Drop']
@@ -1078,7 +844,7 @@ with tab2:
                         
                         # Create frequency table for players
                         cleaport_players = pd.DataFrame(
-                            np.column_stack(np.unique(CleanPortfolio.iloc[:, 0:9].values, return_counts=True)),
+                            np.column_stack(np.unique(CleanPortfolio.iloc[:, 0:7].values, return_counts=True)),
                             columns=['Player', 'Freq']
                         ).sort_values('Freq', ascending=False).reset_index(drop=True)
                         cleaport_players['Freq'] = cleaport_players['Freq'].astype(int)
@@ -1099,7 +865,7 @@ with tab2:
                         
                         # Create frequency table for players
                         cleaport_players = pd.DataFrame(
-                            np.column_stack(np.unique(CleanPortfolio.iloc[:, 0:9].values, return_counts=True)),
+                            np.column_stack(np.unique(CleanPortfolio.iloc[:, 0:7].values, return_counts=True)),
                             columns=['Player', 'Freq']
                         ).sort_values('Freq', ascending=False).reset_index(drop=True)
                         cleaport_players['Freq'] = cleaport_players['Freq'].astype(int)
@@ -1111,15 +877,15 @@ with tab2:
 
                 elif insert_port == 0:
                     CleanPortfolio = UserPortfolio
-                    cleaport_players = pd.DataFrame(np.column_stack(np.unique(CleanPortfolio.iloc[:,0:9].values, return_counts=True)),
+                    cleaport_players = pd.DataFrame(np.column_stack(np.unique(CleanPortfolio.iloc[:,0:7].values, return_counts=True)),
                                                columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
                     cleaport_players['Freq'] = cleaport_players['Freq'].astype(int)
                     nerf_frame = Overall_Proj
                     
                 ref_dict = {
-                    'pos':['RB', 'WR', 'TE', 'FLEX'],
-                    'pos_dfs':['RB_Table', 'WR_Table', 'TE_Table', 'FLEX_Table'],
-                    'pos_dicts':['rb_dict', 'wr_dict', 'te_dict', 'flex_dict']
+                    'pos':['RB', 'WR', 'FLEX'],
+                    'pos_dfs':['RB_Table', 'WR_Table', 'FLEX_Table'],
+                    'pos_dicts':['rb_dict', 'wr_dict', 'flex_dict']
                     }
         
                 maps_dict = {
@@ -1197,7 +963,7 @@ with tab2:
                     else:
                         sample_arrays = sample_arrays1
             
-                    final_array = sample_arrays[sample_arrays[:, 10].argsort()[::-1]]
+                    final_array = sample_arrays[sample_arrays[:, 8].argsort()[::-1]]
                     best_lineup = final_array[final_array[:, -1].argsort(kind='stable')[::-1][:1]]
                     Sim_Winners.append(best_lineup)
                     SimVar += 1
@@ -1226,16 +992,7 @@ with tab2:
                 # Conditional Replacement
                 columns_to_replace = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
                 
-                if site_var1 == 'Draftkings':
-                    replace_dict = dkid_dict
-                elif site_var1 == 'Fanduel':
-                    replace_dict = fdid_dict
-                
-                for col in columns_to_replace:
-                    Sim_Winner_Export[col].replace(replace_dict, inplace=True)
-
-                
-                player_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,0:9].values, return_counts=True)),
+                player_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,0:7].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'])
@@ -1263,7 +1020,7 @@ with tab2:
 
                 qb_freq = qb_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
 
-                rb_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,[1, 2]].values, return_counts=True)),
+                rb_freq = pd.DataFrame(np.column_stack(np.unique(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'])
@@ -1277,7 +1034,7 @@ with tab2:
 
                 rb_freq = rb_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
                 
-                wr_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,[3, 4, 5]].values, return_counts=True)),
+                wr_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,[2, 3]].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'])
@@ -1291,21 +1048,7 @@ with tab2:
 
                 wr_freq = wr_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
                 
-                te_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,[6]].values, return_counts=True)),
-                                           columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
-                te_freq['Freq'] = te_freq['Freq'].astype(int)
-                te_freq['Position'] = te_freq['Player'].map(maps_dict['Pos_map'])
-                te_freq['Salary'] = te_freq['Player'].map(maps_dict['Salary_map'])
-                te_freq['Proj Own'] = te_freq['Player'].map(maps_dict['Own_map']) / 100
-                te_freq['Exposure'] = te_freq['Freq']/Sim_size
-                te_freq['Edge'] = te_freq['Exposure'] - te_freq['Proj Own']
-                te_freq['Team'] = te_freq['Player'].map(maps_dict['Team_map'])
-                for checkVar in range(len(team_list)):
-                                    te_freq['Team'] = te_freq['Team'].replace(item_list, team_list)
-
-                te_freq = te_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
-                
-                flex_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,[7]].values, return_counts=True)),
+                flex_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,[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'])
@@ -1319,7 +1062,7 @@ with tab2:
 
                 flex_freq = flex_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
                 
-                dst_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,8:9].values, return_counts=True)),
+                dst_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,5:6].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'])
@@ -1346,7 +1089,7 @@ with tab2:
             
             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'])
+                tab1, tab2, tab3, tab4, tab5, tab6 = st.tabs(['Overall Exposures', 'QB Exposures', 'RB Exposures', 'WR Exposures', 'FLEX Exposures', 'DST Exposures'])
                 with tab1:
                     st.dataframe(player_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
                     st.download_button(
@@ -1380,14 +1123,6 @@ with tab2:
                         mime='text/csv',
                     )
                 with tab5:
-                    st.dataframe(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(te_freq),
-                        file_name='te_freq_export.csv',
-                        mime='text/csv',
-                    )
-                with tab6:
                     st.dataframe(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",
@@ -1395,7 +1130,7 @@ with tab2:
                         file_name='flex_freq_export.csv',
                         mime='text/csv',
                     )
-                with tab7:
+                with tab6:
                     st.dataframe(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",