James McCool
Enhance column configuration in app.py by adding 'Similarity Score' for projected lineup diversity. This update includes help text, width specifications, and value constraints to improve user interaction and clarity.
6b15752
| 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 | |
| from global_func.small_field_preset import small_field_preset | |
| from global_func.large_field_preset import large_field_preset | |
| from global_func.hedging_preset import hedging_preset | |
| from global_func.volatility_preset import volatility_preset | |
| 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") | |
| 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.") | |
| 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 | |
| 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' 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'): | |
| st.session_state['working_frame'] = st.session_state['base_frame'].copy() | |
| 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', 'Similarity Score'] | |
| 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['base_frame'] = predict_dupes(st.session_state['working_frame'], st.session_state['map_dict'], site_var, type_var, Contest_Size, strength_var, sport_var) | |
| st.session_state['working_frame'] = st.session_state['base_frame'].copy() | |
| # st.session_state['highest_owned_teams'] = st.session_state['projections_df'][~st.session_state['projections_df']['position'].isin(['P', 'SP'])].groupby('team')['ownership'].sum().sort_values(ascending=False).head(3).index.tolist() | |
| # st.session_state['highest_owned_pitchers'] = st.session_state['projections_df'][st.session_state['projections_df']['position'].isin(['P', 'SP'])]['player_names'].sort_values(by='ownership', ascending=False).head(3).tolist() | |
| 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'], | |
| 'Similarity Score': st.session_state['working_frame']['Similarity Score'] | |
| } | |
| 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(), | |
| 'Similarity Score': st.session_state['working_frame']['Similarity Score'].max() | |
| } | |
| with st.sidebar: | |
| 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, | |
| 'Similarity Score': 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).reset_index(drop=True) | |
| 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).reset_index(drop=True) | |
| st.session_state['export_merge'] = st.session_state['working_frame'].copy() | |
| with st.expander('Trimming Options'): | |
| 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', 'Similarity Score'], 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 st.expander('Presets'): | |
| st.info("Still heavily in testing here, I'll announce when they are ready for use.") | |
| with st.form(key='Small Field Preset'): | |
| preset_choice = st.selectbox("Preset", options=['Small Field (Heavy Own)', 'Large Field (Manage Similarity)', 'Hedge Chalk (Manage Leverage)', 'Volatility (Heavy Lineup Edge)'], index=0) | |
| lineup_target = st.number_input("Lineups to produce", value=150, min_value=1, step=1) | |
| submitted = st.form_submit_button("Submit") | |
| if submitted: | |
| if preset_choice == 'Small Field (Heavy Own)': | |
| parsed_frame = small_field_preset(st.session_state['working_frame'], lineup_target, excluded_cols) | |
| elif preset_choice == 'Large Field (Manage Similarity)': | |
| parsed_frame = large_field_preset(st.session_state['working_frame'], lineup_target, excluded_cols) | |
| elif preset_choice == 'Volatility (Heavy Lineup Edge)': | |
| parsed_frame = volatility_preset(st.session_state['working_frame'], lineup_target, excluded_cols) | |
| elif preset_choice == 'Hedge Chalk (Manage Leverage)': | |
| parsed_frame = hedging_preset(st.session_state['working_frame'], lineup_target, st.session_state['projections_df']) | |
| st.session_state['working_frame'] = parsed_frame.reset_index(drop=True) | |
| st.session_state['export_merge'] = st.session_state['working_frame'].copy() | |
| with st.container(): | |
| 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, partial_col, clear_export, blank_export_col = st.columns([1, 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 all 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 partial_col: | |
| if 'export_merge' in st.session_state: | |
| select_custom_index = st.number_input("Select rows to add (from top)", min_value=0, max_value=len(st.session_state['export_merge']), value=0) | |
| if st.button("Add selected to Custom Export"): | |
| st.session_state['export_base'] = pd.concat([st.session_state['export_base'], st.session_state['export_merge'].head(select_custom_index)]) | |
| 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), | |
| column_config={ | |
| "Finish_percentile": st.column_config.NumberColumn( | |
| "Finish%", | |
| help="Projected finishing percentile", | |
| width="small", | |
| min_value=0.0, | |
| max_value=1.0 | |
| ), | |
| "Lineup Edge": st.column_config.NumberColumn( | |
| "Edge", | |
| help="Projected lineup edge", | |
| width="small", | |
| min_value=-1.0, | |
| max_value=1.0 | |
| ), | |
| "Similarity Score": st.column_config.NumberColumn( | |
| "Diversity", | |
| help="Projected lineup diversity", | |
| width="small", | |
| min_value=0.0, | |
| max_value=1.0 | |
| ), | |
| }, | |
| height=500, | |
| use_container_width=True, | |
| hide_index=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']) |