src/sports/nba_functions.py

# Numpy
from numpy import where as np_where
from numpy import random as np_random
from numpy import nan as np_nan
from numpy import array as np_array
from numpy import zeros as np_zeros
from numpy import clip as np_clip

# 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 errors as pd_errors
from pandas import merge, to_numeric
from pandas import options as poptions
from pandas import set_option as pd_set_option

# Time
import time
from datetime import datetime, timedelta
from time import sleep as time_sleep
from pytz import timezone as tz
from datetime import date

# Misc
from ortools.linear_solver import pywraplp
import re
import os
import subprocess
poptions.mode.chained_assignment = None  # default='warn'
pd_set_option('future.no_silent_downcasting', True)
from warnings import simplefilter
simplefilter(action="ignore", category=pd_errors.PerformanceWarning)
from pymongo.mongo_client import MongoClient
from pymongo.server_api import ServerApi

# GO
import json
import subprocess
from random import choice

import streamlit as st
from database import *

# Ownership Models
from sports.NBA_own_regress import xgb_model, lgb_model, knn_model

#Set Timezone to Eastern time
ny = tz("America/New_York")
fmt = '%B %d, %Y %H:%M:%S'
timestart = datetime.now(ny)

# Try to connect with error handling
try:
    # First attempt: Using SRV format
    client = MongoClient(uri, server_api=ServerApi('1'))
    
    # Test the connection
    client.admin.command('ping')
    st.write("Pinged your deployment. You successfully connected to MongoDB!")
    
except Exception as e:
    st.write(f"SRV connection failed: {e}")
    try:
        # Second attempt: Try direct connection format
        direct_uri = uri.replace('mongodb+srv://', 'mongodb://')
        client = MongoClient(direct_uri, server_api=ServerApi('1'))
        
        # Test the connection
        client.admin.command('ping')
        st.write("Pinged your deployment using direct connection!")
        
    except Exception as e:
        st.write(f"Direct connection failed: {e}")
        # If both attempts fail, raise the error
        raise

sh = gc.open_by_url(NBA_Master_hold)

try:
    sh = gc.open_by_url(NBA_Master_hold)
    worksheet = sh.worksheet('Site_Info')
    slate_info: DataFrame = DataFrame(worksheet.get_all_records())
    slate_options: list[str] = ['Main Slate', 'Secondary Slate', 'Late Slate']
except:
    sh = gc2.open_by_url(NBA_Master_hold)
    worksheet = sh.worksheet('Site_Info')
    slate_info: DataFrame = DataFrame(worksheet.get_all_records())
    slate_options: list[str] = ['Main Slate', 'Secondary Slate', 'Late Slate']

time.sleep(1)
worksheet = sh.worksheet('SD_Projections')
dk_sd_projections = DataFrame(worksheet.get_all_records())
dk_sd_projections = dk_sd_projections.replace('#N/A', np_nan)
dk_sd_projections = dk_sd_projections.dropna(subset=['Minutes'])

time.sleep(1)
worksheet = sh.worksheet('FD_SD_Projections')
fd_sd_projections = DataFrame(worksheet.get_all_records())
fd_sd_projections = fd_sd_projections.replace('#N/A', np_nan)
fd_sd_projections = fd_sd_projections.dropna(subset=['Minutes'])

dk_showdown_options = []
fd_showdown_options = []

for slates in dk_sd_projections['Slate'].unique():
        dk_showdown_options.append(slates)
for slates in fd_sd_projections['Slate'].unique():
        fd_showdown_options.append(slates)

nan_value: float = float("NaN")
sim_teams: list[str] = []
cut_slate: int = 0
model_version: int = 1

dk_roo_player_hold: DataFrame = DataFrame(columns=['Player', 'Minutes Proj', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish',
                                    '20+%', '4x%', '5x%', '6x%', 'GPP%', 'Own', 'Small_Own', 'Large_Own', 'Cash_Own', 'CPT_Own', 'LevX', 'ValX', 'player_id', 'site', 'version', 'slate'])
fd_roo_player_hold: DataFrame = DataFrame(columns=['Player', 'Minutes Proj', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish',
                                    '20+%', '4x%', '5x%', '6x%', 'GPP%', 'Own', 'Small_Own', 'Large_Own', 'Cash_Own', 'CPT_Own', 'LevX', 'ValX', 'player_id', 'site', 'version', 'slate'])
dk_sd_player_hold: DataFrame = DataFrame(columns=['Player', 'Minutes Proj', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish',
                                    '20+%', '4x%', '5x%', '6x%', 'GPP%', 'Own', 'Small_Own', 'Large_Own', 'Cash_Own', 'CPT_Own', 'LevX', 'ValX', 'player_id', 'site', 'version', 'slate'])
fd_sd_player_hold: DataFrame = DataFrame(columns=['Player', 'Minutes Proj', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish',
                                    '20+%', '4x%', '5x%', '6x%', 'GPP%', 'Own', 'Small_Own', 'Large_Own', 'Cash_Own', 'CPT_Own', 'LevX', 'ValX', 'player_id', 'site', 'version', 'slate'])

############----------FUNCTION FOR SHOWDOWN SEED FRAME PROCESS WITH GO PACKAGE----------############
def run_go_showdown_lineup_generator(site="DK", sport="NBA"):
    """Run the Go lineup generator after Python data processing"""
    try:
        st.write(f"Starting Go {sport} Showdown lineup generation...")
        start_time = time.time()
        
        # Determine the path to the Go binary
        current_dir = os.path.dirname(os.path.abspath(__file__))
        project_root = os.path.dirname(os.path.dirname(current_dir))
        
        go_binary = os.path.join(project_root, "showdown_go", "showdown_seed_frames")
        
        st.write(f"Looking for binary at: {go_binary}")
        
        # Run the Go executable
        result = subprocess.run(
            [go_binary, site, sport],
            capture_output=True,
            text=True,
            check=True,
            cwd=project_root
        )
        
        end_time = time.time()
        st.write(f"Go {sport} Showdown processing completed in {end_time - start_time:.2f} seconds")
        
        if result.stdout:
            st.write("Go output:", result.stdout)
        if result.stderr:
            st.write("Go warnings:", result.stderr)
            
        return True
        
    except subprocess.CalledProcessError as e:
        st.write(f"Go process failed with exit code {e.returncode}")
        if e.stdout:
            st.write("Stdout:", e.stdout)
        if e.stderr:
            st.write("Error output:", e.stderr)
        return False
    except FileNotFoundError as e:
        st.write(f"Error: Go binary not found at {go_binary}")
        st.write(f"FileNotFoundError: {e}")
        st.write(f"Current working directory: {os.getcwd()}")
        st.write(f"Project root: {project_root}")
        return False

def run_go_classic_lineup_generator(site="DK", sport="NBA"):
    """Run the Go lineup generator after Python data processing"""
    try:
        st.write(f"Starting Go {sport} lineup generation...")
        start_time = time.time()

        # Determine the path to the Go binary
        # __file__ is at /app/src/sports/nba_functions.py
        # Binaries are at /app/dk_nba_go/ and /app/fd_nba_go/ (per Dockerfile)
        current_dir = os.path.dirname(os.path.abspath(__file__))  # /app/src/sports/
        project_root = os.path.dirname(os.path.dirname(current_dir))  # /app/
        
        if site == "DK":
            go_binary = os.path.join(project_root, "dk_nba_go", "NBA_seed_frames")
        else:
            go_binary = os.path.join(project_root, "fd_nba_go", "NBA_seed_frames")
        
        st.write(f"Looking for binary at: {go_binary}")
        
        # Run the Go executable
        result = subprocess.run(
            [go_binary, site, sport],
            capture_output=True,
            text=True,
            check=True,
            cwd=project_root  # Run from project root
        )
        
        end_time = time.time()
        st.write(f"Go {sport} processing completed in {end_time - start_time:.2f} seconds")
        
        if result.stdout:
            st.write("Go output:", result.stdout)
        if result.stderr:
            st.write("Go warnings:", result.stderr)
            
        return True
        
    except subprocess.CalledProcessError as e:
        st.write(f"Go process failed with exit code {e.returncode}")
        if e.stdout:
            st.write("Stdout:", e.stdout)
        if e.stderr:
            st.write("Error output:", e.stderr)
        return False
    except FileNotFoundError as e:
        st.write(f"Error: Go binary not found at {go_binary}")
        st.write(f"FileNotFoundError: {e}")
        st.write(f"Current working directory: {os.getcwd()}")
        st.write(f"Project root: {project_root}")
        return False
    except Exception as e:
        st.write(f"Unexpected error: {e}")
        return False

############----------FUNCTION FOR LINEUP OPTIMIZATION AND COMBO GENERATION----------############
def init_team_results(model_source: DataFrame, position_reqs: dict, salary_cap: int, max_stack_players: int, teams_to_optimize: list, combos: int):
    df = model_source.copy()
    
    # Parse eligible positions for each player
    df['eligible_positions'] = df['Position'].apply(lambda x: x.split('/'))

    # Store results for all teams
    all_team_results = []

    st.write(position_reqs)
    st.write(f"Optimizing {len(teams_to_optimize)} teams")
    
    for target_team in teams_to_optimize:
        filtered_df = df.copy()
        
        # Create a new solver for each team
        solver = pywraplp.Solver.CreateSolver('SCIP')
        if not solver:
            raise Exception("Could not create solver.")

        # Variables: x[i, pos] = 1 if player i is used at position pos
        x = {}
        for i, row in filtered_df.iterrows():
            for pos in row['eligible_positions']:
                x[(i, pos)] = solver.BoolVar(f'x_{i}_{pos}')

        # Create variables for composite positions (G, F)
        if 'G' in position_reqs:
            for i, row in filtered_df.iterrows():
                if any(p in row['eligible_positions'] for p in ['PG', 'SG']):
                    x[(i, 'G')] = solver.BoolVar(f'x_{i}_G')

        if 'F' in position_reqs:
            for i, row in filtered_df.iterrows():
                if any(p in row['eligible_positions'] for p in ['SF', 'PF']):
                    x[(i, 'F')] = solver.BoolVar(f'x_{i}_F')
        
        # Special FLEX variable for FanDuel
        util_x = {}
        if 'FLEX' in position_reqs:
            for i, row in filtered_df.iterrows():
                util_positions = ['PG', 'SG', 'SF', 'PF', 'C']
                if any(pos in row['eligible_positions'] for pos in util_positions):
                    util_x[i] = solver.BoolVar(f'util_{i}')

        # Each player can only be used once (including FLEX)
        for i in filtered_df.index:
            constraint_terms = [x[(i, pos)] for pos in filtered_df.loc[i, 'eligible_positions']]
    
            if 'FLEX' in position_reqs and i in util_x:
                constraint_terms.append(util_x[i])
            if 'G' in position_reqs and (i, 'G') in x:
                constraint_terms.append(x[(i, 'G')])
            if 'F' in position_reqs and (i, 'F') in x:
                constraint_terms.append(x[(i, 'F')])
            
            solver.Add(solver.Sum(constraint_terms) <= 1)

        # Standard DraftKings requirements
        for pos, req in position_reqs.items():
            if pos == 'G':
                # G position can accept PG or SG
                pos_players = [i for i in filtered_df.index 
                            if any(p in filtered_df.loc[i, 'eligible_positions'] for p in ['PG', 'SG'])]
            elif pos == 'F':
                # F position can accept SF or PF
                pos_players = [i for i in filtered_df.index 
                            if any(p in filtered_df.loc[i, 'eligible_positions'] for p in ['SF', 'PF'])]
            elif pos == 'FLEX':
                # FLEX can accept any position
                pos_players = [i for i in filtered_df.index 
                            if any(p in filtered_df.loc[i, 'eligible_positions'] for p in ['PG', 'SG', 'SF', 'PF', 'C'])]
            else:
                # Regular positions (PG, SG, SF, PF, C) - exact match
                pos_players = [i for i in filtered_df.index if pos in filtered_df.loc[i, 'eligible_positions']]
            
            if pos_players:
                if pos == 'FLEX':
                    # FLEX uses util_x dictionary
                    solver.Add(solver.Sum([util_x[i] for i in pos_players if i in util_x]) == req)
                else:
                    # Regular positions, G, and F use x dictionary
                    solver.Add(solver.Sum([x[(i, pos)] for i in pos_players]) == req)

        # Salary cap (include FLEX players)
        salary_terms = []
        for i in filtered_df.index:
            for pos in filtered_df.loc[i, 'eligible_positions']:
                salary_terms.append(x[(i, pos)] * filtered_df.loc[i, 'Salary'])
            
            if 'FLEX' in position_reqs and i in util_x:
                salary_terms.append(util_x[i] * filtered_df.loc[i, 'Salary'])
            if 'G' in position_reqs and (i, 'G') in x:
                salary_terms.append(x[(i, 'G')] * filtered_df.loc[i, 'Salary'])
            if 'F' in position_reqs and (i, 'F') in x:
                salary_terms.append(x[(i, 'F')] * filtered_df.loc[i, 'Salary'])

        solver.Add(solver.Sum(salary_terms) <= salary_cap)

        # Max hitters per team (exclude P/SP positions, include UTIL)
        teams = filtered_df['Team'].unique()
        for team in teams:
            team_constraint_terms = []
            
            for i in filtered_df.index:
                if filtered_df.loc[i, 'Team'] == team:
                    for pos in filtered_df.loc[i, 'eligible_positions']:
                        team_constraint_terms.append(x[(i, pos)])
                    
                    if 'FLEX' in position_reqs and i in util_x:
                        team_constraint_terms.append(util_x[i])
                    if 'G' in position_reqs and (i, 'G') in x:
                        team_constraint_terms.append(x[(i, 'G')])
                    if 'F' in position_reqs and (i, 'F') in x:
                        team_constraint_terms.append(x[(i, 'F')])
            
            solver.Add(solver.Sum(team_constraint_terms) <= max_stack_players)

        # Total players constraint (include FLEX, G, F)
        total_players = solver.Sum(x[(i, pos)] for i in filtered_df.index for pos in filtered_df.loc[i, 'eligible_positions'])

        if 'FLEX' in position_reqs:
            total_players += solver.Sum([util_x[i] for i in util_x.keys()])
        if 'G' in position_reqs:
            total_players += solver.Sum([x[(i, 'G')] for i in filtered_df.index if (i, 'G') in x])
        if 'F' in position_reqs:
            total_players += solver.Sum([x[(i, 'F')] for i in filtered_df.index if (i, 'F') in x])

        solver.Add(total_players == sum(position_reqs.values()))

        # Find the highest median player from the target team
        exclude_positions = []
        target_team_hitters = filtered_df[filtered_df['Team'] == target_team]
        
        if not target_team_hitters.empty:
            # Get the highest median player from the target team
            highest_median_player = target_team_hitters.loc[target_team_hitters['Median'].idxmax()]
            highest_median_idx = highest_median_player.name
            
            # Force the highest median player to be included in the lineup
            # Find which position(s) this player is eligible for
            eligible_positions = highest_median_player['eligible_positions']
            
            # Create constraint to force this player to be used in at least one eligible position
            highest_median_constraint = solver.Sum([
                x[(highest_median_idx, pos)] for pos in eligible_positions
            ])
            
            # Add FLEX, G, F constraint if applicable
            if 'G' in position_reqs and (highest_median_idx, 'G') in x:
                highest_median_constraint += x[(highest_median_idx, 'G')]
            if 'F' in position_reqs and (highest_median_idx, 'F') in x:
                highest_median_constraint += x[(highest_median_idx, 'F')]
            if 'FLEX' in position_reqs and highest_median_idx in util_x:
                highest_median_constraint += util_x[highest_median_idx]
            
            solver.Add(highest_median_constraint >= 1)

        # Force exactly max_hitters players from target team
        target_team_constraint_terms = []

        for i in filtered_df.index:
            if filtered_df.loc[i, 'Team'] == target_team:
                for pos in filtered_df.loc[i, 'eligible_positions']:
                    target_team_constraint_terms.append(x[(i, pos)])
                
                if 'FLEX' in position_reqs and i in util_x:
                    target_team_constraint_terms.append(util_x[i])
                if 'G' in position_reqs and (i, 'G') in x:
                    target_team_constraint_terms.append(x[(i, 'G')])
                if 'F' in position_reqs and (i, 'F') in x:
                    target_team_constraint_terms.append(x[(i, 'F')])

        solver.Add(solver.Sum(target_team_constraint_terms) == max_stack_players)

        # Objective: maximize total median (include FLEX)
        objective_terms = []
        for i in filtered_df.index:
            for pos in filtered_df.loc[i, 'eligible_positions']:
                objective_terms.append(x[(i, pos)] * filtered_df.loc[i, 'Median'])
            
            if 'FLEX' in position_reqs and i in util_x:
                objective_terms.append(util_x[i] * filtered_df.loc[i, 'Median'])
            if 'G' in position_reqs and (i, 'G') in x:
                objective_terms.append(x[(i, 'G')] * filtered_df.loc[i, 'Median'])
            if 'F' in position_reqs and (i, 'F') in x:
                objective_terms.append(x[(i, 'F')] * filtered_df.loc[i, 'Median'])

        solver.Maximize(solver.Sum(objective_terms))

        status = solver.Solve()

        if status == pywraplp.Solver.OPTIMAL or status == pywraplp.Solver.FEASIBLE:
            selected = [
                (i, pos)
                for (i, pos), var in x.items()
                if var.solution_value() > 0.5
            ]
            
            # Add FLEX players to the selected list
            if 'FLEX' in position_reqs:
                util_selected = [
                    (i, 'FLEX')
                    for i, var in util_x.items()
                    if var.solution_value() > 0.5
                ]
                selected.extend(util_selected)
            
            lineup = DataFrame([
                {**filtered_df.loc[i].to_dict(), 'assigned_position': pos}
                for (i, pos) in selected
            ])

            # Assign unique position labels for duplicate positions (e.g., OF1, OF2, OF3, SP1, SP2)
            position_counts = {}
            position_labels = []
            for pos in lineup['assigned_position']:
                if pos not in position_counts:
                    position_counts[pos] = 1
                else:
                    position_counts[pos] += 1
                label = f"{pos}{position_counts[pos]}" if position_counts[pos] > 1 else pos
                position_labels.append(label)
            lineup['position_label'] = position_labels

            # Build the single-row dictionary
            row_dict = {row['position_label']: row['Name'] 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()
            row_dict['Target_Team'] = target_team

            # Convert to DataFrame
            result_df = DataFrame([row_dict])

            st.write(result_df)
            
            # Generate variations for this team
            result_rows = [row_dict.copy()]

            st.write(result_rows)

            st.write(f"Generating {combos} variations for {target_team}")
            

            for _ in range(combos):
                # Copy the current optimal lineup row
                new_row = row_dict.copy()
                # Get all position labels (e.g., 'OF1', 'SP2', etc.)
                pos_labels = [k for k in new_row.keys() if k not in ['Total_Salary', 'Total_Median', 'Target_Team', 'Own']]
                
                # Track which positions have been swapped in this iteration
                swapped_positions = []
                
                # Determine number of positions to swap (1 or 2)
                num_swaps = choice([1, 2])
                
                for swap_num in range(num_swaps):
                    # Get available positions (exclude already swapped positions)
                    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)

                    # Add the position to our swapped tracking list
                    swapped_positions.append(pos_to_swap)

                    # ... existing code for finding replacement player ...
                    # Find the assigned position (e.g., 'OF', 'SP', etc.)
                    match = re.match(r'[A-Z]+', pos_to_swap.strip())
                    if match:
                        assigned_pos = match.group()
                    else:
                        continue
                    
                    # Handle special positions
                    if assigned_pos == 'FLEX':
                        util_positions = ['PG', 'SG', 'SF', 'PF', 'C']
                        eligible = filtered_df[
                            filtered_df['eligible_positions'].apply(lambda pos_list: any(pos in pos_list for pos in util_positions)) &
                            (~filtered_df['Name'].isin(new_row.values()))
                        ]
                    elif assigned_pos == 'G':
                        # G position can accept PG or SG
                        eligible = filtered_df[
                            filtered_df['eligible_positions'].apply(lambda pos_list: any(pos in pos_list for pos in ['PG', 'SG'])) &
                            (~filtered_df['Name'].isin(new_row.values()))
                        ]
                    elif assigned_pos == 'F':
                        # F position can accept SF or PF
                        eligible = filtered_df[
                            filtered_df['eligible_positions'].apply(lambda pos_list: any(pos in pos_list for pos in ['SF', 'PF'])) &
                            (~filtered_df['Name'].isin(new_row.values()))
                        ]
                    else:
                        # Regular position - must match exactly
                        eligible = filtered_df[
                            filtered_df['eligible_positions'].apply(lambda pos_list: assigned_pos in pos_list) &
                            (~filtered_df['Name'].isin(new_row.values()))
                        ]
                    
                    if eligible.empty:
                        continue
                    # Randomly select a replacement
                    replacement = eligible.sample(1).iloc[0]
                    new_row[pos_to_swap] = replacement['Name']

                # Recalculate totals
                # Get the DataFrame rows for all players in the new lineup
                player_rows = filtered_df[filtered_df['Name'].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 the final DataFrame for this team
            final_df = DataFrame(result_rows)
            # Get all position columns (exclude totals)
            pos_labels = [col for col in final_df.columns if col not in ['Total_Salary', 'Total_Median', 'Target_Team', 'Own']]

            # Create a mapping from player name to team for fast lookup
            player_team_map = filtered_df.set_index('Name')['Team'].to_dict()

            # Count target team players in each row
            def count_target_team(row):
                return sum(1 for pos in pos_labels if player_team_map.get(row[pos], None) == target_team)

            final_df['Stack'] = final_df.apply(count_target_team, axis=1)
            final_df = final_df.drop_duplicates(subset=['Total_Median', 'Total_Salary'])
            final_df = final_df[final_df['Total_Salary'] <= salary_cap]
            final_df = final_df[final_df['Stack'] <= max_stack_players]
            final_df = final_df.sort_values(by='Total_Median', ascending=False)
            
            # Add to all results
            all_team_results.append(final_df)

    return all_team_results

############----------FUNCTION FOR FORMATTING GENERATED COMBOS INTO SEED FRAMES----------############
def format_optimals(all_team_results: list, model_source: DataFrame, required_positions: list):
    roo_frame = model_source.copy()

    combined_df = pd_concat(all_team_results, ignore_index=True)
    combined_df = combined_df.sort_values(by='Total_Median', ascending=False)
    
    # Create the final DataFrame with the specified column format
    final_formatted_df = DataFrame()
    
    # Get all position columns (exclude totals and other metadata)
    pos_columns = [col for col in combined_df.columns if col not in ['Total_Salary', 'Total_Median', 'Target_Team', 'Stack', 'Own']]
    
    # Create a mapping from player name to team for fast lookup
    player_team_map = roo_frame.set_index('Name')['Team'].to_dict()
    player_salary_map = roo_frame.set_index('Name')['Salary'].to_dict()
    player_median_map = roo_frame.set_index('Name')['Median'].to_dict()
    player_own_map = roo_frame.set_index('Name')['Own'].to_dict()
    
    # 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']
        new_row['Team'] = row['Target_Team']
        new_row['Team_count'] = row['Stack']
        
        # Calculate Secondary team (second most frequent team)
        team_counts = {}
        for pos in pos_columns:
            player = row[pos]
            if player in player_team_map:
                team = player_team_map[player]
                team_counts[team] = team_counts.get(team, 0) + 1
        
        # Find the second most frequent team (excluding the target team)
        sorted_teams = sorted(team_counts.items(), key=lambda x: x[1], reverse=True)
        secondary_team = 'None'
        secondary_count = 0
        
        for team, count in sorted_teams:
            if team != row['Target_Team']:
                secondary_team = team
                secondary_count = count
                break
        
        new_row['Secondary'] = secondary_team
        new_row['Secondary_count'] = secondary_count
        
        # Add position columns
        for pos in pos_columns:
            new_row[pos] = row[pos]
        
        formatted_rows.append(new_row)
    
    final_formatted_df = DataFrame(formatted_rows)
    
    # Ensure all required position columns exist (in case some are missing)
    for pos in required_positions:
        if pos not in final_formatted_df.columns:
            final_formatted_df[pos] = ''
    
    # Reorder columns to match the specified format
    column_order = ['salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own'] + required_positions
    final_formatted_df = final_formatted_df[column_order]

    return final_formatted_df

def trending_script():
    currentdt = datetime.now()
    finaldt = (currentdt.strftime("%Y-%m-%d"))
    past_three = date.today()-timedelta(days=3)
    past_three = (past_three.strftime("%Y-%m-%d"))
    past_week = date.today()-timedelta(days=7)
    past_week = (past_week.strftime("%Y-%m-%d"))
    past_month = date.today()-timedelta(days=90)
    past_month = (past_month.strftime("%Y-%m-%d"))

    start_frame = DataFrame()
    boost_player = []
    
    try:
        sh = gc.open_by_url('https://docs.google.com/spreadsheets/d/1Yq0vGriWK-bS79e-bD6_u9pqrYE6Yrlbb_wEkmH-ot0/edit#gid=1459432770')
        worksheet = sh.worksheet('Gamelog')
        player_data = DataFrame(worksheet.get_all_records())
    except:
        time_sleep(3)
        sh = gc2.open_by_url('https://docs.google.com/spreadsheets/d/1Yq0vGriWK-bS79e-bD6_u9pqrYE6Yrlbb_wEkmH-ot0/edit#gid=1459432770')
        worksheet = sh.worksheet('Gamelog')
        player_data = DataFrame(worksheet.get_all_records())
    player_data = player_data.sort_values(by='GAME_DATE', ascending=False)
    team_list = player_data['TEAM_NAME'].unique().tolist()
    player_data['FPPM'] = player_data['FPPM'].replace('', 0)
    player_data['FPPM'] = player_data['FPPM'].astype(float)

    L3_frame = DataFrame(columns=player_data.columns)
    L5_frame = DataFrame(columns=player_data.columns)
    L10_frame = DataFrame(columns=player_data.columns)
    season_frame = DataFrame(columns=player_data.columns)

    for teams in team_list:
        team_data = player_data[(player_data['TEAM_NAME'] == teams) & (player_data['SEASON_ID'] == 22025)]
        L3_games_list = team_data['GAME_DATE'].unique().tolist()[:3]
        L5_games_list = team_data['GAME_DATE'].unique().tolist()[:5]
        L10_games_list = team_data['GAME_DATE'].unique().tolist()[:10]
        season_games_list = team_data['GAME_DATE'].unique().tolist()
        
        team_data_parse = team_data[team_data['GAME_DATE'].isin(L3_games_list)]
        L3_frame = pd_concat([L3_frame.dropna(axis=1, how='all'), team_data_parse.dropna(axis=1, how='all')])
        team_data_parse = team_data[team_data['GAME_DATE'].isin(L5_games_list)]
        L5_frame = pd_concat([L5_frame.dropna(axis=1, how='all'), team_data_parse.dropna(axis=1, how='all')])
        team_data_parse = team_data[team_data['GAME_DATE'].isin(L10_games_list)]
        L10_frame = pd_concat([L10_frame.dropna(axis=1, how='all'), team_data_parse.dropna(axis=1, how='all')])
        team_data_parse = team_data[team_data['GAME_DATE'].isin(season_games_list)]
        season_frame = pd_concat([season_frame.dropna(axis=1, how='all'), team_data_parse.dropna(axis=1, how='all')])

    #------ BUILD DRAFTKINGS TRENDING TABLE ------#
    L3_file = L3_frame
    L3_file = L3_file[['GAME_DATE', 'TEAM_NAME', 'PLAYER_NAME', 'TEAM_ABBREVIATION', 'MIN', 'Fantasy', 'FD_Fantasy', 'FPPM']]
    L3_file = L3_file.sort_values(by=['TEAM_NAME', 'GAME_DATE'], ascending=[True, False])
    L3_file = L3_file.groupby(by=['PLAYER_NAME']).head(3).sort_values(by='GAME_DATE', ascending=False)
    L3_file_test = L3_file[L3_file['TEAM_NAME'] == 'New Orleans Pelicans']
    L3_file['L3 MIN'] = L3_file.groupby(['PLAYER_NAME'])['MIN'].transform('mean')
    L3_file['L3 Fantasy'] = L3_file.groupby(['PLAYER_NAME'])['Fantasy'].transform('mean')
    L3_min_sum = L3_file.groupby(['PLAYER_NAME'])['MIN'].transform('sum')
    L3_file['L3 FPPM'] = L3_file.groupby(['PLAYER_NAME'])['Fantasy'].transform('sum') / L3_min_sum.replace(0, np_nan)
    L3_file['L3 Ceiling'] = L3_file.groupby(['PLAYER_NAME'])['Fantasy'].transform(lambda x: x.quantile(.85))
    L3_file['L3 FD_Fantasy'] = L3_file.groupby(['PLAYER_NAME'])['FD_Fantasy'].transform('sum') / L3_min_sum.replace(0, np_nan)
    L3_file['L3 FD_Ceiling'] = L3_file.groupby(['PLAYER_NAME'])['FD_Fantasy'].transform(lambda x: x.quantile(.85))
    L3_file = L3_file.drop_duplicates(subset=['PLAYER_NAME'])
    L3_file_check = L3_file[['PLAYER_NAME', 'TEAM_NAME', 'L3 MIN', 'L3 Fantasy', 'L3 FPPM', 'L3 Ceiling', 'L3 FD_Fantasy', 'L3 FD_Ceiling']]
    L3_file = L3_file[['PLAYER_NAME', 'L3 MIN', 'L3 Fantasy', 'L3 FPPM', 'L3 Ceiling', 'L3 FD_Fantasy', 'L3 FD_Ceiling']]

    L5_file = L5_frame
    L5_file = L5_file[['GAME_DATE', 'TEAM_NAME', 'PLAYER_NAME', 'TEAM_ABBREVIATION', 'MIN', 'Fantasy', 'FD_Fantasy', 'FPPM']]
    L5_file = L5_file.sort_values(by=['TEAM_NAME', 'GAME_DATE'], ascending=[True, False])
    L5_file = L5_file.groupby(by=['PLAYER_NAME']).head(5).sort_values(by='GAME_DATE', ascending=False)
    L5_file['L5 MIN'] = L5_file.groupby(['PLAYER_NAME'])['MIN'].transform('mean')
    L5_file['L5 Fantasy'] = L5_file.groupby(['PLAYER_NAME'])['Fantasy'].transform('mean')
    L5_min_sum = L5_file.groupby(['PLAYER_NAME'])['MIN'].transform('sum')
    L5_file['L5 FPPM'] = L5_file.groupby(['PLAYER_NAME'])['Fantasy'].transform('sum') / L5_min_sum.replace(0, np_nan)
    L5_file['L5 Ceiling'] = L5_file.groupby(['PLAYER_NAME'])['Fantasy'].transform(lambda x: x.quantile(.85))
    L5_file['L5 FD_Fantasy'] = L5_file.groupby(['PLAYER_NAME'])['FD_Fantasy'].transform('sum') / L5_min_sum.replace(0, np_nan)
    L5_file['L5 FD_Ceiling'] = L5_file.groupby(['PLAYER_NAME'])['FD_Fantasy'].transform(lambda x: x.quantile(.85))
    L5_file = L5_file.drop_duplicates(subset=['PLAYER_NAME'])
    L5_file_check = L5_file[['PLAYER_NAME', 'TEAM_NAME', 'L5 MIN', 'L5 Fantasy', 'L5 FPPM', 'L5 Ceiling', 'L5 FD_Fantasy', 'L5 FD_Ceiling']]
    L5_file = L5_file[['PLAYER_NAME', 'L5 MIN', 'L5 Fantasy', 'L5 FPPM', 'L5 Ceiling', 'L5 FD_Fantasy', 'L5 FD_Ceiling']]

    L10_file = L10_frame
    L10_file = L10_file[['GAME_DATE', 'TEAM_NAME', 'PLAYER_NAME', 'TEAM_ABBREVIATION', 'MIN', 'Fantasy', 'FD_Fantasy', 'FPPM']]
    L10_file = L10_file.sort_values(by=['TEAM_NAME', 'GAME_DATE'], ascending=[True, False])
    L10_file = L10_file.groupby(by=['PLAYER_NAME']).head(10).sort_values(by='GAME_DATE', ascending=False)
    L10_file['L10 MIN'] = L10_file.groupby(['PLAYER_NAME'])['MIN'].transform('mean')
    L10_file['L10 Fantasy'] = L10_file.groupby(['PLAYER_NAME'])['Fantasy'].transform('mean')
    L10_min_sum = L10_file.groupby(['PLAYER_NAME'])['MIN'].transform('sum')
    L10_file['L10 FPPM'] = L10_file.groupby(['PLAYER_NAME'])['Fantasy'].transform('sum') / L10_min_sum.replace(0, np_nan)
    L10_file['L10 Ceiling'] = L10_file.groupby(['PLAYER_NAME'])['Fantasy'].transform(lambda x: x.quantile(.85))
    L10_file['L10 FD_Fantasy'] = L10_file.groupby(['PLAYER_NAME'])['FD_Fantasy'].transform('sum') / L10_min_sum.replace(0, np_nan)
    L10_file['L10 FD_Ceiling'] = L10_file.groupby(['PLAYER_NAME'])['FD_Fantasy'].transform(lambda x: x.quantile(.85))
    L10_file = L10_file.drop_duplicates(subset=['PLAYER_NAME'])
    L10_file_check = L10_file[['PLAYER_NAME', 'TEAM_NAME', 'L10 MIN', 'L10 Fantasy', 'L10 FPPM', 'L10 Ceiling', 'L10 FD_Fantasy', 'L10 FD_Ceiling']]
    L10_file = L10_file[['PLAYER_NAME', 'L10 MIN', 'L10 Fantasy', 'L10 FPPM', 'L10 Ceiling', 'L10 FD_Fantasy', 'L10 FD_Ceiling']]
    
    season_file = season_frame
    season_file = season_file[['GAME_DATE', 'TEAM_NAME', 'PLAYER_NAME', 'TEAM_ABBREVIATION', 'MIN', 'Fantasy', 'FD_Fantasy', 'FPPM']]
    season_file = season_file.sort_values(by=['TEAM_NAME', 'GAME_DATE'], ascending=[True, False])
    season_file['Season MIN'] = season_file.groupby(['PLAYER_NAME'])['MIN'].transform('mean')
    season_file['Season Fantasy'] = season_file.groupby(['PLAYER_NAME'])['Fantasy'].transform('mean')
    season_min_sum = season_file.groupby(['PLAYER_NAME'])['MIN'].transform('sum')
    season_file['Season FPPM'] = season_file.groupby(['PLAYER_NAME'])['Fantasy'].transform('sum') / season_min_sum.replace(0, np_nan)
    season_file['Season Ceiling'] = season_file.groupby(['PLAYER_NAME'])['Fantasy'].transform(lambda x: x.quantile(.85))
    season_file['Season FD_Fantasy'] = season_file.groupby(['PLAYER_NAME'])['FD_Fantasy'].transform('sum') / season_min_sum.replace(0, np_nan)
    season_file['Season FD_Ceiling'] = season_file.groupby(['PLAYER_NAME'])['FD_Fantasy'].transform(lambda x: x.quantile(.85))
    season_file = season_file.drop_duplicates(subset=['PLAYER_NAME'])
    season_file_check = season_file[['PLAYER_NAME', 'TEAM_NAME', 'Season MIN', 'Season Fantasy', 'Season FPPM', 'Season Ceiling', 'Season FD_Fantasy', 'Season FD_Ceiling']]
    season_file = season_file[['PLAYER_NAME', 'Season MIN', 'Season Fantasy', 'Season FPPM', 'Season Ceiling', 'Season FD_Fantasy', 'Season FD_Ceiling']]

    Trending_df = season_file.merge(L10_file, how='left').merge(L5_file, how ='left').merge(L3_file, how ='left')
    Trending_df = Trending_df.sort_values(by='L5 Fantasy', ascending=False)
    Trending_df = Trending_df.replace(np_nan, 0)
    try:
        worksheet = sh.worksheet('Trending')
        worksheet.batch_clear(['A:S'])
        worksheet.update([Trending_df.columns.values.tolist()] + Trending_df.values.tolist())
    except:
        worksheet = sh.worksheet('Trending')
        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']
    right_name = ['Luguentz Dort', 'Bub Carrington']
    for slates in slate_options:
        
        if slates == 'Main Slate':
            roo_team_list = slate_info['DK Main'].dropna().values.tolist()
            try:
                sh = gc.open_by_url(NBA_Master_hold)
                worksheet = sh.worksheet('DK_Build_Up')
                projects_raw = DataFrame(worksheet.get_values())
            except:
                sh = gc2.open_by_url(NBA_Master_hold)
                worksheet = sh.worksheet('DK_Build_Up')
                projects_raw = DataFrame(worksheet.get_values())
        elif slates == 'Secondary Slate':
            roo_team_list = slate_info['DK Secondary'].dropna().values.tolist()
            try:
                sh = gc.open_by_url(NBA_Master_hold)
                worksheet = sh.worksheet('Secondary_DK_Build')
                projects_raw = DataFrame(worksheet.get_values())
            except:
                sh = gc2.open_by_url(NBA_Master_hold)
                worksheet = sh.worksheet('Secondary_DK_Build')
                projects_raw = DataFrame(worksheet.get_values())
        elif slates == 'Late Slate':
            roo_team_list = slate_info['DK Late'].dropna().values.tolist()
            try:
                sh = gc.open_by_url(NBA_Master_hold)
                worksheet = sh.worksheet('Late_DK_Build')
                projects_raw = DataFrame(worksheet.get_values())
            except:
                sh = gc2.open_by_url(NBA_Master_hold)
                worksheet = sh.worksheet('Late_DK_Build')
                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[projects_raw['Team'].isin(roo_team_list)]
        projects_raw = projects_raw.rename(columns={"Name": "Player", "Nickname": "Player", "Fantasy": "Median"})
        for checkVar in range(len(wrong_name)):
            projects_raw['Player'] = projects_raw['Player'].replace(wrong_name, right_name)
        projects_raw = projects_raw.replace("", np_nan)
        str_columns = ['Player', 'Position', 'Team', 'Opp', 'Sample']
        numeric_columns = [col for col in projects_raw.columns if col not in str_columns]
        projects_raw[numeric_columns] = projects_raw[numeric_columns].apply(to_numeric, errors='coerce')
        projects_raw = projects_raw.loc[projects_raw['Salary'] > 0]
        projects_raw = projects_raw.loc[projects_raw['Median'] > 0]
        dk_df = projects_raw.sort_values(by='Median', ascending=False)
        
        basic_own_df = dk_df.copy()
        basic_own_df = basic_own_df[basic_own_df['Team'].isin(roo_team_list)]
        basic_own_df['name_team'] = basic_own_df['Player'] + basic_own_df['Position']

        # Prepare the current data with the same feature engineering
        basic_own_df['Actual'] = basic_own_df['Median']  # Rename to match training
        basic_own_df['value'] = basic_own_df['Actual'] / (basic_own_df['Salary'] / 1000)
        basic_own_df['value_adv'] = basic_own_df['value'] - basic_own_df['value'].mean()
        basic_own_df['actual_adv'] = basic_own_df['Actual'] - basic_own_df['Actual'].mean()

        # Create the same engineered features
        # Assuming all rows are from the same contest (current slate)
        basic_own_df['contest_size'] = len(basic_own_df)  # All players in current slate

        # Create value_play feature (same logic as training)
        basic_own_df['value_play'] = np_where(
            (basic_own_df['Salary'] <= 4000) & 
            (basic_own_df['Actual'] / (basic_own_df['Salary'] / 1000) >= 6.0), 
            1, 0
        )

        basic_own_df['value_density'] = basic_own_df['value_play'].sum() / basic_own_df['Player'].count()

        basic_own_df['base_ownership'] = 800.0 / basic_own_df['contest_size']

        basic_own_df['strong_play'] = np_where((basic_own_df['Actual'] / (basic_own_df['Salary'] / 1000) >= 6.0), 1, 0)
        basic_own_df['punt_play'] = np_where((basic_own_df['Salary'] < 3500) & (basic_own_df['Actual'] / (basic_own_df['Salary'] / 1000) >= 5.0), 1, 0)

        basic_own_df['ownership_share'] = basic_own_df['Own'].sum() / basic_own_df['Player'].count() * 800

        feature_cols = ['Salary', 'Actual', 'actual_adv', 'value', 'value_adv', 'contest_size', 'base_ownership', 'value_play', 'value_density', 'strong_play', 'punt_play']
        X_current = basic_own_df[feature_cols]

        # Make predictions with all your models
        basic_own_df['XGB'] = np_clip(xgb_model.predict(X_current), 0, 100)
        basic_own_df['LGB'] = np_clip(lgb_model.predict(X_current), 0, 100) * 100
        basic_own_df['KNN'] = np_clip(knn_model.predict(X_current), 0, 100)

        # Create combo prediction
        basic_own_df['Combo'] = (
            (basic_own_df['XGB'] * .30) + 
            (basic_own_df['LGB'] * .30) + 
            (basic_own_df['KNN'] * .40)
        )

        basic_own_df['Combo'] = np_where((basic_own_df['value'] < 5.0) & (basic_own_df['Salary'] < 9000), basic_own_df['Combo'] * .75, basic_own_df['Combo'])
        basic_own_df['Combo'] = np_where((basic_own_df['Median'] < 18.0), basic_own_df['Combo'] * .33, basic_own_df['Combo'])
        basic_own_df['Combo'] = np_where((basic_own_df['Salary'] > 5000) & (basic_own_df['value'] < 4.5), 1, basic_own_df['Combo'])
        basic_own_df['Combo'] = np_where(basic_own_df['value'] > 6.0, basic_own_df['Combo'] * ((basic_own_df['value'] / 6.0)), basic_own_df['Combo'])
        basic_own_df['Combo'] = np_where((basic_own_df['Salary'] > 9000), basic_own_df['Combo'] * .75, basic_own_df['Combo'])
        basic_own_df['Combo'] = np_where((basic_own_df['Salary'] > 9000) & (basic_own_df['Combo'] < basic_own_df['value']), basic_own_df['value'], basic_own_df['Combo'])
        basic_own_df['Combo'] = np_where((basic_own_df['Median'] > 20.0) & (basic_own_df['Salary'] < 3500), basic_own_df['Combo'] * (10 - basic_own_df['strong_play'].sum()).clip(0, 3), basic_own_df['Combo'])
        basic_own_df['Combo'] = np_where(basic_own_df['Position'].str.contains('/'), basic_own_df['Combo'] * 1.25, basic_own_df['Combo'] * .75)
        basic_own_df['Combo'] = (basic_own_df['Combo'] + basic_own_df['Own']) / 2

        power_scale = 1.10
        combo_powered = basic_own_df['Combo'] ** power_scale

        norm_var = 800.0 / combo_powered.sum()
        basic_own_df['Combo_powered'] = combo_powered * norm_var

        own_dict = dict(zip(basic_own_df.Player, basic_own_df.Own))
        pred_dict = dict(zip(basic_own_df.Player, basic_own_df.Combo_powered))
        team_dict = dict(zip(basic_own_df.name_team, basic_own_df.Team))
        opp_dict = dict(zip(basic_own_df.Player, basic_own_df.Opp))
        min_dict = dict(zip(basic_own_df.Player, basic_own_df.Minutes))
        player_id_dict = dict(zip(basic_own_df.Player, basic_own_df.player_id))
        total_sims = 1000
        
        flex_file = basic_own_df[['Player', 'Position', 'Salary', 'Median', 'Minutes']]
        flex_file = flex_file.rename(columns={"Agg": "Median"})
        flex_file['Floor'] = (flex_file['Median'] * .25) + (flex_file['Minutes'] * .25)
        flex_file['Ceiling'] = flex_file['Median'] + 10 + (flex_file['Minutes'] * .25)
        flex_file['STD'] = (flex_file['Median']/4)
        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)  # Example: 1000 rows
            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(1000)
        
        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_4x_check = (overall_file - (salary_file*4))
        salary_5x_check = (overall_file - (salary_file*5))
        salary_6x_check = (overall_file - (salary_file*6))
        gpp_check = (overall_file - ((salary_file*5)+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_5_finish'] = players_only[players_only <= 5].count(axis=1)/total_sims
        players_only['Top_10_finish'] = players_only[players_only <= 10].count(axis=1)/total_sims
        players_only['20+%'] = overall_file[overall_file >= 20].count(axis=1)/float(total_sims)
        players_only['4x%'] = salary_4x_check[salary_4x_check >= 1].count(axis=1)/float(total_sims)
        players_only['5x%'] = salary_5x_check[salary_5x_check >= 1].count(axis=1)/float(total_sims)
        players_only['6x%'] = salary_6x_check[salary_6x_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_5_finish', 'Top_10_finish', '20+%', '4x%', '5x%', '6x%', 'GPP%']]
    
        final_Proj = pd_merge(hold_file, final_outcomes, on="Player")
        final_Proj = final_Proj[['Player', 'Position', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '4x%', '5x%', '6x%', 'GPP%']]
        
        final_Proj['name_team'] = final_Proj['Player'] + final_Proj['Position']
        final_Proj['Own'] = final_Proj['Player'].map(pred_dict)
        final_Proj = final_Proj.replace('', np_nan)
        final_Proj = final_Proj.dropna(subset=['Own'])
        final_Proj['Own'] = final_Proj['Own'].astype('float')
        # own_average = final_Proj['Own'].mean()
        # final_Proj['Own'] = (final_Proj['Own'] + (final_Proj['Own'] * (final_Proj['Own'] / own_average).clip(upper=1.5, lower=0.5))) / 2
        final_Proj['Small_Own'] = final_Proj['Own'] + (.2 * (final_Proj['Own'] - final_Proj['Own'].mean()))
        own_norm = 800 / 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 = 800 / 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 = 800 / 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['Minutes Proj'] = final_Proj['Player'].map(min_dict)
        final_Proj['Team'] = final_Proj['name_team'].map(team_dict)
        final_Proj['Opp'] = final_Proj['Player'].map(opp_dict)
        final_Proj['player_id'] = final_Proj['Player'].map(player_id_dict)
        final_Proj['CPT_Own'] = final_Proj['Own'] / 6
        final_Proj['LevX'] = ((final_Proj[['Top_finish', '6x%', 'Top_5_finish']].mean(axis=1))*100) - final_Proj['Own']
        final_Proj['ValX'] = ((final_Proj[['5x%', '6x%']].mean(axis=1))*100) + final_Proj['LevX']

        st.write(final_Proj[['Player', 'Minutes Proj', 'Position', 'Team', 'Opp', 'Salary', 'Median', 'Own', 'Small_Own', 'Large_Own']].head(10))
    
        final_Proj = final_Proj[['Player', 'Minutes Proj', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '4x%', '5x%', '6x%', 'GPP%', 'Own', 'Small_Own', 'Large_Own', 'Cash_Own', 'CPT_Own', 'LevX', 'ValX', 'player_id']]
        final_Proj['site'] = 'Draftkings'
        final_Proj['version'] = 'overall'
        final_Proj['slate'] = slates
        final_Proj['Salary'] = final_Proj['Salary'].astype(int)
        final_Proj = final_Proj.sort_values(by='Median', ascending=False)
        
        dk_roo_player_hold = pd_concat([dk_roo_player_hold.dropna(axis=1, how='all'), final_Proj.dropna(axis=1, how='all')])
    
    return dk_roo_player_hold.copy()

def FD_NBA_ROO_Build(fd_roo_player_hold):
    wrong_name = ['Lu Dort', 'Carlton Carrington', 'Alexandre Sarr']
    right_name = ['Luguentz Dort', 'Bub Carrington', 'Alex Sarr']
    for slates in slate_options:
        
        if slates == 'Main Slate':
            roo_team_list = slate_info['FD Main'].dropna().values.tolist()
            try:
                sh = gc.open_by_url(NBA_Master_hold)
                worksheet = sh.worksheet('FD_Build_Up')
                projects_raw = DataFrame(worksheet.get_values())
            except:
                sh = gc2.open_by_url(NBA_Master_hold)
                worksheet = sh.worksheet('FD_Build_Up')
                projects_raw = DataFrame(worksheet.get_values())
        elif slates == 'Secondary Slate':
            roo_team_list = slate_info['FD Secondary'].dropna().values.tolist()
            try:
                sh = gc.open_by_url(NBA_Master_hold)
                worksheet = sh.worksheet('Secondary_FD_Build')
                projects_raw = DataFrame(worksheet.get_values())
            except:
                sh = gc2.open_by_url(NBA_Master_hold)
                worksheet = sh.worksheet('Secondary_FD_Build')
                projects_raw = DataFrame(worksheet.get_values())
        elif slates == 'Late Slate':
            roo_team_list = slate_info['FD Late'].dropna().values.tolist()
            try:
                sh = gc.open_by_url(NBA_Master_hold)
                worksheet = sh.worksheet('Late_FD_Build')
                projects_raw = DataFrame(worksheet.get_values())
            except:
                sh = gc2.open_by_url(NBA_Master_hold)
                worksheet = sh.worksheet('Late_FD_Build')
                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[projects_raw['Team'].isin(roo_team_list)]
        projects_raw = projects_raw.rename(columns={"Name": "Player", "Nickname": "Player", "Fantasy": "Median"})
        for checkVar in range(len(wrong_name)):
            projects_raw['Player'] = projects_raw['Player'].replace(wrong_name, right_name)
        projects_raw = projects_raw.replace("", np_nan)
        str_columns = ['Player', 'Position', 'Team', 'Opp', 'Sample', 'player_id']
        numeric_columns = [col for col in projects_raw.columns if col not in str_columns]
        projects_raw[numeric_columns] = projects_raw[numeric_columns].apply(to_numeric, errors='coerce')
        projects_raw = projects_raw.loc[projects_raw['Salary'] > 0]
        projects_raw = projects_raw.loc[projects_raw['Median'] > 0]
        fd_df = projects_raw.sort_values(by='Median', ascending=False)
        basic_own_df = fd_df.copy()
        basic_own_df = basic_own_df[basic_own_df['Team'].isin(roo_team_list)]
        basic_own_df['name_team'] = basic_own_df['Player'] + basic_own_df['Position']
    
        own_dict = dict(zip(basic_own_df.Player, basic_own_df.Own))
        team_dict = dict(zip(basic_own_df.name_team, basic_own_df.Team))
        opp_dict = dict(zip(basic_own_df.Player, basic_own_df.Opp))
        min_dict = dict(zip(basic_own_df.Player, basic_own_df.Minutes))
        player_id_dict = dict(zip(basic_own_df.Player, basic_own_df.player_id))
        total_sims = 1000
          
        flex_file = basic_own_df[['Player', 'Position', 'Salary', 'Median', 'Minutes']]
        flex_file = flex_file.rename(columns={"Agg": "Median"})
        flex_file['Floor'] = (flex_file['Median'] * .25) + (flex_file['Minutes'] * .25)
        flex_file['Ceiling'] = flex_file['Median'] + 10 + (flex_file['Minutes'] * .25)
        flex_file['STD'] = (flex_file['Median']/4)
        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)  # Example: 1000 rows
            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(1000)
        
        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_4x_check = (overall_file - (salary_file*4))
        salary_5x_check = (overall_file - (salary_file*5))
        salary_6x_check = (overall_file - (salary_file*6))
        gpp_check = (overall_file - ((salary_file*5)+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_5_finish'] = players_only[players_only <= 5].count(axis=1)/total_sims
        players_only['Top_10_finish'] = players_only[players_only <= 10].count(axis=1)/total_sims
        players_only['20+%'] = overall_file[overall_file >= 20].count(axis=1)/float(total_sims)
        players_only['4x%'] = salary_4x_check[salary_4x_check >= 1].count(axis=1)/float(total_sims)
        players_only['5x%'] = salary_5x_check[salary_5x_check >= 1].count(axis=1)/float(total_sims)
        players_only['6x%'] = salary_6x_check[salary_6x_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_5_finish', 'Top_10_finish', '20+%', '4x%', '5x%', '6x%', 'GPP%']]
    
        final_Proj = pd_merge(hold_file, final_outcomes, on="Player")
        final_Proj = final_Proj[['Player', 'Position', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '4x%', '5x%', '6x%', 'GPP%']]
        
        final_Proj['name_team'] = final_Proj['Player'] + final_Proj['Position']
        final_Proj['Own'] = final_Proj['Player'].map(own_dict)
        final_Proj['Own'] = final_Proj['Own'].astype('float')
        # own_average = final_Proj['Own'].mean()
        # final_Proj['Own'] = (final_Proj['Own'] + (final_Proj['Own'] * (final_Proj['Own'] / own_average).clip(upper=1.5, lower=0.5))) / 2
        final_Proj['Small_Own'] = final_Proj['Own'] + (.2 * (final_Proj['Own'] - final_Proj['Own'].mean()))
        own_norm = 800 / 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 = 800 / 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 = 800 / 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['Minutes Proj'] = final_Proj['Player'].map(min_dict)
        final_Proj['Team'] = final_Proj['name_team'].map(team_dict)
        final_Proj['Opp'] = final_Proj['Player'].map(opp_dict)
        final_Proj['player_id'] = final_Proj['Player'].map(player_id_dict)
        final_Proj['CPT_Own'] = final_Proj['Own'] / 6
        final_Proj['LevX'] = ((final_Proj[['Top_finish', '6x%', 'Top_5_finish']].mean(axis=1))*100) - final_Proj['Own']
        final_Proj['ValX'] = ((final_Proj[['5x%', '6x%']].mean(axis=1))*100) + final_Proj['LevX']
    
        final_Proj = final_Proj[['Player', 'Minutes Proj', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '4x%', '5x%', '6x%', 'GPP%', 'Own', 'Small_Own', 'Large_Own', 'Cash_Own', 'CPT_Own', 'LevX', 'ValX', 'player_id']]
        final_Proj['site'] = 'Fanduel'
        final_Proj['version'] = 'overall'
        final_Proj['slate'] = slates
        final_Proj['Salary'] = final_Proj['Salary'].astype(int)
        final_Proj = final_Proj.sort_values(by='Median', ascending=False)
        
        fd_roo_player_hold = pd_concat([fd_roo_player_hold.dropna(axis=1, how='all'), final_Proj.dropna(axis=1, how='all')])
    
    return fd_roo_player_hold.copy()

def DK_SD_NBA_ROO_Build(dk_sd_player_hold, dk_showdown_options, dk_sd_projections):
    wrong_name = ['Lu Dort', 'Carlton Carrington']
    right_name = ['Luguentz Dort', 'Bub Carrington']
    total_sims = 1000
    for slates in dk_showdown_options:
        
        projects_raw = dk_sd_projections.copy()
        projects_raw = projects_raw.reset_index(drop=True)
        projects_raw = projects_raw[projects_raw['Slate'] == slates]
        projects_raw = projects_raw.replace("", 0)
        
        projects_raw = projects_raw.rename(columns={"name": "Player", "Nickname": "Player", "Fantasy": "Median"})
        for checkVar in range(len(wrong_name)):
            projects_raw['Player'] = projects_raw['Player'].replace(wrong_name, right_name)
        projects_raw = projects_raw.replace("", np_nan)
        str_columns = ['Player', 'Position', 'Team', 'Opp', 'Sample']
        numeric_columns = [col for col in projects_raw.columns if col not in str_columns]
        projects_raw[numeric_columns] = projects_raw[numeric_columns].apply(to_numeric, errors='coerce')
        projects_raw = projects_raw.loc[projects_raw['Salary'] > 0]
        projects_raw = projects_raw.loc[projects_raw['Median'] > 0]
        working_roo = projects_raw
        working_roo = working_roo.replace('', 0)
        own_norm_var = 600 / working_roo['Own'].sum()
        
        working_roo['Own'] = working_roo['Own'] * own_norm_var
        
        own_dict = dict(zip(working_roo.Player, working_roo.Own))
        team_dict = dict(zip(working_roo.Player, working_roo.Team))
        opp_dict = dict(zip(working_roo.Player, working_roo.Opp))
        min_dict = dict(zip(working_roo.Player, working_roo.Minutes))
        player_id_dict = dict(zip(working_roo.Player, working_roo.player_ID))
        total_sims = 1000
        
        flex_file = working_roo[['Player', 'Position', 'Salary', 'Median', 'Minutes']]
        flex_file['Floor'] = (flex_file['Median'] * .25) + (flex_file['Minutes'] * .25)
        flex_file['Ceiling'] = flex_file['Median'] + 10 + (flex_file['Minutes'] * .25)
        flex_file['STD'] = (flex_file['Median']/4)
        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)  # Example: 1000 rows
            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(1000)
        
        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_4x_check = (overall_file - (salary_file*4))
        salary_5x_check = (overall_file - (salary_file*5))
        salary_6x_check = (overall_file - (salary_file*6))
        gpp_check = (overall_file - ((salary_file*5)+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_5_finish'] = players_only[players_only <= 5].count(axis=1)/total_sims
        players_only['Top_10_finish'] = players_only[players_only <= 10].count(axis=1)/total_sims
        players_only['20+%'] = overall_file[overall_file >= 20].count(axis=1)/float(total_sims)
        players_only['4x%'] = salary_4x_check[salary_4x_check >= 1].count(axis=1)/float(total_sims)
        players_only['5x%'] = salary_5x_check[salary_5x_check >= 1].count(axis=1)/float(total_sims)
        players_only['6x%'] = salary_6x_check[salary_6x_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_5_finish', 'Top_10_finish', '20+%', '4x%', '5x%', '6x%', 'GPP%']]
    
        final_Proj = pd_merge(hold_file, final_outcomes, on="Player")
        final_Proj = final_Proj[['Player', 'Position', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '4x%', '5x%', '6x%', 'GPP%']]
        
        final_Proj['name_team'] = final_Proj['Player'] + final_Proj['Position']
        final_Proj['Own'] = final_Proj['Player'].map(own_dict)
        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=1)
        final_Proj['Small_Own'] = final_Proj['Small_Own'].clip(upper=99, lower=1)
        final_Proj['Large_Own'] = final_Proj['Large_Own'].clip(upper=90, lower=2)
        final_Proj['Cash_Own'] = final_Proj['Cash_Own'].clip(upper=99, lower=1)
        own_norm = 600 / final_Proj['Own%'].sum()
        final_Proj['Own'] = final_Proj['Own%'] * own_norm
        final_Proj['Team'] = final_Proj['Player'].map(team_dict)
        final_Proj['Opp'] = final_Proj['Player'].map(opp_dict)
        final_Proj['Minutes Proj'] = final_Proj['Player'].map(min_dict)
        final_Proj['Opp'] = final_Proj['Player'].map(opp_dict)
        final_Proj['player_id'] = final_Proj['Player'].map(player_id_dict)
        final_Proj['CPT_Own_raw'] = (final_Proj['Own'] / 2) * ((100 - (100-final_Proj['Own']))/100)
        cpt_own_var = 100 / final_Proj['CPT_Own_raw'].sum()
        final_Proj['CPT_Own'] = final_Proj['CPT_Own_raw'] * cpt_own_var
        final_Proj['CPT_Proj'] = final_Proj['Median'] * 1.5 
        final_Proj['CPT_Salary'] = final_Proj['Salary'] * 1.5   
        final_Proj['LevX'] = ((final_Proj[['Top_finish', '6x%', 'Top_5_finish']].mean(axis=1))*100) - final_Proj['Own']
        final_Proj['ValX'] = ((final_Proj[['5x%', '6x%']].mean(axis=1))*100) + final_Proj['LevX']
    
        final_Proj = final_Proj[['Player', 'Minutes Proj', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '4x%', '5x%', '6x%', 'GPP%', 'Own', 'Small_Own', 'Large_Own', 'Cash_Own', 'CPT_Own', 'LevX', 'ValX', 'player_id']]
        final_Proj['site'] = 'Draftkings'
        final_Proj['version'] = 'overall'
        final_Proj['slate'] = slates
        final_Proj['Salary'] = final_Proj['Salary'].astype(int)
        final_Proj = final_Proj.sort_values(by='Median', ascending=False)

        st.write(final_Proj.head(1))
        
        dk_sd_player_hold = pd_concat([dk_sd_player_hold.dropna(axis=1, how='all'), final_Proj.dropna(axis=1, how='all')])
    
    return dk_sd_player_hold.copy()

def FD_SD_NBA_ROO_Build(fd_sd_player_hold, fd_showdown_options, fd_sd_projections):
    wrong_name = ['Lu Dort', 'Carlton Carrington', 'Alexandre Sarr']
    right_name = ['Luguentz Dort', 'Bub Carrington', 'Alex Sarr']
    total_sims = 1000
    for slates in fd_showdown_options:

        projects_raw = fd_sd_projections.copy()
        projects_raw = projects_raw.reset_index(drop=True)
        projects_raw = projects_raw[projects_raw['Slate'] == slates]
        projects_raw = projects_raw.replace("", 0)
        
        projects_raw = projects_raw.rename(columns={"name": "Player", "Nickname": "Player", "Fantasy": "Median"})
        for checkVar in range(len(wrong_name)):
            projects_raw['Player'] = projects_raw['Player'].replace(wrong_name, right_name)
        projects_raw = projects_raw.replace("", np_nan)
        str_columns = ['Player', 'Position', 'Team', 'Opp', 'Sample', 'player_ID']
        numeric_columns = [col for col in projects_raw.columns if col not in str_columns]
        projects_raw[numeric_columns] = projects_raw[numeric_columns].apply(to_numeric, errors='coerce')
        projects_raw = projects_raw.loc[projects_raw['Salary'] > 0]
        projects_raw = projects_raw.loc[projects_raw['Median'] > 0]
        working_roo = projects_raw
        working_roo = working_roo.replace('', 0)
        own_norm_var = 600 / working_roo['Own'].sum()
        
        working_roo['Own'] = working_roo['Own'] * own_norm_var
        
        own_dict = dict(zip(working_roo.Player, working_roo.Own))
        team_dict = dict(zip(working_roo.Player, working_roo.Team))
        opp_dict = dict(zip(working_roo.Player, working_roo.Opp))
        min_dict = dict(zip(working_roo.Player, working_roo.Minutes))
        player_id_dict = dict(zip(working_roo.Player, working_roo.player_ID))
        total_sims = 1000
        
        flex_file = working_roo[['Player', 'Position', 'Salary', 'Median', 'Minutes']]
        flex_file['Floor'] = (flex_file['Median'] * .25) + (flex_file['Minutes'] * .25)
        flex_file['Ceiling'] = flex_file['Median'] + 10 + (flex_file['Minutes'] * .25)
        flex_file['STD'] = (flex_file['Median']/4)
        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)  # Example: 1000 rows
            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(1000)
        
        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_4x_check = (overall_file - (salary_file*4))
        salary_5x_check = (overall_file - (salary_file*5))
        salary_6x_check = (overall_file - (salary_file*6))
        gpp_check = (overall_file - ((salary_file*5)+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_5_finish'] = players_only[players_only <= 5].count(axis=1)/total_sims
        players_only['Top_10_finish'] = players_only[players_only <= 10].count(axis=1)/total_sims
        players_only['20+%'] = overall_file[overall_file >= 20].count(axis=1)/float(total_sims)
        players_only['4x%'] = salary_4x_check[salary_4x_check >= 1].count(axis=1)/float(total_sims)
        players_only['5x%'] = salary_5x_check[salary_5x_check >= 1].count(axis=1)/float(total_sims)
        players_only['6x%'] = salary_6x_check[salary_6x_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_5_finish', 'Top_10_finish', '20+%', '4x%', '5x%', '6x%', 'GPP%']]
    
        final_Proj = pd_merge(hold_file, final_outcomes, on="Player")
        final_Proj = final_Proj[['Player', 'Position', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '4x%', '5x%', '6x%', 'GPP%']]
        
        final_Proj['name_team'] = final_Proj['Player'] + final_Proj['Position']
        final_Proj['Own'] = final_Proj['Player'].map(own_dict)
        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=1)
        final_Proj['Small_Own'] = final_Proj['Small_Own'].clip(upper=99, lower=1)
        final_Proj['Large_Own'] = final_Proj['Large_Own'].clip(upper=90, lower=2)
        final_Proj['Cash_Own'] = final_Proj['Cash_Own'].clip(upper=99, lower=1)
        own_norm = 600 / final_Proj['Own%'].sum()
        final_Proj['Own'] = final_Proj['Own%'] * own_norm
        final_Proj['Team'] = final_Proj['Player'].map(team_dict)
        final_Proj['Opp'] = final_Proj['Player'].map(opp_dict)
        final_Proj['Minutes Proj'] = final_Proj['Player'].map(min_dict)
        final_Proj['Opp'] = final_Proj['Player'].map(opp_dict)
        final_Proj['player_id'] = final_Proj['Player'].map(player_id_dict)
        final_Proj['CPT_Own_raw'] = (final_Proj['Own'] / 2) * ((100 - (100-final_Proj['Own']))/100)
        cpt_own_var = 100 / final_Proj['CPT_Own_raw'].sum()
        final_Proj['CPT_Own'] = final_Proj['CPT_Own_raw'] * cpt_own_var
        final_Proj['CPT_Proj'] = final_Proj['Median'] * 1.5 
        final_Proj['CPT_Salary'] = final_Proj['Salary'] * 1.5   
        final_Proj['LevX'] = ((final_Proj[['Top_finish', '6x%', 'Top_5_finish']].mean(axis=1))*100) - final_Proj['Own']
        final_Proj['ValX'] = ((final_Proj[['5x%', '6x%']].mean(axis=1))*100) + final_Proj['LevX']
    
        final_Proj = final_Proj[['Player', 'Minutes Proj', 'Position', 'Team', 'Opp', 'Salary', 'Floor', 'Median', 'Ceiling', 'Top_finish', 'Top_5_finish', 'Top_10_finish', '20+%', '4x%', '5x%', '6x%', 'GPP%', 'Own', 'Small_Own', 'Large_Own', 'Cash_Own', 'CPT_Own', 'LevX', 'ValX', 'player_id']]
        final_Proj['site'] = 'Fanduel'
        final_Proj['version'] = 'overall'
        final_Proj['slate'] = slates
        final_Proj['Salary'] = final_Proj['Salary'].astype(int)
        final_Proj = final_Proj.sort_values(by='Median', ascending=False)

        st.write(final_Proj.head(1))
        
        fd_sd_player_hold = pd_concat([fd_sd_player_hold.dropna(axis=1, how='all'), final_Proj.dropna(axis=1, how='all')])
    
    return fd_sd_player_hold.copy()

############----------FUNCTION FOR DRAFTKINGS SHOWDOWN SEED FRAME CREATION----------############
def DK_NBA_SD_seed_frame(dk_showdown_options, dk_sd_projections):

    wrong_team = ['GS', 'NO', 'SA', 'NY']
    right_team = ['GSW', 'NOP', 'SAS', 'NYK']
    wrong_name = ['Lu Dort', 'Carlton Carrington']
    right_name = ['Luguentz Dort', 'Bub Carrington']
    all_players_median = []
    all_cpt_median = []
    
    for slates in dk_showdown_options:
        load_display = dk_sd_projections.copy()
        load_display = load_display.replace('', np_nan)
        load_display = load_display[load_display['Slate'] == slates]
        for checkVar in range(len(wrong_team)):
            load_display['Team'] = load_display['Team'].replace(wrong_team, right_team)
            load_display['Opp'] = load_display['Opp'].replace(wrong_team, right_team)
        for checkVar in range(len(wrong_name)):
            load_display['name'] = load_display['name'].replace(wrong_name, right_name)
        raw_display = load_display.dropna(subset=['Fantasy'])
        raw_display['Position'] = 'FLEX'
        raw_display.rename(columns={"name": "Player", "Fantasy": "Median"}, inplace = True)
        raw_display = raw_display[['Player', 'Salary', 'Position', 'Team', 'Opp', 'Median', 'Minutes', 'Own']]
        dk_roo_raw = raw_display.loc[raw_display['Median'] > 0]
        dk_roo_raw = dk_roo_raw.replace(['0', ''], [np_nan, np_nan])
        Overall_Proj = dk_roo_raw.dropna(subset='Salary')
        Overall_Proj = Overall_Proj.dropna(subset='Median')
        
        own_norm_var = 600 / Overall_Proj['Own'].sum()
        Overall_Proj['Own'] = Overall_Proj['Own'] * own_norm_var
        
        Overall_Proj['Own'] = np_where(Overall_Proj['Own'] > 90, 90, Overall_Proj['Own'])
        
        own_norm_var = 600 / Overall_Proj['Own'].sum()
        Overall_Proj['Own'] = Overall_Proj['Own'] * own_norm_var
        
        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.rename(columns={"Player": "Name"}, inplace = True)
        
        Overall_Proj = Overall_Proj.reset_index(drop=True)
        Team_list = DataFrame(Overall_Proj['Team'].unique(), columns=['Team'])
        Team_list['team_var'] = Team_list.index
        
        players_full = Overall_Proj.sort_values(by='own_Value', ascending=False)
        cpt_median = players_full.drop_duplicates(subset ='Name', keep ='first')
        cpt_median = pd_merge(cpt_median, Team_list, how='left', on='Team')
        cpt_median['Var'] = cpt_median.index
        cpt_median['Median'] = cpt_median['Median'] * 1.5 
        cpt_median['Salary'] = cpt_median['Salary'] * 1.5
        cpt_median['Own'] = (cpt_median['Own'] / 2) * ((100 - (100-cpt_median['Own']))/100)
        cpt_median['Own'] = cpt_median['Own'] * (600 / cpt_median['Own'].sum())
        
        players_median = players_full.drop_duplicates(subset ='Name', keep ='first')
        players_median = pd_merge(players_median, Team_list, how='left', on='Team')
        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'] = slates
        all_players_median.append(players_median_copy)
        
        cpt_median_copy = cpt_median.copy()
        cpt_median_copy['slate'] = slates
        all_cpt_median.append(cpt_median_copy)
    
    # Combine all slates data
    combined_players_median = pd_concat(all_players_median, ignore_index=True)
    combined_cpt_median = pd_concat(all_cpt_median, ignore_index=True)
    
    # Reassign Var indices for combined data
    combined_players_median['Var'] = combined_players_median.index
    combined_cpt_median['Var'] = combined_cpt_median.index + len(combined_players_median)
    
    # Create maps for Go processing
    players_name_map = {str(int(idx)): str(name) for idx, name in combined_players_median.set_index('Var')['Name'].items()}
    players_salary_map = {str(int(idx)): int(salary) for idx, salary in combined_players_median.set_index('Var')['Salary'].items()}
    players_projection_map = {str(int(idx)): float(proj) for idx, proj in combined_players_median.set_index('Var')['Median'].items()}
    players_ownership_map = {str(int(idx)): float(own) for idx, own in combined_players_median.set_index('Var')['Own'].items()}
    players_team_map = {str(int(idx)): str(team) for idx, team in combined_players_median.set_index('Var')['Team'].items()}
    
    cpt_name_map = {str(int(idx)): str(name) for idx, name in combined_cpt_median.set_index('Var')['Name'].items()}
    cpt_salary_map = {str(int(idx)): int(salary) for idx, salary in combined_cpt_median.set_index('Var')['Salary'].items()}
    cpt_projection_map = {str(int(idx)): float(proj) for idx, proj in combined_cpt_median.set_index('Var')['Median'].items()}
    cpt_ownership_map = {str(int(idx)): float(own) for idx, own in combined_cpt_median.set_index('Var')['Own'].items()}
    cpt_team_map = {str(int(idx)): str(team) for idx, team in combined_cpt_median.set_index('Var')['Team'].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,
                "team_map": players_team_map
            }
        },
        "cpt_median": {
            "players": [],
            "maps": {
                "name_map": cpt_name_map,
                "salary_map": cpt_salary_map,
                "projection_map": cpt_projection_map,
                "ownership_map": cpt_ownership_map,
                "team_map": cpt_team_map
            }
        }
    }
    
    # Convert players to Go struct format
    for idx, row in combined_players_median.iterrows():
        player = {
            "id": int(row['Var']),
            "name": str(row['Name']),
            "position": str(row['Position']),
            "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": str(row['slate'])
        }
        output_data["players_median"]["players"].append(player)
    
    for idx, row in combined_cpt_median.iterrows():
        player = {
            "id": int(row['Var']),
            "name": str(row['Name']),
            "position": str(row['Position']),
            "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": str(row['slate'])
        }
        output_data["cpt_median"]["players"].append(player)
    
    # Calculate project root for file paths
    current_dir = os.path.dirname(os.path.abspath(__file__))
    project_root = os.path.dirname(os.path.dirname(current_dir))
    
    # Ensure directory exists
    showdown_dir = os.path.join(project_root, 'showdown_go')
    os.makedirs(showdown_dir, exist_ok=True)
    
    # Write JSON data for Go processing
    player_data_path = os.path.join(showdown_dir, 'player_data.json')
    with open(player_data_path, 'w') as f:
        json.dump(output_data, f)
    
    st.write("JSON export completed, starting Go processing...")
    
    # Call Go function
    if run_go_showdown_lineup_generator("DK", "NBA"):
        st.write("NBA lineup generation for DK completed successfully!")
        return True
    else:
        st.write("Go processing failed")
        return False

############----------FUNCTION FOR FANDUEL SHOWDOWN SEED FRAME CREATION----------############
def FD_NBA_SD_seed_frame(fd_showdown_options, fd_sd_projections):

    wrong_team = ['GS', 'NO', 'SA', 'NY']
    right_team = ['GSW', 'NOP', 'SAS', 'NYK']
    wrong_name = ['Lu Dort', 'Carlton Carrington', 'Alexandre Sarr']
    right_name = ['Luguentz Dort', 'Bub Carrington', 'Alex Sarr']

    all_players_median = []
    all_cpt_median = []
    
    for slates in fd_showdown_options:
        
        load_display = fd_sd_projections.copy()
        load_display = load_display.replace('', np_nan)
        load_display = load_display[load_display['Slate'] == slates]
        for checkVar in range(len(wrong_team)):
            load_display['Team'] = load_display['Team'].replace(wrong_team, right_team)
            load_display['Opp'] = load_display['Opp'].replace(wrong_team, right_team)
        for checkVar in range(len(wrong_name)):
            load_display['name'] = load_display['name'].replace(wrong_name, right_name)
        raw_display = load_display.dropna(subset=['Fantasy'])
        raw_display['Position'] = 'FLEX'
        raw_display.rename(columns={"name": "Player", "Fantasy": "Median"}, inplace = True)
        raw_display = raw_display[['Player', 'Salary', 'Position', 'Team', 'Opp', 'Median', 'Minutes', 'Own']]
        dk_roo_raw = raw_display.loc[raw_display['Median'] > 0]
        dk_roo_raw = dk_roo_raw.replace(['0', ''], [np_nan, np_nan])
        Overall_Proj = dk_roo_raw.dropna(subset='Salary')
        Overall_Proj = Overall_Proj.dropna(subset='Median')
        
        own_norm_var = 600 / Overall_Proj['Own'].sum()
        Overall_Proj['Own'] = Overall_Proj['Own'] * own_norm_var
        
        Overall_Proj['Own'] = np_where(Overall_Proj['Own'] > 90, 90, Overall_Proj['Own'])
        
        own_norm_var = 600 / Overall_Proj['Own'].sum()
        Overall_Proj['Own'] = Overall_Proj['Own'] * own_norm_var
        
        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.rename(columns={"Player": "Name"}, inplace = True)
        
        Overall_Proj = Overall_Proj.reset_index(drop=True)
        Team_list = DataFrame(Overall_Proj['Team'].unique(), columns=['Team'])
        Team_list['team_var'] = Team_list.index
        
        players_full = Overall_Proj.sort_values(by='own_Value', ascending=False)
        cpt_median = players_full.drop_duplicates(subset ='Name', keep ='first')
        cpt_median = pd_merge(cpt_median, Team_list, how='left', on='Team')
        cpt_median['Var'] = cpt_median.index
        cpt_median['Median'] = cpt_median['Median'] * 1.5 
        cpt_median['Salary'] = cpt_median['Salary'] * 1.5
        cpt_median['Own'] = (cpt_median['Own'] / 2) * ((100 - (100-cpt_median['Own']))/100)
        cpt_median['Own'] = cpt_median['Own'] * (600 / cpt_median['Own'].sum())
        
        players_median = players_full.drop_duplicates(subset ='Name', keep ='first')
        players_median = pd_merge(players_median, Team_list, how='left', on='Team')
        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'] = slates
        all_players_median.append(players_median_copy)
        
        cpt_median_copy = cpt_median.copy()
        cpt_median_copy['slate'] = slates
        all_cpt_median.append(cpt_median_copy)
    
    # Combine all slates data
    combined_players_median = pd_concat(all_players_median, ignore_index=True)
    combined_cpt_median = pd_concat(all_cpt_median, ignore_index=True)
    
    # Reassign Var indices for combined data
    combined_players_median['Var'] = combined_players_median.index
    combined_cpt_median['Var'] = combined_cpt_median.index + len(combined_players_median)
    
    # Create maps for Go processing
    players_name_map = {str(int(idx)): str(name) for idx, name in combined_players_median.set_index('Var')['Name'].items()}
    players_salary_map = {str(int(idx)): int(salary) for idx, salary in combined_players_median.set_index('Var')['Salary'].items()}
    players_projection_map = {str(int(idx)): float(proj) for idx, proj in combined_players_median.set_index('Var')['Median'].items()}
    players_ownership_map = {str(int(idx)): float(own) for idx, own in combined_players_median.set_index('Var')['Own'].items()}
    players_team_map = {str(int(idx)): str(team) for idx, team in combined_players_median.set_index('Var')['Team'].items()}
    
    cpt_name_map = {str(int(idx)): str(name) for idx, name in combined_cpt_median.set_index('Var')['Name'].items()}
    cpt_salary_map = {str(int(idx)): int(salary) for idx, salary in combined_cpt_median.set_index('Var')['Salary'].items()}
    cpt_projection_map = {str(int(idx)): float(proj) for idx, proj in combined_cpt_median.set_index('Var')['Median'].items()}
    cpt_ownership_map = {str(int(idx)): float(own) for idx, own in combined_cpt_median.set_index('Var')['Own'].items()}
    cpt_team_map = {str(int(idx)): str(team) for idx, team in combined_cpt_median.set_index('Var')['Team'].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,
                "team_map": players_team_map
            }
        },
        "cpt_median": {
            "players": [],
            "maps": {
                "name_map": cpt_name_map,
                "salary_map": cpt_salary_map,
                "projection_map": cpt_projection_map,
                "ownership_map": cpt_ownership_map,
                "team_map": cpt_team_map
            }
        }
    }
    
    # Convert players to Go struct format
    for idx, row in combined_players_median.iterrows():
        player = {
            "id": int(row['Var']),
            "name": str(row['Name']),
            "position": str(row['Position']),
            "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": str(row['slate'])
        }
        output_data["players_median"]["players"].append(player)
    
    for idx, row in combined_cpt_median.iterrows():
        player = {
            "id": int(row['Var']),
            "name": str(row['Name']),
            "position": str(row['Position']),
            "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": str(row['slate'])
        }
        output_data["cpt_median"]["players"].append(player)
    
    # Calculate project root for file paths
    current_dir = os.path.dirname(os.path.abspath(__file__))
    project_root = os.path.dirname(os.path.dirname(current_dir))
    
    # Ensure directory exists
    showdown_dir = os.path.join(project_root, 'showdown_go')
    os.makedirs(showdown_dir, exist_ok=True)
    
    # Write JSON data for Go processing
    player_data_path = os.path.join(showdown_dir, 'player_data.json')
    with open(player_data_path, 'w') as f:
        json.dump(output_data, f)
    
    st.write("JSON export completed, starting Go processing...")
    
    # Call Go function
    if run_go_showdown_lineup_generator("FD", "NBA"):
        st.write("NBA lineup generation for FD completed successfully!")
        return True
    else:
        st.write("Go processing failed")
        return False

############----------FUNCTION FOR DRAFTKINGS SHOWDOWN SEED FRAME CREATION----------############
def DK_NBA_seed_frame(roo_file, client):
    
    db = client['NBA_Database']

    raw_proj = roo_file[roo_file['site'] == 'Draftkings'].copy()
    wrong_name = ['Lu Dort', 'Carlton Carrington']
    right_name = ['Luguentz Dort', 'Bub Carrington']

    for slates in slate_options:
        optimal_lineups = []

        Overall_Proj = raw_proj.copy()

        Overall_Proj = Overall_Proj.replace(['0', ''], [np_nan, np_nan])
        Overall_Proj = Overall_Proj.dropna(subset='Salary')
        Overall_Proj = Overall_Proj.dropna(subset='Median')
        if slates == 'Main Slate':
            Overall_Proj = Overall_Proj[Overall_Proj['slate'] == 'Main Slate']
        elif slates == 'Secondary Slate':
            Overall_Proj = Overall_Proj[Overall_Proj['slate'] == 'Secondary Slate']
        elif slates == 'Late Slate':
            Overall_Proj = Overall_Proj[Overall_Proj['slate'] == 'Late Slate']
        for checkVar in range(len(wrong_name)):
            Overall_Proj['Player'] = Overall_Proj['Player'].replace(wrong_name, right_name)
        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.rename(columns={"Player": "Name"})
        Overall_Proj = Overall_Proj.dropna()
        
        Overall_Proj = Overall_Proj.reset_index(drop=True)
        Team_list = DataFrame(Overall_Proj['Team'].unique(), columns=['Team'])
        Team_list['team_var'] = Team_list.index

        players_median = Overall_Proj.drop_duplicates(subset ='Name', keep ='first')
        players_median = pd_merge(players_median, Team_list, how='left', on='Team')
        
        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'] = slates

        # 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_team_map = {str(int(idx)): str(team) for idx, team in players_median_copy.set_index('Var')['Team'].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,
                    "team_map": players_team_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']),
                "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": str(row['slate'])
            }
            output_data["players_median"]["players"].append(player)
        
        # Calculate project root for file paths
        current_dir = os.path.dirname(os.path.abspath(__file__))
        project_root = os.path.dirname(os.path.dirname(current_dir))

        # Ensure directory exists
        dk_nba_dir = os.path.join(project_root, 'dk_nba_go')
        os.makedirs(dk_nba_dir, exist_ok=True)
        
        # Write JSON data for Go processing
        player_data_path = os.path.join(dk_nba_dir, 'player_data.json')
        with open(player_data_path, 'w') as f:
            json.dump(output_data, f)

        if slates == 'Main Slate':
            collection = db['DK_NBA_name_map']
        elif slates == 'Secondary Slate':
            collection = db['DK_NBA_Secondary_name_map']
        elif slates == 'Late Slate':
            collection = db['DK_NBA_Late_name_map']

        master_name_map = pd_Series(players_median['Name'].values,index=players_median.Var).to_dict()
        master_salary_map = pd_Series(players_median['Salary'].values,index=players_median.Var).to_dict()
        master_projection_map = pd_Series(players_median['Median'].values,index=players_median.Var).to_dict()
        master_team_num_map = pd_Series(players_median['team_var'].values,index=players_median.Var).to_dict()
        master_team_map = pd_Series(players_median['Team'].values,index=players_median.Var).to_dict()
        master_own_map = pd_Series(players_median['Own'].values,index=players_median.Var).to_dict()
        master_name_index = pd_Series(players_median.Var.values, index=players_median.Name).to_dict()

        position_requirements = {
            'PG': 1,
            'SG': 1,
            'SF': 1,
            'PF': 1,
            'C': 1,
            'G': 1,
            'F': 1,
            'FLEX': 1,
        }

        salary_cap = 50000
        max_team_players = 3

        # Teams to loop through
        teams_to_optimize = players_median['Team'].unique().tolist()

        required_positions = ['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX']

        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:
            st.write(f"Error inserting name map: {e}")
            time_sleep(1)

        optimals = init_team_results(players_median, position_requirements, salary_cap, max_team_players, teams_to_optimize, 1000)
        formatted_optimals = format_optimals(optimals, players_median, required_positions)

        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'] + (formatted_optimals['proj'] * ((formatted_optimals['Team_count'] - 3) * .05))
        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": slates,  # Add slate identifier
                "salary": int(row['salary']),
                "projection": float(row['proj']),
                "team": str(row['Team']),
                "team_count": int(row['Team_count']),
                "secondary": str(row['Secondary']),
                "secondary_count": int(row['Secondary_count']),
                "ownership": float(row['Own']),
                "players": [int(row['PG']), int(row['SG']), int(row['SF']), int(row['PF']), int(row['C']), int(row['G']), int(row['F']), int(row['FLEX'])]
            }
            optimal_lineups.append(optimal_lineup)

        st.write(f"Generated {len(formatted_optimals)} optimal lineups for slate {slates}")

        optimal_lineups_path = os.path.join(dk_nba_dir, 'optimal_lineups.json')
        with open(optimal_lineups_path, 'w') as f:
            json.dump(optimal_lineups, f)

        run_go_classic_lineup_generator("DK", "NBA")
    st.write("NBA lineup generation for DK completed successfully!")

############----------FUNCTION FOR FANDUEL SHOWDOWN SEED FRAME CREATION----------############
def FD_NBA_seed_frame(roo_file, client):

    db = client['NBA_Database']

    raw_proj = roo_file[roo_file['site'] == 'Fanduel'].copy()
    wrong_name = ['Lu Dort', 'Carlton Carrington', 'Alexandre Sarr']
    right_name = ['Luguentz Dort', 'Bub Carrington', 'Alex Sarr']

    for slates in slate_options:
        optimal_lineups = []

        Overall_Proj = raw_proj.copy()
        Overall_Proj = Overall_Proj.replace(['0', ''], [np_nan, np_nan])
        Overall_Proj = Overall_Proj.dropna(subset='Salary')
        Overall_Proj = Overall_Proj.dropna(subset='Median')
        if slates == 'Main Slate':
            Overall_Proj = Overall_Proj[Overall_Proj['slate'] == 'Main Slate']
        elif slates == 'Secondary Slate':
            Overall_Proj = Overall_Proj[Overall_Proj['slate'] == 'Secondary Slate']
        elif slates == 'Late Slate':
            Overall_Proj = Overall_Proj[Overall_Proj['slate'] == 'Late Slate']
        for checkVar in range(len(wrong_name)):
            Overall_Proj['Player'] = Overall_Proj['Player'].replace(wrong_name, right_name)
        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.rename(columns={"Player": "Name"})
        Overall_Proj = Overall_Proj.dropna()

        Overall_Proj = Overall_Proj.reset_index(drop=True)
        Team_list = DataFrame(Overall_Proj['Team'].unique(), columns=['Team'])
        Team_list['team_var'] = Team_list.index

        players_median = Overall_Proj.drop_duplicates(subset ='Name', keep ='first')
        players_median = pd_merge(players_median, Team_list, how='left', on='Team')
        
        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'] = slates

        # 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_team_map = {str(int(idx)): str(team) for idx, team in players_median_copy.set_index('Var')['Team'].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,
                    "team_map": players_team_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']),
                "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": str(row['slate'])
            }
            output_data["players_median"]["players"].append(player)
        
        # Calculate project root for file paths
        current_dir = os.path.dirname(os.path.abspath(__file__))
        project_root = os.path.dirname(os.path.dirname(current_dir))

        fd_nba_dir = os.path.join(project_root, 'fd_nba_go')
        os.makedirs(fd_nba_dir, exist_ok=True)
        
        # Write JSON data for Go processing
        player_data_path = os.path.join(fd_nba_dir, 'player_data.json')
        with open(player_data_path, 'w') as f:
            json.dump(output_data, f)

        if slates == 'Main Slate':
            collection = db['FD_NBA_name_map']
        elif slates == 'Secondary Slate':
            collection = db['FD_NBA_Secondary_name_map']
        elif slates == 'Late Slate':
            collection = db['FD_NBA_Late_name_map']

        master_name_map = pd_Series(players_median['Name'].values,index=players_median.Var).to_dict()
        master_salary_map = pd_Series(players_median['Salary'].values,index=players_median.Var).to_dict()
        master_projection_map = pd_Series(players_median['Median'].values,index=players_median.Var).to_dict()
        master_team_num_map = pd_Series(players_median['team_var'].values,index=players_median.Var).to_dict()
        master_team_map = pd_Series(players_median['Team'].values,index=players_median.Var).to_dict()
        master_own_map = pd_Series(players_median['Own'].values,index=players_median.Var).to_dict()
        master_name_index = pd_Series(players_median.Var.values, index=players_median.Name).to_dict()

        position_requirements = {
            'PG': 2,
            'SG': 2,
            'SF': 2,
            'PF': 2,
            'C': 1,
        }

        salary_cap = 60000
        max_team_players = 3

        # Teams to loop through
        teams_to_optimize = players_median['Team'].unique().tolist()

        required_positions = ['PG', 'PG2', 'SG', 'SG2', 'SF', 'SF2', 'PF', 'PF2', 'C']

        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:
            st.write(f"Error inserting name map: {e}")
            time_sleep(1)

        optimals = init_team_results(players_median, position_requirements, salary_cap, max_team_players, teams_to_optimize, 1000)
        formatted_optimals = format_optimals(optimals, players_median, required_positions)

        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'] + (formatted_optimals['proj'] * ((formatted_optimals['Team_count'] - 3) * .05))
        formatted_optimals['proj'] = formatted_optimals['proj'].astype(float)

        formatted_optimals = formatted_optimals.rename(columns={'PG': 'PG1', 'SG': 'SG1', 'SF': 'SF1', 'PF': 'PF1'})
        st.write(formatted_optimals.head(10))

        # Convert this slate's optimals to JSON format and add slate info
        for idx, row in formatted_optimals.iterrows():
            optimal_lineup = {
                "slate": slates,  # Add slate identifier
                "salary": int(row['salary']),
                "projection": float(row['proj']),
                "team": str(row['Team']),
                "team_count": int(row['Team_count']),
                "secondary": str(row['Secondary']),
                "secondary_count": int(row['Secondary_count']),
                "ownership": float(row['Own']),
                "players": [int(row['PG1']), int(row['PG2']), int(row['SG1']), int(row['SG2']), int(row['SF1']), int(row['SF2']), int(row['PF1']), int(row['PF2']), int(row['C'])]
            }
            optimal_lineups.append(optimal_lineup)

        st.write(f"Generated {len(formatted_optimals)} optimal lineups for slate {slates}")

        optimal_lineups_path = os.path.join(fd_nba_dir, 'optimal_lineups.json')
        with open(optimal_lineups_path, 'w') as f:
            json.dump(optimal_lineups, f)

        run_go_classic_lineup_generator("FD", "NBA")
    st.write("NBA lineup generation for FD completed successfully!")

def upload_betting_data(client):
    NBA_Master_hold = 'https://docs.google.com/spreadsheets/d/1Yq0vGriWK-bS79e-bD6_u9pqrYE6Yrlbb_wEkmH-ot0/edit?gid=853878325#gid=853878325'
    
    db = client['NBA_Database']
    
    try:
        sh = gc.open_by_url(NBA_Master_hold)
        worksheet = sh.worksheet('Betting Model Clean')
        Overall_Proj = DataFrame(worksheet.get_all_records())
    except:
        sh = gc2.open_by_url(NBA_Master_hold)
        worksheet = sh.worksheet('Betting Model Clean')
        Overall_Proj = DataFrame(worksheet.get_all_records())
    
    collection = db['Game_Betting_Model']
    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)
    
    try:
        sh = gc.open_by_url(NBA_Master_hold)
        worksheet = sh.worksheet('Game_Model_Players')
        Overall_Proj = DataFrame(worksheet.get_all_records())
    except:
        sh = gc2.open_by_url(NBA_Master_hold)
        worksheet = sh.worksheet('Game_Model_Players')
        Overall_Proj = DataFrame(worksheet.get_all_records())
    
    collection = db['Player_Stats']
    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)
    
    try:
        sh = gc.open_by_url(NBA_Master_hold)
        worksheet = sh.worksheet('Prop_Frame')
        Overall_Proj = DataFrame(worksheet.get_all_records())
    except:
        sh = gc2.open_by_url(NBA_Master_hold)
        worksheet = sh.worksheet('Prop_Frame')
        Overall_Proj = DataFrame(worksheet.get_all_records())
    
    collection = db['Prop_Trends']
    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)
    
    try:
        sh = gc.open_by_url(NBA_Master_hold)
        worksheet = sh.worksheet('Bet_Sheet')
        Overall_Proj = DataFrame(worksheet.get_all_records())
    except:
        sh = gc2.open_by_url(NBA_Master_hold)
        worksheet = sh.worksheet('Bet_Sheet')
        Overall_Proj = DataFrame(worksheet.get_all_records())
    
    collection = db['Bet_Sheet']
    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)
    
    try:
        sh = gc.open_by_url(NBA_Master_hold)
        worksheet = sh.worksheet('Pick6_ingest')
        Overall_Proj = DataFrame(worksheet.get_all_records())
    except:
        sh = gc2.open_by_url(NBA_Master_hold)
        worksheet = sh.worksheet('Pick6_ingest')
        Overall_Proj = DataFrame(worksheet.get_all_records())
    
    collection = db['Pick6_Trends']
    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_sd_dfs_data(client, sd_roo_final):
    
    db = client['NBA_Database']
    
    collection = db['Player_SD_Range_Of_Outcomes']
    sd_roo_final = sd_roo_final.reset_index(drop=True)
    chunk_size = 100000
    collection.drop()
    for i in range(0, len(sd_roo_final), chunk_size):
        for _ in range(5):
            try:
                df_chunk = sd_roo_final.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):
    
    db = client['NBA_Database']
    
    try:
        sh = gc.open_by_url(NBA_Master_hold)
        worksheet = sh.worksheet('DK_Build_Up')
        Overall_Proj = DataFrame(worksheet.get_all_records())
        
    except:
        sh = gc2.open_by_url(NBA_Master_hold)
        worksheet = sh.worksheet('DK_Build_Up')
        Overall_Proj = DataFrame(worksheet.get_all_records())
    
    collection = db['DK_Player_Stats']
    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)
    
    try:
        sh = gc.open_by_url(NBA_Master_hold)
        worksheet = sh.worksheet('FD_Build_Up')
        Overall_Proj = DataFrame(worksheet.get_all_records())
        
    except:
        sh = gc2.open_by_url(NBA_Master_hold)
        worksheet = sh.worksheet('FD_Build_Up')
        Overall_Proj = DataFrame(worksheet.get_all_records())
    
    collection = db['FD_Player_Stats']
    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)
    
    try:
        sh = gc.open_by_url(NBA_Master_hold)
        worksheet = sh.worksheet('Secondary_DK_Build')
        Overall_Proj = DataFrame(worksheet.get_all_records())
        
    except:
        sh = gc2.open_by_url(NBA_Master_hold)
        worksheet = sh.worksheet('Secondary_DK_Build')
        Overall_Proj = DataFrame(worksheet.get_all_records())
    
    collection = db['Secondary_DK_Player_Stats']
    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)
    
    try:
        sh = gc.open_by_url(NBA_Master_hold)
        worksheet = sh.worksheet('Secondary_FD_Build')
        Overall_Proj = DataFrame(worksheet.get_all_records())
        
    except:
        sh = gc2.open_by_url(NBA_Master_hold)
        worksheet = sh.worksheet('Secondary_FD_Build')
        Overall_Proj = DataFrame(worksheet.get_all_records())
    
    collection = db['Secondary_FD_Player_Stats']
    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)
    
    collection = db['Player_Range_Of_Outcomes']
    roo_final = roo_final.reset_index(drop=True)
    chunk_size = 100000
    collection.drop()
    for i in range(0, len(roo_final), chunk_size):
        for _ in range(5):
            try:
                df_chunk = roo_final.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)