database_queries.py

import pandas as pd
import numpy as np
import math
from database import *

# Probably should have done this in a dictionary to start with
wrong_nfl_team_names = ['Denver Broncos', 'Washington Commanders', 'Cincinnati Bengals', 'Arizona Cardinals', 'Los Angeles Rams', 'Pittsburgh Steelers',
'Jacksonville Jaguars', 'New England Patriots', 'Tampa Bay Buccaneers', 'San Francisco 49ers', 'Green Bay Packers', 'New York Jets',
'Indianapolis Colts', 'Miami Dolphins', 'Detroit Lions', 'Las Vegas Raiders', 'Atlanta Falcons', 'Seattle Seahawks', 'Houston Texans',
'New Orleans Saints', 'Carolina Panthers', 'New York Giants', 'Cleveland Browns', 'Tennessee Titans', 'Philadelphia Eagles', 'Dallas Cowboys',
'Kansas City Chiefs', 'Los Angeles Chargers', 'Baltimore Ravens', 'Buffalo Bills', 'Minnesota Vikings', 'Chicago Bears']
right_nfl_name_teams = ['Broncos', 'Commanders', 'Bengals', 'Cardinals', 'Rams', 'Steelers', 'Jaguars', 'Patriots', 'Buccaneers', '49ers', 'Packers', 
'Jets', 'Colts', 'Dolphins', 'Lions', 'Raiders', 'Falcons', 'Seahawks', 'Texans', 'Saints', 'Panthers', 'Giants', 'Browns', 'Titans', 'Eagles', 'Cowboys',
'Chiefs', 'Chargers', 'Ravens', 'Bills', 'Vikings', 'Bears']

def init_nfl_baselines(type_var: str):

    if type_var == 'Regular':
        collection = nfl_db["DK_NFL_ROO"] 
        cursor = collection.find()

        raw_display = pd.DataFrame(list(cursor))
        raw_display = raw_display.rename(columns={'player_ID': 'player_id'})
        raw_display = raw_display[['Player', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'exFPTS', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '2x%', '3x%', '4x%',
                                'Own', 'Small_Field_Own', 'Large_Field_Own', 'Cash_Field_Own', 'CPT_Own', 'LevX', 'version', 'slate', 'timestamp', 'player_id', 'site']]
        raw_display['Player'] = raw_display['Player'].map(dict(zip(wrong_nfl_team_names, right_nfl_name_teams)), na_action='ignore').fillna(raw_display['Player'])
        load_display = raw_display[raw_display['Position'] != 'K']
        dk_roo_raw = load_display.dropna(subset=['Median'])

        dk_id_map = dict(zip(dk_roo_raw['Player'], dk_roo_raw['player_id']))

        collection = nfl_db["FD_NFL_ROO"] 
        cursor = collection.find()

        raw_display = pd.DataFrame(list(cursor))
        raw_display = raw_display.rename(columns={'player_ID': 'player_id'})
        raw_display = raw_display[['Player', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'exFPTS', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '2x%', '3x%', '4x%',
                                'Own', 'Small_Field_Own', 'Large_Field_Own', 'Cash_Field_Own', 'CPT_Own', 'LevX', 'version', 'slate', 'timestamp', 'player_id', 'site']]
        raw_display['Player'] = raw_display['Player'].map(dict(zip(wrong_nfl_team_names, right_nfl_name_teams)), na_action='ignore').fillna(raw_display['Player'])
        load_display = raw_display[raw_display['Position'] != 'K']
        fd_roo_raw = load_display.dropna(subset=['Median'])

        fd_id_map = dict(zip(fd_roo_raw['Player'], fd_roo_raw['player_id']))

        dk_roo_raw = dk_roo_raw.drop(columns=['player_id'])
        fd_roo_raw = fd_roo_raw.drop(columns=['player_id'])

        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
    elif type_var == 'Showdown':
        collection = nfl_db["DK_SD_NFL_ROO"] 
        cursor = collection.find()

        raw_display = pd.DataFrame(list(cursor))
        raw_display = raw_display.rename(columns={'player_ID': 'player_id'})
        raw_display = raw_display[['Player', 'Position', 'Team', 'Salary', 'Median', 'Own', 'CPT_Own', 'player_id']]
        raw_display['Player'] = raw_display['Player'].map(dict(zip(wrong_nfl_team_names, right_nfl_name_teams)), na_action='ignore').fillna(raw_display['Player'])
        # load_display = raw_display[raw_display['Position'] != 'K']
        dk_sd_roo_raw = raw_display.dropna(subset=['Median'])

        dk_sd_id_map = dict(zip(dk_sd_roo_raw['Player'], dk_sd_roo_raw['player_id']))

        collection = nfl_db["FD_SD_NFL_ROO"] 
        cursor = collection.find()

        raw_display = pd.DataFrame(list(cursor))
        raw_display = raw_display.rename(columns={'player_ID': 'player_id'})
        raw_display = raw_display[['Player', 'Position', 'Team', 'Salary', 'Median', 'Own', 'CPT_Own', 'player_id']]
        raw_display['Player'] = raw_display['Player'].map(dict(zip(wrong_nfl_team_names, right_nfl_name_teams)), na_action='ignore').fillna(raw_display['Player'])
        # load_display = raw_display[raw_display['Position'] != 'K']
        fd_sd_roo_raw = raw_display.dropna(subset=['Median'])

        fd_sd_id_map = dict(zip(fd_sd_roo_raw['Player'], fd_sd_roo_raw['player_id']))

        dk_sd_roo_raw = dk_sd_roo_raw.drop(columns=['player_id'])
        fd_sd_roo_raw = fd_sd_roo_raw.drop(columns=['player_id'])

        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

    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_NFL_lineups(type_var, slate_var, prio_var, prio_mix, nfl_db_translation, lineup_num, player_var2):  

    if prio_var == 'Mix':
        prio_var = None
    
    if type_var == 'Classic':
        if slate_var == 'Main':
            collection = nfl_db['DK_NFL_name_map']
            cursor = collection.find()
            raw_data = pd.DataFrame(list(cursor))
            raw_data['value'] = raw_data['value'].map(dict(zip(wrong_nfl_team_names, right_nfl_name_teams)), na_action='ignore').fillna(raw_data['value'])
            names_dict = dict(zip(raw_data['key'], raw_data['value']))

            collection = nfl_db['DK_NFL_seed_frame_Main Slate']
            if prio_var == None:
                if player_var2 != []:
                    player_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
                    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=['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST'])

            raw_display = raw_display[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']]
            dict_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
            # Map names
            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
        elif slate_var == 'Secondary':
            collection = nfl_db['DK_NFL_Secondary_name_map']
            cursor = collection.find()
            raw_data = pd.DataFrame(list(cursor))
            raw_data['value'] = raw_data['value'].map(dict(zip(wrong_nfl_team_names, right_nfl_name_teams)), na_action='ignore').fillna(raw_data['value'])
            names_dict = dict(zip(raw_data['key'], raw_data['value']))
            
            collection = nfl_db['DK_NFL_seed_frame_Secondary Slate']
            if prio_var == None:
                if player_var2 != []:
                    player_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
                    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=['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST'])

            raw_display = raw_display[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']]
            dict_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
            # Map names
            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
        elif slate_var == 'Auxiliary':
            collection = nfl_db['DK_NFL_Late_name_map']
            cursor = collection.find()
            raw_data = pd.DataFrame(list(cursor))
            raw_data['value'] = raw_data['value'].map(dict(zip(wrong_nfl_team_names, right_nfl_name_teams)), na_action='ignore').fillna(raw_data['value'])
            names_dict = dict(zip(raw_data['key'], raw_data['value']))
            
            collection = nfl_db['DK_NFL_seed_frame_Late Slate']
            if prio_var == None:
                if player_var2 != []:
                    player_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
                    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=['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST'])

            raw_display = raw_display[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']]
            dict_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
            # Map names
            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
    elif type_var == 'Showdown':
        collection = nfl_db[nfl_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']]
        for column in ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5']:
            raw_display[column] = raw_display[column].map(dict(zip(wrong_nfl_team_names, right_nfl_name_teams)), na_action='ignore').fillna(raw_display[column])

    DK_seed = raw_display.to_numpy()

    return DK_seed

def init_FD_NFL_lineups(type_var, slate_var, prio_var, prio_mix, nfl_db_translation, lineup_num, player_var2):

    if prio_var == 'Mix':
        prio_var = None
    
    if type_var == 'Classic':
        if slate_var == 'Main':
            collection = nfl_db['FD_NFL_name_map']
            cursor = collection.find()
            raw_data = pd.DataFrame(list(cursor))
            raw_data['value'] = raw_data['value'].map(dict(zip(wrong_nfl_team_names, right_nfl_name_teams)), na_action='ignore').fillna(raw_data['value'])
            names_dict = dict(zip(raw_data['key'], raw_data['value']))


            collection = nfl_db['FD_NFL_seed_frame_Main Slate']
            if prio_var == None:
                if player_var2 != []:
                    player_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
                    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=['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST'])

            raw_display = raw_display[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']]
            dict_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
            # Map names
            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
        elif slate_var == 'Secondary':
            collection = nfl_db['FD_NFL_Secondary_name_map']
            cursor = collection.find()
            raw_data = pd.DataFrame(list(cursor))
            raw_data['value'] = raw_data['value'].map(dict(zip(wrong_nfl_team_names, right_nfl_name_teams)), na_action='ignore').fillna(raw_data['value'])
            names_dict = dict(zip(raw_data['key'], raw_data['value']))

            collection = nfl_db['FD_NFL_Secondary_seed_frame_Secondary Slate']
            if prio_var == None:
                if player_var2 != []:
                    player_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
                    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=['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST'])

            raw_display = raw_display[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']]
            dict_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
            # Map names
            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
        elif slate_var == 'Auxiliary':
            collection = nfl_db['FD_NFL_Late_name_map']
            cursor = collection.find()
            raw_data = pd.DataFrame(list(cursor))
            raw_data['value'] = raw_data['value'].map(dict(zip(wrong_nfl_team_names, right_nfl_name_teams)), na_action='ignore').fillna(raw_data['value'])
            names_dict = dict(zip(raw_data['key'], raw_data['value']))

            collection = nfl_db['FD_NFL_Late_seed_frame_Late Slate']
            if prio_var == None:
                if player_var2 != []:
                    player_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
                    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=['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST'])

            raw_display = raw_display[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']]
            dict_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
            # Map names
            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))

    elif type_var == 'Showdown':
        collection = nfl_db[nfl_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']]
        for column in ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5']:
            raw_display[column] = raw_display[column].map(dict(zip(wrong_nfl_team_names, right_nfl_name_teams)), na_action='ignore').fillna(raw_display[column])

    FD_seed = raw_display.to_numpy()

    return FD_seed