James McCool
Update sport selection options in app.py to remove duplicate 'NBA' entry, ensuring clarity and consistency in user choices.
56fb76a
| import streamlit as st | |
| st.set_page_config(layout="wide") | |
| import pandas as pd | |
| from rapidfuzz import process | |
| import random | |
| from collections import Counter | |
| import io | |
| ## 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 | |
| from global_func.reduce_volatility_preset import reduce_volatility_preset | |
| from global_func.analyze_player_combos import analyze_player_combos | |
| from global_func.stratification_function import stratification_function | |
| from global_func.exposure_spread import exposure_spread | |
| from global_func.reassess_edge import reassess_edge | |
| freq_format = {'Finish_percentile': '{:.2%}', 'Lineup Edge': '{:.2%}', 'Win%': '{:.2%}'} | |
| stacking_sports = ['MLB', 'NHL', 'NFL', 'LOL', 'NCAAF'] | |
| all_column_stack_sports = ['LOL', 'NCAAF', 'WNBA', 'NBA', 'CS2'] | |
| player_wrong_names_mlb = ['Enrique Hernandez', 'Joseph Cantillo', 'Mike Soroka', 'Jakob Bauers', 'Temi Fágbénlé'] | |
| player_right_names_mlb = ['Kike Hernandez', 'Joey Cantillo', 'Michael Soroka', 'Jake Bauers', 'Temi Fagbenle'] | |
| def create_position_export_dict(column_name, csv_file, site_var, type_var, sport_var): | |
| try: | |
| # Remove any numbers from the column name to get the position | |
| import re | |
| position_filter = re.sub(r'\d+$', '', column_name) | |
| # Filter CSV file by position | |
| if 'Position' in csv_file.columns: | |
| if type_var == 'Showdown': | |
| filtered_df = csv_file.copy() | |
| else: | |
| if position_filter == 'SP': | |
| filtered_df = csv_file[ | |
| csv_file['Roster Position'] == 'P' | |
| ] | |
| elif position_filter == 'CPT': | |
| filtered_df = csv_file.copy() | |
| elif position_filter == 'FLEX' or position_filter == 'UTIL': | |
| if sport_var == 'NFL': | |
| filtered_df = csv_file['Position'].isin(['RB', 'WR', 'TE']) | |
| elif sport_var == 'SOC': | |
| filtered_df = csv_file['Position'].str.contains(['D', 'M', 'F'], na=False, regex=False) | |
| elif sport_var == 'NCAAF': | |
| filtered_df = csv_file['Position'].isin(['RB', 'WR']) | |
| elif sport_var == 'NHL': | |
| filtered_df = csv_file['Position'].str.contains(['C', 'W', 'D'], na=False, regex=False) | |
| else: | |
| filtered_df = csv_file.copy() | |
| elif position_filter == 'SFLEX': | |
| filtered_df = csv_file.copy() | |
| elif position_filter == 'C/1B': | |
| filtered_df = csv_file[ | |
| csv_file['Position'].str.contains(['C', '1B'], na=False, regex=False) | |
| ] | |
| else: | |
| filtered_df = csv_file[ | |
| csv_file['Position'].str.contains(position_filter, na=False, regex=False) | |
| ] | |
| else: | |
| # Fallback to all players if no position column found | |
| filtered_df = csv_file | |
| # Create the export dictionary for this position | |
| try: | |
| filtered_df = filtered_df.sort_values(by='Salary', ascending=False).drop_duplicates(subset=['Name']) | |
| return dict(zip(filtered_df['Name'], filtered_df['Name + ID'])) | |
| except: | |
| try: | |
| filtered_df = filtered_df.sort_values(by='Salary', ascending=False).drop_duplicates(subset=['Nickname']) | |
| return dict(zip(filtered_df['Nickname'], filtered_df['Id'])) | |
| except: | |
| # Final fallback | |
| return {} | |
| except Exception as e: | |
| st.error(f"Error creating position export dict for {column_name}: {str(e)}") | |
| return {} | |
| 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', 'NCAAF', 'MMA', 'CS2', 'LOL', 'TENNIS', 'NASCAR', 'GOLF', 'WNBA', 'F1']) | |
| with col4: | |
| type_var = st.selectbox("Select Game Type", ['Classic', 'Showdown']) | |
| if sport_var == 'GOLF': | |
| position_var = 'G' | |
| team_var = 'GOLF' | |
| elif sport_var == 'TENNIS': | |
| position_var = 'T' | |
| team_var = 'TENNIS' | |
| elif sport_var == 'MMA': | |
| position_var = 'F' | |
| team_var = 'MMA' | |
| elif sport_var == 'NASCAR': | |
| position_var = 'D' | |
| team_var = 'NASCAR' | |
| elif sport_var == 'F1': | |
| position_var = 'D' | |
| team_var = 'F1' | |
| else: | |
| position_var = None | |
| team_var = None | |
| if site_var == 'Draftkings': | |
| salary_max = 50000 | |
| elif site_var == 'Fanduel': | |
| if type_var == 'Classic': | |
| if sport_var == 'MLB': | |
| salary_max = 40000 | |
| elif sport_var == 'WNBA': | |
| salary_max = 40000 | |
| elif sport_var == 'GOLF': | |
| salary_max = 60000 | |
| elif sport_var == 'MMA': | |
| salary_max = 100 | |
| elif sport_var == 'NFL': | |
| salary_max = 60000 | |
| elif sport_var == 'NASCAR': | |
| salary_max = 50000 | |
| else: | |
| salary_max = 60000 | |
| elif type_var == 'Showdown': | |
| salary_max = 60000 | |
| 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: | |
| if type_var == 'Showdown': | |
| st.session_state['csv_file']['Position'] = 'FLEX' | |
| else: | |
| if sport_var == 'GOLF': | |
| st.session_state['csv_file']['Position'] = 'FLEX' | |
| st.session_state['csv_file']['Team'] = 'GOLF' | |
| elif sport_var == 'TENNIS': | |
| st.session_state['csv_file']['Position'] = 'FLEX' | |
| st.session_state['csv_file']['Team'] = 'TENNIS' | |
| elif sport_var == 'MMA': | |
| st.session_state['csv_file']['Position'] = 'FLEX' | |
| st.session_state['csv_file']['Team'] = 'MMA' | |
| elif sport_var == 'NASCAR': | |
| st.session_state['csv_file']['Position'] = 'FLEX' | |
| st.session_state['csv_file']['Team'] = 'NASCAR' | |
| # 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'], site_var, type_var, sport_var) | |
| 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'], site_var, type_var, sport_var) | |
| 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, site_var, type_var, sport_var, 'portfolio') | |
| 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, site_var, type_var, sport_var, 'projections') | |
| 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 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)) | |
| ### if the position column is empty, set to sport_var appropriate position | |
| if position_var is not None: | |
| projections['position'] = position_var | |
| if team_var is not None: | |
| projections['team'] = team_var | |
| 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'])) | |
| if sport_var in all_column_stack_sports: | |
| st.session_state['portfolio']['Stack'] = st.session_state['portfolio'].apply( | |
| lambda row: Counter( | |
| team_dict.get(player, '') for player in row | |
| if team_dict.get(player, '') != '' | |
| ).most_common(1)[0][0] if any(team_dict.get(player, '') for player in row) else '', | |
| axis=1 | |
| ) | |
| st.session_state['portfolio']['Size'] = st.session_state['portfolio'].apply( | |
| lambda row: Counter( | |
| team_dict.get(player, '') for player in row | |
| if team_dict.get(player, '') != '' | |
| ).most_common(1)[0][1] if any(team_dict.get(player, '') for player in row) else 0, | |
| axis=1 | |
| ) | |
| else: | |
| 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 | |
| ) | |
| st.session_state['stack_dict'] = dict(zip(st.session_state['portfolio'].index, st.session_state['portfolio']['Stack'])) | |
| st.session_state['size_dict'] = dict(zip(st.session_state['portfolio'].index, st.session_state['portfolio']['Size'])) | |
| 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'])) | |
| if 'map_dict' not in st.session_state: | |
| if site_var == 'Draftkings': | |
| if type_var == 'Classic': | |
| if sport_var == 'CS2' or sport_var == 'LOL': | |
| 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' and sport_var != 'LOL': | |
| 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'])) | |
| } | |
| st.session_state['origin_portfolio'] = st.session_state['portfolio'].copy() | |
| buffer = io.BytesIO() | |
| st.session_state['portfolio'].to_parquet(buffer, compression='snappy') | |
| st.session_state['origin_portfolio'] = buffer.getvalue() | |
| del st.session_state['portfolio'] | |
| # 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 'origin_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['settings_base'] = True | |
| 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', 'Diversity'] | |
| if 'working_frame' not in st.session_state: | |
| st.session_state['settings_base'] = True | |
| st.session_state['working_frame'] = pd.read_parquet(io.BytesIO(st.session_state['origin_portfolio'])) | |
| if type_var == 'Classic': | |
| if sport_var == 'CS2' or sport_var == 'LOL': | |
| # 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' and sport_var != 'LOL': | |
| 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' in st.session_state: | |
| st.session_state['working_frame']['Stack'] = st.session_state['working_frame'].index.map(st.session_state['stack_dict']) | |
| st.session_state['working_frame']['Size'] = st.session_state['working_frame'].index.map(st.session_state['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']['Own'] = st.session_state['working_frame']['Own'].astype('float32') | |
| st.session_state['working_frame']['median'] = st.session_state['working_frame']['median'].astype('float32') | |
| st.session_state['working_frame']['salary'] = st.session_state['working_frame']['salary'].astype('uint16') | |
| 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, salary_max) | |
| 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 '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(), | |
| 'Diversity': st.session_state['working_frame']['Diversity'].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, | |
| 'Diversity': 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 stacking_sports: | |
| 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(st.session_state['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(st.session_state['stack_dict'].values()))), default=[]) | |
| submitted_col, export_col = st.columns(2) | |
| st.info("Portfolio Button applies to your overall Portfolio, Export button applies to your Custom Export") | |
| with submitted_col: | |
| reg_submitted = st.form_submit_button("Portfolio") | |
| with export_col: | |
| exp_submitted = st.form_submit_button("Export") | |
| if reg_submitted: | |
| st.session_state['settings_base'] = False | |
| 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() | |
| if exp_submitted: | |
| st.session_state['settings_base'] = False | |
| parsed_frame = st.session_state['export_base'].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['export_base'] = parsed_frame.sort_values(by='median', ascending=False).reset_index(drop=True) | |
| st.session_state['export_merge'] = st.session_state['export_base'].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 stacking_sports: | |
| size_include = st.multiselect("Include sizes?", options=sorted(list(set(st.session_state['working_frame']['Size'].unique()))), default=[]) | |
| else: | |
| size_include = [] | |
| submitted_col, export_col = st.columns(2) | |
| st.info("Portfolio Button applies to your overall Portfolio, Export button applies to your Custom Export") | |
| with submitted_col: | |
| reg_submitted = st.form_submit_button("Portfolio") | |
| with export_col: | |
| exp_submitted = st.form_submit_button("Export") | |
| if reg_submitted: | |
| st.session_state['settings_base'] = False | |
| 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() | |
| elif exp_submitted: | |
| st.session_state['settings_base'] = False | |
| parsed_frame = st.session_state['export_base'].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['export_base'] = parsed_frame.sort_values(by='median', ascending=False).reset_index(drop=True) | |
| st.session_state['export_merge'] = st.session_state['export_base'].copy() | |
| # with st.expander('Conditional Manager'): | |
| # # a set of functions for removing lineups that contain a conditional between players and stacks | |
| # with st.form(key='conditional_manager_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()) | |
| # conditional_remove_players = st.multiselect("Remove lineups containing player(s):", options=sorted(list(player_names)), default=[]) | |
| # conditional_include_players = st.multiselect("If they also contain player(s):", options=sorted(list(player_names)), default=[]) | |
| # submitted_col, export_col = st.columns(2) | |
| # st.info("Portfolio Button applies to your overall Portfolio, Export button applies to your Custom Export") | |
| # with submitted_col: | |
| # reg_submitted = st.form_submit_button("Portfolio") | |
| # with export_col: | |
| # exp_submitted = st.form_submit_button("Export") | |
| # if reg_submitted: | |
| # st.session_state['settings_base'] = False | |
| # parsed_frame = st.session_state['working_frame'].copy() | |
| # player_columns = [col for col in parsed_frame.columns if col not in excluded_cols] | |
| # # Test with a simpler approach | |
| # include_mask = parsed_frame[player_columns].apply( | |
| # lambda row: all(player in row.values for player in conditional_include_players), axis=1 | |
| # ) | |
| # remove_mask = parsed_frame[player_columns].apply( | |
| # lambda row: not any(player in row.values for player in conditional_remove_players), axis=1 | |
| # ) | |
| # parsed_frame = parsed_frame[include_mask & remove_mask] | |
| # 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() | |
| # elif exp_submitted: | |
| # st.session_state['settings_base'] = False | |
| # parsed_frame = st.session_state['export_base'].copy() | |
| # player_columns = [col for col in parsed_frame.columns if col not in excluded_cols] | |
| # # Test with a simpler approach | |
| # include_mask = parsed_frame[player_columns].apply( | |
| # lambda row: all(player in row.values for player in conditional_include_players), axis=1 | |
| # ) | |
| # remove_mask = parsed_frame[player_columns].apply( | |
| # lambda row: not any(player in row.values for player in conditional_remove_players), axis=1 | |
| # ) | |
| # parsed_frame = parsed_frame[include_mask & remove_mask] | |
| # st.session_state['export_base'] = parsed_frame.sort_values(by='median', ascending=False).reset_index(drop=True) | |
| # st.session_state['export_merge'] = st.session_state['export_base'].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', 'Own', 'Weighted Own'], key='sort_var') | |
| with own_var: | |
| own_type = st.selectbox("Trimming variable", ['Own', 'Geomean', 'Weighted Own', 'Diversity'], 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=float(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=float(st.session_state['trimming_dict_maxes'][own_type]), min_value=0.0, step=1.0, key='max_trim') | |
| submitted_col, export_col = st.columns(2) | |
| st.info("Portfolio Button applies to your overall Portfolio, Export button applies to your Custom Export") | |
| with submitted_col: | |
| reg_submitted = st.form_submit_button("Portfolio") | |
| with export_col: | |
| exp_submitted = st.form_submit_button("Export") | |
| if reg_submitted: | |
| st.session_state['settings_base'] = False | |
| st.write('initiated') | |
| parsed_frame = st.session_state['working_frame'].copy() | |
| parsed_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'] = parsed_frame.sort_values(by='median', ascending=False) | |
| st.session_state['export_merge'] = st.session_state['working_frame'].copy() | |
| elif exp_submitted: | |
| st.session_state['settings_base'] = False | |
| parsed_frame = st.session_state['export_base'].copy() | |
| parsed_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['export_base'] = parsed_frame.sort_values(by='median', ascending=False) | |
| st.session_state['export_merge'] = st.session_state['export_base'].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 Diversity)', '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_col, export_col = st.columns(2) | |
| st.info("Portfolio Button applies to your overall Portfolio, Export button applies to your Custom Export") | |
| with submitted_col: | |
| reg_submitted = st.form_submit_button("Portfolio") | |
| with export_col: | |
| exp_submitted = st.form_submit_button("Export") | |
| if reg_submitted: | |
| st.session_state['settings_base'] = False | |
| if preset_choice == 'Small Field (Heavy Own)': | |
| parsed_frame = small_field_preset(st.session_state['working_frame'], lineup_target, excluded_cols, sport_var) | |
| elif preset_choice == 'Large Field (Manage Diversity)': | |
| parsed_frame = large_field_preset(st.session_state['working_frame'], lineup_target, excluded_cols, sport_var) | |
| elif preset_choice == 'Volatility (Heavy Lineup Edge)': | |
| parsed_frame = volatility_preset(st.session_state['working_frame'], lineup_target, excluded_cols, sport_var) | |
| elif preset_choice == 'Hedge Chalk (Manage Leverage)': | |
| parsed_frame = hedging_preset(st.session_state['working_frame'], lineup_target, st.session_state['projections_df'], sport_var) | |
| elif preset_choice == 'Reduce Volatility (Manage Own)': | |
| parsed_frame = reduce_volatility_preset(st.session_state['working_frame'], lineup_target, excluded_cols, sport_var) | |
| st.session_state['working_frame'] = parsed_frame.reset_index(drop=True) | |
| st.session_state['export_merge'] = st.session_state['working_frame'].copy() | |
| elif exp_submitted: | |
| st.session_state['settings_base'] = False | |
| parsed_frame = st.session_state['export_base'].copy() | |
| if preset_choice == 'Small Field (Heavy Own)': | |
| parsed_frame = small_field_preset(st.session_state['export_base'], lineup_target, excluded_cols, sport_var) | |
| elif preset_choice == 'Large Field (Manage Diversity)': | |
| parsed_frame = large_field_preset(st.session_state['export_base'], lineup_target, excluded_cols, sport_var) | |
| elif preset_choice == 'Volatility (Heavy Lineup Edge)': | |
| parsed_frame = volatility_preset(st.session_state['export_base'], lineup_target, excluded_cols, sport_var) | |
| elif preset_choice == 'Hedge Chalk (Manage Leverage)': | |
| parsed_frame = hedging_preset(st.session_state['export_base'], lineup_target, st.session_state['projections_df'], sport_var) | |
| elif preset_choice == 'Reduce Volatility (Manage Own)': | |
| parsed_frame = reduce_volatility_preset(st.session_state['export_base'], lineup_target, excluded_cols, sport_var) | |
| st.session_state['export_base'] = parsed_frame.reset_index(drop=True) | |
| st.session_state['export_merge'] = st.session_state['export_base'].copy() | |
| with st.expander('Stratify'): | |
| with st.form(key='Stratification'): | |
| sorting_choice = st.selectbox("Stat Choice", options=['median', 'Own', 'Weighted Own', 'Geomean', 'Lineup Edge', 'Finish_percentile', 'Diversity'], index=0) | |
| lineup_target = st.number_input("Lineups to produce", value=150, min_value=1, step=1) | |
| strat_sample = st.slider("Sample range", value=[0.0, 100.0], min_value=0.0, max_value=100.0, step=1.0) | |
| submitted_col, export_col = st.columns(2) | |
| st.info("Portfolio Button applies to your overall Portfolio, Export button applies to your Custom Export") | |
| with submitted_col: | |
| reg_submitted = st.form_submit_button("Portfolio") | |
| with export_col: | |
| exp_submitted = st.form_submit_button("Export") | |
| if reg_submitted: | |
| st.session_state['settings_base'] = False | |
| parsed_frame = stratification_function(st.session_state['working_frame'], lineup_target, excluded_cols, sport_var, sorting_choice, strat_sample[0], strat_sample[1]) | |
| st.session_state['working_frame'] = parsed_frame.reset_index(drop=True) | |
| st.session_state['export_merge'] = st.session_state['working_frame'].copy() | |
| elif exp_submitted: | |
| st.session_state['settings_base'] = False | |
| parsed_frame = stratification_function(st.session_state['export_base'], lineup_target, excluded_cols, sport_var, sorting_choice, strat_sample[0], strat_sample[1]) | |
| st.session_state['export_base'] = parsed_frame.reset_index(drop=True) | |
| st.session_state['export_merge'] = st.session_state['export_base'].copy() | |
| with st.expander('Exposure Management'): | |
| with st.form(key='Exposures'): | |
| exposure_player = st.selectbox("Player", options=sorted(list(set(st.session_state['projections_df']['player_names'].unique()))), key='exposure_player') | |
| exposure_target = st.number_input("Target Exposure", value=.50, min_value=0.0, max_value=1.0, step=0.01) | |
| if 'Stack' in st.session_state['working_frame'].columns: | |
| exposure_stack_bool = st.selectbox("Maintain Stacks?", options=['Yes', 'No'], index=0) | |
| else: | |
| exposure_stack_bool = 'No' | |
| remove_teams_exposure = st.multiselect("Removed/Locked teams?", options=sorted(list(set(st.session_state['projections_df']['team'].unique()))), default=[]) | |
| submitted_col, export_col = st.columns(2) | |
| st.info("Portfolio Button applies to your overall Portfolio, Export button applies to your Custom Export") | |
| with submitted_col: | |
| reg_submitted = st.form_submit_button("Portfolio") | |
| with export_col: | |
| exp_submitted = st.form_submit_button("Export") | |
| if reg_submitted: | |
| st.session_state['settings_base'] = False | |
| prior_frame = st.session_state['working_frame'].copy() | |
| parsed_frame = exposure_spread(st.session_state['working_frame'], st.session_state['exposure_player'], exposure_target, exposure_stack_bool, remove_teams_exposure, st.session_state['projections_df'], sport_var, type_var, salary_max, stacking_sports) | |
| if type_var == 'Classic': | |
| if sport_var == 'CS2' or sport_var == 'LOL': | |
| # Calculate salary (CPT uses cpt_salary_map, others use salary_map) | |
| parsed_frame['salary'] = parsed_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) | |
| parsed_frame['median'] = parsed_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) | |
| parsed_frame['Own'] = parsed_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' and sport_var != 'LOL': | |
| parsed_frame['salary'] = parsed_frame.apply(lambda row: sum(st.session_state['map_dict']['salary_map'].get(player, 0) for player in row), axis=1) | |
| parsed_frame['median'] = parsed_frame.apply(lambda row: sum(st.session_state['map_dict']['proj_map'].get(player, 0) for player in row), axis=1) | |
| parsed_frame['Own'] = parsed_frame.apply(lambda row: sum(st.session_state['map_dict']['own_map'].get(player, 0) for player in row), axis=1) | |
| if 'stack_dict' in st.session_state: | |
| team_dict = dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])) | |
| if sport_var == 'LOL': | |
| parsed_frame['Stack'] = parsed_frame.apply( | |
| lambda row: Counter( | |
| team_dict.get(player, '') for player in row | |
| if team_dict.get(player, '') != '' | |
| ).most_common(1)[0][0] if any(team_dict.get(player, '') for player in row) else '', | |
| axis=1 | |
| ) | |
| parsed_frame['Size'] = parsed_frame.apply( | |
| lambda row: Counter( | |
| team_dict.get(player, '') for player in row | |
| if team_dict.get(player, '') != '' | |
| ).most_common(1)[0][1] if any(team_dict.get(player, '') for player in row) else 0, | |
| axis=1 | |
| ) | |
| else: | |
| parsed_frame['Stack'] = parsed_frame.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 | |
| ) | |
| parsed_frame['Size'] = parsed_frame.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 | |
| ) | |
| elif type_var == 'Showdown': | |
| # Calculate salary (CPT uses cpt_salary_map, others use salary_map) | |
| parsed_frame['salary'] = parsed_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) | |
| parsed_frame['median'] = parsed_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) | |
| parsed_frame['Own'] = parsed_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'] = parsed_frame.reset_index(drop=True) | |
| # st.session_state['working_frame']['Own'] = st.session_state['working_frame']['Own'].astype('float32') | |
| st.session_state['working_frame']['median'] = st.session_state['working_frame']['median'].astype('float32') | |
| st.session_state['working_frame']['salary'] = st.session_state['working_frame']['salary'].astype('uint16') | |
| # 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) | |
| st.session_state['working_frame'] = reassess_edge(st.session_state['working_frame'], st.session_state['base_frame'], st.session_state['map_dict'], site_var, type_var, Contest_Size, strength_var, sport_var, salary_max) | |
| st.session_state['export_merge'] = st.session_state['working_frame'].copy() | |
| elif exp_submitted: | |
| st.session_state['settings_base'] = False | |
| prior_frame = st.session_state['export_base'].copy() | |
| parsed_frame = exposure_spread(st.session_state['export_base'], st.session_state['exposure_player'], exposure_target, exposure_stack_bool, remove_teams_exposure, st.session_state['projections_df'], sport_var, type_var, salary_max, stacking_sports) | |
| if type_var == 'Classic': | |
| if sport_var == 'CS2' or sport_var == 'LOL': | |
| parsed_frame['salary'] = parsed_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 | |
| ) | |
| parsed_frame['median'] = parsed_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) | |
| parsed_frame['Own'] = parsed_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' and sport_var != 'LOL': | |
| parsed_frame['salary'] = parsed_frame.apply(lambda row: sum(st.session_state['map_dict']['salary_map'].get(player, 0) for player in row), axis=1) | |
| parsed_frame['median'] = parsed_frame.apply(lambda row: sum(st.session_state['map_dict']['proj_map'].get(player, 0) for player in row), axis=1) | |
| parsed_frame['Own'] = parsed_frame.apply(lambda row: sum(st.session_state['map_dict']['own_map'].get(player, 0) for player in row), axis=1) | |
| if 'stack_dict' in st.session_state: | |
| team_dict = dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])) | |
| if sport_var == 'LOL': | |
| parsed_frame['Stack'] = parsed_frame.apply( | |
| lambda row: Counter( | |
| team_dict.get(player, '') for player in row | |
| if team_dict.get(player, '') != '' | |
| ).most_common(1)[0][0] if any(team_dict.get(player, '') for player in row) else '', | |
| axis=1 | |
| ) | |
| parsed_frame['Size'] = parsed_frame.apply( | |
| lambda row: Counter( | |
| team_dict.get(player, '') for player in row | |
| if team_dict.get(player, '') != '' | |
| ).most_common(1)[0][1] if any(team_dict.get(player, '') for player in row) else 0, | |
| axis=1 | |
| ) | |
| else: | |
| parsed_frame['Stack'] = parsed_frame.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 | |
| ) | |
| parsed_frame['Size'] = parsed_frame.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 | |
| ) | |
| elif type_var == 'Showdown': | |
| if sport_var == 'GOLF': | |
| parsed_frame['salary'] = parsed_frame.apply(lambda row: sum(st.session_state['map_dict']['salary_map'].get(player, 0) for player in row), axis=1) | |
| parsed_frame['median'] = parsed_frame.apply(lambda row: sum(st.session_state['map_dict']['proj_map'].get(player, 0) for player in row), axis=1) | |
| parsed_frame['Own'] = parsed_frame.apply(lambda row: sum(st.session_state['map_dict']['own_map'].get(player, 0) for player in row), axis=1) | |
| else: | |
| parsed_frame['salary'] = parsed_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) | |
| parsed_frame['median'] = parsed_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) | |
| parsed_frame['Own'] = parsed_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['export_base'] = parsed_frame.reset_index(drop=True) | |
| # st.session_state['export_base']['Own'] = st.session_state['export_base']['Own'].astype('float32') | |
| st.session_state['export_base']['median'] = st.session_state['export_base']['median'].astype('float32') | |
| st.session_state['export_base']['salary'] = st.session_state['export_base']['salary'].astype('uint16') | |
| # st.session_state['export_base'] = predict_dupes(st.session_state['export_base'], st.session_state['map_dict'], site_var, type_var, Contest_Size, strength_var, sport_var) | |
| st.session_state['export_base'] = reassess_edge(st.session_state['export_base'], st.session_state['base_frame'], st.session_state['map_dict'], site_var, type_var, Contest_Size, strength_var, sport_var, salary_max) | |
| st.session_state['export_merge'] = st.session_state['export_base'].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': | |
| st.session_state['display_frame'] = st.session_state['working_frame'] | |
| st.session_state['export_file'] = st.session_state['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': | |
| st.session_state['display_frame'] = st.session_state['export_base'] | |
| st.session_state['export_file'] = st.session_state['display_frame'].copy() | |
| for col in st.session_state['export_file'].columns: | |
| if col not in excluded_cols: | |
| # Create position-specific export dictionary on the fly | |
| position_dict = create_position_export_dict(col, st.session_state['csv_file'], site_var, type_var, sport_var) | |
| st.session_state['export_file'][col] = st.session_state['export_file'][col].map(position_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': | |
| st.session_state['display_frame'] = st.session_state['working_frame'] | |
| elif display_frame_source == 'Export Base': | |
| st.session_state['display_frame'] = st.session_state['export_base'] | |
| total_rows = len(st.session_state['display_frame']) | |
| rows_per_page = 100 | |
| total_pages = (total_rows + rows_per_page - 1) // rows_per_page # Ceiling division | |
| # Initialize page number in session state if not exists | |
| if 'current_page' not in st.session_state: | |
| st.session_state.current_page = 1 | |
| # Display current page range info and pagination control in a single line | |
| st.write( | |
| f"Showing rows {(st.session_state.current_page - 1) * rows_per_page + 1} " | |
| f"to {min(st.session_state.current_page * rows_per_page, total_rows)} of {total_rows}" | |
| ) | |
| # Add page number input | |
| st.session_state.current_page = st.number_input( | |
| f"Page (1-{total_pages})", | |
| min_value=1, | |
| max_value=total_pages, | |
| value=st.session_state.current_page | |
| ) | |
| # Calculate start and end indices for current page | |
| start_idx = (st.session_state.current_page - 1) * rows_per_page | |
| end_idx = min(start_idx + rows_per_page, total_rows) | |
| # Get the subset of data for the current page | |
| current_page_data = st.session_state['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 | |
| ), | |
| "Diversity": st.column_config.NumberColumn( | |
| "Diversity", | |
| help="Projected lineup diversity", | |
| width="small", | |
| min_value=0.0, | |
| max_value=1.0 | |
| ), | |
| }, | |
| height=499, | |
| use_container_width=True, | |
| hide_index=True | |
| ) | |
| player_stats_col, stack_stats_col, combos_col = st.tabs(['Player Stats', 'Stack Stats', 'Combos']) | |
| with player_stats_col: | |
| if st.button("Analyze Players", key='analyze_players'): | |
| player_stats = [] | |
| player_columns = [col for col in st.session_state['display_frame'].columns if col not in excluded_cols] | |
| if st.session_state['settings_base'] and 'origin_player_exposures' in st.session_state and display_frame_source == 'Portfolio': | |
| st.session_state['player_summary'] = st.session_state['origin_player_exposures'] | |
| else: | |
| if type_var == 'Showdown': | |
| if sport_var == 'GOLF': | |
| for player in player_names: | |
| player_mask = st.session_state['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(st.session_state['display_frame']), | |
| 'Avg Median': st.session_state['display_frame'][player_mask]['median'].mean(), | |
| 'Avg Own': st.session_state['display_frame'][player_mask]['Own'].mean(), | |
| 'Avg Dupes': st.session_state['display_frame'][player_mask]['Dupes'].mean(), | |
| 'Avg Finish %': st.session_state['display_frame'][player_mask]['Finish_percentile'].mean(), | |
| 'Avg Lineup Edge': st.session_state['display_frame'][player_mask]['Lineup Edge'].mean(), | |
| }) | |
| else: | |
| for player in player_names: | |
| # Create mask for lineups where this player is Captain (first column) | |
| cpt_mask = st.session_state['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(st.session_state['display_frame']), | |
| 'Avg Median': st.session_state['display_frame'][cpt_mask]['median'].mean(), | |
| 'Avg Own': st.session_state['display_frame'][cpt_mask]['Own'].mean(), | |
| 'Avg Dupes': st.session_state['display_frame'][cpt_mask]['Dupes'].mean(), | |
| 'Avg Finish %': st.session_state['display_frame'][cpt_mask]['Finish_percentile'].mean(), | |
| 'Avg Lineup Edge': st.session_state['display_frame'][cpt_mask]['Lineup Edge'].mean(), | |
| }) | |
| # Create mask for lineups where this player is FLEX (other columns) | |
| flex_mask = st.session_state['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(st.session_state['display_frame']), | |
| 'Avg Median': st.session_state['display_frame'][flex_mask]['median'].mean(), | |
| 'Avg Own': st.session_state['display_frame'][flex_mask]['Own'].mean(), | |
| 'Avg Dupes': st.session_state['display_frame'][flex_mask]['Dupes'].mean(), | |
| 'Avg Finish %': st.session_state['display_frame'][flex_mask]['Finish_percentile'].mean(), | |
| 'Avg Lineup Edge': st.session_state['display_frame'][flex_mask]['Lineup Edge'].mean(), | |
| }) | |
| else: | |
| if sport_var == 'CS2' or sport_var == 'LOL': | |
| # Handle Captain positions | |
| for player in player_names: | |
| # Create mask for lineups where this player is Captain (first column) | |
| cpt_mask = st.session_state['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(st.session_state['display_frame']), | |
| 'Avg Median': st.session_state['display_frame'][cpt_mask]['median'].mean(), | |
| 'Avg Own': st.session_state['display_frame'][cpt_mask]['Own'].mean(), | |
| 'Avg Dupes': st.session_state['display_frame'][cpt_mask]['Dupes'].mean(), | |
| 'Avg Finish %': st.session_state['display_frame'][cpt_mask]['Finish_percentile'].mean(), | |
| 'Avg Lineup Edge': st.session_state['display_frame'][cpt_mask]['Lineup Edge'].mean(), | |
| }) | |
| # Create mask for lineups where this player is FLEX (other columns) | |
| flex_mask = st.session_state['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(st.session_state['display_frame']), | |
| 'Avg Median': st.session_state['display_frame'][flex_mask]['median'].mean(), | |
| 'Avg Own': st.session_state['display_frame'][flex_mask]['Own'].mean(), | |
| 'Avg Dupes': st.session_state['display_frame'][flex_mask]['Dupes'].mean(), | |
| 'Avg Finish %': st.session_state['display_frame'][flex_mask]['Finish_percentile'].mean(), | |
| 'Avg Lineup Edge': st.session_state['display_frame'][flex_mask]['Lineup Edge'].mean(), | |
| }) | |
| elif sport_var != 'CS2' and sport_var != 'LOL': | |
| # Original Classic format processing | |
| for player in player_names: | |
| player_mask = st.session_state['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(st.session_state['display_frame']), | |
| 'Avg Median': st.session_state['display_frame'][player_mask]['median'].mean(), | |
| 'Avg Own': st.session_state['display_frame'][player_mask]['Own'].mean(), | |
| 'Avg Dupes': st.session_state['display_frame'][player_mask]['Dupes'].mean(), | |
| 'Avg Finish %': st.session_state['display_frame'][player_mask]['Finish_percentile'].mean(), | |
| 'Avg Lineup Edge': st.session_state['display_frame'][player_mask]['Lineup Edge'].mean(), | |
| }) | |
| player_summary = pd.DataFrame(player_stats) | |
| player_summary = player_summary.sort_values('Lineup Count', ascending=False) | |
| st.session_state['player_summary'] = player_summary.copy() | |
| if 'origin_player_exposures' not in st.session_state: | |
| st.session_state['origin_player_exposures'] = player_summary.copy() | |
| st.subheader("Player Summary") | |
| st.dataframe( | |
| st.session_state['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 st.session_state['display_frame'].columns: | |
| if st.button("Analyze Stacks", key='analyze_stacks'): | |
| stack_stats = [] | |
| stack_columns = [col for col in st.session_state['display_frame'].columns if col.startswith('Stack')] | |
| if st.session_state['settings_base'] and 'origin_stack_exposures' in st.session_state and display_frame_source == 'Portfolio': | |
| st.session_state['stack_summary'] = st.session_state['origin_stack_exposures'] | |
| else: | |
| for stack in st.session_state['stack_dict'].values(): | |
| stack_mask = st.session_state['display_frame']['Stack'] == stack | |
| if stack_mask.any(): | |
| stack_stats.append({ | |
| 'Stack': stack, | |
| 'Lineup Count': stack_mask.sum(), | |
| 'Exposure': stack_mask.sum() / len(st.session_state['display_frame']), | |
| 'Avg Median': st.session_state['display_frame'][stack_mask]['median'].mean(), | |
| 'Avg Own': st.session_state['display_frame'][stack_mask]['Own'].mean(), | |
| 'Avg Dupes': st.session_state['display_frame'][stack_mask]['Dupes'].mean(), | |
| 'Avg Finish %': st.session_state['display_frame'][stack_mask]['Finish_percentile'].mean(), | |
| 'Avg Lineup Edge': st.session_state['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.session_state['stack_summary'] = stack_summary.copy() | |
| if 'origin_stack_exposures' not in st.session_state: | |
| st.session_state['origin_stack_exposures'] = stack_summary.copy() | |
| st.subheader("Stack Summary") | |
| st.dataframe( | |
| st.session_state['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']) | |
| with combos_col: | |
| st.subheader("Player Combinations") | |
| # Add controls for combo analysis | |
| col1, col2 = st.columns(2) | |
| with col1: | |
| combo_size = st.selectbox("Combo Size", [2, 3], key='combo_size') | |
| with col2: | |
| if st.button("Analyze Combos", key='analyze_combos'): | |
| st.session_state['combo_analysis'] = analyze_player_combos( | |
| st.session_state['display_frame'], excluded_cols, combo_size | |
| ) | |
| # Display results | |
| if 'combo_analysis' in st.session_state: | |
| st.dataframe( | |
| st.session_state['combo_analysis'].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: | |
| st.info("Click 'Analyze Combos' to see the most common player combinations.") | |