import streamlit as st st.set_page_config(layout="wide") import numpy as np import pandas as pd import time from rapidfuzz import process, fuzz import random import re from collections import Counter ## 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.load_dk_fd_file import load_dk_fd_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 from global_func.trim_portfolio import trim_portfolio from global_func.get_portfolio_names import get_portfolio_names freq_format = {'Finish_percentile': '{:.2%}', 'Lineup Edge': '{:.2%}', 'Win%': '{:.2%}'} stacking_sports = ['MLB', 'NHL', 'NFL'] player_wrong_names_mlb = ['Enrique Hernandez'] player_right_names_mlb = ['Kike Hernandez'] with st.container(): col1, col2, col3, col4 = st.columns(4) with col1: if st.button('Clear data', key='reset3'): st.session_state.clear() with col2: site_var = st.selectbox("Select Site", ['Draftkings', 'Fanduel']) with col3: sport_var = st.selectbox("Select Sport", ['NFL', 'MLB', 'NBA', 'NHL', 'MMA', 'CS2', 'TENNIS', 'GOLF', 'WNBA']) with col4: type_var = st.selectbox("Select Game Type", ['Classic', 'Showdown']) tab1, tab2 = st.tabs(["Data Load", "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.") upload_toggle = st.selectbox("What source are you uploading from?", options=['SaberSim (Just IDs)', 'Draftkings/Fanduel (Names + IDs)', 'Other (Just Names)']) if upload_toggle == 'SaberSim (Just IDs)' or upload_toggle == 'Draftkings/Fanduel (Names + IDs)': 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' not in st.session_state: if portfolio_file: if upload_toggle == 'SaberSim (Just IDs)': 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) elif upload_toggle == 'Draftkings/Fanduel (Names + IDs)': st.session_state['export_portfolio'], st.session_state['portfolio'] = load_dk_fd_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!') try: projections['salary'] = projections['salary'].str.replace(',', '').str.replace('$', '').str.replace(' ', '') st.write('replaced salary symbols') except: pass try: projections['ownership'] = projections['ownership'].str.replace('%', '').str.replace(' ', '') st.write('replaced ownership symbols') except: pass projections['salary'] = projections['salary'].dropna().astype(int) projections['ownership'] = projections['ownership'].astype(float) if type_var == 'Showdown': if projections['captain ownership'].isna().all(): projections['CPT_Own_raw'] = (projections['ownership'] / 2) * ((100 - (100-projections['ownership']))/100) cpt_own_var = 100 / projections['CPT_Own_raw'].sum() projections['captain ownership'] = projections['CPT_Own_raw'] * cpt_own_var projections = projections.drop(columns='CPT_Own_raw', axis=1) 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 # Get unique names from portfolio portfolio_names = get_portfolio_names(st.session_state['portfolio']) try: csv_names = st.session_state['csv_file']['Name'].tolist() except: csv_names = st.session_state['csv_file']['Nickname'].tolist() projection_names = projections['player_names'].tolist() # Create match dictionary for portfolio names to projection names portfolio_match_dict = {} unmatched_names = [] for portfolio_name in portfolio_names: match = process.extractOne( portfolio_name, csv_names, score_cutoff=87 ) if match: portfolio_match_dict[portfolio_name] = match[0] if match[1] < 100: st.write(f"{portfolio_name} matched from portfolio to site csv {match[0]} with a score of {match[1]}%") else: portfolio_match_dict[portfolio_name] = portfolio_name unmatched_names.append(portfolio_name) # Update portfolio with matched names portfolio = st.session_state['portfolio'].copy() player_columns = [col for col in portfolio.columns if col not in ['salary', 'median', 'Own']] # For each player column, update names using the match dictionary for col in player_columns: portfolio[col] = portfolio[col].map(lambda x: portfolio_match_dict.get(x, x)) st.session_state['portfolio'] = portfolio # Create match dictionary for portfolio names to projection names projections_match_dict = {} unmatched_proj_names = [] for projections_name in projection_names: match = process.extractOne( projections_name, csv_names, score_cutoff=87 ) if match: projections_match_dict[projections_name] = match[0] if match[1] < 100: st.write(f"{projections_name} matched from projections to site csv {match[0]} with a score of {match[1]}%") else: projections_match_dict[projections_name] = projections_name unmatched_proj_names.append(projections_name) # Update projections with matched names projections['player_names'] = projections['player_names'].map(lambda x: projections_match_dict.get(x, x)) st.session_state['projections_df'] = projections projections_names = st.session_state['projections_df']['player_names'].tolist() portfolio_names = get_portfolio_names(st.session_state['portfolio']) # Create match dictionary for portfolio names to projection names projections_match_dict = {} unmatched_proj_names = [] for projections_name in projection_names: match = process.extractOne( projections_name, portfolio_names, score_cutoff=87 ) if match: projections_match_dict[projections_name] = match[0] if match[1] < 100: st.write(f"{projections_name} matched from portfolio to projections {match[0]} with a score of {match[1]}%") else: projections_match_dict[projections_name] = projections_name unmatched_proj_names.append(projections_name) # Update projections with matched names projections['player_names'] = projections['player_names'].map(lambda x: projections_match_dict.get(x, x)) st.session_state['projections_df'] = projections if sport_var in stacking_sports: team_dict = dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])) st.session_state['portfolio']['Stack'] = st.session_state['portfolio'].apply( lambda row: Counter( team_dict.get(player, '') for player in row[2:] if team_dict.get(player, '') != '' ).most_common(1)[0][0] if any(team_dict.get(player, '') for player in row[2:]) else '', axis=1 ) st.session_state['portfolio']['Size'] = st.session_state['portfolio'].apply( lambda row: Counter( team_dict.get(player, '') for player in row[2:] if team_dict.get(player, '') != '' ).most_common(1)[0][1] if any(team_dict.get(player, '') for player in row[2:]) else 0, axis=1 ) stack_dict = dict(zip(st.session_state['portfolio'].index, st.session_state['portfolio']['Stack'])) size_dict = dict(zip(st.session_state['portfolio'].index, st.session_state['portfolio']['Size'])) working_frame = st.session_state['portfolio'].copy() try: st.session_state['export_dict'] = dict(zip(st.session_state['csv_file']['Name'], st.session_state['csv_file']['Name + ID'])) except: st.session_state['export_dict'] = dict(zip(st.session_state['csv_file']['Nickname'], st.session_state['csv_file']['Id'])) st.session_state['origin_portfolio'] = st.session_state['portfolio'].copy() # 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 tab2: if 'portfolio' in st.session_state and 'projections_df' in st.session_state: with st.container(): col1, col2 = st.columns(2) with col1: if st.button('Reset Portfolio', key='reset_port'): del st.session_state['working_frame'] with col2: with st.form(key='contest_size_form'): size_col, strength_col, submit_col = st.columns(3) with size_col: Contest_Size = st.number_input("Enter Contest Size", value=25000, min_value=1, step=1) with strength_col: strength_var = st.selectbox("Select field strength", ['Average', 'Sharp', 'Weak']) with submit_col: submitted = st.form_submit_button("Submit Size/Strength") if submitted: del st.session_state['working_frame'] excluded_cols = ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Stack', 'Size', 'Win%', 'Lineup Edge', 'Weighted Own', 'Geomean'] if 'working_frame' not in st.session_state: st.session_state['working_frame'] = st.session_state['origin_portfolio'].copy() if site_var == 'Draftkings': if type_var == 'Classic': if sport_var == 'CS2': st.session_state['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 != 'CS2': st.session_state['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 == 'GOLF': st.session_state['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'])), 'cpt_own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'])) } if sport_var != 'GOLF': st.session_state['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 site_var == 'Fanduel': st.session_state['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': if sport_var == 'CS2': # Calculate salary (CPT uses cpt_salary_map, others use salary_map) st.session_state['working_frame']['salary'] = st.session_state['working_frame'].apply( lambda row: st.session_state['map_dict']['cpt_salary_map'].get(row.iloc[0], 0) + sum(st.session_state['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['working_frame']['median'] = st.session_state['working_frame'].apply( lambda row: st.session_state['map_dict']['cpt_proj_map'].get(row.iloc[0], 0) + sum(st.session_state['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['working_frame']['Own'] = st.session_state['working_frame'].apply( lambda row: st.session_state['map_dict']['cpt_own_map'].get(row.iloc[0], 0) + sum(st.session_state['map_dict']['own_map'].get(player, 0) for player in row.iloc[1:]), axis=1 ) elif sport_var != 'CS2': st.session_state['working_frame']['salary'] = st.session_state['working_frame'].apply(lambda row: sum(st.session_state['map_dict']['salary_map'].get(player, 0) for player in row), axis=1) st.session_state['working_frame']['median'] = st.session_state['working_frame'].apply(lambda row: sum(st.session_state['map_dict']['proj_map'].get(player, 0) for player in row), axis=1) st.session_state['working_frame']['Own'] = st.session_state['working_frame'].apply(lambda row: sum(st.session_state['map_dict']['own_map'].get(player, 0) for player in row), axis=1) if stack_dict is not None: st.session_state['working_frame']['Stack'] = st.session_state['working_frame'].index.map(stack_dict) st.session_state['working_frame']['Size'] = st.session_state['working_frame'].index.map(size_dict) elif type_var == 'Showdown': # Calculate salary (CPT uses cpt_salary_map, others use salary_map) st.session_state['working_frame']['salary'] = st.session_state['working_frame'].apply( lambda row: st.session_state['map_dict']['cpt_salary_map'].get(row.iloc[0], 0) + sum(st.session_state['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['working_frame']['median'] = st.session_state['working_frame'].apply( lambda row: st.session_state['map_dict']['cpt_proj_map'].get(row.iloc[0], 0) + sum(st.session_state['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['working_frame']['Own'] = st.session_state['working_frame'].apply( lambda row: st.session_state['map_dict']['cpt_own_map'].get(row.iloc[0], 0) + sum(st.session_state['map_dict']['own_map'].get(player, 0) for player in row.iloc[1:]), axis=1 ) st.session_state['working_frame'] = predict_dupes(st.session_state['working_frame'], st.session_state['map_dict'], site_var, type_var, Contest_Size, strength_var, sport_var) if 'info_columns_dict' not in st.session_state: st.session_state['info_columns_dict'] = { 'Dupes': st.session_state['working_frame']['Dupes'], 'Finish_percentile': st.session_state['working_frame']['Finish_percentile'], 'Win%': st.session_state['working_frame']['Win%'], 'Lineup Edge': st.session_state['working_frame']['Lineup Edge'], 'Weighted Own': st.session_state['working_frame']['Weighted Own'], 'Geomean': st.session_state['working_frame']['Geomean'], } if 'trimming_dict_maxes' not in st.session_state: st.session_state['trimming_dict_maxes'] = { 'Own': st.session_state['working_frame']['Own'].max(), 'Geomean': st.session_state['working_frame']['Geomean'].max(), 'Weighted Own': st.session_state['working_frame']['Weighted Own'].max(), 'median': st.session_state['working_frame']['median'].max(), 'Finish_percentile': st.session_state['working_frame']['Finish_percentile'].max() } col1, col2 = st.columns([2, 8]) with col1: if 'trimming_dict_maxes' not in st.session_state: st.session_state['trimming_dict_maxes'] = { 'Own': 500.0, 'Geomean': 500.0, 'Weighted Own': 500.0, 'median': 500.0, 'Finish_percentile': 1.0 } with st.expander('Macro Filter Options'): with st.form(key='macro_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=100000, min_value=1000, step=100) max_finish_percentile = st.number_input("Max acceptable finish percentile?", value=.50, min_value=0.005, step=.001) min_lineup_edge = st.number_input("Min acceptable Lineup Edge?", value=-.5, min_value=-1.00, step=.001) if sport_var in ['NFL', 'MLB', 'NHL']: stack_include_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_toggle = st.selectbox("Remove specific stacks?", options=['No', 'Yes'], index=0) stack_remove = st.multiselect("If Specific Stacks, Which to remove?", options=sorted(list(set(stack_dict.values()))), default=[]) submitted = st.form_submit_button("Submit") if submitted: parsed_frame = st.session_state['working_frame'].copy() parsed_frame = parsed_frame[parsed_frame['Dupes'] <= max_dupes] parsed_frame = parsed_frame[parsed_frame['salary'] >= min_salary] parsed_frame = parsed_frame[parsed_frame['salary'] <= max_salary] parsed_frame = parsed_frame[parsed_frame['Finish_percentile'] <= max_finish_percentile] parsed_frame = parsed_frame[parsed_frame['Lineup Edge'] >= min_lineup_edge] if 'Stack' in parsed_frame.columns: if stack_include_toggle == 'All Stacks': parsed_frame = parsed_frame else: parsed_frame = parsed_frame[parsed_frame['Stack'].isin(stack_selections)] if stack_remove_toggle == 'Yes': parsed_frame = parsed_frame[~parsed_frame['Stack'].isin(stack_remove)] else: parsed_frame = parsed_frame st.session_state['working_frame'] = parsed_frame.sort_values(by='median', ascending=False) st.session_state['export_merge'] = st.session_state['working_frame'].copy() with st.expander('Micro Filter Options'): with st.form(key='micro_filter_form'): player_names = set() for col in st.session_state['working_frame'].columns: if col not in excluded_cols: player_names.update(st.session_state['working_frame'][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=[]) team_include = st.multiselect("Include teams?", options=sorted(list(set(st.session_state['projections_df']['team'].unique()))), default=[]) team_remove = st.multiselect("Remove teams?", options=sorted(list(set(st.session_state['projections_df']['team'].unique()))), default=[]) if sport_var in ['NFL', 'MLB', 'NHL']: size_include = st.multiselect("Include sizes?", options=sorted(list(set(st.session_state['working_frame']['Size'].unique()))), default=[]) else: size_include = [] submitted = st.form_submit_button("Submit") if submitted: parsed_frame = st.session_state['working_frame'].copy() if player_remove: # Create mask for lineups that contain any of the removed players player_columns = [col for col in parsed_frame.columns if col not in excluded_cols] remove_mask = parsed_frame[player_columns].apply( lambda row: not any(player in list(row) for player in player_remove), axis=1 ) parsed_frame = parsed_frame[remove_mask] if player_lock: # Create mask for lineups that contain all locked players player_columns = [col for col in parsed_frame.columns if col not in excluded_cols] lock_mask = parsed_frame[player_columns].apply( lambda row: all(player in list(row) for player in player_lock), axis=1 ) parsed_frame = parsed_frame[lock_mask] if team_include: # Create a copy of the frame with player names replaced by teams, excluding SP1 and SP2 filtered_player_columns = [col for col in player_columns if col not in ['SP1', 'SP2']] team_frame = parsed_frame[filtered_player_columns].apply( lambda x: x.map(st.session_state['map_dict']['team_map']) ) # Create mask for lineups that contain any of the included teams include_mask = team_frame.apply( lambda row: any(team in list(row) for team in team_include), axis=1 ) parsed_frame = parsed_frame[include_mask] if team_remove: # Create a copy of the frame with player names replaced by teams, excluding SP1 and SP2 filtered_player_columns = [col for col in player_columns if col not in ['SP1', 'SP2']] team_frame = parsed_frame[filtered_player_columns].apply( lambda x: x.map(st.session_state['map_dict']['team_map']) ) # Create mask for lineups that don't contain any of the removed teams remove_mask = team_frame.apply( lambda row: not any(team in list(row) for team in team_remove), axis=1 ) parsed_frame = parsed_frame[remove_mask] if size_include: parsed_frame = parsed_frame[parsed_frame['Size'].isin(size_include)] st.session_state['working_frame'] = parsed_frame.sort_values(by='median', ascending=False) st.session_state['export_merge'] = st.session_state['working_frame'].copy() with st.expander('Trimming Options'): st.info("Make sure you filter before trimming if you want to filter, trimming before a filter will reset your portfolio") with st.form(key='trim_form'): st.write("Sorting and trimming variables:") perf_var, own_var = st.columns(2) with perf_var: performance_type = st.selectbox("Sorting variable", ['median', 'Finish_percentile'], key='sort_var') with own_var: own_type = st.selectbox("Trimming variable", ['Own', 'Geomean', 'Weighted Own'], key='trim_var') trim_slack_var = st.number_input("Trim slack (percentile addition to trimming variable ceiling)", value=0.0, min_value=0.0, max_value=1.0, step=0.1, key='trim_slack') st.write("Sorting threshold range:") min_sort, max_sort = st.columns(2) with min_sort: performance_threshold_low = st.number_input("Min", value=0.0, min_value=0.0, step=1.0, key='min_sort') with max_sort: performance_threshold_high = st.number_input("Max", value=st.session_state['trimming_dict_maxes'][performance_type], min_value=0.0, step=1.0, key='max_sort') st.write("Trimming threshold range:") min_trim, max_trim = st.columns(2) with min_trim: own_threshold_low = st.number_input("Min", value=0.0, min_value=0.0, step=1.0, key='min_trim') with max_trim: own_threshold_high = st.number_input("Max", value=st.session_state['trimming_dict_maxes'][own_type], min_value=0.0, step=1.0, key='max_trim') submitted = st.form_submit_button("Trim") if submitted: st.write('initiated') parsed_frame = st.session_state['working_frame'].copy() st.session_state['working_frame'] = trim_portfolio(parsed_frame, trim_slack_var, performance_type, own_type, performance_threshold_high, performance_threshold_low, own_threshold_high, own_threshold_low) st.session_state['working_frame'] = st.session_state['working_frame'].sort_values(by='median', ascending=False) st.session_state['export_merge'] = st.session_state['working_frame'].copy() with col2: # with st.expander("Download options"): # if stack_dict is not None: # download_type = st.selectbox("Simple or Advanced Download?", options=['Simple', 'Advanced'], key='download_choice') # if download_type == 'Simple': # st.session_state['export_file'] = st.session_state['working_frame'].copy() # for col in st.session_state['export_file'].columns: # if col not in excluded_cols: # st.session_state['export_file'][col] = st.session_state['export_file'][col].map(st.session_state['export_dict']) # else: # 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['working_frame'][st.session_state['working_frame']['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 # ) # portfolio_copy = st.session_state['working_frame'].copy() # submitted = st.form_submit_button("Submit") # if submitted: # # 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_concat = pd.concat(selected_rows) # # Update export_file with filtered data # st.session_state['export_file'] = portfolio_concat.copy() # for col in st.session_state['export_file'].columns: # if col not in excluded_cols: # st.session_state['export_file'][col] = st.session_state['export_file'][col].map(st.session_state['export_dict']) # st.write('Export portfolio updated!') # else: # st.session_state['export_file'] = st.session_state['working_frame'].copy() # if 'export_base' not in st.session_state: # st.session_state['export_base'] = pd.DataFrame(columns=st.session_state['working_frame'].columns) # for col in st.session_state['export_file'].columns: # if col not in excluded_cols: # st.session_state['export_file'][col] = st.session_state['export_file'][col].map(st.session_state['export_dict']) if 'export_base' not in st.session_state: st.session_state['export_base'] = pd.DataFrame(columns=st.session_state['working_frame'].columns) display_frame_source = st.selectbox("Display:", options=['Portfolio', 'Export Base'], key='display_frame_source') if display_frame_source == 'Portfolio': display_frame = st.session_state['working_frame'] st.session_state['export_file'] = display_frame.copy() for col in st.session_state['export_file'].columns: if col not in excluded_cols: st.session_state['export_file'][col] = st.session_state['export_file'][col].map(st.session_state['export_dict']) elif display_frame_source == 'Export Base': display_frame = st.session_state['export_base'] st.session_state['export_file'] = display_frame.copy() for col in st.session_state['export_file'].columns: if col not in excluded_cols: st.session_state['export_file'][col] = st.session_state['export_file'][col].map(st.session_state['export_dict']) if 'export_file' in st.session_state: download_port, merge_port, clear_export, blank_export_col = st.columns([1, 1, 1, 8]) with download_port: st.download_button(label="Download Portfolio", data=st.session_state['export_file'].to_csv(index=False), file_name="portfolio.csv", mime="text/csv") with merge_port: if st.button("Add to Custom Export"): st.session_state['export_base'] = pd.concat([st.session_state['export_base'], st.session_state['export_merge']]) st.session_state['export_base'] = st.session_state['export_base'].drop_duplicates() st.session_state['export_base'] = st.session_state['export_base'].reset_index(drop=True) with clear_export: if st.button("Clear Custom Export"): st.session_state['export_base'] = pd.DataFrame(columns=st.session_state['working_frame'].columns) if display_frame_source == 'Portfolio': display_frame = st.session_state['working_frame'] elif display_frame_source == 'Export Base': display_frame = st.session_state['export_base'] total_rows = len(display_frame) 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 = display_frame.iloc[start_idx:end_idx] # Display the paginated dataframe first st.dataframe( current_page_data.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 ) player_stats_col, stack_stats_col = st.tabs(['Player Stats', 'Stack Stats']) with player_stats_col: player_stats = [] player_columns = [col for col in display_frame.columns if col not in excluded_cols] if type_var == 'Showdown': for player in player_names: # Create mask for lineups where this player is Captain (first column) cpt_mask = display_frame[player_columns[0]] == player if cpt_mask.any(): player_stats.append({ 'Player': f"{player} (CPT)", 'Lineup Count': cpt_mask.sum(), 'Exposure': cpt_mask.sum() / len(display_frame), 'Avg Median': display_frame[cpt_mask]['median'].mean(), 'Avg Own': display_frame[cpt_mask]['Own'].mean(), 'Avg Dupes': display_frame[cpt_mask]['Dupes'].mean(), 'Avg Finish %': display_frame[cpt_mask]['Finish_percentile'].mean(), 'Avg Lineup Edge': display_frame[cpt_mask]['Lineup Edge'].mean(), }) # Create mask for lineups where this player is FLEX (other columns) flex_mask = display_frame[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(), 'Exposure': flex_mask.sum() / len(display_frame), 'Avg Median': display_frame[flex_mask]['median'].mean(), 'Avg Own': display_frame[flex_mask]['Own'].mean(), 'Avg Dupes': display_frame[flex_mask]['Dupes'].mean(), 'Avg Finish %': display_frame[flex_mask]['Finish_percentile'].mean(), 'Avg Lineup Edge': display_frame[flex_mask]['Lineup Edge'].mean(), }) else: if sport_var == 'CS2': # Handle Captain positions for player in player_names: # Create mask for lineups where this player is Captain (first column) cpt_mask = display_frame[player_columns[0]] == player if cpt_mask.any(): player_stats.append({ 'Player': f"{player} (CPT)", 'Lineup Count': cpt_mask.sum(), 'Exposure': cpt_mask.sum() / len(display_frame), 'Avg Median': display_frame[cpt_mask]['median'].mean(), 'Avg Own': display_frame[cpt_mask]['Own'].mean(), 'Avg Dupes': display_frame[cpt_mask]['Dupes'].mean(), 'Avg Finish %': display_frame[cpt_mask]['Finish_percentile'].mean(), 'Avg Lineup Edge': display_frame[cpt_mask]['Lineup Edge'].mean(), }) # Create mask for lineups where this player is FLEX (other columns) flex_mask = display_frame[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(), 'Exposure': flex_mask.sum() / len(display_frame), 'Avg Median': display_frame[flex_mask]['median'].mean(), 'Avg Own': display_frame[flex_mask]['Own'].mean(), 'Avg Dupes': display_frame[flex_mask]['Dupes'].mean(), 'Avg Finish %': display_frame[flex_mask]['Finish_percentile'].mean(), 'Avg Lineup Edge': display_frame[flex_mask]['Lineup Edge'].mean(), }) elif sport_var != 'CS2': # Original Classic format processing for player in player_names: player_mask = display_frame[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(), 'Exposure': player_mask.sum() / len(display_frame), 'Avg Median': display_frame[player_mask]['median'].mean(), 'Avg Own': display_frame[player_mask]['Own'].mean(), 'Avg Dupes': display_frame[player_mask]['Dupes'].mean(), 'Avg Finish %': display_frame[player_mask]['Finish_percentile'].mean(), 'Avg Lineup Edge': display_frame[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%}', 'Exposure': '{:.2%}' }), height=400, use_container_width=True ) with stack_stats_col: if 'Stack' in display_frame.columns: stack_stats = [] stack_columns = [col for col in display_frame.columns if col.startswith('Stack')] for stack in stack_dict.values(): stack_mask = display_frame['Stack'] == stack if stack_mask.any(): stack_stats.append({ 'Stack': stack, 'Lineup Count': stack_mask.sum(), 'Exposure': stack_mask.sum() / len(display_frame), 'Avg Median': display_frame[stack_mask]['median'].mean(), 'Avg Own': display_frame[stack_mask]['Own'].mean(), 'Avg Dupes': display_frame[stack_mask]['Dupes'].mean(), 'Avg Finish %': display_frame[stack_mask]['Finish_percentile'].mean(), 'Avg Lineup Edge': display_frame[stack_mask]['Lineup Edge'].mean(), }) stack_summary = pd.DataFrame(stack_stats) stack_summary = stack_summary.sort_values('Lineup Count', ascending=False).drop_duplicates() st.subheader("Stack Summary") st.dataframe( stack_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%}', 'Exposure': '{:.2%}' }), height=400, use_container_width=True ) else: stack_summary = pd.DataFrame(columns=['Stack', 'Lineup Count', 'Avg Median', 'Avg Own', 'Avg Dupes', 'Avg Finish %', 'Avg Lineup Edge'])