James McCool
Add initial Streamlit application with data loading, portfolio management, and optimization features
069adbe
| import streamlit as st | |
| st.set_page_config(layout="wide") | |
| import numpy as np | |
| import pandas as pd | |
| import time | |
| from fuzzywuzzy import process | |
| import random | |
| ## import global functions | |
| from global_func.clean_player_name import clean_player_name | |
| from global_func.load_file import load_file | |
| from global_func.load_ss_file import load_ss_file | |
| from global_func.find_name_mismatches import find_name_mismatches | |
| from global_func.predict_dupes import predict_dupes | |
| from global_func.highlight_rows import highlight_changes, highlight_changes_winners, highlight_changes_losers | |
| from global_func.load_csv import load_csv | |
| from global_func.find_csv_mismatches import find_csv_mismatches | |
| freq_format = {'Finish_percentile': '{:.2%}', 'Lineup Edge': '{:.2%}', 'Win%': '{:.2%}'} | |
| player_wrong_names_mlb = ['Enrique Hernandez'] | |
| player_right_names_mlb = ['Kike Hernandez'] | |
| tab1, tab2, tab3 = st.tabs(["Data Load", "Late Swap", "Manage Portfolio"]) | |
| with tab1: | |
| if st.button('Clear data', key='reset1'): | |
| st.session_state.clear() | |
| # Add file uploaders to your app | |
| col1, col2, col3 = st.columns(3) | |
| with col1: | |
| st.subheader("Draftkings/Fanduel CSV") | |
| st.info("Upload the player pricing CSV from the site you are playing on. This is used in late swap exporting and/or with SaberSim portfolios, but is not necessary for the portfolio management functions.") | |
| upload_csv_col, csv_template_col = st.columns([3, 1]) | |
| with upload_csv_col: | |
| csv_file = st.file_uploader("Upload CSV File", type=['csv']) | |
| if 'csv_file' in st.session_state: | |
| del st.session_state['csv_file'] | |
| with csv_template_col: | |
| csv_template_df = pd.DataFrame(columns=['Name', 'ID', 'Roster Position', 'Salary']) | |
| st.download_button( | |
| label="CSV Template", | |
| data=csv_template_df.to_csv(index=False), | |
| file_name="csv_template.csv", | |
| mime="text/csv" | |
| ) | |
| st.session_state['csv_file'] = load_csv(csv_file) | |
| try: | |
| st.session_state['csv_file']['Salary'] = st.session_state['csv_file']['Salary'].astype(str).str.replace(',', '').astype(int) | |
| except: | |
| pass | |
| if csv_file: | |
| st.session_state['csv_file'] = st.session_state['csv_file'].drop_duplicates(subset=['Name']) | |
| st.success('Projections file loaded successfully!') | |
| st.dataframe(st.session_state['csv_file'].head(10)) | |
| with col2: | |
| st.subheader("Portfolio File") | |
| st.info("Go ahead and upload a portfolio file here. Only include player columns and an optional 'Stack' column if you are playing MLB.") | |
| saber_toggle = st.radio("Are you uploading from SaberSim?", options=['No', 'Yes']) | |
| st.info("If you are uploading from SaberSim, you will need to upload a CSV file for the slate for name matching.") | |
| if saber_toggle == 'Yes': | |
| if csv_file is not None: | |
| portfolio_file = st.file_uploader("Upload Portfolio File (CSV or Excel)", type=['csv', 'xlsx', 'xls']) | |
| if 'portfolio' in st.session_state: | |
| del st.session_state['portfolio'] | |
| if 'export_portfolio' in st.session_state: | |
| del st.session_state['export_portfolio'] | |
| else: | |
| portfolio_file = st.file_uploader("Upload Portfolio File (CSV or Excel)", type=['csv', 'xlsx', 'xls']) | |
| if 'portfolio' in st.session_state: | |
| del st.session_state['portfolio'] | |
| if 'export_portfolio' in st.session_state: | |
| del st.session_state['export_portfolio'] | |
| if portfolio_file: | |
| if saber_toggle == 'Yes': | |
| st.session_state['export_portfolio'], st.session_state['portfolio'] = load_ss_file(portfolio_file, st.session_state['csv_file']) | |
| st.session_state['export_portfolio'] = st.session_state['export_portfolio'].dropna(how='all') | |
| st.session_state['export_portfolio'] = st.session_state['export_portfolio'].reset_index(drop=True) | |
| st.session_state['portfolio'] = st.session_state['portfolio'].dropna(how='all') | |
| st.session_state['portfolio'] = st.session_state['portfolio'].reset_index(drop=True) | |
| else: | |
| st.session_state['export_portfolio'], st.session_state['portfolio'] = load_file(portfolio_file) | |
| st.session_state['export_portfolio'] = st.session_state['export_portfolio'].dropna(how='all') | |
| st.session_state['export_portfolio'] = st.session_state['export_portfolio'].reset_index(drop=True) | |
| st.session_state['portfolio'] = st.session_state['portfolio'].dropna(how='all') | |
| st.session_state['portfolio'] = st.session_state['portfolio'].reset_index(drop=True) | |
| # Check if Stack column exists in the portfolio | |
| if 'Stack' in st.session_state['portfolio'].columns: | |
| # Create dictionary mapping index to Stack values | |
| stack_dict = dict(zip(st.session_state['portfolio'].index, st.session_state['portfolio']['Stack'])) | |
| st.write(f"Found {len(stack_dict)} stack assignments") | |
| st.session_state['portfolio'] = st.session_state['portfolio'].drop(columns=['Stack']) | |
| else: | |
| stack_dict = None | |
| st.info("No Stack column found in portfolio") | |
| if st.session_state['portfolio'] is not None: | |
| st.success('Portfolio file loaded successfully!') | |
| st.session_state['portfolio'] = st.session_state['portfolio'].apply(lambda x: x.replace(player_wrong_names_mlb, player_right_names_mlb)) | |
| st.dataframe(st.session_state['portfolio'].head(10)) | |
| with col3: | |
| st.subheader("Projections File") | |
| st.info("upload a projections file that has 'player_names', 'salary', 'median', 'ownership', and 'captain ownership' (Needed for Showdown) columns. Note that the salary for showdown needs to be the FLEX salary, not the captain salary.") | |
| # Create two columns for the uploader and template button | |
| upload_col, template_col = st.columns([3, 1]) | |
| with upload_col: | |
| projections_file = st.file_uploader("Upload Projections File (CSV or Excel)", type=['csv', 'xlsx', 'xls']) | |
| if 'projections_df' in st.session_state: | |
| del st.session_state['projections_df'] | |
| with template_col: | |
| # Create empty DataFrame with required columns | |
| template_df = pd.DataFrame(columns=['player_names', 'position', 'team', 'salary', 'median', 'ownership', 'captain ownership']) | |
| # Add download button for template | |
| st.download_button( | |
| label="Template", | |
| data=template_df.to_csv(index=False), | |
| file_name="projections_template.csv", | |
| mime="text/csv" | |
| ) | |
| if projections_file: | |
| export_projections, projections = load_file(projections_file) | |
| if projections is not None: | |
| st.success('Projections file loaded successfully!') | |
| projections = projections.apply(lambda x: x.replace(player_wrong_names_mlb, player_right_names_mlb)) | |
| st.dataframe(projections.head(10)) | |
| if portfolio_file and projections_file: | |
| if st.session_state['portfolio'] is not None and projections is not None: | |
| st.subheader("Name Matching Analysis") | |
| # Initialize projections_df in session state if it doesn't exist | |
| if 'projections_df' not in st.session_state: | |
| st.session_state['projections_df'] = projections.copy() | |
| st.session_state['projections_df']['salary'] = (st.session_state['projections_df']['salary'].astype(str).str.replace(',', '').astype(float).astype(int)) | |
| # Update projections_df with any new matches | |
| st.session_state['projections_df'] = find_name_mismatches(st.session_state['portfolio'], st.session_state['projections_df']) | |
| if csv_file is not None and 'export_dict' not in st.session_state: | |
| # Create a dictionary of Name to Name+ID from csv_file | |
| try: | |
| name_id_map = dict(zip( | |
| st.session_state['csv_file']['Name'], | |
| st.session_state['csv_file']['Name + ID'] | |
| )) | |
| except: | |
| name_id_map = dict(zip( | |
| st.session_state['csv_file']['Nickname'], | |
| st.session_state['csv_file']['Id'] | |
| )) | |
| # Function to find best match | |
| def find_best_match(name): | |
| best_match = process.extractOne(name, name_id_map.keys()) | |
| if best_match and best_match[1] >= 85: # 85% match threshold | |
| return name_id_map[best_match[0]] | |
| return name # Return original name if no good match found | |
| # Apply the matching | |
| projections['upload_match'] = projections['player_names'].apply(find_best_match) | |
| st.session_state['export_dict'] = dict(zip(projections['player_names'], projections['upload_match'])) | |
| with tab2: | |
| if st.button('Clear data', key='reset2'): | |
| st.session_state.clear() | |
| if 'portfolio' in st.session_state and 'projections_df' in st.session_state: | |
| optimized_df = None | |
| map_dict = { | |
| 'pos_map': dict(zip(st.session_state['projections_df']['player_names'], | |
| st.session_state['projections_df']['position'])), | |
| 'salary_map': dict(zip(st.session_state['projections_df']['player_names'], | |
| st.session_state['projections_df']['salary'])), | |
| 'proj_map': dict(zip(st.session_state['projections_df']['player_names'], | |
| st.session_state['projections_df']['median'])), | |
| 'own_map': dict(zip(st.session_state['projections_df']['player_names'], | |
| st.session_state['projections_df']['ownership'])), | |
| 'team_map': dict(zip(st.session_state['projections_df']['player_names'], | |
| st.session_state['projections_df']['team'])) | |
| } | |
| # Calculate new stats for optimized lineups | |
| st.session_state['portfolio']['salary'] = st.session_state['portfolio'].apply( | |
| lambda row: sum(map_dict['salary_map'].get(player, 0) for player in row if player in map_dict['salary_map']), axis=1 | |
| ) | |
| st.session_state['portfolio']['median'] = st.session_state['portfolio'].apply( | |
| lambda row: sum(map_dict['proj_map'].get(player, 0) for player in row if player in map_dict['proj_map']), axis=1 | |
| ) | |
| st.session_state['portfolio']['Own'] = st.session_state['portfolio'].apply( | |
| lambda row: sum(map_dict['own_map'].get(player, 0) for player in row if player in map_dict['own_map']), axis=1 | |
| ) | |
| options_container = st.container() | |
| with options_container: | |
| col1, col2, col3, col4, col5, col6 = st.columns(6) | |
| with col1: | |
| curr_site_var = st.selectbox("Select your current site", options=['DraftKings', 'FanDuel']) | |
| with col2: | |
| curr_sport_var = st.selectbox("Select your current sport", options=['NBA', 'MLB', 'NFL', 'NHL', 'MMA']) | |
| with col3: | |
| swap_var = st.multiselect("Select late swap strategy", options=['Optimize', 'Increase volatility', 'Decrease volatility']) | |
| with col4: | |
| remove_teams_var = st.multiselect("What teams have already played?", options=st.session_state['projections_df']['team'].unique()) | |
| with col5: | |
| winners_var = st.multiselect("Are there any players doing exceptionally well?", options=st.session_state['projections_df']['player_names'].unique(), max_selections=3) | |
| with col6: | |
| losers_var = st.multiselect("Are there any players doing exceptionally poorly?", options=st.session_state['projections_df']['player_names'].unique(), max_selections=3) | |
| if st.button('Clear Late Swap'): | |
| if 'optimized_df' in st.session_state: | |
| del st.session_state['optimized_df'] | |
| map_dict = { | |
| 'pos_map': dict(zip(st.session_state['projections_df']['player_names'], | |
| st.session_state['projections_df']['position'])), | |
| 'salary_map': dict(zip(st.session_state['projections_df']['player_names'], | |
| st.session_state['projections_df']['salary'])), | |
| 'proj_map': dict(zip(st.session_state['projections_df']['player_names'], | |
| st.session_state['projections_df']['median'])), | |
| 'own_map': dict(zip(st.session_state['projections_df']['player_names'], | |
| st.session_state['projections_df']['ownership'])), | |
| 'team_map': dict(zip(st.session_state['projections_df']['player_names'], | |
| st.session_state['projections_df']['team'])) | |
| } | |
| # Calculate new stats for optimized lineups | |
| st.session_state['portfolio']['salary'] = st.session_state['portfolio'].apply( | |
| lambda row: sum(map_dict['salary_map'].get(player, 0) for player in row if player in map_dict['salary_map']), axis=1 | |
| ) | |
| st.session_state['portfolio']['median'] = st.session_state['portfolio'].apply( | |
| lambda row: sum(map_dict['proj_map'].get(player, 0) for player in row if player in map_dict['proj_map']), axis=1 | |
| ) | |
| st.session_state['portfolio']['Own'] = st.session_state['portfolio'].apply( | |
| lambda row: sum(map_dict['own_map'].get(player, 0) for player in row if player in map_dict['own_map']), axis=1 | |
| ) | |
| if st.button('Run Late Swap'): | |
| st.session_state['portfolio'] = st.session_state['portfolio'].drop(columns=['salary', 'median', 'Own']) | |
| if curr_sport_var == 'NBA': | |
| if curr_site_var == 'DraftKings': | |
| st.session_state['portfolio'] = st.session_state['portfolio'].set_axis(['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'UTIL'], axis=1) | |
| else: | |
| st.session_state['portfolio'] = st.session_state['portfolio'].set_axis(['PG', 'PG', 'SG', 'SG', 'SF', 'SF', 'PF', 'PF', 'C'], axis=1) | |
| # Define roster position rules | |
| if curr_site_var == 'DraftKings': | |
| position_rules = { | |
| 'PG': ['PG'], | |
| 'SG': ['SG'], | |
| 'SF': ['SF'], | |
| 'PF': ['PF'], | |
| 'C': ['C'], | |
| 'G': ['PG', 'SG'], | |
| 'F': ['SF', 'PF'], | |
| 'UTIL': ['PG', 'SG', 'SF', 'PF', 'C'] | |
| } | |
| else: | |
| position_rules = { | |
| 'PG': ['PG'], | |
| 'SG': ['SG'], | |
| 'SF': ['SF'], | |
| 'PF': ['PF'], | |
| 'C': ['C'], | |
| } | |
| # Create position groups from projections data | |
| position_groups = {} | |
| for _, player in st.session_state['projections_df'].iterrows(): | |
| positions = player['position'].split('/') | |
| for pos in positions: | |
| if pos not in position_groups: | |
| position_groups[pos] = [] | |
| position_groups[pos].append({ | |
| 'player_names': player['player_names'], | |
| 'salary': player['salary'], | |
| 'median': player['median'], | |
| 'ownership': player['ownership'], | |
| 'positions': positions # Store all eligible positions | |
| }) | |
| def optimize_lineup(row): | |
| current_lineup = [] | |
| total_salary = 0 | |
| if curr_site_var == 'DraftKings': | |
| salary_cap = 50000 | |
| else: | |
| salary_cap = 60000 | |
| used_players = set() | |
| # Convert row to dictionary with roster positions | |
| roster = {} | |
| for col, player in zip(row.index, row): | |
| if col not in ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Lineup Edge']: | |
| roster[col] = { | |
| 'name': player, | |
| 'position': map_dict['pos_map'].get(player, '').split('/'), | |
| 'team': map_dict['team_map'].get(player, ''), | |
| 'salary': map_dict['salary_map'].get(player, 0), | |
| 'median': map_dict['proj_map'].get(player, 0), | |
| 'ownership': map_dict['own_map'].get(player, 0) | |
| } | |
| total_salary += roster[col]['salary'] | |
| used_players.add(player) | |
| # Optimize each roster position in random order | |
| roster_positions = list(roster.items()) | |
| random.shuffle(roster_positions) | |
| for roster_pos, current in roster_positions: | |
| # Skip optimization for players from removed teams | |
| if current['team'] in remove_teams_var: | |
| continue | |
| valid_positions = position_rules[roster_pos] | |
| better_options = [] | |
| # Find valid replacements for this roster position | |
| for pos in valid_positions: | |
| if pos in position_groups: | |
| pos_options = [ | |
| p for p in position_groups[pos] | |
| if p['median'] > current['median'] | |
| and (total_salary - current['salary'] + p['salary']) <= salary_cap | |
| and p['player_names'] not in used_players | |
| and any(valid_pos in p['positions'] for valid_pos in valid_positions) | |
| and map_dict['team_map'].get(p['player_names']) not in remove_teams_var # Check team restriction | |
| ] | |
| better_options.extend(pos_options) | |
| if better_options: | |
| # Remove duplicates | |
| better_options = {opt['player_names']: opt for opt in better_options}.values() | |
| # Sort by median projection and take the best one | |
| best_replacement = max(better_options, key=lambda x: x['median']) | |
| # Update the lineup and tracking variables | |
| used_players.remove(current['name']) | |
| used_players.add(best_replacement['player_names']) | |
| total_salary = total_salary - current['salary'] + best_replacement['salary'] | |
| roster[roster_pos] = { | |
| 'name': best_replacement['player_names'], | |
| 'position': map_dict['pos_map'][best_replacement['player_names']].split('/'), | |
| 'team': map_dict['team_map'][best_replacement['player_names']], | |
| 'salary': best_replacement['salary'], | |
| 'median': best_replacement['median'], | |
| 'ownership': best_replacement['ownership'] | |
| } | |
| # Return optimized lineup maintaining original column order | |
| return [roster[pos]['name'] for pos in row.index if pos in roster] | |
| def optimize_lineup_winners(row): | |
| current_lineup = [] | |
| total_salary = 0 | |
| if curr_site_var == 'DraftKings': | |
| salary_cap = 50000 | |
| else: | |
| salary_cap = 60000 | |
| used_players = set() | |
| # Check if any winners are in the lineup and count them | |
| winners_in_lineup = sum(1 for player in row if player in winners_var) | |
| changes_needed = min(winners_in_lineup, 3) if winners_in_lineup > 0 else 0 | |
| changes_made = 0 | |
| # Convert row to dictionary with roster positions | |
| roster = {} | |
| for col, player in zip(row.index, row): | |
| if col not in ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Lineup Edge']: | |
| roster[col] = { | |
| 'name': player, | |
| 'position': map_dict['pos_map'].get(player, '').split('/'), | |
| 'team': map_dict['team_map'].get(player, ''), | |
| 'salary': map_dict['salary_map'].get(player, 0), | |
| 'median': map_dict['proj_map'].get(player, 0), | |
| 'ownership': map_dict['own_map'].get(player, 0) | |
| } | |
| total_salary += roster[col]['salary'] | |
| used_players.add(player) | |
| # Only proceed with ownership-based optimization if we have winners in the lineup | |
| if changes_needed > 0: | |
| # Randomize the order of positions to optimize | |
| roster_positions = list(roster.items()) | |
| random.shuffle(roster_positions) | |
| for roster_pos, current in roster_positions: | |
| # Stop if we've made enough changes | |
| if changes_made >= changes_needed: | |
| break | |
| # Skip optimization for players from removed teams or if the current player is a winner | |
| if current['team'] in remove_teams_var or current['name'] in winners_var: | |
| continue | |
| valid_positions = list(position_rules[roster_pos]) | |
| random.shuffle(valid_positions) | |
| better_options = [] | |
| # Find valid replacements with higher ownership | |
| for pos in valid_positions: | |
| if pos in position_groups: | |
| pos_options = [ | |
| p for p in position_groups[pos] | |
| if p['ownership'] > current['ownership'] | |
| and p['median'] >= current['median'] - 3 | |
| and (total_salary - current['salary'] + p['salary']) <= salary_cap | |
| and (total_salary - current['salary'] + p['salary']) >= salary_cap - 1000 | |
| and p['player_names'] not in used_players | |
| and any(valid_pos in p['positions'] for valid_pos in valid_positions) | |
| and map_dict['team_map'].get(p['player_names']) not in remove_teams_var | |
| ] | |
| better_options.extend(pos_options) | |
| if better_options: | |
| # Remove duplicates | |
| better_options = {opt['player_names']: opt for opt in better_options}.values() | |
| # Sort by ownership and take the highest owned option | |
| best_replacement = max(better_options, key=lambda x: x['ownership']) | |
| # Update the lineup and tracking variables | |
| used_players.remove(current['name']) | |
| used_players.add(best_replacement['player_names']) | |
| total_salary = total_salary - current['salary'] + best_replacement['salary'] | |
| roster[roster_pos] = { | |
| 'name': best_replacement['player_names'], | |
| 'position': map_dict['pos_map'][best_replacement['player_names']].split('/'), | |
| 'team': map_dict['team_map'][best_replacement['player_names']], | |
| 'salary': best_replacement['salary'], | |
| 'median': best_replacement['median'], | |
| 'ownership': best_replacement['ownership'] | |
| } | |
| changes_made += 1 | |
| # Return optimized lineup maintaining original column order | |
| return [roster[pos]['name'] for pos in row.index if pos in roster] | |
| def optimize_lineup_losers(row): | |
| current_lineup = [] | |
| total_salary = 0 | |
| if curr_site_var == 'DraftKings': | |
| salary_cap = 50000 | |
| else: | |
| salary_cap = 60000 | |
| used_players = set() | |
| # Check if any winners are in the lineup and count them | |
| losers_in_lineup = sum(1 for player in row if player in losers_var) | |
| changes_needed = min(losers_in_lineup, 3) if losers_in_lineup > 0 else 0 | |
| changes_made = 0 | |
| # Convert row to dictionary with roster positions | |
| roster = {} | |
| for col, player in zip(row.index, row): | |
| if col not in ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Lineup Edge']: | |
| roster[col] = { | |
| 'name': player, | |
| 'position': map_dict['pos_map'].get(player, '').split('/'), | |
| 'team': map_dict['team_map'].get(player, ''), | |
| 'salary': map_dict['salary_map'].get(player, 0), | |
| 'median': map_dict['proj_map'].get(player, 0), | |
| 'ownership': map_dict['own_map'].get(player, 0) | |
| } | |
| total_salary += roster[col]['salary'] | |
| used_players.add(player) | |
| # Only proceed with ownership-based optimization if we have winners in the lineup | |
| if changes_needed > 0: | |
| # Randomize the order of positions to optimize | |
| roster_positions = list(roster.items()) | |
| random.shuffle(roster_positions) | |
| for roster_pos, current in roster_positions: | |
| # Stop if we've made enough changes | |
| if changes_made >= changes_needed: | |
| break | |
| # Skip optimization for players from removed teams or if the current player is a winner | |
| if current['team'] in remove_teams_var or current['name'] in losers_var: | |
| continue | |
| valid_positions = list(position_rules[roster_pos]) | |
| random.shuffle(valid_positions) | |
| better_options = [] | |
| # Find valid replacements with higher ownership | |
| for pos in valid_positions: | |
| if pos in position_groups: | |
| pos_options = [ | |
| p for p in position_groups[pos] | |
| if p['ownership'] < current['ownership'] | |
| and p['median'] >= current['median'] - 3 | |
| and (total_salary - current['salary'] + p['salary']) <= salary_cap | |
| and (total_salary - current['salary'] + p['salary']) >= salary_cap - 1000 | |
| and p['player_names'] not in used_players | |
| and any(valid_pos in p['positions'] for valid_pos in valid_positions) | |
| and map_dict['team_map'].get(p['player_names']) not in remove_teams_var | |
| ] | |
| better_options.extend(pos_options) | |
| if better_options: | |
| # Remove duplicates | |
| better_options = {opt['player_names']: opt for opt in better_options}.values() | |
| # Sort by ownership and take the highest owned option | |
| best_replacement = max(better_options, key=lambda x: x['ownership']) | |
| # Update the lineup and tracking variables | |
| used_players.remove(current['name']) | |
| used_players.add(best_replacement['player_names']) | |
| total_salary = total_salary - current['salary'] + best_replacement['salary'] | |
| roster[roster_pos] = { | |
| 'name': best_replacement['player_names'], | |
| 'position': map_dict['pos_map'][best_replacement['player_names']].split('/'), | |
| 'team': map_dict['team_map'][best_replacement['player_names']], | |
| 'salary': best_replacement['salary'], | |
| 'median': best_replacement['median'], | |
| 'ownership': best_replacement['ownership'] | |
| } | |
| changes_made += 1 | |
| # Return optimized lineup maintaining original column order | |
| return [roster[pos]['name'] for pos in row.index if pos in roster] | |
| # Create a progress bar | |
| progress_bar = st.progress(0) | |
| status_text = st.empty() | |
| # Process each lineup | |
| optimized_lineups = [] | |
| total_lineups = len(st.session_state['portfolio']) | |
| for idx, row in st.session_state['portfolio'].iterrows(): | |
| # First optimization pass | |
| first_pass = optimize_lineup(row) | |
| first_pass_series = pd.Series(first_pass, index=row.index) | |
| second_pass = optimize_lineup(first_pass_series) | |
| second_pass_series = pd.Series(second_pass, index=row.index) | |
| third_pass = optimize_lineup(second_pass_series) | |
| third_pass_series = pd.Series(third_pass, index=row.index) | |
| fourth_pass = optimize_lineup(third_pass_series) | |
| fourth_pass_series = pd.Series(fourth_pass, index=row.index) | |
| fifth_pass = optimize_lineup(fourth_pass_series) | |
| fifth_pass_series = pd.Series(fifth_pass, index=row.index) | |
| # Second optimization pass | |
| final_lineup = optimize_lineup(fifth_pass_series) | |
| optimized_lineups.append(final_lineup) | |
| if 'Optimize' in swap_var: | |
| progress = (idx + 1) / total_lineups | |
| progress_bar.progress(progress) | |
| status_text.text(f'Optimizing Lineups {idx + 1} of {total_lineups}') | |
| else: | |
| pass | |
| # Create new dataframe with optimized lineups | |
| if 'Optimize' in swap_var: | |
| st.session_state['optimized_df_medians'] = pd.DataFrame(optimized_lineups, columns=st.session_state['portfolio'].columns) | |
| else: | |
| st.session_state['optimized_df_medians'] = st.session_state['portfolio'] | |
| # Create a progress bar | |
| progress_bar_winners = st.progress(0) | |
| status_text_winners = st.empty() | |
| # Process each lineup | |
| optimized_lineups_winners = [] | |
| total_lineups = len(st.session_state['optimized_df_medians']) | |
| for idx, row in st.session_state['optimized_df_medians'].iterrows(): | |
| final_lineup = optimize_lineup_winners(row) | |
| optimized_lineups_winners.append(final_lineup) | |
| if 'Decrease volatility' in swap_var: | |
| progress_winners = (idx + 1) / total_lineups | |
| progress_bar_winners.progress(progress_winners) | |
| status_text_winners.text(f'Lowering Volatility around Winners {idx + 1} of {total_lineups}') | |
| else: | |
| pass | |
| # Create new dataframe with optimized lineups | |
| if 'Decrease volatility' in swap_var: | |
| st.session_state['optimized_df_winners'] = pd.DataFrame(optimized_lineups_winners, columns=st.session_state['optimized_df_medians'].columns) | |
| else: | |
| st.session_state['optimized_df_winners'] = st.session_state['optimized_df_medians'] | |
| # Create a progress bar | |
| progress_bar_losers = st.progress(0) | |
| status_text_losers = st.empty() | |
| # Process each lineup | |
| optimized_lineups_losers = [] | |
| total_lineups = len(st.session_state['optimized_df_winners']) | |
| for idx, row in st.session_state['optimized_df_winners'].iterrows(): | |
| final_lineup = optimize_lineup_losers(row) | |
| optimized_lineups_losers.append(final_lineup) | |
| if 'Increase volatility' in swap_var: | |
| progress_losers = (idx + 1) / total_lineups | |
| progress_bar_losers.progress(progress_losers) | |
| status_text_losers.text(f'Increasing Volatility around Losers {idx + 1} of {total_lineups}') | |
| else: | |
| pass | |
| # Create new dataframe with optimized lineups | |
| if 'Increase volatility' in swap_var: | |
| st.session_state['optimized_df'] = pd.DataFrame(optimized_lineups_losers, columns=st.session_state['optimized_df_winners'].columns) | |
| else: | |
| st.session_state['optimized_df'] = st.session_state['optimized_df_winners'] | |
| # Calculate new stats for optimized lineups | |
| st.session_state['optimized_df']['salary'] = st.session_state['optimized_df'].apply( | |
| lambda row: sum(map_dict['salary_map'].get(player, 0) for player in row if player in map_dict['salary_map']), axis=1 | |
| ) | |
| st.session_state['optimized_df']['median'] = st.session_state['optimized_df'].apply( | |
| lambda row: sum(map_dict['proj_map'].get(player, 0) for player in row if player in map_dict['proj_map']), axis=1 | |
| ) | |
| st.session_state['optimized_df']['Own'] = st.session_state['optimized_df'].apply( | |
| lambda row: sum(map_dict['own_map'].get(player, 0) for player in row if player in map_dict['own_map']), axis=1 | |
| ) | |
| # Display results | |
| st.success('Optimization complete!') | |
| if 'optimized_df' in st.session_state: | |
| st.write("Increase in median highlighted in yellow, descrease in volatility highlighted in blue, increase in volatility highlighted in red:") | |
| st.dataframe( | |
| st.session_state['optimized_df'].style | |
| .apply(highlight_changes, axis=1) | |
| .apply(highlight_changes_winners, axis=1) | |
| .apply(highlight_changes_losers, axis=1) | |
| .background_gradient(axis=0) | |
| .background_gradient(cmap='RdYlGn') | |
| .format(precision=2), | |
| height=1000, | |
| use_container_width=True | |
| ) | |
| # Option to download optimized lineups | |
| if st.button('Prepare Late Swap Export'): | |
| export_df = st.session_state['optimized_df'].copy() | |
| # Map player names to their export IDs for all player columns | |
| for col in export_df.columns: | |
| if col not in ['salary', 'median', 'Own']: | |
| export_df[col] = export_df[col].map(st.session_state['export_dict']) | |
| csv = export_df.to_csv(index=False) | |
| st.download_button( | |
| label="Download CSV", | |
| data=csv, | |
| file_name="optimized_lineups.csv", | |
| mime="text/csv" | |
| ) | |
| else: | |
| st.write("Current Portfolio") | |
| st.dataframe( | |
| st.session_state['portfolio'].style | |
| .background_gradient(axis=0) | |
| .background_gradient(cmap='RdYlGn') | |
| .format(precision=2), | |
| height=1000, | |
| use_container_width=True | |
| ) | |
| with tab3: | |
| if st.button('Clear data', key='reset3'): | |
| st.session_state.clear() | |
| if 'portfolio' in st.session_state and 'projections_df' in st.session_state: | |
| col1, col2, col3 = st.columns([1, 8, 1]) | |
| excluded_cols = ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Stack', 'Win%', 'Lineup Edge'] | |
| with col1: | |
| site_var = st.selectbox("Select Site", ['Draftkings', 'Fanduel']) | |
| sport_var = st.selectbox("Select Sport", ['NFL', 'MLB', 'NBA', 'NHL', 'MMA']) | |
| st.info("It currently does not matter what sport you select, it may matter in the future.") | |
| type_var = st.selectbox("Select Game Type", ['Classic', 'Showdown']) | |
| Contest_Size = st.number_input("Enter Contest Size", value=25000, min_value=1, step=1) | |
| strength_var = st.selectbox("Select field strength", ['Average', 'Sharp', 'Weak']) | |
| if site_var == 'Draftkings': | |
| if type_var == 'Classic': | |
| map_dict = { | |
| 'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])), | |
| 'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])), | |
| 'salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])), | |
| 'proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])), | |
| 'own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'])), | |
| 'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))), | |
| 'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])), | |
| 'cpt_proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'] * 1.5)), | |
| 'cpt_own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['captain ownership'])) | |
| } | |
| elif type_var == 'Showdown': | |
| if sport_var == 'NFL': | |
| map_dict = { | |
| 'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])), | |
| 'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])), | |
| 'salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])), | |
| 'proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])), | |
| 'own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'])), | |
| 'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))), | |
| 'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'] * 1.5)), | |
| 'cpt_proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'] * 1.5)), | |
| 'cpt_own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['captain ownership'])) | |
| } | |
| elif sport_var != 'NFL': | |
| map_dict = { | |
| 'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])), | |
| 'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])), | |
| 'salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'] / 1.5)), | |
| 'proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])), | |
| 'own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'])), | |
| 'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))), | |
| 'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])), | |
| 'cpt_proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'] * 1.5)), | |
| 'cpt_own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['captain ownership'])) | |
| } | |
| elif site_var == 'Fanduel': | |
| map_dict = { | |
| 'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])), | |
| 'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])), | |
| 'salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])), | |
| 'proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])), | |
| 'own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'])), | |
| 'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))), | |
| 'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])), | |
| 'cpt_proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'] * 1.5)), | |
| 'cpt_own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['captain ownership'])) | |
| } | |
| if type_var == 'Classic': | |
| st.session_state['portfolio']['salary'] = st.session_state['portfolio'].apply(lambda row: sum(map_dict['salary_map'].get(player, 0) for player in row), axis=1) | |
| st.session_state['portfolio']['median'] = st.session_state['portfolio'].apply(lambda row: sum(map_dict['proj_map'].get(player, 0) for player in row), axis=1) | |
| st.session_state['portfolio']['Own'] = st.session_state['portfolio'].apply(lambda row: sum(map_dict['own_map'].get(player, 0) for player in row), axis=1) | |
| if stack_dict is not None: | |
| st.session_state['portfolio']['Stack'] = st.session_state['portfolio'].index.map(stack_dict) | |
| elif type_var == 'Showdown': | |
| # Calculate salary (CPT uses cpt_salary_map, others use salary_map) | |
| st.session_state['portfolio']['salary'] = st.session_state['portfolio'].apply( | |
| lambda row: map_dict['cpt_salary_map'].get(row.iloc[0], 0) + | |
| sum(map_dict['salary_map'].get(player, 0) for player in row.iloc[1:]), | |
| axis=1 | |
| ) | |
| # Calculate median (CPT uses cpt_proj_map, others use proj_map) | |
| st.session_state['portfolio']['median'] = st.session_state['portfolio'].apply( | |
| lambda row: map_dict['cpt_proj_map'].get(row.iloc[0], 0) + | |
| sum(map_dict['proj_map'].get(player, 0) for player in row.iloc[1:]), | |
| axis=1 | |
| ) | |
| # Calculate ownership (CPT uses cpt_own_map, others use own_map) | |
| st.session_state['portfolio']['Own'] = st.session_state['portfolio'].apply( | |
| lambda row: map_dict['cpt_own_map'].get(row.iloc[0], 0) + | |
| sum(map_dict['own_map'].get(player, 0) for player in row.iloc[1:]), | |
| axis=1 | |
| ) | |
| with col3: | |
| with st.form(key='filter_form'): | |
| max_dupes = st.number_input("Max acceptable dupes?", value=1000, min_value=1, step=1) | |
| min_salary = st.number_input("Min acceptable salary?", value=1000, min_value=1000, step=100) | |
| max_salary = st.number_input("Max acceptable salary?", value=60000, min_value=1000, step=100) | |
| max_finish_percentile = st.number_input("Max acceptable finish percentile?", value=.50, min_value=0.005, step=.001) | |
| player_names = set() | |
| for col in st.session_state['portfolio'].columns: | |
| if col not in excluded_cols: | |
| player_names.update(st.session_state['portfolio'][col].unique()) | |
| player_lock = st.multiselect("Lock players?", options=sorted(list(player_names)), default=[]) | |
| player_remove = st.multiselect("Remove players?", options=sorted(list(player_names)), default=[]) | |
| if stack_dict is not None: | |
| stack_toggle = st.selectbox("Include specific stacks?", options=['All Stacks', 'Specific Stacks'], index=0) | |
| stack_selections = st.multiselect("If Specific Stacks, Which to include?", options=sorted(list(set(stack_dict.values()))), default=[]) | |
| stack_remove = st.multiselect("If Specific Stacks, Which to remove?", options=sorted(list(set(stack_dict.values()))), default=[]) | |
| submitted = st.form_submit_button("Submit") | |
| with col2: | |
| st.session_state['portfolio'] = predict_dupes(st.session_state['portfolio'], map_dict, site_var, type_var, Contest_Size, strength_var) | |
| st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['Dupes'] <= max_dupes] | |
| st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['salary'] >= min_salary] | |
| st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['salary'] <= max_salary] | |
| st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['Finish_percentile'] <= max_finish_percentile] | |
| if stack_dict is not None: | |
| if stack_toggle == 'All Stacks': | |
| st.session_state['portfolio'] = st.session_state['portfolio'] | |
| st.session_state['portfolio'] = st.session_state['portfolio'][~st.session_state['portfolio']['Stack'].isin(stack_remove)] | |
| else: | |
| st.session_state['portfolio'] = st.session_state['portfolio'][st.session_state['portfolio']['Stack'].isin(stack_selections)] | |
| st.session_state['portfolio'] = st.session_state['portfolio'][~st.session_state['portfolio']['Stack'].isin(stack_remove)] | |
| if player_remove: | |
| # Create mask for lineups that contain any of the removed players | |
| player_columns = [col for col in st.session_state['portfolio'].columns if col not in excluded_cols] | |
| remove_mask = st.session_state['portfolio'][player_columns].apply( | |
| lambda row: not any(player in list(row) for player in player_remove), axis=1 | |
| ) | |
| st.session_state['portfolio'] = st.session_state['portfolio'][remove_mask] | |
| if player_lock: | |
| # Create mask for lineups that contain all locked players | |
| player_columns = [col for col in st.session_state['portfolio'].columns if col not in excluded_cols] | |
| lock_mask = st.session_state['portfolio'][player_columns].apply( | |
| lambda row: all(player in list(row) for player in player_lock), axis=1 | |
| ) | |
| st.session_state['portfolio'] = st.session_state['portfolio'][lock_mask] | |
| export_file = st.session_state['portfolio'].copy() | |
| st.session_state['portfolio'] = st.session_state['portfolio'].sort_values(by='median', ascending=False) | |
| if csv_file is not None: | |
| player_columns = [col for col in st.session_state['portfolio'].columns if col not in excluded_cols] | |
| for col in player_columns: | |
| export_file[col] = export_file[col].map(st.session_state['export_dict']) | |
| with st.expander("Download options"): | |
| if stack_dict is not None: | |
| with st.form(key='stack_form'): | |
| st.subheader("Stack Count Adjustments") | |
| st.info("This allows you to fine tune the stacks that you wish to export. If you want to make sure you don't export any of a specific stack you can 0 it out.") | |
| # Create a container for stack value inputs | |
| sort_container = st.container() | |
| with sort_container: | |
| sort_var = st.selectbox("Sort export portfolio by:", options=['median', 'Lineup Edge', 'Own']) | |
| # Get unique stack values | |
| unique_stacks = sorted(list(set(stack_dict.values()))) | |
| # Create a dictionary to store stack multipliers | |
| if 'stack_multipliers' not in st.session_state: | |
| st.session_state.stack_multipliers = {stack: 0.0 for stack in unique_stacks} | |
| # Create columns for the stack inputs | |
| num_cols = 6 # Number of columns to display | |
| for i in range(0, len(unique_stacks), num_cols): | |
| cols = st.columns(num_cols) | |
| for j, stack in enumerate(unique_stacks[i:i+num_cols]): | |
| with cols[j]: | |
| # Create a unique key for each number input | |
| key = f"stack_count_{stack}" | |
| # Get the current count of this stack in the portfolio | |
| current_stack_count = len(st.session_state['portfolio'][st.session_state['portfolio']['Stack'] == stack]) | |
| # Create number input with current value and max value based on actual count | |
| st.session_state.stack_multipliers[stack] = st.number_input( | |
| f"{stack} count", | |
| min_value=0.0, | |
| max_value=float(current_stack_count), | |
| value=0.0, | |
| step=1.0, | |
| key=key | |
| ) | |
| # Create a copy of the portfolio | |
| portfolio_copy = st.session_state['portfolio'].copy() | |
| # Create a list to store selected rows | |
| selected_rows = [] | |
| # For each stack, select the top N rows based on the count value | |
| for stack in unique_stacks: | |
| if stack in st.session_state.stack_multipliers: | |
| count = int(st.session_state.stack_multipliers[stack]) | |
| # Get rows for this stack | |
| stack_rows = portfolio_copy[portfolio_copy['Stack'] == stack] | |
| # Sort by median and take top N rows | |
| top_rows = stack_rows.nlargest(count, sort_var) | |
| selected_rows.append(top_rows) | |
| # Combine all selected rows | |
| portfolio_copy = pd.concat(selected_rows) | |
| # Update export_file with filtered data | |
| export_file = portfolio_copy.copy() | |
| for col in export_file.columns: | |
| if col not in excluded_cols: | |
| export_file[col] = export_file[col].map(st.session_state['export_dict']) | |
| submitted = st.form_submit_button("Submit") | |
| if submitted: | |
| st.write('Export portfolio updated!') | |
| st.download_button(label="Download Portfolio", data=export_file.to_csv(index=False), file_name="portfolio.csv", mime="text/csv") | |
| # Display the paginated dataframe first | |
| st.dataframe( | |
| st.session_state['portfolio'].style | |
| .background_gradient(axis=0) | |
| .background_gradient(cmap='RdYlGn') | |
| .background_gradient(cmap='RdYlGn_r', subset=['Finish_percentile', 'Own', 'Dupes']) | |
| .format(freq_format, precision=2), | |
| height=1000, | |
| use_container_width=True | |
| ) | |
| # Add pagination controls below the dataframe | |
| total_rows = len(st.session_state['portfolio']) | |
| rows_per_page = 500 | |
| total_pages = (total_rows + rows_per_page - 1) // rows_per_page # Ceiling division | |
| # Initialize page number in session state if not exists | |
| if 'current_page' not in st.session_state: | |
| st.session_state.current_page = 1 | |
| # Display current page range info and pagination control in a single line | |
| st.write( | |
| f"Showing rows {(st.session_state.current_page - 1) * rows_per_page + 1} " | |
| f"to {min(st.session_state.current_page * rows_per_page, total_rows)} of {total_rows}" | |
| ) | |
| # Add page number input | |
| st.session_state.current_page = st.number_input( | |
| f"Page (1-{total_pages})", | |
| min_value=1, | |
| max_value=total_pages, | |
| value=st.session_state.current_page | |
| ) | |
| # Calculate start and end indices for current page | |
| start_idx = (st.session_state.current_page - 1) * rows_per_page | |
| end_idx = min(start_idx + rows_per_page, total_rows) | |
| # Get the subset of data for the current page | |
| current_page_data = st.session_state['portfolio'].iloc[start_idx:end_idx] | |
| # Create player summary dataframe | |
| player_stats = [] | |
| player_columns = [col for col in st.session_state['portfolio'].columns if col not in excluded_cols] | |
| if type_var == 'Showdown': | |
| # Handle Captain positions | |
| for player in player_names: | |
| # Create mask for lineups where this player is Captain (first column) | |
| cpt_mask = st.session_state['portfolio'][player_columns[0]] == player | |
| if cpt_mask.any(): | |
| player_stats.append({ | |
| 'Player': f"{player} (CPT)", | |
| 'Lineup Count': cpt_mask.sum(), | |
| 'Avg Median': st.session_state['portfolio'][cpt_mask]['median'].mean(), | |
| 'Avg Own': st.session_state['portfolio'][cpt_mask]['Own'].mean(), | |
| 'Avg Dupes': st.session_state['portfolio'][cpt_mask]['Dupes'].mean(), | |
| 'Avg Finish %': st.session_state['portfolio'][cpt_mask]['Finish_percentile'].mean(), | |
| 'Avg Lineup Edge': st.session_state['portfolio'][cpt_mask]['Lineup Edge'].mean(), | |
| }) | |
| # Create mask for lineups where this player is FLEX (other columns) | |
| flex_mask = st.session_state['portfolio'][player_columns[1:]].apply( | |
| lambda row: player in list(row), axis=1 | |
| ) | |
| if flex_mask.any(): | |
| player_stats.append({ | |
| 'Player': f"{player} (FLEX)", | |
| 'Lineup Count': flex_mask.sum(), | |
| 'Avg Median': st.session_state['portfolio'][flex_mask]['median'].mean(), | |
| 'Avg Own': st.session_state['portfolio'][flex_mask]['Own'].mean(), | |
| 'Avg Dupes': st.session_state['portfolio'][flex_mask]['Dupes'].mean(), | |
| 'Avg Finish %': st.session_state['portfolio'][flex_mask]['Finish_percentile'].mean(), | |
| 'Avg Lineup Edge': st.session_state['portfolio'][flex_mask]['Lineup Edge'].mean(), | |
| }) | |
| else: | |
| # Original Classic format processing | |
| for player in player_names: | |
| player_mask = st.session_state['portfolio'][player_columns].apply( | |
| lambda row: player in list(row), axis=1 | |
| ) | |
| if player_mask.any(): | |
| player_stats.append({ | |
| 'Player': player, | |
| 'Lineup Count': player_mask.sum(), | |
| 'Avg Median': st.session_state['portfolio'][player_mask]['median'].mean(), | |
| 'Avg Own': st.session_state['portfolio'][player_mask]['Own'].mean(), | |
| 'Avg Dupes': st.session_state['portfolio'][player_mask]['Dupes'].mean(), | |
| 'Avg Finish %': st.session_state['portfolio'][player_mask]['Finish_percentile'].mean(), | |
| 'Avg Lineup Edge': st.session_state['portfolio'][player_mask]['Lineup Edge'].mean(), | |
| }) | |
| player_summary = pd.DataFrame(player_stats) | |
| player_summary = player_summary.sort_values('Lineup Count', ascending=False) | |
| st.subheader("Player Summary") | |
| st.dataframe( | |
| player_summary.style | |
| .background_gradient(axis=0).background_gradient(cmap='RdYlGn').background_gradient(cmap='RdYlGn_r', subset=['Avg Finish %', 'Avg Own', 'Avg Dupes']) | |
| .format({ | |
| 'Avg Median': '{:.2f}', | |
| 'Avg Own': '{:.2f}', | |
| 'Avg Dupes': '{:.2f}', | |
| 'Avg Finish %': '{:.2%}', | |
| 'Avg Lineup Edge': '{:.2%}' | |
| }), | |
| height=400, | |
| use_container_width=True | |
| ) |