database_queries.py

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

# 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, 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 == 'Classic':
        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', 'Salary', 'Median', 'Own', 'CPT_Own','player_id', 'slate', 'version']]
        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_roo_raw = dk_roo_raw[dk_roo_raw['version'] == 'overall']
        dk_roo_raw = dk_roo_raw[dk_roo_raw['slate'] == slate_var]

        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', 'Salary', 'Median', 'Own', 'CPT_Own','player_id', 'slate', 'version']]
        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_roo_raw = fd_roo_raw[fd_roo_raw['version'] == 'overall']
        fd_roo_raw = fd_roo_raw[fd_roo_raw['slate'] == slate_var]

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

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

        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', 'slate']]
        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_roo_raw['Salary'] = dk_sd_roo_raw['Salary'] / 1.5

        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', 'slate']]
        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_roo_raw['Salary'] = fd_sd_roo_raw['Salary'] / 1.5

        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', 'slate'])
        fd_sd_roo_raw = fd_sd_roo_raw.drop(columns=['player_id', 'slate'])

        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, salary_min, salary_max, 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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                    else:
                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                    else:
                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                    else:
                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                else:
                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_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[['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, salary_min, salary_max, 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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                    else:
                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                    else:
                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num = ((100 - prio_mix) / 100)))
                    else:
                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                else:
                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_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[['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

def init_nba_baselines(type_var: str, site_var: str, slate_var: str):

    if slate_var == 'Main':
        slate_var = 'Main Slate'
    elif slate_var == 'Secondary':
        slate_var = 'Secondary Slate'
    elif slate_var == 'Auxiliary':
        slate_var = 'Late Slate'

    if type_var == 'Showdown':
        collection = nba_db["Player_SD_Range_Of_Outcomes"]
        cursor = collection.find()

        raw_display = pd.DataFrame(list(cursor))
        raw_display = raw_display[['Player', 'Position', 'Team', 'Salary', 'Median', 'Own', 'CPT_Own', 'player_id', 'slate', '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 = nba_db["Player_Range_Of_Outcomes"]
        cursor = collection.find()

        raw_display = pd.DataFrame(list(cursor))
        raw_display = raw_display[['Player', 'Position', 'Team', 'Salary', 'Median', 'Own', 'CPT_Own', 'player_id', 'slate', '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]
        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', 'version', 'timestamp', 'site'])
        fd_roo_raw = fd_roo_raw.drop(columns=['player_ID', 'slate', 'version', '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_NBA_lineups(type_var, slate_var, prio_var, prio_mix, nba_db_translation, lineup_num, salary_min, salary_max, player_var2):

    if prio_var == 'Mix':
        prio_var = None
    
    if type_var == 'Classic':
        if slate_var == 'Main':
            collection = nba_db['DK_NBA_name_map']
            cursor = collection.find()
            raw_data = pd.DataFrame(list(cursor))
            names_dict = dict(zip(raw_data['key'], raw_data['value']))

            collection = nba_db['DK_NBA_seed_frame_Main Slate']
            if prio_var == None:
                if player_var2 != []:
                    player_columns = ['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX']
                    query_conditions = []
                    
                    for player in player_var2:
                        # Create a condition for each player to check if they appear in any column
                        player_condition = {'$or': [{col: player} for col in player_columns]}
                        query_conditions.append(player_condition)
                    
                    # Combine all player conditions with $or
                    if query_conditions:
                        filter_query = {'$or': query_conditions}
                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                    else:
                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
                raw_display = pd.DataFrame(list(cursor))
            
            raw_display = raw_display.drop_duplicates(subset=['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX'])

            raw_display = raw_display[['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX']]
            dict_columns = ['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX']
            # Map names
            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
        elif slate_var == 'Secondary':
            collection = nba_db['DK_NBA_Secondary_name_map']
            cursor = collection.find()
            raw_data = pd.DataFrame(list(cursor))
            names_dict = dict(zip(raw_data['key'], raw_data['value']))
            
            collection = nba_db['DK_NBA_seed_frame_Secondary Slate']
            if prio_var == None:
                if player_var2 != []:
                    player_columns = ['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX']
                    query_conditions = []
                    
                    for player in player_var2:
                        # Create a condition for each player to check if they appear in any column
                        player_condition = {'$or': [{col: player} for col in player_columns]}
                        query_conditions.append(player_condition)
                    
                    # Combine all player conditions with $or
                    if query_conditions:
                        filter_query = {'$or': query_conditions}
                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                    else:
                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
                raw_display = pd.DataFrame(list(cursor))

            raw_display = raw_display.drop_duplicates(subset=['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX'])

            raw_display = raw_display[['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX']]
            dict_columns = ['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX']
            # Map names
            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
        elif slate_var == 'Auxiliary':
            collection = nba_db['DK_NBA_Late_name_map']
            cursor = collection.find()
            raw_data = pd.DataFrame(list(cursor))
            names_dict = dict(zip(raw_data['key'], raw_data['value']))
            
            collection = nba_db['DK_NBA_seed_frame_Late Slate']
            if prio_var == None:
                if player_var2 != []:
                    player_columns = ['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX']
                    query_conditions = []
                    
                    for player in player_var2:
                        # Create a condition for each player to check if they appear in any column
                        player_condition = {'$or': [{col: player} for col in player_columns]}
                        query_conditions.append(player_condition)
                    
                    # Combine all player conditions with $or
                    if query_conditions:
                        filter_query = {'$or': query_conditions}
                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                    else:
                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
                raw_display = pd.DataFrame(list(cursor))

            raw_display = raw_display.drop_duplicates(subset=['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX'])

            raw_display = raw_display[['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX']]
            dict_columns = ['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX']
            # Map names
            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
    elif type_var == 'Showdown':
        collection = nba_db[nba_db_translation[slate_var]]
        if prio_var == None:
            if player_var2 != []:
                player_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5']
                query_conditions = []
                
                for player in player_var2:
                    # Create a condition for each player to check if they appear in any column
                    player_condition = {'$or': [{col: player} for col in player_columns]}
                    query_conditions.append(player_condition)
                
                # Combine all player conditions with $or
                if query_conditions:
                    filter_query = {'$or': query_conditions}
                    cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                else:
                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_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[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5']]

    DK_seed = raw_display.to_numpy()

    return DK_seed

def init_FD_NBA_lineups(type_var, slate_var, prio_var, prio_mix, nba_db_translation, lineup_num, salary_min, salary_max, player_var2):

    if prio_var == 'Mix':
        prio_var = None
    
    if type_var == 'Classic':
        if slate_var == 'Main':
            collection = nba_db['FD_NBA_name_map']
            cursor = collection.find()
            raw_data = pd.DataFrame(list(cursor))
            names_dict = dict(zip(raw_data['key'], raw_data['value']))


            collection = nba_db['FD_NBA_seed_frame_Main Slate']
            if prio_var == None:
                if player_var2 != []:
                    player_columns = ['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C']
                    query_conditions = []
                    
                    for player in player_var2:
                        # Create a condition for each player to check if they appear in any column
                        player_condition = {'$or': [{col: player} for col in player_columns]}
                        query_conditions.append(player_condition)
                    
                    # Combine all player conditions with $or
                    if query_conditions:
                        filter_query = {'$or': query_conditions}
                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                    else:
                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
                raw_display = pd.DataFrame(list(cursor))

            raw_display = raw_display.drop_duplicates(subset=['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C'])

            raw_display = raw_display[['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C']]
            dict_columns = ['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C']
            # Map names
            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
        elif slate_var == 'Secondary':
            collection = nba_db['FD_NBA_Secondary_name_map']
            cursor = collection.find()
            raw_data = pd.DataFrame(list(cursor))
            names_dict = dict(zip(raw_data['key'], raw_data['value']))

            collection = nba_db['FD_NBA_Secondary_seed_frame_Secondary Slate']
            if prio_var == None:
                if player_var2 != []:
                    player_columns = ['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C']
                    query_conditions = []
                    
                    for player in player_var2:
                        # Create a condition for each player to check if they appear in any column
                        player_condition = {'$or': [{col: player} for col in player_columns]}
                        query_conditions.append(player_condition)
                    
                    # Combine all player conditions with $or
                    if query_conditions:
                        filter_query = {'$or': query_conditions}
                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                    else:
                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
                raw_display = pd.DataFrame(list(cursor))

            raw_display = raw_display.drop_duplicates(subset=['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C'])

            raw_display = raw_display[['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C']]
            dict_columns = ['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C']
            # Map names
            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
        elif slate_var == 'Auxiliary':
            collection = nba_db['FD_NBA_Late_name_map']
            cursor = collection.find()
            raw_data = pd.DataFrame(list(cursor))
            names_dict = dict(zip(raw_data['key'], raw_data['value']))

            collection = nba_db['FD_NBA_Late_seed_frame_Late Slate']
            if prio_var == None:
                if player_var2 != []:
                    player_columns = ['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C']
                    query_conditions = []

                    for player in player_var2:
                        # Create a condition for each player to check if they appear in any column
                        player_condition = {'$or': [{col: player} for col in player_columns]}
                        query_conditions.append(player_condition)

                    # Combine all player conditions with $or
                    if query_conditions:
                        filter_query = {'$or': query_conditions}
                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num = ((100 - prio_mix) / 100)))
                    else:
                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
                raw_display = pd.DataFrame(list(cursor))

            raw_display = raw_display.drop_duplicates(subset=['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C'])

            raw_display = raw_display[['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C']]
            dict_columns = ['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C']
            # Map names
            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))

    elif type_var == 'Showdown':
        collection = nba_db[nba_db_translation[slate_var]]
        if prio_var == None:
            if player_var2 != []:
                player_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5']
                query_conditions = []
                
                for player in player_var2:
                    # Create a condition for each player to check if they appear in any column
                    player_condition = {'$or': [{col: player} for col in player_columns]}
                    query_conditions.append(player_condition)
                
                # Combine all player conditions with $or
                if query_conditions:
                    filter_query = {'$or': query_conditions}
                    cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                else:
                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_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[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5']]

    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, salary_min, salary_max, 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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                    else:
                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                    else:
                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                    else:
                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                else:
                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_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[['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, salary_min, salary_max, 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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                    else:
                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                    else:
                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num = ((100 - prio_mix) / 100)))
                    else:
                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                else:
                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_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[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5']]

    FD_seed = raw_display.to_numpy()

    return FD_seed

def init_mma_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 = mma_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 = mma_db["Player_Level_ROO"]
        cursor = collection.find()

        raw_display = pd.DataFrame(list(cursor))
        raw_display = raw_display[['Player', 'Position', 'Salary', 'Median', 'Own', 'CPT_Own', 'player_id']]
        raw_display['Team'] = 'MMA'
        raw_display['Site'] = site_var
        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'] == 'Draftkings']
        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'])
        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
    
    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_MMA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, salary_min, salary_max, player_var2):

    if prio_var == 'Mix':
        prio_var = None
    
    if type_var == 'Classic':
        if slate_var == 'Main':
            collection = mma_db['DK_MMA_name_map']
            cursor = collection.find()
            raw_data = pd.DataFrame(list(cursor))
            names_dict = dict(zip(raw_data['key'], raw_data['value']))

            collection = mma_db['DK_MMA_seed_frame_Main Slate']
            if prio_var == None:
                if player_var2 != []:
                    player_columns = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
                    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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                    else:
                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
                raw_display = pd.DataFrame(list(cursor))
            
            raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])

            raw_display = raw_display[['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']]
            dict_columns = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
            # Map names
            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
        elif slate_var == 'Secondary':
            collection = mma_db['DK_MMA_Secondary_name_map']
            cursor = collection.find()
            raw_data = pd.DataFrame(list(cursor))
            names_dict = dict(zip(raw_data['key'], raw_data['value']))
            
            collection = mma_db['DK_MMA_seed_frame_Secondary Slate']
            if prio_var == None:
                if player_var2 != []:
                    player_columns = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
                    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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                    else:
                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
                raw_display = pd.DataFrame(list(cursor))

            raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])

            raw_display = raw_display[['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']]
            dict_columns = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
            # Map names
            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
        elif slate_var == 'Auxiliary':
            collection = mma_db['DK_MMA_Late_name_map']
            cursor = collection.find()
            raw_data = pd.DataFrame(list(cursor))
            names_dict = dict(zip(raw_data['key'], raw_data['value']))
            
            collection = mma_db['DK_MMA_seed_frame_Late Slate']
            if prio_var == None:
                if player_var2 != []:
                    player_columns = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
                    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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                    else:
                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
                raw_display = pd.DataFrame(list(cursor))

            raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])

            raw_display = raw_display[['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']]
            dict_columns = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
            # Map names
            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
    elif type_var == 'Showdown':
        collection = mma_db[mma_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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                else:
                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_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[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5']]

    DK_seed = raw_display.to_numpy()

    return DK_seed

def init_FD_MMA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, salary_min, salary_max, player_var2):

    if prio_var == 'Mix':
        prio_var = None
    
    if type_var == 'Classic':
        if slate_var == 'Main':
            collection = mma_db['FD_MMA_name_map']
            cursor = collection.find()
            raw_data = pd.DataFrame(list(cursor))
            names_dict = dict(zip(raw_data['key'], raw_data['value']))


            collection = mma_db['FD_MMA_seed_frame_Main Slate']
            if prio_var == None:
                if player_var2 != []:
                    player_columns = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
                    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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                    else:
                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
                raw_display = pd.DataFrame(list(cursor))

            raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])

            raw_display = raw_display[['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']]
            dict_columns = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
            # Map names
            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
        elif slate_var == 'Secondary':
            collection = mma_db['FD_MMA_Secondary_name_map']
            cursor = collection.find()
            raw_data = pd.DataFrame(list(cursor))
            names_dict = dict(zip(raw_data['key'], raw_data['value']))

            collection = mma_db['FD_MMA_Secondary_seed_frame_Secondary Slate']
            if prio_var == None:
                if player_var2 != []:
                    player_columns = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
                    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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                    else:
                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
                raw_display = pd.DataFrame(list(cursor))

            raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])

            raw_display = raw_display[['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']]
            dict_columns = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
            # Map names
            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
        elif slate_var == 'Auxiliary':
            collection = mma_db['FD_MMA_Late_name_map']
            cursor = collection.find()
            raw_data = pd.DataFrame(list(cursor))
            names_dict = dict(zip(raw_data['key'], raw_data['value']))

            collection = mma_db['FD_MMA_Late_seed_frame_Late Slate']
            if prio_var == None:
                if player_var2 != []:
                    player_columns = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
                    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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num = ((100 - prio_mix) / 100)))
                    else:
                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
                raw_display = pd.DataFrame(list(cursor))

            raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])

            raw_display = raw_display[['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']]
            dict_columns = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
            # Map names
            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))

    elif type_var == 'Showdown':
        collection = mma_db[mma_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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                else:
                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_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[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5']]

    FD_seed = raw_display.to_numpy()

    return FD_seed

def init_pga_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 = pga_db["Player_Level_Showdown_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']]
        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', 'site'])
        fd_sd_roo_raw = fd_sd_roo_raw.drop(columns=['player_ID', 'slate', 'version', '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 = pga_db["Player_Level_ROO"]
        cursor = collection.find()

        raw_display = pd.DataFrame(list(cursor))
        raw_display = raw_display[['Player', 'Position', 'Salary', 'Median', 'Own', 'CPT_Own', 'player_id']]
        raw_display['Team'] = 'PGA'
        raw_display['Site'] = site_var
        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'] == 'Draftkings']
        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'])
        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
    
    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_PGA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, salary_min, salary_max, player_var2):

    if prio_var == 'Mix':
        prio_var = None
    
    if type_var == 'Classic':
        if slate_var == 'Main':
            collection = pga_db['DK_PGA_Classic_name_map']
            cursor = collection.find()
            raw_data = pd.DataFrame(list(cursor))
            names_dict = dict(zip(raw_data['key'], raw_data['value']))

            collection = pga_db['DK_PGA_Classic_seed_frame_Main Slate']
            if prio_var == None:
                if player_var2 != []:
                    player_columns = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
                    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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                    else:
                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
                raw_display = pd.DataFrame(list(cursor))
            
            raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])

            raw_display = raw_display[['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']]
            dict_columns = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
            # Map names
            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
        elif slate_var == 'Secondary':
            collection = pga_db['DK_PGA_Classic_Secondary_name_map']
            cursor = collection.find()
            raw_data = pd.DataFrame(list(cursor))
            names_dict = dict(zip(raw_data['key'], raw_data['value']))
            
            collection = pga_db['DK_PGA_Classic_seed_frame_Secondary Slate']
            if prio_var == None:
                if player_var2 != []:
                    player_columns = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
                    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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                    else:
                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
                raw_display = pd.DataFrame(list(cursor))

            raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])

            raw_display = raw_display[['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']]
            dict_columns = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
            # Map names
            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
        elif slate_var == 'Auxiliary':
            collection = pga_db['DK_PGA_Classic_Late_name_map']
            cursor = collection.find()
            raw_data = pd.DataFrame(list(cursor))
            names_dict = dict(zip(raw_data['key'], raw_data['value']))
            
            collection = pga_db['DK_PGA_Classic_seed_frame_Late Slate']
            if prio_var == None:
                if player_var2 != []:
                    player_columns = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
                    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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                    else:
                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
                raw_display = pd.DataFrame(list(cursor))

            raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])

            raw_display = raw_display[['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']]
            dict_columns = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
            # Map names
            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
    elif type_var == 'Showdown':
        collection = pga_db['DK_PGA_Showdown_name_map']
        cursor = collection.find()
        raw_data = pd.DataFrame(list(cursor))
        names_dict = dict(zip(raw_data['key'], raw_data['value']))
        
        collection = pga_db['DK_PGA_Showdown_seed_frame_Main Slate']
        if prio_var == None:
            if player_var2 != []:
                player_columns = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
                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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                else:
                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
            raw_display = pd.DataFrame(list(cursor))

        raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])

        raw_display = raw_display[['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']]
        dict_columns = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
        # Map names
        raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))

    DK_seed = raw_display.to_numpy()

    return DK_seed

def init_FD_PGA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, salary_min, salary_max, player_var2):
    
    if prio_var == 'Mix':
        prio_var = None
    
    if type_var == 'Classic':
        if slate_var == 'Main':
            collection = pga_db['FD_PGA_Classic_name_map']
            cursor = collection.find()
            raw_data = pd.DataFrame(list(cursor))
            names_dict = dict(zip(raw_data['key'], raw_data['value']))

            collection = pga_db['FD_PGA_Classic_seed_frame_Main Slate']
            if prio_var == None:
                if player_var2 != []:
                    player_columns = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
                    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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                    else:
                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
                raw_display = pd.DataFrame(list(cursor))
            
            raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])

            raw_display = raw_display[['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']]
            dict_columns = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
            # Map names
            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
        elif slate_var == 'Secondary':
            collection = pga_db['FD_PGA_Classic_Secondary_name_map']
            cursor = collection.find()
            raw_data = pd.DataFrame(list(cursor))
            names_dict = dict(zip(raw_data['key'], raw_data['value']))
            
            collection = pga_db['FD_PGA_Classic_seed_frame_Secondary Slate']
            if prio_var == None:
                if player_var2 != []:
                    player_columns = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
                    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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                    else:
                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
                raw_display = pd.DataFrame(list(cursor))

            raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])

            raw_display = raw_display[['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']]
            dict_columns = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
            # Map names
            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
        elif slate_var == 'Auxiliary':
            collection = pga_db['FD_PGA_Classic_Late_name_map']
            cursor = collection.find()
            raw_data = pd.DataFrame(list(cursor))
            names_dict = dict(zip(raw_data['key'], raw_data['value']))
            
            collection = pga_db['FD_PGA_Classic_seed_frame_Late Slate']
            if prio_var == None:
                if player_var2 != []:
                    player_columns = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
                    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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                    else:
                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
                raw_display = pd.DataFrame(list(cursor))

            raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])

            raw_display = raw_display[['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']]
            dict_columns = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
            # Map names
            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
    elif type_var == 'Showdown':
        collection = pga_db['FD_PGA_Showdown_name_map']
        cursor = collection.find()
        raw_data = pd.DataFrame(list(cursor))
        names_dict = dict(zip(raw_data['key'], raw_data['value']))
        
        collection = pga_db['FD_PGA_Showdown_seed_frame_Main Slate']
        if prio_var == None:
            if player_var2 != []:
                player_columns = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
                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, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                else:
                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
                cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).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({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
            raw_display = pd.DataFrame(list(cursor))

        raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])

        raw_display = raw_display[['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']]
        dict_columns = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
        # Map names
        raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))

    FD_seed = raw_display.to_numpy()

    return FD_seed