Lots of additions and improvements to the NHL update functions and addition of the NBA functions

func/NBA_own_regress.py

@@ -0,0 +1,229 @@
+import pymongo
+import pandas as pd
+import numpy as np
+import xgboost as xgb
+import lightgbm as lgb
+
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error
+from sklearn.svm import SVR
+from sklearn.neighbors import KNeighborsRegressor
+from sklearn.linear_model import LinearRegression
+
+from src.database import *
+
+collection = contest_db["NBA_reg_exposure_frames"]
+cursor = collection.find()
+raw_display = pd.DataFrame(list(cursor)).drop_duplicates(subset=['Player', 'Contest Date', 'Contest ID'])
+raw_display = raw_display[raw_display['Exposure Overall'].between(.0001, 1)]
+raw_display = raw_display[raw_display['Actual'].between(1, 100)]
+
+print(raw_display.sort_values('Exposure Overall', ascending=False).head(10))
+
+collection = nba_db["Player_Range_Of_Outcomes"]
+cursor = collection.find()
+raw_projections = pd.DataFrame(list(cursor))
+try:
+    raw_projections = raw_projections[['Player', 'Minutes Proj', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '4x%', '5x%', '6x%', 'GPP%',
+                            'Own', 'Small_Own', 'Large_Own', 'Cash_Own', 'CPT_Own', 'LevX', 'ValX', 'site', 'version', 'slate', 'timestamp', 'player_ID']]
+except:
+    raw_projections = raw_projections[['Player', 'Minutes Proj', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '4x%', '5x%', '6x%', 'GPP%',
+                            'Own', 'Small_Own', 'Large_Own', 'Cash_Own', 'CPT_Own', 'LevX', 'ValX', 'site', 'version', 'slate', 'timestamp', 'player_id']]
+    raw_projections = raw_projections.rename(columns={"player_id": "player_ID"})
+raw_projections['Median'] = raw_projections['Median'].replace('', 0).astype(float)
+
+current_projections = raw_projections[(raw_projections['slate'] == 'Main Slate') & (raw_projections['site'] == 'Draftkings')]
+
+intcols = ['Contest ID', 'Salary']
+floatcols = ['Actual', 'Exposure Overall', 'Exposure Top 1%', 'Exposure Top 5%', 'Exposure Top 10%', 'Exposure Top 20%']
+percentagecols = ['Exposure Overall', 'Exposure Top 1%', 'Exposure Top 5%', 'Exposure Top 10%', 'Exposure Top 20%']
+stringcols = ['_id', 'Player', 'Pos', 'Contest Date']
+
+for col in intcols:
+    raw_display[col] = raw_display[col].replace([np.nan, np.inf, -np.inf], 0).astype(int)
+for col in floatcols:
+    raw_display[col] = raw_display[col].replace([np.nan, np.inf, -np.inf], 0).astype(float)
+for col in percentagecols:
+    raw_display[col] = raw_display[col] * 100.0
+for col in stringcols:
+    raw_display[col] = raw_display[col].astype(str)
+
+df_clean = raw_display.dropna(subset=['Salary', 'Actual', 'Exposure Overall']).copy()
+
+df_clean['Actual'] = df_clean['Actual'] * .90
+df_clean['value'] = df_clean['Actual'] / (df_clean['Salary'] / 1000)
+df_clean['value_adv'] = df_clean['value'] - df_clean['value'].mean()
+df_clean['actual_adv'] = df_clean['Actual'] - df_clean['Actual'].mean()
+df_clean['contest_size'] = df_clean.groupby('Contest ID')['Player'].transform('count')
+df_clean['base_ownership'] = 800.0 / df_clean['contest_size']
+df_clean['value_play'] = np.where((df_clean['Salary'] <= 4000) & (df_clean['Actual'] / (df_clean['Salary'] / 1000) >= 6.0), 1, 0)
+df_clean['value_density'] = df_clean.groupby('Contest ID')['value_play'].transform('sum') / df_clean.groupby('Contest ID')['Player'].transform('count')
+df_clean['strong_play'] = np.where((df_clean['Actual'] / (df_clean['Salary'] / 1000) >= 6.0), 1, 0)
+df_clean['punt_play'] = np.where((df_clean['Salary'] < 3500) & (df_clean['Actual'] / (df_clean['Salary'] / 1000) >= 5.0), 1, 0)
+df_clean['ownership_share'] = df_clean.groupby('Contest ID')['Exposure Overall'].transform(
+    lambda x: x / x.sum() * 800
+)
+
+# Prepare features and target
+feature_cols = ['Salary', 'Actual', 'actual_adv', 'value', 'value_adv', 'contest_size', 'base_ownership', 'value_play', 'value_density', 'strong_play', 'punt_play']
+X = df_clean[feature_cols]
+y = df_clean['ownership_share']
+
+# Train-test split
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# Create and train model
+xgb_model = xgb.XGBRegressor(
+    n_estimators=1000,
+    learning_rate=0.10,
+    max_depth=5,
+    random_state=42,
+    base_score=10
+)
+
+xgb_model.fit(X_train, y_train)
+
+lgb_model = lgb.LGBMRegressor(
+    n_estimators=1000,      # number of boosting rounds
+    learning_rate=0.1,      # learning rate
+    num_leaves=31,          # max number of leaves in one tree
+    random_state=42,
+    verbose=-1              # suppress warnings during training
+)
+
+lgb_model.fit(X_train, y_train / 100)
+
+knn_model = KNeighborsRegressor(
+    n_neighbors=5,
+    weights='distance'  # or 'uniform'
+)
+
+knn_model.fit(X_train, y_train)
+
+__all__ = ['xgb_model', 'lgb_model', 'knn_model']
+
+if __name__ == '__main__':
+    X_full = df_clean[feature_cols]
+    y_full = df_clean['Exposure Overall']
+
+    # Get predictions from all your models on the full dataset
+    y_pred_xgb_full = np.clip(xgb_model.predict(X_full), 0, 100)
+    y_pred_lgb_full = np.clip(lgb_model.predict(X_full), 0, 100) * 100
+    y_pred_knn_full = np.clip(knn_model.predict(X_full), 0, 100)
+
+    # Create combo prediction
+    y_pred_combo_full = (y_pred_xgb_full + y_pred_lgb_full + y_pred_knn_full) / 3
+
+    # Create full comparison DataFrame
+    comparison_full = pd.DataFrame({
+        'Actual_Exposure': y_full.values,
+        'XGB': y_pred_xgb_full,
+        'LGB': y_pred_lgb_full,
+        'KNN': y_pred_knn_full,
+        'Combo': y_pred_combo_full,
+        'Abs_Error': np.abs(y_full.values - y_pred_combo_full)
+    })
+
+    # Add back the full features for context
+    comparison_full = pd.concat([
+        X_full.reset_index(drop=True), 
+        comparison_full.reset_index(drop=True)
+    ], axis=1)
+
+    # You can also add the original columns from df_clean for more context
+    comparison_full['Player'] = df_clean['Player'].values
+    comparison_full['Contest_Date'] = df_clean['Contest Date'].values
+    comparison_full['Pos'] = df_clean['Pos'].values
+
+    # Overall performance metrics on full dataset
+    print("\n=== Full Dataset Performance ===")
+    for model_name, predictions in [('XGB', y_pred_xgb_full), ('LGB', y_pred_lgb_full), ('KNN', y_pred_knn_full), ('Combo', y_pred_combo_full)]:
+        rmse = np.sqrt(mean_squared_error(y_full, predictions))
+        mae = mean_absolute_error(y_full, predictions)
+        r2 = r2_score(y_full, predictions)
+        print(f"{model_name:8} - RMSE: {rmse:6.2f}, MAE: {mae:6.2f}, R²: {r2:6.3f}")
+
+    # Analysis on full dataset
+    print("\n=== Highest Ownership (Full Data) ===")
+    print(comparison_full.sort_values('Actual_Exposure', ascending=False).head(10)[
+        ['Player', 'Pos', 'Salary', 'Actual', 'value', 'Actual_Exposure', 'XGB', 'LGB', 'KNN', 'Combo', 'Abs_Error']
+    ])
+
+    print("\n=== Highest Predicted Ownership (Full Data) ===")
+    print(comparison_full.sort_values('Combo', ascending=False).head(10)[
+        ['Player', 'Pos', 'Salary', 'Actual', 'value', 'Actual_Exposure', 'XGB', 'LGB', 'KNN', 'Combo', 'Abs_Error']
+    ])
+
+    print("\n=== Worst Predictions (Full Data) ===")
+    print(comparison_full.nlargest(10, 'Abs_Error')[
+        ['Player', 'Pos', 'Salary', 'Actual', 'value', 'Actual_Exposure', 'XGB', 'LGB', 'KNN', 'Combo', 'Abs_Error']
+    ])
+
+    print("\n=== Best Predictions (Full Data) ===")
+    print(comparison_full.nsmallest(10, 'Abs_Error')[
+        ['Player', 'Pos', 'Salary', 'Actual', 'value', 'Actual_Exposure', 'XGB', 'LGB', 'KNN', 'Combo', 'Abs_Error']
+    ])
+
+    # Prepare the current data with the same feature engineering
+    current_projections['Actual'] = current_projections['Median']  # Rename to match training
+    current_projections['value'] = current_projections['Actual'] / (current_projections['Salary'] / 1000)
+    current_projections['value_adv'] = current_projections['value'] - current_projections['value'].mean()
+    current_projections['actual_adv'] = current_projections['Actual'] - current_projections['Actual'].mean()
+
+    # Create the same engineered features
+    # Assuming all rows are from the same contest (current slate)
+    current_projections['contest_size'] = len(current_projections)  # All players in current slate
+
+    # Create value_play feature (same logic as training)
+    current_projections['value_play'] = np.where(
+        (current_projections['Salary'] <= 4000) & 
+        (current_projections['Actual'] / (current_projections['Salary'] / 1000) >= 6.0), 
+        1, 0
+    )
+
+    current_projections['value_density'] = current_projections['value_play'].sum() / current_projections['Player'].count()
+
+    current_projections['base_ownership'] = 800.0 / current_projections['contest_size']
+
+    current_projections['strong_play'] = np.where((current_projections['Actual'] / (current_projections['Salary'] / 1000) >= 6.0), 1, 0)
+    current_projections['punt_play'] = np.where((current_projections['Salary'] < 3500) & (current_projections['Actual'] / (current_projections['Salary'] / 1000) >= 5.0), 1, 0)
+
+    current_projections['ownership_share'] = current_projections['Own'].sum() / current_projections['Player'].count() * 800
+    # Prepare features in the same order as training
+    X_current = current_projections[feature_cols]
+
+    # Make predictions with all your models
+    current_projections['XGB'] = np.clip(xgb_model.predict(X_current), 0, 100)
+    current_projections['LGB'] = np.clip(lgb_model.predict(X_current), 0, 100) * 100
+    current_projections['KNN'] = np.clip(knn_model.predict(X_current), 0, 100)
+
+    # Create combo prediction
+    current_projections['Combo'] = (
+        (current_projections['XGB'] * .30) + 
+        (current_projections['LGB'] * .30) + 
+        (current_projections['KNN'] * .40)
+    )
+
+    current_projections['Combo'] = np.where((current_projections['value'] < 5.0) & (current_projections['Salary'] < 9000), current_projections['Combo'] * .75, current_projections['Combo'])
+    current_projections['Combo'] = np.where((current_projections['Median'] < 18.0), current_projections['Combo'] * .33, current_projections['Combo'])
+    current_projections['Combo'] = np.where((current_projections['Salary'] > 5000) & (current_projections['value'] < 4.5), 1, current_projections['Combo'])
+    current_projections['Combo'] = np.where(current_projections['value'] > 6.0, current_projections['Combo'] * ((current_projections['value'] / 6.0)), current_projections['Combo'])
+    current_projections['Combo'] = np.where((current_projections['Salary'] > 9000), current_projections['Combo'] * .75, current_projections['Combo'])
+    current_projections['Combo'] = np.where((current_projections['Salary'] > 9000) & (current_projections['Combo'] < current_projections['value']), current_projections['value'], current_projections['Combo'])
+    current_projections['Combo'] = np.where((current_projections['Median'] > 20.0) & (current_projections['Salary'] < 3500), current_projections['Combo'] * (10 - current_projections['strong_play'].sum()).clip(0, 3), current_projections['Combo'])
+    current_projections['Combo'] = np.where(current_projections['Position'].str.contains('/'), current_projections['Combo'] * 1.25, current_projections['Combo'] * .75)
+
+    power_scale = 1.10
+    combo_powered = current_projections['Combo'] ** power_scale
+
+    norm_var = 800.0 / combo_powered.sum()
+    current_projections['Combo_powered'] = combo_powered * norm_var
+
+    # Display predictions sorted by predicted ownership
+    print("\n=== Current Slate - Predicted Ownership ===")
+    print(f'the strong_play count is {current_projections['strong_play'].sum()}')
+    display_cols = ['Player', 'Position', 'Salary', 'Median', 'value', 'Own', 'XGB', 'LGB', 'KNN', 'Combo', 'Combo_powered']
+    print(f'sum of Own is {current_projections['Own'].sum()} while sum of combo is {current_projections['Combo'].sum()} while combo_powered is {current_projections['Combo_powered'].sum()}')
+    print(f'sum of position C is {current_projections[current_projections['Position'] == 'C']['Combo_powered'].sum()}')
+    print(current_projections.sort_values('Combo_powered', ascending=False)[display_cols].head(20))
+    print(current_projections[current_projections['Position'] == 'C'].sort_values('Combo_powered', ascending=False)[display_cols].head(20))

func/NHL_own_regress.py

@@ -1,13 +1,74 @@
-"""
-NHL Ownership Regression Models
-Pre-trained models for ownership prediction
-"""
+import pymongo
+import pandas as pd
+import numpy as np
 import xgboost as xgb
 import lightgbm as lgb
+
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error
+from sklearn.svm import SVR
 from sklearn.neighbors import KNeighborsRegressor
+from sklearn.linear_model import LinearRegression
+
+from src.database import *
+
+collection = contest_db["NHL_reg_exposure_frames"]
+cursor = collection.find()
+raw_display = pd.DataFrame(list(cursor)).drop_duplicates(subset=['Player', 'Contest Date', 'Contest ID'])
+raw_display = raw_display[raw_display['Exposure Overall'].between(.0001, 1)]
+raw_display = raw_display[raw_display['Actual'].between(1, 100)]
+
+print(raw_display.sort_values('Exposure Overall', ascending=False).head(10))
+
+collection = nhl_db["Player_Level_ROO"]
+cursor = collection.find()
+raw_projections = pd.DataFrame(list(cursor))
+raw_projections = raw_projections[['Player', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '2x%', '3x%', '4x%', 'Own',
+                            'Small Field Own%', 'Large Field Own%', 'Cash Own%', 'CPT_Own', 'Site', 'Type', 'Slate', 'player_id', 'timestamp']]
+raw_projections = raw_projections.rename(columns={"player_id": "player_ID"})
+raw_projections['Median'] = raw_projections['Median'].replace('', 0).astype(float)
+
+current_projections = raw_projections[(raw_projections['Slate'] == 'Main Slate') & (raw_projections['Site'] == 'Draftkings')]
+
+intcols = ['Contest ID', 'Salary']
+floatcols = ['Actual', 'Exposure Overall', 'Exposure Top 1%', 'Exposure Top 5%', 'Exposure Top 10%', 'Exposure Top 20%']
+percentagecols = ['Exposure Overall', 'Exposure Top 1%', 'Exposure Top 5%', 'Exposure Top 10%', 'Exposure Top 20%']
+stringcols = ['_id', 'Player', 'Pos', 'Contest Date']
+
+for col in intcols:
+    raw_display[col] = raw_display[col].replace([np.nan, np.inf, -np.inf], 0).astype(int)
+for col in floatcols:
+    raw_display[col] = raw_display[col].replace([np.nan, np.inf, -np.inf], 0).astype(float)
+for col in percentagecols:
+    raw_display[col] = raw_display[col] * 100.0
+for col in stringcols:
+    raw_display[col] = raw_display[col].astype(str)
+
+df_clean = raw_display.dropna(subset=['Salary', 'Actual', 'Exposure Overall']).copy()
+
+df_clean['Actual'] = df_clean['Actual'] * .90
+df_clean['value'] = df_clean['Actual'] / (df_clean['Salary'] / 1000)
+df_clean['value_adv'] = df_clean['value'] - df_clean['value'].mean()
+df_clean['actual_adv'] = df_clean['Actual'] - df_clean['Actual'].mean()
+df_clean['contest_size'] = df_clean.groupby('Contest ID')['Player'].transform('count')
+df_clean['base_ownership'] = 900.0 / df_clean['contest_size']
+df_clean['value_play'] = np.where((df_clean['Salary'] <= 4500) & (df_clean['Actual'] / (df_clean['Salary'] / 1000) >= 2.0), 1, 0)
+df_clean['value_density'] = df_clean.groupby('Contest ID')['value_play'].transform('sum') / df_clean.groupby('Contest ID')['Player'].transform('count')
+df_clean['strong_play'] = np.where((df_clean['Actual'] / (df_clean['Salary'] / 1000) >= 2.0), 1, 0)
+df_clean['punt_play'] = np.where((df_clean['Salary'] < 3500) & (df_clean['Actual'] / (df_clean['Salary'] / 1000) >= 2.0), 1, 0)
+df_clean['ownership_share'] = df_clean.groupby('Contest ID')['Exposure Overall'].transform(
+    lambda x: x / x.sum() * 900
+)
+
+# Prepare features and target
+feature_cols = ['Salary', 'Actual', 'actual_adv', 'value', 'value_adv', 'contest_size', 'base_ownership', 'value_play', 'value_density', 'strong_play', 'punt_play']
+X = df_clean[feature_cols]
+y = df_clean['ownership_share']
+
+# Train-test split
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
 
-# Create untrained model instances with default parameters
-# These will be used as-is or can be trained later if needed
+# Create and train model
 xgb_model = xgb.XGBRegressor(
     n_estimators=1000,
     learning_rate=0.10,
@@ -16,104 +77,28 @@ xgb_model = xgb.XGBRegressor(
     base_score=10
 )
 
+xgb_model.fit(X_train, y_train)
+
 lgb_model = lgb.LGBMRegressor(
-    n_estimators=1000,
-    learning_rate=0.1,
-    num_leaves=31,
+    n_estimators=1000,      # number of boosting rounds
+    learning_rate=0.1,      # learning rate
+    num_leaves=31,          # max number of leaves in one tree
     random_state=42,
-    verbose=-1
+    verbose=-1              # suppress warnings during training
 )
 
+lgb_model.fit(X_train, y_train / 100)
+
 knn_model = KNeighborsRegressor(
     n_neighbors=5,
-    weights='distance'
+    weights='distance'  # or 'uniform'
 )
 
+knn_model.fit(X_train, y_train)
+
 __all__ = ['xgb_model', 'lgb_model', 'knn_model']
 
-# Training code moved to separate script to avoid slow imports
 if __name__ == '__main__':
-    import pymongo
-    import pandas as pd
-    import numpy as np
-    from sklearn.model_selection import train_test_split
-    from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error
-
-    def init_conn():
-        uri = "mongodb+srv://multichem:Xr1q5wZdXPbxdUmJ@testcluster.lgwtp5i.mongodb.net/?retryWrites=true&w=majority"
-        client = pymongo.MongoClient(uri, retryWrites=True, serverSelectionTimeoutMS=500000)
-        contest_db = client["Contest_Information"]
-        nba_db = client["NHL_Database"]
-        return contest_db, nba_db
-        
-    contest_db, nba_db = init_conn()
-
-    collection = contest_db["NHL_reg_exposure_frames"]
-    cursor = collection.find()
-    raw_display = pd.DataFrame(list(cursor)).drop_duplicates(subset=['Player', 'Contest Date', 'Contest ID'])
-    raw_display = raw_display[raw_display['Exposure Overall'].between(.0001, 1)]
-    raw_display = raw_display[raw_display['Actual'].between(1, 100)]
-
-    print(raw_display.sort_values('Exposure Overall', ascending=False).head(10))
-
-    collection = nba_db["Player_Level_ROO"]
-    cursor = collection.find()
-    raw_projections = pd.DataFrame(list(cursor))
-    raw_projections = raw_projections[['Player', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '2x%', '3x%', '4x%', 'Own',
-                                'Small Field Own%', 'Large Field Own%', 'Cash Own%', 'CPT_Own', 'Site', 'Type', 'Slate', 'player_id', 'timestamp']]
-    raw_projections = raw_projections.rename(columns={"player_id": "player_ID"})
-    raw_projections['Median'] = raw_projections['Median'].replace('', 0).astype(float)
-
-    current_projections = raw_projections[(raw_projections['Slate'] == 'Main Slate') & (raw_projections['Site'] == 'Draftkings')]
-
-    intcols = ['Contest ID', 'Salary']
-    floatcols = ['Actual', 'Exposure Overall', 'Exposure Top 1%', 'Exposure Top 5%', 'Exposure Top 10%', 'Exposure Top 20%']
-    percentagecols = ['Exposure Overall', 'Exposure Top 1%', 'Exposure Top 5%', 'Exposure Top 10%', 'Exposure Top 20%']
-    stringcols = ['_id', 'Player', 'Pos', 'Contest Date']
-
-    for col in intcols:
-        raw_display[col] = raw_display[col].replace([np.nan, np.inf, -np.inf], 0).astype(int)
-    for col in floatcols:
-        raw_display[col] = raw_display[col].replace([np.nan, np.inf, -np.inf], 0).astype(float)
-    for col in percentagecols:
-        raw_display[col] = raw_display[col] * 100.0
-    for col in stringcols:
-        raw_display[col] = raw_display[col].astype(str)
-
-    df_clean = raw_display.dropna(subset=['Salary', 'Actual', 'Exposure Overall']).copy()
-
-    df_clean['Actual'] = df_clean['Actual'] * .90
-    df_clean['value'] = df_clean['Actual'] / (df_clean['Salary'] / 1000)
-    df_clean['value_adv'] = df_clean['value'] - df_clean['value'].mean()
-    df_clean['actual_adv'] = df_clean['Actual'] - df_clean['Actual'].mean()
-    df_clean['contest_size'] = df_clean.groupby('Contest ID')['Player'].transform('count')
-    df_clean['base_ownership'] = 900.0 / df_clean['contest_size']
-    df_clean['value_play'] = np.where((df_clean['Salary'] <= 4500) & (df_clean['Actual'] / (df_clean['Salary'] / 1000) >= 2.0), 1, 0)
-    df_clean['value_density'] = df_clean.groupby('Contest ID')['value_play'].transform('sum') / df_clean.groupby('Contest ID')['Player'].transform('count')
-    df_clean['strong_play'] = np.where((df_clean['Actual'] / (df_clean['Salary'] / 1000) >= 2.0), 1, 0)
-    df_clean['punt_play'] = np.where((df_clean['Salary'] < 3500) & (df_clean['Actual'] / (df_clean['Salary'] / 1000) >= 2.0), 1, 0)
-    df_clean['ownership_share'] = df_clean.groupby('Contest ID')['Exposure Overall'].transform(
-        lambda x: x / x.sum() * 900
-    )
-
-    # Prepare features and target
-    feature_cols = ['Salary', 'Actual', 'actual_adv', 'value', 'value_adv', 'contest_size', 'base_ownership', 'value_play', 'value_density', 'strong_play', 'punt_play']
-    X = df_clean[feature_cols]
-    y = df_clean['ownership_share']
-
-    # Train-test split
-    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
-
-    # Train models
-    print("Training XGBoost model...")
-    xgb_model.fit(X_train, y_train)
-
-    print("Training LightGBM model...")
-    lgb_model.fit(X_train, y_train / 100)
-
-    print("Training KNN model...")
-    knn_model.fit(X_train, y_train)
-
     X_full = df_clean[feature_cols]
     y_full = df_clean['Exposure Overall']
 
@@ -232,4 +217,4 @@ if __name__ == '__main__':
     print(f'sum of Own is {current_projections['Own'].sum()} while sum of combo is {current_projections['Combo'].sum()} while combo_powered is {current_projections['Combo_powered'].sum()}')
     print(f'sum of position C is {current_projections[current_projections['Position'] == 'C']['Combo_powered'].sum()}')
     print(current_projections.sort_values('Combo_powered', ascending=False)[display_cols].head(20))
-    print(current_projections[current_projections['Position'] == 'C'].sort_values('Combo_powered', ascending=False)[display_cols].head(20))
+    print(current_projections[current_projections['Position'] == 'C'].sort_values('Combo_powered', ascending=False)[display_cols].head(20))

func/dk_nba_go/NBA_seed_frames.go

@@ -0,0 +1,1133 @@
+package main
+
+import (
+	// Script Imports
+	"context"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"math/rand"
+	"os"
+	"slices"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	// MongoDB Imports
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+)
+
+type LineupData struct {
+	Salary          []int32
+	Projection      []float64
+	Team            []string
+	Team_count      []int32
+	Secondary       []string
+	Secondary_count []int32
+	Ownership       []float64
+	Players         [][]int32
+}
+
+type Player struct {
+	ID          int32   `json:"id"`
+	Name        string  `json:"name"`
+	Team        string  `json:"team"`
+	Position    string  `json:"position"`
+	Salary      int32   `json:"salary"`
+	Projection  float64 `json:"projection"`
+	Ownership   float64 `json:"ownership"`
+	SalaryValue float64 `json:"salary_value"`
+	ProjValue   float64 `json:"proj_value"`
+	OwnValue    float64 `json:"own_value"`
+	SortValue   float64 `json:"sort_value"`
+	Slate       string  `json:"slate"`
+}
+
+type PlayerSet struct {
+	Players []Player `json:"players"`
+	Maps    struct {
+		NameMap       map[string]string  `json:"name_map"`
+		SalaryMap     map[string]int32   `json:"salary_map"`
+		ProjectionMap map[string]float64 `json:"projection_map"`
+		OwnershipMap  map[string]float64 `json:"ownership_map"`
+		TeamMap       map[string]string  `json:"team_map"`
+	} `json:"maps"`
+}
+
+type ProcessedData struct {
+	PlayersMedian PlayerSet `json:"players_median"`
+}
+
+type PlayerData struct {
+	Players []Player
+	NameMap map[int]string
+}
+
+type StrengthResult struct {
+	Index int
+	Data  LineupData
+	Error error
+}
+
+type LineupDocument struct {
+	Salary          int32     `bson:"salary"`
+	Projection      float64   `bson:"proj"`
+	Team            string    `bson:"Team"`
+	Team_count      int32     `bson:"Team_count"`
+	Secondary       string    `bson:"Secondary"`
+	Secondary_count int32     `bson:"Secondary_count"`
+	Ownership       float64   `bson:"Own"`
+	PG              int32     `bson:"PG"`
+	SG              int32     `bson:"SG"`
+	SF              int32     `bson:"SF"`
+	PF              int32     `bson:"PF"`
+	C               int32     `bson:"C"`
+	G               int32     `bson:"G"`
+	F               int32     `bson:"F"`
+	FLEX            int32     `bson:"FLEX"`
+	CreatedAt       time.Time `bson:"created_at"`
+}
+
+func loadPlayerData() (*ProcessedData, error) {
+	data, err := ioutil.ReadFile("dk_nba_go/player_data.json")
+	if err != nil {
+		return nil, fmt.Errorf("failed to read in data: %v", err)
+	}
+
+	var processedData ProcessedData
+	if err := json.Unmarshal(data, &processedData); err != nil {
+		return nil, fmt.Errorf("failed to parse json: %v", err)
+	}
+
+	return &processedData, nil
+}
+
+func loadOptimals() (map[string]LineupData, error) {
+	data, err := ioutil.ReadFile("dk_nba_go/optimal_lineups.json")
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse optimals: %v", err)
+	}
+
+	type OptimalsJSON struct {
+		Slate           string  `json:"slate"`
+		Salary          int32   `json:"salary"`
+		Projection      float64 `json:"projection"`
+		Team            string  `json:"team"`
+		Team_count      int32   `json:"team_count"`
+		Secondary       string  `json:"secondary"`
+		Secondary_count int32   `json:"secondary_count"`
+		Ownership       float64 `json:"ownership"`
+		Players         []int32 `json:"players"`
+	}
+
+	var allOptimals []OptimalsJSON
+	if err := json.Unmarshal(data, &allOptimals); err != nil {
+		return nil, fmt.Errorf("failed to parse optimals JSON: %v", err)
+	}
+
+	optimalsBySlate := make(map[string]LineupData)
+
+	for _, optimal := range allOptimals {
+		if _, exists := optimalsBySlate[optimal.Slate]; !exists {
+			optimalsBySlate[optimal.Slate] = LineupData{
+				Salary:          []int32{},
+				Projection:      []float64{},
+				Team:            []string{},
+				Team_count:      []int32{},
+				Secondary:       []string{},
+				Secondary_count: []int32{},
+				Ownership:       []float64{},
+				Players:         [][]int32{},
+			}
+		}
+
+		slateData := optimalsBySlate[optimal.Slate]
+		slateData.Salary = append(slateData.Salary, optimal.Salary)
+		slateData.Projection = append(slateData.Projection, optimal.Projection)
+		slateData.Team = append(slateData.Team, optimal.Team)
+		slateData.Team_count = append(slateData.Team_count, optimal.Team_count)
+		slateData.Secondary = append(slateData.Secondary, optimal.Secondary)
+		slateData.Secondary_count = append(slateData.Secondary_count, optimal.Secondary_count)
+		slateData.Ownership = append(slateData.Ownership, optimal.Ownership)
+		slateData.Players = append(slateData.Players, optimal.Players)
+
+		optimalsBySlate[optimal.Slate] = slateData
+	}
+
+	return optimalsBySlate, nil
+}
+
+func appendOptimalLineups(results []LineupData, optimals LineupData) []LineupData {
+	if len(optimals.Salary) == 0 {
+		return results
+	}
+
+	// Simply append the optimal LineupData to existing results
+	return append(results, optimals)
+}
+
+func convertMapsToInt32Keys(playerSet *PlayerSet) (map[int32]int32, map[int32]float64, map[int32]float64, map[int32]string) {
+	salaryMap := make(map[int32]int32)
+	projMap := make(map[int32]float64)
+	ownMap := make(map[int32]float64)
+	teamMap := make(map[int32]string)
+
+	for keyStr, value := range playerSet.Maps.SalaryMap {
+		key, err := strconv.Atoi(keyStr)
+		if err != nil {
+			fmt.Printf("Error converting key %s: %v\n", keyStr, err)
+			continue
+		}
+		salaryMap[int32(key)] = value
+	}
+
+	for keyStr, value := range playerSet.Maps.ProjectionMap {
+		key, err := strconv.Atoi(keyStr)
+		if err != nil {
+			fmt.Printf("Error converting key %s: %v\n", keyStr, err)
+			continue
+		}
+		projMap[int32(key)] = value
+	}
+
+	for keyStr, value := range playerSet.Maps.OwnershipMap {
+		key, err := strconv.Atoi(keyStr)
+		if err != nil {
+			fmt.Printf("Error converting key %s: %v\n", keyStr, err)
+			continue
+		}
+		ownMap[int32(key)] = value
+	}
+
+	for keyStr, value := range playerSet.Maps.TeamMap {
+		key, err := strconv.Atoi(keyStr)
+		if err != nil {
+			fmt.Printf("Error converting key %s: %v\n", keyStr, err)
+			continue
+		}
+		teamMap[int32(key)] = value
+	}
+
+	return salaryMap, projMap, ownMap, teamMap
+}
+
+func processAndFill[T comparable, U any](input []T, valueMap map[T]U) []U {
+	result := make([]U, len(input))
+
+	for i, key := range input {
+		if value, exists := valueMap[key]; exists {
+			result[i] = value
+		} else {
+			var zero U
+			result[i] = zero
+		}
+	}
+
+	return result
+}
+
+func sortChars(strData string) string {
+	runes := []rune(strData)
+	slices.Sort(runes)
+	return string(runes)
+}
+
+func rowMostCommon(row []int) (*int, *int) {
+	if len(row) == 0 {
+		return nil, nil
+	}
+
+	counts := make(map[int]int)
+	for _, value := range row {
+		counts[value]++
+	}
+
+	if len(counts) < 2 {
+		return nil, nil
+	}
+
+	mostCommon := 0
+	maxCount := 0
+	secondMost := 0
+	secondMax := 0
+
+	for value, count := range counts {
+		if count > maxCount {
+			secondMax = maxCount
+			secondMost = mostCommon
+
+			maxCount = count
+			mostCommon = value
+		} else if count > secondMax && count < maxCount {
+			secondMax = count
+			secondMost = value
+		}
+
+	}
+
+	return &mostCommon, &secondMost
+}
+
+func rowBiggestAndSecond(row []int) (int, int) {
+	if len(row) == 0 {
+		return 0, 0
+	}
+
+	counts := make(map[int]int)
+	for _, value := range row {
+		counts[value]++
+	}
+
+	if len(counts) == 1 {
+		return len(row), 0
+	}
+
+	biggestVal := 0
+	secondBiggestVal := 0
+
+	for _, count := range counts {
+		if count > biggestVal {
+			secondBiggestVal = biggestVal
+			biggestVal = count
+		} else if count > secondBiggestVal && count < biggestVal {
+			secondBiggestVal = count
+		}
+	}
+
+	return biggestVal, secondBiggestVal
+}
+
+func createOverallDFs(players []Player, pos string) PlayerData {
+	var filteredPlayers []Player
+	for _, player := range players {
+		if pos == "FLEX" {
+			filteredPlayers = append(filteredPlayers, player)
+		} else {
+			if strings.Contains(player.Position, pos) {
+				filteredPlayers = append(filteredPlayers, player)
+			}
+		}
+	}
+
+	nameMap := make(map[int]string)
+	for i, player := range filteredPlayers {
+		nameMap[i] = player.Name
+	}
+
+	return PlayerData{
+		Players: filteredPlayers,
+		NameMap: nameMap,
+	}
+}
+
+func sumSalaryRows(data [][]int32) []int32 {
+	result := make([]int32, len(data))
+
+	for i, row := range data {
+		var sum int32
+		for _, value := range row {
+			sum += value
+		}
+		result[i] = sum
+	}
+
+	return result
+}
+
+func sumOwnRows(data [][]float64) []float64 {
+	result := make([]float64, len(data))
+
+	for i, row := range data {
+		var sum float64
+		for _, value := range row {
+			sum += value
+		}
+		result[i] = sum
+	}
+
+	return result
+}
+
+func sumProjRows(data [][]float64) []float64 {
+	result := make([]float64, len(data))
+
+	for i, row := range data {
+		var sum float64
+		for _, value := range row {
+			sum += value
+		}
+		result[i] = sum
+	}
+
+	return result
+}
+
+func filterMax[T ~int32 | ~float64](values []T, maxVal T) []int {
+	var validIndicies []int
+
+	for i, value := range values {
+		if value <= maxVal {
+			validIndicies = append(validIndicies, i)
+		}
+	}
+
+	return validIndicies
+}
+
+func filterMin[T ~int32 | ~float64](values []T, minVal T) []int {
+	var validIndicies []int
+
+	for i, value := range values {
+		if value >= minVal {
+			validIndicies = append(validIndicies, i)
+		}
+	}
+
+	return validIndicies
+}
+
+func sliceByIndicies[T any](data []T, indicies []int) []T {
+	result := make([]T, len(indicies))
+
+	for i, idx := range indicies {
+		result[i] = data[idx]
+	}
+
+	return result
+}
+
+func sortDataByField(data LineupData, field string, ascending bool) LineupData {
+	indicies := make([]int, len(data.Ownership))
+	for i := range indicies {
+		indicies[i] = i
+	}
+
+	switch field {
+	case "salary":
+		sort.Slice(indicies, func(i, j int) bool {
+			if ascending {
+				return data.Salary[indicies[i]] < data.Salary[indicies[j]]
+			}
+			return data.Salary[indicies[i]] > data.Salary[indicies[j]]
+		})
+	case "projection":
+		sort.Slice(indicies, func(i, j int) bool {
+			if ascending {
+				return data.Projection[indicies[i]] < data.Projection[indicies[j]]
+			}
+			return data.Projection[indicies[i]] > data.Projection[indicies[j]]
+		})
+	case "ownership":
+		sort.Slice(indicies, func(i, j int) bool {
+			if ascending {
+				return data.Ownership[indicies[i]] < data.Ownership[indicies[j]]
+			}
+			return data.Ownership[indicies[i]] > data.Ownership[indicies[j]]
+		})
+	default:
+		sort.Slice(indicies, func(i, j int) bool {
+			return data.Projection[indicies[i]] > data.Projection[indicies[j]]
+		})
+	}
+
+	return LineupData{
+		Salary:          sliceByIndicies(data.Salary, indicies),
+		Projection:      sliceByIndicies(data.Projection, indicies),
+		Team:            sliceByIndicies(data.Team, indicies),
+		Team_count:      sliceByIndicies(data.Team_count, indicies),
+		Secondary:       sliceByIndicies(data.Secondary, indicies),
+		Secondary_count: sliceByIndicies(data.Secondary_count, indicies),
+		Ownership:       sliceByIndicies(data.Ownership, indicies),
+		Players:         sliceByIndicies(data.Players, indicies),
+	}
+}
+
+func combineArrays(pg, sg, sf, pf, c, g, f, flex []int32) [][]int32 {
+	length := len(pg)
+
+	result := make([][]int32, length)
+
+	for i := 0; i < length; i++ {
+		result[i] = []int32{
+			pg[i],
+			sg[i],
+			sf[i],
+			pf[i],
+			c[i],
+			g[i],
+			f[i],
+			flex[i],
+		}
+	}
+
+	return result
+}
+
+func createSeedFrames(combinedArrays [][]int32, salaryMap map[int32]int32, projMap map[int32]float64, ownMap map[int32]float64, teamMap map[int32]string, site string) LineupData {
+
+	salaries := make([][]int32, len(combinedArrays))
+	projections := make([][]float64, len(combinedArrays))
+	ownership := make([][]float64, len(combinedArrays))
+	teamArrays := make([][]string, len(combinedArrays))
+
+	for i, row := range combinedArrays {
+
+		players := row[0:8]
+
+		playerSalaries := processAndFill(players, salaryMap)
+		playerProjections := processAndFill(players, projMap)
+		playerOwnership := processAndFill(players, ownMap)
+		playerTeams := processAndFill(players, teamMap)
+
+		salaries[i] = playerSalaries
+		projections[i] = playerProjections
+		ownership[i] = playerOwnership
+		teamArrays[i] = playerTeams
+	}
+
+	totalSalaries := sumSalaryRows(salaries)
+	totalProjections := sumProjRows(projections)
+	totalOwnership := sumOwnRows(ownership)
+
+	teamData := make([]string, len(teamArrays))
+	teamCounts := make([]int32, len(teamArrays))
+	secondaryData := make([]string, len(teamArrays))
+	secondaryCounts := make([]int32, len(teamArrays))
+
+	for i, teams := range teamArrays {
+		teamMap := make(map[string]int)
+		uniqueTeams := make([]string, 0)
+		for _, team := range teams {
+			if _, exists := teamMap[team]; !exists {
+				teamMap[team] = len(uniqueTeams)
+				uniqueTeams = append(uniqueTeams, team)
+			}
+		}
+
+		teamInts := make([]int, len(teams))
+		for j, team := range teams {
+			teamInts[j] = teamMap[team]
+		}
+
+		mostCommon, secondMost := rowMostCommon(teamInts)
+		if mostCommon != nil {
+			teamData[i] = uniqueTeams[*mostCommon]
+			teamCount, _ := rowBiggestAndSecond(teamInts)
+			teamCounts[i] = int32(teamCount)
+		}
+		if secondMost != nil {
+			secondaryData[i] = uniqueTeams[*secondMost]
+			_, secondaryCount := rowBiggestAndSecond(teamInts)
+			secondaryCounts[i] = int32(secondaryCount)
+		}
+	}
+
+	var validIndicies []int
+	if site == "DK" {
+		validIndicies = filterMax(totalSalaries, int32(50000))
+	} else {
+		validIndicies = filterMax(totalSalaries, int32(60000))
+	}
+
+	validData := LineupData{
+		Salary:          sliceByIndicies(totalSalaries, validIndicies),
+		Projection:      sliceByIndicies(totalProjections, validIndicies),
+		Team:            sliceByIndicies(teamData, validIndicies),
+		Team_count:      sliceByIndicies(teamCounts, validIndicies),
+		Secondary:       sliceByIndicies(secondaryData, validIndicies),
+		Secondary_count: sliceByIndicies(secondaryCounts, validIndicies),
+		Ownership:       sliceByIndicies(totalOwnership, validIndicies),
+		Players:         sliceByIndicies(combinedArrays, validIndicies),
+	}
+
+	return sortDataByField(validData, "projection", false)
+}
+
+func calculateQuantile(values []float64, quantile float64) (float64, error) {
+	if len(values) == 0 {
+		return 0, fmt.Errorf("cannot calculate quantile of empty slice")
+	}
+
+	if quantile < 0 || quantile > 1 {
+		return 0, fmt.Errorf("quantile must be between 0 and 1, got %.2f", quantile)
+	}
+
+	sorted := make([]float64, len(values))
+	copy(sorted, values)
+	sort.Float64s(sorted)
+
+	index := int(float64(len(sorted)-1) * quantile)
+	return sorted[index], nil
+}
+
+func generateUniqueRow(playerIDs []int32, count int, rng *rand.Rand) ([]int32, error) {
+	if count > len(playerIDs) {
+		return nil, fmt.Errorf("cannot generate %d unique values from %d players", count, len(playerIDs))
+	}
+
+	shuffled := make([]int32, len(playerIDs))
+	copy(shuffled, playerIDs)
+
+	for i := len(shuffled) - 1; i > 0; i-- {
+		j := rng.Intn(i + 1)
+		shuffled[i], shuffled[j] = shuffled[j], shuffled[i]
+	}
+
+	return shuffled[:count], nil
+}
+
+func generateBaseArrays(pgPlayers, sgPlayers, sfPlayers, pfPlayers, cPlayers, gPlayers, fPlayers, flexPlayers []Player, numRows int, strengthStep float64, rng *rand.Rand) ([][]int32, error) {
+
+	// DEBUG: Check pool sizes
+	fmt.Printf("DEBUG - Pool sizes: PG=%d, SG=%d, SF=%d, PF=%d, C=%d\n",
+		len(pgPlayers), len(sgPlayers), len(sfPlayers), len(pfPlayers), len(cPlayers))
+
+	if len(pgPlayers) == 0 || len(sgPlayers) == 0 || len(sfPlayers) == 0 || len(pfPlayers) == 0 || len(cPlayers) == 0 || len(gPlayers) == 0 || len(fPlayers) == 0 || len(flexPlayers) == 0 {
+		return nil, fmt.Errorf("one or more position pools is empty: PG=%d, SG=%d, SF=%d, PF=%d, C=%d, G=%d, F=%d, FLEX=%d",
+			len(pgPlayers), len(sgPlayers), len(sfPlayers), len(pfPlayers), len(cPlayers), len(gPlayers), len(fPlayers), len(flexPlayers))
+	}
+
+	var validArrays [][]int32
+	attempts := 0
+	maxAttempts := numRows * 10
+
+	for len(validArrays) < numRows && attempts < maxAttempts {
+		attempts++
+
+		pg := pgPlayers[rng.Intn(len(pgPlayers))]
+		sg := sgPlayers[rng.Intn(len(sgPlayers))]
+		sf := sfPlayers[rng.Intn(len(sfPlayers))]
+		pf := pfPlayers[rng.Intn(len(pfPlayers))]
+		c := cPlayers[rng.Intn(len(cPlayers))]
+		g := gPlayers[rng.Intn(len(gPlayers))]
+		f := fPlayers[rng.Intn(len(fPlayers))]
+		flex := flexPlayers[rng.Intn(len(flexPlayers))]
+
+		if pg.Name != sg.Name && pg.Name != sf.Name && pg.Name != pf.Name && pg.Name != g.Name && pg.Name != f.Name && pg.Name != flex.Name && sg.Name != sf.Name &&
+			sg.Name != pf.Name && sg.Name != g.Name && sg.Name != f.Name && sg.Name != flex.Name && sf.Name != pf.Name && sf.Name != g.Name && sf.Name != f.Name &&
+			sf.Name != flex.Name && pf.Name != c.Name && pf.Name != g.Name && pf.Name != f.Name && pf.Name != flex.Name && c.Name != f.Name && c.Name != flex.Name &&
+			g.Name != f.Name && g.Name != flex.Name && f.Name != flex.Name {
+
+			playerIDs := []int32{pg.ID, sg.ID, sf.ID, pf.ID, c.ID, g.ID, f.ID, flex.ID}
+			validArrays = append(validArrays, playerIDs)
+		}
+	}
+
+	if len(validArrays) == 0 {
+		return nil, fmt.Errorf("only generated %d valid lineups out of %d requested", len(validArrays), numRows)
+	}
+
+	return validArrays, nil
+}
+
+func filterPosPlayersInQuantile(players []Player, pos string, strengthStep float64) ([]Player, error) {
+	if len(players) == 0 {
+		return nil, fmt.Errorf("no players provided")
+	}
+
+	var filteredPlayers []Player
+	for _, player := range players {
+		if pos == "FLEX" {
+			filteredPlayers = append(filteredPlayers, player)
+		} else {
+			if strings.Contains(player.Position, pos) {
+				filteredPlayers = append(filteredPlayers, player)
+			}
+		}
+	}
+
+	ownVals := make([]float64, len(filteredPlayers))
+	for i, player := range filteredPlayers {
+		ownVals[i] = player.OwnValue
+	}
+
+	threshold, err := calculateQuantile(ownVals, strengthStep)
+	if err != nil {
+		return nil, err
+	}
+
+	var filtered []Player
+	for _, player := range filteredPlayers {
+		if player.OwnValue >= threshold {
+			filtered = append(filtered, player)
+		}
+	}
+
+	if len(filtered) == 0 {
+		return nil, fmt.Errorf("no players meet ownership threshold %.2f", threshold)
+	}
+
+	return filtered, nil
+}
+
+func processStrengthLevels(players []Player, strengthStep float64, numRows int, rng *rand.Rand, salaryMap map[int32]int32, projMap map[int32]float64, ownMap map[int32]float64, teamMap map[int32]string, site string) (LineupData, error) {
+
+	pgPlayers, err := filterPosPlayersInQuantile(players, "PG", strengthStep)
+	if err != nil {
+		return LineupData{}, fmt.Errorf("failed to filter PG players: %v", err)
+	}
+
+	sgPlayers, err := filterPosPlayersInQuantile(players, "SG", strengthStep)
+	if err != nil {
+		return LineupData{}, fmt.Errorf("failed to filter SG players: %v", err)
+	}
+
+	sfPlayers, err := filterPosPlayersInQuantile(players, "SF", strengthStep)
+	if err != nil {
+		return LineupData{}, fmt.Errorf("failed to filter SF players: %v", err)
+	}
+
+	pfPlayers, err := filterPosPlayersInQuantile(players, "PF", strengthStep)
+	if err != nil {
+		return LineupData{}, fmt.Errorf("failed to filter PF players: %v", err)
+	}
+
+	cPlayers, err := filterPosPlayersInQuantile(players, "C", strengthStep)
+	if err != nil {
+		return LineupData{}, fmt.Errorf("failed to filter C players: %v", err)
+	}
+
+	gPlayers, err := filterPosPlayersInQuantile(players, "G", strengthStep)
+	if err != nil {
+		return LineupData{}, fmt.Errorf("failed to filter G players: %v", err)
+	}
+
+	fPlayers, err := filterPosPlayersInQuantile(players, "F", strengthStep)
+	if err != nil {
+		return LineupData{}, fmt.Errorf("failed to filter F players: %v", err)
+	}
+
+	flexPlayers, err := filterPosPlayersInQuantile(players, "FLEX", strengthStep)
+	if err != nil {
+		return LineupData{}, fmt.Errorf("failed to filter FLEX players: %v", err)
+	}
+
+	overallArrays, err := generateBaseArrays(pgPlayers, sgPlayers, sfPlayers, pfPlayers, cPlayers, gPlayers, fPlayers, flexPlayers, numRows, strengthStep, rng)
+	if err != nil {
+		return LineupData{}, fmt.Errorf("failed to generate base arrays: %v", err)
+	}
+
+	result := createSeedFrames(overallArrays, salaryMap, projMap, ownMap, teamMap, site)
+
+	return result, nil
+}
+
+func runSeedframeRoutines(players []Player, strengthVars []float64, rowsPerLevel []int, salaryMap map[int32]int32, projMap map[int32]float64, ownMap map[int32]float64, teamMap map[int32]string, site string) ([]LineupData, error) {
+	resultsChan := make(chan StrengthResult, len(strengthVars))
+
+	for i, strengthStep := range strengthVars {
+		go func(step float64, rows int, index int) {
+			rng := rand.New(rand.NewSource(time.Now().UnixNano() + int64(index)))
+
+			result, err := processStrengthLevels(players, step, rows, rng, salaryMap, projMap, ownMap, teamMap, site)
+			resultsChan <- StrengthResult{Index: index, Data: result, Error: err}
+
+			if err != nil {
+				fmt.Printf("Error in strength level %.2f: %v\n", step, err)
+			} else {
+				fmt.Printf("Completed strength level %.2f with %d lineups\n", step, len(result.Salary))
+			}
+		}(strengthStep, rowsPerLevel[i], i)
+	}
+
+	allResults := make([]LineupData, len(strengthVars))
+	var errors []error
+	successCount := 0
+
+	for i := 0; i < len(strengthVars); i++ {
+		result := <-resultsChan
+		if result.Error != nil {
+			errors = append(errors, result.Error)
+		} else {
+			allResults[result.Index] = result.Data
+			successCount++
+		}
+	}
+
+	if successCount == 0 {
+		return nil, fmt.Errorf("all %d strength levels failed: %v", len(strengthVars), errors)
+	}
+
+	var validResults []LineupData
+	for i, result := range allResults {
+		if len(result.Salary) > 0 {
+			validResults = append(validResults, result)
+		} else {
+			fmt.Printf("skipping empty result from strength level %.2f\n", strengthVars[i])
+		}
+	}
+
+	fmt.Printf("📊 Successfully processed %d out of %d strength levels\n", len(validResults), len(strengthVars))
+	return validResults, nil
+}
+
+func printResults(results []LineupData, nameMap map[int32]string) {
+	fmt.Printf("Generated %d strength levels:\n", len(results))
+
+	// Combine all results into one big dataset
+	var allSalaries []int32
+	var allProjections []float64
+	var allOwnership []float64
+	var allPlayers [][]int32
+
+	for _, result := range results {
+		allSalaries = append(allSalaries, result.Salary...)
+		allProjections = append(allProjections, result.Projection...)
+		allOwnership = append(allOwnership, result.Ownership...)
+		allPlayers = append(allPlayers, result.Players...)
+	}
+
+	fmt.Printf("Total lineups generated: %d\n", len(allSalaries))
+
+	if len(allSalaries) > 0 {
+		// Print top 5 lineups (highest projection)
+		fmt.Printf("\nTop 5 lineups (by projection):\n")
+		for i := 0; i < 5 && i < len(allSalaries); i++ {
+			playerNames := []string{
+				getPlayerName(allPlayers[i][0], nameMap, "PG"),
+				getPlayerName(allPlayers[i][1], nameMap, "SG"),
+				getPlayerName(allPlayers[i][2], nameMap, "SF"),
+				getPlayerName(allPlayers[i][3], nameMap, "PF"),
+				getPlayerName(allPlayers[i][4], nameMap, "C"),
+				getPlayerName(allPlayers[i][5], nameMap, "G"),
+				getPlayerName(allPlayers[i][6], nameMap, "F"),
+				getPlayerName(allPlayers[i][7], nameMap, "FLEX"),
+			}
+
+			fmt.Printf("  Lineup %d: Salary=%d, Projection=%.2f, Ownership=%.3f\n",
+				i+1, allSalaries[i], allProjections[i], allOwnership[i])
+			fmt.Printf("    Players: PG=%s, SG=%s, SF=%s, PF=%s, C=%s, G=%s, F=%s, FLEX=%s\n",
+				playerNames[0], playerNames[1], playerNames[2], playerNames[3],
+				playerNames[4], playerNames[5], playerNames[6], playerNames[7])
+		}
+
+		// Print bottom 5 lineups (lowest projection)
+		if len(allSalaries) > 5 {
+			fmt.Printf("\nBottom 5 lineups (by projection):\n")
+			start := len(allSalaries) - 5
+			for i := start; i < len(allSalaries); i++ {
+				// Convert player IDs to names
+				playerNames := []string{
+					getPlayerName(allPlayers[i][0], nameMap, "PG"),
+					getPlayerName(allPlayers[i][1], nameMap, "SG"),
+					getPlayerName(allPlayers[i][2], nameMap, "SF"),
+					getPlayerName(allPlayers[i][3], nameMap, "PF"),
+					getPlayerName(allPlayers[i][4], nameMap, "C"),
+					getPlayerName(allPlayers[i][5], nameMap, "G"),
+					getPlayerName(allPlayers[i][6], nameMap, "F"),
+					getPlayerName(allPlayers[i][7], nameMap, "FLEX"),
+				}
+
+				fmt.Printf("  Lineup %d: Salary=%d, Projection=%.2f, Ownership=%.3f\n",
+					i+1, allSalaries[i], allProjections[i], allOwnership[i])
+				fmt.Printf("    Players: PG=%s, SG=%s, SF=%s, PF=%s, C=%s, G=%s, F=%s, FLEX=%s\n",
+					playerNames[0], playerNames[1], playerNames[2], playerNames[3],
+					playerNames[4], playerNames[5], playerNames[6], playerNames[7])
+			}
+		}
+	}
+}
+
+func removeDuplicates(results []LineupData) []LineupData {
+	seen := make(map[string]bool)
+	var uniqueLineups []LineupData
+
+	for _, result := range results {
+		for i := 0; i < len(result.Players); i++ {
+			// Create combo string like Python
+			combo := fmt.Sprintf("%d%d%d%d%d%d%d%d",
+				result.Players[i][0], result.Players[i][1], result.Players[i][2],
+				result.Players[i][3], result.Players[i][4], result.Players[i][5],
+				result.Players[i][6], result.Players[i][7])
+
+			// Sort combo like Python
+			sortedCombo := sortChars(combo)
+
+			if !seen[sortedCombo] {
+				seen[sortedCombo] = true
+				uniqueLineups = append(uniqueLineups, LineupData{
+					Salary:          []int32{result.Salary[i]},
+					Projection:      []float64{result.Projection[i]},
+					Team:            []string{result.Team[i]},
+					Team_count:      []int32{result.Team_count[i]},
+					Secondary:       []string{result.Secondary[i]},
+					Secondary_count: []int32{result.Secondary_count[i]},
+					Ownership:       []float64{result.Ownership[i]},
+					Players:         [][]int32{result.Players[i]},
+				})
+			}
+		}
+	}
+
+	if len(uniqueLineups) == 0 {
+		return []LineupData{}
+	}
+
+	var allSalary []int32
+	var allProjection []float64
+	var allTeam []string
+	var allTeamCount []int32
+	var allSecondary []string
+	var allSecondaryCount []int32
+	var allOwnership []float64
+	var allPlayers [][]int32
+
+	for _, lineup := range uniqueLineups {
+		allSalary = append(allSalary, lineup.Salary[0])
+		allProjection = append(allProjection, lineup.Projection[0])
+		allTeam = append(allTeam, lineup.Team[0])
+		allTeamCount = append(allTeamCount, lineup.Team_count[0])
+		allSecondary = append(allSecondary, lineup.Secondary[0])
+		allSecondaryCount = append(allSecondaryCount, lineup.Secondary_count[0])
+		allOwnership = append(allOwnership, lineup.Ownership[0])
+		allPlayers = append(allPlayers, lineup.Players[0])
+	}
+
+	return []LineupData{{
+		Salary:          allSalary,
+		Projection:      allProjection,
+		Team:            allTeam,
+		Team_count:      allTeamCount,
+		Secondary:       allSecondary,
+		Secondary_count: allSecondaryCount,
+		Ownership:       allOwnership,
+		Players:         allPlayers,
+	}}
+}
+
+func connectToMongoDB() (*mongo.Client, error) {
+	uri := "mongodb+srv://multichem:Xr1q5wZdXPbxdUmJ@testcluster.lgwtp5i.mongodb.net/?retryWrites=true&w=majority"
+
+	clientOptions := options.Client().
+		ApplyURI(uri).
+		SetRetryWrites(true).
+		SetServerSelectionTimeout(10 * time.Second).
+		SetMaxPoolSize(100).
+		SetMinPoolSize(10).
+		SetMaxConnIdleTime(30 * time.Second).
+		SetRetryReads(true)
+
+	client, err := mongo.Connect(context.TODO(), clientOptions)
+	if err != nil {
+		return nil, fmt.Errorf("failed to connect to MongoDB: %v", err)
+	}
+
+	err = client.Ping(context.TODO(), nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to ping mMongoDB %v", err)
+	}
+
+	fmt.Printf("Connected to MongoDB!")
+	return client, nil
+}
+
+func insertLineupsToMongoDB(client *mongo.Client, results []LineupData, slate string, nameMap map[int32]string, site string, sport string) error {
+	db := client.Database(fmt.Sprintf("%s_Database", sport))
+
+	collectionName := fmt.Sprintf("%s_%s_seed_frame_%s", site, sport, slate) // NOTE: change the database here
+	collection := db.Collection(collectionName)
+
+	err := collection.Drop(context.TODO())
+	if err != nil {
+		fmt.Printf("Warning: Could not drop collection %s: %v\n", collectionName, err)
+	}
+
+	var documents []interface{}
+
+	for _, result := range results {
+
+		if len(result.Salary) == 0 || len(result.Players) == 0 {
+			fmt.Printf("Warning: Empty result found, skipping\n")
+			continue
+		}
+
+		for i := 0; i < len(result.Salary); i++ {
+			if len(result.Players[i]) < 8 {
+				fmt.Printf("Warning: Lineup %d has only %d players, expected 8\n", i, len(result.Players[i]))
+			}
+
+			doc := LineupDocument{
+				Salary:          result.Salary[i],
+				Projection:      result.Projection[i],
+				Team:            result.Team[i],
+				Team_count:      result.Team_count[i],
+				Secondary:       result.Secondary[i],
+				Secondary_count: result.Secondary_count[i],
+				Ownership:       result.Ownership[i],
+				PG:              result.Players[i][0],
+				SG:              result.Players[i][1],
+				SF:              result.Players[i][2],
+				PF:              result.Players[i][3],
+				C:               result.Players[i][4],
+				G:               result.Players[i][5],
+				F:               result.Players[i][6],
+				FLEX:            result.Players[i][7],
+				CreatedAt:       time.Now(),
+			}
+
+			documents = append(documents, doc)
+		}
+	}
+
+	if len(documents) == 0 {
+		fmt.Printf("Warning: No documents to insert for slate %s\n", slate)
+	}
+
+	if len(documents) > 500000 {
+		documents = documents[:500000]
+	}
+
+	chunkSize := 250000
+	for i := 0; i < len(documents); i += chunkSize {
+		end := i + chunkSize
+		if end > len(documents) {
+			end = len(documents)
+		}
+
+		chunk := documents[i:end]
+
+		for attempt := 0; attempt < 5; attempt++ {
+			ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+
+			opts := options.InsertMany().SetOrdered(false)
+			_, err := collection.InsertMany(ctx, chunk, opts)
+			cancel()
+
+			if err == nil {
+				fmt.Printf("Successfully inserted chunk %d-%d to %s\n", i, end, collectionName)
+				break
+			}
+
+			fmt.Printf("Retry %d due to error: %v\n", attempt+1, err)
+			if attempt < 4 {
+				time.Sleep(1 * time.Second)
+			}
+		}
+
+		if err != nil {
+			return fmt.Errorf("failed to insert chunk %d-%d after 5 attempts: %v", i, end, err)
+		}
+	}
+
+	fmt.Printf("All documents inserted successfully to %s!\n", collectionName)
+	return nil
+}
+
+func groupPlayersBySlate(players []Player) map[string][]Player {
+	slateGroups := make(map[string][]Player)
+
+	for _, player := range players {
+		slateGroups[player.Slate] = append(slateGroups[player.Slate], player)
+	}
+
+	return slateGroups
+}
+
+func getPlayerName(playerID int32, nameMap map[int32]string, position string) string {
+	if name, exists := nameMap[playerID]; exists && name != "" {
+		return name
+	}
+	return fmt.Sprintf("Unknown_%s_%d", position, playerID)
+}
+
+func convertNamesToMaps(playerSet *PlayerSet) map[int32]string {
+	nameMap := make(map[int32]string)
+
+	for keyStr, value := range playerSet.Maps.NameMap {
+		key, err := strconv.Atoi(keyStr)
+		if err != nil {
+			fmt.Printf("Error coinverting name key %s: %v\n", keyStr, err)
+			continue
+		}
+		nameMap[int32(key)] = value
+	}
+
+	return nameMap
+}
+
+func main() {
+	site := "DK"
+	sport := "NBA"
+	if len(os.Args) > 1 {
+		site = os.Args[1]
+	}
+	if len(os.Args) > 2 {
+		sport = os.Args[2]
+	}
+	processedData, err := loadPlayerData()
+	if err != nil {
+		fmt.Printf("Error loading data: %v\n", err)
+		return
+	}
+
+	start := time.Now()
+	strengthVars := []float64{0.01, 0.20, 0.40, 0.60, 0.80}
+	rowsPerLevel := []int{1000000, 1000000, 1000000, 1000000, 1000000}
+
+	SlateGroups := groupPlayersBySlate(processedData.PlayersMedian.Players)
+
+	salaryMapJSON, projectionMapJSON, ownershipMapJSON, teamMapJSON := convertMapsToInt32Keys(&processedData.PlayersMedian)
+
+	nameMap := convertNamesToMaps(&processedData.PlayersMedian)
+
+	mongoClient, err := connectToMongoDB()
+	if err != nil {
+		fmt.Printf("Error connecting to MongoDB: %v\n", err)
+		return
+	}
+	defer func() {
+		if err := mongoClient.Disconnect(context.TODO()); err != nil {
+			fmt.Printf("Error disconnecting from MongoDB: %v\n", err)
+		}
+	}()
+
+	optimalsBySlate, err := loadOptimals()
+	if err != nil {
+		fmt.Printf("Warning: Could not load optimal lineups: %v\n", err)
+		optimalsBySlate = make(map[string]LineupData) // Continue with empty optimals
+	} else {
+		totalOptimals := 0
+		for _, optimals := range optimalsBySlate {
+			totalOptimals += len(optimals.Salary)
+		}
+		fmt.Printf("Loaded %d optimal lineups across all slates\n", totalOptimals)
+	}
+
+	for slate, players := range SlateGroups {
+
+		fmt.Printf("Processing slate: %s\n", slate)
+
+		results, err := runSeedframeRoutines(
+			players, strengthVars, rowsPerLevel,
+			salaryMapJSON, projectionMapJSON,
+			ownershipMapJSON, teamMapJSON, site)
+
+		if err != nil {
+			fmt.Printf("Error generating mixed lineups for slate %s: %v\n", slate, err)
+			continue
+		}
+
+		// Get optimal lineups for this specific slate
+		slateOptimals := optimalsBySlate[slate]
+
+		// Append optimal lineups for this slate
+		finalResults := appendOptimalLineups(results, slateOptimals)
+
+		exportResults := removeDuplicates(finalResults)
+
+		exportResults[0] = sortDataByField(exportResults[0], "projection", false)
+
+		err = insertLineupsToMongoDB(mongoClient, exportResults, slate, nameMap, site, sport)
+		if err != nil {
+			fmt.Printf("Error inserting to MongoDB for slate %s: %v\n", slate, err)
+			continue
+		}
+
+		printResults(exportResults, nameMap)
+	}
+
+	// Add this line at the end
+	fmt.Printf("This took %.2f seconds\n", time.Since(start).Seconds())
+}

func/fd_nba_go/NBA_seed_frames.go

@@ -0,0 +1,1118 @@
+package main
+
+import (
+	// Script Imports
+	"context"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"math/rand"
+	"os"
+	"slices"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	// MongoDB Imports
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+)
+
+type LineupData struct {
+	Salary          []int32
+	Projection      []float64
+	Team            []string
+	Team_count      []int32
+	Secondary       []string
+	Secondary_count []int32
+	Ownership       []float64
+	Players         [][]int32
+}
+
+type Player struct {
+	ID          int32   `json:"id"`
+	Name        string  `json:"name"`
+	Team        string  `json:"team"`
+	Position    string  `json:"position"`
+	Salary      int32   `json:"salary"`
+	Projection  float64 `json:"projection"`
+	Ownership   float64 `json:"ownership"`
+	SalaryValue float64 `json:"salary_value"`
+	ProjValue   float64 `json:"proj_value"`
+	OwnValue    float64 `json:"own_value"`
+	SortValue   float64 `json:"sort_value"`
+	Slate       string  `json:"slate"`
+}
+
+type PlayerSet struct {
+	Players []Player `json:"players"`
+	Maps    struct {
+		NameMap       map[string]string  `json:"name_map"`
+		SalaryMap     map[string]int32   `json:"salary_map"`
+		ProjectionMap map[string]float64 `json:"projection_map"`
+		OwnershipMap  map[string]float64 `json:"ownership_map"`
+		TeamMap       map[string]string  `json:"team_map"`
+	} `json:"maps"`
+}
+
+type ProcessedData struct {
+	PlayersMedian PlayerSet `json:"players_median"`
+}
+
+type PlayerData struct {
+	Players []Player
+	NameMap map[int]string
+}
+
+type StrengthResult struct {
+	Index int
+	Data  LineupData
+	Error error
+}
+
+type LineupDocument struct {
+	Salary          int32     `bson:"salary"`
+	Projection      float64   `bson:"proj"`
+	Team            string    `bson:"Team"`
+	Team_count      int32     `bson:"Team_count"`
+	Secondary       string    `bson:"Secondary"`
+	Secondary_count int32     `bson:"Secondary_count"`
+	Ownership       float64   `bson:"Own"`
+	PG1             int32     `bson:"PG1"`
+	PG2             int32     `bson:"PG2"`
+	SG1             int32     `bson:"SG1"`
+	SG2             int32     `bson:"SG2"`
+	SF1             int32     `bson:"SF1"`
+	SF2             int32     `bson:"SF2"`
+	PF1             int32     `bson:"PF1"`
+	PF2             int32     `bson:"PF2"`
+	C               int32     `bson:"C"`
+	CreatedAt       time.Time `bson:"created_at"`
+}
+
+func loadPlayerData() (*ProcessedData, error) {
+	data, err := ioutil.ReadFile("fd_nba_go/player_data.json")
+	if err != nil {
+		return nil, fmt.Errorf("failed to read in data: %v", err)
+	}
+
+	var processedData ProcessedData
+	if err := json.Unmarshal(data, &processedData); err != nil {
+		return nil, fmt.Errorf("failed to parse json: %v", err)
+	}
+
+	return &processedData, nil
+}
+
+func loadOptimals() (map[string]LineupData, error) {
+	data, err := ioutil.ReadFile("fd_nba_go/optimal_lineups.json")
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse optimals: %v", err)
+	}
+
+	type OptimalsJSON struct {
+		Slate           string  `json:"slate"`
+		Salary          int32   `json:"salary"`
+		Projection      float64 `json:"projection"`
+		Team            string  `json:"team"`
+		Team_count      int32   `json:"team_count"`
+		Secondary       string  `json:"secondary"`
+		Secondary_count int32   `json:"secondary_count"`
+		Ownership       float64 `json:"ownership"`
+		Players         []int32 `json:"players"`
+	}
+
+	var allOptimals []OptimalsJSON
+	if err := json.Unmarshal(data, &allOptimals); err != nil {
+		return nil, fmt.Errorf("failed to parse optimals JSON: %v", err)
+	}
+
+	optimalsBySlate := make(map[string]LineupData)
+
+	for _, optimal := range allOptimals {
+		if _, exists := optimalsBySlate[optimal.Slate]; !exists {
+			optimalsBySlate[optimal.Slate] = LineupData{
+				Salary:          []int32{},
+				Projection:      []float64{},
+				Team:            []string{},
+				Team_count:      []int32{},
+				Secondary:       []string{},
+				Secondary_count: []int32{},
+				Ownership:       []float64{},
+				Players:         [][]int32{},
+			}
+		}
+
+		slateData := optimalsBySlate[optimal.Slate]
+		slateData.Salary = append(slateData.Salary, optimal.Salary)
+		slateData.Projection = append(slateData.Projection, optimal.Projection)
+		slateData.Team = append(slateData.Team, optimal.Team)
+		slateData.Team_count = append(slateData.Team_count, optimal.Team_count)
+		slateData.Secondary = append(slateData.Secondary, optimal.Secondary)
+		slateData.Secondary_count = append(slateData.Secondary_count, optimal.Secondary_count)
+		slateData.Ownership = append(slateData.Ownership, optimal.Ownership)
+		slateData.Players = append(slateData.Players, optimal.Players)
+
+		optimalsBySlate[optimal.Slate] = slateData
+	}
+
+	return optimalsBySlate, nil
+}
+
+func appendOptimalLineups(results []LineupData, optimals LineupData) []LineupData {
+	if len(optimals.Salary) == 0 {
+		return results
+	}
+
+	// Simply append the optimal LineupData to existing results
+	return append(results, optimals)
+}
+
+func convertMapsToInt32Keys(playerSet *PlayerSet) (map[int32]int32, map[int32]float64, map[int32]float64, map[int32]string) {
+	salaryMap := make(map[int32]int32)
+	projMap := make(map[int32]float64)
+	ownMap := make(map[int32]float64)
+	teamMap := make(map[int32]string)
+
+	for keyStr, value := range playerSet.Maps.SalaryMap {
+		key, err := strconv.Atoi(keyStr)
+		if err != nil {
+			fmt.Printf("Error converting key %s: %v\n", keyStr, err)
+			continue
+		}
+		salaryMap[int32(key)] = value
+	}
+
+	for keyStr, value := range playerSet.Maps.ProjectionMap {
+		key, err := strconv.Atoi(keyStr)
+		if err != nil {
+			fmt.Printf("Error converting key %s: %v\n", keyStr, err)
+			continue
+		}
+		projMap[int32(key)] = value
+	}
+
+	for keyStr, value := range playerSet.Maps.OwnershipMap {
+		key, err := strconv.Atoi(keyStr)
+		if err != nil {
+			fmt.Printf("Error converting key %s: %v\n", keyStr, err)
+			continue
+		}
+		ownMap[int32(key)] = value
+	}
+
+	for keyStr, value := range playerSet.Maps.TeamMap {
+		key, err := strconv.Atoi(keyStr)
+		if err != nil {
+			fmt.Printf("Error converting key %s: %v\n", keyStr, err)
+			continue
+		}
+		teamMap[int32(key)] = value
+	}
+
+	return salaryMap, projMap, ownMap, teamMap
+}
+
+func processAndFill[T comparable, U any](input []T, valueMap map[T]U) []U {
+	result := make([]U, len(input))
+
+	for i, key := range input {
+		if value, exists := valueMap[key]; exists {
+			result[i] = value
+		} else {
+			var zero U
+			result[i] = zero
+		}
+	}
+
+	return result
+}
+
+func sortChars(strData string) string {
+	runes := []rune(strData)
+	slices.Sort(runes)
+	return string(runes)
+}
+
+func rowMostCommon(row []int) (*int, *int) {
+	if len(row) == 0 {
+		return nil, nil
+	}
+
+	counts := make(map[int]int)
+	for _, value := range row {
+		counts[value]++
+	}
+
+	if len(counts) < 2 {
+		return nil, nil
+	}
+
+	mostCommon := 0
+	maxCount := 0
+	secondMost := 0
+	secondMax := 0
+
+	for value, count := range counts {
+		if count > maxCount {
+			secondMax = maxCount
+			secondMost = mostCommon
+
+			maxCount = count
+			mostCommon = value
+		} else if count > secondMax && count < maxCount {
+			secondMax = count
+			secondMost = value
+		}
+
+	}
+
+	return &mostCommon, &secondMost
+}
+
+func rowBiggestAndSecond(row []int) (int, int) {
+	if len(row) == 0 {
+		return 0, 0
+	}
+
+	counts := make(map[int]int)
+	for _, value := range row {
+		counts[value]++
+	}
+
+	if len(counts) == 1 {
+		return len(row), 0
+	}
+
+	biggestVal := 0
+	secondBiggestVal := 0
+
+	for _, count := range counts {
+		if count > biggestVal {
+			secondBiggestVal = biggestVal
+			biggestVal = count
+		} else if count > secondBiggestVal && count < biggestVal {
+			secondBiggestVal = count
+		}
+	}
+
+	return biggestVal, secondBiggestVal
+}
+
+func createOverallDFs(players []Player, pos string) PlayerData {
+	var filteredPlayers []Player
+	for _, player := range players {
+		if strings.Contains(player.Position, pos) {
+			filteredPlayers = append(filteredPlayers, player)
+		}
+	}
+
+	nameMap := make(map[int]string)
+	for i, player := range filteredPlayers {
+		nameMap[i] = player.Name
+	}
+
+	return PlayerData{
+		Players: filteredPlayers,
+		NameMap: nameMap,
+	}
+}
+
+func sumSalaryRows(data [][]int32) []int32 {
+	result := make([]int32, len(data))
+
+	for i, row := range data {
+		var sum int32
+		for _, value := range row {
+			sum += value
+		}
+		result[i] = sum
+	}
+
+	return result
+}
+
+func sumOwnRows(data [][]float64) []float64 {
+	result := make([]float64, len(data))
+
+	for i, row := range data {
+		var sum float64
+		for _, value := range row {
+			sum += value
+		}
+		result[i] = sum
+	}
+
+	return result
+}
+
+func sumProjRows(data [][]float64) []float64 {
+	result := make([]float64, len(data))
+
+	for i, row := range data {
+		var sum float64
+		for _, value := range row {
+			sum += value
+		}
+		result[i] = sum
+	}
+
+	return result
+}
+
+func filterMax[T ~int32 | ~float64](values []T, maxVal T) []int {
+	var validIndicies []int
+
+	for i, value := range values {
+		if value <= maxVal {
+			validIndicies = append(validIndicies, i)
+		}
+	}
+
+	return validIndicies
+}
+
+func filterMin[T ~int32 | ~float64](values []T, minVal T) []int {
+	var validIndicies []int
+
+	for i, value := range values {
+		if value >= minVal {
+			validIndicies = append(validIndicies, i)
+		}
+	}
+
+	return validIndicies
+}
+
+func sliceByIndicies[T any](data []T, indicies []int) []T {
+	result := make([]T, len(indicies))
+
+	for i, idx := range indicies {
+		result[i] = data[idx]
+	}
+
+	return result
+}
+
+func sortDataByField(data LineupData, field string, ascending bool) LineupData {
+	indicies := make([]int, len(data.Ownership))
+	for i := range indicies {
+		indicies[i] = i
+	}
+
+	switch field {
+	case "salary":
+		sort.Slice(indicies, func(i, j int) bool {
+			if ascending {
+				return data.Salary[indicies[i]] < data.Salary[indicies[j]]
+			}
+			return data.Salary[indicies[i]] > data.Salary[indicies[j]]
+		})
+	case "projection":
+		sort.Slice(indicies, func(i, j int) bool {
+			if ascending {
+				return data.Projection[indicies[i]] < data.Projection[indicies[j]]
+			}
+			return data.Projection[indicies[i]] > data.Projection[indicies[j]]
+		})
+	case "ownership":
+		sort.Slice(indicies, func(i, j int) bool {
+			if ascending {
+				return data.Ownership[indicies[i]] < data.Ownership[indicies[j]]
+			}
+			return data.Ownership[indicies[i]] > data.Ownership[indicies[j]]
+		})
+	default:
+		sort.Slice(indicies, func(i, j int) bool {
+			return data.Projection[indicies[i]] > data.Projection[indicies[j]]
+		})
+	}
+
+	return LineupData{
+		Salary:          sliceByIndicies(data.Salary, indicies),
+		Projection:      sliceByIndicies(data.Projection, indicies),
+		Team:            sliceByIndicies(data.Team, indicies),
+		Team_count:      sliceByIndicies(data.Team_count, indicies),
+		Secondary:       sliceByIndicies(data.Secondary, indicies),
+		Secondary_count: sliceByIndicies(data.Secondary_count, indicies),
+		Ownership:       sliceByIndicies(data.Ownership, indicies),
+		Players:         sliceByIndicies(data.Players, indicies),
+	}
+}
+
+func combineArrays(pg1, pg2, sg1, sg2, sf1, sf2, pf1, pf2, c []int32) [][]int32 {
+	length := len(pg1)
+
+	result := make([][]int32, length)
+
+	for i := 0; i < length; i++ {
+		result[i] = []int32{
+			pg1[i],
+			pg2[i],
+			sg1[i],
+			sg2[i],
+			sf1[i],
+			sf2[i],
+			pf1[i],
+			pf2[i],
+			c[i],
+		}
+	}
+
+	return result
+}
+
+func createSeedFrames(combinedArrays [][]int32, salaryMap map[int32]int32, projMap map[int32]float64, ownMap map[int32]float64, teamMap map[int32]string, site string) LineupData {
+
+	salaries := make([][]int32, len(combinedArrays))
+	projections := make([][]float64, len(combinedArrays))
+	ownership := make([][]float64, len(combinedArrays))
+	teamArrays := make([][]string, len(combinedArrays))
+
+	for i, row := range combinedArrays {
+
+		players := row[0:9]
+
+		playerSalaries := processAndFill(players, salaryMap)
+		playerProjections := processAndFill(players, projMap)
+		playerOwnership := processAndFill(players, ownMap)
+		playerTeams := processAndFill(players, teamMap)
+
+		salaries[i] = playerSalaries
+		projections[i] = playerProjections
+		ownership[i] = playerOwnership
+		teamArrays[i] = playerTeams
+	}
+
+	totalSalaries := sumSalaryRows(salaries)
+	totalProjections := sumProjRows(projections)
+	totalOwnership := sumOwnRows(ownership)
+
+	teamData := make([]string, len(teamArrays))
+	teamCounts := make([]int32, len(teamArrays))
+	secondaryData := make([]string, len(teamArrays))
+	secondaryCounts := make([]int32, len(teamArrays))
+
+	for i, teams := range teamArrays {
+		teamMap := make(map[string]int)
+		uniqueTeams := make([]string, 0)
+		for _, team := range teams {
+			if _, exists := teamMap[team]; !exists {
+				teamMap[team] = len(uniqueTeams)
+				uniqueTeams = append(uniqueTeams, team)
+			}
+		}
+
+		teamInts := make([]int, len(teams))
+		for j, team := range teams {
+			teamInts[j] = teamMap[team]
+		}
+
+		mostCommon, secondMost := rowMostCommon(teamInts)
+		if mostCommon != nil {
+			teamData[i] = uniqueTeams[*mostCommon]
+			teamCount, _ := rowBiggestAndSecond(teamInts)
+			teamCounts[i] = int32(teamCount)
+		}
+		if secondMost != nil {
+			secondaryData[i] = uniqueTeams[*secondMost]
+			_, secondaryCount := rowBiggestAndSecond(teamInts)
+			secondaryCounts[i] = int32(secondaryCount)
+		}
+	}
+
+	var validIndicies []int
+	if site == "DK" {
+		validIndicies = filterMax(totalSalaries, int32(50000))
+	} else {
+		validIndicies = filterMax(totalSalaries, int32(60000))
+	}
+
+	validData := LineupData{
+		Salary:          sliceByIndicies(totalSalaries, validIndicies),
+		Projection:      sliceByIndicies(totalProjections, validIndicies),
+		Team:            sliceByIndicies(teamData, validIndicies),
+		Team_count:      sliceByIndicies(teamCounts, validIndicies),
+		Secondary:       sliceByIndicies(secondaryData, validIndicies),
+		Secondary_count: sliceByIndicies(secondaryCounts, validIndicies),
+		Ownership:       sliceByIndicies(totalOwnership, validIndicies),
+		Players:         sliceByIndicies(combinedArrays, validIndicies),
+	}
+
+	return sortDataByField(validData, "projection", false)
+}
+
+func calculateQuantile(values []float64, quantile float64) (float64, error) {
+	if len(values) == 0 {
+		return 0, fmt.Errorf("cannot calculate quantile of empty slice")
+	}
+
+	if quantile < 0 || quantile > 1 {
+		return 0, fmt.Errorf("quantile must be between 0 and 1, got %.2f", quantile)
+	}
+
+	sorted := make([]float64, len(values))
+	copy(sorted, values)
+	sort.Float64s(sorted)
+
+	index := int(float64(len(sorted)-1) * quantile)
+	return sorted[index], nil
+}
+
+func generateUniqueRow(playerIDs []int32, count int, rng *rand.Rand) ([]int32, error) {
+	if count > len(playerIDs) {
+		return nil, fmt.Errorf("cannot generate %d unique values from %d players", count, len(playerIDs))
+	}
+
+	shuffled := make([]int32, len(playerIDs))
+	copy(shuffled, playerIDs)
+
+	for i := len(shuffled) - 1; i > 0; i-- {
+		j := rng.Intn(i + 1)
+		shuffled[i], shuffled[j] = shuffled[j], shuffled[i]
+	}
+
+	return shuffled[:count], nil
+}
+
+func generateBaseArrays(pgPlayers, sgPlayers, sfPlayers, pfPlayers, cPlayers []Player, numRows int, strengthStep float64, rng *rand.Rand) ([][]int32, error) {
+
+	// DEBUG: Check pool sizes
+	fmt.Printf("DEBUG - Pool sizes: PG=%d, SG=%d, SF=%d, PF=%d, C=%d\n",
+		len(pgPlayers), len(sgPlayers), len(sfPlayers), len(pfPlayers), len(cPlayers))
+
+	if len(pgPlayers) == 0 || len(sgPlayers) == 0 || len(sfPlayers) == 0 || len(pfPlayers) == 0 || len(cPlayers) == 0 {
+		return nil, fmt.Errorf("one or more position pools is empty: PG=%d, SG=%d, SF=%d, PF=%d, C=%d",
+			len(pgPlayers), len(sgPlayers), len(sfPlayers), len(pfPlayers), len(cPlayers))
+	}
+
+	var validArrays [][]int32
+	attempts := 0
+	maxAttempts := numRows * 10
+
+	for len(validArrays) < numRows && attempts < maxAttempts {
+		attempts++
+
+		pg1 := pgPlayers[rng.Intn(len(pgPlayers))]
+		pg2 := pgPlayers[rng.Intn(len(pgPlayers))]
+		sg1 := sgPlayers[rng.Intn(len(sgPlayers))]
+		sg2 := sgPlayers[rng.Intn(len(sgPlayers))]
+		sf1 := sfPlayers[rng.Intn(len(sfPlayers))]
+		sf2 := sfPlayers[rng.Intn(len(sfPlayers))]
+		pf1 := pfPlayers[rng.Intn(len(pfPlayers))]
+		pf2 := pfPlayers[rng.Intn(len(pfPlayers))]
+		c := cPlayers[rng.Intn(len(cPlayers))]
+
+		if pg1.Name != pg2.Name && pg1.Name != sg1.Name && pg1.Name != sg2.Name && pg1.Name != sf1.Name && pg1.Name != sf2.Name && pg1.Name != pf1.Name && pg1.Name != pf2.Name &&
+			pg2.Name != sg1.Name && pg2.Name != sg2.Name && pg2.Name != sf1.Name && pg2.Name != sf2.Name && pg2.Name != pf1.Name && pg2.Name != pf2.Name &&
+			sg1.Name != sg2.Name && sg1.Name != sf1.Name && sg1.Name != sf2.Name && sg1.Name != pf1.Name && sg1.Name != pf2.Name &&
+			sg2.Name != sf1.Name && sg2.Name != sf2.Name && sg2.Name != pf1.Name && sg2.Name != pf2.Name &&
+			sf1.Name != sf2.Name && sf1.Name != pf1.Name && sf1.Name != pf2.Name && sf2.Name != pf1.Name &&
+			sf2.Name != pf2.Name && pf1.Name != pf2.Name && pf1.Name != c.Name && pf2.Name != c.Name {
+
+			playerIDs := []int32{pg1.ID, pg2.ID, sg1.ID, sg2.ID, sf1.ID, sf2.ID, pf1.ID, pf2.ID, c.ID}
+			validArrays = append(validArrays, playerIDs)
+		}
+	}
+
+	if len(validArrays) == 0 {
+		return nil, fmt.Errorf("only generated %d valid lineups out of %d requested", len(validArrays), numRows)
+	}
+
+	return validArrays, nil
+}
+
+func filterPosPlayersInQuantile(players []Player, pos string, strengthStep float64) ([]Player, error) {
+	if len(players) == 0 {
+		return nil, fmt.Errorf("no players provided")
+	}
+
+	var filteredPlayers []Player
+	for _, player := range players {
+		if strings.Contains(player.Position, pos) {
+			filteredPlayers = append(filteredPlayers, player)
+		}
+	}
+
+	ownVals := make([]float64, len(filteredPlayers))
+	for i, player := range filteredPlayers {
+		ownVals[i] = player.OwnValue
+	}
+
+	threshold, err := calculateQuantile(ownVals, strengthStep)
+	if err != nil {
+		return nil, err
+	}
+
+	var filtered []Player
+	for _, player := range filteredPlayers {
+		if player.OwnValue >= threshold {
+			filtered = append(filtered, player)
+		}
+	}
+
+	if len(filtered) == 0 {
+		return nil, fmt.Errorf("no players meet ownership threshold %.2f", threshold)
+	}
+
+	return filtered, nil
+}
+
+func processStrengthLevels(players []Player, strengthStep float64, numRows int, rng *rand.Rand, salaryMap map[int32]int32, projMap map[int32]float64, ownMap map[int32]float64, teamMap map[int32]string, site string) (LineupData, error) {
+
+	pgPlayers, err := filterPosPlayersInQuantile(players, "PG", strengthStep)
+	if err != nil {
+		return LineupData{}, fmt.Errorf("failed to filter PG players: %v", err)
+	}
+
+	sgPlayers, err := filterPosPlayersInQuantile(players, "SG", strengthStep)
+	if err != nil {
+		return LineupData{}, fmt.Errorf("failed to filter SG players: %v", err)
+	}
+
+	sfPlayers, err := filterPosPlayersInQuantile(players, "SF", strengthStep)
+	if err != nil {
+		return LineupData{}, fmt.Errorf("failed to filter SF players: %v", err)
+	}
+
+	pfPlayers, err := filterPosPlayersInQuantile(players, "PF", strengthStep)
+	if err != nil {
+		return LineupData{}, fmt.Errorf("failed to filter PF players: %v", err)
+	}
+
+	cPlayers, err := filterPosPlayersInQuantile(players, "C", strengthStep)
+	if err != nil {
+		return LineupData{}, fmt.Errorf("failed to filter C players: %v", err)
+	}
+
+	overallArrays, err := generateBaseArrays(pgPlayers, sgPlayers, sfPlayers, pfPlayers, cPlayers, numRows, strengthStep, rng)
+	if err != nil {
+		return LineupData{}, fmt.Errorf("failed to generate base arrays: %v", err)
+	}
+
+	result := createSeedFrames(overallArrays, salaryMap, projMap, ownMap, teamMap, site)
+
+	return result, nil
+}
+
+func runSeedframeRoutines(players []Player, strengthVars []float64, rowsPerLevel []int, salaryMap map[int32]int32, projMap map[int32]float64, ownMap map[int32]float64, teamMap map[int32]string, site string) ([]LineupData, error) {
+	resultsChan := make(chan StrengthResult, len(strengthVars))
+
+	for i, strengthStep := range strengthVars {
+		go func(step float64, rows int, index int) {
+			rng := rand.New(rand.NewSource(time.Now().UnixNano() + int64(index)))
+
+			result, err := processStrengthLevels(players, step, rows, rng, salaryMap, projMap, ownMap, teamMap, site)
+			resultsChan <- StrengthResult{Index: index, Data: result, Error: err}
+
+			if err != nil {
+				fmt.Printf("Error in strength level %.2f: %v\n", step, err)
+			} else {
+				fmt.Printf("Completed strength level %.2f with %d lineups\n", step, len(result.Salary))
+			}
+		}(strengthStep, rowsPerLevel[i], i)
+	}
+
+	allResults := make([]LineupData, len(strengthVars))
+	var errors []error
+	successCount := 0
+
+	for i := 0; i < len(strengthVars); i++ {
+		result := <-resultsChan
+		if result.Error != nil {
+			errors = append(errors, result.Error)
+		} else {
+			allResults[result.Index] = result.Data
+			successCount++
+		}
+	}
+
+	if successCount == 0 {
+		return nil, fmt.Errorf("all %d strength levels failed: %v", len(strengthVars), errors)
+	}
+
+	var validResults []LineupData
+	for i, result := range allResults {
+		if len(result.Salary) > 0 {
+			validResults = append(validResults, result)
+		} else {
+			fmt.Printf("skipping empty result from strength level %.2f\n", strengthVars[i])
+		}
+	}
+
+	fmt.Printf("📊 Successfully processed %d out of %d strength levels\n", len(validResults), len(strengthVars))
+	return validResults, nil
+}
+
+func printResults(results []LineupData, nameMap map[int32]string) {
+	fmt.Printf("Generated %d strength levels:\n", len(results))
+
+	// Combine all results into one big dataset
+	var allSalaries []int32
+	var allProjections []float64
+	var allOwnership []float64
+	var allPlayers [][]int32
+
+	for _, result := range results {
+		allSalaries = append(allSalaries, result.Salary...)
+		allProjections = append(allProjections, result.Projection...)
+		allOwnership = append(allOwnership, result.Ownership...)
+		allPlayers = append(allPlayers, result.Players...)
+	}
+
+	fmt.Printf("Total lineups generated: %d\n", len(allSalaries))
+
+	if len(allSalaries) > 0 {
+		// Print top 5 lineups (highest projection)
+		fmt.Printf("\nTop 5 lineups (by projection):\n")
+		for i := 0; i < 5 && i < len(allSalaries); i++ {
+			playerNames := []string{
+				getPlayerName(allPlayers[i][0], nameMap, "PG1"),
+				getPlayerName(allPlayers[i][1], nameMap, "PG2"),
+				getPlayerName(allPlayers[i][2], nameMap, "SG1"),
+				getPlayerName(allPlayers[i][3], nameMap, "SG2"),
+				getPlayerName(allPlayers[i][4], nameMap, "SF1"),
+				getPlayerName(allPlayers[i][5], nameMap, "SF2"),
+				getPlayerName(allPlayers[i][6], nameMap, "PF1"),
+				getPlayerName(allPlayers[i][7], nameMap, "PF2"),
+				getPlayerName(allPlayers[i][8], nameMap, "C"),
+			}
+
+			fmt.Printf("  Lineup %d: Salary=%d, Projection=%.2f, Ownership=%.3f\n",
+				i+1, allSalaries[i], allProjections[i], allOwnership[i])
+			fmt.Printf("    Players: PG1=%s, PG2=%s, SG1=%s, SG2=%s, SF1=%s, SF2=%s, PF1=%s, PF2=%s, C=%s\n",
+				playerNames[0], playerNames[1], playerNames[2], playerNames[3],
+				playerNames[4], playerNames[5], playerNames[6], playerNames[7], playerNames[8])
+		}
+
+		// Print bottom 5 lineups (lowest projection)
+		if len(allSalaries) > 5 {
+			fmt.Printf("\nBottom 5 lineups (by projection):\n")
+			start := len(allSalaries) - 5
+			for i := start; i < len(allSalaries); i++ {
+				// Convert player IDs to names
+				playerNames := []string{
+					getPlayerName(allPlayers[i][0], nameMap, "PG1"),
+					getPlayerName(allPlayers[i][1], nameMap, "PG2"),
+					getPlayerName(allPlayers[i][2], nameMap, "SG1"),
+					getPlayerName(allPlayers[i][3], nameMap, "SG2"),
+					getPlayerName(allPlayers[i][4], nameMap, "SF1"),
+					getPlayerName(allPlayers[i][5], nameMap, "SF2"),
+					getPlayerName(allPlayers[i][6], nameMap, "PF1"),
+					getPlayerName(allPlayers[i][7], nameMap, "PF2"),
+					getPlayerName(allPlayers[i][8], nameMap, "C"),
+				}
+
+				fmt.Printf("  Lineup %d: Salary=%d, Projection=%.2f, Ownership=%.3f\n",
+					i+1, allSalaries[i], allProjections[i], allOwnership[i])
+				fmt.Printf("    Players: PG1=%s, PG2=%s, SG1=%s, SG2=%s, SF1=%s, SF2=%s, PF1=%s, PF2=%s, C=%s\n",
+					playerNames[0], playerNames[1], playerNames[2], playerNames[3],
+					playerNames[4], playerNames[5], playerNames[6], playerNames[7], playerNames[8])
+			}
+		}
+	}
+}
+
+func removeDuplicates(results []LineupData) []LineupData {
+	seen := make(map[string]bool)
+	var uniqueLineups []LineupData
+
+	for _, result := range results {
+		for i := 0; i < len(result.Players); i++ {
+			// Create combo string like Python
+			combo := fmt.Sprintf("%d%d%d%d%d%d%d%d%d",
+				result.Players[i][0], result.Players[i][1], result.Players[i][2],
+				result.Players[i][3], result.Players[i][4], result.Players[i][5],
+				result.Players[i][6], result.Players[i][7], result.Players[i][8])
+
+			// Sort combo like Python
+			sortedCombo := sortChars(combo)
+
+			if !seen[sortedCombo] {
+				seen[sortedCombo] = true
+				uniqueLineups = append(uniqueLineups, LineupData{
+					Salary:          []int32{result.Salary[i]},
+					Projection:      []float64{result.Projection[i]},
+					Team:            []string{result.Team[i]},
+					Team_count:      []int32{result.Team_count[i]},
+					Secondary:       []string{result.Secondary[i]},
+					Secondary_count: []int32{result.Secondary_count[i]},
+					Ownership:       []float64{result.Ownership[i]},
+					Players:         [][]int32{result.Players[i]},
+				})
+			}
+		}
+	}
+
+	if len(uniqueLineups) == 0 {
+		return []LineupData{}
+	}
+
+	var allSalary []int32
+	var allProjection []float64
+	var allTeam []string
+	var allTeamCount []int32
+	var allSecondary []string
+	var allSecondaryCount []int32
+	var allOwnership []float64
+	var allPlayers [][]int32
+
+	for _, lineup := range uniqueLineups {
+		allSalary = append(allSalary, lineup.Salary[0])
+		allProjection = append(allProjection, lineup.Projection[0])
+		allTeam = append(allTeam, lineup.Team[0])
+		allTeamCount = append(allTeamCount, lineup.Team_count[0])
+		allSecondary = append(allSecondary, lineup.Secondary[0])
+		allSecondaryCount = append(allSecondaryCount, lineup.Secondary_count[0])
+		allOwnership = append(allOwnership, lineup.Ownership[0])
+		allPlayers = append(allPlayers, lineup.Players[0])
+	}
+
+	return []LineupData{{
+		Salary:          allSalary,
+		Projection:      allProjection,
+		Team:            allTeam,
+		Team_count:      allTeamCount,
+		Secondary:       allSecondary,
+		Secondary_count: allSecondaryCount,
+		Ownership:       allOwnership,
+		Players:         allPlayers,
+	}}
+}
+
+func connectToMongoDB() (*mongo.Client, error) {
+	uri := "mongodb+srv://multichem:Xr1q5wZdXPbxdUmJ@testcluster.lgwtp5i.mongodb.net/?retryWrites=true&w=majority"
+
+	clientOptions := options.Client().
+		ApplyURI(uri).
+		SetRetryWrites(true).
+		SetServerSelectionTimeout(10 * time.Second).
+		SetMaxPoolSize(100).
+		SetMinPoolSize(10).
+		SetMaxConnIdleTime(30 * time.Second).
+		SetRetryReads(true)
+
+	client, err := mongo.Connect(context.TODO(), clientOptions)
+	if err != nil {
+		return nil, fmt.Errorf("failed to connect to MongoDB: %v", err)
+	}
+
+	err = client.Ping(context.TODO(), nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to ping mMongoDB %v", err)
+	}
+
+	fmt.Printf("Connected to MongoDB!")
+	return client, nil
+}
+
+func insertLineupsToMongoDB(client *mongo.Client, results []LineupData, slate string, nameMap map[int32]string, site string, sport string) error {
+	db := client.Database(fmt.Sprintf("%s_Database", sport))
+
+	collectionName := fmt.Sprintf("%s_%s_seed_frame_%s", site, sport, slate) // NOTE: change the database here
+	collection := db.Collection(collectionName)
+
+	err := collection.Drop(context.TODO())
+	if err != nil {
+		fmt.Printf("Warning: Could not drop collection %s: %v\n", collectionName, err)
+	}
+
+	var documents []interface{}
+
+	for _, result := range results {
+
+		if len(result.Salary) == 0 || len(result.Players) == 0 {
+			fmt.Printf("Warning: Empty result found, skipping\n")
+			continue
+		}
+
+		for i := 0; i < len(result.Salary); i++ {
+			if len(result.Players[i]) < 9 {
+				fmt.Printf("Warning: Lineup %d has only %d players, expected 8\n", i, len(result.Players[i]))
+			}
+
+			doc := LineupDocument{
+				Salary:          result.Salary[i],
+				Projection:      result.Projection[i],
+				Team:            result.Team[i],
+				Team_count:      result.Team_count[i],
+				Secondary:       result.Secondary[i],
+				Secondary_count: result.Secondary_count[i],
+				Ownership:       result.Ownership[i],
+				PG1:             result.Players[i][0],
+				PG2:             result.Players[i][1],
+				SG1:             result.Players[i][2],
+				SG2:             result.Players[i][3],
+				SF1:             result.Players[i][4],
+				SF2:             result.Players[i][5],
+				PF1:             result.Players[i][6],
+				PF2:             result.Players[i][7],
+				C:               result.Players[i][8],
+				CreatedAt:       time.Now(),
+			}
+
+			documents = append(documents, doc)
+		}
+	}
+
+	if len(documents) == 0 {
+		fmt.Printf("Warning: No documents to insert for slate %s\n", slate)
+	}
+
+	if len(documents) > 500000 {
+		documents = documents[:500000]
+	}
+
+	chunkSize := 250000
+	for i := 0; i < len(documents); i += chunkSize {
+		end := i + chunkSize
+		if end > len(documents) {
+			end = len(documents)
+		}
+
+		chunk := documents[i:end]
+
+		for attempt := 0; attempt < 5; attempt++ {
+			ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+
+			opts := options.InsertMany().SetOrdered(false)
+			_, err := collection.InsertMany(ctx, chunk, opts)
+			cancel()
+
+			if err == nil {
+				fmt.Printf("Successfully inserted chunk %d-%d to %s\n", i, end, collectionName)
+				break
+			}
+
+			fmt.Printf("Retry %d due to error: %v\n", attempt+1, err)
+			if attempt < 4 {
+				time.Sleep(1 * time.Second)
+			}
+		}
+
+		if err != nil {
+			return fmt.Errorf("failed to insert chunk %d-%d after 5 attempts: %v", i, end, err)
+		}
+	}
+
+	fmt.Printf("All documents inserted successfully to %s!\n", collectionName)
+	return nil
+}
+
+func groupPlayersBySlate(players []Player) map[string][]Player {
+	slateGroups := make(map[string][]Player)
+
+	for _, player := range players {
+		slateGroups[player.Slate] = append(slateGroups[player.Slate], player)
+	}
+
+	return slateGroups
+}
+
+func getPlayerName(playerID int32, nameMap map[int32]string, position string) string {
+	if name, exists := nameMap[playerID]; exists && name != "" {
+		return name
+	}
+	return fmt.Sprintf("Unknown_%s_%d", position, playerID)
+}
+
+func convertNamesToMaps(playerSet *PlayerSet) map[int32]string {
+	nameMap := make(map[int32]string)
+
+	for keyStr, value := range playerSet.Maps.NameMap {
+		key, err := strconv.Atoi(keyStr)
+		if err != nil {
+			fmt.Printf("Error coinverting name key %s: %v\n", keyStr, err)
+			continue
+		}
+		nameMap[int32(key)] = value
+	}
+
+	return nameMap
+}
+
+func main() {
+	site := "FD"
+	sport := "NBA"
+	if len(os.Args) > 1 {
+		site = os.Args[1]
+	}
+	if len(os.Args) > 2 {
+		sport = os.Args[2]
+	}
+	processedData, err := loadPlayerData()
+	if err != nil {
+		fmt.Printf("Error loading data: %v\n", err)
+		return
+	}
+
+	start := time.Now()
+	strengthVars := []float64{0.01, 0.20, 0.40, 0.60, 0.80}
+	rowsPerLevel := []int{1000000, 1000000, 1000000, 1000000, 1000000}
+
+	SlateGroups := groupPlayersBySlate(processedData.PlayersMedian.Players)
+
+	salaryMapJSON, projectionMapJSON, ownershipMapJSON, teamMapJSON := convertMapsToInt32Keys(&processedData.PlayersMedian)
+
+	nameMap := convertNamesToMaps(&processedData.PlayersMedian)
+
+	mongoClient, err := connectToMongoDB()
+	if err != nil {
+		fmt.Printf("Error connecting to MongoDB: %v\n", err)
+		return
+	}
+	defer func() {
+		if err := mongoClient.Disconnect(context.TODO()); err != nil {
+			fmt.Printf("Error disconnecting from MongoDB: %v\n", err)
+		}
+	}()
+
+	optimalsBySlate, err := loadOptimals()
+	if err != nil {
+		fmt.Printf("Warning: Could not load optimal lineups: %v\n", err)
+		optimalsBySlate = make(map[string]LineupData) // Continue with empty optimals
+	} else {
+		totalOptimals := 0
+		for _, optimals := range optimalsBySlate {
+			totalOptimals += len(optimals.Salary)
+		}
+		fmt.Printf("Loaded %d optimal lineups across all slates\n", totalOptimals)
+	}
+
+	for slate, players := range SlateGroups {
+
+		fmt.Printf("Processing slate: %s\n", slate)
+
+		results, err := runSeedframeRoutines(
+			players, strengthVars, rowsPerLevel,
+			salaryMapJSON, projectionMapJSON,
+			ownershipMapJSON, teamMapJSON, site)
+
+		if err != nil {
+			fmt.Printf("Error generating mixed lineups for slate %s: %v\n", slate, err)
+			continue
+		}
+
+		// Get optimal lineups for this specific slate
+		slateOptimals := optimalsBySlate[slate]
+
+		// Append optimal lineups for this slate
+		finalResults := appendOptimalLineups(results, slateOptimals)
+
+		exportResults := removeDuplicates(finalResults)
+
+		exportResults[0] = sortDataByField(exportResults[0], "projection", false)
+
+		err = insertLineupsToMongoDB(mongoClient, exportResults, slate, nameMap, site, sport)
+		if err != nil {
+			fmt.Printf("Error inserting to MongoDB for slate %s: %v\n", slate, err)
+			continue
+		}
+
+		printResults(exportResults, nameMap)
+	}
+
+	// Add this line at the end
+	fmt.Printf("This took %.2f seconds\n", time.Since(start).Seconds())
+}

func/showdown_go/showdown_seed_frames.go

@@ -0,0 +1,1006 @@
+package main
+
+import (
+	// Script Imports
+	"context"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"math/rand"
+	"os"
+	"slices"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	// MongoDB Imports
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+)
+
+type LineupData struct {
+	Salary          []int32
+	Projection      []float64
+	Team            []string
+	Team_count      []int32
+	Secondary       []string
+	Secondary_count []int32
+	Ownership       []float64
+	Players         [][]int32
+}
+
+type Player struct {
+	ID          int32   `json:"id"`
+	Name        string  `json:"name"`
+	Team        string  `json:"team"`
+	Position    string  `json:"position"`
+	Salary      int32   `json:"salary"`
+	Projection  float64 `json:"projection"`
+	Ownership   float64 `json:"ownership"`
+	SalaryValue float64 `json:"salary_value"`
+	ProjValue   float64 `json:"proj_value"`
+	OwnValue    float64 `json:"own_value"`
+	SortValue   float64 `json:"sort_value"`
+	Slate       string  `json:"slate"`
+}
+
+type PlayerSet struct {
+	Players []Player `json:"players"`
+	Maps    struct {
+		NameMap       map[string]string  `json:"name_map"`
+		SalaryMap     map[string]int32   `json:"salary_map"`
+		ProjectionMap map[string]float64 `json:"projection_map"`
+		OwnershipMap  map[string]float64 `json:"ownership_map"`
+		TeamMap       map[string]string  `json:"team_map"`
+	} `json:"maps"`
+}
+
+type ProcessedData struct {
+	PlayersMedian PlayerSet `json:"players_median"`
+	CptMedian     PlayerSet `json:"cpt_median"`
+}
+
+type PlayerData struct {
+	Players []Player
+	NameMap map[int]string
+}
+
+type StrengthResult struct {
+	Index int
+	Data  LineupData
+	Error error
+}
+
+type LineupDocument struct {
+	Salary          int32     `bson:"salary"`
+	Projection      float64   `bson:"proj"`
+	Team            string    `bson:"Team"`
+	Team_count      int32     `bson:"Team_count"`
+	Secondary       string    `bson:"Secondary"`
+	Secondary_count int32     `bson:"Secondary_count"`
+	Ownership       float64   `bson:"Own"`
+	CPT             string    `bson:"CPT"`
+	FLEX1           string    `bson:"FLEX1"`
+	FLEX2           string    `bson:"FLEX2"`
+	FLEX3           string    `bson:"FLEX3"`
+	FLEX4           string    `bson:"FLEX4"`
+	FLEX5           string    `bson:"FLEX5"`
+	CreatedAt       time.Time `bson:"created_at"`
+}
+
+func loadPlayerData() (*ProcessedData, error) {
+	data, err := ioutil.ReadFile("showdown_go/player_data.json")
+	if err != nil {
+		return nil, fmt.Errorf("failed to read in data: %v", err)
+	}
+
+	var processedData ProcessedData
+	if err := json.Unmarshal(data, &processedData); err != nil {
+		return nil, fmt.Errorf("failed to parse json: %v", err)
+	}
+
+	return &processedData, nil
+}
+
+func convertMapsToInt32Keys(playerSet *PlayerSet) (map[int32]int32, map[int32]float64, map[int32]float64, map[int32]string) {
+	salaryMap := make(map[int32]int32)
+	projMap := make(map[int32]float64)
+	ownMap := make(map[int32]float64)
+	teamMap := make(map[int32]string)
+
+	for keyStr, value := range playerSet.Maps.SalaryMap {
+		key, err := strconv.Atoi(keyStr)
+		if err != nil {
+			fmt.Printf("Error converting key %s: %v\n", keyStr, err)
+			continue
+		}
+		salaryMap[int32(key)] = value
+	}
+
+	for keyStr, value := range playerSet.Maps.ProjectionMap {
+		key, err := strconv.Atoi(keyStr)
+		if err != nil {
+			fmt.Printf("Error converting key %s: %v\n", keyStr, err)
+			continue
+		}
+		projMap[int32(key)] = value
+	}
+
+	for keyStr, value := range playerSet.Maps.OwnershipMap {
+		key, err := strconv.Atoi(keyStr)
+		if err != nil {
+			fmt.Printf("Error converting key %s: %v\n", keyStr, err)
+			continue
+		}
+		ownMap[int32(key)] = value
+	}
+
+	for keyStr, value := range playerSet.Maps.TeamMap {
+		key, err := strconv.Atoi(keyStr)
+		if err != nil {
+			fmt.Printf("Error converting key %s: %v\n", keyStr, err)
+			continue
+		}
+		teamMap[int32(key)] = value
+	}
+
+	return salaryMap, projMap, ownMap, teamMap
+}
+
+func processAndFill[T comparable, U any](input []T, valueMap map[T]U) []U {
+	result := make([]U, len(input))
+
+	for i, key := range input {
+		if value, exists := valueMap[key]; exists {
+			result[i] = value
+		} else {
+			var zero U
+			result[i] = zero
+		}
+	}
+
+	return result
+}
+
+func sortChars(strData string) string {
+	runes := []rune(strData)
+	slices.Sort(runes)
+	return string(runes)
+}
+
+func rowMostCommon(row []int) (*int, *int) {
+	if len(row) == 0 {
+		return nil, nil
+	}
+
+	counts := make(map[int]int)
+	for _, value := range row {
+		counts[value]++
+	}
+
+	if len(counts) < 2 {
+		return nil, nil
+	}
+
+	mostCommon := 0
+	maxCount := 0
+	secondMost := 0
+	secondMax := 0
+
+	for value, count := range counts {
+		if count > maxCount {
+			secondMax = maxCount
+			secondMost = mostCommon
+
+			maxCount = count
+			mostCommon = value
+		} else if count > secondMax && count < maxCount {
+			secondMax = count
+			secondMost = value
+		}
+
+	}
+
+	return &mostCommon, &secondMost
+}
+
+func rowBiggestAndSecond(row []int) (int, int) {
+	if len(row) == 0 {
+		return 0, 0
+	}
+
+	counts := make(map[int]int)
+	for _, value := range row {
+		counts[value]++
+	}
+
+	if len(counts) == 1 {
+		return len(row), 0
+	}
+
+	biggestVal := 0
+	secondBiggestVal := 0
+
+	for _, count := range counts {
+		if count > biggestVal {
+			secondBiggestVal = biggestVal
+			biggestVal = count
+		} else if count > secondBiggestVal && count < biggestVal {
+			secondBiggestVal = count
+		}
+	}
+
+	return biggestVal, secondBiggestVal
+}
+
+func createOverallDFs(players []Player, pos string) PlayerData {
+	var filteredPlayers []Player
+	for _, player := range players {
+		if strings.Contains(player.Position, pos) {
+			filteredPlayers = append(filteredPlayers, player)
+		}
+	}
+
+	nameMap := make(map[int]string)
+	for i, player := range filteredPlayers {
+		nameMap[i] = player.Name
+	}
+
+	return PlayerData{
+		Players: filteredPlayers,
+		NameMap: nameMap,
+	}
+}
+
+func sumSalaryRows(data [][]int32) []int32 {
+	result := make([]int32, len(data))
+
+	for i, row := range data {
+		var sum int32
+		for _, value := range row {
+			sum += value
+		}
+		result[i] = sum
+	}
+
+	return result
+}
+
+func sumOwnRows(data [][]float64) []float64 {
+	result := make([]float64, len(data))
+
+	for i, row := range data {
+		var sum float64
+		for _, value := range row {
+			sum += value
+		}
+		result[i] = sum
+	}
+
+	return result
+}
+
+func sumProjRows(data [][]float64) []float64 {
+	result := make([]float64, len(data))
+
+	for i, row := range data {
+		var sum float64
+		for _, value := range row {
+			sum += value
+		}
+		result[i] = sum
+	}
+
+	return result
+}
+
+func filterMax[T ~int32 | ~float64](values []T, maxVal T) []int {
+	var validIndicies []int
+
+	for i, value := range values {
+		if value <= maxVal {
+			validIndicies = append(validIndicies, i)
+		}
+	}
+
+	return validIndicies
+}
+
+func filterMin[T ~int32 | ~float64](values []T, minVal T) []int {
+	var validIndicies []int
+
+	for i, value := range values {
+		if value >= minVal {
+			validIndicies = append(validIndicies, i)
+		}
+	}
+
+	return validIndicies
+}
+
+func sliceByIndicies[T any](data []T, indicies []int) []T {
+	result := make([]T, len(indicies))
+
+	for i, idx := range indicies {
+		result[i] = data[idx]
+	}
+
+	return result
+}
+
+func sortDataByField(data LineupData, field string, ascending bool) LineupData {
+	indicies := make([]int, len(data.Ownership))
+	for i := range indicies {
+		indicies[i] = i
+	}
+
+	switch field {
+	case "salary":
+		sort.Slice(indicies, func(i, j int) bool {
+			if ascending {
+				return data.Salary[indicies[i]] < data.Salary[indicies[j]]
+			}
+			return data.Salary[indicies[i]] > data.Salary[indicies[j]]
+		})
+	case "projection":
+		sort.Slice(indicies, func(i, j int) bool {
+			if ascending {
+				return data.Projection[indicies[i]] < data.Projection[indicies[j]]
+			}
+			return data.Projection[indicies[i]] > data.Projection[indicies[j]]
+		})
+	case "ownership":
+		sort.Slice(indicies, func(i, j int) bool {
+			if ascending {
+				return data.Ownership[indicies[i]] < data.Ownership[indicies[j]]
+			}
+			return data.Ownership[indicies[i]] > data.Ownership[indicies[j]]
+		})
+	default:
+		sort.Slice(indicies, func(i, j int) bool {
+			return data.Projection[indicies[i]] > data.Projection[indicies[j]]
+		})
+	}
+
+	return LineupData{
+		Salary:          sliceByIndicies(data.Salary, indicies),
+		Projection:      sliceByIndicies(data.Projection, indicies),
+		Team:            sliceByIndicies(data.Team, indicies),
+		Team_count:      sliceByIndicies(data.Team_count, indicies),
+		Secondary:       sliceByIndicies(data.Secondary, indicies),
+		Secondary_count: sliceByIndicies(data.Secondary_count, indicies),
+		Ownership:       sliceByIndicies(data.Ownership, indicies),
+		Players:         sliceByIndicies(data.Players, indicies),
+	}
+}
+
+func combineArrays(flex1, flex2, flex3, flex4, flex5, flex6 []int32) [][]int32 {
+	length := len(flex1)
+
+	result := make([][]int32, length)
+
+	for i := 0; i < length; i++ {
+		result[i] = []int32{
+			flex1[i],
+			flex2[i],
+			flex3[i],
+			flex4[i],
+			flex5[i],
+			flex6[i],
+		}
+	}
+
+	return result
+}
+
+func createSeedFrames(combinedArrays [][]int32, cptSalaryMap, flexSalaryMap map[int32]int32, cptProjMap, flexProjMap map[int32]float64, cptOwnMap, flexOwnMap map[int32]float64, cptTeamMap, flexTeamMap map[int32]string, site string) LineupData {
+
+	salaries := make([][]int32, len(combinedArrays))
+	projections := make([][]float64, len(combinedArrays))
+	ownership := make([][]float64, len(combinedArrays))
+	teamArrays := make([][]string, len(combinedArrays))
+
+	for i, row := range combinedArrays {
+
+		cptPlayers := []int32{row[0]}
+		flexPlayers := row[1:]
+
+		cptSalaries := processAndFill(cptPlayers, cptSalaryMap)
+		cptProjections := processAndFill(cptPlayers, cptProjMap)
+		cptOwnership := processAndFill(cptPlayers, cptOwnMap)
+		cptTeams := processAndFill(cptPlayers, cptTeamMap)
+
+		flexSalaries := processAndFill(flexPlayers, flexSalaryMap)
+		flexProjections := processAndFill(flexPlayers, flexProjMap)
+		flexOwnership := processAndFill(flexPlayers, flexOwnMap)
+		flexTeams := processAndFill(flexPlayers, flexTeamMap)
+
+		salaries[i] = append(cptSalaries, flexSalaries...)
+		projections[i] = append(cptProjections, flexProjections...)
+		ownership[i] = append(cptOwnership, flexOwnership...)
+		teamArrays[i] = append(cptTeams, flexTeams...)
+	}
+
+	totalSalaries := sumSalaryRows(salaries)
+	totalProjections := sumProjRows(projections)
+	totalOwnership := sumOwnRows(ownership)
+
+	teamData := make([]string, len(teamArrays))
+	teamCounts := make([]int32, len(teamArrays))
+	secondaryData := make([]string, len(teamArrays))
+	secondaryCounts := make([]int32, len(teamArrays))
+
+	for i, teams := range teamArrays {
+		teamMap := make(map[string]int)
+		uniqueTeams := make([]string, 0)
+		for _, team := range teams {
+			if _, exists := teamMap[team]; !exists {
+				teamMap[team] = len(uniqueTeams)
+				uniqueTeams = append(uniqueTeams, team)
+			}
+		}
+
+		teamInts := make([]int, len(teams))
+		for j, team := range teams {
+			teamInts[j] = teamMap[team]
+		}
+
+		mostCommon, secondMost := rowMostCommon(teamInts)
+		if mostCommon != nil {
+			teamData[i] = uniqueTeams[*mostCommon]
+			teamCount, _ := rowBiggestAndSecond(teamInts)
+			teamCounts[i] = int32(teamCount)
+		}
+		if secondMost != nil {
+			secondaryData[i] = uniqueTeams[*secondMost]
+			_, secondaryCount := rowBiggestAndSecond(teamInts)
+			secondaryCounts[i] = int32(secondaryCount)
+		}
+	}
+
+	var validIndicies []int
+	if site == "DK" {
+		validIndicies = filterMax(totalSalaries, int32(50000))
+	} else {
+		validIndicies = filterMax(totalSalaries, int32(60000))
+	}
+
+	validData := LineupData{
+		Salary:          sliceByIndicies(totalSalaries, validIndicies),
+		Projection:      sliceByIndicies(totalProjections, validIndicies),
+		Team:            sliceByIndicies(teamData, validIndicies),
+		Team_count:      sliceByIndicies(teamCounts, validIndicies),
+		Secondary:       sliceByIndicies(secondaryData, validIndicies),
+		Secondary_count: sliceByIndicies(secondaryCounts, validIndicies),
+		Ownership:       sliceByIndicies(totalOwnership, validIndicies),
+		Players:         sliceByIndicies(combinedArrays, validIndicies),
+	}
+
+	return sortDataByField(validData, "ownership", false)
+}
+
+func calculateQuantile(values []float64, quantile float64) (float64, error) {
+	if len(values) == 0 {
+		return 0, fmt.Errorf("cannot calculate quantile of empty slice")
+	}
+
+	if quantile < 0 || quantile > 1 {
+		return 0, fmt.Errorf("quantile must be between 0 and 1, got %.2f", quantile)
+	}
+
+	sorted := make([]float64, len(values))
+	copy(sorted, values)
+	sort.Float64s(sorted)
+
+	index := int(float64(len(sorted)-1) * quantile)
+	return sorted[index], nil
+}
+
+func generateUniqueRow(playerIDs []int32, count int, rng *rand.Rand) ([]int32, error) {
+	if count > len(playerIDs) {
+		return nil, fmt.Errorf("cannot generate %d unique values from %d players", count, len(playerIDs))
+	}
+
+	shuffled := make([]int32, len(playerIDs))
+	copy(shuffled, playerIDs)
+
+	for i := len(shuffled) - 1; i > 0; i-- {
+		j := rng.Intn(i + 1)
+		shuffled[i], shuffled[j] = shuffled[j], shuffled[i]
+	}
+
+	return shuffled[:count], nil
+}
+
+func generateBaseArrays(cptPlayers, flexPlayers []Player, numRows int, rng *rand.Rand) ([][]int32, error) {
+
+	if len(cptPlayers) < 1 || len(flexPlayers) < 5 {
+		return nil, fmt.Errorf("need at least 1 cpt and 5 flex, got %d cpt and %d flex", len(cptPlayers), len(flexPlayers))
+	}
+
+	var validArrays [][]int32
+	attempts := 0
+	maxAttempts := numRows * 10
+
+	for len(validArrays) < numRows && attempts < maxAttempts {
+		attempts++
+
+		cptPlayer := cptPlayers[rng.Intn(len(cptPlayers))]
+		flexPlayers_selected := make([]Player, 5)
+
+		for i := 0; i < 5; i++ {
+			flexPlayers_selected[i] = flexPlayers[rng.Intn(len(flexPlayers))]
+		}
+
+		flexNames := make([]string, 5)
+		for i, player := range flexPlayers_selected {
+			flexNames[i] = player.Name
+		}
+
+		if flexNames[0] != flexNames[1] && flexNames[0] != flexNames[2] && flexNames[0] != flexNames[3] && flexNames[0] != flexNames[4] &&
+			flexNames[1] != flexNames[2] && flexNames[1] != flexNames[3] && flexNames[1] != flexNames[4] &&
+			flexNames[2] != flexNames[3] && flexNames[2] != flexNames[4] &&
+			flexNames[3] != flexNames[4] {
+
+			cptUnique := true
+			for _, flexName := range flexNames {
+				if cptPlayer.Name == flexName {
+					cptUnique = false
+					break
+				}
+			}
+
+			if cptUnique {
+				flexIDs := make([]int32, 5)
+				for i, player := range flexPlayers_selected {
+					flexIDs[i] = player.ID
+				}
+				combinedRow := append([]int32{cptPlayer.ID}, flexIDs...)
+				validArrays = append(validArrays, combinedRow)
+			}
+		}
+	}
+
+	if len(validArrays) == 0 {
+		return nil, fmt.Errorf("only generated %d valid lineups out of %d requested", len(validArrays), numRows)
+	}
+
+	return validArrays, nil
+}
+
+func filterPlayersInQuantile(players []Player, strengthStep float64) ([]Player, error) {
+	if len(players) == 0 {
+		return nil, fmt.Errorf("no players provided")
+	}
+
+	ownVals := make([]float64, len(players))
+	for i, player := range players {
+		ownVals[i] = player.OwnValue
+	}
+
+	threshold, err := calculateQuantile(ownVals, strengthStep)
+	if err != nil {
+		return nil, err
+	}
+
+	var filtered []Player
+	for _, player := range players {
+		if player.OwnValue >= threshold {
+			filtered = append(filtered, player)
+		}
+	}
+
+	if len(filtered) == 0 {
+		return nil, fmt.Errorf("no players meet ownership threshold %.2f", threshold)
+	}
+
+	return filtered, nil
+}
+
+func processStrengthLevels(cptPlayers, flexPlayers []Player, strengthStep float64, numRows int, rng *rand.Rand, cptSalaryMap, flexSalaryMap map[int32]int32, cptProjMap, flexProjMap map[int32]float64, cptOwnMap, flexOwnMap map[int32]float64, cptTeamMap, flexTeamMap map[int32]string, site string) (LineupData, error) {
+
+	filteredCptPlayers, err := filterPlayersInQuantile(cptPlayers, strengthStep)
+	if err != nil {
+		return LineupData{}, err
+	}
+
+	filteredFlexPlayers, err := filterPlayersInQuantile(flexPlayers, strengthStep)
+	if err != nil {
+		return LineupData{}, err
+	}
+
+	overallArrays, err := generateBaseArrays(filteredCptPlayers, filteredFlexPlayers, numRows, rng)
+	if err != nil {
+		return LineupData{}, err
+	}
+
+	result := createSeedFrames(overallArrays, cptSalaryMap, flexSalaryMap, cptProjMap, flexProjMap, cptOwnMap, flexOwnMap, cptTeamMap, flexTeamMap, site)
+
+	return result, nil
+}
+
+func runSeedframeRoutines(cptPlayers, flexPlayers []Player, strengthVars []float64, rowsPerLevel []int, cptSalaryMap, flexSalaryMap map[int32]int32, cptProjMap, flexProjMap map[int32]float64, cptOwnMap, flexOwnMap map[int32]float64, cptTeamMap, flexTeamMap map[int32]string, site string) ([]LineupData, error) {
+	resultsChan := make(chan StrengthResult, len(strengthVars))
+
+	for i, strengthStep := range strengthVars {
+		go func(step float64, rows int, index int) {
+			rng := rand.New(rand.NewSource(time.Now().UnixNano() + int64(index)))
+
+			result, err := processStrengthLevels(cptPlayers, flexPlayers, step, rows, rng, cptSalaryMap, flexSalaryMap, cptProjMap, flexProjMap, cptOwnMap, flexOwnMap, cptTeamMap, flexTeamMap, site)
+			resultsChan <- StrengthResult{Index: index, Data: result, Error: err}
+
+			if err != nil {
+				fmt.Printf("Error in strength level %.2f: %v\n", step, err)
+			} else {
+				fmt.Printf("Completed strength level %.2f with %d lineups\n", step, len(result.Salary))
+			}
+		}(strengthStep, rowsPerLevel[i], i)
+	}
+
+	allResults := make([]LineupData, len(strengthVars))
+	var errors []error
+	successCount := 0
+
+	for i := 0; i < len(strengthVars); i++ {
+		result := <-resultsChan
+		if result.Error != nil {
+			errors = append(errors, result.Error)
+		} else {
+			allResults[result.Index] = result.Data
+			successCount++
+		}
+	}
+
+	if successCount == 0 {
+		return nil, fmt.Errorf("all %d strength levels failed: %v", len(strengthVars), errors)
+	}
+
+	var validResults []LineupData
+	for i, result := range allResults {
+		if len(result.Salary) > 0 {
+			validResults = append(validResults, result)
+		} else {
+			fmt.Printf("skipping empty result from strength level %.2f\n", strengthVars[i])
+		}
+	}
+
+	fmt.Printf("📊 Successfully processed %d out of %d strength levels\n", len(validResults), len(strengthVars))
+	return validResults, nil
+}
+
+func printResults(results []LineupData) {
+	fmt.Printf("Generated %d strength levels:\n", len(results))
+
+	// Combine all results into one big dataset
+	var allSalaries []int32
+	var allProjections []float64
+	var allOwnership []float64
+	var allPlayers [][]int32
+
+	for _, result := range results {
+		allSalaries = append(allSalaries, result.Salary...)
+		allProjections = append(allProjections, result.Projection...)
+		allOwnership = append(allOwnership, result.Ownership...)
+		allPlayers = append(allPlayers, result.Players...)
+	}
+
+	fmt.Printf("Total lineups generated: %d\n", len(allSalaries))
+
+	if len(allSalaries) > 0 {
+		// Print top 5 lineups (highest projection)
+		fmt.Printf("\nTop 5 lineups (by projection):\n")
+		for i := 0; i < 5 && i < len(allSalaries); i++ {
+			fmt.Printf("  Lineup %d: Salary=%d, Projection=%.2f, Ownership=%.3f, Players=%v\n",
+				i+1, allSalaries[i], allProjections[i], allOwnership[i], allPlayers[i])
+		}
+
+		// Print bottom 5 lineups (lowest projection)
+		if len(allSalaries) > 5 {
+			fmt.Printf("\nBottom 5 lineups (by projection):\n")
+			start := len(allSalaries) - 5
+			for i := start; i < len(allSalaries); i++ {
+				fmt.Printf("  Lineup %d: Salary=%d, Projection=%.2f, Ownership=%.3f, Players=%v\n",
+					i+1, allSalaries[i], allProjections[i], allOwnership[i], allPlayers[i])
+			}
+		}
+	}
+}
+
+func removeDuplicates(results []LineupData) []LineupData {
+	seen := make(map[string]bool)
+	var uniqueLineups []LineupData
+
+	for _, result := range results {
+		for i := 0; i < len(result.Players); i++ {
+			// Create combo string like Python
+			combo := fmt.Sprintf("%d%d%d%d%d%d",
+				result.Players[i][0], result.Players[i][1], result.Players[i][2],
+				result.Players[i][3], result.Players[i][4], result.Players[i][5])
+
+			// Sort combo like Python
+			sortedCombo := sortChars(combo)
+
+			if !seen[sortedCombo] {
+				seen[sortedCombo] = true
+				uniqueLineups = append(uniqueLineups, LineupData{
+					Salary:          []int32{result.Salary[i]},
+					Projection:      []float64{result.Projection[i]},
+					Team:            []string{result.Team[i]},
+					Team_count:      []int32{result.Team_count[i]},
+					Secondary:       []string{result.Secondary[i]},
+					Secondary_count: []int32{result.Secondary_count[i]},
+					Ownership:       []float64{result.Ownership[i]},
+					Players:         [][]int32{result.Players[i]},
+				})
+			}
+		}
+	}
+
+	if len(uniqueLineups) == 0 {
+		return []LineupData{}
+	}
+
+	var allSalary []int32
+	var allProjection []float64
+	var allTeam []string
+	var allTeamCount []int32
+	var allSecondary []string
+	var allSecondaryCount []int32
+	var allOwnership []float64
+	var allPlayers [][]int32
+
+	for _, lineup := range uniqueLineups {
+		allSalary = append(allSalary, lineup.Salary[0])
+		allProjection = append(allProjection, lineup.Projection[0])
+		allTeam = append(allTeam, lineup.Team[0])
+		allTeamCount = append(allTeamCount, lineup.Team_count[0])
+		allSecondary = append(allSecondary, lineup.Secondary[0])
+		allSecondaryCount = append(allSecondaryCount, lineup.Secondary_count[0])
+		allOwnership = append(allOwnership, lineup.Ownership[0])
+		allPlayers = append(allPlayers, lineup.Players[0])
+	}
+
+	return []LineupData{{
+		Salary:          allSalary,
+		Projection:      allProjection,
+		Team:            allTeam,
+		Team_count:      allTeamCount,
+		Secondary:       allSecondary,
+		Secondary_count: allSecondaryCount,
+		Ownership:       allOwnership,
+		Players:         allPlayers,
+	}}
+}
+
+func connectToMongoDB() (*mongo.Client, error) {
+	uri := "mongodb+srv://multichem:Xr1q5wZdXPbxdUmJ@testcluster.lgwtp5i.mongodb.net/?retryWrites=true&w=majority"
+
+	clientOptions := options.Client().
+		ApplyURI(uri).
+		SetRetryWrites(true).
+		SetServerSelectionTimeout(10 * time.Second).
+		SetMaxPoolSize(100).
+		SetMinPoolSize(10).
+		SetMaxConnIdleTime(30 * time.Second).
+		SetRetryReads(true)
+
+	client, err := mongo.Connect(context.TODO(), clientOptions)
+	if err != nil {
+		return nil, fmt.Errorf("failed to connect to MongoDB: %v", err)
+	}
+
+	err = client.Ping(context.TODO(), nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to ping mMongoDB %v", err)
+	}
+
+	fmt.Printf("Connected to MongoDB!")
+	return client, nil
+}
+
+func insertLineupsToMongoDB(client *mongo.Client, results []LineupData, slate string, cptNameMap, flexNameMap map[int32]string, site string, sport string) error {
+	db := client.Database(fmt.Sprintf("%s_Database", sport))
+
+	collectionName := fmt.Sprintf("%s_%s_SD_seed_frame_%s", site, sport, slate)
+	collection := db.Collection(collectionName)
+
+	err := collection.Drop(context.TODO())
+	if err != nil {
+		fmt.Printf("Warning: Could not drop collection %s: %v\n", collectionName, err)
+	}
+
+	var documents []interface{}
+
+	for _, result := range results {
+
+		if len(result.Salary) == 0 || len(result.Players) == 0 {
+			fmt.Printf("Warning: Empty result found, skipping\n")
+			continue
+		}
+
+		for i := 0; i < len(result.Salary); i++ {
+			if len(result.Players[i]) < 6 {
+				fmt.Printf("Warning: Lineup %d has only %d players, expected 6\n", i, len(result.Players[i]))
+			}
+
+			playerNames := []string{
+				getPlayerName(result.Players[i][0], cptNameMap, "CPT"),   // CPT
+				getPlayerName(result.Players[i][1], flexNameMap, "FLEX"), // FLEX1
+				getPlayerName(result.Players[i][2], flexNameMap, "FLEX"), // FLEX2
+				getPlayerName(result.Players[i][3], flexNameMap, "FLEX"), // FLEX3
+				getPlayerName(result.Players[i][4], flexNameMap, "FLEX"), // FLEX4
+				getPlayerName(result.Players[i][5], flexNameMap, "FLEX"), // FLEX5
+			}
+
+			doc := LineupDocument{
+				Salary:          result.Salary[i],
+				Projection:      result.Projection[i],
+				Team:            result.Team[i],
+				Team_count:      result.Team_count[i],
+				Secondary:       result.Secondary[i],
+				Secondary_count: result.Secondary_count[i],
+				Ownership:       result.Ownership[i],
+				CPT:             playerNames[0],
+				FLEX1:           playerNames[1],
+				FLEX2:           playerNames[2],
+				FLEX3:           playerNames[3],
+				FLEX4:           playerNames[4],
+				FLEX5:           playerNames[5],
+				CreatedAt:       time.Now(),
+			}
+			documents = append(documents, doc)
+		}
+	}
+
+	if len(documents) == 0 {
+		fmt.Printf("Warning: No documents to insert for slate %s\n", slate)
+	}
+
+	if len(documents) > 500000 {
+		documents = documents[:500000]
+	}
+
+	chunkSize := 250000
+	for i := 0; i < len(documents); i += chunkSize {
+		end := i + chunkSize
+		if end > len(documents) {
+			end = len(documents)
+		}
+
+		chunk := documents[i:end]
+
+		for attempt := 0; attempt < 5; attempt++ {
+			ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+
+			opts := options.InsertMany().SetOrdered(false)
+			_, err := collection.InsertMany(ctx, chunk, opts)
+			cancel()
+
+			if err == nil {
+				fmt.Printf("Successfully inserted chunk %d-%d to %s\n", i, end, collectionName)
+				break
+			}
+
+			fmt.Printf("Retry %d due to error: %v\n", attempt+1, err)
+			if attempt < 4 {
+				time.Sleep(1 * time.Second)
+			}
+		}
+
+		if err != nil {
+			return fmt.Errorf("failed to insert chunk %d-%d after 5 attempts: %v", i, end, err)
+		}
+	}
+
+	fmt.Printf("All documents inserted successfully to %s!\n", collectionName)
+	return nil
+}
+
+func groupPlayersBySlate(players []Player) map[string][]Player {
+	slateGroups := make(map[string][]Player)
+
+	for _, player := range players {
+		slateGroups[player.Slate] = append(slateGroups[player.Slate], player)
+	}
+
+	return slateGroups
+}
+
+func getPlayerName(playerID int32, nameMap map[int32]string, position string) string {
+	if name, exists := nameMap[playerID]; exists && name != "" {
+		return name
+	}
+	return fmt.Sprintf("Unknown_%s_%d", position, playerID)
+}
+
+func convertNamesToMaps(playerSet *PlayerSet) map[int32]string {
+	nameMap := make(map[int32]string)
+
+	for keyStr, value := range playerSet.Maps.NameMap {
+		key, err := strconv.Atoi(keyStr)
+		if err != nil {
+			fmt.Printf("Error coinverting name key %s: %v\n", keyStr, err)
+			continue
+		}
+		nameMap[int32(key)] = value
+	}
+
+	return nameMap
+}
+
+func main() {
+	site := "DK"
+	sport := "NFL"
+	if len(os.Args) > 1 {
+		site = os.Args[1]
+	}
+	if len(os.Args) > 2 {
+		sport = os.Args[2]
+	}
+
+	processedData, err := loadPlayerData()
+	if err != nil {
+		fmt.Printf("Error loading data: %v\n", err)
+		return
+	}
+
+	start := time.Now()
+	strengthVars := []float64{0.01, 0.20, 0.40, 0.60, 0.80}
+	rowsPerLevel := []int{1000000, 1000000, 1000000, 1000000, 1000000}
+
+	cptSlateGroups := groupPlayersBySlate(processedData.CptMedian.Players)
+	flexSlateGroups := groupPlayersBySlate(processedData.PlayersMedian.Players)
+
+	cptSalaryMapJSON, cptProjectionMapJSON, cptOwnershipMapJSON, cptTeamMapJSON := convertMapsToInt32Keys(&processedData.CptMedian)
+	flexSalaryMapJSON, flexProjectionMapJSON, flexOwnershipMapJSON, flexTeamMapJSON := convertMapsToInt32Keys(&processedData.PlayersMedian)
+
+	cptNameMap := convertNamesToMaps(&processedData.CptMedian)
+	flexNameMap := convertNamesToMaps(&processedData.PlayersMedian)
+
+	mongoClient, err := connectToMongoDB()
+	if err != nil {
+		fmt.Printf("Error connecting to MongoDB: %v\n", err)
+		return
+	}
+	defer func() {
+		if err := mongoClient.Disconnect(context.TODO()); err != nil {
+			fmt.Printf("Error disconnecting from MongoDB: %v\n", err)
+		}
+	}()
+
+	for slate, cptPlayers := range cptSlateGroups {
+		flexPlayers, exists := flexSlateGroups[slate]
+		if !exists {
+			fmt.Printf("Warning: no FLEX players found for slate %s\n", slate)
+			continue
+		}
+
+		fmt.Printf("Processing slate: %s\n", slate)
+
+		results, err := runSeedframeRoutines(
+			cptPlayers, flexPlayers,
+			strengthVars, rowsPerLevel,
+			cptSalaryMapJSON, flexSalaryMapJSON,
+			cptProjectionMapJSON, flexProjectionMapJSON,
+			cptOwnershipMapJSON, flexOwnershipMapJSON,
+			cptTeamMapJSON, flexTeamMapJSON, site)
+
+		if err != nil {
+			fmt.Printf("Error generating mixed lineups for slate %s: %v\n", slate, err)
+			continue
+		}
+
+		uniqueResults := removeDuplicates(results)
+		fmt.Printf("Generated %d unique lineups for slate %s\n", len(uniqueResults), slate)
+
+		err = insertLineupsToMongoDB(mongoClient, uniqueResults, slate, cptNameMap, flexNameMap, site, sport)
+		if err != nil {
+			fmt.Printf("Error inserting to MongoDB for slate %s: %v\n", slate, err)
+			continue
+		}
+	}
+
+	// Add this line at the end
+	fmt.Printf("This took %.2f seconds\n", time.Since(start).Seconds())
+}

requirements.txt

@@ -6,3 +6,6 @@ ortools
 gspread
 discordwebhook
 pymongo
+xgboost
+lightgbm
+scikit-learn

src/database.py

@@ -52,9 +52,12 @@ uri = get_secret("MONGODB_URI", "mongodb+srv://multichem:Xr1q5wZdXPbxdUmJ@testcl
 client = MongoClient(uri, retryWrites=True, serverSelectionTimeoutMS=10000, w=0)
 
 nhl_db = client['NHL_Database']
+nba_db = client['NBA_Database']
+contest_db = client["Contest_Information"]
 
 # Google Sheets URL
 NHL_Master_hold = get_secret("MASTER_SHEET_URL", 'https://docs.google.com/spreadsheets/d/1NmKa-b-2D3w7rRxwMPSchh31GKfJ1XcDI2GU8rXWnHI/edit#gid=578660863')
+NBA_Master_hold: str = 'https://docs.google.com/spreadsheets/d/1Yq0vGriWK-bS79e-bD6_u9pqrYE6Yrlbb_wEkmH-ot0/edit?gid=172632260#gid=172632260'
 
 # Discord Webhook
 discord = Discord(url=get_secret("DISCORD_WEBHOOK_URL", "https://discord.com/api/webhooks/1244687568394780672/COng4Gz1JFdoS-zCCcB24tQWo1upansxWFdfIv16_HZIb_j7-glZoGd4TXAGJDLIRiIJ"))

src/sports/nhl_functions.py

@@ -1,22 +1,10 @@
 import time
-import sys
-import io
-from contextlib import redirect_stdout
 import re
 
 # Numpy
 from numpy import where as np_where
-from numpy import newaxis as np_newaxis
 from numpy import random as np_random
-from numpy import hstack as np_hstack
 from numpy import array as np_array
-from numpy import apply_along_axis as np_apply_along_axis
-from numpy import bincount as np_bincount
-from numpy import partition as np_partition
-from numpy import count_nonzero as np_count_nonzero
-from numpy import argsort as np_argsort
-from numpy import unique as np_unique
-from numpy import vectorize as np_vectorize
 from numpy import nan as np_nan
 from numpy import inf as np_inf
 from numpy import zeros as np_zeros
@@ -32,7 +20,6 @@ from pandas import errors as pd_errors
 from pandas import merge, to_numeric
 from pandas import options as poptions
 from pandas import set_option
-from pandas import notnull
 
 # Time
 import time
@@ -48,24 +35,20 @@ import os
 import subprocess
 from ortools.linear_solver import pywraplp
 from random import random
-from random import randint
 from random import choice
 
 # Ownership Models
-# from NHL_own_regress import xgb_model, lgb_model, knn_model
+from func.NHL_own_regress import xgb_model, lgb_model, knn_model
 
 pd_options.mode.chained_assignment = None  # default='warn'
 from warnings import simplefilter
 simplefilter(action="ignore", category=pd_errors.PerformanceWarning)
 poptions.mode.chained_assignment = None  # default='warn'
 set_option('future.no_silent_downcasting', True)
-from gspread.auth import service_account_from_dict
-from discordwebhook import Discord
-from pymongo import MongoClient, UpdateOne
 
 import streamlit as st
 
-from database import *
+from src.database import *
 
 nan_value = float("NaN")
 sim_teams = []
@@ -731,12 +714,19 @@ def build_dk_player_level_basic_outcomes(slate_info, dk_player_hold, fd_player_h
         feature_cols = ['Salary', 'Actual', 'actual_adv', 'value', 'value_adv', 'contest_size', 'base_ownership', 'value_play', 'value_density', 'strong_play', 'punt_play']
         X_current = basic_own_df[feature_cols]
 
-        # Use simplified ownership prediction (faster than ML models)
-        # Base prediction on value and salary
+        print(X_current)
+
+        # Make predictions with all your models
+        basic_own_df['XGB'] = np_clip(xgb_model.predict(X_current), 0, 100)
+        basic_own_df['LGB'] = np_clip(lgb_model.predict(X_current), 0, 100) * 100
+        basic_own_df['KNN'] = np_clip(knn_model.predict(X_current), 0, 100)
+
+        # Create combo prediction
         basic_own_df['Combo'] = (
-            (basic_own_df['value'] * 10) * 
-            (100 / (basic_own_df['Salary'] / 1000))
-        ) / 100
+            (basic_own_df['XGB'] * .30) + 
+            (basic_own_df['LGB'] * .30) + 
+            (basic_own_df['KNN'] * .40)
+        )
 
         basic_own_df['Combo'] = np_where((basic_own_df['value'] < 1.5) & (basic_own_df['Salary'] < 7500), basic_own_df['Combo'] * .75, basic_own_df['Combo'])
         basic_own_df['Combo'] = np_where((basic_own_df['Salary'] > 5000) & (basic_own_df['value'] < 1.5), basic_own_df['value'], basic_own_df['Combo'])

src/streamlit_app.py

@@ -17,7 +17,8 @@ from pandas import set_option
 # Time
 import time
 from time import sleep as time_sleep
-from datetime import datetime
+from datetime import datetime, date
+from pytz import timezone as pytz_timezone
 
 from database import *
 from sports.nhl_functions import *
@@ -237,8 +238,252 @@ if selected_tab == "NFL Updates":
     st.write("NFL functionality will be added later on.")
     
 if selected_tab == "NBA Updates":
-    st.info("NBA updates coming soon!")
-    st.write("NBA functionality will be added later on.")
+
+    if st.button(f"🏀 Update NBA models and generate seed frames", type="primary", use_container_width=True):
+        x: int = 1
+        high_end: int = 1
+
+        while x <= high_end:
+            try:
+                try:
+                    sh = gc.open_by_url(NBA_Master_hold)
+                    worksheet = sh.worksheet('Game_Adj')
+                except:
+                    sh = gc2.open_by_url(NBA_Master_hold)
+                    worksheet = sh.worksheet('Game_Adj')
+                
+                t_range = worksheet.range('T2:T32')
+                # Create a list of zeros with the same length as t_range
+                values = [0] * len(t_range)
+                worksheet.update('T2:T32', [[0] for _ in range(len(t_range))])
+
+                # Sleep for 2 seconds
+                time.sleep(2)
+
+                # Get values from Z2:Z32
+                z_values = worksheet.range('Z2:Z32')
+                
+                z_data = [cell.value for cell in z_values]
+                worksheet.update([[val] for val in z_data], 'T2:T32')
+            except:
+                pass
+                        
+            ROO_creation_var = 0
+            SD_ROO_creation_var = 0
+            DK_SD_seed_frame_var = 0
+            FD_SD_seed_frame_var = 0
+            DK_seed_frame_var = 0
+            FD_seed_frame_var = 0
+            upload_mongo_dfs_var = 0
+            upload_mongo_bets_var = 0
+            
+            if ROO_creation_var == 0:
+                try:
+                    DK_ROO = DK_NBA_ROO_Build(dk_roo_player_hold)
+                    FD_ROO = FD_NBA_ROO_Build(fd_roo_player_hold)
+                    
+                    solver_DK = DK_ROO.copy()
+                    solver_FD = FD_ROO.copy()
+                    solver_DK = solver_DK.drop_duplicates(subset=['Player'])
+                    solver_DK['Player'] = solver_DK['Player'].replace('Ron Holland', 'Ronald Holland II')
+                    solver_FD = solver_FD.drop_duplicates(subset=['Player'])
+                    solver_FD['Player'] = solver_FD['Player'].replace('Ron Holland', 'Ronald Holland II')
+                    
+                    try:
+                        solver_DK['Timestamp'] = str(date.today())
+                        sh = gc.open_by_url('https://docs.google.com/spreadsheets/d/1H7kdaxVF7Bv3kb1DSa_3Dq6OaC9ajq9UAQfVyDluXzk/edit?gid=0#gid=0')
+                        worksheet = sh.worksheet('NBA DK')
+                        worksheet.batch_clear(['A:AB'])
+                        worksheet.update([solver_DK.columns.values.tolist()] + solver_DK.values.tolist())
+                    except:
+                        sh = gc2.open_by_url(NBA_Master_hold)
+                        worksheet = sh.worksheet('NBA DK')
+                        worksheet.batch_clear(['A:AB'])
+                        worksheet.update([solver_DK.columns.values.tolist()] + solver_DK.values.tolist())
+                    
+                    try:
+                        solver_FD['Timestamp'] = str(date.today())
+                        sh = gc.open_by_url('https://docs.google.com/spreadsheets/d/1H7kdaxVF7Bv3kb1DSa_3Dq6OaC9ajq9UAQfVyDluXzk/edit?gid=0#gid=0')
+                        worksheet = sh.worksheet('NBA FD')
+                        worksheet.batch_clear(['A:AB'])
+                        worksheet.update([solver_FD.columns.values.tolist()] + solver_FD.values.tolist())
+                    except:
+                        sh = gc2.open_by_url(NBA_Master_hold)
+                        worksheet = sh.worksheet('NBA FD')
+                        worksheet.batch_clear(['A:AB'])
+                        worksheet.update([solver_FD.columns.values.tolist()] + solver_FD.values.tolist())
+            
+                    time.sleep(3)
+                    
+                    roo_final = pd_concat([DK_ROO, FD_ROO])
+                    roo_final['Salary'] = roo_final['Salary'].astype(int)
+            
+                    tz = pytz_timezone('US/Central')
+                    central_tz = datetime.now(tz)
+                    current_time = central_tz.strftime("%H:%M:%S")
+            
+                    roo_final['timestamp'] = current_time
+            
+                    try:
+                        sh = gc.open_by_url(NBA_Master_hold)
+                        worksheet = sh.worksheet('Player_Level_ROO')
+                        worksheet.batch_clear(['A:AB'])
+                        worksheet.update([roo_final.columns.values.tolist()] + roo_final.values.tolist())
+                    except:
+                        sh = gc2.open_by_url(NBA_Master_hold)
+                        worksheet = sh.worksheet('Player_Level_ROO')
+                        worksheet.batch_clear(['A:AB'])
+                        worksheet.update([roo_final.columns.values.tolist()] + roo_final.values.tolist())
+            
+                    ROO_creation_var = 1
+                except:
+                    pass
+                
+                if ROO_creation_var == 1:
+                    try:
+                        discord.post(content="NBA ROO structure refreshed")
+                    except:
+                        pass
+                else:
+                    try:
+                        discord.post(content="NBA ROO structure script broke")
+                    except:
+                        pass
+                    
+                time_sleep(1)
+            
+            upload_dfs_data(client, roo_final)
+            discord.post(content="NBA DFS database refreshed")
+            
+            upload_betting_data(client)
+            discord.post(content="NBA betting database refreshed")
+            
+            try:
+                trending_script()
+                discord.post(content="NBA Trending Tables refreshed")
+            except:
+                discord.post(content="NBA Trending Tables broke")
+                pass
+
+            if DK_seed_frame_var == 0:
+                DK_NBA_seed_frame(roo_final, client)
+                DK_seed_frame_var = 1
+                
+                if DK_seed_frame_var == 1:
+                    try:
+                        discord.post(content="NBA Draftkings Seed Frames refreshed")
+                    except:
+                        pass
+                else:
+                    try:
+                        discord.post(content="NBA Draftkings Seed Frames script broke")
+                    except:
+                        pass
+                    
+                time_sleep(1)
+            
+            if FD_seed_frame_var == 0:
+                FD_NBA_seed_frame(roo_final, client)
+                FD_seed_frame_var = 1
+                
+                if FD_seed_frame_var == 1:
+                    try:
+                        discord.post(content="NBA Fanduel Seed Frames refreshed")
+                    except:
+                        pass
+                else:
+                    try:
+                        discord.post(content="NBA Fanduel Seed Frames script broke")
+                    except:
+                        pass
+                    
+                time_sleep(1)
+            
+            if SD_ROO_creation_var == 0:
+                DK_SD_ROO = DK_SD_NBA_ROO_Build(dk_sd_player_hold, dk_showdown_options, dk_sd_projections)
+                FD_SD_ROO = FD_SD_NBA_ROO_Build(fd_sd_player_hold, fd_showdown_options, fd_sd_projections)
+                
+                sd_roo_final = pd_concat([DK_SD_ROO, FD_SD_ROO])
+                sd_roo_final['Salary'] = sd_roo_final['Salary'].astype(int)
+
+                tz = pytz_timezone('US/Central')
+                central_tz = datetime.now(tz)
+                current_time = central_tz.strftime("%H:%M:%S")
+
+                sd_roo_final['timestamp'] = current_time
+
+                try:
+                    sh = gc.open_by_url(NBA_Master_hold)
+                    worksheet = sh.worksheet('Player_Level_SD_ROO')
+                    worksheet.batch_clear(['A:AB'])
+                    worksheet.update([sd_roo_final.columns.values.tolist()] + sd_roo_final.values.tolist())
+                except:
+                    sh = gc2.open_by_url(NBA_Master_hold)
+                    worksheet = sh.worksheet('Player_Level_SD_ROO')
+                    worksheet.batch_clear(['A:AB'])
+                    worksheet.update([sd_roo_final.columns.values.tolist()] + sd_roo_final.values.tolist())
+
+                ROO_creation_var = 1
+                
+                if ROO_creation_var == 1:
+                    try:
+                        discord.post(content="NBA SD ROO structure refreshed")
+                    except:
+                        pass
+                else:
+                    try:
+                        discord.post(content="NBA SD ROO structure script broke")
+                    except:
+                        pass
+                    
+                time_sleep(1)
+            
+            if DK_SD_seed_frame_var == 0:
+                DK_NBA_SD_seed_frame(dk_showdown_options, dk_sd_projections)
+                DK_SD_seed_frame_var = 1
+                
+                if DK_SD_seed_frame_var == 1:
+                    try:
+                        discord.post(content="NBA Draftkings SD Seed Frames refreshed")
+                    except:
+                        pass
+                else:
+                    try:
+                        discord.post(content="NBA Draftkings SD Seed Frames script broke")
+                    except:
+                        pass
+                    
+                time_sleep(1)
+            
+            if FD_SD_seed_frame_var == 0:
+                FD_NBA_SD_seed_frame(fd_showdown_options, fd_sd_projections)
+                FD_SD_seed_frame_var = 1
+                
+                if FD_SD_seed_frame_var == 1:
+                    try:
+                        discord.post(content="NBA Fanduel SD Seed Frames refreshed")
+                    except:
+                        pass
+                else:
+                    try:
+                        discord.post(content="NBA Fanduel SD Seed Frames script broke")
+                    except:
+                        pass
+                    
+                time_sleep(1)
+            
+            upload_sd_dfs_data(client, sd_roo_final)
+            discord.post(content="NBA SD DFS database refreshed")
+            
+            print (f'currently on run {x}, {high_end - x} runs remaining')
+            
+            x += 1
+            
+            if high_end > 1:
+                time_sleep(600)
+        
+        st.success("✅ NBA updates completed successfully!")
+        st.balloons()
     
 if selected_tab == "MLB Updates":
     st.info("MLB updates coming soon!")