Adding NFL functionality

CHANGES.md

@@ -1,303 +0,0 @@
-# 🔧 Changes Summary - Paydirt NHL Model Updates
-
-## Overview
-
-Successfully converted your Python script into a production-ready Streamlit app with proper configuration for Hugging Face deployment.
-
----
-
-## ✅ Issues Fixed
-
-### 1. Missing Python Dependencies ✓
-**Problem**: `requirements.txt` only had 3 packages  
-**Solution**: Added all required dependencies with version pinning
-
-**Updated `requirements.txt`:**
-- streamlit==1.32.0
-- pandas==2.2.0
-- numpy==1.26.4
-- altair==5.2.0
-- pytz==2024.1
-- ortools==9.9.3963
-- gspread==6.0.2
-- discordwebhook==1.0.3
-- pymongo==4.6.2
-- xgboost==2.0.3
-- lightgbm==4.3.0
-- scikit-learn==1.4.1.post1
-
-### 2. Import Path for NHL_own_regress ✓
-**Problem**: Module was in `func/` directory, not in Python path  
-**Solution**: Added path adjustment in `streamlit_app.py`
-
-```python
-import sys
-sys.path.append('../func')
-from NHL_own_regress import xgb_model, lgb_model, knn_model
-```
-
-### 3. Go Executable Compatibility ✓
-**Problem**: Windows `.exe` files won't work in Docker Linux container  
-**Solution**: Multi-stage Docker build that compiles Go programs for Linux
-
-**Updated `Dockerfile`:**
-- Stage 1: Builds Go binaries from source for Linux
-- Stage 2: Creates Python runtime with compiled binaries
-- Optimized with Alpine Linux for Go build
-- Proper file permissions set
-
-### 4. Hardcoded Credentials ✓
-**Problem**: Service account keys and URIs exposed in code  
-**Solution**: Environment variable support with fallbacks
-
-**Added to `streamlit_app.py`:**
-```python
-def get_secret(key, default=None):
-    """Get secret from Streamlit secrets or environment variables"""
-    try:
-        return st.secrets[key]
-    except:
-        return os.getenv(key, default)
-```
-
-All credentials now configurable via:
-- Streamlit secrets (`.streamlit/secrets.toml`)
-- Environment variables
-- Hugging Face Space secrets
-
-### 5. Streamlit UI Components ✓
-**Problem**: No proper Streamlit interface  
-**Solution**: Added comprehensive UI
-
-**Added UI Elements:**
-- Page configuration with title and icon
-- Sidebar with app info and connection status
-- Visual connection indicators for MongoDB and Google Sheets
-- Styled primary button for lineup generation
-- Progress messages throughout execution
-- Success message and celebration animation on completion
-
----
-
-## 📁 New Files Created
-
-### Configuration Files
-
-1. **`.gitignore`**
-   - Prevents committing sensitive files
-   - Includes Python, IDE, and Streamlit patterns
-
-2. **`.dockerignore`**
-   - Optimizes Docker build
-   - Excludes unnecessary files from image
-
-3. **`.streamlit/config.toml`**
-   - Streamlit app configuration
-   - Custom theme settings
-   - Server configuration for Hugging Face
-
-4. **`.streamlit/secrets.toml.example`**
-   - Template for local development secrets
-   - Documents all required credentials
-
-### Documentation
-
-5. **`README.md`** (Replaced)
-   - Comprehensive project documentation
-   - Setup instructions for local and cloud
-   - Architecture overview
-   - Technology stack details
-
-6. **`DEPLOYMENT.md`**
-   - Step-by-step Hugging Face deployment guide
-   - Troubleshooting section
-   - Security checklist
-   - Monitoring and maintenance procedures
-
-7. **`CHANGES.md`** (This file)
-   - Summary of all modifications
-   - Before/after comparisons
-
----
-
-## 🔄 Modified Files
-
-### `streamlit_app.py`
-
-**Line 54-59**: Added path adjustment for NHL_own_regress import
-```python
-import sys
-sys.path.append('../func')
-from NHL_own_regress import xgb_model, lgb_model, knn_model
-```
-
-**Line 70-129**: Replaced hardcoded credentials with environment variable support
-- Added `get_secret()` helper function
-- Updated all credential dictionaries to use `get_secret()`
-- Applied to MongoDB URI, Discord webhook, Google Sheets URL
-
-**Line 137-156**: Fixed subprocess calls for Go binaries
-- Changed `.exe` to Linux binary names
-- Updated working directory path
-- Already had `st.write()` calls for progress
-
-**Line 2117-2151**: Added comprehensive Streamlit UI
-- Page configuration
-- Title and layout
-- Sidebar with info and status
-- Connection indicators
-- Styled button
-
-**Line 2317-2321**: Fixed ending logic
-- Removed old loop variables (`x`, `high_end`)
-- Added success message and balloons
-- Clean MongoDB connection closure
-
-### `Dockerfile`
-
-**Complete rewrite** with multi-stage build:
-
-**Stage 1 - Go Builder:**
-```dockerfile
-FROM golang:1.24-alpine AS go-builder
-# Builds DK and FD NHL seed frame generators
-```
-
-**Stage 2 - Python Runtime:**
-```dockerfile
-FROM python:3.13-slim
-# Copies Go binaries and sets up Python environment
-```
-
-### `requirements.txt`
-
-**Before:**
-```
-altair
-pandas
-streamlit
-```
-
-**After:**
-```
-streamlit==1.32.0
-pandas==2.2.0
-numpy==1.26.4
-# ... 9 more packages with versions
-```
-
----
-
-## 🎯 Features Added
-
-### Security Enhancements
-- ✓ Environment variable support
-- ✓ Streamlit secrets integration
-- ✓ Hugging Face Spaces secrets compatibility
-- ✓ `.gitignore` for sensitive files
-- ✓ Default values for local development
-
-### User Experience
-- ✓ Professional UI with icons
-- ✓ Real-time connection status
-- ✓ Progress indicators
-- ✓ Success notifications
-- ✓ Celebration animation
-- ✓ Sidebar information panel
-
-### DevOps
-- ✓ Multi-stage Docker build
-- ✓ Optimized image size
-- ✓ Health check endpoint
-- ✓ Proper build caching
-- ✓ Cross-platform compatibility
-
-### Documentation
-- ✓ Comprehensive README
-- ✓ Deployment guide
-- ✓ Architecture documentation
-- ✓ Configuration templates
-- ✓ Security checklists
-
----
-
-## 🚀 Ready for Deployment
-
-Your app is now ready to deploy on Hugging Face Spaces!
-
-### Quick Start
-
-1. **Create Space** on Hugging Face (Docker SDK)
-2. **Add Secrets** from `.streamlit/secrets.toml.example`
-3. **Push Code** to Space repository
-4. **Monitor Build** (8-12 minutes first time)
-5. **Test App** and verify connections
-
-### What Happens on Deploy
-
-1. Docker builds Go programs for Linux ✓
-2. Installs Python dependencies ✓
-3. Configures Streamlit ✓
-4. Starts app on port 8501 ✓
-5. Auto-restarts on file changes [[memory:6085392]] ✓
-
----
-
-## 📋 Pre-Deployment Checklist
-
-- [ ] Review `DEPLOYMENT.md` for detailed instructions
-- [ ] Prepare all secrets (MongoDB, Google, Discord)
-- [ ] Create Hugging Face Space
-- [ ] Add secrets to Space settings
-- [ ] Push code to Space repository
-- [ ] Monitor build logs
-- [ ] Test functionality
-- [ ] Verify Discord notifications
-- [ ] Check Google Sheets updates
-- [ ] Confirm MongoDB writes
-
----
-
-## 🔐 Security Reminders
-
-1. **Never commit** `.streamlit/secrets.toml`
-2. **Use Hugging Face Secrets** for production
-3. **Rotate credentials** regularly
-4. **Review permissions** on service accounts
-5. **Keep Space private** if handling sensitive data
-
----
-
-## 📚 Next Steps
-
-1. Test locally: `streamlit run src/streamlit_app.py`
-2. Follow `DEPLOYMENT.md` for Hugging Face deployment
-3. Set up monitoring and alerts
-4. Document any custom configurations
-5. Train team on using the app
-
----
-
-## 🐛 Known Limitations
-
-1. **Linter Warnings**: Import warnings are false positives (packages not in linter env)
-2. **First Build**: Takes 8-12 minutes on Hugging Face
-3. **Connection Errors**: Require proper secret configuration
-4. **Go Binaries**: Only work in Docker (Linux), need `.exe` for local Windows
-
----
-
-## 💡 Support
-
-If you encounter issues:
-
-1. Check `DEPLOYMENT.md` troubleshooting section
-2. Review Streamlit and Hugging Face logs
-3. Verify all secrets are configured correctly
-4. Test locally with same secrets
-5. Contact development team
-
----
-
-**All changes have been tested and are ready for deployment!** 🎉
-

DEPLOYMENT.md

@@ -1,278 +0,0 @@
-# 🚀 Deployment Guide - Paydirt NHL Model Updates
-
-## Hugging Face Spaces Deployment
-
-### Prerequisites
-
-1. Hugging Face account
-2. Service account credentials for Google Sheets API
-3. MongoDB Atlas connection string
-4. Discord webhook URL (optional)
-
-### Step-by-Step Deployment
-
-#### 1. Create a New Space
-
-1. Go to [Hugging Face Spaces](https://huggingface.co/spaces)
-2. Click "Create new Space"
-3. Configure:
-   - **Name**: paydirt-nhl-model-updates (or your choice)
-   - **SDK**: Docker
-   - **Hardware**: CPU Basic (upgrade if needed)
-   - **Visibility**: Private (recommended for production data)
-
-#### 2. Configure Secrets
-
-Go to your Space Settings → Repository secrets and add:
-
-```
-MONGODB_URI = "mongodb+srv://username:password@cluster.mongodb.net/..."
-GOOGLE_PROJECT_ID_1 = "your-project-id"
-GOOGLE_PRIVATE_KEY_ID_1 = "your-key-id"
-GOOGLE_PRIVATE_KEY_1 = "-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----\n"
-GOOGLE_CLIENT_EMAIL_1 = "service-account@project.iam.gserviceaccount.com"
-GOOGLE_CLIENT_ID_1 = "123456789"
-GOOGLE_PROJECT_ID_2 = "backup-project-id"
-GOOGLE_PRIVATE_KEY_ID_2 = "backup-key-id"
-GOOGLE_PRIVATE_KEY_2 = "-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----\n"
-GOOGLE_CLIENT_EMAIL_2 = "backup-service-account@project.iam.gserviceaccount.com"
-GOOGLE_CLIENT_ID_2 = "987654321"
-DISCORD_WEBHOOK_URL = "https://discord.com/api/webhooks/..."
-MASTER_SHEET_URL = "https://docs.google.com/spreadsheets/d/..."
-```
-
-**Important Notes:**
-- For private keys, keep the `\n` characters for newlines
-- Values will be automatically available as Streamlit secrets
-- Never commit these values to the repository
-
-#### 3. Push Code to Space
-
-**Option A: Using Git**
-
-```bash
-# Clone your Space repository
-git clone https://huggingface.co/spaces/YOUR_USERNAME/paydirt-nhl-model-updates
-cd paydirt-nhl-model-updates
-
-# Copy your code
-cp -r /path/to/Paydirt_model_updates/* .
-
-# Commit and push
-git add .
-git commit -m "Initial deployment"
-git push
-```
-
-**Option B: Using Hugging Face Web Interface**
-
-1. Go to Files → Add file
-2. Upload all files from `Paydirt_model_updates/` directory
-3. Commit changes
-
-#### 4. Monitor Build
-
-1. Go to your Space's "Building" tab
-2. Watch the Docker build logs
-3. Build should complete in 5-10 minutes
-4. Space will automatically start once build succeeds
-
-#### 5. Verify Deployment
-
-1. Open your Space URL
-2. Check sidebar for connection status
-3. Test the "Generate NHL Lineups" button
-4. Monitor Discord for notification
-5. Verify data updates in Google Sheets and MongoDB
-
----
-
-## Docker Build Details
-
-### Build Stages
-
-1. **Go Builder Stage**
-   - Compiles DK and FD lineup generators
-   - Uses Alpine Linux for minimal size
-   - Produces static binaries
-
-2. **Python Runtime Stage**
-   - Installs Python dependencies
-   - Copies Go binaries
-   - Configures Streamlit
-
-### Build Time
-
-- First build: ~8-12 minutes
-- Subsequent builds: ~3-5 minutes (with layer caching)
-
-### Troubleshooting Build Issues
-
-**Go Build Fails:**
-```bash
-# Check go.mod and go.sum are present
-# Verify Go version compatibility (1.24)
-```
-
-**Python Dependencies Fail:**
-```bash
-# Check requirements.txt format
-# Verify all packages are available on PyPI
-# Consider pinning versions for stability
-```
-
-**Large Image Size:**
-```bash
-# Current size: ~2-3 GB
-# Optimize by:
-#   - Using slimmer base images
-#   - Multi-stage builds (already implemented)
-#   - Cleaning up apt cache (already implemented)
-```
-
----
-
-## Environment-Specific Configuration
-
-### Development (Local)
-
-```bash
-# Use .streamlit/secrets.toml for local secrets
-streamlit run src/streamlit_app.py
-```
-
-### Staging/Production (Hugging Face)
-
-- Secrets managed via Space Settings
-- Automatic builds on push
-- Zero-downtime deployments
-
----
-
-## Monitoring & Maintenance
-
-### Health Checks
-
-The app includes a health check endpoint at `/_stcore/health`
-
-### Logs
-
-View logs in Hugging Face Spaces:
-1. Go to your Space
-2. Click "Logs" tab
-3. Monitor for errors or warnings
-
-### Performance
-
-- CPU Basic sufficient for typical use
-- Upgrade to CPU Upgrade for:
-  - Larger datasets
-  - More frequent runs
-  - Multiple concurrent users
-
-### Updates
-
-To update the app:
-
-```bash
-# Pull latest changes
-git pull origin main
-
-# Make changes
-# ...
-
-# Push updates
-git add .
-git commit -m "Update: [description]"
-git push
-```
-
-Space will automatically rebuild and redeploy.
-
----
-
-## Security Checklist
-
-- [ ] All secrets configured in Space settings (not in code)
-- [ ] Space visibility set to Private
-- [ ] Service account has minimal required permissions
-- [ ] MongoDB connection uses restricted user
-- [ ] Discord webhook secured
-- [ ] Google Sheets shared only with service accounts
-- [ ] Regular credential rotation schedule established
-
----
-
-## Rollback Procedure
-
-If deployment fails:
-
-1. Go to Space Settings → Files
-2. Find previous working commit
-3. Click "Restore to this revision"
-4. Space will rebuild from that commit
-
----
-
-## Cost Considerations
-
-### Hugging Face Spaces Pricing
-
-- **CPU Basic**: Free (with limitations)
-- **CPU Upgrade**: ~$0.03/hour
-- **GPU**: Not needed for this app
-
-### External Services
-
-- **MongoDB Atlas**: Free tier (512 MB) to paid plans
-- **Google Cloud**: Free API quotas, then pay-per-use
-- **Discord**: Free
-
----
-
-## Support & Troubleshooting
-
-### Common Issues
-
-**"MongoDB Connection Failed"**
-- Verify MONGODB_URI in secrets
-- Check MongoDB Atlas network access (allow all IPs or Hugging Face IPs)
-- Verify MongoDB user permissions
-
-**"Google Sheets Connection Failed"**
-- Verify service account credentials
-- Check sheet permissions (share with service account email)
-- Ensure API is enabled in Google Cloud Console
-
-**"Go binary not found"**
-- Check Docker build logs
-- Verify Go files are being copied correctly
-- Ensure binaries are made executable
-
-### Getting Help
-
-1. Check Streamlit logs in the app
-2. Review Hugging Face build logs
-3. Test locally with same secrets
-4. Contact development team
-
----
-
-## Best Practices
-
-1. **Version Control**: Keep all code in git
-2. **Secret Management**: Never commit secrets
-3. **Testing**: Test locally before deploying
-4. **Monitoring**: Check logs regularly
-5. **Backups**: Regular MongoDB backups
-6. **Documentation**: Keep this guide updated
-
----
-
-## Additional Resources
-
-- [Streamlit Documentation](https://docs.streamlit.io)
-- [Hugging Face Spaces Documentation](https://huggingface.co/docs/hub/spaces)
-- [Docker Best Practices](https://docs.docker.com/develop/dev-best-practices/)
-- [MongoDB Atlas Documentation](https://docs.atlas.mongodb.com/)
-

Dockerfile

@@ -14,6 +14,8 @@ COPY func/dk_nhl_go ./func/dk_nhl_go
 COPY func/fd_nhl_go ./func/fd_nhl_go
 COPY func/dk_nba_go ./func/dk_nba_go
 COPY func/fd_nba_go ./func/fd_nba_go
+COPY func/dk_nfl_go ./func/dk_nfl_go
+COPY func/fd_nfl_go ./func/fd_nfl_go
 COPY func/showdown_go ./func/showdown_go
 
 # Build the Go programs for Linux
@@ -21,6 +23,8 @@ RUN CGO_ENABLED=0 GOOS=linux go build -o dk_nhl_seed ./func/dk_nhl_go/NHL_seed_f
 RUN CGO_ENABLED=0 GOOS=linux go build -o fd_nhl_seed ./func/fd_nhl_go/NHL_seed_frames.go
 RUN CGO_ENABLED=0 GOOS=linux go build -o dk_nba_seed ./func/dk_nba_go/NBA_seed_frames.go
 RUN CGO_ENABLED=0 GOOS=linux go build -o fd_nba_seed ./func/fd_nba_go/NBA_seed_frames.go
+RUN CGO_ENABLED=0 GOOS=linux go build -o dk_nfl_seed ./func/dk_nfl_go/NFL_seed_frames.go
+RUN CGO_ENABLED=0 GOOS=linux go build -o fd_nfl_seed ./func/fd_nfl_go/NFL_seed_frames.go
 RUN CGO_ENABLED=0 GOOS=linux go build -o showdown_seed ./func/showdown_go/showdown_seed_frames.go
 
 # Python stage
@@ -47,11 +51,14 @@ COPY --from=go-builder /go-build/dk_nhl_seed ./dk_nhl_go/NHL_seed_frames
 COPY --from=go-builder /go-build/fd_nhl_seed ./fd_nhl_go/NHL_seed_frames
 COPY --from=go-builder /go-build/dk_nba_seed ./dk_nba_go/NBA_seed_frames
 COPY --from=go-builder /go-build/fd_nba_seed ./fd_nba_go/NBA_seed_frames
+COPY --from=go-builder /go-build/dk_nfl_seed ./dk_nfl_go/NFL_seed_frames
+COPY --from=go-builder /go-build/fd_nfl_seed ./fd_nfl_go/NFL_seed_frames
 COPY --from=go-builder /go-build/showdown_seed ./showdown_go/showdown_seed_frames
 
 # Make Go binaries executable
 RUN chmod +x ./dk_nhl_go/NHL_seed_frames ./fd_nhl_go/NHL_seed_frames
 RUN chmod +x ./dk_nba_go/NBA_seed_frames ./fd_nba_go/NBA_seed_frames
+RUN chmod +x ./dk_nfl_go/NFL_seed_frames ./fd_nfl_go/NFL_seed_frames
 RUN chmod +x ./showdown_go/showdown_seed_frames
 
 # Create .streamlit directory for config

func/dk_nfl_go/NFL_seed_frames.go

@@ -0,0 +1,1131 @@
+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"`
+	QB              int32     `bson:"QB"`
+	RB1             int32     `bson:"RB1"`
+	RB2             int32     `bson:"RB2"`
+	WR1             int32     `bson:"WR1"`
+	WR2             int32     `bson:"WR2"`
+	WR3             int32     `bson:"WR3"`
+	TE              int32     `bson:"TE"`
+	FLEX            int32     `bson:"FLEX"`
+	DST             int32     `bson:"DST"`
+	CreatedAt       time.Time `bson:"created_at"`
+}
+
+func loadPlayerData() (*ProcessedData, error) {
+	data, err := ioutil.ReadFile("dk_nfl_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_nfl_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" {
+			if !strings.Contains(player.Position, "QB") && !strings.Contains(player.Position, "DST") {
+				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(qb, rb1, rb2, wr1, wr2, wr3, te, flex, dst []int32) [][]int32 {
+	length := len(qb)
+
+	result := make([][]int32, length)
+
+	for i := 0; i < length; i++ {
+		result[i] = []int32{
+			qb[i],
+			rb1[i],
+			rb2[i],
+			wr1[i],
+			wr2[i],
+			wr3[i],
+			te[i],
+			flex[i],
+			dst[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(qbPlayers, rbPlayers, wrPlayers, tePlayers, flexPlayers, dstPlayers []Player, numRows int, strengthStep float64, rng *rand.Rand) ([][]int32, error) {
+
+	// DEBUG: Check pool sizes
+	fmt.Printf("DEBUG - Pool sizes: QB=%d, RB=%d, WR=%d, TE=%d, FLEX=%d, DST=%d\n",
+		len(qbPlayers), len(rbPlayers), len(wrPlayers), len(tePlayers), len(flexPlayers), len(dstPlayers))
+
+	if len(qbPlayers) == 0 || len(rbPlayers) == 0 || len(wrPlayers) == 0 || len(tePlayers) == 0 || len(flexPlayers) == 0 || len(dstPlayers) == 0 {
+		return nil, fmt.Errorf("one or more position pools is empty: QB=%d, RB=%d, WR=%d, TE=%d, FLEX=%d, DST=%d",
+			len(qbPlayers), len(rbPlayers), len(wrPlayers), len(tePlayers), len(flexPlayers), len(dstPlayers))
+	}
+
+	var validArrays [][]int32
+	attempts := 0
+	maxAttempts := numRows * 10
+
+	for len(validArrays) < numRows && attempts < maxAttempts {
+		attempts++
+
+		qb := qbPlayers[rng.Intn(len(qbPlayers))]
+		rb1 := rbPlayers[rng.Intn(len(rbPlayers))]
+		rb2 := rbPlayers[rng.Intn(len(rbPlayers))]
+		wr1 := wrPlayers[rng.Intn(len(wrPlayers))]
+		wr2 := wrPlayers[rng.Intn(len(wrPlayers))]
+		wr3 := wrPlayers[rng.Intn(len(wrPlayers))]
+		te := tePlayers[rng.Intn(len(tePlayers))]
+		flex := flexPlayers[rng.Intn(len(flexPlayers))]
+		dst := dstPlayers[rng.Intn(len(dstPlayers))]
+
+		if rb1.Name != rb2.Name && rb1.Name != flex.Name && rb2.Name != flex.Name && wr1.Name != wr2.Name && wr1.Name != wr3.Name && wr2.Name != wr3.Name &&
+			wr1.Name != flex.Name && wr2.Name != flex.Name && wr3.Name != flex.Name && te.Name != flex.Name {
+
+			playerIDs := []int32{qb.ID, rb1.ID, rb2.ID, wr1.ID, wr2.ID, wr3.ID, te.ID, flex.ID, dst.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" {
+			if !strings.Contains(player.Position, "QB") && !strings.Contains(player.Position, "DST") {
+				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) {
+
+	qbPlayers, err := filterPosPlayersInQuantile(players, "QB", strengthStep)
+	if err != nil {
+		return LineupData{}, fmt.Errorf("failed to filter QB players: %v", err)
+	}
+
+	rbPlayers, err := filterPosPlayersInQuantile(players, "RB", strengthStep)
+	if err != nil {
+		return LineupData{}, fmt.Errorf("failed to filter RB players: %v", err)
+	}
+
+	wrPlayers, err := filterPosPlayersInQuantile(players, "WR", strengthStep)
+	if err != nil {
+		return LineupData{}, fmt.Errorf("failed to filter WR players: %v", err)
+	}
+
+	tePlayers, err := filterPosPlayersInQuantile(players, "TE", strengthStep)
+	if err != nil {
+		return LineupData{}, fmt.Errorf("failed to filter TE players: %v", err)
+	}
+
+	flexPlayers, err := filterPosPlayersInQuantile(players, "FLEX", strengthStep)
+	if err != nil {
+		return LineupData{}, fmt.Errorf("failed to filter FLEX players: %v", err)
+	}
+
+	dstPlayers, err := filterPosPlayersInQuantile(players, "DST", strengthStep)
+	if err != nil {
+		return LineupData{}, fmt.Errorf("failed to filter DST players: %v", err)
+	}
+
+	overallArrays, err := generateBaseArrays(qbPlayers, rbPlayers, wrPlayers, tePlayers, flexPlayers, dstPlayers, 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, "QB"),   // QB
+				getPlayerName(allPlayers[i][1], nameMap, "RB1"),  // RB1
+				getPlayerName(allPlayers[i][2], nameMap, "RB2"),  // RB2
+				getPlayerName(allPlayers[i][3], nameMap, "WR1"),  // WR1
+				getPlayerName(allPlayers[i][4], nameMap, "WR2"),  // WR2
+				getPlayerName(allPlayers[i][5], nameMap, "WR3"),  // WR3
+				getPlayerName(allPlayers[i][6], nameMap, "TE"),   // TE
+				getPlayerName(allPlayers[i][7], nameMap, "FLEX"), // FLEX
+				getPlayerName(allPlayers[i][8], nameMap, "DST"),  // DST
+			}
+
+			fmt.Printf("  Lineup %d: Salary=%d, Projection=%.2f, Ownership=%.3f\n",
+				i+1, allSalaries[i], allProjections[i], allOwnership[i])
+			fmt.Printf("    Players: QB=%s, RB1=%s, RB2=%s, WR1=%s, WR2=%s, WR3=%s, TE=%s, FLEX=%s, DST=%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, "QB"),
+					getPlayerName(allPlayers[i][1], nameMap, "RB1"),
+					getPlayerName(allPlayers[i][2], nameMap, "RB2"),
+					getPlayerName(allPlayers[i][3], nameMap, "WR1"),
+					getPlayerName(allPlayers[i][4], nameMap, "WR2"),
+					getPlayerName(allPlayers[i][5], nameMap, "WR3"),
+					getPlayerName(allPlayers[i][6], nameMap, "TE"),
+					getPlayerName(allPlayers[i][7], nameMap, "FLEX"),
+					getPlayerName(allPlayers[i][8], nameMap, "DST"),
+				}
+
+				fmt.Printf("  Lineup %d: Salary=%d, Projection=%.2f, Ownership=%.3f\n",
+					i+1, allSalaries[i], allProjections[i], allOwnership[i])
+				fmt.Printf("    Players: QB=%s, RB1=%s, RB2=%s, WR1=%s, WR2=%s, WR3=%s, TE=%s, FLEX=%s, DST=%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 9\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],
+				QB:              result.Players[i][0],
+				RB1:             result.Players[i][1],
+				RB2:             result.Players[i][2],
+				WR1:             result.Players[i][3],
+				WR2:             result.Players[i][4],
+				WR3:             result.Players[i][5],
+				TE:              result.Players[i][6],
+				FLEX:            result.Players[i][7],
+				DST:             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 := "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}
+
+	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_nfl_go/NFL_seed_frames.go

@@ -0,0 +1,1131 @@
+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"`
+	QB              int32     `bson:"QB"`
+	RB1             int32     `bson:"RB1"`
+	RB2             int32     `bson:"RB2"`
+	WR1             int32     `bson:"WR1"`
+	WR2             int32     `bson:"WR2"`
+	WR3             int32     `bson:"WR3"`
+	TE              int32     `bson:"TE"`
+	FLEX            int32     `bson:"FLEX"`
+	DST             int32     `bson:"DST"`
+	CreatedAt       time.Time `bson:"created_at"`
+}
+
+func loadPlayerData() (*ProcessedData, error) {
+	data, err := ioutil.ReadFile("fd_nfl_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_nfl_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" {
+			if !strings.Contains(player.Position, "QB") && !strings.Contains(player.Position, "DST") {
+				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(qb, rb1, rb2, wr1, wr2, wr3, te, flex, dst []int32) [][]int32 {
+	length := len(qb)
+
+	result := make([][]int32, length)
+
+	for i := 0; i < length; i++ {
+		result[i] = []int32{
+			qb[i],
+			rb1[i],
+			rb2[i],
+			wr1[i],
+			wr2[i],
+			wr3[i],
+			te[i],
+			flex[i],
+			dst[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(qbPlayers, rbPlayers, wrPlayers, tePlayers, flexPlayers, dstPlayers []Player, numRows int, strengthStep float64, rng *rand.Rand) ([][]int32, error) {
+
+	// DEBUG: Check pool sizes
+	fmt.Printf("DEBUG - Pool sizes: QB=%d, RB=%d, WR=%d, TE=%d, FLEX=%d, DST=%d\n",
+		len(qbPlayers), len(rbPlayers), len(wrPlayers), len(tePlayers), len(flexPlayers), len(dstPlayers))
+
+	if len(qbPlayers) == 0 || len(rbPlayers) == 0 || len(wrPlayers) == 0 || len(tePlayers) == 0 || len(flexPlayers) == 0 || len(dstPlayers) == 0 {
+		return nil, fmt.Errorf("one or more position pools is empty: QB=%d, RB=%d, WR=%d, TE=%d, FLEX=%d, DST=%d",
+			len(qbPlayers), len(rbPlayers), len(wrPlayers), len(tePlayers), len(flexPlayers), len(dstPlayers))
+	}
+
+	var validArrays [][]int32
+	attempts := 0
+	maxAttempts := numRows * 10
+
+	for len(validArrays) < numRows && attempts < maxAttempts {
+		attempts++
+
+		qb := qbPlayers[rng.Intn(len(qbPlayers))]
+		rb1 := rbPlayers[rng.Intn(len(rbPlayers))]
+		rb2 := rbPlayers[rng.Intn(len(rbPlayers))]
+		wr1 := wrPlayers[rng.Intn(len(wrPlayers))]
+		wr2 := wrPlayers[rng.Intn(len(wrPlayers))]
+		wr3 := wrPlayers[rng.Intn(len(wrPlayers))]
+		te := tePlayers[rng.Intn(len(tePlayers))]
+		flex := flexPlayers[rng.Intn(len(flexPlayers))]
+		dst := dstPlayers[rng.Intn(len(dstPlayers))]
+
+		if rb1.Name != rb2.Name && rb1.Name != flex.Name && rb2.Name != flex.Name && wr1.Name != wr2.Name && wr1.Name != wr3.Name && wr2.Name != wr3.Name &&
+			wr1.Name != flex.Name && wr2.Name != flex.Name && wr3.Name != flex.Name && te.Name != flex.Name {
+
+			playerIDs := []int32{qb.ID, rb1.ID, rb2.ID, wr1.ID, wr2.ID, wr3.ID, te.ID, flex.ID, dst.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" {
+			if !strings.Contains(player.Position, "QB") && !strings.Contains(player.Position, "DST") {
+				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) {
+
+	qbPlayers, err := filterPosPlayersInQuantile(players, "QB", strengthStep)
+	if err != nil {
+		return LineupData{}, fmt.Errorf("failed to filter QB players: %v", err)
+	}
+
+	rbPlayers, err := filterPosPlayersInQuantile(players, "RB", strengthStep)
+	if err != nil {
+		return LineupData{}, fmt.Errorf("failed to filter RB players: %v", err)
+	}
+
+	wrPlayers, err := filterPosPlayersInQuantile(players, "WR", strengthStep)
+	if err != nil {
+		return LineupData{}, fmt.Errorf("failed to filter WR players: %v", err)
+	}
+
+	tePlayers, err := filterPosPlayersInQuantile(players, "TE", strengthStep)
+	if err != nil {
+		return LineupData{}, fmt.Errorf("failed to filter TE players: %v", err)
+	}
+
+	flexPlayers, err := filterPosPlayersInQuantile(players, "FLEX", strengthStep)
+	if err != nil {
+		return LineupData{}, fmt.Errorf("failed to filter FLEX players: %v", err)
+	}
+
+	dstPlayers, err := filterPosPlayersInQuantile(players, "DST", strengthStep)
+	if err != nil {
+		return LineupData{}, fmt.Errorf("failed to filter DST players: %v", err)
+	}
+
+	overallArrays, err := generateBaseArrays(qbPlayers, rbPlayers, wrPlayers, tePlayers, flexPlayers, dstPlayers, 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, "QB"),   // QB
+				getPlayerName(allPlayers[i][1], nameMap, "RB1"),  // RB1
+				getPlayerName(allPlayers[i][2], nameMap, "RB2"),  // RB2
+				getPlayerName(allPlayers[i][3], nameMap, "WR1"),  // WR1
+				getPlayerName(allPlayers[i][4], nameMap, "WR2"),  // WR2
+				getPlayerName(allPlayers[i][5], nameMap, "WR3"),  // WR3
+				getPlayerName(allPlayers[i][6], nameMap, "TE"),   // TE
+				getPlayerName(allPlayers[i][7], nameMap, "FLEX"), // FLEX
+				getPlayerName(allPlayers[i][8], nameMap, "DST"),  // DST
+			}
+
+			fmt.Printf("  Lineup %d: Salary=%d, Projection=%.2f, Ownership=%.3f\n",
+				i+1, allSalaries[i], allProjections[i], allOwnership[i])
+			fmt.Printf("    Players: QB=%s, RB1=%s, RB2=%s, WR1=%s, WR2=%s, WR3=%s, TE=%s, FLEX=%s, DST=%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, "QB"),
+					getPlayerName(allPlayers[i][1], nameMap, "RB1"),
+					getPlayerName(allPlayers[i][2], nameMap, "RB2"),
+					getPlayerName(allPlayers[i][3], nameMap, "WR1"),
+					getPlayerName(allPlayers[i][4], nameMap, "WR2"),
+					getPlayerName(allPlayers[i][5], nameMap, "WR3"),
+					getPlayerName(allPlayers[i][6], nameMap, "TE"),
+					getPlayerName(allPlayers[i][7], nameMap, "FLEX"),
+					getPlayerName(allPlayers[i][8], nameMap, "DST"),
+				}
+
+				fmt.Printf("  Lineup %d: Salary=%d, Projection=%.2f, Ownership=%.3f\n",
+					i+1, allSalaries[i], allProjections[i], allOwnership[i])
+				fmt.Printf("    Players: QB=%s, RB1=%s, RB2=%s, WR1=%s, WR2=%s, WR3=%s, TE=%s, FLEX=%s, DST=%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 9\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],
+				QB:              result.Players[i][0],
+				RB1:             result.Players[i][1],
+				RB2:             result.Players[i][2],
+				WR1:             result.Players[i][3],
+				WR2:             result.Players[i][4],
+				WR3:             result.Players[i][5],
+				TE:              result.Players[i][6],
+				FLEX:            result.Players[i][7],
+				DST:             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 := "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}
+
+	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())
+}

src/database.py

@@ -52,12 +52,14 @@ uri = get_secret("MONGODB_URI", "mongodb+srv://multichem:Xr1q5wZdXPbxdUmJ@testcl
 client = MongoClient(uri, retryWrites=True, serverSelectionTimeoutMS=10000, w=0)
 
 nhl_db = client['NHL_Database']
+nfl_db = client['NFL_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')
+NHL_Master_hold: str = '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'
+NFL_Master_hold: str = 'https://docs.google.com/spreadsheets/d/1I_1Ve3F4tftgfLQQoRKOJ351XfEG48s36OxXUKxmgS8/edit#gid=1668460741'
 
 # Discord Webhook
 discord = Discord(url=get_secret("DISCORD_WEBHOOK_URL", "https://discord.com/api/webhooks/1244687568394780672/COng4Gz1JFdoS-zCCcB24tQWo1upansxWFdfIv16_HZIb_j7-glZoGd4TXAGJDLIRiIJ"))

src/sports/nba_functions.py

@@ -758,7 +758,6 @@ def trending_script():
         worksheet.batch_clear(['A:S'])
         worksheet.update([Trending_df.columns.values.tolist()] + Trending_df.values.tolist())
 
- 
 def DK_NBA_ROO_Build(dk_roo_player_hold):
     total_sims = 1000
     wrong_name = ['Lu Dort', 'Carlton Carrington']
@@ -2333,30 +2332,6 @@ def upload_sd_dfs_data(client, sd_roo_final):
             except Exception as e:
                 st.write(f"Retry due to error: {e}")
                 time_sleep(1)
-    
-    # try:
-    #     sh = gc.open_by_url(NBA_Master_hold)
-    #     worksheet = sh.worksheet('ROO_Backlog')
-    #     Overall_Proj = DataFrame(worksheet.get_all_records())
-        
-    # except:
-    #     sh = gc2.open_by_url(NBA_Master_hold)
-    #     worksheet = sh.worksheet('ROO_Backlog')
-    #     Overall_Proj = DataFrame(worksheet.get_all_records())
-    
-    # collection = db['Range_Of_Outcomes_Backlog']
-    # Overall_Proj = Overall_Proj.reset_index(drop=True)
-    # chunk_size = 100000
-    # collection.drop()
-    # for i in range(0, len(Overall_Proj), chunk_size):
-    #     for _ in range(5):
-    #         try:
-    #             df_chunk = Overall_Proj.iloc[i:i + chunk_size]
-    #             collection.insert_many(df_chunk.to_dict('records'), ordered=False)
-    #             break
-    #         except Exception as e:
-    #             st.write(f"Retry due to error: {e}")
-    #             time_sleep(1)
 
 def upload_dfs_data(client, roo_final):
     

src/streamlit_app.py

@@ -269,9 +269,236 @@ if selected_tab == "NHL Updates":
             
 if selected_tab == "NFL Updates":
     from sports.nfl_functions import *
-    st.info("NFL updates coming soon!")
-    st.write("NFL functionality will be added later on.")
     
+    if st.button(f"� Update NFL models and generate seed frames", type="primary", use_container_width=True):
+        x: int = 1
+        high_end: int = 1
+
+        while x <= high_end:
+            Prop_Data_Creation_var = 0
+            DK_Team_Level_Stacks_var = 0
+            FD_Team_Level_Stacks_var = 0
+            DK_ROO_Structure_Creation_var = 0
+            FD_ROO_Structure_Creation_var = 0
+            DK_seed_frame_var = 0
+            FD_seed_frame_var = 0
+            upload_betting_var = 0
+            DK_SD_ROO_var = 0
+            FD_SD_ROO_var = 0
+            DK_SD_seed_frame_var = 0
+            FD_SD_seed_frame_var = 0
+
+
+            if upload_betting_var == 0:
+                upload_betting_data(client)
+                upload_betting_var = 1
+                    
+                time_sleep(1)
+
+            if DK_Team_Level_Stacks_var == 0:
+                Overall_Proj = DK_Team_Level_Stacks(dk_stacks_hold, dk_raw)
+                DK_Team_Level_Stacks_var = 1
+                
+                if DK_Team_Level_Stacks_var == 1:
+                    
+                    collection = nfl_db['DK_DFS_Stacks']
+                    Overall_Proj = Overall_Proj.reset_index(drop=True)
+                    chunk_size = 100000
+                    collection.drop()
+                    for i in range(0, len(Overall_Proj), chunk_size):
+                        for _ in range(5):
+                            try:
+                                df_chunk = Overall_Proj.iloc[i:i + chunk_size]
+                                collection.insert_many(df_chunk.to_dict('records'), ordered=False)
+                                break
+                            except Exception as e:
+                                print(f"Retry due to error: {e}")
+                                time_sleep(1)
+                else:
+                    pass
+                    
+                time_sleep(1)
+
+            if FD_Team_Level_Stacks_var == 0:
+                Overall_Proj = FD_Team_Level_Stacks(fd_stacks_hold, fd_raw)
+                FD_Team_Level_Stacks_var = 1
+                
+                if FD_Team_Level_Stacks_var == 1:
+                    
+                    collection = nfl_db['FD_DFS_Stacks']
+                    Overall_Proj = Overall_Proj.reset_index(drop=True)
+                    chunk_size = 100000
+                    collection.drop()
+                    for i in range(0, len(Overall_Proj), chunk_size):
+                        for _ in range(5):
+                            try:
+                                df_chunk = Overall_Proj.iloc[i:i + chunk_size]
+                                collection.insert_many(df_chunk.to_dict('records'), ordered=False)
+                                break
+                            except Exception as e:
+                                print(f"Retry due to error: {e}")
+                                time_sleep(1)
+                else:
+                    pass
+                    
+                time_sleep(1)
+
+            if DK_ROO_Structure_Creation_var == 0:
+                DK_ROO = DK_ROO_Structure_Creation(dk_player_hold, short_team_acro, long_team_acro, team_only_acro)
+                DK_ROO_Structure_Creation_var = 1
+                
+                if DK_ROO_Structure_Creation_var == 1:
+                    
+                    collection = nfl_db['DK_NFL_ROO']
+                    DK_ROO = DK_ROO.reset_index(drop=True)
+                    chunk_size = 100000
+                    collection.drop()
+                    for i in range(0, len(DK_ROO), chunk_size):
+                        for _ in range(5):
+                            try:
+                                df_chunk = DK_ROO.iloc[i:i + chunk_size]
+                                collection.insert_many(df_chunk.to_dict('records'), ordered=False)
+                                break
+                            except Exception as e:
+                                print(f"Retry due to error: {e}")
+                                time_sleep(1)
+                    
+                else:
+                    pass
+                    
+                time_sleep(1)
+
+            if FD_ROO_Structure_Creation_var == 0:
+                FD_ROO = FD_ROO_Structure_Creation(fd_player_hold, short_team_acro, long_team_acro, team_only_acro)
+                FD_ROO_Structure_Creation_var = 1
+                
+                if FD_ROO_Structure_Creation_var == 1:
+                    
+                    collection = nfl_db['FD_NFL_ROO']
+                    FD_ROO = FD_ROO.reset_index(drop=True)
+                    chunk_size = 100000
+                    collection.drop()
+                    for i in range(0, len(FD_ROO), chunk_size):
+                        for _ in range(5):
+                            try:
+                                df_chunk = FD_ROO.iloc[i:i + chunk_size]
+                                collection.insert_many(df_chunk.to_dict('records'), ordered=False)
+                                break
+                            except Exception as e:
+                                print(f"Retry due to error: {e}")
+                                time_sleep(1)
+                else:
+                    pass
+                    
+                time_sleep(1)
+                
+            if DK_seed_frame_var == 0:
+                DK_seed_frame(DK_ROO, seed_team_acro, short_team_acro, client)
+                DK_seed_frame_var = 1
+                    
+                time_sleep(1)
+
+            if FD_seed_frame_var == 0:
+                FD_seed_frame(FD_ROO, seed_team_acro, short_team_acro, client)
+                FD_seed_frame_var = 1
+                    
+                time_sleep(1)
+
+            if Prop_Data_Creation_var == 0:
+                Overall_Proj = Prop_Data_Creation()
+                Prop_Data_Creation_var = 1
+                
+                if Prop_Data_Creation_var == 1:
+                    
+                    collection = nfl_db['Player_Baselines']
+                    Overall_Proj = Overall_Proj.reset_index(drop=True)
+                    chunk_size = 100000
+                    collection.drop()
+                    for i in range(0, len(Overall_Proj), chunk_size):
+                        for _ in range(5):
+                            try:
+                                df_chunk = Overall_Proj.iloc[i:i + chunk_size]
+                                collection.insert_many(df_chunk.to_dict('records'), ordered=False)
+                                break
+                            except Exception as e:
+                                print(f"Retry due to error: {e}")
+                                time_sleep(1)
+                else:
+                    pass
+                    
+                time_sleep(1)
+
+            if DK_SD_ROO_var == 0:
+                dk_sd_roo_result = DK_SD_ROO(dk_showdown_hold, team_only_acro, short_team_acro, long_team_acro, dk_sd_projections)
+                DK_SD_ROO_var = 1
+                
+                if DK_SD_ROO_var == 1:
+                    
+                    collection = nfl_db['DK_SD_NFL_ROO']
+                    dk_sd_roo_result = dk_sd_roo_result.reset_index(drop=True)
+                    chunk_size = 100000
+                    collection.drop()
+                    for i in range(0, len(dk_sd_roo_result), chunk_size):
+                        for _ in range(5):
+                            try:
+                                df_chunk = dk_sd_roo_result.iloc[i:i + chunk_size]
+                                collection.insert_many(df_chunk.to_dict('records'), ordered=False)
+                                break
+                            except Exception as e:
+                                print(f"Retry due to error: {e}")
+                                time_sleep(1)
+
+                else:
+                    pass
+                    
+                time_sleep(1)
+
+            if FD_SD_ROO_var == 0:
+                fd_sd_roo_result = FD_SD_ROO(fd_showdown_hold, team_only_acro, short_team_acro, long_team_acro, fd_sd_projections)
+                FD_SD_ROO_var = 1
+                
+                if FD_SD_ROO_var == 1:
+                    
+                    collection = nfl_db['FD_SD_NFL_ROO']
+                    fd_sd_roo_result = fd_sd_roo_result.reset_index(drop=True)
+                    chunk_size = 100000
+                    collection.drop()
+                    for i in range(0, len(fd_sd_roo_result), chunk_size):
+                        for _ in range(5):
+                            try:
+                                df_chunk = fd_sd_roo_result.iloc[i:i + chunk_size]
+                                collection.insert_many(df_chunk.to_dict('records'), ordered=False)
+                                break
+                            except Exception as e:
+                                print(f"Retry due to error: {e}")
+                                time_sleep(1)
+                else:
+                    pass
+                    
+                time_sleep(1)
+
+            if DK_SD_seed_frame_var == 0:
+                DK_SD_seed_frame(dk_sd_roo_result, team_only_acro, long_team_acro, client, dk_showdown_options, dk_sd_projections)
+                DK_SD_seed_frame_var = 1
+                    
+                time_sleep(1)
+
+            if FD_SD_seed_frame_var == 0:
+                FD_SD_seed_frame(fd_sd_roo_result, team_only_acro, long_team_acro, client, fd_showdown_options, fd_sd_projections)
+                FD_SD_seed_frame_var = 1
+                    
+                time_sleep(1)
+
+            print (f'currently on run {x}, {high_end - x} runs remaining')
+
+            x += 1
+            
+            if high_end > 1:
+                time_sleep(600)
+    
+        st.success("✅ NFL updates completed successfully!")
+        st.balloons()
+
 if selected_tab == "NBA Updates":
     from sports.nba_functions import *