Update app.py

app.py

@@ -40,68 +40,48 @@ def init_conn():
         client = pymongo.MongoClient(uri, retryWrites=True, serverSelectionTimeoutMS=500000)
         db = client["testing_db"]
      
-        NFL_Data = st.secrets['NFL_Data']
+        LOL_Data = st.secrets['LOL_Data']
 
         gc = gspread.service_account_from_dict(credentials)
         gc2 = gspread.service_account_from_dict(credentials2)
 
-        return gc, gc2, db, NFL_Data
+        return gc, gc2, db, LOL_Data
     
-gcservice_account, gcservice_account2, db, NFL_Data = init_conn()
+gcservice_account, gcservice_account2, db, LOL_Data = init_conn()
 
 percentages_format = {'Exposure': '{:.2%}'}
 freq_format = {'Exposure': '{:.2%}', 'Proj Own': '{:.2%}', 'Edge': '{:.2%}'}
-dk_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']
-fd_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']
+dk_columns = ['CPT', 'TOP', 'JNG', 'MID', 'ADC', 'SUP', 'TEAM', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']
+fd_columns = ['CPT', 'TOP', 'JNG', 'MID', 'ADC', 'SUP', 'TEAM', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']
 
 @st.cache_data(ttl = 599)
 def init_DK_seed_frames():  
     
-        collection = db["DK_NFL_seed_frame"] 
+        collection = db["League_of_Legends_DK_seed_frame"] 
         cursor = collection.find()
     
         raw_display = pd.DataFrame(list(cursor))
-        raw_display = raw_display[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
+        raw_display = raw_display[['CPT', 'TOP', 'JNG', 'MID', 'ADC', 'SUP', 'TEAM', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
         DK_seed = raw_display.to_numpy()
 
         return DK_seed
 
-@st.cache_data(ttl = 599)
-def init_FD_seed_frames():  
-    
-        collection = db["FD_NFL_seed_frame"] 
-        cursor = collection.find()
-    
-        raw_display = pd.DataFrame(list(cursor))
-        raw_display = raw_display[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
-        FD_seed = raw_display.to_numpy()
-
-        return FD_seed
-
 @st.cache_data(ttl = 599)
 def init_baselines():
     try:
-        sh = gcservice_account.open_by_url(NFL_Data)
+        sh = gcservice_account.open_by_url(LOL_Data)
     except:
-        sh = gcservice_account2.open_by_url(NFL_Data)
+        sh = gcservice_account2.open_by_url(LOL_Data)
     
-    worksheet = sh.worksheet('DK_ROO')
+    worksheet = sh.worksheet('ROO')
     load_display = pd.DataFrame(worksheet.get_all_records())
     load_display.replace('', np.nan, inplace=True)
     load_display['STDev'] = load_display['Median'] / 4
     load_display = load_display.drop_duplicates(subset=['Player'], keep='first')
     
     dk_raw = load_display.dropna(subset=['Median'])
-    
-    worksheet = sh.worksheet('FD_ROO')
-    load_display = pd.DataFrame(worksheet.get_all_records())
-    load_display.replace('', np.nan, inplace=True)
-    load_display['STDev'] = load_display['Median'] / 4
-    load_display = load_display.drop_duplicates(subset=['Player'], keep='first')
-    
-    fd_raw = load_display.dropna(subset=['Median'])
 
-    return dk_raw, fd_raw
+    return dk_raw
 
 @st.cache_data
 def convert_df(array):
@@ -110,14 +90,14 @@ def convert_df(array):
 
 @st.cache_data
 def calculate_DK_value_frequencies(np_array):
-    unique, counts = np.unique(np_array[:, :9], return_counts=True)
+    unique, counts = np.unique(np_array[:, :6], return_counts=True)
     frequencies = counts / len(np_array)  # Normalize by the number of rows 
     combined_array = np.column_stack((unique, frequencies))  
     return combined_array 
 
 @st.cache_data
 def calculate_FD_value_frequencies(np_array):
-    unique, counts = np.unique(np_array[:, :9], return_counts=True)
+    unique, counts = np.unique(np_array[:, :6], return_counts=True)
     frequencies = counts / len(np_array)  # Normalize by the number of rows 
     combined_array = np.column_stack((unique, frequencies))  
     return combined_array
@@ -147,7 +127,7 @@ def sim_contest(Sim_size, seed_frame, maps_dict, sharp_split, Contest_Size):
 
         sample_arrays = sample_arrays1
 
-        final_array = sample_arrays[sample_arrays[:, 10].argsort()[::-1]]
+        final_array = sample_arrays[sample_arrays[:, 7].argsort()[::-1]]
         best_lineup = final_array[final_array[:, -1].argsort(kind='stable')[::-1][:1]]
         Sim_Winners.append(best_lineup)
         SimVar += 1
@@ -155,8 +135,7 @@ def sim_contest(Sim_size, seed_frame, maps_dict, sharp_split, Contest_Size):
     return Sim_Winners
 
 DK_seed = init_DK_seed_frames()
-FD_seed = init_FD_seed_frames()
-dk_raw, fd_raw = init_baselines()
+dk_raw = init_baselines()
 
 tab1, tab2 = st.tabs(['Contest Sims', 'Data Export'])
 with tab2:
@@ -167,11 +146,10 @@ with tab2:
               for key in st.session_state.keys():
                   del st.session_state[key]
               DK_seed = init_DK_seed_frames()
-              FD_seed = init_FD_seed_frames()
-              dk_raw, fd_raw = init_baselines()
+              dk_raw = init_baselines()
               
         slate_var1 = st.radio("Which data are you loading?", ('Main Slate', 'Other Main Slate'))
-        site_var1 = st.radio("What site are you working with?", ('Draftkings', 'Fanduel'))
+        site_var1 = st.radio("What site are you working with?", ('Draftkings'))
         if site_var1 == 'Draftkings':
             raw_baselines = dk_raw
             column_names = dk_columns
@@ -184,33 +162,16 @@ with tab2:
             
             stack_var1 = st.radio("Do you want a frame with specific stack sizes?", ('Full Slate', 'Specific Stack Sizes'), key='stack_var1')
             if stack_var1 == 'Specific Stack Sizes':
-                    stack_var2 = st.multiselect('Which stack sizes do you want?', options = [5, 4, 3, 2, 1, 0])
+                    stack_var2 = st.multiselect('Which stack sizes do you want?', options = [4, 3, 2, 1, 0])
             elif stack_var1 == 'Full Slate':
-                    stack_var2 = [5, 4, 3, 2, 1, 0]
-                    
-        elif site_var1 == 'Fanduel':
-            raw_baselines = fd_raw
-            column_names = fd_columns
-            
-            team_var1 = st.radio("Do you want a frame with specific teams?", ('Full Slate', 'Specific Teams'), key='team_var1')
-            if team_var1 == 'Specific Teams':
-                    team_var2 = st.multiselect('Which teams do you want?', options = fd_raw['Team'].unique())
-            elif team_var1 == 'Full Slate':
-                    team_var2 = fd_raw.Team.values.tolist()
-            
-            stack_var1 = st.radio("Do you want a frame with specific stack sizes?", ('Full Slate', 'Specific Stack Sizes'), key='stack_var1')
-            if stack_var1 == 'Specific Stack Sizes':
-                    stack_var2 = st.multiselect('Which stack sizes do you want?', options = [5, 4, 3, 2, 1, 0])
-            elif stack_var1 == 'Full Slate':
-                    stack_var2 = [5, 4, 3, 2, 1, 0]
+                    stack_var2 = [4, 3, 2, 1, 0]
         
-
         if st.button("Prepare data export", key='data_export'):
                 data_export = st.session_state.working_seed.copy()
                 st.download_button(
                     label="Export optimals set",
                     data=convert_df(data_export),
-                    file_name='NFL_optimals_export.csv',
+                    file_name='LOL_optimals_export.csv',
                     mime='text/csv',
                 )
             
@@ -218,24 +179,13 @@ with tab2:
         if st.button("Load Data", key='load_data'):
             if site_var1 == 'Draftkings':
                 if 'working_seed' in st.session_state:
-                    st.session_state.working_seed = st.session_state.working_seed[np.isin(st.session_state.working_seed[:, 11], team_var2)]
-                    st.session_state.working_seed = st.session_state.working_seed[np.isin(st.session_state.working_seed[:, 12], stack_var2)]
+                    st.session_state.working_seed = st.session_state.working_seed[np.isin(st.session_state.working_seed[:, 8], team_var2)]
+                    st.session_state.working_seed = st.session_state.working_seed[np.isin(st.session_state.working_seed[:, 9], stack_var2)]
                     st.session_state.data_export_display = pd.DataFrame(st.session_state.working_seed[0:1000], columns=column_names)
                 elif 'working_seed' not in st.session_state:
                     st.session_state.working_seed = DK_seed.copy()
-                    st.session_state.working_seed = st.session_state.working_seed[np.isin(st.session_state.working_seed[:, 11], team_var2)]
-                    st.session_state.working_seed = st.session_state.working_seed[np.isin(st.session_state.working_seed[:, 12], stack_var2)]
-                    st.session_state.data_export_display = pd.DataFrame(st.session_state.working_seed[0:1000], columns=column_names)
-                
-            elif site_var1 == 'Fanduel':
-                if 'working_seed' in st.session_state:
-                    st.session_state.working_seed = st.session_state.working_seed[np.isin(st.session_state.working_seed[:, 11], team_var2)]
-                    st.session_state.working_seed = st.session_state.working_seed[np.isin(st.session_state.working_seed[:, 12], stack_var2)]
-                    st.session_state.data_export_display = pd.DataFrame(st.session_state.working_seed[0:1000], columns=column_names)
-                elif 'working_seed' not in st.session_state:
-                    st.session_state.working_seed = FD_seed.copy()
-                    st.session_state.working_seed = st.session_state.working_seed[np.isin(st.session_state.working_seed[:, 11], team_var2)]
-                    st.session_state.working_seed = st.session_state.working_seed[np.isin(st.session_state.working_seed[:, 12], stack_var2)]
+                    st.session_state.working_seed = st.session_state.working_seed[np.isin(st.session_state.working_seed[:, 8], team_var2)]
+                    st.session_state.working_seed = st.session_state.working_seed[np.isin(st.session_state.working_seed[:, 9], stack_var2)]
                     st.session_state.data_export_display = pd.DataFrame(st.session_state.working_seed[0:1000], columns=column_names)
                 
         with st.container():
@@ -250,16 +200,12 @@ with tab1:
               for key in st.session_state.keys():
                   del st.session_state[key]
               DK_seed = init_DK_seed_frames()
-              FD_seed = init_FD_seed_frames()
-              dk_raw, fd_raw = init_baselines()
+              dk_raw = init_baselines()
         sim_slate_var1 = st.radio("Which data are you loading?", ('Main Slate', 'Other Main Slate'), key='sim_slate_var1')
-        sim_site_var1 = st.radio("What site are you working with?", ('Draftkings', 'Fanduel'), key='sim_site_var1')
+        sim_site_var1 = st.radio("What site are you working with?", ('Draftkings'), key='sim_site_var1')
         if sim_site_var1 == 'Draftkings':
             raw_baselines = dk_raw
             column_names = dk_columns
-        elif sim_site_var1 == 'Fanduel':
-            raw_baselines = fd_raw
-            column_names = fd_columns
             
         contest_var1 = st.selectbox("What contest size are you simulating?", ('Small', 'Medium', 'Large', 'Custom'))
         if contest_var1 == 'Small':
@@ -296,8 +242,6 @@ with tab1:
                         }
                 Sim_Winners = sim_contest(1000, st.session_state.working_seed, maps_dict, sharp_split, Contest_Size)
                 Sim_Winner_Frame = pd.DataFrame(np.concatenate(Sim_Winners))
-                
-                #st.table(Sim_Winner_Frame)
                             
                 # Initial setup
                 Sim_Winner_Frame = pd.DataFrame(np.concatenate(Sim_Winners), columns=column_names + ['Fantasy'])
@@ -322,8 +266,6 @@ with tab1:
             else:
                 if sim_site_var1 == 'Draftkings':
                     st.session_state.working_seed = DK_seed.copy()
-                elif sim_site_var1 == 'Fanduel':
-                    st.session_state.working_seed = FD_seed.copy()
                 maps_dict = {
                         'Projection_map':dict(zip(raw_baselines.Player,raw_baselines.Median)),
                         'Salary_map':dict(zip(raw_baselines.Player,raw_baselines.Salary)),
@@ -334,8 +276,6 @@ with tab1:
                         }
                 Sim_Winners = sim_contest(1000, st.session_state.working_seed, maps_dict, sharp_split, Contest_Size)
                 Sim_Winner_Frame = pd.DataFrame(np.concatenate(Sim_Winners))
-                
-                #st.table(Sim_Winner_Frame)
                             
                 # Initial setup
                 Sim_Winner_Frame = pd.DataFrame(np.concatenate(Sim_Winners), columns=column_names + ['Fantasy'])
@@ -359,10 +299,7 @@ with tab1:
                 freq_copy = st.session_state.Sim_Winner_Display
                 
             if sim_site_var1 == 'Draftkings':
-                freq_working = pd.DataFrame(np.column_stack(np.unique(freq_copy.iloc[:,0:9].values, return_counts=True)),
-                                                columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
-            elif sim_site_var1 == 'Fanduel':
-                freq_working = pd.DataFrame(np.column_stack(np.unique(freq_copy.iloc[:,0:9].values, return_counts=True)),
+                freq_working = pd.DataFrame(np.column_stack(np.unique(freq_copy.iloc[:,0:6].values, return_counts=True)),
                                                 columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
             freq_working['Freq'] = freq_working['Freq'].astype(int)
             freq_working['Position'] = freq_working['Player'].map(maps_dict['Pos_map'])
@@ -374,119 +311,95 @@ with tab1:
             st.session_state.player_freq = freq_working.copy()
 
             if sim_site_var1 == 'Draftkings':
-                qb_working = pd.DataFrame(np.column_stack(np.unique(freq_copy.iloc[:,0:1].values, return_counts=True)),
+                cpt_working = pd.DataFrame(np.column_stack(np.unique(freq_copy.iloc[:,0:1].values, return_counts=True)),
                                                 columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
-            elif sim_site_var1 == 'Fanduel':
-                qb_working = pd.DataFrame(np.column_stack(np.unique(freq_copy.iloc[:,0:1].values, return_counts=True)),
-                                                columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
-            qb_working['Freq'] = qb_working['Freq'].astype(int)
-            qb_working['Position'] = qb_working['Player'].map(maps_dict['Pos_map'])
-            qb_working['Salary'] = qb_working['Player'].map(maps_dict['Salary_map'])
-            qb_working['Proj Own'] = qb_working['Player'].map(maps_dict['Own_map']) / 100
-            qb_working['Exposure'] = qb_working['Freq']/(1000)
-            qb_working['Edge'] = qb_working['Exposure'] - qb_working['Proj Own']
-            qb_working['Team'] = qb_working['Player'].map(maps_dict['Team_map'])
-            st.session_state.qb_freq = qb_working.copy()
+            cpt_working['Freq'] = cpt_working['Freq'].astype(int)
+            cpt_working['Position'] = cpt_working['Player'].map(maps_dict['Pos_map'])
+            cpt_working['Salary'] = cpt_working['Player'].map(maps_dict['Salary_map'])
+            cpt_working['Proj Own'] = cpt_working['Player'].map(maps_dict['Own_map']) / 100
+            cpt_working['Exposure'] = cpt_working['Freq']/(1000)
+            cpt_working['Edge'] = cpt_working['Exposure'] - cpt_working['Proj Own']
+            cpt_working['Team'] = cpt_working['Player'].map(maps_dict['Team_map'])
+            st.session_state.cpt_freq = cpt_working.copy()
             
             if sim_site_var1 == 'Draftkings':
-                rbwrte_working = pd.DataFrame(np.column_stack(np.unique(freq_copy.iloc[:,1:7].values, return_counts=True)),
-                                                columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
-            elif sim_site_var1 == 'Fanduel':
-                rbwrte_working = pd.DataFrame(np.column_stack(np.unique(freq_copy.iloc[:,1:7].values, return_counts=True)),
+                top_working = pd.DataFrame(np.column_stack(np.unique(freq_copy.iloc[:,1:2].values, return_counts=True)),
                                                 columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
-            rbwrte_working['Freq'] = rbwrte_working['Freq'].astype(int)
-            rbwrte_working['Position'] = rbwrte_working['Player'].map(maps_dict['Pos_map'])
-            rbwrte_working['Salary'] = rbwrte_working['Player'].map(maps_dict['Salary_map'])
-            rbwrte_working['Proj Own'] = rbwrte_working['Player'].map(maps_dict['Own_map']) / 100
-            rbwrte_working['Exposure'] = rbwrte_working['Freq']/(1000)
-            rbwrte_working['Edge'] = rbwrte_working['Exposure'] - rbwrte_working['Proj Own']
-            rbwrte_working['Team'] = rbwrte_working['Player'].map(maps_dict['Team_map'])
-            st.session_state.rbwrte_freq = rbwrte_working.copy()
+            top_working['Freq'] = top_working['Freq'].astype(int)
+            top_working['Position'] = top_working['Player'].map(maps_dict['Pos_map'])
+            top_working['Salary'] = top_working['Player'].map(maps_dict['Salary_map'])
+            top_working['Proj Own'] = top_working['Player'].map(maps_dict['Own_map']) / 100
+            top_working['Exposure'] = top_working['Freq']/(1000)
+            top_working['Edge'] = top_working['Exposure'] - top_working['Proj Own']
+            top_working['Team'] = top_working['Player'].map(maps_dict['Team_map'])
+            st.session_state.top_freq = top_working.copy()
             
             if sim_site_var1 == 'Draftkings':
-                rb_working = pd.DataFrame(np.column_stack(np.unique(freq_copy.iloc[:,1:3].values, return_counts=True)),
-                                                columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
-            elif sim_site_var1 == 'Fanduel':
-                rb_working = pd.DataFrame(np.column_stack(np.unique(freq_copy.iloc[:,1:3].values, return_counts=True)),
+                jng_working = pd.DataFrame(np.column_stack(np.unique(freq_copy.iloc[:,2:3].values, return_counts=True)),
                                                 columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
-            rb_working['Freq'] = rb_working['Freq'].astype(int)
-            rb_working['Position'] = rb_working['Player'].map(maps_dict['Pos_map'])
-            rb_working['Salary'] = rb_working['Player'].map(maps_dict['Salary_map'])
-            rb_working['Proj Own'] = rb_working['Player'].map(maps_dict['Own_map']) / 100
-            rb_working['Exposure'] = rb_working['Freq']/(1000)
-            rb_working['Edge'] = rb_working['Exposure'] - rb_working['Proj Own']
-            rb_working['Team'] = rb_working['Player'].map(maps_dict['Team_map'])
-            st.session_state.rb_freq = rb_working.copy()
+            jng_working['Freq'] = jng_working['Freq'].astype(int)
+            jng_working['Position'] = jng_working['Player'].map(maps_dict['Pos_map'])
+            jng_working['Salary'] = jng_working['Player'].map(maps_dict['Salary_map'])
+            jng_working['Proj Own'] = jng_working['Player'].map(maps_dict['Own_map']) / 100
+            jng_working['Exposure'] = jng_working['Freq']/(1000)
+            jng_working['Edge'] = jng_working['Exposure'] - jng_working['Proj Own']
+            jng_working['Team'] = jng_working['Player'].map(maps_dict['Team_map'])
+            st.session_state.jng_freq = jng_working.copy()
             
             if sim_site_var1 == 'Draftkings':
-                wr_working = pd.DataFrame(np.column_stack(np.unique(freq_copy.iloc[:,3:6].values, return_counts=True)),
+                mid_working = pd.DataFrame(np.column_stack(np.unique(freq_copy.iloc[:,3:4].values, return_counts=True)),
                                                 columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
-            elif sim_site_var1 == 'Fanduel':
-                wr_working = pd.DataFrame(np.column_stack(np.unique(freq_copy.iloc[:,3:6].values, return_counts=True)),
-                                                columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
-            wr_working['Freq'] = wr_working['Freq'].astype(int)
-            wr_working['Position'] = wr_working['Player'].map(maps_dict['Pos_map'])
-            wr_working['Salary'] = wr_working['Player'].map(maps_dict['Salary_map'])
-            wr_working['Proj Own'] = wr_working['Player'].map(maps_dict['Own_map']) / 100
-            wr_working['Exposure'] = wr_working['Freq']/(1000)
-            wr_working['Edge'] = wr_working['Exposure'] - wr_working['Proj Own']
-            wr_working['Team'] = wr_working['Player'].map(maps_dict['Team_map'])
-            st.session_state.wr_freq = wr_working.copy()
+            mid_working['Freq'] = mid_working['Freq'].astype(int)
+            mid_working['Position'] = mid_working['Player'].map(maps_dict['Pos_map'])
+            mid_working['Salary'] = mid_working['Player'].map(maps_dict['Salary_map'])
+            mid_working['Proj Own'] = mid_working['Player'].map(maps_dict['Own_map']) / 100
+            mid_working['Exposure'] = mid_working['Freq']/(1000)
+            mid_working['Edge'] = mid_working['Exposure'] - mid_working['Proj Own']
+            mid_working['Team'] = mid_working['Player'].map(maps_dict['Team_map'])
+            st.session_state.mid_freq = mid_working.copy()
             
             if sim_site_var1 == 'Draftkings':
-                te_working = pd.DataFrame(np.column_stack(np.unique(freq_copy.iloc[:,6:7].values, return_counts=True)),
-                                                columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
-            elif sim_site_var1 == 'Fanduel':
-                te_working = pd.DataFrame(np.column_stack(np.unique(freq_copy.iloc[:,6:7].values, return_counts=True)),
+                adc_working = pd.DataFrame(np.column_stack(np.unique(freq_copy.iloc[:,4:5].values, return_counts=True)),
                                                 columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
-            te_working['Freq'] = te_working['Freq'].astype(int)
-            te_working['Position'] = te_working['Player'].map(maps_dict['Pos_map'])
-            te_working['Salary'] = te_working['Player'].map(maps_dict['Salary_map'])
-            te_working['Proj Own'] = te_working['Player'].map(maps_dict['Own_map']) / 100
-            te_working['Exposure'] = te_working['Freq']/(1000)
-            te_working['Edge'] = te_working['Exposure'] - te_working['Proj Own']
-            te_working['Team'] = te_working['Player'].map(maps_dict['Team_map'])
-            st.session_state.te_freq = te_working.copy()
+            adc_working['Freq'] = adc_working['Freq'].astype(int)
+            adc_working['Position'] = adc_working['Player'].map(maps_dict['Pos_map'])
+            adc_working['Salary'] = adc_working['Player'].map(maps_dict['Salary_map'])
+            adc_working['Proj Own'] = adc_working['Player'].map(maps_dict['Own_map']) / 100
+            adc_working['Exposure'] = adc_working['Freq']/(1000)
+            adc_working['Edge'] = adc_working['Exposure'] - adc_working['Proj Own']
+            adc_working['Team'] = adc_working['Player'].map(maps_dict['Team_map'])
+            st.session_state.adc_freq = adc_working.copy()
             
             if sim_site_var1 == 'Draftkings':
-                flex_working = pd.DataFrame(np.column_stack(np.unique(freq_copy.iloc[:,7:8].values, return_counts=True)),
-                                                columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
-            elif sim_site_var1 == 'Fanduel':
-                flex_working = pd.DataFrame(np.column_stack(np.unique(freq_copy.iloc[:,7:8].values, return_counts=True)),
+                sup_working = pd.DataFrame(np.column_stack(np.unique(freq_copy.iloc[:,5:6].values, return_counts=True)),
                                                 columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
-            flex_working['Freq'] = flex_working['Freq'].astype(int)
-            flex_working['Position'] = flex_working['Player'].map(maps_dict['Pos_map'])
-            flex_working['Salary'] = flex_working['Player'].map(maps_dict['Salary_map'])
-            flex_working['Proj Own'] = flex_working['Player'].map(maps_dict['Own_map']) / 100
-            flex_working['Exposure'] = flex_working['Freq']/(1000)
-            flex_working['Edge'] = flex_working['Exposure'] - flex_working['Proj Own']
-            flex_working['Team'] = flex_working['Player'].map(maps_dict['Team_map'])
-            st.session_state.flex_freq = flex_working.copy()
+            sup_working['Freq'] = sup_working['Freq'].astype(int)
+            sup_working['Position'] = sup_working['Player'].map(maps_dict['Pos_map'])
+            sup_working['Salary'] = sup_working['Player'].map(maps_dict['Salary_map'])
+            sup_working['Proj Own'] = sup_working['Player'].map(maps_dict['Own_map']) / 100
+            sup_working['Exposure'] = sup_working['Freq']/(1000)
+            sup_working['Edge'] = sup_working['Exposure'] - sup_working['Proj Own']
+            sup_working['Team'] = sup_working['Player'].map(maps_dict['Team_map'])
+            st.session_state.sup_freq = sup_working.copy()
             
             if sim_site_var1 == 'Draftkings':
-                dst_working = pd.DataFrame(np.column_stack(np.unique(freq_copy.iloc[:,8:9].values, return_counts=True)),
-                                                columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
-            elif sim_site_var1 == 'Fanduel':
-                dst_working = pd.DataFrame(np.column_stack(np.unique(freq_copy.iloc[:,8:9].values, return_counts=True)),
-                                                columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
-            dst_working['Freq'] = dst_working['Freq'].astype(int)
-            dst_working['Position'] = dst_working['Player'].map(maps_dict['Pos_map'])
-            dst_working['Salary'] = dst_working['Player'].map(maps_dict['Salary_map'])
-            dst_working['Proj Own'] = dst_working['Player'].map(maps_dict['Own_map']) / 100
-            dst_working['Exposure'] = dst_working['Freq']/(1000)
-            dst_working['Edge'] = dst_working['Exposure'] - dst_working['Proj Own']
-            dst_working['Team'] = dst_working['Player'].map(maps_dict['Team_map'])
-            st.session_state.dst_freq = dst_working.copy()
-
-            if sim_site_var1 == 'Draftkings':
-                team_working = pd.DataFrame(np.column_stack(np.unique(freq_copy.iloc[:,11:12].values, return_counts=True)),
-                                                columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
-            elif sim_site_var1 == 'Fanduel':
-                team_working = pd.DataFrame(np.column_stack(np.unique(freq_copy.iloc[:,11:12].values, return_counts=True)),
+                team_working = pd.DataFrame(np.column_stack(np.unique(freq_copy.iloc[:,6:7].values, return_counts=True)),
                                                 columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
             team_working['Freq'] = team_working['Freq'].astype(int)
+            team_working['Position'] = team_working['Player'].map(maps_dict['Pos_map'])
+            team_working['Salary'] = team_working['Player'].map(maps_dict['Salary_map'])
+            team_working['Proj Own'] = team_working['Player'].map(maps_dict['Own_map']) / 100
             team_working['Exposure'] = team_working['Freq']/(1000)
+            team_working['Edge'] = team_working['Exposure'] - team_working['Proj Own']
+            team_working['Team'] = team_working['Player'].map(maps_dict['Team_map'])
             st.session_state.team_freq = team_working.copy()
+
+            if sim_site_var1 == 'Draftkings':
+                stack_working = pd.DataFrame(np.column_stack(np.unique(freq_copy.iloc[:,7:8].values, return_counts=True)),
+                                                columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
+            stack_working['Freq'] = stack_working['Freq'].astype(int)
+            stack_working['Exposure'] = stack_working['Freq']/(1000)
+            st.session_state.stack_freq = stack_working.copy()
             
         with st.container():
             if st.button("Reset Sim", key='reset_sim'):
@@ -509,12 +422,12 @@ with tab1:
                 st.download_button(
                     label="Export Full Frame",
                     data=st.session_state.Sim_Winner_Export.to_csv().encode('utf-8'),
-                    file_name='MLB_consim_export.csv',
+                    file_name='LOL_consim_export.csv',
                     mime='text/csv',
                 )  
                 
         with st.container():
-            tab1, tab2, tab3, tab4, tab5, tab6, tab7, tab8, tab9 = st.tabs(['Overall Exposures', 'QB Exposures', 'RB-WR-TE Exposures', 'RB Exposures', 'WR Exposures', 'TE Exposures', 'FLEX Exposures', 'DST Exposures', 'Team Exposures'])
+            tab1, tab2, tab3, tab4, tab5, tab6, tab7, tab8, tab9 = st.tabs(['Overall Exposures', 'CPT Exposures', 'TOP Exposures', 'JNG Exposures', 'MID Exposures', 'ADC Exposures', 'SUP Exposures', 'Team Exposures', 'Stack Exposures'])
             with tab1:
                 if 'player_freq' in st.session_state:
                     
@@ -527,90 +440,90 @@ with tab1:
                         key='overall'
                     )
             with tab2:
-                if 'qb_freq' in st.session_state:
+                if 'cpt_freq' in st.session_state:
                     
-                    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.dataframe(st.session_state.cpt_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
                     st.download_button(
                         label="Export Exposures",
-                        data=st.session_state.qb_freq.to_csv().encode('utf-8'),
-                        file_name='qb_freq.csv',
+                        data=st.session_state.cpt_freq.to_csv().encode('utf-8'),
+                        file_name='cpt_freq.csv',
                         mime='text/csv',
-                        key='qb'
+                        key='cpt'
                     )
             with tab3:
-                if 'rbwrte_freq' in st.session_state:
+                if 'top_freq' in st.session_state:
                     
-                    st.dataframe(st.session_state.rbwrte_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
+                    st.dataframe(st.session_state.top_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=st.session_state.rbwrte_freq.to_csv().encode('utf-8'),
-                        file_name='rbwrte_freq.csv',
+                        data=st.session_state.top_freq.to_csv().encode('utf-8'),
+                        file_name='top_freq.csv',
                         mime='text/csv',
-                        key='rbwrte'
+                        key='top'
                     )
             with tab4:
-                if 'rb_freq' in st.session_state:
+                if 'jng_freq' in st.session_state:
                     
-                    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.dataframe(st.session_state.jng_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=st.session_state.rb_freq.to_csv().encode('utf-8'),
-                        file_name='rb_freq.csv',
+                        data=st.session_state.jng_freq.to_csv().encode('utf-8'),
+                        file_name='jng_freq.csv',
                         mime='text/csv',
-                        key='rb'
+                        key='jng'
                     )
             with tab5:
-                if 'wr_freq' in st.session_state:
+                if 'mid_freq' in st.session_state:
                     
-                    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.dataframe(st.session_state.mid_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=st.session_state.wr_freq.to_csv().encode('utf-8'),
-                        file_name='wr_freq.csv',
+                        data=st.session_state.mid_freq.to_csv().encode('utf-8'),
+                        file_name='mid_freq.csv',
                         mime='text/csv',
-                        key='wr'
+                        key='mid'
                     )
             with tab6:
-                if 'te_freq' in st.session_state:
+                if 'adc_freq' in st.session_state:
                     
-                    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.dataframe(st.session_state.adc_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=st.session_state.te_freq.to_csv().encode('utf-8'),
-                        file_name='te_freq.csv',
+                        data=st.session_state.adc_freq.to_csv().encode('utf-8'),
+                        file_name='adc_freq.csv',
                         mime='text/csv',
-                        key='te'
+                        key='adc'
                     )
             with tab7:
-                if 'flex_freq' in st.session_state:
+                if 'sup_freq' in st.session_state:
                     
-                    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.dataframe(st.session_state.sup_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=st.session_state.flex_freq.to_csv().encode('utf-8'),
-                        file_name='flex_freq.csv',
+                        data=st.session_state.sup_freq.to_csv().encode('utf-8'),
+                        file_name='sup_freq.csv',
                         mime='text/csv',
-                        key='flex'
+                        key='sup'
                     )
             with tab8:
-                if 'dst_freq' in st.session_state:
+                if 'team_freq' in st.session_state:
                     
-                    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.dataframe(st.session_state.team_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=st.session_state.dst_freq.to_csv().encode('utf-8'),
-                        file_name='dst_freq.csv',
+                        data=st.session_state.team_freq.to_csv().encode('utf-8'),
+                        file_name='team_freq.csv',
                         mime='text/csv',
-                        key='dst'
+                        key='team'
                     )
             with tab9:
-                if 'team_freq' in st.session_state:
+                if 'stack_freq' in st.session_state:
                     
-                    st.dataframe(st.session_state.team_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(percentages_format, precision=2), use_container_width = True)
+                    st.dataframe(st.session_state.stack_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(percentages_format, precision=2), use_container_width = True)
                     st.download_button(
                         label="Export Exposures",
-                        data=st.session_state.team_freq.to_csv().encode('utf-8'),
-                        file_name='team_freq.csv',
+                        data=st.session_state.stack_freq.to_csv().encode('utf-8'),
+                        file_name='stack_freq.csv',
                         mime='text/csv',
-                        key='team'
+                        key='stack'
                     )