Spaces:

Multichem-PD
/

DFS_Portfolio_Manager

Running

James McCool

Update default stack count value to zero in app.py

2daa4c0 6 days ago

60.9 kB

	import streamlit as st
	st.set_page_config(layout="wide")
	import numpy as np
	import pandas as pd
	import time
	from fuzzywuzzy import process
	import random

	## import global functions
	from global_func.clean_player_name import clean_player_name
	from global_func.load_file import load_file
	from global_func.load_ss_file import load_ss_file
	from global_func.find_name_mismatches import find_name_mismatches
	from global_func.predict_dupes import predict_dupes
	from global_func.highlight_rows import highlight_changes, highlight_changes_winners, highlight_changes_losers
	from global_func.load_csv import load_csv
	from global_func.find_csv_mismatches import find_csv_mismatches

	freq_format = {'Finish_percentile': '{:.2%}', 'Lineup Edge': '{:.2%}', 'Win%': '{:.2%}'}
	player_wrong_names_mlb = ['Enrique Hernandez']
	player_right_names_mlb = ['Kike Hernandez']

	tab1, tab2, tab3 = st.tabs(["Data Load", "Late Swap", "Manage Portfolio"])
	with tab1:
	if st.button('Clear data', key='reset1'):
	st.session_state.clear()
	# Add file uploaders to your app
	col1, col2, col3 = st.columns(3)

	with col1:
	st.subheader("Draftkings/Fanduel CSV")
	st.info("Upload the player pricing CSV from the site you are playing on. This is used in late swap exporting and/or with SaberSim portfolios, but is not necessary for the portfolio management functions.")

	upload_csv_col, csv_template_col = st.columns([3, 1])
	with upload_csv_col:
	csv_file = st.file_uploader("Upload CSV File", type=['csv'])
	if 'csv_file' in st.session_state:
	del st.session_state['csv_file']
	with csv_template_col:

	csv_template_df = pd.DataFrame(columns=['Name', 'ID', 'Roster Position', 'Salary'])

	st.download_button(
	label="CSV Template",
	data=csv_template_df.to_csv(index=False),
	file_name="csv_template.csv",
	mime="text/csv"
	)
	st.session_state['csv_file'] = load_csv(csv_file)
	try:
	st.session_state['csv_file']['Salary'] = st.session_state['csv_file']['Salary'].astype(str).str.replace(',', '').astype(int)
	except:
	pass

	if csv_file:
	st.session_state['csv_file'] = st.session_state['csv_file'].drop_duplicates(subset=['Name'])
	st.success('Projections file loaded successfully!')
	st.dataframe(st.session_state['csv_file'].head(10))

	with col2:
	st.subheader("Portfolio File")
	st.info("Go ahead and upload a portfolio file here. Only include player columns and an optional 'Stack' column if you are playing MLB.")
	saber_toggle = st.radio("Are you uploading from SaberSim?", options=['No', 'Yes'])
	st.info("If you are uploading from SaberSim, you will need to upload a CSV file for the slate for name matching.")
	if saber_toggle == 'Yes':
	if csv_file is not None:
	portfolio_file = st.file_uploader("Upload Portfolio File (CSV or Excel)", type=['csv', 'xlsx', 'xls'])
	if 'portfolio' in st.session_state:
	del st.session_state['portfolio']
	if 'export_portfolio' in st.session_state:
	del st.session_state['export_portfolio']

	else:
	portfolio_file = st.file_uploader("Upload Portfolio File (CSV or Excel)", type=['csv', 'xlsx', 'xls'])
	if 'portfolio' in st.session_state:
	del st.session_state['portfolio']
	if 'export_portfolio' in st.session_state:
	del st.session_state['export_portfolio']

	if portfolio_file:
	if saber_toggle == 'Yes':
	st.session_state['export_portfolio'], st.session_state['portfolio'] = load_ss_file(portfolio_file, st.session_state['csv_file'])
	st.session_state['export_portfolio'] = st.session_state['export_portfolio'].dropna(how='all')
	st.session_state['export_portfolio'] = st.session_state['export_portfolio'].reset_index(drop=True)
	st.session_state['portfolio'] = st.session_state['portfolio'].dropna(how='all')
	st.session_state['portfolio'] = st.session_state['portfolio'].reset_index(drop=True)
	else:
	st.session_state['export_portfolio'], st.session_state['portfolio'] = load_file(portfolio_file)
	st.session_state['export_portfolio'] = st.session_state['export_portfolio'].dropna(how='all')
	st.session_state['export_portfolio'] = st.session_state['export_portfolio'].reset_index(drop=True)
	st.session_state['portfolio'] = st.session_state['portfolio'].dropna(how='all')
	st.session_state['portfolio'] = st.session_state['portfolio'].reset_index(drop=True)
	# Check if Stack column exists in the portfolio
	if 'Stack' in st.session_state['portfolio'].columns:
	# Create dictionary mapping index to Stack values
	stack_dict = dict(zip(st.session_state['portfolio'].index, st.session_state['portfolio']['Stack']))
	st.write(f"Found {len(stack_dict)} stack assignments")
	st.session_state['portfolio'] = st.session_state['portfolio'].drop(columns=['Stack'])
	else:
	stack_dict = None
	st.info("No Stack column found in portfolio")
	if st.session_state['portfolio'] is not None:
	st.success('Portfolio file loaded successfully!')
	st.session_state['portfolio'] = st.session_state['portfolio'].apply(lambda x: x.replace(player_wrong_names_mlb, player_right_names_mlb))
	st.dataframe(st.session_state['portfolio'].head(10))

	with col3:
	st.subheader("Projections File")
	st.info("upload a projections file that has 'player_names', 'salary', 'median', 'ownership', and 'captain ownership' (Needed for Showdown) columns. Note that the salary for showdown needs to be the FLEX salary, not the captain salary.")

	# Create two columns for the uploader and template button
	upload_col, template_col = st.columns([3, 1])

	with upload_col:
	projections_file = st.file_uploader("Upload Projections File (CSV or Excel)", type=['csv', 'xlsx', 'xls'])
	if 'projections_df' in st.session_state:
	del st.session_state['projections_df']

	with template_col:
	# Create empty DataFrame with required columns
	template_df = pd.DataFrame(columns=['player_names', 'position', 'team', 'salary', 'median', 'ownership', 'captain ownership'])
	# Add download button for template
	st.download_button(
	label="Template",
	data=template_df.to_csv(index=False),
	file_name="projections_template.csv",
	mime="text/csv"
	)

	if projections_file:
	export_projections, projections = load_file(projections_file)
	if projections is not None:
	st.success('Projections file loaded successfully!')
	projections = projections.apply(lambda x: x.replace(player_wrong_names_mlb, player_right_names_mlb))
	st.dataframe(projections.head(10))

	if portfolio_file and projections_file:
	if st.session_state['portfolio'] is not None and projections is not None:
	st.subheader("Name Matching Analysis")
	# Initialize projections_df in session state if it doesn't exist
	if 'projections_df' not in st.session_state:
	st.session_state['projections_df'] = projections.copy()
	st.session_state['projections_df']['salary'] = (st.session_state['projections_df']['salary'].astype(str).str.replace(',', '').astype(float).astype(int))

	# Update projections_df with any new matches
	st.session_state['projections_df'] = find_name_mismatches(st.session_state['portfolio'], st.session_state['projections_df'])
	if csv_file is not None and 'export_dict' not in st.session_state:
	# Create a dictionary of Name to Name+ID from csv_file
	try:
	name_id_map = dict(zip(
	st.session_state['csv_file']['Name'],
	st.session_state['csv_file']['Name + ID']
	))
	except:
	name_id_map = dict(zip(
	st.session_state['csv_file']['Nickname'],
	st.session_state['csv_file']['Id']
	))

	# Function to find best match
	def find_best_match(name):
	best_match = process.extractOne(name, name_id_map.keys())
	if best_match and best_match[1] >= 85: # 85% match threshold
	return name_id_map[best_match[0]]
	return name # Return original name if no good match found

	# Apply the matching
	projections['upload_match'] = projections['player_names'].apply(find_best_match)
	st.session_state['export_dict'] = dict(zip(projections['player_names'], projections['upload_match']))

	with tab2:
	if st.button('Clear data', key='reset2'):
	st.session_state.clear()

	if 'portfolio' in st.session_state and 'projections_df' in st.session_state:

	optimized_df = None

	map_dict = {
	'pos_map': dict(zip(st.session_state['projections_df']['player_names'],
	st.session_state['projections_df']['position'])),
	'salary_map': dict(zip(st.session_state['projections_df']['player_names'],
	st.session_state['projections_df']['salary'])),
	'proj_map': dict(zip(st.session_state['projections_df']['player_names'],
	st.session_state['projections_df']['median'])),
	'own_map': dict(zip(st.session_state['projections_df']['player_names'],
	st.session_state['projections_df']['ownership'])),
	'team_map': dict(zip(st.session_state['projections_df']['player_names'],
	st.session_state['projections_df']['team']))
	}
	# Calculate new stats for optimized lineups
	st.session_state['portfolio']['salary'] = st.session_state['portfolio'].apply(
	lambda row: sum(map_dict['salary_map'].get(player, 0) for player in row if player in map_dict['salary_map']), axis=1
	)
	st.session_state['portfolio']['median'] = st.session_state['portfolio'].apply(
	lambda row: sum(map_dict['proj_map'].get(player, 0) for player in row if player in map_dict['proj_map']), axis=1
	)

	st.session_state['portfolio']['Own'] = st.session_state['portfolio'].apply(
	lambda row: sum(map_dict['own_map'].get(player, 0) for player in row if player in map_dict['own_map']), axis=1
	)

	options_container = st.container()
	with options_container:
	col1, col2, col3, col4, col5, col6 = st.columns(6)
	with col1:
	curr_site_var = st.selectbox("Select your current site", options=['DraftKings', 'FanDuel'])
	with col2:
	curr_sport_var = st.selectbox("Select your current sport", options=['NBA', 'MLB', 'NFL', 'NHL', 'MMA'])
	with col3:
	swap_var = st.multiselect("Select late swap strategy", options=['Optimize', 'Increase volatility', 'Decrease volatility'])
	with col4:
	remove_teams_var = st.multiselect("What teams have already played?", options=st.session_state['projections_df']['team'].unique())
	with col5:
	winners_var = st.multiselect("Are there any players doing exceptionally well?", options=st.session_state['projections_df']['player_names'].unique(), max_selections=3)
	with col6:
	losers_var = st.multiselect("Are there any players doing exceptionally poorly?", options=st.session_state['projections_df']['player_names'].unique(), max_selections=3)
	if st.button('Clear Late Swap'):
	if 'optimized_df' in st.session_state:
	del st.session_state['optimized_df']

	map_dict = {
	'pos_map': dict(zip(st.session_state['projections_df']['player_names'],
	st.session_state['projections_df']['position'])),
	'salary_map': dict(zip(st.session_state['projections_df']['player_names'],
	st.session_state['projections_df']['salary'])),
	'proj_map': dict(zip(st.session_state['projections_df']['player_names'],
	st.session_state['projections_df']['median'])),
	'own_map': dict(zip(st.session_state['projections_df']['player_names'],
	st.session_state['projections_df']['ownership'])),
	'team_map': dict(zip(st.session_state['projections_df']['player_names'],
	st.session_state['projections_df']['team']))
	}
	# Calculate new stats for optimized lineups
	st.session_state['portfolio']['salary'] = st.session_state['portfolio'].apply(
	lambda row: sum(map_dict['salary_map'].get(player, 0) for player in row if player in map_dict['salary_map']), axis=1
	)
	st.session_state['portfolio']['median'] = st.session_state['portfolio'].apply(
	lambda row: sum(map_dict['proj_map'].get(player, 0) for player in row if player in map_dict['proj_map']), axis=1
	)
	st.session_state['portfolio']['Own'] = st.session_state['portfolio'].apply(
	lambda row: sum(map_dict['own_map'].get(player, 0) for player in row if player in map_dict['own_map']), axis=1
	)

	if st.button('Run Late Swap'):
	st.session_state['portfolio'] = st.session_state['portfolio'].drop(columns=['salary', 'median', 'Own'])
	if curr_sport_var == 'NBA':
	if curr_site_var == 'DraftKings':
	st.session_state['portfolio'] = st.session_state['portfolio'].set_axis(['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'UTIL'], axis=1)
	else:
	st.session_state['portfolio'] = st.session_state['portfolio'].set_axis(['PG', 'PG', 'SG', 'SG', 'SF', 'SF', 'PF', 'PF', 'C'], axis=1)

	# Define roster position rules
	if curr_site_var == 'DraftKings':
	position_rules = {
	'PG': ['PG'],
	'SG': ['SG'],
	'SF': ['SF'],
	'PF': ['PF'],
	'C': ['C'],
	'G': ['PG', 'SG'],
	'F': ['SF', 'PF'],
	'UTIL': ['PG', 'SG', 'SF', 'PF', 'C']
	}
	else:
	position_rules = {
	'PG': ['PG'],
	'SG': ['SG'],
	'SF': ['SF'],
	'PF': ['PF'],
	'C': ['C'],
	}
	# Create position groups from projections data
	position_groups = {}
	for _, player in st.session_state['projections_df'].iterrows():
	positions = player['position'].split('/')
	for pos in positions:
	if pos not in position_groups:
	position_groups[pos] = []
	position_groups[pos].append({
	'player_names': player['player_names'],
	'salary': player['salary'],
	'median': player['median'],
	'ownership': player['ownership'],
	'positions': positions # Store all eligible positions
	})

	def optimize_lineup(row):
	current_lineup = []
	total_salary = 0
	if curr_site_var == 'DraftKings':
	salary_cap = 50000
	else:
	salary_cap = 60000
	used_players = set()

	# Convert row to dictionary with roster positions
	roster = {}
	for col, player in zip(row.index, row):
	if col not in ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Lineup Edge']:
	roster[col] = {
	'name': player,
	'position': map_dict['pos_map'].get(player, '').split('/'),
	'team': map_dict['team_map'].get(player, ''),
	'salary': map_dict['salary_map'].get(player, 0),
	'median': map_dict['proj_map'].get(player, 0),
	'ownership': map_dict['own_map'].get(player, 0)
	}
	total_salary += roster[col]['salary']
	used_players.add(player)

	# Optimize each roster position in random order
	roster_positions = list(roster.items())
	random.shuffle(roster_positions)

	for roster_pos, current in roster_positions:
	# Skip optimization for players from removed teams
	if current['team'] in remove_teams_var:
	continue

	valid_positions = position_rules[roster_pos]
	better_options = []

	# Find valid replacements for this roster position
	for pos in valid_positions:
	if pos in position_groups:
	pos_options = [
	p for p in position_groups[pos]
	if p['median'] > current['median']
	and (total_salary - current['salary'] + p['salary']) <= salary_cap
	and p['player_names'] not in used_players
	and any(valid_pos in p['positions'] for valid_pos in valid_positions)
	and map_dict['team_map'].get(p['player_names']) not in remove_teams_var # Check team restriction
	]
	better_options.extend(pos_options)

	if better_options:
	# Remove duplicates
	better_options = {opt['player_names']: opt for opt in better_options}.values()

	# Sort by median projection and take the best one
	best_replacement = max(better_options, key=lambda x: x['median'])

	# Update the lineup and tracking variables
	used_players.remove(current['name'])
	used_players.add(best_replacement['player_names'])
	total_salary = total_salary - current['salary'] + best_replacement['salary']
	roster[roster_pos] = {
	'name': best_replacement['player_names'],
	'position': map_dict['pos_map'][best_replacement['player_names']].split('/'),
	'team': map_dict['team_map'][best_replacement['player_names']],
	'salary': best_replacement['salary'],
	'median': best_replacement['median'],
	'ownership': best_replacement['ownership']
	}

	# Return optimized lineup maintaining original column order
	return [roster[pos]['name'] for pos in row.index if pos in roster]

	def optimize_lineup_winners(row):
	current_lineup = []
	total_salary = 0
	if curr_site_var == 'DraftKings':
	salary_cap = 50000
	else:
	salary_cap = 60000
	used_players = set()

	# Check if any winners are in the lineup and count them
	winners_in_lineup = sum(1 for player in row if player in winners_var)
	changes_needed = min(winners_in_lineup, 3) if winners_in_lineup > 0 else 0
	changes_made = 0

	# Convert row to dictionary with roster positions
	roster = {}
	for col, player in zip(row.index, row):
	if col not in ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Lineup Edge']:
	roster[col] = {
	'name': player,
	'position': map_dict['pos_map'].get(player, '').split('/'),
	'team': map_dict['team_map'].get(player, ''),
	'salary': map_dict['salary_map'].get(player, 0),
	'median': map_dict['proj_map'].get(player, 0),
	'ownership': map_dict['own_map'].get(player, 0)
	}
	total_salary += roster[col]['salary']
	used_players.add(player)

	# Only proceed with ownership-based optimization if we have winners in the lineup
	if changes_needed > 0:
	# Randomize the order of positions to optimize
	roster_positions = list(roster.items())
	random.shuffle(roster_positions)

	for roster_pos, current in roster_positions:
	# Stop if we've made enough changes
	if changes_made >= changes_needed:
	break

	# Skip optimization for players from removed teams or if the current player is a winner
	if current['team'] in remove_teams_var or current['name'] in winners_var:
	continue

	valid_positions = list(position_rules[roster_pos])
	random.shuffle(valid_positions)
	better_options = []

	# Find valid replacements with higher ownership
	for pos in valid_positions:
	if pos in position_groups:
	pos_options = [
	p for p in position_groups[pos]
	if p['ownership'] > current['ownership']
	and p['median'] >= current['median'] - 3
	and (total_salary - current['salary'] + p['salary']) <= salary_cap
	and (total_salary - current['salary'] + p['salary']) >= salary_cap - 1000
	and p['player_names'] not in used_players
	and any(valid_pos in p['positions'] for valid_pos in valid_positions)
	and map_dict['team_map'].get(p['player_names']) not in remove_teams_var
	]
	better_options.extend(pos_options)

	if better_options:
	# Remove duplicates
	better_options = {opt['player_names']: opt for opt in better_options}.values()

	# Sort by ownership and take the highest owned option
	best_replacement = max(better_options, key=lambda x: x['ownership'])

	# Update the lineup and tracking variables
	used_players.remove(current['name'])
	used_players.add(best_replacement['player_names'])
	total_salary = total_salary - current['salary'] + best_replacement['salary']
	roster[roster_pos] = {
	'name': best_replacement['player_names'],
	'position': map_dict['pos_map'][best_replacement['player_names']].split('/'),
	'team': map_dict['team_map'][best_replacement['player_names']],
	'salary': best_replacement['salary'],
	'median': best_replacement['median'],
	'ownership': best_replacement['ownership']
	}
	changes_made += 1

	# Return optimized lineup maintaining original column order
	return [roster[pos]['name'] for pos in row.index if pos in roster]

	def optimize_lineup_losers(row):
	current_lineup = []
	total_salary = 0
	if curr_site_var == 'DraftKings':
	salary_cap = 50000
	else:
	salary_cap = 60000
	used_players = set()

	# Check if any winners are in the lineup and count them
	losers_in_lineup = sum(1 for player in row if player in losers_var)
	changes_needed = min(losers_in_lineup, 3) if losers_in_lineup > 0 else 0
	changes_made = 0

	# Convert row to dictionary with roster positions
	roster = {}
	for col, player in zip(row.index, row):
	if col not in ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Lineup Edge']:
	roster[col] = {
	'name': player,
	'position': map_dict['pos_map'].get(player, '').split('/'),
	'team': map_dict['team_map'].get(player, ''),
	'salary': map_dict['salary_map'].get(player, 0),
	'median': map_dict['proj_map'].get(player, 0),
	'ownership': map_dict['own_map'].get(player, 0)
	}
	total_salary += roster[col]['salary']
	used_players.add(player)

	# Only proceed with ownership-based optimization if we have winners in the lineup
	if changes_needed > 0:
	# Randomize the order of positions to optimize
	roster_positions = list(roster.items())
	random.shuffle(roster_positions)

	for roster_pos, current in roster_positions:
	# Stop if we've made enough changes
	if changes_made >= changes_needed:
	break

	# Skip optimization for players from removed teams or if the current player is a winner
	if current['team'] in remove_teams_var or current['name'] in losers_var:
	continue

	valid_positions = list(position_rules[roster_pos])
	random.shuffle(valid_positions)
	better_options = []

	# Find valid replacements with higher ownership
	for pos in valid_positions:
	if pos in position_groups:
	pos_options = [
	p for p in position_groups[pos]
	if p['ownership'] < current['ownership']
	and p['median'] >= current['median'] - 3
	and (total_salary - current['salary'] + p['salary']) <= salary_cap
	and (total_salary - current['salary'] + p['salary']) >= salary_cap - 1000
	and p['player_names'] not in used_players
	and any(valid_pos in p['positions'] for valid_pos in valid_positions)
	and map_dict['team_map'].get(p['player_names']) not in remove_teams_var
	]
	better_options.extend(pos_options)

	if better_options:
	# Remove duplicates
	better_options = {opt['player_names']: opt for opt in better_options}.values()

	# Sort by ownership and take the highest owned option
	best_replacement = max(better_options, key=lambda x: x['ownership'])

	# Update the lineup and tracking variables
	used_players.remove(current['name'])
	used_players.add(best_replacement['player_names'])
	total_salary = total_salary - current['salary'] + best_replacement['salary']
	roster[roster_pos] = {
	'name': best_replacement['player_names'],
	'position': map_dict['pos_map'][best_replacement['player_names']].split('/'),
	'team': map_dict['team_map'][best_replacement['player_names']],
	'salary': best_replacement['salary'],
	'median': best_replacement['median'],
	'ownership': best_replacement['ownership']
	}
	changes_made += 1

	# Return optimized lineup maintaining original column order
	return [roster[pos]['name'] for pos in row.index if pos in roster]

	# Create a progress bar
	progress_bar = st.progress(0)
	status_text = st.empty()

	# Process each lineup
	optimized_lineups = []
	total_lineups = len(st.session_state['portfolio'])

	for idx, row in st.session_state['portfolio'].iterrows():
	# First optimization pass
	first_pass = optimize_lineup(row)
	first_pass_series = pd.Series(first_pass, index=row.index)

	second_pass = optimize_lineup(first_pass_series)
	second_pass_series = pd.Series(second_pass, index=row.index)

	third_pass = optimize_lineup(second_pass_series)
	third_pass_series = pd.Series(third_pass, index=row.index)

	fourth_pass = optimize_lineup(third_pass_series)
	fourth_pass_series = pd.Series(fourth_pass, index=row.index)

	fifth_pass = optimize_lineup(fourth_pass_series)
	fifth_pass_series = pd.Series(fifth_pass, index=row.index)

	# Second optimization pass
	final_lineup = optimize_lineup(fifth_pass_series)
	optimized_lineups.append(final_lineup)

	if 'Optimize' in swap_var:
	progress = (idx + 1) / total_lineups
	progress_bar.progress(progress)
	status_text.text(f'Optimizing Lineups {idx + 1} of {total_lineups}')
	else:
	pass

	# Create new dataframe with optimized lineups
	if 'Optimize' in swap_var:
	st.session_state['optimized_df_medians'] = pd.DataFrame(optimized_lineups, columns=st.session_state['portfolio'].columns)
	else:
	st.session_state['optimized_df_medians'] = st.session_state['portfolio']

	# Create a progress bar
	progress_bar_winners = st.progress(0)
	status_text_winners = st.empty()

	# Process each lineup
	optimized_lineups_winners = []
	total_lineups = len(st.session_state['optimized_df_medians'])

	for idx, row in st.session_state['optimized_df_medians'].iterrows():

	final_lineup = optimize_lineup_winners(row)
	optimized_lineups_winners.append(final_lineup)

	if 'Decrease volatility' in swap_var:
	progress_winners = (idx + 1) / total_lineups
	progress_bar_winners.progress(progress_winners)
	status_text_winners.text(f'Lowering Volatility around Winners {idx + 1} of {total_lineups}')
	else:
	pass

	# Create new dataframe with optimized lineups
	if 'Decrease volatility' in swap_var:
	st.session_state['optimized_df_winners'] = pd.DataFrame(optimized_lineups_winners, columns=st.session_state['optimized_df_medians'].columns)
	else:
	st.session_state['optimized_df_winners'] = st.session_state['optimized_df_medians']

	# Create a progress bar
	progress_bar_losers = st.progress(0)
	status_text_losers = st.empty()

	# Process each lineup
	optimized_lineups_losers = []
	total_lineups = len(st.session_state['optimized_df_winners'])

	for idx, row in st.session_state['optimized_df_winners'].iterrows():

	final_lineup = optimize_lineup_losers(row)
	optimized_lineups_losers.append(final_lineup)

	if 'Increase volatility' in swap_var:
	progress_losers = (idx + 1) / total_lineups
	progress_bar_losers.progress(progress_losers)
	status_text_losers.text(f'Increasing Volatility around Losers {idx + 1} of {total_lineups}')
	else:
	pass

	# Create new dataframe with optimized lineups
	if 'Increase volatility' in swap_var:
	st.session_state['optimized_df'] = pd.DataFrame(optimized_lineups_losers, columns=st.session_state['optimized_df_winners'].columns)
	else:
	st.session_state['optimized_df'] = st.session_state['optimized_df_winners']

	# Calculate new stats for optimized lineups
	st.session_state['optimized_df']['salary'] = st.session_state['optimized_df'].apply(
	lambda row: sum(map_dict['salary_map'].get(player, 0) for player in row if player in map_dict['salary_map']), axis=1
	)
	st.session_state['optimized_df']['median'] = st.session_state['optimized_df'].apply(
	lambda row: sum(map_dict['proj_map'].get(player, 0) for player in row if player in map_dict['proj_map']), axis=1
	)
	st.session_state['optimized_df']['Own'] = st.session_state['optimized_df'].apply(
	lambda row: sum(map_dict['own_map'].get(player, 0) for player in row if player in map_dict['own_map']), axis=1
	)

	# Display results
	st.success('Optimization complete!')

	if 'optimized_df' in st.session_state:
	st.write("Increase in median highlighted in yellow, descrease in volatility highlighted in blue, increase in volatility highlighted in red:")
	st.dataframe(
	st.session_state['optimized_df'].style
	.apply(highlight_changes, axis=1)
	.apply(highlight_changes_winners, axis=1)
	.apply(highlight_changes_losers, axis=1)
	.background_gradient(axis=0)
	.background_gradient(cmap='RdYlGn')
	.format(precision=2),
	height=1000,
	use_container_width=True
	)

	# Option to download optimized lineups
	if st.button('Prepare Late Swap Export'):
	export_df = st.session_state['optimized_df'].copy()

	# Map player names to their export IDs for all player columns
	for col in export_df.columns:
	if col not in ['salary', 'median', 'Own']:
	export_df[col] = export_df[col].map(st.session_state['export_dict'])

	csv = export_df.to_csv(index=False)
	st.download_button(
	label="Download CSV",
	data=csv,
	file_name="optimized_lineups.csv",
	mime="text/csv"
	)
	else:
	st.write("Current Portfolio")
	st.dataframe(
	st.session_state['portfolio'].style
	.background_gradient(axis=0)
	.background_gradient(cmap='RdYlGn')
	.format(precision=2),
	height=1000,
	use_container_width=True
	)

	with tab3:
	if st.button('Clear data', key='reset3'):
	st.session_state.clear()
	if 'portfolio' in st.session_state and 'projections_df' in st.session_state:
	col1, col2, col3 = st.columns([1, 8, 1])
	excluded_cols = ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Stack', 'Win%', 'Lineup Edge']
	with col1:
	site_var = st.selectbox("Select Site", ['Draftkings', 'Fanduel'])
	sport_var = st.selectbox("Select Sport", ['NFL', 'MLB', 'NBA', 'NHL', 'MMA'])
	st.info("It currently does not matter what sport you select, it may matter in the future.")
	type_var = st.selectbox("Select Game Type", ['Classic', 'Showdown'])
	Contest_Size = st.number_input("Enter Contest Size", value=25000, min_value=1, step=1)
	strength_var = st.selectbox("Select field strength", ['Average', 'Sharp', 'Weak'])
	if site_var == 'Draftkings':
	if type_var == 'Classic':
	map_dict = {
	'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])),
	'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])),
	'salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
	'proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])),
	'own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'])),
	'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))),
	'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
	'cpt_proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'] * 1.5)),
	'cpt_own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['captain ownership']))
	}
	elif type_var == 'Showdown':
	if sport_var == 'NFL':
	map_dict = {
	'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])),
	'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])),
	'salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
	'proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])),
	'own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'])),
	'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))),
	'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'] * 1.5)),
	'cpt_proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'] * 1.5)),
	'cpt_own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['captain ownership']))
	}
	elif sport_var != 'NFL':
	map_dict = {
	'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])),
	'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])),
	'salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'] / 1.5)),
	'proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])),
	'own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'])),
	'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))),
	'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
	'cpt_proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'] * 1.5)),
	'cpt_own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['captain ownership']))
	}
	elif site_var == 'Fanduel':
	map_dict = {
	'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])),
	'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])),
	'salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
	'proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])),
	'own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'])),
	'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))),
	'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
	'cpt_proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'] * 1.5)),
	'cpt_own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['captain ownership']))
	}

	if type_var == 'Classic':
	st.session_state['portfolio']['salary'] = st.session_state['portfolio'].apply(lambda row: sum(map_dict['salary_map'].get(player, 0) for player in row), axis=1)
	st.session_state['portfolio']['median'] = st.session_state['portfolio'].apply(lambda row: sum(map_dict['proj_map'].get(player, 0) for player in row), axis=1)
	st.session_state['portfolio']['Own'] = st.session_state['portfolio'].apply(lambda row: sum(map_dict['own_map'].get(player, 0) for player in row), axis=1)
	if stack_dict is not None:
	st.session_state['portfolio']['Stack'] = st.session_state['portfolio'].index.map(stack_dict)
	elif type_var == 'Showdown':
	# Calculate salary (CPT uses cpt_salary_map, others use salary_map)
	st.session_state['portfolio']['salary'] = st.session_state['portfolio'].apply(
	lambda row: map_dict['cpt_salary_map'].get(row.iloc[0], 0) +
	sum(map_dict['salary_map'].get(player, 0) for player in row.iloc[1:]),
	axis=1
	)

	# Calculate median (CPT uses cpt_proj_map, others use proj_map)
	st.session_state['portfolio']['median'] = st.session_state['portfolio'].apply(
	lambda row: map_dict['cpt_proj_map'].get(row.iloc[0], 0) +
	sum(map_dict['proj_map'].get(player, 0) for player in row.iloc[1:]),
	axis=1
	)

	# Calculate ownership (CPT uses cpt_own_map, others use own_map)
	st.session_state['portfolio']['Own'] = st.session_state['portfolio'].apply(
	lambda row: map_dict['cpt_own_map'].get(row.iloc[0], 0) +
	sum(map_dict['own_map'].get(player, 0) for player in row.iloc[1:]),
	axis=1
	)
	with col3:
	with st.form(key='filter_form'):
	max_dupes = st.number_input("Max acceptable dupes?", value=1000, min_value=1, step=1)
	min_salary = st.number_input("Min acceptable salary?", value=1000, min_value=1000, step=100)
	max_salary = st.number_input("Max acceptable salary?", value=60000, min_value=1000, step=100)
	max_finish_percentile = st.number_input("Max acceptable finish percentile?", value=.50, min_value=0.005, step=.001)
	player_names = set()
	for col in st.session_state['portfolio'].columns:
	if col not in excluded_cols:
	player_names.update(st.session_state['portfolio'][col].unique())
	player_lock = st.multiselect("Lock players?", options=sorted(list(player_names)), default=[])
	player_remove = st.multiselect("Remove players?", options=sorted(list(player_names)), default=[])
	if stack_dict is not None:
	stack_toggle = st.selectbox("Include specific stacks?", options=['All Stacks', 'Specific Stacks'], index=0)
	stack_selections = st.multiselect("If Specific Stacks, Which to include?", options=sorted(list(set(stack_dict.values()))), default=[])
	stack_remove = st.multiselect("If Specific Stacks, Which to remove?", options=sorted(list(set(stack_dict.values()))), default=[])

	submitted = st.form_submit_button("Submit")

	with col2:
	st.session_state['portfolio'] = predict_dupes(st.session_state['portfolio'], map_dict, site_var, type_var, Contest_Size, strength_var)
	st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['Dupes'] <= max_dupes]
	st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['salary'] >= min_salary]
	st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['salary'] <= max_salary]
	st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['Finish_percentile'] <= max_finish_percentile]
	if stack_dict is not None:
	if stack_toggle == 'All Stacks':
	st.session_state['portfolio'] = st.session_state['portfolio']
	st.session_state['portfolio'] = st.session_state['portfolio'][~st.session_state['portfolio']['Stack'].isin(stack_remove)]
	else:
	st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['Stack'].isin(stack_selections)]
	st.session_state['portfolio'] = st.session_state['portfolio'][~st.session_state['portfolio']['Stack'].isin(stack_remove)]
	if player_remove:
	# Create mask for lineups that contain any of the removed players
	player_columns = [col for col in st.session_state['portfolio'].columns if col not in excluded_cols]
	remove_mask = st.session_state['portfolio'][player_columns].apply(
	lambda row: not any(player in list(row) for player in player_remove), axis=1
	)
	st.session_state['portfolio'] = st.session_state['portfolio'][remove_mask]

	if player_lock:
	# Create mask for lineups that contain all locked players
	player_columns = [col for col in st.session_state['portfolio'].columns if col not in excluded_cols]

	lock_mask = st.session_state['portfolio'][player_columns].apply(
	lambda row: all(player in list(row) for player in player_lock), axis=1
	)
	st.session_state['portfolio'] = st.session_state['portfolio'][lock_mask]
	export_file = st.session_state['portfolio'].copy()
	st.session_state['portfolio'] = st.session_state['portfolio'].sort_values(by='median', ascending=False)
	if csv_file is not None:
	player_columns = [col for col in st.session_state['portfolio'].columns if col not in excluded_cols]
	for col in player_columns:
	export_file[col] = export_file[col].map(st.session_state['export_dict'])
	with st.expander("Download options"):
	if stack_dict is not None:
	with st.form(key='stack_form'):
	st.subheader("Stack Count Adjustments")
	st.info("This allows you to fine tune the stacks that you wish to export. If you want to make sure you don't export any of a specific stack you can 0 it out.")
	# Create a container for stack value inputs
	sort_container = st.container()
	with sort_container:
	sort_var = st.selectbox("Sort export portfolio by:", options=['median', 'Lineup Edge', 'Own'])

	# Get unique stack values
	unique_stacks = sorted(list(set(stack_dict.values())))

	# Create a dictionary to store stack multipliers
	if 'stack_multipliers' not in st.session_state:
	st.session_state.stack_multipliers = {stack: 0.0 for stack in unique_stacks}

	# Create columns for the stack inputs
	num_cols = 6 # Number of columns to display
	for i in range(0, len(unique_stacks), num_cols):
	cols = st.columns(num_cols)
	for j, stack in enumerate(unique_stacks[i:i+num_cols]):
	with cols[j]:
	# Create a unique key for each number input
	key = f"stack_count_{stack}"
	# Get the current count of this stack in the portfolio
	current_stack_count = len(st.session_state['portfolio'][st.session_state['portfolio']['Stack'] == stack])
	# Create number input with current value and max value based on actual count
	st.session_state.stack_multipliers[stack] = st.number_input(
	f"{stack} count",
	min_value=0.0,
	max_value=float(current_stack_count),
	value=0.0,
	step=1.0,
	key=key
	)

	# Create a copy of the portfolio
	portfolio_copy = st.session_state['portfolio'].copy()

	# Create a list to store selected rows
	selected_rows = []

	# For each stack, select the top N rows based on the count value
	for stack in unique_stacks:
	if stack in st.session_state.stack_multipliers:
	count = int(st.session_state.stack_multipliers[stack])
	# Get rows for this stack
	stack_rows = portfolio_copy[portfolio_copy['Stack'] == stack]
	# Sort by median and take top N rows
	top_rows = stack_rows.nlargest(count, sort_var)
	selected_rows.append(top_rows)

	# Combine all selected rows
	portfolio_copy = pd.concat(selected_rows)

	# Update export_file with filtered data
	export_file = portfolio_copy.copy()
	for col in export_file.columns:
	if col not in excluded_cols:
	export_file[col] = export_file[col].map(st.session_state['export_dict'])

	submitted = st.form_submit_button("Submit")
	if submitted:
	st.write('Export portfolio updated!')

	st.download_button(label="Download Portfolio", data=export_file.to_csv(index=False), file_name="portfolio.csv", mime="text/csv")
	# Display the paginated dataframe first
	st.dataframe(
	st.session_state['portfolio'].style
	.background_gradient(axis=0)
	.background_gradient(cmap='RdYlGn')
	.background_gradient(cmap='RdYlGn_r', subset=['Finish_percentile', 'Own', 'Dupes'])
	.format(freq_format, precision=2),
	height=1000,
	use_container_width=True
	)

	# Add pagination controls below the dataframe
	total_rows = len(st.session_state['portfolio'])
	rows_per_page = 500
	total_pages = (total_rows + rows_per_page - 1) // rows_per_page # Ceiling division

	# Initialize page number in session state if not exists
	if 'current_page' not in st.session_state:
	st.session_state.current_page = 1

	# Display current page range info and pagination control in a single line
	st.write(
	f"Showing rows {(st.session_state.current_page - 1) * rows_per_page + 1} "
	f"to {min(st.session_state.current_page * rows_per_page, total_rows)} of {total_rows}"
	)

	# Add page number input
	st.session_state.current_page = st.number_input(
	f"Page (1-{total_pages})",
	min_value=1,
	max_value=total_pages,
	value=st.session_state.current_page
	)

	# Calculate start and end indices for current page
	start_idx = (st.session_state.current_page - 1) * rows_per_page
	end_idx = min(start_idx + rows_per_page, total_rows)

	# Get the subset of data for the current page
	current_page_data = st.session_state['portfolio'].iloc[start_idx:end_idx]

	# Create player summary dataframe
	player_stats = []
	player_columns = [col for col in st.session_state['portfolio'].columns if col not in excluded_cols]

	if type_var == 'Showdown':
	# Handle Captain positions
	for player in player_names:
	# Create mask for lineups where this player is Captain (first column)
	cpt_mask = st.session_state['portfolio'][player_columns[0]] == player

	if cpt_mask.any():
	player_stats.append({
	'Player': f"{player} (CPT)",
	'Lineup Count': cpt_mask.sum(),
	'Avg Median': st.session_state['portfolio'][cpt_mask]['median'].mean(),
	'Avg Own': st.session_state['portfolio'][cpt_mask]['Own'].mean(),
	'Avg Dupes': st.session_state['portfolio'][cpt_mask]['Dupes'].mean(),
	'Avg Finish %': st.session_state['portfolio'][cpt_mask]['Finish_percentile'].mean(),
	'Avg Lineup Edge': st.session_state['portfolio'][cpt_mask]['Lineup Edge'].mean(),
	})

	# Create mask for lineups where this player is FLEX (other columns)
	flex_mask = st.session_state['portfolio'][player_columns[1:]].apply(
	lambda row: player in list(row), axis=1
	)

	if flex_mask.any():
	player_stats.append({
	'Player': f"{player} (FLEX)",
	'Lineup Count': flex_mask.sum(),
	'Avg Median': st.session_state['portfolio'][flex_mask]['median'].mean(),
	'Avg Own': st.session_state['portfolio'][flex_mask]['Own'].mean(),
	'Avg Dupes': st.session_state['portfolio'][flex_mask]['Dupes'].mean(),
	'Avg Finish %': st.session_state['portfolio'][flex_mask]['Finish_percentile'].mean(),
	'Avg Lineup Edge': st.session_state['portfolio'][flex_mask]['Lineup Edge'].mean(),
	})
	else:
	# Original Classic format processing
	for player in player_names:
	player_mask = st.session_state['portfolio'][player_columns].apply(
	lambda row: player in list(row), axis=1
	)

	if player_mask.any():
	player_stats.append({
	'Player': player,
	'Lineup Count': player_mask.sum(),
	'Avg Median': st.session_state['portfolio'][player_mask]['median'].mean(),
	'Avg Own': st.session_state['portfolio'][player_mask]['Own'].mean(),
	'Avg Dupes': st.session_state['portfolio'][player_mask]['Dupes'].mean(),
	'Avg Finish %': st.session_state['portfolio'][player_mask]['Finish_percentile'].mean(),
	'Avg Lineup Edge': st.session_state['portfolio'][player_mask]['Lineup Edge'].mean(),
	})

	player_summary = pd.DataFrame(player_stats)
	player_summary = player_summary.sort_values('Lineup Count', ascending=False)

	st.subheader("Player Summary")
	st.dataframe(
	player_summary.style
	.background_gradient(axis=0).background_gradient(cmap='RdYlGn').background_gradient(cmap='RdYlGn_r', subset=['Avg Finish %', 'Avg Own', 'Avg Dupes'])
	.format({
	'Avg Median': '{:.2f}',
	'Avg Own': '{:.2f}',
	'Avg Dupes': '{:.2f}',
	'Avg Finish %': '{:.2%}',
	'Avg Lineup Edge': '{:.2%}'
	}),
	height=400,
	use_container_width=True
	)