Add timezone handling for current date in salary retrieval functions across NFL, NBA, MLB, and NHL

app.py

@@ -131,7 +131,8 @@ st.markdown("""
 
 def grab_nfl_reg_salaries(slate_var: str):
     collection = salaries_db["NFL_reg_player_info"]
-    today_str = datetime.now().strftime("%Y%m%d")
+    eastern = pytz.timezone('US/Eastern')
+    today_str = datetime.now(eastern).strftime("%Y%m%d")
     records = pd.DataFrame(list(collection.find({'Date': {'$gte': today_str}})))
     records = records[['Display Name', 'draftableId', 'Position', 'Salary']]
     records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'})
@@ -164,7 +165,8 @@ def grab_nfl_reg_salaries(slate_var: str):
 
 def grab_nfl_showdown_salaries():
     collection = salaries_db["NFL_showdown_player_info"]
-    today_str = datetime.now().strftime("%Y%m%d")
+    eastern = pytz.timezone('US/Eastern')
+    today_str = datetime.now(eastern).strftime("%Y%m%d")
     records = pd.DataFrame(list(collection.find({'Date': {'$gte': today_str}})))
     records = records[['Display Name', 'draftableId', 'Position', 'Salary']]
     records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'})
@@ -172,7 +174,8 @@ def grab_nfl_showdown_salaries():
 
 def grab_nba_reg_salaries(slate_var: str):
     collection = salaries_db["NBA_reg_player_info"]
-    today_str = datetime.now().strftime("%Y%m%d")
+    eastern = pytz.timezone('US/Eastern')
+    today_str = datetime.now(eastern).strftime("%Y%m%d")
     records = pd.DataFrame(list(collection.find({'Date': {'$gte': today_str}})))
     records = records[['Display Name', 'draftableId', 'Position', 'Salary']]
     records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'})
@@ -216,7 +219,8 @@ def grab_nba_showdown_salaries():
 
 def grab_mlb_reg_salaries(slate_var: str):
     collection = salaries_db["MLB_reg_player_info"]
-    today_str = datetime.now().strftime("%Y%m%d")
+    eastern = pytz.timezone('US/Eastern')
+    today_str = datetime.now(eastern).strftime("%Y%m%d")
     records = pd.DataFrame(list(collection.find({'Date': {'$gte': today_str}})))
     records = records[['Display Name', 'draftableId', 'Position', 'Salary']]
     records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'})
@@ -249,7 +253,8 @@ def grab_mlb_reg_salaries(slate_var: str):
 
 def grab_mlb_showdown_salaries():
     collection = salaries_db["MLB_showdown_player_info"]
-    today_str = datetime.now().strftime("%Y%m%d")
+    eastern = pytz.timezone('US/Eastern')
+    today_str = datetime.now(eastern).strftime("%Y%m%d")
     records = pd.DataFrame(list(collection.find({'Date': {'$gte': today_str}})))
     records = records[['Display Name', 'draftableId', 'Position', 'Salary']]
     records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'})
@@ -257,7 +262,8 @@ def grab_mlb_showdown_salaries():
 
 def grab_nhl_reg_salaries(slate_var: str):
     collection = salaries_db["NHL_reg_player_info"]
-    today_str = datetime.now().strftime("%Y%m%d")
+    eastern = pytz.timezone('US/Eastern')
+    today_str = datetime.now(eastern).strftime("%Y%m%d")
     records = pd.DataFrame(list(collection.find({'Date': {'$gte': today_str}})))
     records = records[['Display Name', 'draftableId', 'Position', 'Salary']]
     records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'})
@@ -290,7 +296,8 @@ def grab_nhl_reg_salaries(slate_var: str):
 
 def grab_nhl_showdown_salaries():
     collection = salaries_db["NHL_showdown_player_info"]
-    today_str = datetime.now().strftime("%Y%m%d")
+    eastern = pytz.timezone('US/Eastern')
+    today_str = datetime.now(eastern).strftime("%Y%m%d")
     records = pd.DataFrame(list(collection.find({'Date': {'$gte': today_str}})))
     records = records[['Display Name', 'draftableId', 'Position', 'Salary']]
     records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'})

database_queries.py

@@ -832,4 +832,398 @@ def init_FD_NBA_lineups(type_var, slate_var, prio_var, prio_mix, nba_db_translat
 
     FD_seed = raw_display.to_numpy()
 
+    return FD_seed
+
+def init_nhl_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 = nhl_db["Player_Level_SD_ROO"]
+        cursor = collection.find()
+
+        raw_display = pd.DataFrame(list(cursor))
+        raw_display = raw_display[['Player', 'Position', 'Team', 'Salary', 'Median', 'Own', 'CPT_Own', 'player_id', 'slate', 'site', 'version', 'timestamp']]
+        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)
+
+        dk_sd_roo_raw = dk_sd_roo_raw.drop(columns=['player_ID', 'slate', 'version', 'timestamp', 'site'])
+        fd_sd_roo_raw = fd_sd_roo_raw.drop(columns=['player_ID', 'slate', 'version', 'timestamp', 'site'])
+
+        dk_sd_roo_raw = dk_sd_roo_raw.rename(columns={'Player': 'player_names', 'Position': 'position', 'Team': 'team', 'Salary': 'salary', 'Median': 'median', 'Own': 'ownership', 'CPT_Own': 'captain ownership'})
+        fd_sd_roo_raw = fd_sd_roo_raw.rename(columns={'Player': 'player_names', 'Position': 'position', 'Team': 'team', 'Salary': 'salary', 'Median': 'median', 'Own': 'ownership', 'CPT_Own': 'captain ownership'})
+
+        dk_roo_raw = None
+        fd_roo_raw = None
+        dk_id_map = None
+        fd_id_map = None
+
+    else:
+        collection = nhl_db["Player_Level_ROO"]
+        cursor = collection.find()
+
+        raw_display = pd.DataFrame(list(cursor))
+        raw_display = raw_display[['Player', 'Position', 'Team', 'Salary', 'Median', 'Own', 'CPT_Own', 'player_id', 'Slate', 'Site', 'timestamp']]
+        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')
+
+        dk_roo_raw = dk_roo_raw.drop(columns=['player_ID', 'Slate', 'timestamp', 'Site'])
+        fd_roo_raw = fd_roo_raw.drop(columns=['player_ID', 'Slate', 'timestamp', 'Site'])
+
+        dk_roo_raw = dk_roo_raw.rename(columns={'Player': 'player_names', 'Position': 'position', 'Team': 'team', 'Salary': 'salary', 'Median': 'median', 'Own': 'ownership', 'CPT_Own': 'captain ownership'})
+        fd_roo_raw = fd_roo_raw.rename(columns={'Player': 'player_names', 'Position': 'position', 'Team': 'team', 'Salary': 'salary', 'Median': 'median', 'Own': 'ownership', 'CPT_Own': 'captain ownership'})
+
+        dk_sd_roo_raw = None
+        fd_sd_roo_raw = None
+        dk_sd_id_map = None
+        fd_sd_id_map = None
+    
+    return 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
+
+def init_DK_NHL_lineups(type_var, slate_var, prio_var, prio_mix, nhl_db_translation, lineup_num, player_var2):  
+
+    if prio_var == 'Mix':
+        prio_var = None
+    
+    if type_var == 'Classic':
+        if slate_var == 'Main':
+            collection = nhl_db['DK_NHL_name_map']
+            cursor = collection.find()
+            raw_data = pd.DataFrame(list(cursor))
+            names_dict = dict(zip(raw_data['key'], raw_data['value']))
+
+            collection = nhl_db['DK_NHL_seed_frame_Main Slate']
+            if prio_var == None:
+                if player_var2 != []:
+                    player_columns = ['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', '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=['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', 'FLEX'])
+
+            raw_display = raw_display[['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', 'FLEX']]
+            dict_columns = ['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', 'FLEX']
+            # Map names
+            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+        elif slate_var == 'Secondary':
+            collection = nhl_db['DK_NHL_Secondary_name_map']
+            cursor = collection.find()
+            raw_data = pd.DataFrame(list(cursor))
+            names_dict = dict(zip(raw_data['key'], raw_data['value']))
+            
+            collection = nhl_db['DK_NHL_seed_frame_Secondary Slate']
+            if prio_var == None:
+                if player_var2 != []:
+                    player_columns = ['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', '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=['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', 'FLEX'])
+
+            raw_display = raw_display[['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', 'FLEX']]
+            dict_columns = ['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', 'FLEX']
+            # Map names
+            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+        elif slate_var == 'Auxiliary':
+            collection = nhl_db['DK_NHL_Late_name_map']
+            cursor = collection.find()
+            raw_data = pd.DataFrame(list(cursor))
+            names_dict = dict(zip(raw_data['key'], raw_data['value']))
+            
+            collection = nhl_db['DK_NHL_seed_frame_Late Slate']
+            if prio_var == None:
+                if player_var2 != []:
+                    player_columns = ['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', '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=['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', 'FLEX'])
+
+            raw_display = raw_display[['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', 'FLEX']]
+            dict_columns = ['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', 'FLEX']
+            # Map names
+            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+    elif type_var == 'Showdown':
+        collection = nhl_db[nhl_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_NHL_lineups(type_var, slate_var, prio_var, prio_mix, nhl_db_translation, lineup_num, player_var2):
+
+    if prio_var == 'Mix':
+        prio_var = None
+    
+    if type_var == 'Classic':
+        if slate_var == 'Main':
+            collection = nhl_db['FD_NHL_name_map']
+            cursor = collection.find()
+            raw_data = pd.DataFrame(list(cursor))
+            names_dict = dict(zip(raw_data['key'], raw_data['value']))
+
+
+            collection = nhl_db['FD_NHL_seed_frame_Main Slate']
+            if prio_var == None:
+                if player_var2 != []:
+                    player_columns = ['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G']
+                    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=['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G'])
+
+            raw_display = raw_display[['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G']]
+            dict_columns = ['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G']
+            # Map names
+            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+        elif slate_var == 'Secondary':
+            collection = nhl_db['FD_NHL_Secondary_name_map']
+            cursor = collection.find()
+            raw_data = pd.DataFrame(list(cursor))
+            names_dict = dict(zip(raw_data['key'], raw_data['value']))
+
+            collection = nhl_db['FD_NHL_Secondary_seed_frame_Secondary Slate']
+            if prio_var == None:
+                if player_var2 != []:
+                    player_columns = ['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G']
+                    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=['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G'])
+
+            raw_display = raw_display[['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G']]
+            dict_columns = ['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G']
+            # Map names
+            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+        elif slate_var == 'Auxiliary':
+            collection = nhl_db['FD_NHL_Late_name_map']
+            cursor = collection.find()
+            raw_data = pd.DataFrame(list(cursor))
+            names_dict = dict(zip(raw_data['key'], raw_data['value']))
+
+            collection = nhl_db['FD_NHL_Late_seed_frame_Late Slate']
+            if prio_var == None:
+                if player_var2 != []:
+                    player_columns = ['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G']
+                    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=['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G'])
+
+            raw_display = raw_display[['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G']]
+            dict_columns = ['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G']
+            # Map names
+            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+
+    elif type_var == 'Showdown':
+        collection = nhl_db[nhl_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