Hugging Face's logo

Spaces:
Multichem-PD
/
DFS_Portfolio_Manager
Running

App Files Community
DFS_Portfolio_Manager / app.py
James McCool
printing a check frame
520ddc7
raw
history blame
165 kB
 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
from global_func.recalc_diversity import recalc_diversity
freq_format = {'Finish_percentile': '{:.2%}', 'Lineup Edge': '{:.2%}', 'Win%': '{:.2%}'}
stacking_sports = ['MLB', 'NHL', 'NFL', 'LOL', 'NCAAF']
stack_column_dict = {
'Draftkings': {
'Classic': {
'MLB': ['C', '1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3'],
'NHL': ['C', 'W', 'D'],
'NFL': ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX'],
'LOL': ['TOP', 'JNG', 'MID', 'ADC', 'SUP', 'TEAM'],
'NCAAF': ['QB', 'WR1', 'WR2', 'WR3', 'FLEX', 'SFLEX'],
},
'Showdown': {
'MLB': ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'],
'NHL': ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'],
'NFL': ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'],
'LOL': ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'],
'NCAAF': ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'],
},
},
'Fanduel': {
'Classic': {
'MLB': ['C/1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'UTIL'],
'NHL': ['C', 'W', 'D'],
'NFL': ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX'],
'LOL': ['TOP', 'JNG', 'MID', 'ADC', 'SUP', 'TEAM'],
'NCAAF': ['QB', 'WR1', 'WR2', 'WR3', 'FLEX', 'SFLEX'],
},
'Showdown': {
'MLB': ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'],
'NHL': ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'],
'NFL': ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'],
'LOL': ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'],
'NCAAF': ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'],
},
},
}
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']
st.markdown("""
<style>
/* Tab styling */
.stElementContainer [data-baseweb="button-group"] {
gap: 2.000rem;
padding: 4px;
}
.stElementContainer [kind="segmented_control"] {
height: 2.000rem;
white-space: pre-wrap;
background-color: #DAA520;
color: white;
border-radius: 20px;
gap: 1px;
padding: 10px 20px;
font-weight: bold;
transition: all 0.3s ease;
}
.stElementContainer [kind="segmented_controlActive"] {
height: 3.000rem;
background-color: #DAA520;
border: 3px solid #FFD700;
border-radius: 10px;
color: black;
}
.stElementContainer [kind="segmented_control"]:hover {
background-color: #FFD700;
cursor: pointer;
}
div[data-baseweb="select"] > div {
background-color: #DAA520;
color: white;
}
</style>""", unsafe_allow_html=True)
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[csv_file['Position'].isin(['RB', 'WR', 'TE'])]
elif sport_var == 'SOC':
filtered_df = csv_file[csv_file['Position'].str.contains('D|M|F', na=False, regex=True)]
elif sport_var == 'NCAAF':
filtered_df = csv_file[csv_file['Position'].str.contains('RB|WR', na=False, regex=True)]
elif sport_var == 'NHL':
filtered_df = csv_file[csv_file['Position'].str.contains('C|W|D', na=False, regex=True)]
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
if site_var == 'Draftkings':
filtered_df = filtered_df.sort_values(by='Salary', ascending=False).drop_duplicates(subset=['Name'])
return dict(zip(filtered_df['Name'], filtered_df['Name + ID']))
else:
filtered_df = filtered_df.sort_values(by='Salary', ascending=False).drop_duplicates(subset=['Nickname'])
return dict(zip(filtered_df['Nickname'], filtered_df['Id']))
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([1, 4, 4, 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
try:
selected_tab = st.segmented_control(
"Select Tab",
options=["Data Load", "Manage Portfolio"],
selection_mode='single',
default='Data Load',
label_visibility='collapsed',
width='stretch',
key='tab_selector'
)
except:
selected_tab = st.segmented_control(
"Select Tab",
options=["Data Load", "Manage Portfolio"],
selection_mode='single',
default='Data Load',
label_visibility='collapsed',
key='tab_selector'
)
if selected_tab == 'Data Load':
# 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:
if site_var == 'Draftkings':
csv_template_df = pd.DataFrame(columns=['Name', 'ID', 'Roster Position', 'Salary'])
else:
csv_template_df = pd.DataFrame(columns=['Nickname', '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']))
st.session_state['portfolio']['Stack'] = st.session_state['portfolio'].apply(
lambda row: Counter(
team_dict.get(player, '') for player in row[stack_column_dict[site_var][type_var][sport_var]]
if team_dict.get(player, '') != ''
).most_common(1)[0][0] if any(team_dict.get(player, '') for player in row[stack_column_dict[site_var][type_var][sport_var]]) else '',
axis=1
)
st.session_state['portfolio']['Size'] = st.session_state['portfolio'].apply(
lambda row: Counter(
team_dict.get(player, '') for player in row[stack_column_dict[site_var][type_var][sport_var]]
if team_dict.get(player, '') != ''
).most_common(1)[0][1] if any(team_dict.get(player, '') for player in row[stack_column_dict[site_var][type_var][sport_var]]) 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'] * 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']))
}
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
# )
if selected_tab == 'Manage Portfolio':
if 'origin_portfolio' in st.session_state and 'projections_df' in st.session_state:
with st.container():
reset_port_col, recalc_div_col, blank_reset_col, contest_size_col = st.columns([1, 1, 6, 4])
with reset_port_col:
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 recalc_div_col:
if st.button("Recalculate Diversity"):
st.session_state['display_frame']['Diversity'] = recalc_diversity(st.session_state['display_frame'], st.session_state['player_columns'])
with contest_size_col:
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']))
st.session_state['player_columns'] = [col for col in st.session_state['working_frame'].columns if col not in excluded_cols]
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'], check_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()
st.table(check_frame)
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'):
# recent changes for showdown included
with st.form(key='macro_filter_form'):
macro_min_col, macro_max_col = st.columns(2)
with macro_min_col:
min_salary = st.number_input("Min acceptable salary?", value=0, min_value=0, max_value=salary_max, step=100)
min_proj = st.number_input("Min acceptable projection?", value=0.0, min_value=0.0, max_value=500.0, step=1.0)
min_own = st.number_input("Min acceptable ownership?", value=0.0, min_value=0.0, max_value=500.0, step=1.0)
min_dupes = st.number_input("Min acceptable dupes?", value=0, min_value=0, max_value=1000, step=1)
min_finish_percentile = st.number_input("Min acceptable finish percentile?", value=0.00, min_value=0.00, max_value=1.00, step=.001)
min_lineup_edge = st.number_input("Min acceptable Lineup Edge?", value=-1.00, min_value=-1.00, max_value=1.00, step=.001)
with macro_max_col:
max_salary = st.number_input("Max acceptable salary?", value=salary_max, min_value=0, max_value=salary_max, step=100)
max_proj = st.number_input("Max acceptable projection?", value=500.0, min_value=0.0, max_value=500.0, step=1.0)
max_own = st.number_input("Max acceptable ownership?", value=500.0, min_value=0.0, max_value=500.0, step=1.0)
max_dupes = st.number_input("Max acceptable dupes?", value=1000, min_value=1, max_value=1000, step=1)
max_finish_percentile = st.number_input("Max acceptable finish percentile?", value=1.00, min_value=0.00, max_value=1.00, step=.001)
max_lineup_edge = st.number_input("Max acceptable Lineup Edge?", value=1.00, min_value=-1.00, max_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['salary'] >= min_salary]
parsed_frame = parsed_frame[parsed_frame['salary'] <= max_salary]
parsed_frame = parsed_frame[parsed_frame['median'] >= min_proj]
parsed_frame = parsed_frame[parsed_frame['median'] <= max_proj]
parsed_frame = parsed_frame[parsed_frame['Own'] >= min_own]
parsed_frame = parsed_frame[parsed_frame['Own'] <= max_own]
parsed_frame = parsed_frame[parsed_frame['Dupes'] >= min_dupes]
parsed_frame = parsed_frame[parsed_frame['Dupes'] <= max_dupes]
parsed_frame = parsed_frame[parsed_frame['Finish_percentile'] >= min_finish_percentile]
parsed_frame = parsed_frame[parsed_frame['Finish_percentile'] <= max_finish_percentile]
parsed_frame = parsed_frame[parsed_frame['Lineup Edge'] >= min_lineup_edge]
parsed_frame = parsed_frame[parsed_frame['Lineup Edge'] <= max_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['salary'] >= min_salary]
parsed_frame = parsed_frame[parsed_frame['salary'] <= max_salary]
parsed_frame = parsed_frame[parsed_frame['median'] >= min_proj]
parsed_frame = parsed_frame[parsed_frame['median'] <= max_proj]
parsed_frame = parsed_frame[parsed_frame['Own'] >= min_own]
parsed_frame = parsed_frame[parsed_frame['Own'] <= max_own]
parsed_frame = parsed_frame[parsed_frame['Dupes'] >= min_dupes]
parsed_frame = parsed_frame[parsed_frame['Dupes'] <= max_dupes]
parsed_frame = parsed_frame[parsed_frame['Finish_percentile'] >= min_finish_percentile]
parsed_frame = parsed_frame[parsed_frame['Finish_percentile'] <= max_finish_percentile]
parsed_frame = parsed_frame[parsed_frame['Lineup Edge'] >= min_lineup_edge]
parsed_frame = parsed_frame[parsed_frame['Lineup Edge'] <= max_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())
if type_var == 'Showdown':
cpt_flex_focus = st.selectbox("Focus on Overall, CPT, or FLEX?", options=['Overall', 'CPT', 'FLEX'], index=0)
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:
if type_var == 'Showdown':
if cpt_flex_focus == 'CPT':
remove_mask = parsed_frame.iloc[:, 0].apply(
lambda player: not any(remove_player in str(player) for remove_player in player_remove)
)
elif cpt_flex_focus == 'FLEX':
remove_mask = parsed_frame.iloc[:, 1:].apply(
lambda row: not any(player in list(row) for player in player_remove), axis=1
)
elif cpt_flex_focus == 'Overall':
remove_mask = parsed_frame[st.session_state['player_columns']].apply(
lambda row: not any(player in list(row) for player in player_remove), axis=1
)
else:
# Create mask for lineups that contain any of the removed players
remove_mask = parsed_frame[st.session_state['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:
if type_var == 'Showdown':
if cpt_flex_focus == 'CPT':
lock_mask = parsed_frame.iloc[:, 0].apply(
lambda player: any(lock_player in str(player) for lock_player in player_lock)
)
elif cpt_flex_focus == 'FLEX':
lock_mask = parsed_frame.iloc[:, 1:].apply(
lambda row: all(player in list(row) for player in player_lock), axis=1
)
elif cpt_flex_focus == 'Overall':
lock_mask = parsed_frame[st.session_state['player_columns']].apply(
lambda row: all(player in list(row) for player in player_lock), axis=1
)
else:
lock_mask = parsed_frame[st.session_state['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:
if type_var == 'Showdown':
if cpt_flex_focus == 'CPT':
team_frame = parsed_frame.iloc[:, 0].apply(
lambda x: x.map(st.session_state['map_dict']['team_map'])
)
include_mask = team_frame.apply(
lambda row: any(team in list(row) for team in team_include), axis=1
)
elif cpt_flex_focus == 'FLEX':
team_frame = parsed_frame.iloc[:, 1:].apply(
lambda x: x.map(st.session_state['map_dict']['team_map'])
)
include_mask = team_frame.apply(
lambda row: any(team in list(row) for team in team_include), axis=1
)
elif cpt_flex_focus == 'Overall':
team_frame = parsed_frame[st.session_state['player_columns']].apply(
lambda x: x.map(st.session_state['map_dict']['team_map'])
)
include_mask = team_frame.apply(
lambda row: any(team in list(row) for team in team_include), axis=1
)
else:
# Create a copy of the frame with player names replaced by teams, excluding SP1 and SP2
filtered_player_columns = [col for col in st.session_state['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:
if type_var == 'Showdown':
if cpt_flex_focus == 'CPT':
team_frame = parsed_frame.iloc[:, 0].apply(
lambda x: x.map(st.session_state['map_dict']['team_map'])
)
remove_mask = team_frame.apply(
lambda row: not any(team in list(row) for team in team_remove), axis=1
)
elif cpt_flex_focus == 'FLEX':
team_frame = parsed_frame.iloc[:, 1:].apply(
lambda x: x.map(st.session_state['map_dict']['team_map'])
)
remove_mask = team_frame.apply(
lambda row: not any(team in list(row) for team in team_remove), axis=1
)
elif cpt_flex_focus == 'Overall':
team_frame = parsed_frame[st.session_state['player_columns']].apply(
lambda x: x.map(st.session_state['map_dict']['team_map'])
)
remove_mask = team_frame.apply(
lambda row: not any(team in list(row) for team in team_remove), axis=1
)
else:
# Create a copy of the frame with player names replaced by teams, excluding SP1 and SP2
filtered_player_columns = [col for col in st.session_state['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:
if type_var == 'Showdown':
if cpt_flex_focus == 'CPT':
remove_mask = parsed_frame.iloc[:, 0].apply(
lambda player: not any(remove_player in str(player) for remove_player in player_remove)
)
elif cpt_flex_focus == 'FLEX':
remove_mask = parsed_frame.iloc[:, 1:].apply(
lambda row: not any(player in list(row) for player in player_remove), axis=1
)
elif cpt_flex_focus == 'Overall':
remove_mask = parsed_frame[st.session_state['player_columns']].apply(
lambda row: not any(player in list(row) for player in player_remove), axis=1
)
else:
remove_mask = parsed_frame[st.session_state['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:
if type_var == 'Showdown':
if cpt_flex_focus == 'CPT':
lock_mask = parsed_frame.iloc[:, 0].apply(
lambda player: any(lock_player in str(player) for lock_player in player_lock)
)
elif cpt_flex_focus == 'FLEX':
lock_mask = parsed_frame.iloc[:, 1:].apply(
lambda row: all(player in list(row) for player in player_lock), axis=1
)
elif cpt_flex_focus == 'Overall':
lock_mask = parsed_frame[st.session_state['player_columns']].apply(
lambda row: all(player in list(row) for player in player_lock), axis=1
)
else:
lock_mask = parsed_frame[st.session_state['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:
if type_var == 'Showdown':
if cpt_flex_focus == 'CPT':
team_frame = parsed_frame.iloc[:, 0].apply(
lambda x: x.map(st.session_state['map_dict']['team_map'])
)
include_mask = team_frame.apply(
lambda row: any(team in list(row) for team in team_include), axis=1
)
elif cpt_flex_focus == 'FLEX':
team_frame = parsed_frame.iloc[:, 1:].apply(
lambda x: x.map(st.session_state['map_dict']['team_map'])
)
include_mask = team_frame.apply(
lambda row: any(team in list(row) for team in team_include), axis=1
)
elif cpt_flex_focus == 'Overall':
team_frame = parsed_frame[st.session_state['player_columns']].apply(
lambda x: x.map(st.session_state['map_dict']['team_map'])
)
include_mask = team_frame.apply(
lambda row: any(team in list(row) for team in team_include), axis=1
)
else:
# Create a copy of the frame with player names replaced by teams, excluding SP1 and SP2
filtered_player_columns = [col for col in st.session_state['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:
if type_var == 'Showdown':
if cpt_flex_focus == 'CPT':
team_frame = parsed_frame.iloc[:, 0].apply(
lambda x: x.map(st.session_state['map_dict']['team_map'])
)
remove_mask = team_frame.apply(
lambda row: not any(team in list(row) for team in team_remove), axis=1
)
elif cpt_flex_focus == 'FLEX':
team_frame = parsed_frame.iloc[:, 1:].apply(
lambda x: x.map(st.session_state['map_dict']['team_map'])
)
remove_mask = team_frame.apply(
lambda row: not any(team in list(row) for team in team_remove), axis=1
)
elif cpt_flex_focus == 'Overall':
team_frame = parsed_frame[st.session_state['player_columns']].apply(
lambda x: x.map(st.session_state['map_dict']['team_map'])
)
remove_mask = team_frame.apply(
lambda row: not any(team in list(row) for team in team_remove), axis=1
)
else:
# Create a copy of the frame with player names replaced by teams, excluding SP1 and SP2
filtered_player_columns = [col for col in st.session_state['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('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('Conditionals Manager (players)'):
# a set of functions for removing lineups that contain a conditional between players and stacks
with st.form(key='conditional_players_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())
keep_remove_var = st.selectbox("Conditional:", options=['Keep', 'Remove'], index=0)
conditional_side_alpha = st.multiselect("Lineups containing:", options=sorted(list(player_names)), default=[])
cpt_flex_alpha = st.selectbox("in slot:", options=['Overall', 'CPT', 'FLEX'], index=0, key='cpt_flex_alpha')
conditional_var = st.selectbox("where they also contain:", options=['Any', 'All', 'None'], index=0)
conditional_side_beta = st.multiselect("of the following player(s):", options=sorted(list(player_names)), default=[])
cpt_flex_beta = st.selectbox("in slot:", options=['Overall', 'CPT', 'FLEX'], index=0, key='cpt_flex_beta')
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()
# Check if we have players selected for both alpha and beta sides
if conditional_side_alpha and conditional_side_beta:
# Create boolean mask for rows containing ALL players from alpha side
alpha_mask = pd.Series([True] * len(parsed_frame), index=parsed_frame.index)
for player in conditional_side_alpha:
if type_var == 'Showdown':
if cpt_flex_alpha == 'Overall':
player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
elif cpt_flex_alpha == 'CPT':
player_present = parsed_frame.iloc[:, 0].apply(lambda row: player in row)
elif cpt_flex_alpha == 'FLEX':
player_present = parsed_frame.iloc[:, 1:].apply(lambda row: player in row.values, axis=1)
else:
player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
alpha_mask = alpha_mask & player_present
# Only apply beta logic to rows that match alpha condition
rows_to_process = alpha_mask
# For rows that match alpha condition, check beta condition
if conditional_var == 'Any':
# Check if row contains ANY of the beta players
beta_mask = pd.Series([False] * len(parsed_frame), index=parsed_frame.index)
for player in conditional_side_beta:
if type_var == 'Showdown':
if cpt_flex_beta == 'Overall':
player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
elif cpt_flex_beta == 'CPT':
player_present = parsed_frame.iloc[:, 0].apply(lambda row: player in row)
elif cpt_flex_beta == 'FLEX':
player_present = parsed_frame.iloc[:, 1:].apply(lambda row: player in row.values, axis=1)
else:
player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
beta_mask = beta_mask | player_present
elif conditional_var == 'All':
# Check if row contains ALL of the beta players
beta_mask = pd.Series([True] * len(parsed_frame), index=parsed_frame.index)
for player in conditional_side_beta:
if type_var == 'Showdown':
if cpt_flex_beta == 'Overall':
player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
elif cpt_flex_beta == 'CPT':
player_present = parsed_frame.iloc[:, 0].apply(lambda row: player in row)
elif cpt_flex_beta == 'FLEX':
player_present = parsed_frame.iloc[:, 1:].apply(lambda row: player in row.values, axis=1)
else:
player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
beta_mask = beta_mask & player_present
elif conditional_var == 'None':
# Check if row contains NONE of the beta players
beta_mask = pd.Series([True] * len(parsed_frame), index=parsed_frame.index)
for player in conditional_side_beta:
if type_var == 'Showdown':
if cpt_flex_beta == 'Overall':
player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
elif cpt_flex_beta == 'CPT':
player_present = parsed_frame.iloc[:, 0].apply(lambda row: player in row)
elif cpt_flex_beta == 'FLEX':
player_present = parsed_frame.iloc[:, 1:].apply(lambda row: player in row.values, axis=1)
else:
player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
beta_mask = beta_mask & (~player_present)
# Combine conditions: alpha_mask AND beta_mask
final_condition = rows_to_process & beta_mask
# Apply keep or remove logic
if keep_remove_var == 'Keep':
parsed_frame = parsed_frame[~rows_to_process | final_condition]
else: # Remove
parsed_frame = parsed_frame[~final_condition]
elif conditional_side_alpha:
# Only alpha side specified - filter based on presence of alpha players
alpha_mask = pd.Series([True] * len(parsed_frame), index=parsed_frame.index)
for player in conditional_side_alpha:
if type_var == 'Showdown':
if cpt_flex_alpha == 'Overall':
player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
elif cpt_flex_alpha == 'CPT':
player_present = parsed_frame.iloc[:, 0].apply(lambda row: player in row)
elif cpt_flex_alpha == 'FLEX':
player_present = parsed_frame.iloc[:, 1:].apply(lambda row: player in row.values, axis=1)
else:
player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
alpha_mask = alpha_mask & player_present
if keep_remove_var == 'Keep':
parsed_frame = parsed_frame[alpha_mask]
else: # Remove
parsed_frame = parsed_frame[~alpha_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()
# Check if we have players selected for both alpha and beta sides
if conditional_side_alpha and conditional_side_beta:
# Create boolean mask for rows containing ALL players from alpha side
alpha_mask = pd.Series([True] * len(parsed_frame), index=parsed_frame.index)
for player in conditional_side_alpha:
if type_var == 'Showdown':
if cpt_flex_alpha == 'Overall':
player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
elif cpt_flex_alpha == 'CPT':
player_present = parsed_frame.iloc[:, 0].apply(lambda row: player in row)
elif cpt_flex_alpha == 'FLEX':
player_present = parsed_frame.iloc[:, 1:].apply(lambda row: player in row.values, axis=1)
else:
player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
alpha_mask = alpha_mask & player_present
# Only apply beta logic to rows that match alpha condition
rows_to_process = alpha_mask
# For rows that match alpha condition, check beta condition
if conditional_var == 'Any':
# Check if row contains ANY of the beta players
beta_mask = pd.Series([False] * len(parsed_frame), index=parsed_frame.index)
for player in conditional_side_beta:
if type_var == 'Showdown':
if cpt_flex_beta == 'Overall':
player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
elif cpt_flex_beta == 'CPT':
player_present = parsed_frame.iloc[:, 0].apply(lambda row: player in row)
elif cpt_flex_beta == 'FLEX':
player_present = parsed_frame.iloc[:, 1:].apply(lambda row: player in row.values, axis=1)
else:
player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
beta_mask = beta_mask | player_present
elif conditional_var == 'All':
# Check if row contains ALL of the beta players
beta_mask = pd.Series([True] * len(parsed_frame), index=parsed_frame.index)
for player in conditional_side_beta:
if type_var == 'Showdown':
if cpt_flex_beta == 'Overall':
player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
elif cpt_flex_beta == 'CPT':
player_present = parsed_frame.iloc[:, 0].apply(lambda row: player in row)
elif cpt_flex_beta == 'FLEX':
player_present = parsed_frame.iloc[:, 1:].apply(lambda row: player in row.values, axis=1)
else:
player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
beta_mask = beta_mask & player_present
elif conditional_var == 'None':
# Check if row contains NONE of the beta players
beta_mask = pd.Series([True] * len(parsed_frame), index=parsed_frame.index)
for player in conditional_side_beta:
if type_var == 'Showdown':
if cpt_flex_beta == 'Overall':
player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
elif cpt_flex_beta == 'CPT':
player_present = parsed_frame.iloc[:, 0].apply(lambda row: player in row)
elif cpt_flex_beta == 'FLEX':
player_present = parsed_frame.iloc[:, 1:].apply(lambda row: player in row.values, axis=1)
else:
player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
beta_mask = beta_mask & (~player_present)
# Combine conditions: alpha_mask AND beta_mask
final_condition = rows_to_process & beta_mask
# Apply keep or remove logic
if keep_remove_var == 'Keep':
parsed_frame = parsed_frame[~rows_to_process | final_condition]
else: # Remove
parsed_frame = parsed_frame[~final_condition]
elif conditional_side_alpha:
# Only alpha side specified - filter based on presence of alpha players
alpha_mask = pd.Series([True] * len(parsed_frame), index=parsed_frame.index)
for player in conditional_side_alpha:
if type_var == 'Showdown':
if cpt_flex_alpha == 'Overall':
player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
elif cpt_flex_alpha == 'CPT':
player_present = parsed_frame.iloc[:, 0].apply(lambda row: player in row)
elif cpt_flex_alpha == 'FLEX':
player_present = parsed_frame.iloc[:, 1:].apply(lambda row: player in row.values, axis=1)
else:
player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
alpha_mask = alpha_mask & player_present
if keep_remove_var == 'Keep':
parsed_frame = parsed_frame[alpha_mask]
else: # Remove
parsed_frame = parsed_frame[~alpha_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('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:
ignore_stacks = st.multiselect("Ignore Specific Stacks?", options=sorted(list(set(st.session_state['projections_df']['team'].unique()))), default=[])
else:
ignore_stacks = []
remove_teams_exposure = st.multiselect("Removed/Locked teams?", options=sorted(list(set(st.session_state['projections_df']['team'].unique()))), default=[])
specific_replacements = st.multiselect("Specific Replacements?", options=sorted(list(set(st.session_state['projections_df']['player_names'].unique()))), default=[])
# Considering making it so Showdown is CPT/FLEX not column specific but eh
specific_columns = st.multiselect("Specific Positions?", options=sorted(list(st.session_state['player_columns'])), 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, ignore_stacks, remove_teams_exposure, specific_replacements, specific_columns, 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, ignore_stacks, remove_teams_exposure, specific_replacements, specific_columns, 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, clear_export, add_rows_col, remove_rows_col, blank_export_col = st.columns([1, 1, 1, 2, 2, 6])
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 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']
with add_rows_col:
select_custom_index = st.multiselect("Select rows to add (based on first column):", options=st.session_state['display_frame'].index, default=[])
if st.button("Add selected to Custom Export"):
st.session_state['export_base'] = pd.concat([st.session_state['export_base'], st.session_state['display_frame'].loc[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 remove_rows_col:
remove_custom_index = st.multiselect("Remove rows (based on first column):", options=st.session_state['display_frame'].index, default=[])
if st.button("Remove selected from Display"):
st.session_state['display_frame'] = st.session_state['display_frame'].drop(remove_custom_index)
st.session_state['display_frame'] = st.session_state['display_frame'].drop_duplicates()
st.session_state['display_frame'] = st.session_state['display_frame'].reset_index(drop=True)
total_rows = len(st.session_state['display_frame'])
rows_per_page = 500
total_pages = (total_rows + rows_per_page - 1) // rows_per_page # Ceiling division
# Initialize page number in session state if not exists
if 'current_page' not in st.session_state:
st.session_state.current_page = 1
# Display current page range info and pagination control in a single line
st.write(
f"Showing rows {(st.session_state.current_page - 1) * rows_per_page + 1} "
f"to {min(st.session_state.current_page * rows_per_page, total_rows)} of {total_rows}"
)
# Add page number input
st.session_state.current_page = st.number_input(
f"Page (1-{total_pages})",
min_value=1,
max_value=total_pages,
value=st.session_state.current_page
)
# Calculate start and end indices for current page
start_idx = (st.session_state.current_page - 1) * rows_per_page
end_idx = min(start_idx + rows_per_page, total_rows)
# Get the subset of data for the current page
current_page_data = 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
)
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 = []
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'][st.session_state['player_columns']].apply(
lambda row: player in list(row), axis=1
)
if player_mask.any():
player_stats.append({
'Player': player,
'Position': st.session_state['map_dict']['pos_map'][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(),
'Avg Diversity': st.session_state['display_frame'][player_mask]['Diversity'].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'][st.session_state['player_columns'][0]] == player
if cpt_mask.any():
player_stats.append({
'Player': f"{player} (CPT)",
'Position': st.session_state['map_dict']['pos_map'][player],
'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(),
'Avg Diversity': st.session_state['display_frame'][cpt_mask]['Diversity'].mean(),
})
# Create mask for lineups where this player is FLEX (other columns)
flex_mask = st.session_state['display_frame'][st.session_state['player_columns'][1:]].apply(
lambda row: player in list(row), axis=1
)
if flex_mask.any():
player_stats.append({
'Player': f"{player} (FLEX)",
'Position': st.session_state['map_dict']['pos_map'][player],
'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(),
'Avg Diversity': st.session_state['display_frame'][flex_mask]['Diversity'].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'][st.session_state['player_columns'][0]] == player
if cpt_mask.any():
player_stats.append({
'Player': f"{player} (CPT)",
'Position': st.session_state['map_dict']['pos_map'][player],
'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(),
'Avg Diversity': st.session_state['display_frame'][cpt_mask]['Diversity'].mean(),
})
# Create mask for lineups where this player is FLEX (other columns)
flex_mask = st.session_state['display_frame'][st.session_state['player_columns'][1:]].apply(
lambda row: player in list(row), axis=1
)
if flex_mask.any():
player_stats.append({
'Player': f"{player} (FLEX)",
'Position': st.session_state['map_dict']['pos_map'][player],
'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(),
'Avg Diversity': st.session_state['display_frame'][flex_mask]['Diversity'].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'][st.session_state['player_columns']].apply(
lambda row: player in list(row), axis=1
)
if player_mask.any():
player_stats.append({
'Player': player,
'Position': st.session_state['map_dict']['pos_map'][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(),
'Avg Diversity': st.session_state['display_frame'][player_mask]['Diversity'].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%}',
'Avg Diversity': '{:.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(),
'Avg Diversity': st.session_state['display_frame'][stack_mask]['Diversity'].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%}',
'Avg Diversity': '{:.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
with st.form("combo_analysis_form"):
combo_size_col, columns_excluded_col, combo_analyze_col = st.columns(3)
with combo_size_col:
combo_size = st.selectbox("Combo Size", [2, 3], key='combo_size')
with columns_excluded_col:
try:
excluded_cols_extended = st.multiselect("Exclude Columns?", st.session_state['display_frame'].drop(columns=excluded_cols).columns, key='excluded_cols_extended')
except:
excluded_cols_extended = st.multiselect("Exclude Columns?", st.session_state['display_frame'].columns, key='excluded_cols_extended')
with combo_analyze_col:
submitted = st.form_submit_button("Analyze Combos")
if submitted:
st.session_state['combo_analysis'] = analyze_player_combos(
st.session_state['display_frame'], excluded_cols + excluded_cols_extended, 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%}',
'Avg Diversity': '{:.2%}'
}),
height=400,
use_container_width=True
)
else:
st.info("Click 'Analyze Combos' to see the most common player combinations.")