diff --git "a/database_queries.py" "b/database_queries.py"
--- "a/database_queries.py"
+++ "b/database_queries.py"
@@ -1764,23 +1764,25 @@ def init_DK_MMA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
+                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']]
+            if raw_display.empty:
+                raw_display = pd.DataFrame(columns=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
+            else:
+                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))
@@ -1804,23 +1806,25 @@ def init_DK_MMA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
+                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']]
+            if raw_display.empty:
+                raw_display = pd.DataFrame(columns=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
+            else:
+                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))
@@ -1844,23 +1848,25 @@ def init_DK_MMA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
+                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']]
+            if raw_display.empty:
+                raw_display = pd.DataFrame(columns=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
+            else:
+                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))
@@ -1879,18 +1885,18 @@ def init_DK_MMA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                 # Combine all player conditions with $or
                 if query_conditions:
                     filter_query = {'$or': query_conditions}
-                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'$and': [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(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    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(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                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(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort(prio_var, -1).limit(lineup_num)
+            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'])
@@ -1928,23 +1934,25 @@ def init_FD_MMA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
+                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']]
+            if raw_display.empty:
+                raw_display = pd.DataFrame(columns=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
+            else:
+                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))
@@ -1968,23 +1976,25 @@ def init_FD_MMA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
+                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']]
+            if raw_display.empty:
+                raw_display = pd.DataFrame(columns=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
+            else:
+                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))
@@ -2008,23 +2018,25 @@ def init_FD_MMA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num = ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
+                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']]
+            if raw_display.empty:
+                raw_display = pd.DataFrame(columns=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
+            else:
+                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))
@@ -2044,18 +2056,18 @@ def init_FD_MMA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                 # Combine all player conditions with $or
                 if query_conditions:
                     filter_query = {'$or': query_conditions}
-                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'$and': [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(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    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(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                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(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort(prio_var, -1).limit(lineup_num)
+            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'])
@@ -2160,23 +2172,25 @@ def init_DK_PGA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
+                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']]
+            if raw_display.empty:
+                raw_display = pd.DataFrame(columns=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
+            else:
+                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))
@@ -2200,23 +2214,25 @@ def init_DK_PGA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
+                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']]
+            if raw_display.empty:
+                raw_display = pd.DataFrame(columns=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
+            else:
+                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))
@@ -2240,23 +2256,25 @@ def init_DK_PGA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
+                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']]
+            if raw_display.empty:
+                raw_display = pd.DataFrame(columns=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
+            else:
+                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))
@@ -2280,23 +2298,25 @@ def init_DK_PGA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                 # Combine all player conditions with $or
                 if query_conditions:
                     filter_query = {'$or': query_conditions}
-                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'$and': [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(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    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(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                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(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort(prio_var, -1).limit(lineup_num)
+            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']]
+        if raw_display.empty:
+            raw_display = pd.DataFrame(columns=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
+        else:
+            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))
@@ -2331,23 +2351,25 @@ def init_FD_PGA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
+                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']]
+            if raw_display.empty:
+                raw_display = pd.DataFrame(columns=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
+            else:
+                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))
@@ -2371,23 +2393,25 @@ def init_FD_PGA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
+                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']]
+            if raw_display.empty:
+                raw_display = pd.DataFrame(columns=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
+            else:
+                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))
@@ -2411,23 +2435,25 @@ def init_FD_PGA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
+                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']]
+            if raw_display.empty:
+                raw_display = pd.DataFrame(columns=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
+            else:
+                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))
@@ -2451,23 +2477,25 @@ def init_FD_PGA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                 # Combine all player conditions with $or
                 if query_conditions:
                     filter_query = {'$or': query_conditions}
-                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'$and': [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(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    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(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                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(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort(prio_var, -1).limit(lineup_num)
+            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']]
+        if raw_display.empty:
+            raw_display = pd.DataFrame(columns=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
+        else:
+            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))
@@ -2576,23 +2604,25 @@ def init_DK_NASCAR_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num,
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
+                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']]
+            if raw_display.empty:
+                raw_display = pd.DataFrame(columns=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
+            else:
+                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']
             raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
         elif slate_var == 'Secondary':
@@ -2615,23 +2645,25 @@ def init_DK_NASCAR_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num,
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
+                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']]
+            if raw_display.empty:
+                raw_display = pd.DataFrame(columns=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
+            else:
+                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']
             raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
         elif slate_var == 'Auxiliary':
@@ -2654,23 +2686,25 @@ def init_DK_NASCAR_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num,
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
+                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']]
+            if raw_display.empty:
+                raw_display = pd.DataFrame(columns=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
+            else:
+                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))
@@ -2694,18 +2728,18 @@ def init_DK_NASCAR_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num,
                 # Combine all player conditions with $or
                 if query_conditions:
                     filter_query = {'$or': query_conditions}
-                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'$and': [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(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    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(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                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(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort(prio_var, -1).limit(lineup_num)
+            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'])
@@ -2745,23 +2779,25 @@ def init_FD_NASCAR_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num,
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
+                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']]
+            if raw_display.empty:
+                raw_display = pd.DataFrame(columns=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
+            else:
+                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))
@@ -2785,23 +2821,25 @@ def init_FD_NASCAR_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num,
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
+                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']]
+            if raw_display.empty:
+                raw_display = pd.DataFrame(columns=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
+            else:
+                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))
@@ -2825,23 +2863,25 @@ def init_FD_NASCAR_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num,
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    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}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
+                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']]
+            if raw_display.empty:
+                raw_display = pd.DataFrame(columns=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
+            else:
+                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))
@@ -2865,18 +2905,18 @@ def init_FD_NASCAR_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num,
                 # Combine all player conditions with $or
                 if query_conditions:
                     filter_query = {'$or': query_conditions}
-                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'$and': [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(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    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(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                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(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort(prio_var, -1).limit(lineup_num)
+            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'])