Adding PGA functionality

app.py

@@ -57,6 +57,12 @@ dk_db_mma_showdown_selections = ['DK_MMA_SD_seed_frame_Showdown #1', 'DK_MMA_SD_
 fd_db_mma_showdown_selections = ['FD_MMA_SD_seed_frame_Showdown #1', 'FD_MMA_SD_seed_frame_Showdown #2', 'FD_MMA_SD_seed_frame_Showdown #3', 'FD_MMA_SD_seed_frame_Showdown #4', 'FD_MMA_SD_seed_frame_Showdown #5', 'FD_MMA_SD_seed_frame_Showdown #6',
 'FD_MMA_SD_seed_frame_Showdown #7', 'FD_MMA_SD_seed_frame_Showdown #8', 'FD_MMA_SD_seed_frame_Showdown #9', 'FD_MMA_SD_seed_frame_Showdown #10', 'FD_MMA_SD_seed_frame_Showdown #11', 'FD_MMA_SD_seed_frame_Showdown #12', 'FD_MMA_SD_seed_frame_Showdown #13',
 'FD_MMA_SD_seed_frame_Showdown #14', 'FD_MMA_SD_seed_frame_Showdown #15']
+dk_db_pga_showdown_selections = ['DK_PGA_SD_seed_frame_Showdown #1', 'DK_PGA_SD_seed_frame_Showdown #2', 'DK_PGA_SD_seed_frame_Showdown #3', 'DK_PGA_SD_seed_frame_Showdown #4', 'DK_PGA_SD_seed_frame_Showdown #5', 'DK_PGA_SD_seed_frame_Showdown #6',
+'DK_PGA_SD_seed_frame_Showdown #7', 'DK_PGA_SD_seed_frame_Showdown #8', 'DK_PGA_SD_seed_frame_Showdown #9', 'DK_PGA_SD_seed_frame_Showdown #10', 'DK_PGA_SD_seed_frame_Showdown #11', 'DK_PGA_SD_seed_frame_Showdown #12', 'DK_PGA_SD_seed_frame_Showdown #13',
+'DK_PGA_SD_seed_frame_Showdown #14', 'DK_PGA_SD_seed_frame_Showdown #15']
+fd_db_pga_showdown_selections = ['FD_PGA_SD_seed_frame_Showdown #1', 'FD_PGA_SD_seed_frame_Showdown #2', 'FD_PGA_SD_seed_frame_Showdown #3', 'FD_PGA_SD_seed_frame_Showdown #4', 'FD_PGA_SD_seed_frame_Showdown #5', 'FD_PGA_SD_seed_frame_Showdown #6',
+'FD_PGA_SD_seed_frame_Showdown #7', 'FD_PGA_SD_seed_frame_Showdown #8', 'FD_PGA_SD_seed_frame_Showdown #9', 'FD_PGA_SD_seed_frame_Showdown #10', 'FD_PGA_SD_seed_frame_Showdown #11', 'FD_PGA_SD_seed_frame_Showdown #12', 'FD_PGA_SD_seed_frame_Showdown #13',
+'FD_PGA_SD_seed_frame_Showdown #14', 'FD_PGA_SD_seed_frame_Showdown #15']
 
 dk_nfl_showdown_db_translation = dict(zip(showdown_selections, dk_db_nfl_showdown_selections))
 fd_nfl_showdown_db_translation = dict(zip(showdown_selections, fd_db_nfl_showdown_selections))
@@ -66,6 +72,8 @@ dk_nhl_showdown_db_translation = dict(zip(showdown_selections, dk_db_nhl_showdow
 fd_nhl_showdown_db_translation = dict(zip(showdown_selections, fd_db_nhl_showdown_selections))
 dk_mma_showdown_db_translation = dict(zip(showdown_selections, dk_db_mma_showdown_selections))
 fd_mma_showdown_db_translation = dict(zip(showdown_selections, fd_db_mma_showdown_selections))
+dk_pga_showdown_db_translation = dict(zip(showdown_selections, dk_db_pga_showdown_selections))
+fd_pga_showdown_db_translation = dict(zip(showdown_selections, fd_db_pga_showdown_selections))
 
 freq_format = {'Finish_percentile': '{:.2%}', 'Lineup Edge': '{:.2%}', 'Lineup Edge_Raw': '{:.2%}', 'Win%': '{:.2%}'}
 stacking_sports = ['MLB', 'NHL', 'NFL', 'LOL', 'NCAAF']
@@ -149,7 +157,7 @@ def grab_nfl_reg_salaries(slate_var: str):
     collection = salaries_db["NFL_reg_player_info"]
     eastern = pytz.timezone('US/Eastern')
     today_str = datetime.now(eastern).strftime("%Y%m%d")
-    records = pd.DataFrame(list(collection.find({'Date': {'$gte': today_str}})))
+    records = pd.DataFrame(list(collection.find({'Contest Date': {'$gte': today_str}})))
     records = records[['Display Name', 'draftableId', 'Position', 'Salary']]
     records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'})
     if slate_var == 'Main':
@@ -183,7 +191,7 @@ def grab_nfl_showdown_salaries():
     collection = salaries_db["NFL_showdown_player_info"]
     eastern = pytz.timezone('US/Eastern')
     today_str = datetime.now(eastern).strftime("%Y%m%d")
-    records = pd.DataFrame(list(collection.find({'Date': {'$gte': today_str}})))
+    records = pd.DataFrame(list(collection.find({'Contest Date': {'$gte': today_str}})))
     records = records[['Display Name', 'draftableId', 'Position', 'Salary']]
     records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'})
     return records
@@ -192,7 +200,7 @@ def grab_nba_reg_salaries(slate_var: str):
     collection = salaries_db["NBA_reg_player_info"]
     eastern = pytz.timezone('US/Eastern')
     today_str = datetime.now(eastern).strftime("%Y%m%d")
-    records = pd.DataFrame(list(collection.find({'Date': {'$gte': today_str}})))
+    records = pd.DataFrame(list(collection.find({'Contest Date': {'$gte': today_str}})))
     records = records[['Display Name', 'draftableId', 'Position', 'Salary']]
     records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'})
     if slate_var == 'Main':
@@ -228,7 +236,7 @@ def grab_nba_showdown_salaries():
     eastern = pytz.timezone('US/Eastern')
     today_str = datetime.now(eastern).strftime("%Y%m%d")
     print(f"Current date in Eastern Time: {today_str}")
-    records = pd.DataFrame(list(collection.find({'Date': {'$gte': today_str}})))
+    records = pd.DataFrame(list(collection.find({'Contest Date': {'$gte': today_str}})))
     records = records[['Display Name', 'draftableId', 'Position', 'Salary']]
     records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'})
     return records
@@ -237,7 +245,7 @@ def grab_mlb_reg_salaries(slate_var: str):
     collection = salaries_db["MLB_reg_player_info"]
     eastern = pytz.timezone('US/Eastern')
     today_str = datetime.now(eastern).strftime("%Y%m%d")
-    records = pd.DataFrame(list(collection.find({'Date': {'$gte': today_str}})))
+    records = pd.DataFrame(list(collection.find({'Contest Date': {'$gte': today_str}})))
     records = records[['Display Name', 'draftableId', 'Position', 'Salary']]
     records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'})
     if slate_var == 'Main':
@@ -271,7 +279,7 @@ def grab_mlb_showdown_salaries():
     collection = salaries_db["MLB_showdown_player_info"]
     eastern = pytz.timezone('US/Eastern')
     today_str = datetime.now(eastern).strftime("%Y%m%d")
-    records = pd.DataFrame(list(collection.find({'Date': {'$gte': today_str}})))
+    records = pd.DataFrame(list(collection.find({'Contest Date': {'$gte': today_str}})))
     records = records[['Display Name', 'draftableId', 'Position', 'Salary']]
     records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'})
     return records
@@ -280,7 +288,7 @@ def grab_nhl_reg_salaries(slate_var: str):
     collection = salaries_db["NHL_reg_player_info"]
     eastern = pytz.timezone('US/Eastern')
     today_str = datetime.now(eastern).strftime("%Y%m%d")
-    records = pd.DataFrame(list(collection.find({'Date': {'$gte': today_str}})))
+    records = pd.DataFrame(list(collection.find({'Contest Date': {'$gte': today_str}})))
     records = records[['Display Name', 'draftableId', 'Position', 'Salary']]
     records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'})
     if slate_var == 'Main':
@@ -314,7 +322,7 @@ def grab_nhl_showdown_salaries():
     collection = salaries_db["NHL_showdown_player_info"]
     eastern = pytz.timezone('US/Eastern')
     today_str = datetime.now(eastern).strftime("%Y%m%d")
-    records = pd.DataFrame(list(collection.find({'Date': {'$gte': today_str}})))
+    records = pd.DataFrame(list(collection.find({'Contest Date': {'$gte': today_str}})))
     records = records[['Display Name', 'draftableId', 'Position', 'Salary']]
     records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'})
     return records
@@ -357,7 +365,50 @@ def grab_mma_showdown_salaries():
     collection = salaries_db["MMA_showdown_player_info"]
     eastern = pytz.timezone('US/Eastern')
     today_str = datetime.now(eastern).strftime("%Y%m%d")
-    records = pd.DataFrame(list(collection.find({'Date': {'$gte': today_str}})))
+    records = pd.DataFrame(list(collection.find({'Contest Date': {'$gte': today_str}})))
+    records = records[['Display Name', 'draftableId', 'Position', 'Salary']]
+    records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'})
+    return records
+
+def grab_pga_reg_salaries(slate_var: str):
+    collection = salaries_db["PGA_reg_player_info"]
+    eastern = pytz.timezone('US/Eastern')
+    today_str = datetime.now(eastern).strftime("%Y%m%d")
+    records = pd.DataFrame(list(collection.find({'Contest Date': {'$gte': today_str}})))
+    records = records[['Display Name', 'draftableId', 'Position', 'Salary']]
+    records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'})
+    if slate_var == 'Main':
+        records = records.sort_values(by='ID', ascending=True)
+        records = records.drop_duplicates(subset=['Name'], keep='first')
+    elif slate_var == 'Secondary':
+        records = records.sort_values(by='ID', ascending=True)
+        # Keep middle occurrence: drop first and last, keep middle
+        grouped = records.groupby('Name')
+        middle_records = []
+        for name, group in grouped:
+            if len(group) == 1:
+                # Only one record, keep it
+                middle_records.append(group)
+            elif len(group) == 2:
+                # Two records, keep the second one (last)
+                middle_records.append(group.iloc[1:2])
+            else:
+                # Three or more records, keep the middle one(s)
+                # For odd number of records, keep the true middle
+                # For even number of records, keep the record at index len//2
+                middle_idx = len(group) // 2
+                middle_records.append(group.iloc[middle_idx:middle_idx+1])
+        records = pd.concat(middle_records, ignore_index=True)
+    elif slate_var == 'Auxiliary':
+        records = records.sort_values(by='ID', ascending=True)
+        records = records.drop_duplicates(subset=['Name'], keep='last')
+    return records
+
+def grab_pga_showdown_salaries():
+    collection = salaries_db["PGA_showdown_player_info"]
+    eastern = pytz.timezone('US/Eastern')
+    today_str = datetime.now(eastern).strftime("%Y%m%d")
+    records = pd.DataFrame(list(collection.find({'Contest Date': {'$gte': today_str}})))
     records = records[['Display Name', 'draftableId', 'Position', 'Salary']]
     records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'})
     return records
@@ -498,52 +549,6 @@ except:
     nhl_slate_names_fd = []
     nhl_slate_name_lookup_fd = {}
 
-def define_dk_mma_showdown_slates():
-    collection = mma_db["Player_Level_SD_ROO"]
-    cursor = collection.find()
-    raw_display = pd.DataFrame(list(cursor))
-    raw_display = raw_display[raw_display['Site'] == 'Draftkings']
-    unique_slates = raw_display['Slate'].unique()
-
-    slate_names = []
-
-    for slate in unique_slates:
-        slate_data = raw_display[raw_display['Slate'] == slate]
-        slate_name = slate_data.iloc[0]['Team'] + ' vs. ' + slate_data.iloc[0]['Opp']
-        slate_names.append(slate_name)
-    
-    slate_name_lookup = dict(zip(slate_names, unique_slates))
-    return slate_names, slate_name_lookup
-
-def define_fd_mma_showdown_slates():
-    collection = mma_db["Player_Level_SD_ROO"]
-    cursor = collection.find()
-    raw_display = pd.DataFrame(list(cursor))
-    raw_display = raw_display[raw_display['Site'] == 'Fanduel']
-    unique_slates = raw_display['Slate'].unique()
-
-    slate_names = []
-
-    for slate in unique_slates:
-        slate_data = raw_display[raw_display['Slate'] == slate]
-        slate_name = slate_data.iloc[0]['Team'] + ' vs. ' + slate_data.iloc[0]['Opp']
-        slate_names.append(slate_name)
-    
-    slate_name_lookup = dict(zip(slate_names, unique_slates))
-    return slate_names, slate_name_lookup
-
-try:
-    mma_slate_names_dk, mma_slate_name_lookup_dk = define_dk_mma_showdown_slates()
-except:
-    mma_slate_names_dk = []
-    mma_slate_name_lookup_dk = {}
-    
-try:
-    mma_slate_names_fd, mma_slate_name_lookup_fd = define_fd_mma_showdown_slates()
-except:
-    mma_slate_names_fd = []
-    mma_slate_name_lookup_fd = {}
-
 # Memory optimization helper functions
 def chunk_name_matching(portfolio_names, csv_names, chunk_size=1000):
     """Process name matching in chunks to reduce memory usage"""
@@ -924,7 +929,9 @@ with st.container():
                 elif sport_var == 'NHL':
                     slate_var3 = st.radio("Which slate data are you loading?", (nhl_slate_names_dk if type_var == 'Showdown' else ['Main', 'Secondary', 'Auxiliary']), key='slate_var3_radio')
                 elif sport_var == 'MMA':
-                    slate_var3 = st.radio("Which slate data are you loading?", (mma_slate_names_dk if type_var == 'Showdown' else ['Main', 'Secondary', 'Auxiliary']), key='slate_var3_radio')
+                    slate_var3 = st.radio("Which slate data are you loading?", (['Main', 'Secondary', 'Auxiliary']), key='slate_var3_radio')
+                elif sport_var == 'GOLF':
+                    slate_var3 = st.radio("Which slate data are you loading?", (['Main', 'Secondary', 'Auxiliary']), key='slate_var3_radio')
                 else:
                     slate_var3 = st.radio("Which slate data are you loading?", (['Main', 'Secondary', 'Auxiliary']), key='slate_var3_radio')
             elif site_var == 'Fanduel':
@@ -935,7 +942,9 @@ with st.container():
                 elif sport_var == 'NHL':
                     slate_var3 = st.radio("Which slate data are you loading?", (nhl_slate_names_fd if type_var == 'Showdown' else ['Main', 'Secondary', 'Auxiliary']), key='slate_var3_radio')
                 elif sport_var == 'MMA':
-                    slate_var3 = st.radio("Which slate data are you loading?", (mma_slate_names_fd if type_var == 'Showdown' else ['Main', 'Secondary', 'Auxiliary']), key='slate_var3_radio')
+                    slate_var3 = st.radio("Which slate data are you loading?", (['Main', 'Secondary', 'Auxiliary']), key='slate_var3_radio')
+                elif sport_var == 'GOLF':
+                    slate_var3 = st.radio("Which slate data are you loading?", (['Main', 'Secondary', 'Auxiliary']), key='slate_var3_radio')
                 else:
                     slate_var3 = st.radio("Which slate data are you loading?", (['Main', 'Secondary', 'Auxiliary']), key='slate_var3_radio')
 
@@ -990,6 +999,14 @@ with st.container():
         mma_showdown_salaries = grab_mma_showdown_salaries()
     except:
         mma_showdown_salaries = None
+    try:
+        pga_reg_salaries = grab_pga_reg_salaries(slate_var3)
+    except:
+        pga_reg_salaries = None
+    try:
+        pga_showdown_salaries = grab_pga_showdown_salaries()
+    except:
+        pga_showdown_salaries = None
 
 try:
     selected_tab = st.segmented_control(
@@ -1049,6 +1066,11 @@ if selected_tab == 'Data Load':
                         st.session_state['csv_file'] = load_csv(mma_reg_salaries)
                     elif type_var == 'Showdown':
                         st.session_state['csv_file'] = load_csv(mma_showdown_salaries)
+                elif sport_var == 'GOLF':
+                    if type_var == 'Classic':
+                        st.session_state['csv_file'] = load_csv(pga_reg_salaries)
+                    elif type_var == 'Showdown':
+                        st.session_state['csv_file'] = load_csv(pga_showdown_salaries)
                 st.session_state['pricing_loaded'] = True
                 
             try:
@@ -1124,7 +1146,9 @@ if selected_tab == 'Data Load':
                         elif sport_var == 'NHL':
                             portfolio_load = init_DK_NHL_lineups(type_var, slate_var3, prio_var, 50, dk_nhl_showdown_db_translation, lineup_num_var, [])
                         elif sport_var == 'MMA':
-                            portfolio_load = init_DK_MMA_lineups(type_var, slate_var3, prio_var, 50, dk_mma_showdown_db_translation, lineup_num_var, [])
+                            portfolio_load = init_DK_MMA_lineups(type_var, slate_var3, prio_var, 50, lineup_num_var, [])
+                        elif sport_var == 'GOLF':
+                            portfolio_load = init_DK_PGA_lineups(type_var, slate_var3, prio_var, 50, lineup_num_var, [])
                     else:
                         if sport_var == 'NBA':
                             portfolio_load = init_DK_NBA_lineups(type_var, nba_slate_name_lookup_dk[slate_var3], prio_var, 50, dk_nba_showdown_db_translation, lineup_num_var, [])
@@ -1133,7 +1157,9 @@ if selected_tab == 'Data Load':
                         elif sport_var == 'NHL':
                             portfolio_load = init_DK_NHL_lineups(type_var, nhl_slate_name_lookup_dk[slate_var3], prio_var, 50, dk_nhl_showdown_db_translation, lineup_num_var, [])
                         elif sport_var == 'MMA':
-                            portfolio_load = init_DK_MMA_lineups(type_var, mma_slate_name_lookup_dk[slate_var3], prio_var, 50, dk_mma_showdown_db_translation, lineup_num_var, [])
+                            portfolio_load = init_DK_MMA_lineups(type_var, slate_var3, prio_var, 50, lineup_num_var, [])
+                        elif sport_var == 'GOLF':
+                            portfolio_load = init_DK_PGA_lineups(type_var, slate_var3, prio_var, 50, lineup_num_var, [])
 
                     st.session_state['db_portfolio_file'] = pd.DataFrame(portfolio_load)
                     st.session_state['portfolio_loaded'] = True
@@ -1150,7 +1176,9 @@ if selected_tab == 'Data Load':
                         elif sport_var == 'NHL':
                             portfolio_load = init_FD_NHL_lineups(type_var, slate_var3, prio_var, 50, fd_nhl_showdown_db_translation, lineup_num_var, [])
                         elif sport_var == 'MMA':
-                            portfolio_load = init_FD_MMA_lineups(type_var, slate_var3, prio_var, 50, fd_mma_showdown_db_translation, lineup_num_var, [])
+                            portfolio_load = init_FD_MMA_lineups(type_var, slate_var3, prio_var, 50, lineup_num_var, [])
+                        elif sport_var == 'GOLF':
+                            portfolio_load = init_FD_PGA_lineups(type_var, slate_var3, prio_var, 50, lineup_num_var, [])
                     else:
                         if sport_var == 'NBA':
                             portfolio_load = init_FD_NBA_lineups(type_var, nba_slate_name_lookup_fd[slate_var3], prio_var, 50, fd_nba_showdown_db_translation, lineup_num_var, [])
@@ -1159,7 +1187,9 @@ if selected_tab == 'Data Load':
                         elif sport_var == 'NHL':
                             portfolio_load = init_FD_NHL_lineups(type_var, nhl_slate_name_lookup_fd[slate_var3], prio_var, 50, fd_nhl_showdown_db_translation, lineup_num_var, [])
                         elif sport_var == 'MMA':
-                            portfolio_load = init_FD_MMA_lineups(type_var, mma_slate_name_lookup_fd[slate_var3], prio_var, 50, fd_mma_showdown_db_translation, lineup_num_var, [])
+                            portfolio_load = init_FD_MMA_lineups(type_var, slate_var3, prio_var, 50, lineup_num_var, [])
+                        elif sport_var == 'GOLF':
+                            portfolio_load = init_FD_PGA_lineups(type_var, slate_var3, prio_var, 50, lineup_num_var, [])
 
                     st.session_state['db_portfolio_file'] = pd.DataFrame(portfolio_load)
                     st.session_state['portfolio_loaded'] = True
@@ -1305,6 +1335,17 @@ if selected_tab == 'Data Load':
                                 projections_file = init_mma_baselines(type_var, site_var, slate_var3)[1]
                             elif type_var == 'Showdown':
                                 projections_file = init_mma_baselines(type_var, site_var, slate_var3)[3]
+                    elif sport_var == 'GOLF':
+                        if site_var == 'Draftkings':
+                            if type_var == 'Classic':
+                                projections_file = init_pga_baselines(type_var, site_var, slate_var3)[0]
+                            elif type_var == 'Showdown':
+                                projections_file = init_pga_baselines(type_var, site_var, slate_var3)[2]
+                        elif site_var == 'Fanduel':
+                            if type_var == 'Classic':
+                                projections_file = init_pga_baselines(type_var, site_var, slate_var3)[1]
+                            elif type_var == 'Showdown':
+                                projections_file = init_pga_baselines(type_var, site_var, slate_var3)[3]
                     st.session_state['db_projections_file'] = projections_file
                     st.session_state['projections_loaded'] = True
             if 'projections_df' in st.session_state:

database.py

@@ -9,13 +9,14 @@ def init_conn():
         if not uri:
             uri = st.secrets['mongo_uri']
         client = pymongo.MongoClient(uri, retryWrites=True, serverSelectionTimeoutMS=500000)
-        nfl_db = client["NFL_Database"]
         salaries_db = client['Contest_Information']
+        nfl_db = client["NFL_Database"]
         nba_db = client["NBA_Database"]
         mlb_db = client["MLB_Database"]
         nhl_db = client["NHL_Database"]
         mma_db = client["MMA_Database"]
+        pga_db = client["PGA_Database"]
 
-        return nfl_db, salaries_db, nba_db, mlb_db, nhl_db, mma_db
+        return nfl_db, salaries_db, nba_db, mlb_db, nhl_db, mma_db, pga_db
     
-nfl_db, salaries_db, nba_db, mlb_db, nhl_db, mma_db = init_conn()
+nfl_db, salaries_db, nba_db, mlb_db, nhl_db, mma_db, pga_db = init_conn()

database_queries.py

@@ -102,7 +102,7 @@ def init_nfl_baselines(type_var: str, site_var: str, slate_var: str):
 
     return dk_roo_raw, fd_roo_raw, dk_sd_roo_raw, fd_sd_roo_raw, dk_id_map, fd_id_map, dk_sd_id_map, fd_sd_id_map
 
-def init_DK_NFL_lineups(type_var, slate_var, prio_var, prio_mix, nfl_db_translation, lineup_num, player_var2):  
+def init_DK_NFL_lineups(type_var, slate_var, prio_var, prio_mix, nfl_db_translation, lineup_num, player_var2):
 
     if prio_var == 'Mix':
         prio_var = None
@@ -506,7 +506,7 @@ def init_nba_baselines(type_var: str, site_var: str, slate_var: str):
     
     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, player_var2):  
+def init_DK_NBA_lineups(type_var, slate_var, prio_var, prio_mix, nba_db_translation, lineup_num, player_var2):
 
     if prio_var == 'Mix':
         prio_var = None
@@ -900,7 +900,7 @@ def init_nhl_baselines(type_var: str, site_var: str, slate_var: str):
     
     return dk_roo_raw, fd_roo_raw, dk_sd_roo_raw, fd_sd_roo_raw, dk_id_map, fd_id_map, dk_sd_id_map, fd_sd_id_map
 
-def init_DK_NHL_lineups(type_var, slate_var, prio_var, prio_mix, nhl_db_translation, lineup_num, player_var2):  
+def init_DK_NHL_lineups(type_var, slate_var, prio_var, prio_mix, nhl_db_translation, lineup_num, player_var2):
 
     if prio_var == 'Mix':
         prio_var = None
@@ -1296,7 +1296,7 @@ def init_mma_baselines(type_var: str, site_var: str, slate_var: str):
     
     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, mma_db_translation, lineup_num, player_var2):  
+def init_DK_MMA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, player_var2):
 
     if prio_var == 'Mix':
         prio_var = None
@@ -1459,7 +1459,7 @@ def init_DK_MMA_lineups(type_var, slate_var, prio_var, prio_mix, mma_db_translat
 
     return DK_seed
 
-def init_FD_MMA_lineups(type_var, slate_var, prio_var, prio_mix, mma_db_translation, lineup_num, player_var2):
+def init_FD_MMA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, player_var2):
 
     if prio_var == 'Mix':
         prio_var = None
@@ -1622,4 +1622,414 @@ def init_FD_MMA_lineups(type_var, slate_var, prio_var, prio_mix, mma_db_translat
 
     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, 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).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    else:
+                        cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+                else:
+                    cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor = collection.find().sort(prio_var, -1).limit(lineup_num)
+                raw_display = pd.DataFrame(list(cursor))
+            
+            raw_display = raw_display.drop_duplicates(subset=['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).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    else:
+                        cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+                else:
+                    cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor = collection.find().sort(prio_var, -1).limit(lineup_num)
+                raw_display = pd.DataFrame(list(cursor))
+
+            raw_display = raw_display.drop_duplicates(subset=['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).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    else:
+                        cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+                else:
+                    cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor = collection.find().sort(prio_var, -1).limit(lineup_num)
+                raw_display = pd.DataFrame(list(cursor))
+
+            raw_display = raw_display.drop_duplicates(subset=['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).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                else:
+                    cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+        else:
+            cursor = collection.find().sort(prio_var, -1).limit(lineup_num)
+            raw_display = pd.DataFrame(list(cursor))
+
+        raw_display = raw_display.drop_duplicates(subset=['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, 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).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    else:
+                        cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+                else:
+                    cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor = collection.find().sort(prio_var, -1).limit(lineup_num)
+                raw_display = pd.DataFrame(list(cursor))
+            
+            raw_display = raw_display.drop_duplicates(subset=['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).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    else:
+                        cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+                else:
+                    cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor = collection.find().sort(prio_var, -1).limit(lineup_num)
+                raw_display = pd.DataFrame(list(cursor))
+
+            raw_display = raw_display.drop_duplicates(subset=['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).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    else:
+                        cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+                else:
+                    cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor = collection.find().sort(prio_var, -1).limit(lineup_num)
+                raw_display = pd.DataFrame(list(cursor))
+
+            raw_display = raw_display.drop_duplicates(subset=['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).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                else:
+                    cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+        else:
+            cursor = collection.find().sort(prio_var, -1).limit(lineup_num)
+            raw_display = pd.DataFrame(list(cursor))
+
+        raw_display = raw_display.drop_duplicates(subset=['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