Adding WNBA support

app.py

@@ -546,6 +546,51 @@ def define_fd_nfl_showdown_slates():
     slate_name_lookup = dict(zip(slate_names, unique_slates))
     return slate_names, slate_name_lookup
 
+def grab_wnba_reg_salaries(slate_var: str):
+    collection = salaries_db["WNBA_reg_player_info"]
+    eastern = pytz.timezone('US/Eastern')
+    today_str = datetime.now(eastern).strftime("%Y%m%d")
+    records = pd.DataFrame(list(collection.find({'Contest Date': {'$gte': today_str}})))
+    records = records[['Display Name', 'draftableId', 'Position', 'Salary']]
+    records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'})
+    if slate_var == 'Main':
+        records = records.sort_values(by='ID', ascending=True)
+        records = records.drop_duplicates(subset=['Name'], keep='first')
+    elif slate_var == 'Secondary':
+        records = records.sort_values(by='ID', ascending=True)
+        # Keep middle occurrence: drop first and last, keep middle
+        grouped = records.groupby('Name')
+        middle_records = []
+        for name, group in grouped:
+            if len(group) == 1:
+                # Only one record, keep it
+                middle_records.append(group)
+            elif len(group) == 2:
+                # Two records, keep the second one (last)
+                middle_records.append(group.iloc[1:2])
+            else:
+                # Three or more records, keep the middle one(s)
+                # For odd number of records, keep the true middle
+                # For even number of records, keep the record at index len//2
+                middle_idx = len(group) // 2
+                middle_records.append(group.iloc[middle_idx:middle_idx+1])
+        records = pd.concat(middle_records, ignore_index=True)
+    elif slate_var == 'Auxiliary':
+        records = records.sort_values(by='ID', ascending=True)
+        records = records.drop_duplicates(subset=['Name'], keep='last')
+    return records
+
+def grab_wnba_showdown_salaries():
+    collection = salaries_db["WNBA_showdown_player_info"]
+    # Get current time in Eastern Time (handles EST/EDT automatically)
+    eastern = pytz.timezone('US/Eastern')
+    today_str = datetime.now(eastern).strftime("%Y%m%d")
+    print(f"Current date in Eastern Time: {today_str}")
+    records = pd.DataFrame(list(collection.find({'Contest Date': {'$gte': today_str}})))
+    records = records[['Display Name', 'draftableId', 'Position', 'Salary']]
+    records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'})
+    return records
+
 try:
     nfl_slate_names_dk, nfl_slate_name_lookup_dk = define_dk_nfl_showdown_slates()
 except:
@@ -1282,7 +1327,7 @@ with st.container():
         site_var = st.selectbox("Select Site", ['Draftkings', 'Fanduel'])
 
     with col3:
-        sport_var = st.selectbox("Select Sport", ['MLB', 'NBA', 'NHL', 'MMA', 'NASCAR', 'GOLF', 'NFL'], key='sport_var')
+        sport_var = st.selectbox("Select Sport", ['MLB', 'NBA', 'NHL', 'MMA', 'NASCAR', 'GOLF', 'NFL', 'WNBA'], key='sport_var')
         
     with col4:
         type_var = st.selectbox("Select Game Type", ['Classic', 'Showdown'])
@@ -1340,6 +1385,8 @@ with st.container():
             if site_var == 'Draftkings':
                 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 == 'WNBA':
+                    slate_var3 = st.radio("Which slate data are you loading?", (wnba_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')
                 elif sport_var == 'NHL':
@@ -1357,6 +1404,8 @@ with st.container():
             elif site_var == 'Fanduel':
                 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 == 'WNBA':
+                    slate_var3 = st.radio("Which slate data are you loading?", (wnba_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')
                 elif sport_var == 'NHL':
@@ -1383,6 +1432,9 @@ with st.container():
                 elif sport_var == 'MLB':
                     salary_min_var = st.number_input("Minimum salary used", min_value = 0, max_value = 35000, value = 34000, step = 100, key = 'salary_min_var_fd')
                     salary_max_var = st.number_input("Maximum salary used", min_value = 0, max_value = 35000, value = 35000, step = 100, key = 'salary_max_var_fd')
+                elif sport_var == 'WNBA':
+                    salary_min_var = st.number_input("Minimum salary used", min_value = 0, max_value = 40000, value = 39000, step = 100, key = 'salary_min_var_fd')
+                    salary_max_var = st.number_input("Maximum salary used", min_value = 0, max_value = 40000, value = 40000, step = 100, key = 'salary_max_var_fd')
                 else:
                     salary_min_var = st.number_input("Minimum salary used", min_value = 0, max_value = 60000, value = 59000, step = 100, key = 'salary_min_var_fd')
                     salary_max_var = st.number_input("Maximum salary used", min_value = 0, max_value = 60000, value = 60000, step = 100, key = 'salary_max_var_fd')
@@ -1457,6 +1509,14 @@ with st.container():
         mlb_showdown_salaries = grab_mlb_showdown_salaries()
     except:
         mlb_showdown_salaries = None
+    try:
+        wnba_reg_salaries = grab_wnba_reg_salaries(slate_var3)
+    except:
+        wnba_reg_salaries = None
+    try:
+        wnba_showdown_salaries = grab_wnba_showdown_salaries()
+    except:
+        wnba_showdown_salaries = None
 
 try:
     selected_tab = st.segmented_control(
@@ -1675,6 +1735,8 @@ if selected_tab == 'Data Load':
                         if type_var != 'Showdown':
                             if sport_var == 'NBA':
                                 portfolio_load = init_DK_NBA_lineups(type_var, slate_var3, prio_var, prio_mix, dk_nba_showdown_db_translation, lineup_num_var, salary_min_var, salary_max_var, min_stacks_var, max_stacks_var, min_secondary_stacks_var, max_secondary_stacks_var, [])
+                            elif sport_var == 'WNBA':
+                                portfolio_load = init_DK_WNBA_lineups(type_var, slate_var3, prio_var, prio_mix, dk_wnba_showdown_db_translation, lineup_num_var, salary_min_var, salary_max_var, min_stacks_var, max_stacks_var, min_secondary_stacks_var, max_secondary_stacks_var, [])
                             elif sport_var == 'NFL':
                                 portfolio_load = init_DK_NFL_lineups(type_var, slate_var3, prio_var, prio_mix, dk_nfl_showdown_db_translation, lineup_num_var, salary_min_var, salary_max_var, min_stacks_var, max_stacks_var, min_secondary_stacks_var, max_secondary_stacks_var, [])
                             elif sport_var == 'NHL':
@@ -1690,6 +1752,8 @@ if selected_tab == 'Data Load':
                         else:
                             if sport_var == 'NBA':
                                 portfolio_load = init_DK_NBA_lineups(type_var, nba_slate_name_lookup_dk[slate_var3], prio_var, prio_mix, dk_nba_showdown_db_translation, lineup_num_var, salary_min_var, salary_max_var, min_stacks_var, max_stacks_var, min_secondary_stacks_var, max_secondary_stacks_var, [])
+                            elif sport_var == 'WNBA':
+                                portfolio_load = init_DK_WNBA_lineups(type_var, wnba_slate_name_lookup_dk[slate_var3], prio_var, prio_mix, dk_wnba_showdown_db_translation, lineup_num_var, salary_min_var, salary_max_var, min_stacks_var, max_stacks_var, min_secondary_stacks_var, max_secondary_stacks_var, [])
                             elif sport_var == 'NFL':
                                 portfolio_load = init_DK_NFL_lineups(type_var, nfl_slate_name_lookup_dk[slate_var3], prio_var, prio_mix, dk_nfl_showdown_db_translation, lineup_num_var, salary_min_var, salary_max_var, min_stacks_var, max_stacks_var, min_secondary_stacks_var, max_secondary_stacks_var, [])
                             elif sport_var == 'NHL':
@@ -1714,6 +1778,8 @@ if selected_tab == 'Data Load':
                             ## Testing something here
                             if sport_var == 'NBA':
                                 portfolio_load = init_FD_NBA_lineups(type_var, slate_var3, prio_var, prio_mix, fd_nba_showdown_db_translation, lineup_num_var, salary_min_var, salary_max_var, min_stacks_var, max_stacks_var, min_secondary_stacks_var, max_secondary_stacks_var, [])
+                            elif sport_var == 'WNBA':
+                                portfolio_load = init_FD_WNBA_lineups(type_var, slate_var3, prio_var, prio_mix, fd_wnba_showdown_db_translation, lineup_num_var, salary_min_var, salary_max_var, min_stacks_var, max_stacks_var, min_secondary_stacks_var, max_secondary_stacks_var, [])
                             elif sport_var == 'NFL':
                                 portfolio_load = init_FD_NFL_lineups(type_var, slate_var3, prio_var, prio_mix, fd_nfl_showdown_db_translation, lineup_num_var, salary_min_var, salary_max_var, min_stacks_var, max_stacks_var, min_secondary_stacks_var, max_secondary_stacks_var, [])
                             elif sport_var == 'NHL':
@@ -1729,6 +1795,8 @@ if selected_tab == 'Data Load':
                         else:
                             if sport_var == 'NBA':
                                 portfolio_load = init_FD_NBA_lineups(type_var, nba_slate_name_lookup_fd[slate_var3], prio_var, prio_mix, fd_nba_showdown_db_translation, lineup_num_var, salary_min_var, salary_max_var, min_stacks_var, max_stacks_var, min_secondary_stacks_var, max_secondary_stacks_var, [])
+                            elif sport_var == 'WNBA':
+                                portfolio_load = init_FD_WNBA_lineups(type_var, wnba_slate_name_lookup_fd[slate_var3], prio_var, prio_mix, fd_wnba_showdown_db_translation, lineup_num_var, salary_min_var, salary_max_var, min_stacks_var, max_stacks_var, min_secondary_stacks_var, max_secondary_stacks_var, [])
                             elif sport_var == 'NFL':
                                 portfolio_load = init_FD_NFL_lineups(type_var, nfl_slate_name_lookup_fd[slate_var3], prio_var, prio_mix, fd_nfl_showdown_db_translation, lineup_num_var, salary_min_var, salary_max_var, min_stacks_var, max_stacks_var, min_secondary_stacks_var, max_secondary_stacks_var, [])
                             elif sport_var == 'NHL':
@@ -2054,8 +2122,36 @@ if selected_tab == 'Data Load':
                                     st.session_state['locked_teams_list'] = None
                                     grid_map = None
                                     opp_map = None
+                        elif sport_var == 'WNBA':
+                            if site_var == 'Draftkings':
+                                if type_var == 'Classic':
+                                    projections_file = init_wnba_baselines(type_var, site_var, slate_var3)[0]
+                                    minutes_map = None
+                                    st.session_state['locked_teams_list'] = None
+                                    grid_map = None
+                                    opp_map = None
+                                elif type_var == 'Showdown':
+                                    projections_file = init_wnba_baselines(type_var, site_var, slate_var3)[2]
+                                    minutes_map = None
+                                    st.session_state['locked_teams_list'] = None
+                                    grid_map = None
+                                    opp_map = None
+                            elif site_var == 'Fanduel':
+                                if type_var == 'Classic':
+                                    projections_file = init_wnba_baselines(type_var, site_var, slate_var3)[1]
+                                    minutes_map = None
+                                    st.session_state['locked_teams_list'] = None
+                                    grid_map = None
+                                    opp_map = None
+                                elif type_var == 'Showdown':
+                                    projections_file = init_wnba_baselines(type_var, site_var, slate_var3)[3]
+                                    minutes_map = None
+                                    st.session_state['locked_teams_list'] = None
+                                    grid_map = None
+                                    opp_map = None
                         st.session_state['db_projections_file'] = projections_file
                         st.session_state['projections_loaded'] = True
+                    
                 if 'projections_df' in st.session_state:
                     del st.session_state['projections_df']
             

database.py

@@ -12,12 +12,13 @@ def init_conn():
         salaries_db = client['Contest_Information']
         nfl_db = client["NFL_Database"]
         nba_db = client["NBA_Database"]
+        wnba_db = client["WNBA_DFS"]
         mlb_db = client["MLB_Database"]
         nhl_db = client["NHL_Database"]
         mma_db = client["MMA_Database"]
         pga_db = client["PGA_Database"]
         nascar_db = client['NASCAR_Database']
 
-        return nfl_db, salaries_db, nba_db, mlb_db, nhl_db, mma_db, pga_db, nascar_db
+        return nfl_db, salaries_db, nba_db, wnba_db, mlb_db, nhl_db, mma_db, pga_db, nascar_db
     
-nfl_db, salaries_db, nba_db, mlb_db, nhl_db, mma_db, pga_db, nascar_db = init_conn()
+nfl_db, salaries_db, nba_db, wnba_db, mlb_db, nhl_db, mma_db, pga_db, nascar_db = init_conn()

database_queries.py

@@ -2952,6 +2952,526 @@ def init_FD_PGA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
 
     return FD_seed
 
+def init_wnba_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 = wnba_db["Player_SD_Range_Of_Outcomes"]
+        cursor = collection.find()
+
+        raw_display = pd.DataFrame(list(cursor))
+        raw_display = raw_display[['Player', 'Position', 'Team', 'Salary', 'Minutes Proj', '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)
+
+        minutes_map = dict(zip(sd_raw['Player'], sd_raw['Minutes Proj']))
+        locked_teams_list = None
+
+        dk_sd_roo_raw = dk_sd_roo_raw.drop(columns=['player_ID', 'slate', 'version', 'timestamp', 'site', 'Minutes Proj'])
+        fd_sd_roo_raw = fd_sd_roo_raw.drop(columns=['player_ID', 'slate', 'version', 'timestamp', 'site', 'Minutes Proj'])
+
+        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 = wnba_db["Player_Range_Of_Outcomes"]
+        cursor = collection.find()
+
+        raw_display = pd.DataFrame(list(cursor))
+        raw_display = raw_display[['Player', 'Position', 'Team', 'Salary', 'Minutes Proj', 'Median', 'Own', 'CPT_Own', 'player_id', 'slate', 'site', 'version', '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]
+        raw_display = raw_display[raw_display['slate'] == slate_var]
+        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')
+
+        minutes_map = dict(zip(raw_display['Player'], raw_display['Minutes Proj']))
+        
+        dk_roo_raw = dk_roo_raw.drop(columns=['player_ID', 'slate', 'version', 'timestamp', 'site', 'Minutes Proj'])
+        fd_roo_raw = fd_roo_raw.drop(columns=['player_ID', 'slate', 'version', 'timestamp', 'site', 'Minutes Proj'])
+
+        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'})
+
+        collection = wnba_db["Live_Projections"]
+        cursor = collection.find()
+
+        raw_display = pd.DataFrame(list(cursor))
+        locked_teams_frame = raw_display[raw_display['Locked'] == 1]
+        live_dict = dict(zip(raw_display['Player'], raw_display['Live_Proj']))
+        live_median_dict = dict(zip(raw_display['Player'], raw_display['Median']))
+        locked_teams_dict = dict(zip(locked_teams_frame['Team'], locked_teams_frame['Locked']))
+        locked_teams_list = list(locked_teams_dict.keys())
+
+        dk_roo_raw['median'] = dk_roo_raw['player_names'].map(live_dict)
+        fd_roo_raw['median'] = fd_roo_raw['player_names'].map(live_dict)
+
+        dk_roo_raw['median'] = np.where(dk_roo_raw['median'] == 0, dk_roo_raw['player_names'].map(live_median_dict), dk_roo_raw['median'])
+        fd_roo_raw['median'] = np.where(fd_roo_raw['median'] == 0, fd_roo_raw['player_names'].map(live_median_dict), fd_roo_raw['median'])
+
+        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, minutes_map, locked_teams_list
+
+def init_DK_WNBA_lineups(type_var, slate_var, prio_var, prio_mix, wnba_db_translation, lineup_num, salary_min, salary_max, team_count_min, team_count_max, secondary_team_count_min, secondary_team_count_max, player_var2):
+
+    if prio_var == 'Mix':
+        prio_var = None
+    
+    if type_var == 'Classic':
+        if slate_var == 'Main':
+            collection = wnba_db['DK_WNBA_name_map']
+            cursor = collection.find()
+            raw_data = pd.DataFrame(list(cursor))
+            names_dict = dict(zip(raw_data['key'], raw_data['value']))
+
+            collection = wnba_db['DK_WNBA_seed_frame']
+            if prio_var == None:
+                if player_var2 != []:
+                    player_columns = ['G1', 'G2', 'F1', 'F2', 'F3', 'UTIL']
+                    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({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max},
+                        'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                        'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                        }]}).sort('proj', -1).limit(_mix_seed_limit_primary(lineup_num, prio_mix))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max},
+                        'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                        'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                        }]}).sort('Own', -1).limit(_mix_seed_limit_secondary(lineup_num, prio_mix))
+                    else:
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                        'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                        }).sort('proj', -1).limit(_mix_seed_limit_primary(lineup_num, prio_mix))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                        'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                        }).sort('Own', -1).limit(_mix_seed_limit_secondary(lineup_num, prio_mix))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+                else:
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                    'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                    }).sort('proj', -1).limit(_mix_seed_limit_primary(lineup_num, prio_mix))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                    'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                    }).sort('Own', -1).limit(_mix_seed_limit_secondary(lineup_num, prio_mix))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                }).sort(prio_var, -1).limit(lineup_num)
+                raw_display = pd.DataFrame(list(cursor))
+            
+            raw_display = raw_display.drop_duplicates(subset=['G1', 'G2', 'F1', 'F2', 'F3', 'UTIL'])
+            raw_display = raw_display.head(lineup_num)
+
+            raw_display = raw_display[['G1', 'G2', 'F1', 'F2', 'F3', 'UTIL']]
+            dict_columns = ['G1', 'G2', 'F1', 'F2', 'F3', 'UTIL']
+            # Map names
+            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+        elif slate_var == 'Secondary':
+            collection = wnba_db['DK_WNBA_Secondary_name_map']
+            cursor = collection.find()
+            raw_data = pd.DataFrame(list(cursor))
+            names_dict = dict(zip(raw_data['key'], raw_data['value']))
+            
+            collection = wnba_db['DK_WNBA_Secondary_seed_frame']
+            if prio_var == None:
+                if player_var2 != []:
+                    player_columns = ['G1', 'G2', 'F1', 'F2', 'F3', 'UTIL']
+                    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({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max},
+                        'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                        'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                        }]}).sort('proj', -1).limit(_mix_seed_limit_primary(lineup_num, prio_mix))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max},
+                        'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                        'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                        }]}).sort('Own', -1).limit(_mix_seed_limit_secondary(lineup_num, prio_mix))
+                    else:
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                        'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                        }).sort('proj', -1).limit(_mix_seed_limit_primary(lineup_num, prio_mix))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                        'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                        }).sort('Own', -1).limit(_mix_seed_limit_secondary(lineup_num, prio_mix))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+                else:
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                    'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                    }).sort('proj', -1).limit(_mix_seed_limit_primary(lineup_num, prio_mix))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                    'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                    }).sort('Own', -1).limit(_mix_seed_limit_secondary(lineup_num, prio_mix))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                }).sort(prio_var, -1).limit(lineup_num)
+                raw_display = pd.DataFrame(list(cursor))
+
+            raw_display = raw_display.drop_duplicates(subset=['G1', 'G2', 'F1', 'F2', 'F3', 'UTIL'])
+            raw_display = raw_display.head(lineup_num)
+
+            raw_display = raw_display[['G1', 'G2', 'F1', 'F2', 'F3', 'UTIL']]
+            dict_columns = ['G1', 'G2', 'F1', 'F2', 'F3', 'UTIL']
+            # Map names
+            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+        elif slate_var == 'Auxiliary':
+            collection = wnba_db['DK_WNBA_Late_name_map']
+            cursor = collection.find()
+            raw_data = pd.DataFrame(list(cursor))
+            names_dict = dict(zip(raw_data['key'], raw_data['value']))
+            
+            collection = wnba_db['DK_WNBA_Late_seed_frame']
+            if prio_var == None:
+                if player_var2 != []:
+                    player_columns = ['G1', 'G2', 'F1', 'F2', 'F3', 'UTIL']
+                    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({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max},
+                        'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                        'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                        }]}).sort('proj', -1).limit(_mix_seed_limit_primary(lineup_num, prio_mix))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max},
+                        'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                        'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                        }]}).sort('Own', -1).limit(_mix_seed_limit_secondary(lineup_num, prio_mix))
+                    else:
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                        'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                        }).sort('proj', -1).limit(_mix_seed_limit_primary(lineup_num, prio_mix))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                        'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                        }).sort('Own', -1).limit(_mix_seed_limit_secondary(lineup_num, prio_mix))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+                else:
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                    'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                    }).sort('proj', -1).limit(_mix_seed_limit_primary(lineup_num, prio_mix))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                    'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                    }).sort('Own', -1).limit(_mix_seed_limit_secondary(lineup_num, prio_mix))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                }).sort(prio_var, -1).limit(lineup_num)
+                raw_display = pd.DataFrame(list(cursor))
+
+            raw_display = raw_display.drop_duplicates(subset=['G1', 'G2', 'F1', 'F2', 'F3', 'UTIL'])
+            raw_display = raw_display.head(lineup_num)
+
+            raw_display = raw_display[['G1', 'G2', 'F1', 'F2', 'F3', 'UTIL']]
+            dict_columns = ['G1', 'G2', 'F1', 'F2', 'F3', 'UTIL']
+            # Map names
+            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+    elif type_var == 'Showdown':
+        collection = wnba_db[wnba_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(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max, secondary_team_count_min, secondary_team_count_max)).sort('proj', -1).limit(_mix_seed_limit_primary(lineup_num, prio_mix))
+                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max, secondary_team_count_min, secondary_team_count_max)).sort('Own', -1).limit(_mix_seed_limit_secondary(lineup_num, prio_mix))
+                else:
+                    cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max, secondary_team_count_min, secondary_team_count_max)).sort('proj', -1).limit(_mix_seed_limit_primary(lineup_num, prio_mix))
+                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max, secondary_team_count_min, secondary_team_count_max)).sort('Own', -1).limit(_mix_seed_limit_secondary(lineup_num, prio_mix))
+                raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max, secondary_team_count_min, secondary_team_count_max)).sort('proj', -1).limit(_mix_seed_limit_primary(lineup_num, prio_mix))
+                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max, secondary_team_count_min, secondary_team_count_max)).sort('Own', -1).limit(_mix_seed_limit_secondary(lineup_num, prio_mix))
+                raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+        else:
+            cursor = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max, secondary_team_count_min, secondary_team_count_max)).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.head(lineup_num)
+
+        raw_display = raw_display[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5']]
+
+    DK_seed = raw_display.to_numpy()
+
+    return DK_seed
+
+def init_FD_WNBA_lineups(type_var, slate_var, prio_var, prio_mix, wnba_db_translation, lineup_num, salary_min, salary_max, team_count_min, team_count_max, secondary_team_count_min, secondary_team_count_max, player_var2):
+
+    if prio_var == 'Mix':
+        prio_var = None
+    
+    if type_var == 'Classic':
+        if slate_var == 'Main':
+            collection = wnba_db['FD_WNBA_name_map']
+            cursor = collection.find()
+            raw_data = pd.DataFrame(list(cursor))
+            names_dict = dict(zip(raw_data['key'], raw_data['value']))
+
+
+            collection = wnba_db['FD_WNBA_seed_frame']
+            if prio_var == None:
+                if player_var2 != []:
+                    player_columns = ['G1', 'G2', 'G3', 'F1', 'F2', 'F3', 'F4']
+                    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({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max},
+                        'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                        'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                        }]}).sort('proj', -1).limit(_mix_seed_limit_primary(lineup_num, prio_mix))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max},
+                        'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                        'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                        }]}).sort('Own', -1).limit(_mix_seed_limit_secondary(lineup_num, prio_mix))
+                    else:
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                        'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                        }).sort('proj', -1).limit(_mix_seed_limit_primary(lineup_num, prio_mix))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                        'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                        }).sort('Own', -1).limit(_mix_seed_limit_secondary(lineup_num, prio_mix))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+                else:
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                    'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                    }).sort('proj', -1).limit(_mix_seed_limit_primary(lineup_num, prio_mix))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                    'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                    }).sort('Own', -1).limit(_mix_seed_limit_secondary(lineup_num, prio_mix))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                }).sort(prio_var, -1).limit(lineup_num)
+                raw_display = pd.DataFrame(list(cursor))
+
+            raw_display = raw_display.drop_duplicates(subset=['G1', 'G2', 'G3', 'F1', 'F2', 'F3', 'F4'])
+            raw_display = raw_display.head(lineup_num)
+
+            raw_display = raw_display[['G1', 'G2', 'G3', 'F1', 'F2', 'F3', 'F4']]
+            dict_columns = ['G1', 'G2', 'G3', 'F1', 'F2', 'F3', 'F4']
+            # Map names
+            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+        elif slate_var == 'Secondary':
+            collection = wnba_db['FD_WNBA_Secondary_name_map']
+            cursor = collection.find()
+            raw_data = pd.DataFrame(list(cursor))
+            names_dict = dict(zip(raw_data['key'], raw_data['value']))
+
+            collection = wnba_db['FD_WNBA_Secondary_seed_frame']
+            if prio_var == None:
+                if player_var2 != []:
+                    player_columns = ['G1', 'G2', 'G3', 'F1', 'F2', 'F3', 'F4']
+                    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({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max},
+                        'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                        'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                        }]}).sort('proj', -1).limit(_mix_seed_limit_primary(lineup_num, prio_mix))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max},
+                        'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                        'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                        }]}).sort('Own', -1).limit(_mix_seed_limit_secondary(lineup_num, prio_mix))
+                    else:
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                        'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                        }).sort('proj', -1).limit(_mix_seed_limit_primary(lineup_num, prio_mix))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                        'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                        }).sort('Own', -1).limit(_mix_seed_limit_secondary(lineup_num, prio_mix))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+                else:
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                    'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                    }).sort('proj', -1).limit(_mix_seed_limit_primary(lineup_num, prio_mix))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                    'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                    }).sort('Own', -1).limit(_mix_seed_limit_secondary(lineup_num, prio_mix))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                }).sort(prio_var, -1).limit(lineup_num)
+                raw_display = pd.DataFrame(list(cursor))
+
+            raw_display = raw_display.drop_duplicates(subset=['G1', 'G2', 'G3', 'F1', 'F2', 'F3', 'F4'])
+            raw_display = raw_display.head(lineup_num)
+
+            raw_display = raw_display[['G1', 'G2', 'G3', 'F1', 'F2', 'F3', 'F4']]
+            dict_columns = ['G1', 'G2', 'G3', 'F1', 'F2', 'F3', 'F4']
+            # Map names
+            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+        elif slate_var == 'Auxiliary':
+            collection = wnba_db['FD_WNBA_Late_name_map']
+            cursor = collection.find()
+            raw_data = pd.DataFrame(list(cursor))
+            names_dict = dict(zip(raw_data['key'], raw_data['value']))
+
+            collection = wnba_db['FD_WNBA_Late_seed_frame']
+            if prio_var == None:
+                if player_var2 != []:
+                    player_columns = ['G1', 'G2', 'G3', 'F1', 'F2', 'F3', 'F4']
+                    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({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max},
+                        'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                        'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                        }]}).sort('proj', -1).limit(_mix_seed_limit_primary(lineup_num, prio_mix))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max},
+                        'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                        'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                        }]}).sort('Own', -1).limit(_mix_seed_limit_secondary(lineup_num, prio_mix))
+                    else:
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                        'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                        }).sort('proj', -1).limit(_mix_seed_limit_primary(lineup_num, prio_mix))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                        'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                        }).sort('Own', -1).limit(_mix_seed_limit_secondary(lineup_num, prio_mix))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+                else:
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                    'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                    }).sort('proj', -1).limit(_mix_seed_limit_primary(lineup_num, prio_mix))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                    'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                    }).sort('Own', -1).limit(_mix_seed_limit_secondary(lineup_num, prio_mix))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
+                'Secondary_count': {'$gte': secondary_team_count_min if secondary_team_count_min is not None else 1, '$lte': secondary_team_count_max if secondary_team_count_max is not None else 999},
+                }).sort(prio_var, -1).limit(lineup_num)
+                raw_display = pd.DataFrame(list(cursor))
+
+            raw_display = raw_display.drop_duplicates(subset=['G1', 'G2', 'G3', 'F1', 'F2', 'F3', 'F4'])
+            raw_display = raw_display.head(lineup_num)
+
+            raw_display = raw_display[['G1', 'G2', 'G3', 'F1', 'F2', 'F3', 'F4']]
+            dict_columns = ['G1', 'G2', 'G3', 'F1', 'F2', 'F3', 'F4']
+            # Map names
+            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+
+    elif type_var == 'Showdown':
+        collection = wnba_db[wnba_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(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max, secondary_team_count_min, secondary_team_count_max)).sort('proj', -1).limit(_mix_seed_limit_primary(lineup_num, prio_mix))
+                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max, secondary_team_count_min, secondary_team_count_max)).sort('Own', -1).limit(_mix_seed_limit_secondary(lineup_num, prio_mix))
+                else:
+                    cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max, secondary_team_count_min, secondary_team_count_max)).sort('proj', -1).limit(_mix_seed_limit_primary(lineup_num, prio_mix))
+                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max, secondary_team_count_min, secondary_team_count_max)).sort('Own', -1).limit(_mix_seed_limit_secondary(lineup_num, prio_mix))
+                raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max, secondary_team_count_min, secondary_team_count_max)).sort('proj', -1).limit(_mix_seed_limit_primary(lineup_num, prio_mix))
+                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max, secondary_team_count_min, secondary_team_count_max)).sort('Own', -1).limit(_mix_seed_limit_secondary(lineup_num, prio_mix))
+                raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+        else:
+            cursor = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max, secondary_team_count_min, secondary_team_count_max)).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.head(lineup_num)
+
+        raw_display = raw_display[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5']]
+
+    FD_seed = raw_display.to_numpy()
+
+    return FD_seed
+
 def init_nascar_baselines(type_var: str, site_var: str, slate_var: str):
 
     if slate_var == 'Main':