Enhance DK and FD lineup initialization in Streamlit app by adding priority variable and mix options for improved data handling. Update UI to include priority selection for optimals, allowing users to customize lineup generation based on projection and ownership metrics.

src/streamlit_app.py

@@ -4,6 +4,7 @@ import pandas as pd
 import pymongo
 import re
 import os
+import math
 
 st.set_page_config(layout="wide")
 
@@ -170,7 +171,10 @@ def init_baselines():
     return player_stats, dk_stacks_raw, fd_stacks_raw, dk_roo_raw, fd_roo_raw, dk_sd_roo_raw, fd_sd_roo_raw, dk_id_map, fd_id_map, dk_sd_id_map, fd_sd_id_map
 
 @st.cache_resource(ttl = 60)
-def init_DK_lineups(type_var, slate_var):  
+def init_DK_lineups(type_var, slate_var, prio_var, prio_mix):  
+
+    if prio_var == 'Mix':
+        prio_var = None
     
     if type_var == 'Regular':
         if slate_var == 'Main':
@@ -180,9 +184,14 @@ def init_DK_lineups(type_var, slate_var):
             names_dict = dict(zip(raw_data['key'], raw_data['value']))
 
             collection = db['DK_NFL_seed_frame']
-            cursor = collection.find().limit(10000)
+            if prio_var == None:
+                cursor1 = collection.find().limit(math.ceil(10000 * (prio_mix / 100)))
+                cursor2 = collection.find().sort('Own', -1).limit(math.ceil(10000 * ((100 - prio_mix) / 100)))
+                raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor = collection.find().sort(prio_var, -1).limit(10000)
+                raw_display = pd.DataFrame(list(cursor))
 
-            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']]
             dict_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
             # Map names
@@ -194,9 +203,14 @@ def init_DK_lineups(type_var, slate_var):
             names_dict = dict(zip(raw_data['key'], raw_data['value']))
             
             collection = db['DK_NFL_Secondary_seed_frame']
-            cursor = collection.find().limit(10000)
+            if prio_var == None:
+                cursor1 = collection.find().limit(math.ceil(10000 * (prio_mix / 100)))
+                cursor2 = collection.find().sort('Own', -1).limit(math.ceil(10000 * ((100 - prio_mix) / 100)))
+                raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor = collection.find().sort(prio_var, -1).limit(10000)
+                raw_display = pd.DataFrame(list(cursor))
 
-            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']]
             dict_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
             # Map names
@@ -208,9 +222,14 @@ def init_DK_lineups(type_var, slate_var):
             names_dict = dict(zip(raw_data['key'], raw_data['value']))
             
             collection = db['DK_NFL_Late_seed_frame']
-            cursor = collection.find().limit(10000)
+            if prio_var == None:
+                cursor1 = collection.find().limit(math.ceil(10000 * (prio_mix / 100)))
+                cursor2 = collection.find().sort('Own', -1).limit(math.ceil(10000 * ((100 - prio_mix) / 100)))
+                raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor = collection.find().sort(prio_var, -1).limit(10000)
+                raw_display = pd.DataFrame(list(cursor))
 
-            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']]
             dict_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
             # Map names
@@ -218,21 +237,36 @@ def init_DK_lineups(type_var, slate_var):
     elif type_var == 'Showdown':
         if slate_var == 'Main':
             collection = db['DK_NFL_SD_seed_frame']
-            cursor = collection.find().limit(10000)
+            if prio_var == None:
+                cursor1 = collection.find().limit(math.ceil(10000 * (prio_mix / 100)))
+                cursor2 = collection.find().sort('Own', -1).limit(math.ceil(10000 * ((100 - prio_mix) / 100)))
+                raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor = collection.find().sort(prio_var, -1).limit(10000)
+                raw_display = pd.DataFrame(list(cursor))
 
-            raw_display = pd.DataFrame(list(cursor))
             raw_display = raw_display[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
         elif slate_var == 'Secondary':
             collection = db['DK_NFL_Secondary_SD_seed_frame']
-            cursor = collection.find().limit(10000)
+            if prio_var == None:
+                cursor1 = collection.find().limit(math.ceil(10000 * (prio_mix / 100)))
+                cursor2 = collection.find().sort('Own', -1).limit(math.ceil(10000 * ((100 - prio_mix) / 100)))
+                raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor = collection.find().sort(prio_var, -1).limit(10000)
+                raw_display = pd.DataFrame(list(cursor))
 
-            raw_display = pd.DataFrame(list(cursor))
             raw_display = raw_display[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
         elif slate_var == 'Auxiliary':
             collection = db['DK_NFL_Auxiliary_SD_seed_frame']
-            cursor = collection.find().limit(10000)
+            if prio_var == None:
+                cursor1 = collection.find().limit(math.ceil(10000 * (prio_mix / 100)))
+                cursor2 = collection.find().sort('Own', -1).limit(math.ceil(10000 * ((100 - prio_mix) / 100)))
+                raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor = collection.find().sort(prio_var, -1).limit(10000)
+                raw_display = pd.DataFrame(list(cursor))
 
-            raw_display = pd.DataFrame(list(cursor))
             raw_display = raw_display[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
 
     DK_seed = raw_display.to_numpy()
@@ -240,75 +274,108 @@ def init_DK_lineups(type_var, slate_var):
     return DK_seed
 
 @st.cache_resource(ttl = 60)
-def init_FD_lineups(type_var, slate_var):  
-        
-        if type_var == 'Regular':
-            if slate_var == 'Main':
-                collection = db['FD_NFL_name_map']
-                cursor = collection.find()
-                raw_data = pd.DataFrame(list(cursor))
-                names_dict = dict(zip(raw_data['key'], raw_data['value']))
+def init_FD_lineups(type_var, slate_var, prio_var, prio_mix):
 
-                collection = db['FD_NFL_seed_frame']
-                cursor = collection.find().limit(10000)
+    if prio_var == 'Mix':
+        prio_var = None
+    
+    if type_var == 'Regular':
+        if slate_var == 'Main':
+            collection = db['FD_NFL_name_map']
+            cursor = collection.find()
+            raw_data = pd.DataFrame(list(cursor))
+            names_dict = dict(zip(raw_data['key'], raw_data['value']))
 
+            collection = db['FD_NFL_seed_frame']
+            if prio_var == None:
+                cursor1 = collection.find().limit(math.ceil(10000 * (prio_mix / 100)))
+                cursor2 = collection.find().sort('Own', -1).limit(math.ceil(10000 * ((100 - prio_mix) / 100)))
+                raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor = collection.find().sort(prio_var, -1).limit(10000)
                 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']]
-                dict_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
-                # Map names
-                raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
-            elif slate_var == 'Secondary':
-                collection = db['FD_NFL_Secondary_name_map']
-                cursor = collection.find()
-                raw_data = pd.DataFrame(list(cursor))
-                names_dict = dict(zip(raw_data['key'], raw_data['value']))
-
-                collection = db['FD_NFL_Secondary_seed_frame']
-                cursor = collection.find().limit(10000)
 
+            raw_display = raw_display[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
+            dict_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
+            # Map names
+            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+        elif slate_var == 'Secondary':
+            collection = db['FD_NFL_Secondary_name_map']
+            cursor = collection.find()
+            raw_data = pd.DataFrame(list(cursor))
+            names_dict = dict(zip(raw_data['key'], raw_data['value']))
+
+            collection = db['FD_NFL_Secondary_seed_frame']
+            if prio_var == None:
+                cursor1 = collection.find().limit(math.ceil(10000 * (prio_mix / 100)))
+                cursor2 = collection.find().sort('Own', -1).limit(math.ceil(10000 * ((100 - prio_mix) / 100)))
+                raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor = collection.find().sort(prio_var, -1).limit(10000)
                 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']]
-                dict_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
-                # Map names
-                raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
-            elif slate_var == 'Auxiliary':
-                collection = db['FD_NFL_Late_name_map']
-                cursor = collection.find()
-                raw_data = pd.DataFrame(list(cursor))
-                names_dict = dict(zip(raw_data['key'], raw_data['value']))
-
-                collection = db['FD_NFL_Late_seed_frame']
-                cursor = collection.find().limit(10000)
-            
+
+            raw_display = raw_display[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
+            dict_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
+            # Map names
+            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+        elif slate_var == 'Auxiliary':
+            collection = db['FD_NFL_Late_name_map']
+            cursor = collection.find()
+            raw_data = pd.DataFrame(list(cursor))
+            names_dict = dict(zip(raw_data['key'], raw_data['value']))
+
+            collection = db['FD_NFL_Late_seed_frame']
+            if prio_var == None:
+                cursor1 = collection.find().limit(math.ceil(10000 * (prio_mix / 100)))
+                cursor2 = collection.find().sort('Own', -1).limit(math.ceil(10000 * ((100 - prio_mix) / 100)))
+                raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor = collection.find().sort(prio_var, -1).limit(10000)
                 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']]
-                dict_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
-                # Map names
-                raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
 
-        elif type_var == 'Showdown':
-            if slate_var == 'Main':
-                collection = db['FD_NFL_SD_seed_frame']
-                cursor = collection.find().limit(10000)
+            raw_display = raw_display[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
+            dict_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
+            # Map names
+            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
 
+    elif type_var == 'Showdown':
+        if slate_var == 'Main':
+            collection = db['FD_NFL_SD_seed_frame']
+            if prio_var == None:
+                cursor1 = collection.find().limit(math.ceil(10000 * (prio_mix / 100)))
+                cursor2 = collection.find().sort('Own', -1).limit(math.ceil(10000 * ((100 - prio_mix) / 100)))
+                raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor = collection.find().sort(prio_var, -1).limit(10000)
                 raw_display = pd.DataFrame(list(cursor))
-                raw_display = raw_display[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
-            elif slate_var == 'Secondary':
-                collection = db['FD_NFL_Secondary_SD_seed_frame']
-                cursor = collection.find().limit(10000)
 
+            raw_display = raw_display[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
+        elif slate_var == 'Secondary':
+            collection = db['FD_NFL_Secondary_SD_seed_frame']
+            if prio_var == None:
+                cursor1 = collection.find().limit(math.ceil(10000 * (prio_mix / 100)))
+                cursor2 = collection.find().sort('Own', -1).limit(math.ceil(10000 * ((100 - prio_mix) / 100)))
+                raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor = collection.find().sort(prio_var, -1).limit(10000)
                 raw_display = pd.DataFrame(list(cursor))
-                raw_display = raw_display[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
-            elif slate_var == 'Auxiliary':
-                collection = db['FD_NFL_Auxiliary_SD_seed_frame']
-                cursor = collection.find().limit(10000)
-            
+
+            raw_display = raw_display[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
+        elif slate_var == 'Auxiliary':
+            collection = db['FD_NFL_Auxiliary_SD_seed_frame']
+            if prio_var == None:
+                cursor1 = collection.find().limit(math.ceil(10000 * (prio_mix / 100)))
+                cursor2 = collection.find().sort('Own', -1).limit(math.ceil(10000 * ((100 - prio_mix) / 100)))
+                raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor = collection.find().sort(prio_var, -1).limit(10000)
                 raw_display = pd.DataFrame(list(cursor))
-                raw_display = raw_display[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
-    
-        FD_seed = raw_display.to_numpy()
 
-        return FD_seed
+            raw_display = raw_display[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
+
+    FD_seed = raw_display.to_numpy()
+
+    return FD_seed
 
 @st.cache_data
 def convert_df_to_csv(df):
@@ -334,8 +401,8 @@ with app_load_reset_column:
     if st.button("Load/Reset Data", key='reset_data_button'):
         st.cache_data.clear()
         player_stats, dk_stacks_raw, fd_stacks_raw, dk_roo_raw, fd_roo_raw, dk_sd_roo_raw, fd_sd_roo_raw, dk_id_map, fd_id_map, dk_sd_id_map, fd_sd_id_map = init_baselines()
-        dk_lineups = init_DK_lineups('Regular', 'Main')
-        fd_lineups = init_FD_lineups('Regular', 'Main')
+        dk_lineups = init_DK_lineups('Regular', 'Main', 'proj', 50)
+        fd_lineups = init_FD_lineups('Regular', 'Main', 'proj', 50)
         for key in st.session_state.keys():
             del st.session_state[key]
 with app_view_site_column:
@@ -901,7 +968,10 @@ elif selected_tab == 'Optimals':
     st.header("Optimals")
     with st.expander("Info and Filters"):
         st.info("These filters will display various optimals in the table below to pick from. If you want to export the entire set of 10,000 optimals, hit the 'Prepare full data export' button. If you would like to apply the filters here to the 10,000 optimals before you export, use the 'Prepare full data export (Filter)' button.")
-        optimals_site_col, optimals_macro_col, optimals_salary_col, optimals_stacks_col = st.columns(4)
+        prio_col, optimals_site_col, optimals_macro_col, optimals_salary_col, optimals_stacks_col = st.columns(5)
+        with prio_col:
+            prio_var = st.radio("Which priority variable do you want to use?", ('proj', 'Own', 'Mix'), key='prio_var_radio')
+            prio_mix = st.number_input("If Mix, what split of Projection/Ownership to dedicate to Projection?", min_value=0, max_value=100, value=50, step=1)
         with optimals_site_col:
             slate_type_var3 = st.radio("Which slate type are you loading?", ('Regular', 'Showdown'), key='slate_type_var3_radio')
             if slate_type_var3 == 'Regular':
@@ -917,14 +987,14 @@ elif selected_tab == 'Optimals':
             slate_var3 = st.radio("Which slate data are you loading?", ('Main', 'Secondary', 'Auxiliary'), key='slate_var3_radio')
             if slate_type_var3 == 'Regular':
                 if site_var == 'Draftkings':
-                    dk_lineups = init_DK_lineups(slate_type_var3, slate_var3)
+                    dk_lineups = init_DK_lineups(slate_type_var3, slate_var3, prio_var, prio_mix)
                 elif site_var == 'Fanduel':
-                    fd_lineups = init_FD_lineups(slate_type_var3, slate_var3)
+                    fd_lineups = init_FD_lineups(slate_type_var3, slate_var3, prio_var, prio_mix)
             elif slate_type_var3 == 'Showdown':
                 if site_var == 'Draftkings':
-                    dk_lineups = init_DK_lineups(slate_type_var3, slate_var3)
+                    dk_lineups = init_DK_lineups(slate_type_var3, slate_var3, prio_var, prio_mix)
                 elif site_var == 'Fanduel':
-                    fd_lineups = init_FD_lineups(slate_type_var3, slate_var3)
+                    fd_lineups = init_FD_lineups(slate_type_var3, slate_var3, prio_var, prio_mix)
         with optimals_macro_col:
             lineup_num_var = st.number_input("How many lineups do you want to display?", min_value=1, max_value=1000, value=150, step=1, key='lineup_num_var_input')
             player_var1 = st.radio("Do you want a frame with specific Players?", ('Full Slate', 'Specific Players'), key='player_var1_radio')