Adding MMA functionality to Dockerfile as well as adding any Go executables, change the database to grab from the MMA database, change the Streamlit app and the MMA_functions to add functionality.

Dockerfile

@@ -18,6 +18,7 @@ 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
 COPY func/pga_go ./func/pga_go
+COPY func/mma_go ./func/mma_go
 
 # Build the Go programs for Linux
 RUN CGO_ENABLED=0 GOOS=linux go build -o dk_nhl_seed ./func/dk_nhl_go/NHL_seed_frames.go
@@ -28,6 +29,7 @@ RUN CGO_ENABLED=0 GOOS=linux go build -o dk_nfl_seed ./func/dk_nfl_go/NFL_seed_f
 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
 RUN CGO_ENABLED=0 GOOS=linux go build -o pga_seed ./func/pga_go/PGA_seed_frames.go
+RUN CGO_ENABLED=0 GOOS=linux go build -o mma_seed ./func/mma_go/MMA_seed_frames.go
 
 # Python stage
 FROM python:3.11-slim
@@ -57,6 +59,7 @@ 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
 COPY --from=go-builder /go-build/pga_seed ./pga_go/PGA_seed_frames
+COPY --from=go-builder /go-build/mma_seed ./mma_go/MMA_seed_frames
 
 # Make Go binaries executable
 RUN chmod +x ./dk_nhl_go/NHL_seed_frames ./fd_nhl_go/NHL_seed_frames
@@ -64,6 +67,7 @@ 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
 RUN chmod +x ./pga_go/PGA_seed_frames
+RUN chmod +x ./mma_go/MMA_seed_frames
 
 # Create .streamlit directory for config
 RUN mkdir -p .streamlit

func/mma_go/MMA_seed_frames.go

@@ -0,0 +1,1003 @@
+package main
+
+import (
+	// Script Imports
+	"context"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"math/rand"
+	"os"
+	"slices"
+	"sort"
+	"strconv"
+	"time"
+
+	// MongoDB Imports
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+)
+
+type LineupData struct {
+	Salary     []int32
+	Projection []float64
+	Ownership  []float64
+	Players    [][]int32
+}
+
+type Player struct {
+	ID          int32   `json:"id"`
+	Name        string  `json:"name"`
+	Position    string  `json:"position"`
+	Opp         string  `json:"opp"`
+	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"`
+		OppMap        map[string]string  `json:"opp_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"`
+	Ownership  float64   `bson:"Own"`
+	FLEX1      int32     `bson:"FLEX1"`
+	FLEX2      int32     `bson:"FLEX2"`
+	FLEX3      int32     `bson:"FLEX3"`
+	FLEX4      int32     `bson:"FLEX4"`
+	FLEX5      int32     `bson:"FLEX5"`
+	FLEX6      int32     `bson:"FLEX6"`
+	CreatedAt  time.Time `bson:"created_at"`
+}
+
+func loadPlayerData() (*ProcessedData, error) {
+	data, err := ioutil.ReadFile("mma_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("mma_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"`
+		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{},
+				Ownership:  []float64{},
+				Players:    [][]int32{},
+			}
+		}
+
+		slateData := optimalsBySlate[optimal.Slate]
+		slateData.Salary = append(slateData.Salary, optimal.Salary)
+		slateData.Projection = append(slateData.Projection, optimal.Projection)
+		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)
+	oppMap := 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.OppMap {
+		key, err := strconv.Atoi(keyStr)
+		if err != nil {
+			fmt.Printf("Error converting key %s: %v\n", keyStr, err)
+			continue
+		}
+		oppMap[int32(key)] = value
+	}
+	return salaryMap, projMap, ownMap, oppMap
+}
+
+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
+	filteredPlayers = append(filteredPlayers, players...)
+
+	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),
+		Ownership:  sliceByIndicies(data.Ownership, indicies),
+		Players:    sliceByIndicies(data.Players, indicies),
+	}
+}
+
+func combineArrays(flex1, flex2, flex3, flex4, flex5, flex6 []int32) [][]int32 {
+	length := len(flex1)
+
+	result := make([][]int32, length)
+
+	for i := 0; i < length; i++ {
+		result[i] = []int32{
+			flex1[i],
+			flex2[i],
+			flex3[i],
+			flex4[i],
+			flex5[i],
+			flex6[i],
+		}
+	}
+
+	return result
+}
+
+func createSeedFrames(combinedArrays [][]int32, salaryMap map[int32]int32, projMap map[int32]float64, ownMap map[int32]float64, site string) LineupData {
+
+	salaries := make([][]int32, len(combinedArrays))
+	projections := make([][]float64, len(combinedArrays))
+	ownership := make([][]float64, len(combinedArrays))
+
+	for i, row := range combinedArrays {
+
+		players := row[0:6]
+
+		playerSalaries := processAndFill(players, salaryMap)
+		playerProjections := processAndFill(players, projMap)
+		playerOwnership := processAndFill(players, ownMap)
+
+		salaries[i] = playerSalaries
+		projections[i] = playerProjections
+		ownership[i] = playerOwnership
+	}
+
+	totalSalaries := sumSalaryRows(salaries)
+	totalProjections := sumProjRows(projections)
+	totalOwnership := sumOwnRows(ownership)
+
+	var validIndicies []int
+	if site == "DK" {
+		validIndicies = filterMax(totalSalaries, int32(50000))
+	} else {
+		validIndicies = filterMax(totalSalaries, int32(100))
+	}
+
+	validData := LineupData{
+		Salary:     sliceByIndicies(totalSalaries, validIndicies),
+		Projection: sliceByIndicies(totalProjections, 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(flexPlayers []Player, oppMap map[int32]string, numRows int, strengthStep float64, rng *rand.Rand) ([][]int32, error) {
+
+	// DEBUG: Check pool sizes
+	fmt.Printf("DEBUG - Pool sizes: FLEX=%d\n", len(flexPlayers))
+
+	if len(flexPlayers) == 0 {
+		return nil, fmt.Errorf("one or more position pools is empty: FLEX=%d", len(flexPlayers))
+	}
+
+	var validArrays [][]int32
+	attempts := 0
+	maxAttempts := numRows * 10
+
+	for len(validArrays) < numRows && attempts < maxAttempts {
+		attempts++
+
+		flex1 := flexPlayers[rng.Intn(len(flexPlayers))]
+		flex2 := flexPlayers[rng.Intn(len(flexPlayers))]
+		flex3 := flexPlayers[rng.Intn(len(flexPlayers))]
+		flex4 := flexPlayers[rng.Intn(len(flexPlayers))]
+		flex5 := flexPlayers[rng.Intn(len(flexPlayers))]
+		flex6 := flexPlayers[rng.Intn(len(flexPlayers))]
+
+		if flex1.Name != flex2.Name && flex1.Name != flex3.Name && flex1.Name != flex4.Name && flex1.Name != flex5.Name && flex1.Name != flex6.Name &&
+			flex2.Name != flex3.Name && flex2.Name != flex4.Name && flex2.Name != flex5.Name && flex2.Name != flex6.Name &&
+			flex3.Name != flex4.Name && flex3.Name != flex5.Name && flex3.Name != flex6.Name && flex4.Name != flex5.Name && flex4.Name != flex6.Name && flex5.Name != flex6.Name {
+
+			if strengthStep >= 0.001 {
+				// Build a set of all player names in this lineup
+				flexAll := []Player{flex1, flex2, flex3, flex4, flex5, flex6}
+				playerNames := make(map[string]bool)
+				for _, p := range flexAll {
+					playerNames[p.Name] = true
+				}
+
+				// Check if any player's opponent is also in the lineup
+				hasOppConflict := false
+				for _, p := range flexAll {
+					oppName := oppMap[p.ID]
+					if oppName != "" && playerNames[oppName] {
+						hasOppConflict = true
+						break
+					}
+				}
+
+				if hasOppConflict {
+					continue
+				}
+			}
+
+			playerIDs := []int32{flex1.ID, flex2.ID, flex3.ID, flex4.ID, flex5.ID, flex6.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
+	filteredPlayers = append(filteredPlayers, players...)
+
+	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, oppMap map[int32]string, strengthStep float64, numRows int, rng *rand.Rand, salaryMap map[int32]int32, projMap map[int32]float64, ownMap map[int32]float64, site string) (LineupData, error) {
+
+	flexPlayers, err := filterPosPlayersInQuantile(players, "FLEX", strengthStep)
+	if err != nil {
+		return LineupData{}, fmt.Errorf("failed to filter FLEX players: %v", err)
+	}
+
+	overallArrays, err := generateBaseArrays(flexPlayers, oppMap, numRows, strengthStep, rng)
+	if err != nil {
+		return LineupData{}, fmt.Errorf("failed to generate base arrays: %v", err)
+	}
+
+	result := createSeedFrames(overallArrays, salaryMap, projMap, ownMap, site)
+
+	return result, nil
+}
+
+func runSeedframeRoutines(players []Player, oppMap map[int32]string, strengthVars []float64, rowsPerLevel []int, salaryMap map[int32]int32, projMap map[int32]float64, ownMap map[int32]float64, 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, oppMap, step, rows, rng, salaryMap, projMap, ownMap, 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, "FLEX1"), // QB
+				getPlayerName(allPlayers[i][1], nameMap, "FLEX2"), // RB1
+				getPlayerName(allPlayers[i][2], nameMap, "FLEX3"), // RB2
+				getPlayerName(allPlayers[i][3], nameMap, "FLEX4"), // WR1
+				getPlayerName(allPlayers[i][4], nameMap, "FLEX5"), // WR2
+				getPlayerName(allPlayers[i][5], nameMap, "FLEX6"), // WR3
+			}
+
+			fmt.Printf("  Lineup %d: Salary=%d, Projection=%.2f, Ownership=%.3f\n",
+				i+1, allSalaries[i], allProjections[i], allOwnership[i])
+			fmt.Printf("    Players: FLEX1=%s, FLEX2=%s, FLEX3=%s, FLEX4=%s, FLEX5=%s, FLEX6=%s\n",
+				playerNames[0], playerNames[1], playerNames[2], playerNames[3],
+				playerNames[4], playerNames[5])
+		}
+
+		// 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, "FLEX1"),
+					getPlayerName(allPlayers[i][1], nameMap, "FLEX2"),
+					getPlayerName(allPlayers[i][2], nameMap, "FLEX3"),
+					getPlayerName(allPlayers[i][3], nameMap, "FLEX4"),
+					getPlayerName(allPlayers[i][4], nameMap, "FLEX5"),
+					getPlayerName(allPlayers[i][5], nameMap, "FLEX6"),
+				}
+
+				fmt.Printf("  Lineup %d: Salary=%d, Projection=%.2f, Ownership=%.3f\n",
+					i+1, allSalaries[i], allProjections[i], allOwnership[i])
+				fmt.Printf("    Players: FLEX1=%s, FLEX2=%s, FLEX3=%s, FLEX4=%s, FLEX5=%s, FLEX6=%s\n",
+					playerNames[0], playerNames[1], playerNames[2], playerNames[3],
+					playerNames[4], playerNames[5])
+			}
+		}
+	}
+}
+
+func removeDuplicates(results []LineupData) []LineupData {
+	seen := make(map[string]bool)
+	var uniqueLineups []LineupData
+
+	for _, result := range results {
+		for i := 0; i < len(result.Players); i++ {
+			// Create combo string like Python
+			combo := fmt.Sprintf("%d%d%d%d%d%d",
+				result.Players[i][0], result.Players[i][1], result.Players[i][2],
+				result.Players[i][3], result.Players[i][4], result.Players[i][5])
+
+			// Sort combo like Python
+			sortedCombo := sortChars(combo)
+
+			if !seen[sortedCombo] {
+				seen[sortedCombo] = true
+				uniqueLineups = append(uniqueLineups, LineupData{
+					Salary:     []int32{result.Salary[i]},
+					Projection: []float64{result.Projection[i]},
+					Ownership:  []float64{result.Ownership[i]},
+					Players:    [][]int32{result.Players[i]},
+				})
+			}
+		}
+	}
+
+	if len(uniqueLineups) == 0 {
+		return []LineupData{}
+	}
+
+	var allSalary []int32
+	var allProjection []float64
+	var allOwnership []float64
+	var allPlayers [][]int32
+
+	for _, lineup := range uniqueLineups {
+		allSalary = append(allSalary, lineup.Salary[0])
+		allProjection = append(allProjection, lineup.Projection[0])
+		allOwnership = append(allOwnership, lineup.Ownership[0])
+		allPlayers = append(allPlayers, lineup.Players[0])
+	}
+
+	return []LineupData{{
+		Salary:     allSalary,
+		Projection: allProjection,
+		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]) < 6 {
+				fmt.Printf("Warning: Lineup %d has only %d players, expected 6\n", i, len(result.Players[i]))
+			}
+
+			doc := LineupDocument{
+				Salary:     result.Salary[i],
+				Projection: result.Projection[i],
+				Ownership:  result.Ownership[i],
+				FLEX1:      result.Players[i][0],
+				FLEX2:      result.Players[i][1],
+				FLEX3:      result.Players[i][2],
+				FLEX4:      result.Players[i][3],
+				FLEX5:      result.Players[i][4],
+				FLEX6:      result.Players[i][5],
+				CreatedAt:  time.Now(),
+			}
+
+			documents = append(documents, doc)
+		}
+	}
+
+	if len(documents) == 0 {
+		fmt.Printf("Warning: No documents to insert for slate %s\n", slate)
+	}
+
+	if len(documents) > 500000 {
+		documents = documents[:500000]
+	}
+
+	chunkSize := 250000
+	for i := 0; i < len(documents); i += chunkSize {
+		end := i + chunkSize
+		if end > len(documents) {
+			end = len(documents)
+		}
+
+		chunk := documents[i:end]
+
+		for attempt := 0; attempt < 5; attempt++ {
+			ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+
+			opts := options.InsertMany().SetOrdered(false)
+			_, err := collection.InsertMany(ctx, chunk, opts)
+			cancel()
+
+			if err == nil {
+				fmt.Printf("Successfully inserted chunk %d-%d to %s\n", i, end, collectionName)
+				break
+			}
+
+			fmt.Printf("Retry %d due to error: %v\n", attempt+1, err)
+			if attempt < 4 {
+				time.Sleep(1 * time.Second)
+			}
+		}
+
+		if err != nil {
+			return fmt.Errorf("failed to insert chunk %d-%d after 5 attempts: %v", i, end, err)
+		}
+	}
+
+	fmt.Printf("All documents inserted successfully to %s!\n", collectionName)
+	return nil
+}
+
+func groupPlayersBySlate(players []Player) map[string][]Player {
+	slateGroups := make(map[string][]Player)
+
+	for _, player := range players {
+		slateGroups[player.Slate] = append(slateGroups[player.Slate], player)
+	}
+
+	return slateGroups
+}
+
+func getPlayerName(playerID int32, nameMap map[int32]string, position string) string {
+	if name, exists := nameMap[playerID]; exists && name != "" {
+		return name
+	}
+	return fmt.Sprintf("Unknown_%s_%d", position, playerID)
+}
+
+func convertNamesToMaps(playerSet *PlayerSet) map[int32]string {
+	nameMap := make(map[int32]string)
+
+	for keyStr, value := range playerSet.Maps.NameMap {
+		key, err := strconv.Atoi(keyStr)
+		if err != nil {
+			fmt.Printf("Error coinverting name key %s: %v\n", keyStr, err)
+			continue
+		}
+		nameMap[int32(key)] = value
+	}
+
+	return nameMap
+}
+
+func main() {
+	site := "DK"
+	sport := "MMA"
+	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, oppMapJSON := 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, oppMapJSON, strengthVars, rowsPerLevel,
+			salaryMapJSON, projectionMapJSON,
+			ownershipMapJSON, 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

@@ -55,6 +55,7 @@ nhl_db = client['NHL_Database']
 nfl_db = client['NFL_Database']
 nba_db = client['NBA_Database']
 pga_db = client['PGA_Database']
+mma_db = client['MMA_Database']
 contest_db = client["Contest_Information"]
 
 # Google Sheets URLs
@@ -62,6 +63,7 @@ NHL_Master_hold: str = 'https://docs.google.com/spreadsheets/d/1NmKa-b-2D3w7rRxw
 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'
 PGA_Master_hold: str = 'https://docs.google.com/spreadsheets/d/1lMLxWdvCnOFBtG9dhM0zv2USuxZbkogI_2jnxFfQVVs/edit?gid=1596772515#gid=1596772515'
+MMA_Master_hold: str = 'https://docs.google.com/spreadsheets/d/1Q1mnICesMHT0xgd4-ZOqYOUOXy2GiaOnrm5T5Jh7Doo/edit?gid=870330026#gid=870330026'
 
 # Discord Webhook
 discord = Discord(url=get_secret("DISCORD_WEBHOOK_URL", "https://discord.com/api/webhooks/1244687568394780672/COng4Gz1JFdoS-zCCcB24tQWo1upansxWFdfIv16_HZIb_j7-glZoGd4TXAGJDLIRiIJ"))

src/sports/mma_functions.py

@@ -0,0 +1,504 @@
+# Numpy
+from numpy import random as np_random
+from numpy import array as np_array
+from numpy import zeros as np_zeros
+from numpy import nan as np_nan
+
+# Pandas
+from pandas import DataFrame
+from pandas import merge as pd_merge
+from pandas import concat as pd_concat
+from pandas import Series as pd_Series
+from pandas import options as pd_options
+from pandas import errors as pd_errors
+from pandas import options as poptions
+
+# Time
+import time
+from time import sleep as time_sleep
+from pytz import timezone as tz
+from datetime import datetime
+
+# Database
+from pymongo import MongoClient
+
+# Misc
+from ortools.linear_solver import pywraplp
+from random import choice
+pd_options.mode.chained_assignment = None  # default='warn'
+from warnings import simplefilter
+simplefilter(action="ignore", category=pd_errors.PerformanceWarning)
+poptions.mode.chained_assignment = None  # default='warn'
+
+# GO
+import json
+import subprocess
+import os
+
+def run_go_classic_lineup_generator(site="DK", sport="MMA"):
+    """Run the Go lineup generator after Python data processing"""
+    try:
+        print(f"Starting Go {sport} lineup generation...")
+        start_time = time.time()
+        
+        # Determine the correct binary path based on environment
+        binary_path = "./mma_go/MMA_seed_frames"  # Linux (Streamlit)
+        if os.name == 'nt':  # Windows
+            binary_path = "./mma_go/MMA_seed_frames.exe"
+        
+        # Check if binary exists
+        if not os.path.exists(binary_path):
+            print(f"Error: Binary not found at {binary_path}")
+            return False
+        
+        print(f"Looking for binary at: {os.path.abspath(binary_path)}")
+        
+        # Run the Go executable
+        result = subprocess.run(
+            [binary_path, site, sport],
+            capture_output=True,
+            text=True,
+            check=True,
+            cwd="."  # Make sure we're in the right directory
+        )
+        
+        end_time = time.time()
+        print(f"Go {sport} processing completed in {end_time - start_time:.2f} seconds")
+        
+        if result.stdout:
+            print("Go output:", result.stdout)
+        if result.stderr:
+            print("Go warnings:", result.stderr)
+            
+        return True
+        
+    except subprocess.CalledProcessError as e:
+        print(f"Go process failed with exit code {e.returncode}")
+        if e.stdout:
+            print("Stdout:", e.stdout)
+        if e.stderr:
+            print("Error output:", e.stderr)
+        return False
+    except FileNotFoundError:
+        print(f"Error: {binary_path} not found. Make sure it's compiled and in the correct directory.")
+        return False
+
+def init_mma_optimals(model_source: DataFrame, salary_cap: int, combos: int):
+    """
+    Generate optimal MMA lineups.
+    
+    MMA Rules:
+    - 6 FLEX positions (FLEX1-FLEX6)
+    - A player cannot be in the same lineup as their opponent (Opp)
+    - Salary cap constraint
+    """
+    df = model_source.copy()
+    
+    # Build opponent mapping for constraint checking
+    player_opp_map = df.set_index('Player')['Opp'].to_dict()
+    
+    # Create solver
+    solver = pywraplp.Solver.CreateSolver('SCIP')
+    if not solver:
+        raise Exception("Could not create solver.")
+    
+    # Variables: x[i] = 1 if player i is selected
+    x = {}
+    for i in df.index:
+        x[i] = solver.BoolVar(f'x_{i}')
+    
+    # Constraint: Select exactly 6 players
+    solver.Add(solver.Sum([x[i] for i in df.index]) == 6)
+    
+    # Constraint: Salary cap
+    solver.Add(
+        solver.Sum(x[i] * df.loc[i, 'Salary'] for i in df.index) <= salary_cap
+    )
+    
+    # Constraint: Player cannot be in lineup with their opponent
+    # For each player, if they're selected, their opponent cannot be
+    for i in df.index:
+        player_name = df.loc[i, 'Player']
+        opp_name = df.loc[i, 'Opp']
+        # Find opponent's index
+        opp_rows = df[df['Player'] == opp_name]
+        if not opp_rows.empty:
+            opp_idx = opp_rows.index[0]
+            # x[i] + x[opp_idx] <= 1 (can't have both)
+            solver.Add(x[i] + x[opp_idx] <= 1)
+    
+    # Objective: maximize total median
+    objective = solver.Sum(x[i] * df.loc[i, 'Median'] for i in df.index)
+    solver.Maximize(objective)
+    
+    status = solver.Solve()
+    
+    if status != pywraplp.Solver.OPTIMAL and status != pywraplp.Solver.FEASIBLE:
+        return []
+    
+    # Get selected players
+    selected_indices = [i for i in df.index if x[i].solution_value() > 0.5]
+    lineup = df.loc[selected_indices].copy()
+    
+    # Assign FLEX1-FLEX6 labels
+    lineup = lineup.sort_values(by='Median', ascending=False).reset_index(drop=True)
+    lineup['position_label'] = [f'FLEX{i+1}' for i in range(len(lineup))]
+    
+    # Build the row dictionary
+    row_dict = {row['position_label']: row['Player'] for _, row in lineup.iterrows()}
+    row_dict['Total_Salary'] = lineup['Salary'].sum()
+    row_dict['Total_Median'] = lineup['Median'].sum()
+    row_dict['Own'] = lineup['Own'].sum()
+    
+    # Generate variations
+    result_rows = [row_dict.copy()]
+    pos_labels = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
+    
+    for _ in range(combos):
+        new_row = row_dict.copy()
+        swapped_positions = []
+        
+        # Determine number of positions to swap (1-3)
+        num_swaps = choice([1, 2, 3])
+        
+        for _ in range(num_swaps):
+            available_positions = [pos for pos in pos_labels if pos not in swapped_positions]
+            if not available_positions:
+                break
+            
+            pos_to_swap = choice(available_positions)
+            swapped_positions.append(pos_to_swap)
+            
+            # Get current lineup players
+            current_players = [new_row[p] for p in pos_labels]
+            
+            # Get opponents of current players (can't add these)
+            blocked_opps = set()
+            for player in current_players:
+                if player != new_row[pos_to_swap]:  # Exclude the player being swapped
+                    opp = player_opp_map.get(player)
+                    if opp:
+                        blocked_opps.add(opp)
+            
+            # Find eligible replacements:
+            # - Not already in lineup
+            # - Not an opponent of anyone in lineup
+            eligible = df[
+                (~df['Player'].isin(current_players)) &
+                (~df['Player'].isin(blocked_opps))
+            ]
+            
+            if eligible.empty:
+                continue
+            
+            # Randomly select a replacement
+            replacement = eligible.sample(1).iloc[0]
+            new_row[pos_to_swap] = replacement['Player']
+        
+        # Recalculate totals
+        player_rows = df[df['Player'].isin([new_row[k] for k in pos_labels])]
+        new_row['Total_Salary'] = player_rows['Salary'].sum()
+        new_row['Total_Median'] = player_rows['Median'].sum()
+        new_row['Own'] = player_rows['Own'].sum()
+        
+        result_rows.append(new_row)
+    
+    # Create final DataFrame
+    final_df = DataFrame(result_rows)
+    final_df = final_df.drop_duplicates(subset=['Total_Median', 'Total_Salary'])
+    final_df = final_df[final_df['Total_Salary'] <= salary_cap]
+    
+    # Validate no opponent conflicts in final lineups
+    def has_opponent_conflict(row):
+        players = [row[pos] for pos in pos_labels]
+        for player in players:
+            opp = player_opp_map.get(player)
+            if opp and opp in players:
+                return True
+        return False
+    
+    final_df = final_df[~final_df.apply(has_opponent_conflict, axis=1)]
+    final_df = final_df.sort_values(by='Total_Median', ascending=False)
+    
+    return [final_df]
+
+def format_mma_optimals(all_results: list, model_source: DataFrame):
+    """
+    Format MMA optimal lineups for output.
+    
+    Args:
+        all_results: List of DataFrames with optimal lineups
+        model_source: Original player data
+    
+    Returns:
+        Formatted DataFrame with lineup data
+    """
+    if not all_results:
+        return DataFrame()
+    
+    roo_frame = model_source.copy()
+    required_positions = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
+    
+    combined_df = pd_concat(all_results, ignore_index=True)
+    combined_df = combined_df.sort_values(by='Total_Median', ascending=False)
+    
+    # Process each row to create the formatted structure
+    formatted_rows = []
+    
+    for _, row in combined_df.iterrows():
+        new_row = {}
+        
+        # Basic columns
+        new_row['salary'] = row['Total_Salary']
+        new_row['proj'] = row['Total_Median']
+        new_row['Own'] = row['Own']
+        
+        # Add position columns
+        for pos in required_positions:
+            if pos in row:
+                new_row[pos] = row[pos]
+        
+        formatted_rows.append(new_row)
+    
+    final_formatted_df = DataFrame(formatted_rows)
+    
+    # Ensure all required position columns exist
+    for pos in required_positions:
+        if pos not in final_formatted_df.columns:
+            final_formatted_df[pos] = ''
+    
+    # Reorder columns
+    column_order = ['salary', 'proj', 'Own'] + required_positions
+    final_formatted_df = final_formatted_df[column_order]
+
+    return final_formatted_df
+
+def player_level_roo(working_proj: DataFrame, fighter_dicts: dict, client: MongoClient, total_sims: int = 1000):
+    db = client['MMA_Database']
+
+    flex_file = working_proj[['Player', 'Position', 'Salary', 'Floor', 'Median', 'Ceiling']]
+    flex_file['STD'] = (flex_file['Median'] / 3)
+    flex_file = flex_file[['Player', 'Position', 'Salary', 'Floor', 'Median', 'Ceiling', 'STD']]
+    flex_file = flex_file.reset_index(drop=True)
+    hold_file = flex_file.copy()
+    overall_file = flex_file.copy()
+    salary_file = flex_file.copy()
+    
+    try:    
+        overall_median_gpu = np_array(overall_file['Median'])
+        overall_std_gpu = np_array(overall_file['STD'])
+        overall_salary_gpu = np_array(overall_file['Salary'])
+        
+        data_shape = (len(overall_file['Player']), total_sims)
+        salary_array = np_zeros(data_shape)
+        sim_array = np_zeros(data_shape)
+        
+        for x in range(0, total_sims):    
+            result_gpu = overall_salary_gpu
+            salary_array[:, x] = result_gpu 
+        cupy_array = salary_array
+        
+        salary_file = salary_file.reset_index(drop=True)
+        salary_cupy = DataFrame(cupy_array, columns=list(range(0, total_sims)))
+        salary_check_file = pd_concat([salary_file, salary_cupy], axis=1)
+    except:
+        for x in range(0,total_sims):    
+            salary_file[x] = salary_file['Salary']
+        salary_check_file = salary_file.copy()
+
+    salary_file=salary_check_file.drop(['Player', 'Position', 'Salary', 'Floor', 'Median', 'Ceiling', 'STD'], axis=1)
+
+    salary_file = salary_file.div(total_sims)
+    
+    try:
+        for x in range(0, total_sims):    
+            result_gpu = np_random.normal(overall_median_gpu, overall_std_gpu)
+            sim_array[:, x] = result_gpu 
+        add_array = sim_array
+        
+        overall_file = overall_file.reset_index(drop=True)
+        df2 = DataFrame(add_array, columns=list(range(0, total_sims)))
+        check_file = pd_concat([overall_file, df2], axis=1)
+    except:
+        for x in range(0,total_sims):    
+            overall_file[x] = np_random.normal(overall_file['Median'],overall_file['STD'])
+        check_file = overall_file.copy()
+        
+    overall_file=check_file.drop(['Player', 'Position', 'Salary', 'Floor', 'Median', 'Ceiling', 'STD'], axis=1)
+
+    players_only = hold_file[['Player']]
+    raw_lineups_file = players_only
+
+    for x in range(0,total_sims):
+        maps_dict = {'proj_map':dict(zip(hold_file.Player,overall_file[x]))}
+        raw_lineups_file[x] = sum([raw_lineups_file['Player'].map(maps_dict['proj_map'])])
+        players_only[x] = raw_lineups_file[x].rank(ascending=False)
+
+    players_only=players_only.drop(['Player'], axis=1)
+    
+    salary_low_check = (overall_file - (salary_file*10))
+    salary_mid_check = (overall_file - (salary_file*11))
+    salary_high_check = (overall_file - (salary_file*12))
+    gpp_check = (overall_file - ((salary_file*10)+10))
+
+    players_only['Average_Rank'] = players_only.mean(axis=1)
+    players_only['Top_finish'] = players_only[players_only == 1].count(axis=1)/total_sims
+    players_only['Top_3_finish'] = players_only[players_only <= 3].count(axis=1)/total_sims
+    players_only['Top_5_finish'] = players_only[players_only <= 5].count(axis=1)/total_sims
+    players_only['100+%'] = overall_file[overall_file >= 100].count(axis=1)/float(total_sims)
+    players_only['10x%'] = salary_low_check[salary_low_check >= 1].count(axis=1)/float(total_sims)
+    players_only['11x%'] = salary_mid_check[salary_mid_check >= 1].count(axis=1)/float(total_sims)
+    players_only['12x%'] = salary_high_check[salary_high_check >= 1].count(axis=1)/float(total_sims)
+    players_only['GPP%'] = gpp_check[gpp_check >= 1].count(axis=1)/float(total_sims)
+
+    players_only['Player'] = hold_file[['Player']]
+
+    final_outcomes = players_only[['Player', 'Top_finish', 'Top_3_finish', 'Top_5_finish', '100+%', '10x%', '11x%', '12x%', 'GPP%']]
+
+    final_Proj = pd_merge(hold_file, final_outcomes, on="Player")
+    final_Proj = final_Proj[['Player', 'Position', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_3_finish', 'Top_5_finish', '100+%', '10x%', '11x%', '12x%', 'GPP%']]
+    
+    final_Proj['Own'] = final_Proj['Player'].map(fighter_dicts['Own'])
+    final_Proj = final_Proj.replace('', np_nan)
+    final_Proj = final_Proj.dropna(subset=['Own'])
+    final_Proj['Own'] = final_Proj['Own'].astype('float')
+    final_Proj['Small_Own'] = final_Proj['Own'] + (.2 * (final_Proj['Own'] - final_Proj['Own'].mean()))
+    own_norm = 600 / final_Proj['Small_Own'].sum()
+    final_Proj['Small_Own'] = final_Proj['Small_Own'] * own_norm
+    final_Proj['Large_Own'] = final_Proj['Own'] - (.2 * (final_Proj['Own'] - final_Proj['Own'].mean()))
+    own_norm = 600 / final_Proj['Large_Own'].sum()
+    final_Proj['Large_Own'] = final_Proj['Large_Own'] * own_norm
+    final_Proj['Cash_Own'] = final_Proj['Own'] + (.33 * (final_Proj['Own'] - final_Proj['Own'].mean()))
+    own_norm = 600 / final_Proj['Cash_Own'].sum()
+    final_Proj['Cash_Own'] = final_Proj['Cash_Own'] * own_norm
+    final_Proj['Own'] = final_Proj['Own'].clip(upper=85, lower=0)
+    final_Proj['Small_Own'] = final_Proj['Small_Own'].clip(upper=95, lower=.01)
+    final_Proj['Large_Own'] = final_Proj['Large_Own'].clip(upper=80, lower=.1)
+    final_Proj['Cash_Own'] = final_Proj['Cash_Own'].clip(upper=99, lower=0)
+    final_Proj['CPT_Own'] = final_Proj['Own'] / 6
+    final_Proj.insert(loc=1, column='Opp', value=final_Proj['Player'].map(fighter_dicts['Opp']))
+    final_Proj['player_id'] = final_Proj['Player'].map(fighter_dicts['player_id'])
+    final_Proj = final_Proj.sort_values(by='Median', ascending=False)
+
+    return final_Proj.copy()
+
+def DK_seed_frame(working_proj: DataFrame, fighter_dicts: dict, client: MongoClient):
+
+    db = client['MMA_Database']
+
+    source_frame = working_proj.copy()
+    optimal_lineups = []
+
+    Overall_Proj = source_frame.copy()
+
+    Overall_Proj['salary_Value'] = (Overall_Proj['Salary'] / 1000) / Overall_Proj['Median']
+    Overall_Proj['proj_Value'] = Overall_Proj['Median'].rank(pct = True)
+    Overall_Proj['own_Value'] = Overall_Proj['Own'].rank(pct = True)
+    Overall_Proj['sort_Value'] = Overall_Proj[['own_Value', 'salary_Value']].mean(axis=1)
+    Overall_Proj = Overall_Proj.sort_values(by='own_Value', ascending=False)
+    Overall_Proj.rename(columns={"Player": "Name"}, inplace = True)
+    Overall_Proj = Overall_Proj.dropna()
+    Overall_Proj = Overall_Proj.reset_index(drop=True)
+
+    players_median = Overall_Proj.drop_duplicates(subset ='Name', keep ='first')
+    
+    players_median['Var'] = players_median.index
+
+    # Add slate identifier and collect data for JSON export
+    players_median_copy = players_median.copy()
+    players_median_copy['slate'] = 'Main Slate'
+
+    # Create maps for Go processing
+    players_name_map = {str(int(idx)): str(name) for idx, name in players_median_copy.set_index('Var')['Name'].items()}
+    players_salary_map = {str(int(idx)): int(salary) for idx, salary in players_median_copy.set_index('Var')['Salary'].items()}
+    players_projection_map = {str(int(idx)): float(proj) for idx, proj in players_median_copy.set_index('Var')['Median'].items()}
+    players_ownership_map = {str(int(idx)): float(own) for idx, own in players_median_copy.set_index('Var')['Own'].items()}
+    players_opp_map = {str(int(idx)): str(opp) for idx, opp in players_median_copy.set_index('Var')['Opp'].items()}
+    
+    # Create output data structure for Go
+    output_data = {
+        "players_median": {
+            "players": [],
+            "maps": {
+                "name_map": players_name_map,
+                "salary_map": players_salary_map,
+                "projection_map": players_projection_map,
+                "ownership_map": players_ownership_map,
+                "opp_map": players_opp_map
+            }
+        }
+    }
+    
+    # Convert players to Go struct format
+    for idx, row in players_median_copy.iterrows():
+        player = {
+            "id": int(row['Var']),
+            "name": str(row['Name']),
+            "position": str(row['Position']),
+            "opp": str(row['Opp']),
+            "salary": int(row['Salary']),
+            "projection": float(row['Median']),
+            "ownership": float(row['Own']),
+            "salary_value": float(row['salary_Value']),
+            "proj_value": float(row['proj_Value']),
+            "own_value": float(row['own_Value']),
+            "sort_value": float(row['sort_Value']),
+            "slate": 'Main Slate'
+        }
+        output_data["players_median"]["players"].append(player)
+    
+    # Write JSON data for Go processing
+    with open(f'mma_go/player_data.json', 'w') as f:
+        json.dump(output_data, f)
+
+    collection = db['DK_MMA_name_map']
+
+    master_name_map = pd_Series(players_median.Name.values,index=players_median.Var).to_dict()
+    master_name_index = pd_Series(players_median.Var.values, index=players_median.Name).to_dict()
+
+    position_requirements = {
+        'FLEX': 6
+    }
+
+    salary_cap = 50000
+    max_team_players = 6
+
+    required_positions = ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6']
+
+    collection.drop()
+    try:
+        # Convert dictionary to format suitable for MongoDB
+        mongo_docs = [{"key": k, "value": v} for k, v in master_name_map.items()]
+        collection.insert_many(mongo_docs, ordered=False)
+    except Exception as e:
+        print(f"Error inserting name map: {e}")
+        time_sleep(1)
+
+    optimals = init_mma_optimals(working_proj, salary_cap, 1000)
+    formatted_optimals = format_mma_optimals(optimals, working_proj)
+
+    for col in required_positions:
+        if col in formatted_optimals.columns:
+            formatted_optimals[col] = formatted_optimals[col].map(master_name_index).fillna(formatted_optimals[col])
+
+    formatted_optimals['proj'] = formatted_optimals['proj'].astype(float)
+
+    # Convert this slate's optimals to JSON format and add slate info
+    for idx, row in formatted_optimals.iterrows():
+        optimal_lineup = {
+            "slate": 'Main Slate',  # Add slate identifier
+            "salary": int(row['salary']),
+            "projection": float(row['proj']),
+            "ownership": float(row['Own']),
+            "players": [int(row['FLEX1']), int(row['FLEX2']), int(row['FLEX3']), 
+                    int(row['FLEX4']), int(row['FLEX5']), int(row['FLEX6'])]
+        }
+        optimal_lineups.append(optimal_lineup)
+
+    print(f"Generated {len(formatted_optimals)} optimal lineups for slate Main Slate")
+
+    with open(f'mma_go/optimal_lineups.json', 'w') as f:
+        json.dump(optimal_lineups, f)
+
+    run_go_classic_lineup_generator("DK", "MMA")
+    print("MMA lineup generation for DK completed successfully!")

src/streamlit_app.py

@@ -75,12 +75,13 @@ sport_icons = {
     "NFL": "🏈",
     "NBA": "🏀",
     "MLB": "⚾",
-    "PGA": "⛳"
+    "PGA": "⛳",
+    "MMA": "🥊"
 }
 
 selected_tab = st.segmented_control(
     "Select Tab",
-    options=["NHL Updates", "NBA Updates", 'MLB Updates', 'NFL Updates', 'PGA Updates'],
+    options=["NHL Updates", "NBA Updates", 'MLB Updates', 'NFL Updates', 'PGA Updates', 'MMA Updates'],
     selection_mode='single',
     default='NHL Updates',
     width='stretch',
@@ -552,3 +553,88 @@ elif selected_tab == "MLB Updates":
     st.header("⚾ MLB Model Updates")
     st.info("MLB updates coming soon!")
     st.write("MLB functionality will be added in a future update.")
+
+# ============================================================================
+# MMA UPDATES TAB
+# ============================================================================
+elif selected_tab == "MMA Updates":
+    from sports.mma_functions import *
+    
+    st.header("🥊 MMA Model Updates")
+    
+    # Column definitions
+    str_columns = ['Fighter1', 'Opp']
+    float_columns = ['Avg Win', 'Avg Loss', 'Avg Draw', 'ToWin', 'To Win By KO/TKO/DQ', 'To Win By Submission', 'To Win By Decision', 'Draw', 'Round 1', 'Round 2', 'Round 3', 'Round 4', 'Round 5',
+                    'By Decision', 'Average', 'OddsProj', 'SalaryProj', 'DeviationVar', 'FloorProj', 'AggProj', 'CeilingProj', 'OwnRaw', 'OwnAdj', 'Own']
+    int_columns = ['Salary', 'player_id']
+    
+    if st.button("🔄 Run MMA Updates", type="primary", use_container_width=True):
+        with st.spinner("Updating MMA models..."):
+            st.write("Loading MMA data from Google Sheets...")
+            try:
+                sh = gc.open_by_url(MMA_Master_hold)
+                worksheet = sh.worksheet('Export')
+                projects_raw = DataFrame(worksheet.get_values())
+            except:
+                sh = gc2.open_by_url(MMA_Master_hold)
+                worksheet = sh.worksheet('Export')
+                projects_raw = DataFrame(worksheet.get_values())
+            
+            projects_raw.columns = projects_raw.iloc[0]
+            projects_raw = projects_raw[1:]
+            projects_raw = projects_raw.reset_index(drop=True)
+            projects_raw = projects_raw.replace('', np_nan)
+            projects_raw = projects_raw.dropna(subset=['Salary'])
+            projects_raw['Position'] = 'FLEX'
+            
+            st.write("MMA data loaded successfully!")
+            st.table(projects_raw.head(10))
+            
+            for col in str_columns:
+                projects_raw[col] = projects_raw[col].astype(str)
+            for col in float_columns:
+                projects_raw[col] = projects_raw[col].astype(float)
+            for col in int_columns:
+                projects_raw[col] = projects_raw[col].astype(int)
+            
+            fighter_dicts = {}
+            
+            for col in float_columns:
+                fighter_dicts[col] = dict(zip(projects_raw['Fighter1'], projects_raw[col]))
+            fighter_dicts['Opp'] = dict(zip(projects_raw['Fighter1'], projects_raw['Opp']))
+            fighter_dicts['player_id'] = dict(zip(projects_raw['Fighter1'], projects_raw['player_id']))
+            
+            working_proj = projects_raw[['Fighter1', 'Position', 'Opp', 'Salary', 'FloorProj', 'AggProj', 'CeilingProj', 'Own']]
+            working_proj = working_proj.rename(columns={"Fighter1": "Player", "FloorProj": "Floor", "AggProj": "Median", "CeilingProj": "Ceiling", "Own": "Own"})
+            
+            st.write("Generating MMA ROO structure...")
+            Overall_Proj = player_level_roo(working_proj, fighter_dicts, client)
+            st.write("MMA Draftkings ROO structure refreshed")
+            st.table(Overall_Proj.head(10))
+            
+            try:
+                discord.post(content="MMA Draftkings ROO structure refreshed")
+            except:
+                pass
+            
+            # Upload to database
+            collection = mma_db['Player_Level_ROO']
+            Overall_Proj_copy = Overall_Proj.reset_index(drop=True)
+            chunk_size = 100000
+            collection.drop()
+            for i in range(0, len(Overall_Proj_copy), chunk_size):
+                for _ in range(5):
+                    try:
+                        df_chunk = Overall_Proj_copy.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)
+            
+            st.write("Generating MMA seed frames...")
+            DK_seed_frame(Overall_Proj, fighter_dicts, client)
+            st.write("MMA Draftkings Seed Frames refreshed")
+        
+        st.success("✅ MMA updates completed successfully!")
+        st.balloons()