Adding some database support

app.py

@@ -28,6 +28,20 @@ from global_func.exposure_spread import exposure_spread
 from global_func.reassess_edge import reassess_edge
 from global_func.recalc_diversity import recalc_diversity
 
+from database_queries import *
+from database import *
+
+showdown_selections = ['Showdown #1', 'Showdown #2', 'Showdown #3', 'Showdown #4', 'Showdown #5', 'Showdown #6', 'Showdown #7', 'Showdown #8', 'Showdown #9', 'Showdown #10', 'Showdown #11', 'Showdown #12', 'Showdown #13', 'Showdown #14', 'Showdown #15']
+dk_db_nfl_showdown_selections = ['DK_NFL_SD_seed_frame_Showdown #1', 'DK_NFL_SD_seed_frame_Showdown #2', 'DK_NFL_SD_seed_frame_Showdown #3', 'DK_NFL_SD_seed_frame_Showdown #4', 'DK_NFL_SD_seed_frame_Showdown #5', 'DK_NFL_SD_seed_frame_Showdown #6',
+'DK_NFL_SD_seed_frame_Showdown #7', 'DK_NFL_SD_seed_frame_Showdown #8', 'DK_NFL_SD_seed_frame_Showdown #9', 'DK_NFL_SD_seed_frame_Showdown #10', 'DK_NFL_SD_seed_frame_Showdown #11', 'DK_NFL_SD_seed_frame_Showdown #12', 'DK_NFL_SD_seed_frame_Showdown #13',
+'DK_NFL_SD_seed_frame_Showdown #14', 'DK_NFL_SD_seed_frame_Showdown #15']
+fd_db_nfl_showdown_selections = ['FD_NFL_SD_seed_frame_Showdown #1', 'FD_NFL_SD_seed_frame_Showdown #2', 'FD_NFL_SD_seed_frame_Showdown #3', 'FD_NFL_SD_seed_frame_Showdown #4', 'FD_NFL_SD_seed_frame_Showdown #5', 'FD_NFL_SD_seed_frame_Showdown #6',
+'FD_NFL_SD_seed_frame_Showdown #7', 'FD_NFL_SD_seed_frame_Showdown #8', 'FD_NFL_SD_seed_frame_Showdown #9', 'FD_NFL_SD_seed_frame_Showdown #10', 'FD_NFL_SD_seed_frame_Showdown #11', 'FD_NFL_SD_seed_frame_Showdown #12', 'FD_NFL_SD_seed_frame_Showdown #13',
+'FD_NFL_SD_seed_frame_Showdown #14', 'FD_NFL_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))
+
 freq_format = {'Finish_percentile': '{:.2%}', 'Lineup Edge': '{:.2%}', 'Lineup Edge_Raw': '{:.2%}', 'Win%': '{:.2%}'}
 stacking_sports = ['MLB', 'NHL', 'NFL', 'LOL', 'NCAAF']
 stack_column_dict = {
@@ -545,8 +559,14 @@ if selected_tab == 'Data Load':
         st.subheader("Portfolio File")
         st.info("Go ahead and upload a portfolio file here. Only include player columns.")
 
-        upload_toggle = st.selectbox("What source are you uploading from?", options=['SaberSim (Just IDs)', 'Draftkings/Fanduel (Names + IDs)', 'Other (Just Names)'])
-        if upload_toggle == 'SaberSim (Just IDs)' or upload_toggle == 'Draftkings/Fanduel (Names + IDs)':
+        upload_toggle = st.selectbox("What source are you uploading from?", options=['Paydirt DB', 'SaberSim (Just IDs)', 'Draftkings/Fanduel (Names + IDs)', 'Other (Just Names)'])
+        if upload_toggle == 'Paydirt DB':
+            if site_var == 'Draftkings':
+                portfolio_file = init_DK_NFL_lineups(type_var, 'Main Slate', 'proj', 50, dk_nfl_showdown_db_translation, 25000, [])
+            else:
+                portfolio_file = init_FD_NFL_lineups(type_var, 'Main Slate', 'proj', 50, fd_nfl_showdown_db_translation, 25000, [])
+
+        elif upload_toggle == 'SaberSim (Just IDs)' or upload_toggle == 'Draftkings/Fanduel (Names + IDs)':
             portfolio_file = st.file_uploader("Upload Portfolio File (CSV or Excel)", type=['csv', 'xlsx', 'xls'])
             if 'portfolio' in st.session_state:
                 del st.session_state['portfolio']
@@ -559,6 +579,7 @@ if selected_tab == 'Data Load':
                 del st.session_state['portfolio']
             if 'export_portfolio' in st.session_state:
                 del st.session_state['export_portfolio']
+                
         if 'portfolio' not in st.session_state:
             if portfolio_file:
                 if upload_toggle == 'SaberSim (Just IDs)':

database.py

@@ -0,0 +1,16 @@
+import streamlit as st
+import pymongo
+import os
+
+@st.cache_resource
+def init_conn():
+         # Try to get from environment variable first, fall back to secrets
+        uri = os.getenv('MONGO_URI')
+        if not uri:
+            uri = st.secrets['mongo_uri']
+        client = pymongo.MongoClient(uri, retryWrites=True, serverSelectionTimeoutMS=500000)
+        nfl_db = client["NFL_Database"]
+
+        return nfl_db
+    
+nfl_db = init_conn()

database_queries.py

@@ -0,0 +1,429 @@
+import pandas as pd
+import numpy as np
+import math
+from database import *
+
+# Probably should have done this in a dictionary to start with
+wrong_nfl_team_names = ['Denver Broncos', 'Washington Commanders', 'Cincinnati Bengals', 'Arizona Cardinals', 'Los Angeles Rams', 'Pittsburgh Steelers',
+'Jacksonville Jaguars', 'New England Patriots', 'Tampa Bay Buccaneers', 'San Francisco 49ers', 'Green Bay Packers', 'New York Jets',
+'Indianapolis Colts', 'Miami Dolphins', 'Detroit Lions', 'Las Vegas Raiders', 'Atlanta Falcons', 'Seattle Seahawks', 'Houston Texans',
+'New Orleans Saints', 'Carolina Panthers', 'New York Giants', 'Cleveland Browns', 'Tennessee Titans', 'Philadelphia Eagles', 'Dallas Cowboys',
+'Kansas City Chiefs', 'Los Angeles Chargers', 'Baltimore Ravens', 'Buffalo Bills', 'Minnesota Vikings', 'Chicago Bears']
+right_nfl_name_teams = ['Broncos', 'Commanders', 'Bengals', 'Cardinals', 'Rams', 'Steelers', 'Jaguars', 'Patriots', 'Buccaneers', '49ers', 'Packers', 
+'Jets', 'Colts', 'Dolphins', 'Lions', 'Raiders', 'Falcons', 'Seahawks', 'Texans', 'Saints', 'Panthers', 'Giants', 'Browns', 'Titans', 'Eagles', 'Cowboys',
+'Chiefs', 'Chargers', 'Ravens', 'Bills', 'Vikings', 'Bears']
+
+def init_nfl_baselines(type_var: str):
+
+    if type_var == 'Regular':
+        collection = nfl_db["DK_NFL_ROO"] 
+        cursor = collection.find()
+
+        raw_display = pd.DataFrame(list(cursor))
+        raw_display = raw_display.rename(columns={'player_ID': 'player_id'})
+        raw_display = raw_display[['Player', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'exFPTS', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '2x%', '3x%', '4x%',
+                                'Own', 'Small_Field_Own', 'Large_Field_Own', 'Cash_Field_Own', 'CPT_Own', 'LevX', 'version', 'slate', 'timestamp', 'player_id', 'site']]
+        raw_display['Player'] = raw_display['Player'].map(dict(zip(wrong_nfl_team_names, right_nfl_name_teams)), na_action='ignore').fillna(raw_display['Player'])
+        load_display = raw_display[raw_display['Position'] != 'K']
+        dk_roo_raw = load_display.dropna(subset=['Median'])
+
+        dk_id_map = dict(zip(dk_roo_raw['Player'], dk_roo_raw['player_id']))
+
+        collection = nfl_db["FD_NFL_ROO"] 
+        cursor = collection.find()
+
+        raw_display = pd.DataFrame(list(cursor))
+        raw_display = raw_display.rename(columns={'player_ID': 'player_id'})
+        raw_display = raw_display[['Player', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'exFPTS', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '2x%', '3x%', '4x%',
+                                'Own', 'Small_Field_Own', 'Large_Field_Own', 'Cash_Field_Own', 'CPT_Own', 'LevX', 'version', 'slate', 'timestamp', 'player_id', 'site']]
+        raw_display['Player'] = raw_display['Player'].map(dict(zip(wrong_nfl_team_names, right_nfl_name_teams)), na_action='ignore').fillna(raw_display['Player'])
+        load_display = raw_display[raw_display['Position'] != 'K']
+        fd_roo_raw = load_display.dropna(subset=['Median'])
+
+        fd_id_map = dict(zip(fd_roo_raw['Player'], fd_roo_raw['player_id']))
+
+        dk_roo_raw = dk_roo_raw.drop(columns=['player_id'])
+        fd_roo_raw = fd_roo_raw.drop(columns=['player_id'])
+
+        dk_roo_raw = dk_roo_raw.rename(columns={'Player': 'player_names', 'Position': 'position', 'Team': 'team', 'Salary': 'salary', 'Median': 'median', 'Own': 'ownership', 'CPT_Own': 'captain ownership'})
+        fd_roo_raw = fd_roo_raw.rename(columns={'Player': 'player_names', 'Position': 'position', 'Team': 'team', 'Salary': 'salary', 'Median': 'median', 'Own': 'ownership', 'CPT_Own': 'captain ownership'})
+
+        dk_sd_roo_raw = None
+        fd_sd_roo_raw = None
+        dk_sd_id_map = None
+        fd_sd_id_map = None
+    elif type_var == 'Showdown':
+        collection = nfl_db["DK_SD_NFL_ROO"] 
+        cursor = collection.find()
+
+        raw_display = pd.DataFrame(list(cursor))
+        raw_display = raw_display.rename(columns={'player_ID': 'player_id'})
+        raw_display = raw_display[['Player', 'Position', 'Team', 'Salary', 'Median', 'Own', 'CPT_Own', 'player_id']]
+        raw_display['Player'] = raw_display['Player'].map(dict(zip(wrong_nfl_team_names, right_nfl_name_teams)), na_action='ignore').fillna(raw_display['Player'])
+        # load_display = raw_display[raw_display['Position'] != 'K']
+        dk_sd_roo_raw = raw_display.dropna(subset=['Median'])
+
+        dk_sd_id_map = dict(zip(dk_sd_roo_raw['Player'], dk_sd_roo_raw['player_id']))
+
+        collection = nfl_db["FD_SD_NFL_ROO"] 
+        cursor = collection.find()
+
+        raw_display = pd.DataFrame(list(cursor))
+        raw_display = raw_display.rename(columns={'player_ID': 'player_id'})
+        raw_display = raw_display[['Player', 'Position', 'Team', 'Salary', 'Median', 'Own', 'CPT_Own', 'player_id']]
+        raw_display['Player'] = raw_display['Player'].map(dict(zip(wrong_nfl_team_names, right_nfl_name_teams)), na_action='ignore').fillna(raw_display['Player'])
+        # load_display = raw_display[raw_display['Position'] != 'K']
+        fd_sd_roo_raw = raw_display.dropna(subset=['Median'])
+
+        fd_sd_id_map = dict(zip(fd_sd_roo_raw['Player'], fd_sd_roo_raw['player_id']))
+
+        dk_sd_roo_raw = dk_sd_roo_raw.drop(columns=['player_id'])
+        fd_sd_roo_raw = fd_sd_roo_raw.drop(columns=['player_id'])
+
+        dk_sd_roo_raw = dk_sd_roo_raw.rename(columns={'Player': 'player_names', 'Position': 'position', 'Team': 'team', 'Salary': 'salary', 'Median': 'median', 'Own': 'ownership', 'CPT_Own': 'captain ownership'})
+        fd_sd_roo_raw = fd_sd_roo_raw.rename(columns={'Player': 'player_names', 'Position': 'position', 'Team': 'team', 'Salary': 'salary', 'Median': 'median', 'Own': 'ownership', 'CPT_Own': 'captain_ownership'})
+
+        dk_roo_raw = None
+        fd_roo_raw = None
+        dk_id_map = None
+        fd_id_map = None
+
+    return dk_roo_raw, fd_roo_raw, dk_sd_roo_raw, fd_sd_roo_raw, dk_id_map, fd_id_map, dk_sd_id_map, fd_sd_id_map
+
+def init_DK_NFL_lineups(type_var, slate_var, prio_var, prio_mix, nfl_db_translation, lineup_num, player_var2):  
+
+    if prio_var == 'Mix':
+        prio_var = None
+    
+    if type_var == 'Regular':
+        if slate_var == 'Main':
+            collection = nfl_db['DK_NFL_name_map']
+            cursor = collection.find()
+            raw_data = pd.DataFrame(list(cursor))
+            raw_data['value'] = raw_data['value'].map(dict(zip(wrong_nfl_team_names, right_nfl_name_teams)), na_action='ignore').fillna(raw_data['value'])
+            names_dict = dict(zip(raw_data['key'], raw_data['value']))
+
+            collection = nfl_db['DK_NFL_seed_frame_Main Slate']
+            if prio_var == None:
+                if player_var2 != []:
+                    player_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
+                    query_conditions = []
+                    
+                    for player in player_var2:
+                        # Create a condition for each player to check if they appear in any column
+                        player_condition = {'$or': [{col: player} for col in player_columns]}
+                        query_conditions.append(player_condition)
+                    
+                    # Combine all player conditions with $or
+                    if query_conditions:
+                        filter_query = {'$or': query_conditions}
+                        cursor1 = collection.find(filter_query).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    else:
+                        cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+                else:
+                    cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor = collection.find().sort(prio_var, -1).limit(lineup_num)
+                raw_display = pd.DataFrame(list(cursor))
+            
+            raw_display = raw_display.drop_duplicates(subset=['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST'])
+
+            raw_display = raw_display[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']]
+            dict_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
+            # Map names
+            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+        elif slate_var == 'Secondary':
+            collection = nfl_db['DK_NFL_Secondary_name_map']
+            cursor = collection.find()
+            raw_data = pd.DataFrame(list(cursor))
+            raw_data['value'] = raw_data['value'].map(dict(zip(wrong_nfl_team_names, right_nfl_name_teams)), na_action='ignore').fillna(raw_data['value'])
+            names_dict = dict(zip(raw_data['key'], raw_data['value']))
+            
+            collection = nfl_db['DK_NFL_seed_frame_Secondary Slate']
+            if prio_var == None:
+                if player_var2 != []:
+                    player_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
+                    query_conditions = []
+                    
+                    for player in player_var2:
+                        # Create a condition for each player to check if they appear in any column
+                        player_condition = {'$or': [{col: player} for col in player_columns]}
+                        query_conditions.append(player_condition)
+                    
+                    # Combine all player conditions with $or
+                    if query_conditions:
+                        filter_query = {'$or': query_conditions}
+                        cursor1 = collection.find(filter_query).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    else:
+                        cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+                else:
+                    cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor = collection.find().sort(prio_var, -1).limit(lineup_num)
+                raw_display = pd.DataFrame(list(cursor))
+
+            raw_display = raw_display.drop_duplicates(subset=['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST'])
+
+            raw_display = raw_display[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']]
+            dict_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
+            # Map names
+            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+        elif slate_var == 'Auxiliary':
+            collection = nfl_db['DK_NFL_Late_name_map']
+            cursor = collection.find()
+            raw_data = pd.DataFrame(list(cursor))
+            raw_data['value'] = raw_data['value'].map(dict(zip(wrong_nfl_team_names, right_nfl_name_teams)), na_action='ignore').fillna(raw_data['value'])
+            names_dict = dict(zip(raw_data['key'], raw_data['value']))
+            
+            collection = nfl_db['DK_NFL_seed_frame_Late Slate']
+            if prio_var == None:
+                if player_var2 != []:
+                    player_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
+                    query_conditions = []
+                    
+                    for player in player_var2:
+                        # Create a condition for each player to check if they appear in any column
+                        player_condition = {'$or': [{col: player} for col in player_columns]}
+                        query_conditions.append(player_condition)
+                    
+                    # Combine all player conditions with $or
+                    if query_conditions:
+                        filter_query = {'$or': query_conditions}
+                        cursor1 = collection.find(filter_query).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    else:
+                        cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+                else:
+                    cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor = collection.find().sort(prio_var, -1).limit(lineup_num)
+                raw_display = pd.DataFrame(list(cursor))
+
+            raw_display = raw_display.drop_duplicates(subset=['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST'])
+
+            raw_display = raw_display[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']]
+            dict_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
+            # Map names
+            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+    elif type_var == 'Showdown':
+        collection = nfl_db[nfl_db_translation[slate_var]]
+        if prio_var == None:
+            if player_var2 != []:
+                player_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5']
+                query_conditions = []
+                
+                for player in player_var2:
+                    # Create a condition for each player to check if they appear in any column
+                    player_condition = {'$or': [{col: player} for col in player_columns]}
+                    query_conditions.append(player_condition)
+                
+                # Combine all player conditions with $or
+                if query_conditions:
+                    filter_query = {'$or': query_conditions}
+                    cursor1 = collection.find(filter_query).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                else:
+                    cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+        else:
+            cursor = collection.find().sort(prio_var, -1).limit(lineup_num)
+            raw_display = pd.DataFrame(list(cursor))
+
+        raw_display = raw_display.drop_duplicates(subset=['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'])
+
+        raw_display = raw_display[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5']]
+        for column in ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5']:
+            raw_display[column] = raw_display[column].map(dict(zip(wrong_nfl_team_names, right_nfl_name_teams)), na_action='ignore').fillna(raw_display[column])
+
+    DK_seed = raw_display.to_numpy()
+
+    return DK_seed
+
+def init_FD_NFL_lineups(type_var, slate_var, prio_var, prio_mix, nfl_db_translation, lineup_num, player_var2):
+
+    if prio_var == 'Mix':
+        prio_var = None
+    
+    if type_var == 'Regular':
+        if slate_var == 'Main':
+            collection = nfl_db['FD_NFL_name_map']
+            cursor = collection.find()
+            raw_data = pd.DataFrame(list(cursor))
+            raw_data['value'] = raw_data['value'].map(dict(zip(wrong_nfl_team_names, right_nfl_name_teams)), na_action='ignore').fillna(raw_data['value'])
+            names_dict = dict(zip(raw_data['key'], raw_data['value']))
+
+
+            collection = nfl_db['FD_NFL_seed_frame_Main Slate']
+            if prio_var == None:
+                if player_var2 != []:
+                    player_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
+                    query_conditions = []
+                    
+                    for player in player_var2:
+                        # Create a condition for each player to check if they appear in any column
+                        player_condition = {'$or': [{col: player} for col in player_columns]}
+                        query_conditions.append(player_condition)
+                    
+                    # Combine all player conditions with $or
+                    if query_conditions:
+                        filter_query = {'$or': query_conditions}
+                        cursor1 = collection.find(filter_query).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    else:
+                        cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+                else:
+                    cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor = collection.find().sort(prio_var, -1).limit(lineup_num)
+                raw_display = pd.DataFrame(list(cursor))
+
+            raw_display = raw_display.drop_duplicates(subset=['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST'])
+
+            raw_display = raw_display[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']]
+            dict_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
+            # Map names
+            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+        elif slate_var == 'Secondary':
+            collection = nfl_db['FD_NFL_Secondary_name_map']
+            cursor = collection.find()
+            raw_data = pd.DataFrame(list(cursor))
+            raw_data['value'] = raw_data['value'].map(dict(zip(wrong_nfl_team_names, right_nfl_name_teams)), na_action='ignore').fillna(raw_data['value'])
+            names_dict = dict(zip(raw_data['key'], raw_data['value']))
+
+            collection = nfl_db['FD_NFL_Secondary_seed_frame_Secondary Slate']
+            if prio_var == None:
+                if player_var2 != []:
+                    player_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
+                    query_conditions = []
+                    
+                    for player in player_var2:
+                        # Create a condition for each player to check if they appear in any column
+                        player_condition = {'$or': [{col: player} for col in player_columns]}
+                        query_conditions.append(player_condition)
+                    
+                    # Combine all player conditions with $or
+                    if query_conditions:
+                        filter_query = {'$or': query_conditions}
+                        cursor1 = collection.find(filter_query).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    else:
+                        cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+                else:
+                    cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor = collection.find().sort(prio_var, -1).limit(lineup_num)
+                raw_display = pd.DataFrame(list(cursor))
+
+            raw_display = raw_display.drop_duplicates(subset=['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST'])
+
+            raw_display = raw_display[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']]
+            dict_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
+            # Map names
+            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+        elif slate_var == 'Auxiliary':
+            collection = nfl_db['FD_NFL_Late_name_map']
+            cursor = collection.find()
+            raw_data = pd.DataFrame(list(cursor))
+            raw_data['value'] = raw_data['value'].map(dict(zip(wrong_nfl_team_names, right_nfl_name_teams)), na_action='ignore').fillna(raw_data['value'])
+            names_dict = dict(zip(raw_data['key'], raw_data['value']))
+
+            collection = nfl_db['FD_NFL_Late_seed_frame_Late Slate']
+            if prio_var == None:
+                if player_var2 != []:
+                    player_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
+                    query_conditions = []
+
+                    for player in player_var2:
+                        # Create a condition for each player to check if they appear in any column
+                        player_condition = {'$or': [{col: player} for col in player_columns]}
+                        query_conditions.append(player_condition)
+
+                    # Combine all player conditions with $or
+                    if query_conditions:
+                        filter_query = {'$or': query_conditions}
+                        cursor1 = collection.find(filter_query).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num = ((100 - prio_mix) / 100)))
+                    else:
+                        cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+                else:
+                    cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor = collection.find().sort(prio_var, -1).limit(lineup_num)
+                raw_display = pd.DataFrame(list(cursor))
+
+            raw_display = raw_display.drop_duplicates(subset=['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST'])
+
+            raw_display = raw_display[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']]
+            dict_columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
+            # Map names
+            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
+
+    elif type_var == 'Showdown':
+        collection = nfl_db[nfl_db_translation[slate_var]]
+        if prio_var == None:
+            if player_var2 != []:
+                player_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5']
+                query_conditions = []
+                
+                for player in player_var2:
+                    # Create a condition for each player to check if they appear in any column
+                    player_condition = {'$or': [{col: player} for col in player_columns]}
+                    query_conditions.append(player_condition)
+                
+                # Combine all player conditions with $or
+                if query_conditions:
+                    filter_query = {'$or': query_conditions}
+                    cursor1 = collection.find(filter_query).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(filter_query).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                else:
+                    cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+            else:
+                cursor1 = collection.find().limit(math.ceil(lineup_num * (prio_mix / 100)))
+                cursor2 = collection.find().sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
+        else:
+            cursor = collection.find().sort(prio_var, -1).limit(lineup_num)
+            raw_display = pd.DataFrame(list(cursor))
+
+        raw_display = raw_display.drop_duplicates(subset=['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'])
+
+        raw_display = raw_display[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5']]
+        for column in ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5']:
+            raw_display[column] = raw_display[column].map(dict(zip(wrong_nfl_team_names, right_nfl_name_teams)), na_action='ignore').fillna(raw_display[column])
+
+    FD_seed = raw_display.to_numpy()
+
+    return FD_seed

requirements.txt

@@ -1,4 +1,5 @@
 streamlit==1.48.0
+pymongo
 pandas
 numpy
 rapidfuzz