introducing NBA functions

app.py

@@ -38,9 +38,17 @@ dk_db_nfl_showdown_selections = ['DK_NFL_SD_seed_frame_Showdown #1', 'DK_NFL_SD_
 fd_db_nfl_showdown_selections = ['FD_NFL_SD_seed_frame_Showdown #1', 'FD_NFL_SD_seed_frame_Showdown #2', 'FD_NFL_SD_seed_frame_Showdown #3', 'FD_NFL_SD_seed_frame_Showdown #4', 'FD_NFL_SD_seed_frame_Showdown #5', 'FD_NFL_SD_seed_frame_Showdown #6',
 'FD_NFL_SD_seed_frame_Showdown #7', 'FD_NFL_SD_seed_frame_Showdown #8', 'FD_NFL_SD_seed_frame_Showdown #9', 'FD_NFL_SD_seed_frame_Showdown #10', 'FD_NFL_SD_seed_frame_Showdown #11', 'FD_NFL_SD_seed_frame_Showdown #12', 'FD_NFL_SD_seed_frame_Showdown #13',
 'FD_NFL_SD_seed_frame_Showdown #14', 'FD_NFL_SD_seed_frame_Showdown #15']
+dk_db_nba_showdown_selections = ['DK_NBA_SD_seed_frame_Showdown #1', 'DK_NBA_SD_seed_frame_Showdown #2', 'DK_NBA_SD_seed_frame_Showdown #3', 'DK_NBA_SD_seed_frame_Showdown #4', 'DK_NBA_SD_seed_frame_Showdown #5', 'DK_NBA_SD_seed_frame_Showdown #6',
+'DK_NBA_SD_seed_frame_Showdown #7', 'DK_NBA_SD_seed_frame_Showdown #8', 'DK_NBA_SD_seed_frame_Showdown #9', 'DK_NBA_SD_seed_frame_Showdown #10', 'DK_NBA_SD_seed_frame_Showdown #11', 'DK_NBA_SD_seed_frame_Showdown #12', 'DK_NBA_SD_seed_frame_Showdown #13',
+'DK_NBA_SD_seed_frame_Showdown #14', 'DK_NBA_SD_seed_frame_Showdown #15']
+fd_db_nba_showdown_selections = ['FD_NBA_SD_seed_frame_Showdown #1', 'FD_NBA_SD_seed_frame_Showdown #2', 'FD_NBA_SD_seed_frame_Showdown #3', 'FD_NBA_SD_seed_frame_Showdown #4', 'FD_NBA_SD_seed_frame_Showdown #5', 'FD_NBA_SD_seed_frame_Showdown #6',
+'FD_NBA_SD_seed_frame_Showdown #7', 'FD_NBA_SD_seed_frame_Showdown #8', 'FD_NBA_SD_seed_frame_Showdown #9', 'FD_NBA_SD_seed_frame_Showdown #10', 'FD_NBA_SD_seed_frame_Showdown #11', 'FD_NBA_SD_seed_frame_Showdown #12', 'FD_NBA_SD_seed_frame_Showdown #13',
+'FD_NBA_SD_seed_frame_Showdown #14', 'FD_NBA_SD_seed_frame_Showdown #15']
 
 dk_nfl_showdown_db_translation = dict(zip(showdown_selections, dk_db_nfl_showdown_selections))
 fd_nfl_showdown_db_translation = dict(zip(showdown_selections, fd_db_nfl_showdown_selections))
+dk_nba_showdown_db_translation = dict(zip(showdown_selections, dk_db_nba_showdown_selections))
+fd_nba_showdown_db_translation = dict(zip(showdown_selections, fd_db_nba_showdown_selections))
 
 freq_format = {'Finish_percentile': '{:.2%}', 'Lineup Edge': '{:.2%}', 'Lineup Edge_Raw': '{:.2%}', 'Win%': '{:.2%}'}
 stacking_sports = ['MLB', 'NHL', 'NFL', 'LOL', 'NCAAF']
@@ -196,7 +204,54 @@ except:
     nfl_slate_names_fd = []
     nfl_slate_name_lookup_fd = {}
 
+def define_dk_nba_showdown_slates():
+    collection = nba_db["Player_SD_Range_Of_Outcomes"]
+    cursor = collection.find()
+    raw_display = pd.DataFrame(list(cursor))
+    raw_display = raw_display[raw_display['site'] == 'Draftkings']
+    unique_slates = raw_display['slate'].unique()
+
+    slate_names = []
+
+    for slate in unique_slates:
+        slate_data = raw_display[raw_display['slate'] == slate]
+        slate_name = slate_data.iloc[0]['Team'] + ' vs. ' + slate_data.iloc[0]['Opp']
+        slate_names.append(slate_name)
+    
+    slate_name_lookup = dict(zip(slate_names, unique_slates))
+    return slate_names, slate_name_lookup
+
+def define_fd_nba_showdown_slates():
+    collection = nba_db["Player_SD_Range_Of_Outcomes"]
+    cursor = collection.find()
+    raw_display = pd.DataFrame(list(cursor))
+    raw_display = raw_display[raw_display['site'] == 'Fanduel']
+    unique_slates = raw_display['slate'].unique()
+
+    slate_names = []
+
+    for slate in unique_slates:
+        slate_data = raw_display[raw_display['slate'] == slate]
+        slate_name = slate_data.iloc[0]['Team'] + ' vs. ' + slate_data.iloc[0]['Opp']
+        slate_names.append(slate_name)
+    
+    slate_name_lookup = dict(zip(slate_names, unique_slates))
+    return slate_names, slate_name_lookup
+
+try:
+    nba_slate_names_dk, nba_slate_name_lookup_dk = define_dk_nba_showdown_slates()
+except:
+    nba_slate_names_dk = []
+    nba_slate_name_lookup_dk = {}
+    
+try:
+    nba_slate_names_fd, nba_slate_name_lookup_fd = define_fd_nba_showdown_slates()
+except:
+    nba_slate_names_fd = []
+    nba_slate_name_lookup_fd = {}
+
 nfl_reg_salaries = grab_nfl_reg_salaries()
+nba_reg_salaries = grab_nba_reg_salaries()
 
 # Memory optimization helper functions
 def chunk_name_matching(portfolio_names, csv_names, chunk_size=1000):
@@ -568,9 +623,19 @@ with st.container():
 
         with optimals_site_col:
             if site_var == 'Draftkings':
-                slate_var3 = st.radio("Which slate data are you loading?", (nfl_slate_names_dk if type_var == 'Showdown' else ['Main', 'Secondary', 'Auxiliary']), key='slate_var3_radio')
+                if sport_var == 'NBA':
+                    slate_var3 = st.radio("Which slate data are you loading?", (nba_slate_names_dk if type_var == 'Showdown' else ['Main', 'Secondary', 'Auxiliary']), key='slate_var3_radio')
+                elif sport_var == 'NFL':
+                    slate_var3 = st.radio("Which slate data are you loading?", (nfl_slate_names_dk if type_var == 'Showdown' else ['Main', 'Secondary', 'Auxiliary']), key='slate_var3_radio')
+                else:
+                    slate_var3 = st.radio("Which slate data are you loading?", (['Main', 'Secondary', 'Auxiliary']), key='slate_var3_radio')
             elif site_var == 'Fanduel':
-                slate_var3 = st.radio("Which slate data are you loading?", (nfl_slate_names_fd if type_var == 'Showdown' else ['Main', 'Secondary', 'Auxiliary']), key='slate_var3_radio')
+                if sport_var == 'NBA':
+                    slate_var3 = st.radio("Which slate data are you loading?", (nba_slate_names_fd if type_var == 'Showdown' else ['Main', 'Secondary', 'Auxiliary']), key='slate_var3_radio')
+                elif sport_var == 'NFL':
+                    slate_var3 = st.radio("Which slate data are you loading?", (nfl_slate_names_fd if type_var == 'Showdown' else ['Main', 'Secondary', 'Auxiliary']), key='slate_var3_radio')
+                else:
+                    slate_var3 = st.radio("Which slate data are you loading?", (['Main', 'Secondary', 'Auxiliary']), key='slate_var3_radio')
             
         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')
@@ -627,7 +692,10 @@ if selected_tab == 'Data Load':
             if st.button("Load from Paydirt DB"):
                 if 'csv_file' in st.session_state:
                     del st.session_state['csv_file']
-                st.session_state['csv_file'] = load_csv(nfl_reg_salaries)
+                if sport_var == 'NBA':
+                    st.session_state['csv_file'] = load_csv(nba_reg_salaries)
+                elif sport_var == 'NFL':
+                    st.session_state['csv_file'] = load_csv(nfl_reg_salaries)
                 st.session_state['pricing_loaded'] = True
                 
             try:
@@ -693,9 +761,15 @@ if selected_tab == 'Data Load':
             if st.button("Load from Database after inserting site CSV"):
                 if site_var == 'Draftkings':
                     if type_var != 'Showdown':
-                        portfolio_load = init_DK_NFL_lineups(type_var, slate_var3, prio_var, 50, dk_nfl_showdown_db_translation, lineup_num_var, [])
+                        if sport_var == 'NBA':
+                            portfolio_load = init_DK_NBA_lineups(type_var, slate_var3, prio_var, 50, dk_nba_showdown_db_translation, lineup_num_var, [])
+                        elif sport_var == 'NFL':
+                            portfolio_load = init_DK_NFL_lineups(type_var, slate_var3, prio_var, 50, dk_nfl_showdown_db_translation, lineup_num_var, [])
                     else:
-                        portfolio_load = init_DK_NFL_lineups(type_var, nfl_slate_name_lookup_dk[slate_var3], prio_var, 50, dk_nfl_showdown_db_translation, lineup_num_var, [])
+                        if sport_var == 'NBA':
+                            portfolio_load = init_DK_NBA_lineups(type_var, nba_slate_name_lookup_dk[slate_var3], prio_var, 50, dk_nba_showdown_db_translation, lineup_num_var, [])
+                        elif sport_var == 'NFL':
+                            portfolio_load = init_DK_NFL_lineups(type_var, nfl_slate_name_lookup_dk[slate_var3], prio_var, 50, dk_nfl_showdown_db_translation, lineup_num_var, [])
                     st.session_state['db_portfolio_file'] = pd.DataFrame(portfolio_load)
                     st.session_state['portfolio_loaded'] = True
                     if 'portfolio' in st.session_state:
@@ -704,9 +778,15 @@ if selected_tab == 'Data Load':
                         del st.session_state['export_portfolio']
                 else:
                     if type_var != 'Showdown':
-                        portfolio_load = init_FD_NFL_lineups(type_var, slate_var3, prio_var, 50, fd_nfl_showdown_db_translation, lineup_num_var, [])
+                        if sport_var == 'NBA':
+                            portfolio_load = init_FD_NBA_lineups(type_var, slate_var3, prio_var, 50, fd_nba_showdown_db_translation, lineup_num_var, [])
+                        elif sport_var == 'NFL':
+                            portfolio_load = init_FD_NFL_lineups(type_var, slate_var3, prio_var, 50, fd_nfl_showdown_db_translation, lineup_num_var, [])
                     else:
-                        portfolio_load = init_FD_NFL_lineups(type_var, nfl_slate_name_lookup_fd[slate_var3], prio_var, 50, fd_nfl_showdown_db_translation, lineup_num_var, [])
+                        if sport_var == 'NBA':
+                            portfolio_load = init_FD_NBA_lineups(type_var, nba_slate_name_lookup_fd[slate_var3], prio_var, 50, fd_nba_showdown_db_translation, lineup_num_var, [])
+                        elif sport_var == 'NFL':
+                            portfolio_load = init_FD_NFL_lineups(type_var, nfl_slate_name_lookup_fd[slate_var3], prio_var, 50, fd_nfl_showdown_db_translation, lineup_num_var, [])
                     st.session_state['db_portfolio_file'] = pd.DataFrame(portfolio_load)
                     st.session_state['portfolio_loaded'] = True
                     if 'portfolio' in st.session_state:
@@ -801,7 +881,10 @@ if selected_tab == 'Data Load':
                 st.session_state['projections_loaded'] = True
             elif proj_options == 'Paydirt DB':
                 if st.button("Load from Database"):
-                    projections_file = init_nfl_baselines(type_var, site_var, slate_var3)[0]
+                    if sport_var == 'NBA':
+                        projections_file = init_nba_baselines(type_var, site_var, slate_var3)[0]
+                    elif sport_var == 'NFL':
+                        projections_file = init_nfl_baselines(type_var, site_var, slate_var3)[0]
                     st.session_state['db_projections_file'] = projections_file
                     st.session_state['projections_loaded'] = True
             if 'projections_df' in st.session_state:

database_queries.py

@@ -436,4 +436,393 @@ def init_FD_NFL_lineups(type_var, slate_var, prio_var, prio_mix, nfl_db_translat
 
     FD_seed = raw_display.to_numpy()
 
+    return FD_seed
+
+def init_nba_baselines(type_var: str, site_var: str, slate_var: str):
+
+    if slate_var == 'Main':
+        slate_var = 'Main Slate'
+    elif slate_var == 'Secondary':
+        slate_var = 'Secondary Slate'
+    elif slate_var == 'Auxiliary':
+        slate_var = 'Late Slate'
+
+    if type_var == 'Showdown':
+        collection = nba_db["Player_SD_Range_Of_Outcomes"]
+        cursor = collection.find()
+
+        raw_display = pd.DataFrame(list(cursor))
+        raw_display = raw_display[['Player', 'Position', 'Team', 'Salary', 'Median', 'Own', 'CPT_Own', 'player_id', 'slate', 'version']]
+        raw_display['Median'] = raw_display['Median'].replace('', 0).astype(float)
+        raw_display = raw_display.rename(columns={"player_id": "player_ID"})
+        raw_display = raw_display.loc[raw_display['Median'] > 0]
+        raw_display = raw_display.apply(pd.to_numeric, errors='ignore')
+        sd_raw = raw_display.sort_values(by='Median', ascending=False)
+        dk_sd_roo_raw = sd_raw[sd_raw['site'] == 'Draftkings']
+        dk_sd_id_map = dict(zip(dk_sd_roo_raw['Player'], dk_sd_roo_raw['player_ID']))
+        fd_sd_roo_raw = sd_raw[sd_raw['site'] == 'Fanduel']
+        fd_sd_id_map = dict(zip(fd_sd_roo_raw['Player'], fd_sd_roo_raw['player_ID']))
+        fd_sd_roo_raw['player_ID'] = fd_sd_roo_raw['player_ID'].astype(str)
+        fd_sd_roo_raw['player_ID'] = fd_sd_roo_raw['player_ID'].str.rsplit('-', n=1).str[0].astype(str)
+
+        timestamp = sd_raw['timestamp'].values[0]
+
+        roo_raw = None
+        dk_roo_raw = None
+        fd_roo_raw = None
+        dk_id_map = None
+        fd_id_map = None
+
+    else:
+        collection = nba_db["Player_Range_Of_Outcomes"]
+        cursor = collection.find()
+
+        raw_display = pd.DataFrame(list(cursor))
+        raw_display = raw_display[['Player', 'Position', 'Team', 'Salary', 'Median', 'Own', 'CPT_Own', 'player_id', 'slate', 'version']]
+        raw_display = raw_display.rename(columns={"player_id": "player_ID"})
+        raw_display['Median'] = raw_display['Median'].replace('', 0).astype(float)
+        raw_display = raw_display.loc[raw_display['Median'] > 0]
+        dk_roo_raw = raw_display[raw_display['site'] == 'Draftkings']
+        fd_roo_raw = raw_display[raw_display['site'] == 'Fanduel']
+        dk_id_map = dict(zip(dk_roo_raw['Player'], dk_roo_raw['player_ID']))
+        fd_id_map = dict(zip(fd_roo_raw['Player'], fd_roo_raw['player_ID']))
+        raw_display = raw_display.apply(pd.to_numeric, errors='ignore')
+        roo_raw = raw_display.sort_values(by='Median', ascending=False)
+
+        timestamp = roo_raw['timestamp'].values[0]
+
+        sd_raw = None
+        dk_sd_roo_raw = None
+        fd_sd_roo_raw = None
+        dk_sd_id_map = None
+        fd_sd_id_map = None
+    
+    return roo_raw, dk_roo_raw, fd_roo_raw, sd_raw, dk_sd_roo_raw, fd_sd_roo_raw, dk_id_map, fd_id_map, dk_sd_id_map, fd_sd_id_map, timestamp
+
+def init_DK_NBA_lineups(type_var, slate_var, prio_var, prio_mix, nba_db_translation, lineup_num, player_var2):  
+
+    if prio_var == 'Mix':
+        prio_var = None
+    
+    if type_var == 'Regular':
+        if slate_var == 'Main':
+            collection = nba_db['DK_NBA_name_map']
+            cursor = collection.find()
+            raw_data = pd.DataFrame(list(cursor))
+            names_dict = dict(zip(raw_data['key'], raw_data['value']))
+
+            collection = nba_db['DK_NBA_seed_frame_Main Slate']
+            if prio_var == None:
+                if player_var2 != []:
+                    player_columns = ['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX']
+                    query_conditions = []
+                    
+                    for player in player_var2:
+                        # Create a condition for each player to check if they appear in any column
+                        player_condition = {'$or': [{col: player} for col in player_columns]}
+                        query_conditions.append(player_condition)
+                    
+                    # Combine all player conditions with $or
+                    if query_conditions:
+                        filter_query = {'$or': query_conditions}
+                        cursor1 = collection.find(filter_query).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    else:
+                        cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+                else:
+                    cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((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(lineup_num)
+                raw_display = pd.DataFrame(list(cursor))
+            
+            raw_display = raw_display.drop_duplicates(subset=['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX'])
+
+            raw_display = raw_display[['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX']]
+            dict_columns = ['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX']
+            # Map names
+            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+        elif slate_var == 'Secondary':
+            collection = nba_db['DK_NBA_Secondary_name_map']
+            cursor = collection.find()
+            raw_data = pd.DataFrame(list(cursor))
+            names_dict = dict(zip(raw_data['key'], raw_data['value']))
+            
+            collection = nba_db['DK_NBA_seed_frame_Secondary Slate']
+            if prio_var == None:
+                if player_var2 != []:
+                    player_columns = ['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX']
+                    query_conditions = []
+                    
+                    for player in player_var2:
+                        # Create a condition for each player to check if they appear in any column
+                        player_condition = {'$or': [{col: player} for col in player_columns]}
+                        query_conditions.append(player_condition)
+                    
+                    # Combine all player conditions with $or
+                    if query_conditions:
+                        filter_query = {'$or': query_conditions}
+                        cursor1 = collection.find(filter_query).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    else:
+                        cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+                else:
+                    cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((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(lineup_num)
+                raw_display = pd.DataFrame(list(cursor))
+
+            raw_display = raw_display.drop_duplicates(subset=['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX'])
+
+            raw_display = raw_display[['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX']]
+            dict_columns = ['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX']
+            # Map names
+            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+        elif slate_var == 'Auxiliary':
+            collection = nba_db['DK_NBA_Late_name_map']
+            cursor = collection.find()
+            raw_data = pd.DataFrame(list(cursor))
+            names_dict = dict(zip(raw_data['key'], raw_data['value']))
+            
+            collection = nba_db['DK_NBA_seed_frame_Late Slate']
+            if prio_var == None:
+                if player_var2 != []:
+                    player_columns = ['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX']
+                    query_conditions = []
+                    
+                    for player in player_var2:
+                        # Create a condition for each player to check if they appear in any column
+                        player_condition = {'$or': [{col: player} for col in player_columns]}
+                        query_conditions.append(player_condition)
+                    
+                    # Combine all player conditions with $or
+                    if query_conditions:
+                        filter_query = {'$or': query_conditions}
+                        cursor1 = collection.find(filter_query).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    else:
+                        cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+                else:
+                    cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((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(lineup_num)
+                raw_display = pd.DataFrame(list(cursor))
+
+            raw_display = raw_display.drop_duplicates(subset=['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX'])
+
+            raw_display = raw_display[['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX']]
+            dict_columns = ['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX']
+            # Map names
+            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+    elif type_var == 'Showdown':
+        collection = nba_db[nba_db_translation[slate_var]]
+        if prio_var == None:
+            if player_var2 != []:
+                player_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5']
+                query_conditions = []
+                
+                for player in player_var2:
+                    # Create a condition for each player to check if they appear in any column
+                    player_condition = {'$or': [{col: player} for col in player_columns]}
+                    query_conditions.append(player_condition)
+                
+                # Combine all player conditions with $or
+                if query_conditions:
+                    filter_query = {'$or': query_conditions}
+                    cursor1 = collection.find(filter_query).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                else:
+                    cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((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(lineup_num)
+            raw_display = pd.DataFrame(list(cursor))
+
+        raw_display = raw_display.drop_duplicates(subset=['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'])
+
+        raw_display = raw_display[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5']]
+
+    DK_seed = raw_display.to_numpy()
+
+    return DK_seed
+
+def init_FD_NBA_lineups(type_var, slate_var, prio_var, prio_mix, nba_db_translation, lineup_num, player_var2):
+
+    if prio_var == 'Mix':
+        prio_var = None
+    
+    if type_var == 'Regular':
+        if slate_var == 'Main':
+            collection = nba_db['FD_NBA_name_map']
+            cursor = collection.find()
+            raw_data = pd.DataFrame(list(cursor))
+            names_dict = dict(zip(raw_data['key'], raw_data['value']))
+
+
+            collection = nba_db['FD_NBA_seed_frame_Main Slate']
+            if prio_var == None:
+                if player_var2 != []:
+                    player_columns = ['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C']
+                    query_conditions = []
+                    
+                    for player in player_var2:
+                        # Create a condition for each player to check if they appear in any column
+                        player_condition = {'$or': [{col: player} for col in player_columns]}
+                        query_conditions.append(player_condition)
+                    
+                    # Combine all player conditions with $or
+                    if query_conditions:
+                        filter_query = {'$or': query_conditions}
+                        cursor1 = collection.find(filter_query).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    else:
+                        cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+                else:
+                    cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((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(lineup_num)
+                raw_display = pd.DataFrame(list(cursor))
+
+            raw_display = raw_display.drop_duplicates(subset=['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C'])
+
+            raw_display = raw_display[['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C']]
+            dict_columns = ['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C']
+            # Map names
+            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+        elif slate_var == 'Secondary':
+            collection = nba_db['FD_NBA_Secondary_name_map']
+            cursor = collection.find()
+            raw_data = pd.DataFrame(list(cursor))
+            names_dict = dict(zip(raw_data['key'], raw_data['value']))
+
+            collection = nba_db['FD_NBA_Secondary_seed_frame_Secondary Slate']
+            if prio_var == None:
+                if player_var2 != []:
+                    player_columns = ['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C']
+                    query_conditions = []
+                    
+                    for player in player_var2:
+                        # Create a condition for each player to check if they appear in any column
+                        player_condition = {'$or': [{col: player} for col in player_columns]}
+                        query_conditions.append(player_condition)
+                    
+                    # Combine all player conditions with $or
+                    if query_conditions:
+                        filter_query = {'$or': query_conditions}
+                        cursor1 = collection.find(filter_query).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    else:
+                        cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+                else:
+                    cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((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(lineup_num)
+                raw_display = pd.DataFrame(list(cursor))
+
+            raw_display = raw_display.drop_duplicates(subset=['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C'])
+
+            raw_display = raw_display[['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C']]
+            dict_columns = ['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C']
+            # Map names
+            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+        elif slate_var == 'Auxiliary':
+            collection = nba_db['FD_NBA_Late_name_map']
+            cursor = collection.find()
+            raw_data = pd.DataFrame(list(cursor))
+            names_dict = dict(zip(raw_data['key'], raw_data['value']))
+
+            collection = nba_db['FD_NBA_Late_seed_frame_Late Slate']
+            if prio_var == None:
+                if player_var2 != []:
+                    player_columns = ['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C']
+                    query_conditions = []
+
+                    for player in player_var2:
+                        # Create a condition for each player to check if they appear in any column
+                        player_condition = {'$or': [{col: player} for col in player_columns]}
+                        query_conditions.append(player_condition)
+
+                    # Combine all player conditions with $or
+                    if query_conditions:
+                        filter_query = {'$or': query_conditions}
+                        cursor1 = collection.find(filter_query).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num = ((100 - prio_mix) / 100)))
+                    else:
+                        cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+                else:
+                    cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((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(lineup_num)
+                raw_display = pd.DataFrame(list(cursor))
+
+            raw_display = raw_display.drop_duplicates(subset=['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C'])
+
+            raw_display = raw_display[['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C']]
+            dict_columns = ['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C']
+            # Map names
+            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+
+    elif type_var == 'Showdown':
+        collection = nba_db[nba_db_translation[slate_var]]
+        if prio_var == None:
+            if player_var2 != []:
+                player_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5']
+                query_conditions = []
+                
+                for player in player_var2:
+                    # Create a condition for each player to check if they appear in any column
+                    player_condition = {'$or': [{col: player} for col in player_columns]}
+                    query_conditions.append(player_condition)
+                
+                # Combine all player conditions with $or
+                if query_conditions:
+                    filter_query = {'$or': query_conditions}
+                    cursor1 = collection.find(filter_query).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                else:
+                    cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((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(lineup_num)
+            raw_display = pd.DataFrame(list(cursor))
+
+        raw_display = raw_display.drop_duplicates(subset=['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'])
+
+        raw_display = raw_display[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5']]
+
+    FD_seed = raw_display.to_numpy()
+
     return FD_seed