|
|
import streamlit as st |
|
|
st.set_page_config(layout="wide") |
|
|
import pandas as pd |
|
|
import pytz |
|
|
from rapidfuzz import process |
|
|
from collections import Counter |
|
|
import io |
|
|
|
|
|
|
|
|
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 |
|
|
from global_func.optimize_lineup import optimize_lineup |
|
|
|
|
|
from database_queries import * |
|
|
from database import * |
|
|
|
|
|
pos_parse_mapping = { |
|
|
'Projection': 'proj_map', |
|
|
'Ownership': 'own_map', |
|
|
'Salary': 'salary_map', |
|
|
'Position': 'pos_map', |
|
|
'Team': 'team_map' |
|
|
} |
|
|
|
|
|
pos_parse_options = list(pos_parse_mapping.keys()) |
|
|
|
|
|
showdown_selections = ['Showdown #1', 'Showdown #2', 'Showdown #3', 'Showdown #4', 'Showdown #5', 'Showdown #6', 'Showdown #7', 'Showdown #8', 'Showdown #9', 'Showdown #10', 'Showdown #11', 'Showdown #12', 'Showdown #13', 'Showdown #14', 'Showdown #15'] |
|
|
dk_db_nfl_showdown_selections = ['DK_NFL_SD_seed_frame_Showdown #1', 'DK_NFL_SD_seed_frame_Showdown #2', 'DK_NFL_SD_seed_frame_Showdown #3', 'DK_NFL_SD_seed_frame_Showdown #4', 'DK_NFL_SD_seed_frame_Showdown #5', 'DK_NFL_SD_seed_frame_Showdown #6', |
|
|
'DK_NFL_SD_seed_frame_Showdown #7', 'DK_NFL_SD_seed_frame_Showdown #8', 'DK_NFL_SD_seed_frame_Showdown #9', 'DK_NFL_SD_seed_frame_Showdown #10', 'DK_NFL_SD_seed_frame_Showdown #11', 'DK_NFL_SD_seed_frame_Showdown #12', 'DK_NFL_SD_seed_frame_Showdown #13', |
|
|
'DK_NFL_SD_seed_frame_Showdown #14', 'DK_NFL_SD_seed_frame_Showdown #15'] |
|
|
fd_db_nfl_showdown_selections = ['FD_NFL_SD_seed_frame_Showdown #1', 'FD_NFL_SD_seed_frame_Showdown #2', 'FD_NFL_SD_seed_frame_Showdown #3', 'FD_NFL_SD_seed_frame_Showdown #4', 'FD_NFL_SD_seed_frame_Showdown #5', 'FD_NFL_SD_seed_frame_Showdown #6', |
|
|
'FD_NFL_SD_seed_frame_Showdown #7', 'FD_NFL_SD_seed_frame_Showdown #8', 'FD_NFL_SD_seed_frame_Showdown #9', 'FD_NFL_SD_seed_frame_Showdown #10', 'FD_NFL_SD_seed_frame_Showdown #11', 'FD_NFL_SD_seed_frame_Showdown #12', 'FD_NFL_SD_seed_frame_Showdown #13', |
|
|
'FD_NFL_SD_seed_frame_Showdown #14', 'FD_NFL_SD_seed_frame_Showdown #15'] |
|
|
dk_db_nba_showdown_selections = ['DK_NBA_SD_seed_frame_Showdown #1', 'DK_NBA_SD_seed_frame_Showdown #2', 'DK_NBA_SD_seed_frame_Showdown #3', 'DK_NBA_SD_seed_frame_Showdown #4', 'DK_NBA_SD_seed_frame_Showdown #5', 'DK_NBA_SD_seed_frame_Showdown #6', |
|
|
'DK_NBA_SD_seed_frame_Showdown #7', 'DK_NBA_SD_seed_frame_Showdown #8', 'DK_NBA_SD_seed_frame_Showdown #9', 'DK_NBA_SD_seed_frame_Showdown #10', 'DK_NBA_SD_seed_frame_Showdown #11', 'DK_NBA_SD_seed_frame_Showdown #12', 'DK_NBA_SD_seed_frame_Showdown #13', |
|
|
'DK_NBA_SD_seed_frame_Showdown #14', 'DK_NBA_SD_seed_frame_Showdown #15'] |
|
|
fd_db_nba_showdown_selections = ['FD_NBA_SD_seed_frame_Showdown #1', 'FD_NBA_SD_seed_frame_Showdown #2', 'FD_NBA_SD_seed_frame_Showdown #3', 'FD_NBA_SD_seed_frame_Showdown #4', 'FD_NBA_SD_seed_frame_Showdown #5', 'FD_NBA_SD_seed_frame_Showdown #6', |
|
|
'FD_NBA_SD_seed_frame_Showdown #7', 'FD_NBA_SD_seed_frame_Showdown #8', 'FD_NBA_SD_seed_frame_Showdown #9', 'FD_NBA_SD_seed_frame_Showdown #10', 'FD_NBA_SD_seed_frame_Showdown #11', 'FD_NBA_SD_seed_frame_Showdown #12', 'FD_NBA_SD_seed_frame_Showdown #13', |
|
|
'FD_NBA_SD_seed_frame_Showdown #14', 'FD_NBA_SD_seed_frame_Showdown #15'] |
|
|
dk_db_nhl_showdown_selections = ['DK_NHL_SD_seed_frame_Showdown #1', 'DK_NHL_SD_seed_frame_Showdown #2', 'DK_NHL_SD_seed_frame_Showdown #3', 'DK_NHL_SD_seed_frame_Showdown #4', 'DK_NHL_SD_seed_frame_Showdown #5', 'DK_NHL_SD_seed_frame_Showdown #6', |
|
|
'DK_NHL_SD_seed_frame_Showdown #7', 'DK_NHL_SD_seed_frame_Showdown #8', 'DK_NHL_SD_seed_frame_Showdown #9', 'DK_NHL_SD_seed_frame_Showdown #10', 'DK_NHL_SD_seed_frame_Showdown #11', 'DK_NHL_SD_seed_frame_Showdown #12', 'DK_NHL_SD_seed_frame_Showdown #13', |
|
|
'DK_NHL_SD_seed_frame_Showdown #14', 'DK_NHL_SD_seed_frame_Showdown #15'] |
|
|
fd_db_nhl_showdown_selections = ['FD_NHL_SD_seed_frame_Showdown #1', 'FD_NHL_SD_seed_frame_Showdown #2', 'FD_NHL_SD_seed_frame_Showdown #3', 'FD_NHL_SD_seed_frame_Showdown #4', 'FD_NHL_SD_seed_frame_Showdown #5', 'FD_NHL_SD_seed_frame_Showdown #6', |
|
|
'FD_NHL_SD_seed_frame_Showdown #7', 'FD_NHL_SD_seed_frame_Showdown #8', 'FD_NHL_SD_seed_frame_Showdown #9', 'FD_NHL_SD_seed_frame_Showdown #10', 'FD_NHL_SD_seed_frame_Showdown #11', 'FD_NHL_SD_seed_frame_Showdown #12', 'FD_NHL_SD_seed_frame_Showdown #13', |
|
|
'FD_NHL_SD_seed_frame_Showdown #14', 'FD_NHL_SD_seed_frame_Showdown #15'] |
|
|
dk_db_mma_showdown_selections = ['DK_MMA_SD_seed_frame_Showdown #1', 'DK_MMA_SD_seed_frame_Showdown #2', 'DK_MMA_SD_seed_frame_Showdown #3', 'DK_MMA_SD_seed_frame_Showdown #4', 'DK_MMA_SD_seed_frame_Showdown #5', 'DK_MMA_SD_seed_frame_Showdown #6', |
|
|
'DK_MMA_SD_seed_frame_Showdown #7', 'DK_MMA_SD_seed_frame_Showdown #8', 'DK_MMA_SD_seed_frame_Showdown #9', 'DK_MMA_SD_seed_frame_Showdown #10', 'DK_MMA_SD_seed_frame_Showdown #11', 'DK_MMA_SD_seed_frame_Showdown #12', 'DK_MMA_SD_seed_frame_Showdown #13', |
|
|
'DK_MMA_SD_seed_frame_Showdown #14', 'DK_MMA_SD_seed_frame_Showdown #15'] |
|
|
fd_db_mma_showdown_selections = ['FD_MMA_SD_seed_frame_Showdown #1', 'FD_MMA_SD_seed_frame_Showdown #2', 'FD_MMA_SD_seed_frame_Showdown #3', 'FD_MMA_SD_seed_frame_Showdown #4', 'FD_MMA_SD_seed_frame_Showdown #5', 'FD_MMA_SD_seed_frame_Showdown #6', |
|
|
'FD_MMA_SD_seed_frame_Showdown #7', 'FD_MMA_SD_seed_frame_Showdown #8', 'FD_MMA_SD_seed_frame_Showdown #9', 'FD_MMA_SD_seed_frame_Showdown #10', 'FD_MMA_SD_seed_frame_Showdown #11', 'FD_MMA_SD_seed_frame_Showdown #12', 'FD_MMA_SD_seed_frame_Showdown #13', |
|
|
'FD_MMA_SD_seed_frame_Showdown #14', 'FD_MMA_SD_seed_frame_Showdown #15'] |
|
|
dk_db_pga_showdown_selections = ['DK_PGA_SD_seed_frame_Showdown #1', 'DK_PGA_SD_seed_frame_Showdown #2', 'DK_PGA_SD_seed_frame_Showdown #3', 'DK_PGA_SD_seed_frame_Showdown #4', 'DK_PGA_SD_seed_frame_Showdown #5', 'DK_PGA_SD_seed_frame_Showdown #6', |
|
|
'DK_PGA_SD_seed_frame_Showdown #7', 'DK_PGA_SD_seed_frame_Showdown #8', 'DK_PGA_SD_seed_frame_Showdown #9', 'DK_PGA_SD_seed_frame_Showdown #10', 'DK_PGA_SD_seed_frame_Showdown #11', 'DK_PGA_SD_seed_frame_Showdown #12', 'DK_PGA_SD_seed_frame_Showdown #13', |
|
|
'DK_PGA_SD_seed_frame_Showdown #14', 'DK_PGA_SD_seed_frame_Showdown #15'] |
|
|
fd_db_pga_showdown_selections = ['FD_PGA_SD_seed_frame_Showdown #1', 'FD_PGA_SD_seed_frame_Showdown #2', 'FD_PGA_SD_seed_frame_Showdown #3', 'FD_PGA_SD_seed_frame_Showdown #4', 'FD_PGA_SD_seed_frame_Showdown #5', 'FD_PGA_SD_seed_frame_Showdown #6', |
|
|
'FD_PGA_SD_seed_frame_Showdown #7', 'FD_PGA_SD_seed_frame_Showdown #8', 'FD_PGA_SD_seed_frame_Showdown #9', 'FD_PGA_SD_seed_frame_Showdown #10', 'FD_PGA_SD_seed_frame_Showdown #11', 'FD_PGA_SD_seed_frame_Showdown #12', 'FD_PGA_SD_seed_frame_Showdown #13', |
|
|
'FD_PGA_SD_seed_frame_Showdown #14', 'FD_PGA_SD_seed_frame_Showdown #15'] |
|
|
|
|
|
dk_nfl_showdown_db_translation = dict(zip(showdown_selections, dk_db_nfl_showdown_selections)) |
|
|
fd_nfl_showdown_db_translation = dict(zip(showdown_selections, fd_db_nfl_showdown_selections)) |
|
|
dk_nba_showdown_db_translation = dict(zip(showdown_selections, dk_db_nba_showdown_selections)) |
|
|
fd_nba_showdown_db_translation = dict(zip(showdown_selections, fd_db_nba_showdown_selections)) |
|
|
dk_nhl_showdown_db_translation = dict(zip(showdown_selections, dk_db_nhl_showdown_selections)) |
|
|
fd_nhl_showdown_db_translation = dict(zip(showdown_selections, fd_db_nhl_showdown_selections)) |
|
|
dk_mma_showdown_db_translation = dict(zip(showdown_selections, dk_db_mma_showdown_selections)) |
|
|
fd_mma_showdown_db_translation = dict(zip(showdown_selections, fd_db_mma_showdown_selections)) |
|
|
dk_pga_showdown_db_translation = dict(zip(showdown_selections, dk_db_pga_showdown_selections)) |
|
|
fd_pga_showdown_db_translation = dict(zip(showdown_selections, fd_db_pga_showdown_selections)) |
|
|
|
|
|
freq_format = {'Finish_percentile': '{:.2%}', 'Lineup Edge': '{:.2%}', 'Lineup Edge_Raw': '{:.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': ['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', 'UTIL'], |
|
|
'NFL': ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX'], |
|
|
'LOL': ['TOP', 'JNG', 'MID', 'ADC', 'SUP', 'TEAM'], |
|
|
'NCAAF': ['QB', 'WR1', 'WR2', 'WR3', 'FLEX', 'SFLEX'], |
|
|
'MMA': ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'], |
|
|
}, |
|
|
'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': ['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'UTIL1', 'UTIL2', 'G'], |
|
|
'NFL': ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX'], |
|
|
'LOL': ['TOP', 'JNG', 'MID', 'ADC', 'SUP', 'TEAM'], |
|
|
'NCAAF': ['QB', 'WR1', 'WR2', 'WR3', 'SFLEX'], |
|
|
'MMA': ['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'], |
|
|
}, |
|
|
'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'], |
|
|
}, |
|
|
}, |
|
|
} |
|
|
|
|
|
sport_position_lists = { |
|
|
'Draftkings': { |
|
|
'MLB': ['P', 'C', '1B', '2B', '3B', 'SS', 'OF'], |
|
|
'NHL': ['C', 'W', 'D', 'G'], |
|
|
'NFL': ['QB', 'RB', 'WR', 'TE'], |
|
|
'LOL': ['TOP', 'JNG', 'MID', 'ADC', 'SUP', 'TEAM'], |
|
|
'COD': ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'TEAM'], |
|
|
'NCAAF': ['QB', 'WR', 'RB'], |
|
|
'MMA': ['FLEX'], |
|
|
'GOLF': ['FLEX'], |
|
|
'TENNIS': ['FLEX'], |
|
|
'WNBA': ['G', 'F'], |
|
|
'NBA': ['PG', 'SG', 'SF', 'PF', 'C'], |
|
|
'NASCAR': ['FLEX'], |
|
|
'F1': ['DRIVER', 'CONST'], |
|
|
'SOC': ['F', 'M', 'D', 'GK'], |
|
|
}, |
|
|
'Fanduel': { |
|
|
'MLB': ['P', 'C', '1B', '2B', '3B', 'SS', 'OF'], |
|
|
'NHL': ['C', 'W', 'D', 'G'], |
|
|
'NFL': ['QB', 'RB', 'WR', 'TE'], |
|
|
'LOL': ['TOP', 'JNG', 'MID', 'ADC', 'SUP', 'TEAM'], |
|
|
'COD': ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'TEAM'], |
|
|
'NCAAF': ['QB', 'WR', 'RB'], |
|
|
'MMA': ['FLEX'], |
|
|
'GOLF': ['FLEX'], |
|
|
'TENNIS': ['FLEX'], |
|
|
'WNBA': ['G', 'F'], |
|
|
'NBA': ['PG', 'SG', 'SF', 'PF', 'C'], |
|
|
'NASCAR': ['FLEX'], |
|
|
'F1': ['DRIVER', 'CONST'], |
|
|
'SOC': ['F', 'M', 'D', 'GK'], |
|
|
}, |
|
|
} |
|
|
|
|
|
showdown_position_lists = ['CPT', 'FLEX'] |
|
|
|
|
|
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 grab_nfl_reg_salaries(slate_var: str): |
|
|
collection = salaries_db["NFL_reg_player_info"] |
|
|
eastern = pytz.timezone('US/Eastern') |
|
|
today_str = datetime.now(eastern).strftime("%Y%m%d") |
|
|
records = pd.DataFrame(list(collection.find({'Contest Date': {'$gte': today_str}}))) |
|
|
records = records[['Display Name', 'draftableId', 'Position', 'Salary']] |
|
|
records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'}) |
|
|
if slate_var == 'Main': |
|
|
records = records.sort_values(by='ID', ascending=True) |
|
|
records = records.drop_duplicates(subset=['Name'], keep='first') |
|
|
elif slate_var == 'Secondary': |
|
|
records = records.sort_values(by='ID', ascending=True) |
|
|
|
|
|
grouped = records.groupby('Name') |
|
|
middle_records = [] |
|
|
for name, group in grouped: |
|
|
if len(group) == 1: |
|
|
|
|
|
middle_records.append(group) |
|
|
elif len(group) == 2: |
|
|
|
|
|
middle_records.append(group.iloc[1:2]) |
|
|
else: |
|
|
|
|
|
|
|
|
|
|
|
middle_idx = len(group) // 2 |
|
|
middle_records.append(group.iloc[middle_idx:middle_idx+1]) |
|
|
records = pd.concat(middle_records, ignore_index=True) |
|
|
elif slate_var == 'Auxiliary': |
|
|
records = records.sort_values(by='ID', ascending=True) |
|
|
records = records.drop_duplicates(subset=['Name'], keep='last') |
|
|
return records |
|
|
|
|
|
def grab_nfl_showdown_salaries(): |
|
|
collection = salaries_db["NFL_showdown_player_info"] |
|
|
eastern = pytz.timezone('US/Eastern') |
|
|
today_str = datetime.now(eastern).strftime("%Y%m%d") |
|
|
records = pd.DataFrame(list(collection.find({'Contest Date': {'$gte': today_str}}))) |
|
|
records = records[['Display Name', 'draftableId', 'Position', 'Salary']] |
|
|
records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'}) |
|
|
return records |
|
|
|
|
|
def grab_nba_reg_salaries(slate_var: str): |
|
|
collection = salaries_db["NBA_reg_player_info"] |
|
|
eastern = pytz.timezone('US/Eastern') |
|
|
today_str = datetime.now(eastern).strftime("%Y%m%d") |
|
|
records = pd.DataFrame(list(collection.find({'Contest Date': {'$gte': today_str}}))) |
|
|
records = records[['Display Name', 'draftableId', 'Position', 'Salary']] |
|
|
records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'}) |
|
|
if slate_var == 'Main': |
|
|
records = records.sort_values(by='ID', ascending=True) |
|
|
records = records.drop_duplicates(subset=['Name'], keep='first') |
|
|
elif slate_var == 'Secondary': |
|
|
records = records.sort_values(by='ID', ascending=True) |
|
|
|
|
|
grouped = records.groupby('Name') |
|
|
middle_records = [] |
|
|
for name, group in grouped: |
|
|
if len(group) == 1: |
|
|
|
|
|
middle_records.append(group) |
|
|
elif len(group) == 2: |
|
|
|
|
|
middle_records.append(group.iloc[1:2]) |
|
|
else: |
|
|
|
|
|
|
|
|
|
|
|
middle_idx = len(group) // 2 |
|
|
middle_records.append(group.iloc[middle_idx:middle_idx+1]) |
|
|
records = pd.concat(middle_records, ignore_index=True) |
|
|
elif slate_var == 'Auxiliary': |
|
|
records = records.sort_values(by='ID', ascending=True) |
|
|
records = records.drop_duplicates(subset=['Name'], keep='last') |
|
|
return records |
|
|
|
|
|
def grab_nba_showdown_salaries(): |
|
|
collection = salaries_db["NBA_showdown_player_info"] |
|
|
|
|
|
eastern = pytz.timezone('US/Eastern') |
|
|
today_str = datetime.now(eastern).strftime("%Y%m%d") |
|
|
print(f"Current date in Eastern Time: {today_str}") |
|
|
records = pd.DataFrame(list(collection.find({'Contest Date': {'$gte': today_str}}))) |
|
|
records = records[['Display Name', 'draftableId', 'Position', 'Salary']] |
|
|
records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'}) |
|
|
return records |
|
|
|
|
|
def grab_mlb_reg_salaries(slate_var: str): |
|
|
collection = salaries_db["MLB_reg_player_info"] |
|
|
eastern = pytz.timezone('US/Eastern') |
|
|
today_str = datetime.now(eastern).strftime("%Y%m%d") |
|
|
records = pd.DataFrame(list(collection.find({'Contest Date': {'$gte': today_str}}))) |
|
|
records = records[['Display Name', 'draftableId', 'Position', 'Salary']] |
|
|
records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'}) |
|
|
if slate_var == 'Main': |
|
|
records = records.sort_values(by='ID', ascending=True) |
|
|
records = records.drop_duplicates(subset=['Name'], keep='first') |
|
|
elif slate_var == 'Secondary': |
|
|
records = records.sort_values(by='ID', ascending=True) |
|
|
|
|
|
grouped = records.groupby('Name') |
|
|
middle_records = [] |
|
|
for name, group in grouped: |
|
|
if len(group) == 1: |
|
|
|
|
|
middle_records.append(group) |
|
|
elif len(group) == 2: |
|
|
|
|
|
middle_records.append(group.iloc[1:2]) |
|
|
else: |
|
|
|
|
|
|
|
|
|
|
|
middle_idx = len(group) // 2 |
|
|
middle_records.append(group.iloc[middle_idx:middle_idx+1]) |
|
|
records = pd.concat(middle_records, ignore_index=True) |
|
|
elif slate_var == 'Auxiliary': |
|
|
records = records.sort_values(by='ID', ascending=True) |
|
|
records = records.drop_duplicates(subset=['Name'], keep='last') |
|
|
return records |
|
|
|
|
|
def grab_mlb_showdown_salaries(): |
|
|
collection = salaries_db["MLB_showdown_player_info"] |
|
|
eastern = pytz.timezone('US/Eastern') |
|
|
today_str = datetime.now(eastern).strftime("%Y%m%d") |
|
|
records = pd.DataFrame(list(collection.find({'Contest Date': {'$gte': today_str}}))) |
|
|
records = records[['Display Name', 'draftableId', 'Position', 'Salary']] |
|
|
records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'}) |
|
|
return records |
|
|
|
|
|
def grab_nhl_reg_salaries(slate_var: str): |
|
|
collection = salaries_db["NHL_reg_player_info"] |
|
|
eastern = pytz.timezone('US/Eastern') |
|
|
today_str = datetime.now(eastern).strftime("%Y%m%d") |
|
|
records = pd.DataFrame(list(collection.find({'Contest Date': {'$gte': today_str}}))) |
|
|
records = records[['Display Name', 'draftableId', 'Position', 'Salary']] |
|
|
records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'}) |
|
|
if slate_var == 'Main': |
|
|
records = records.sort_values(by='ID', ascending=True) |
|
|
records = records.drop_duplicates(subset=['Name'], keep='first') |
|
|
elif slate_var == 'Secondary': |
|
|
records = records.sort_values(by='ID', ascending=True) |
|
|
|
|
|
grouped = records.groupby('Name') |
|
|
middle_records = [] |
|
|
for name, group in grouped: |
|
|
if len(group) == 1: |
|
|
|
|
|
middle_records.append(group) |
|
|
elif len(group) == 2: |
|
|
|
|
|
middle_records.append(group.iloc[1:2]) |
|
|
else: |
|
|
|
|
|
|
|
|
|
|
|
middle_idx = len(group) // 2 |
|
|
middle_records.append(group.iloc[middle_idx:middle_idx+1]) |
|
|
records = pd.concat(middle_records, ignore_index=True) |
|
|
elif slate_var == 'Auxiliary': |
|
|
records = records.sort_values(by='ID', ascending=True) |
|
|
records = records.drop_duplicates(subset=['Name'], keep='last') |
|
|
return records |
|
|
|
|
|
def grab_nhl_showdown_salaries(): |
|
|
collection = salaries_db["NHL_showdown_player_info"] |
|
|
eastern = pytz.timezone('US/Eastern') |
|
|
today_str = datetime.now(eastern).strftime("%Y%m%d") |
|
|
records = pd.DataFrame(list(collection.find({'Contest Date': {'$gte': today_str}}))) |
|
|
records = records[['Display Name', 'draftableId', 'Position', 'Salary']] |
|
|
records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'}) |
|
|
return records |
|
|
|
|
|
def grab_mma_reg_salaries(slate_var: str): |
|
|
collection = salaries_db["MMA_reg_player_info"] |
|
|
eastern = pytz.timezone('US/Eastern') |
|
|
today_str = datetime.now(eastern).strftime("%Y%m%d") |
|
|
records = pd.DataFrame(list(collection.find({'Contest Date': {'$gte': today_str}}))) |
|
|
records = records[['Display Name', 'draftableId', 'Position', 'Salary']] |
|
|
records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'}) |
|
|
if slate_var == 'Main': |
|
|
records = records.sort_values(by='ID', ascending=True) |
|
|
records = records.drop_duplicates(subset=['Name'], keep='first') |
|
|
elif slate_var == 'Secondary': |
|
|
records = records.sort_values(by='ID', ascending=True) |
|
|
|
|
|
grouped = records.groupby('Name') |
|
|
middle_records = [] |
|
|
for name, group in grouped: |
|
|
if len(group) == 1: |
|
|
|
|
|
middle_records.append(group) |
|
|
elif len(group) == 2: |
|
|
|
|
|
middle_records.append(group.iloc[1:2]) |
|
|
else: |
|
|
|
|
|
|
|
|
|
|
|
middle_idx = len(group) // 2 |
|
|
middle_records.append(group.iloc[middle_idx:middle_idx+1]) |
|
|
records = pd.concat(middle_records, ignore_index=True) |
|
|
elif slate_var == 'Auxiliary': |
|
|
records = records.sort_values(by='ID', ascending=True) |
|
|
records = records.drop_duplicates(subset=['Name'], keep='last') |
|
|
return records |
|
|
|
|
|
def grab_mma_showdown_salaries(): |
|
|
collection = salaries_db["MMA_showdown_player_info"] |
|
|
eastern = pytz.timezone('US/Eastern') |
|
|
today_str = datetime.now(eastern).strftime("%Y%m%d") |
|
|
records = pd.DataFrame(list(collection.find({'Contest Date': {'$gte': today_str}}))) |
|
|
records = records[['Display Name', 'draftableId', 'Position', 'Salary']] |
|
|
records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'}) |
|
|
return records |
|
|
|
|
|
def grab_pga_reg_salaries(slate_var: str): |
|
|
collection = salaries_db["PGA_reg_player_info"] |
|
|
eastern = pytz.timezone('US/Eastern') |
|
|
today_str = datetime.now(eastern).strftime("%Y%m%d") |
|
|
records = pd.DataFrame(list(collection.find({'Contest Date': {'$gte': today_str}}))) |
|
|
records = records[['Display Name', 'draftableId', 'Position', 'Salary']] |
|
|
records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'}) |
|
|
if slate_var == 'Main': |
|
|
records = records.sort_values(by='ID', ascending=True) |
|
|
records = records.drop_duplicates(subset=['Name'], keep='first') |
|
|
elif slate_var == 'Secondary': |
|
|
records = records.sort_values(by='ID', ascending=True) |
|
|
|
|
|
grouped = records.groupby('Name') |
|
|
middle_records = [] |
|
|
for name, group in grouped: |
|
|
if len(group) == 1: |
|
|
|
|
|
middle_records.append(group) |
|
|
elif len(group) == 2: |
|
|
|
|
|
middle_records.append(group.iloc[1:2]) |
|
|
else: |
|
|
|
|
|
|
|
|
|
|
|
middle_idx = len(group) // 2 |
|
|
middle_records.append(group.iloc[middle_idx:middle_idx+1]) |
|
|
records = pd.concat(middle_records, ignore_index=True) |
|
|
elif slate_var == 'Auxiliary': |
|
|
records = records.sort_values(by='ID', ascending=True) |
|
|
records = records.drop_duplicates(subset=['Name'], keep='last') |
|
|
return records |
|
|
|
|
|
def grab_pga_showdown_salaries(): |
|
|
collection = salaries_db["PGA_showdown_player_info"] |
|
|
eastern = pytz.timezone('US/Eastern') |
|
|
today_str = datetime.now(eastern).strftime("%Y%m%d") |
|
|
records = pd.DataFrame(list(collection.find({'Contest Date': {'$gte': today_str}}))) |
|
|
records = records[['Display Name', 'draftableId', 'Position', 'Salary']] |
|
|
records = records.rename(columns={'Display Name': 'Name', 'draftableId': 'ID', 'Position': 'Roster Position'}) |
|
|
return records |
|
|
|
|
|
def define_dk_nfl_showdown_slates(): |
|
|
collection = nfl_db["DK_SD_NFL_ROO"] |
|
|
cursor = collection.find() |
|
|
raw_display = pd.DataFrame(list(cursor)) |
|
|
unique_slates = raw_display['slate'].unique() |
|
|
|
|
|
slate_names = [] |
|
|
|
|
|
for slate in unique_slates: |
|
|
slate_data = raw_display[raw_display['slate'] == slate] |
|
|
slate_name = slate_data.iloc[0]['Team'] + ' vs. ' + slate_data.iloc[0]['Opp'] |
|
|
slate_names.append(slate_name) |
|
|
|
|
|
slate_name_lookup = dict(zip(slate_names, unique_slates)) |
|
|
return slate_names, slate_name_lookup |
|
|
|
|
|
def define_fd_nfl_showdown_slates(): |
|
|
collection = nfl_db["FD_SD_NFL_ROO"] |
|
|
cursor = collection.find() |
|
|
raw_display = pd.DataFrame(list(cursor)) |
|
|
unique_slates = raw_display['slate'].unique() |
|
|
|
|
|
slate_names = [] |
|
|
|
|
|
for slate in unique_slates: |
|
|
slate_data = raw_display[raw_display['slate'] == slate] |
|
|
slate_name = slate_data.iloc[0]['Team'] + ' vs. ' + slate_data.iloc[0]['Opp'] |
|
|
slate_names.append(slate_name) |
|
|
|
|
|
slate_name_lookup = dict(zip(slate_names, unique_slates)) |
|
|
return slate_names, slate_name_lookup |
|
|
|
|
|
try: |
|
|
nfl_slate_names_dk, nfl_slate_name_lookup_dk = define_dk_nfl_showdown_slates() |
|
|
except: |
|
|
nfl_slate_names_dk = [] |
|
|
nfl_slate_name_lookup_dk = {} |
|
|
|
|
|
try: |
|
|
nfl_slate_names_fd, nfl_slate_name_lookup_fd = define_fd_nfl_showdown_slates() |
|
|
except: |
|
|
nfl_slate_names_fd = [] |
|
|
nfl_slate_name_lookup_fd = {} |
|
|
|
|
|
def define_dk_nba_showdown_slates(): |
|
|
collection = nba_db["Player_SD_Range_Of_Outcomes"] |
|
|
cursor = collection.find() |
|
|
raw_display = pd.DataFrame(list(cursor)) |
|
|
raw_display = raw_display[raw_display['site'] == 'Draftkings'] |
|
|
unique_slates = raw_display['slate'].unique() |
|
|
|
|
|
slate_names = [] |
|
|
|
|
|
for slate in unique_slates: |
|
|
slate_data = raw_display[raw_display['slate'] == slate] |
|
|
slate_name = slate_data.iloc[0]['Team'] + ' vs. ' + slate_data.iloc[0]['Opp'] |
|
|
slate_names.append(slate_name) |
|
|
|
|
|
slate_name_lookup = dict(zip(slate_names, unique_slates)) |
|
|
return slate_names, slate_name_lookup |
|
|
|
|
|
def define_fd_nba_showdown_slates(): |
|
|
collection = nba_db["Player_SD_Range_Of_Outcomes"] |
|
|
cursor = collection.find() |
|
|
raw_display = pd.DataFrame(list(cursor)) |
|
|
raw_display = raw_display[raw_display['site'] == 'Fanduel'] |
|
|
unique_slates = raw_display['slate'].unique() |
|
|
|
|
|
slate_names = [] |
|
|
|
|
|
for slate in unique_slates: |
|
|
slate_data = raw_display[raw_display['slate'] == slate] |
|
|
slate_name = slate_data.iloc[0]['Team'] + ' vs. ' + slate_data.iloc[0]['Opp'] |
|
|
slate_names.append(slate_name) |
|
|
|
|
|
slate_name_lookup = dict(zip(slate_names, unique_slates)) |
|
|
return slate_names, slate_name_lookup |
|
|
|
|
|
try: |
|
|
nba_slate_names_dk, nba_slate_name_lookup_dk = define_dk_nba_showdown_slates() |
|
|
except: |
|
|
nba_slate_names_dk = [] |
|
|
nba_slate_name_lookup_dk = {} |
|
|
|
|
|
try: |
|
|
nba_slate_names_fd, nba_slate_name_lookup_fd = define_fd_nba_showdown_slates() |
|
|
except: |
|
|
nba_slate_names_fd = [] |
|
|
nba_slate_name_lookup_fd = {} |
|
|
|
|
|
def define_dk_nhl_showdown_slates(): |
|
|
collection = nhl_db["Player_Level_SD_ROO"] |
|
|
cursor = collection.find() |
|
|
raw_display = pd.DataFrame(list(cursor)) |
|
|
raw_display = raw_display[raw_display['Site'] == 'Draftkings'] |
|
|
unique_slates = raw_display['Slate'].unique() |
|
|
|
|
|
slate_names = [] |
|
|
|
|
|
for slate in unique_slates: |
|
|
slate_data = raw_display[raw_display['Slate'] == slate] |
|
|
slate_name = slate_data.iloc[0]['Team'] + ' vs. ' + slate_data.iloc[0]['Opp'] |
|
|
slate_names.append(slate_name) |
|
|
|
|
|
slate_name_lookup = dict(zip(slate_names, unique_slates)) |
|
|
return slate_names, slate_name_lookup |
|
|
|
|
|
def define_fd_nhl_showdown_slates(): |
|
|
collection = nhl_db["Player_Level_SD_ROO"] |
|
|
cursor = collection.find() |
|
|
raw_display = pd.DataFrame(list(cursor)) |
|
|
raw_display = raw_display[raw_display['Site'] == 'Fanduel'] |
|
|
unique_slates = raw_display['Slate'].unique() |
|
|
|
|
|
slate_names = [] |
|
|
|
|
|
for slate in unique_slates: |
|
|
slate_data = raw_display[raw_display['Slate'] == slate] |
|
|
slate_name = slate_data.iloc[0]['Team'] + ' vs. ' + slate_data.iloc[0]['Opp'] |
|
|
slate_names.append(slate_name) |
|
|
|
|
|
slate_name_lookup = dict(zip(slate_names, unique_slates)) |
|
|
return slate_names, slate_name_lookup |
|
|
|
|
|
try: |
|
|
nhl_slate_names_dk, nhl_slate_name_lookup_dk = define_dk_nhl_showdown_slates() |
|
|
except: |
|
|
nhl_slate_names_dk = [] |
|
|
nhl_slate_name_lookup_dk = {} |
|
|
|
|
|
try: |
|
|
nhl_slate_names_fd, nhl_slate_name_lookup_fd = define_fd_nhl_showdown_slates() |
|
|
except: |
|
|
nhl_slate_names_fd = [] |
|
|
nhl_slate_name_lookup_fd = {} |
|
|
|
|
|
|
|
|
def chunk_name_matching(portfolio_names, csv_names, chunk_size=1000): |
|
|
"""Process name matching in chunks to reduce memory usage""" |
|
|
portfolio_match_dict = {} |
|
|
unmatched_names = [] |
|
|
|
|
|
for i in range(0, len(portfolio_names), chunk_size): |
|
|
chunk = portfolio_names[i:i+chunk_size] |
|
|
for portfolio_name in chunk: |
|
|
match = process.extractOne( |
|
|
portfolio_name, |
|
|
csv_names, |
|
|
score_cutoff=90 |
|
|
) |
|
|
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) |
|
|
|
|
|
return portfolio_match_dict, unmatched_names |
|
|
|
|
|
def optimize_dataframe_dtypes(df): |
|
|
"""Optimize DataFrame data types for memory efficiency""" |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
for col in df.columns: |
|
|
if df[col].dtype == 'float64': |
|
|
|
|
|
try: |
|
|
if df[col].max() < 3.4e+38 and df[col].min() > -3.4e+38: |
|
|
df[col] = df[col].astype('float32') |
|
|
except: |
|
|
pass |
|
|
elif df[col].dtype == 'int64': |
|
|
|
|
|
try: |
|
|
if df[col].max() <= 32767 and df[col].min() >= -32768: |
|
|
df[col] = df[col].astype('int16') |
|
|
elif df[col].max() <= 2147483647 and df[col].min() >= -2147483648: |
|
|
df[col] = df[col].astype('int32') |
|
|
except: |
|
|
pass |
|
|
|
|
|
return df |
|
|
|
|
|
def load_base_frame(base_name): |
|
|
"""Load a base frame from compressed storage""" |
|
|
if base_name in st.session_state['base_frame_names']: |
|
|
base_bytes = st.session_state['base_frame_names'][base_name] |
|
|
return pd.read_parquet(io.BytesIO(base_bytes)) |
|
|
else: |
|
|
raise KeyError(f"Base frame '{base_name}' not found") |
|
|
|
|
|
def save_base_frame(base_name, dataframe): |
|
|
"""Save a base frame to compressed storage""" |
|
|
buffer = io.BytesIO() |
|
|
dataframe.to_parquet(buffer, compression='gzip') |
|
|
st.session_state['base_frame_names'][base_name] = buffer.getvalue() |
|
|
|
|
|
def create_memory_efficient_mappings(projections_df, site_var, type_var, sport_var): |
|
|
"""Create mappings with optimized data types""" |
|
|
|
|
|
projections_df = projections_df.copy() |
|
|
|
|
|
|
|
|
if 'position' in projections_df.columns: |
|
|
projections_df['position'] = projections_df['position'].astype('category') |
|
|
if 'team' in projections_df.columns: |
|
|
projections_df['team'] = projections_df['team'].astype('category') |
|
|
if 'salary' in projections_df.columns: |
|
|
projections_df['salary'] = projections_df['salary'].astype('int32') |
|
|
if 'median' in projections_df.columns: |
|
|
projections_df['median'] = projections_df['median'].astype('float32') |
|
|
if 'ownership' in projections_df.columns: |
|
|
projections_df['ownership'] = projections_df['ownership'].astype('float32') |
|
|
if 'captain ownership' in projections_df.columns: |
|
|
projections_df['captain ownership'] = projections_df['captain ownership'].astype('float32') |
|
|
|
|
|
|
|
|
base_mappings = { |
|
|
'pos_map': dict(zip(projections_df['player_names'], projections_df['position'])), |
|
|
'team_map': dict(zip(projections_df['player_names'], projections_df['team'])), |
|
|
'salary_map': dict(zip(projections_df['player_names'], projections_df['salary'])), |
|
|
'proj_map': dict(zip(projections_df['player_names'], projections_df['median'])), |
|
|
'own_map': dict(zip(projections_df['player_names'], projections_df['ownership'])), |
|
|
'own_percent_rank': dict(zip(projections_df['player_names'], projections_df['ownership'].rank(pct=True).astype('float32'))) |
|
|
} |
|
|
|
|
|
|
|
|
if site_var == 'Draftkings': |
|
|
if type_var == 'Classic': |
|
|
if sport_var == 'CS2' or sport_var == 'LOL': |
|
|
base_mappings.update({ |
|
|
'cpt_salary_map': dict(zip(projections_df['player_names'], projections_df['salary'] * 1.5)), |
|
|
'cpt_proj_map': dict(zip(projections_df['player_names'], projections_df['median'] * 1.5)), |
|
|
'cpt_own_map': dict(zip(projections_df['player_names'], projections_df['captain ownership'])) |
|
|
}) |
|
|
else: |
|
|
base_mappings.update({ |
|
|
'cpt_salary_map': dict(zip(projections_df['player_names'], projections_df['salary'])), |
|
|
'cpt_proj_map': dict(zip(projections_df['player_names'], projections_df['median'] * 1.5)), |
|
|
'cpt_own_map': dict(zip(projections_df['player_names'], projections_df['captain ownership'])) |
|
|
}) |
|
|
elif type_var == 'Showdown': |
|
|
if sport_var == 'GOLF': |
|
|
base_mappings.update({ |
|
|
'cpt_salary_map': dict(zip(projections_df['player_names'], projections_df['salary'])), |
|
|
'cpt_proj_map': dict(zip(projections_df['player_names'], projections_df['median'])), |
|
|
'cpt_own_map': dict(zip(projections_df['player_names'], projections_df['ownership'])) |
|
|
}) |
|
|
else: |
|
|
base_mappings.update({ |
|
|
'cpt_salary_map': dict(zip(projections_df['player_names'], projections_df['salary'] * 1.5)), |
|
|
'cpt_proj_map': dict(zip(projections_df['player_names'], projections_df['median'] * 1.5)), |
|
|
'cpt_own_map': dict(zip(projections_df['player_names'], projections_df['captain ownership'])) |
|
|
}) |
|
|
elif site_var == 'Fanduel': |
|
|
base_mappings.update({ |
|
|
'cpt_salary_map': dict(zip(projections_df['player_names'], projections_df['salary'] * 1.5)), |
|
|
'cpt_proj_map': dict(zip(projections_df['player_names'], projections_df['median'] * 1.5)), |
|
|
'cpt_own_map': dict(zip(projections_df['player_names'], projections_df['captain ownership'])) |
|
|
}) |
|
|
|
|
|
return base_mappings |
|
|
|
|
|
def create_comprehensive_mappings(projections_df, portfolio_df, csv_file, site_var, type_var, sport_var): |
|
|
"""Create mappings that include all portfolio players, using projections first and csv_file as fallback""" |
|
|
|
|
|
|
|
|
portfolio_players = get_portfolio_names(portfolio_df) |
|
|
|
|
|
|
|
|
projections_df = projections_df.copy() |
|
|
if 'position' in projections_df.columns: |
|
|
projections_df['position'] = projections_df['position'].astype('category') |
|
|
if 'team' in projections_df.columns: |
|
|
projections_df['team'] = projections_df['team'].astype('category') |
|
|
if 'salary' in projections_df.columns: |
|
|
projections_df['salary'] = projections_df['salary'].astype('int32') |
|
|
if 'median' in projections_df.columns: |
|
|
projections_df['median'] = projections_df['median'].astype('float32') |
|
|
if 'ownership' in projections_df.columns: |
|
|
projections_df['ownership'] = projections_df['ownership'].astype('float32') |
|
|
if 'captain ownership' in projections_df.columns: |
|
|
projections_df['captain ownership'] = projections_df['captain ownership'].astype('float32') |
|
|
|
|
|
|
|
|
projection_players = set(projections_df['player_names'].tolist()) |
|
|
missing_players = set(portfolio_players) - projection_players |
|
|
|
|
|
|
|
|
csv_fallback = {} |
|
|
if not missing_players: |
|
|
|
|
|
return create_memory_efficient_mappings(projections_df, site_var, type_var, sport_var) |
|
|
|
|
|
|
|
|
try: |
|
|
csv_name_col = 'Name' if 'Name' in csv_file.columns else 'Nickname' |
|
|
csv_salary_col = 'Salary' |
|
|
csv_position_col = 'Position' if 'Position' in csv_file.columns else 'Roster Position' |
|
|
csv_team_col = 'Team' if 'Team' in csv_file.columns else None |
|
|
|
|
|
|
|
|
csv_salary_map = dict(zip(csv_file[csv_name_col], csv_file[csv_salary_col])) |
|
|
csv_position_map = dict(zip(csv_file[csv_name_col], csv_file[csv_position_col])) |
|
|
csv_team_map = dict(zip(csv_file[csv_name_col], csv_file.get(csv_team_col, 'Unknown'))) if csv_team_col else {} |
|
|
|
|
|
except Exception as e: |
|
|
st.warning(f"Could not create csv fallback mappings: {e}") |
|
|
|
|
|
return create_memory_efficient_mappings(projections_df, site_var, type_var, sport_var) |
|
|
|
|
|
|
|
|
base_mappings = { |
|
|
'pos_map': dict(zip(projections_df['player_names'], projections_df['position'])), |
|
|
'team_map': dict(zip(projections_df['player_names'], projections_df['team'])), |
|
|
'salary_map': dict(zip(projections_df['player_names'], projections_df['salary'])), |
|
|
'proj_map': dict(zip(projections_df['player_names'], projections_df['median'])), |
|
|
'own_map': dict(zip(projections_df['player_names'], projections_df['ownership'])), |
|
|
'own_percent_rank': dict(zip(projections_df['player_names'], projections_df['ownership'].rank(pct=True).astype('float32'))) |
|
|
} |
|
|
|
|
|
|
|
|
for player in missing_players: |
|
|
if player in csv_salary_map: |
|
|
base_mappings['pos_map'][player] = csv_position_map.get(player, 'FLEX') |
|
|
base_mappings['team_map'][player] = csv_team_map.get(player, 'Unknown') if csv_team_map else 'Unknown' |
|
|
base_mappings['salary_map'][player] = csv_salary_map[player] |
|
|
base_mappings['proj_map'][player] = 0.0 |
|
|
base_mappings['own_map'][player] = 0.0 |
|
|
base_mappings['own_percent_rank'][player] = 0.0 |
|
|
else: |
|
|
st.warning(f"Player '{player}' not found in projections or csv_file") |
|
|
|
|
|
base_mappings['pos_map'][player] = 'FLEX' |
|
|
base_mappings['team_map'][player] = 'Unknown' |
|
|
base_mappings['salary_map'][player] = 0 |
|
|
base_mappings['proj_map'][player] = 0.0 |
|
|
base_mappings['own_map'][player] = 0.0 |
|
|
base_mappings['own_percent_rank'][player] = 0.0 |
|
|
|
|
|
|
|
|
if site_var == 'Draftkings': |
|
|
if type_var == 'Classic': |
|
|
if sport_var == 'CS2' or sport_var == 'LOL': |
|
|
cpt_salary_map = dict(zip(projections_df['player_names'], projections_df['salary'] * 1.5)) |
|
|
cpt_proj_map = dict(zip(projections_df['player_names'], projections_df['median'] * 1.5)) |
|
|
cpt_own_map = dict(zip(projections_df['player_names'], projections_df['captain ownership'])) |
|
|
|
|
|
|
|
|
for player in missing_players: |
|
|
if player in csv_salary_map: |
|
|
cpt_salary_map[player] = csv_salary_map[player] * 1.5 |
|
|
cpt_proj_map[player] = 0.0 |
|
|
cpt_own_map[player] = 0.0 |
|
|
|
|
|
base_mappings.update({ |
|
|
'cpt_salary_map': cpt_salary_map, |
|
|
'cpt_proj_map': cpt_proj_map, |
|
|
'cpt_own_map': cpt_own_map |
|
|
}) |
|
|
else: |
|
|
cpt_salary_map = dict(zip(projections_df['player_names'], projections_df['salary'])) |
|
|
cpt_proj_map = dict(zip(projections_df['player_names'], projections_df['median'] * 1.5)) |
|
|
cpt_own_map = dict(zip(projections_df['player_names'], projections_df['captain ownership'])) |
|
|
|
|
|
|
|
|
for player in missing_players: |
|
|
if player in csv_salary_map: |
|
|
cpt_salary_map[player] = csv_salary_map[player] |
|
|
cpt_proj_map[player] = 0.0 |
|
|
cpt_own_map[player] = 0.0 |
|
|
|
|
|
base_mappings.update({ |
|
|
'cpt_salary_map': cpt_salary_map, |
|
|
'cpt_proj_map': cpt_proj_map, |
|
|
'cpt_own_map': cpt_own_map |
|
|
}) |
|
|
elif type_var == 'Showdown': |
|
|
if sport_var == 'GOLF': |
|
|
cpt_salary_map = dict(zip(projections_df['player_names'], projections_df['salary'])) |
|
|
cpt_proj_map = dict(zip(projections_df['player_names'], projections_df['median'])) |
|
|
cpt_own_map = dict(zip(projections_df['player_names'], projections_df['ownership'])) |
|
|
|
|
|
|
|
|
for player in missing_players: |
|
|
if player in csv_salary_map: |
|
|
cpt_salary_map[player] = csv_salary_map[player] |
|
|
cpt_proj_map[player] = 0.0 |
|
|
cpt_own_map[player] = 0.0 |
|
|
|
|
|
base_mappings.update({ |
|
|
'cpt_salary_map': cpt_salary_map, |
|
|
'cpt_proj_map': cpt_proj_map, |
|
|
'cpt_own_map': cpt_own_map |
|
|
}) |
|
|
else: |
|
|
cpt_salary_map = dict(zip(projections_df['player_names'], projections_df['salary'] * 1.5)) |
|
|
cpt_proj_map = dict(zip(projections_df['player_names'], projections_df['median'] * 1.5)) |
|
|
cpt_own_map = dict(zip(projections_df['player_names'], projections_df['captain ownership'])) |
|
|
|
|
|
|
|
|
for player in missing_players: |
|
|
if player in csv_salary_map: |
|
|
cpt_salary_map[player] = csv_salary_map[player] * 1.5 |
|
|
cpt_proj_map[player] = 0.0 |
|
|
cpt_own_map[player] = 0.0 |
|
|
|
|
|
base_mappings.update({ |
|
|
'cpt_salary_map': cpt_salary_map, |
|
|
'cpt_proj_map': cpt_proj_map, |
|
|
'cpt_own_map': cpt_own_map |
|
|
}) |
|
|
elif site_var == 'Fanduel': |
|
|
cpt_salary_map = dict(zip(projections_df['player_names'], projections_df['salary'] * 1.5)) |
|
|
cpt_proj_map = dict(zip(projections_df['player_names'], projections_df['median'] * 1.5)) |
|
|
cpt_own_map = dict(zip(projections_df['player_names'], projections_df['captain ownership'])) |
|
|
|
|
|
|
|
|
for player in missing_players: |
|
|
if player in csv_salary_map: |
|
|
cpt_salary_map[player] = csv_salary_map[player] * 1.5 |
|
|
cpt_proj_map[player] = 0.0 |
|
|
cpt_own_map[player] = 0.0 |
|
|
|
|
|
base_mappings.update({ |
|
|
'cpt_salary_map': cpt_salary_map, |
|
|
'cpt_proj_map': cpt_proj_map, |
|
|
'cpt_own_map': cpt_own_map |
|
|
}) |
|
|
|
|
|
return base_mappings |
|
|
|
|
|
def calculate_salary_vectorized(df, player_columns, map_dict, type_var, sport_var): |
|
|
"""Vectorized salary calculation to replace expensive apply operations""" |
|
|
def safe_map_and_fill(series, mapping, fill_value=0): |
|
|
"""Safely map values and fill NaN, handling categorical columns""" |
|
|
mapped = series.map(mapping) |
|
|
if hasattr(series, 'cat'): |
|
|
|
|
|
mapped = mapped.astype('object') |
|
|
return mapped.fillna(fill_value) |
|
|
|
|
|
if type_var == 'Classic' and (sport_var == 'CS2' or sport_var == 'LOL'): |
|
|
|
|
|
cpt_salaries = safe_map_and_fill(df.iloc[:, 0], map_dict['cpt_salary_map']) |
|
|
flex_salaries = sum(safe_map_and_fill(df.iloc[:, i], map_dict['salary_map']) for i in range(1, len(player_columns))) |
|
|
return cpt_salaries + flex_salaries |
|
|
elif type_var == 'Showdown': |
|
|
if sport_var == 'GOLF': |
|
|
return sum(safe_map_and_fill(df[col], map_dict['salary_map']) for col in player_columns) |
|
|
else: |
|
|
cpt_salaries = safe_map_and_fill(df.iloc[:, 0], map_dict['cpt_salary_map']) |
|
|
flex_salaries = sum(safe_map_and_fill(df.iloc[:, i], map_dict['salary_map']) for i in range(1, len(player_columns))) |
|
|
return cpt_salaries + flex_salaries |
|
|
else: |
|
|
|
|
|
return sum(safe_map_and_fill(df[col], map_dict['salary_map']) for col in player_columns) |
|
|
|
|
|
def calculate_median_vectorized(df, player_columns, map_dict, type_var, sport_var): |
|
|
"""Vectorized median calculation to replace expensive apply operations""" |
|
|
def safe_map_and_fill(series, mapping, fill_value=0): |
|
|
"""Safely map values and fill NaN, handling categorical columns""" |
|
|
mapped = series.map(mapping) |
|
|
if hasattr(series, 'cat'): |
|
|
|
|
|
mapped = mapped.astype('object') |
|
|
return mapped.fillna(fill_value) |
|
|
|
|
|
if type_var == 'Classic' and (sport_var == 'CS2' or sport_var == 'LOL'): |
|
|
cpt_medians = safe_map_and_fill(df.iloc[:, 0], map_dict['cpt_proj_map']) |
|
|
flex_medians = sum(safe_map_and_fill(df.iloc[:, i], map_dict['proj_map']) for i in range(1, len(player_columns))) |
|
|
return cpt_medians + flex_medians |
|
|
elif type_var == 'Showdown': |
|
|
if sport_var == 'GOLF': |
|
|
return sum(safe_map_and_fill(df[col], map_dict['proj_map']) for col in player_columns) |
|
|
else: |
|
|
cpt_medians = safe_map_and_fill(df.iloc[:, 0], map_dict['cpt_proj_map']) |
|
|
flex_medians = sum(safe_map_and_fill(df.iloc[:, i], map_dict['proj_map']) for i in range(1, len(player_columns))) |
|
|
return cpt_medians + flex_medians |
|
|
else: |
|
|
return sum(safe_map_and_fill(df[col], map_dict['proj_map']) for col in player_columns) |
|
|
|
|
|
def calculate_ownership_vectorized(df, player_columns, map_dict, type_var, sport_var): |
|
|
"""Vectorized ownership calculation to replace expensive apply operations""" |
|
|
def safe_map_and_fill(series, mapping, fill_value=0): |
|
|
"""Safely map values and fill NaN, handling categorical columns""" |
|
|
mapped = series.map(mapping) |
|
|
if hasattr(series, 'cat'): |
|
|
|
|
|
mapped = mapped.astype('object') |
|
|
return mapped.fillna(fill_value) |
|
|
|
|
|
if type_var == 'Classic' and (sport_var == 'CS2' or sport_var == 'LOL'): |
|
|
cpt_own = safe_map_and_fill(df.iloc[:, 0], map_dict['cpt_own_map']) |
|
|
flex_own = sum(safe_map_and_fill(df.iloc[:, i], map_dict['own_map']) for i in range(1, len(player_columns))) |
|
|
return cpt_own + flex_own |
|
|
elif type_var == 'Showdown': |
|
|
if sport_var == 'GOLF': |
|
|
return sum(safe_map_and_fill(df[col], map_dict['own_map']) for col in player_columns) |
|
|
else: |
|
|
cpt_own = safe_map_and_fill(df.iloc[:, 0], map_dict['cpt_own_map']) |
|
|
flex_own = sum(safe_map_and_fill(df.iloc[:, i], map_dict['own_map']) for i in range(1, len(player_columns))) |
|
|
return cpt_own + flex_own |
|
|
else: |
|
|
return sum(safe_map_and_fill(df[col], map_dict['own_map']) for col in player_columns) |
|
|
|
|
|
def calculate_lineup_metrics(df, player_columns, map_dict, type_var, sport_var, projections_df=None): |
|
|
"""Centralized function to calculate salary, median, and ownership efficiently""" |
|
|
df = df.copy() |
|
|
|
|
|
|
|
|
for col in player_columns: |
|
|
if df[col].dtype.name == 'category': |
|
|
df[col] = df[col].astype('object') |
|
|
|
|
|
|
|
|
df['salary'] = calculate_salary_vectorized(df[player_columns], player_columns, map_dict, type_var, sport_var) |
|
|
df['median'] = calculate_median_vectorized(df[player_columns], player_columns, map_dict, type_var, sport_var) |
|
|
df['Own'] = calculate_ownership_vectorized(df[player_columns], player_columns, map_dict, type_var, sport_var) |
|
|
|
|
|
return df |
|
|
|
|
|
def create_team_filter_mask(df, player_columns, team_map, teams_to_filter, focus_type='Overall', type_var='Classic'): |
|
|
"""Create boolean mask for team filtering without creating intermediate DataFrames""" |
|
|
mask = pd.Series(False, index=df.index) |
|
|
|
|
|
if type_var == 'Showdown' and focus_type != 'Overall': |
|
|
if focus_type == 'CPT': |
|
|
focus_columns = [player_columns[0]] |
|
|
elif focus_type == 'FLEX': |
|
|
focus_columns = player_columns[1:] |
|
|
else: |
|
|
focus_columns = player_columns |
|
|
else: |
|
|
|
|
|
if type_var == 'Classic': |
|
|
focus_columns = [col for col in player_columns if col not in ['SP1', 'SP2']] |
|
|
else: |
|
|
focus_columns = player_columns |
|
|
|
|
|
for team in teams_to_filter: |
|
|
for col in focus_columns: |
|
|
team_mask = df[col].map(team_map) == team |
|
|
mask |= team_mask |
|
|
|
|
|
return mask |
|
|
|
|
|
def prepare_dataframe_for_exposure_spread(df, player_columns): |
|
|
"""Ensure DataFrame is ready for exposure_spread by converting player columns to object type""" |
|
|
df_prepared = df.copy() |
|
|
|
|
|
|
|
|
for col in player_columns: |
|
|
if col in df_prepared.columns and df_prepared[col].dtype.name == 'category': |
|
|
df_prepared[col] = df_prepared[col].astype('object') |
|
|
|
|
|
return df_prepared |
|
|
|
|
|
def create_position_export_dict(column_name, csv_file, site_var, type_var, sport_var): |
|
|
try: |
|
|
|
|
|
import re |
|
|
position_filter = re.sub(r'\d+$', '', column_name) |
|
|
|
|
|
|
|
|
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: |
|
|
|
|
|
filtered_df = csv_file |
|
|
|
|
|
|
|
|
if site_var == 'Draftkings': |
|
|
try: |
|
|
filtered_df = filtered_df.sort_values(by='Salary', ascending=False).drop_duplicates(subset=['Name']) |
|
|
return dict(zip(filtered_df['Name'], filtered_df['Name + ID'])) |
|
|
except: |
|
|
filtered_df = filtered_df.sort_values(by='Salary', ascending=False).drop_duplicates(subset=['Nickname']) |
|
|
return dict(zip(filtered_df['Nickname'], filtered_df['Name + ID'])) |
|
|
else: |
|
|
try: |
|
|
filtered_df = filtered_df.sort_values(by='Salary', ascending=False).drop_duplicates(subset=['Nickname']) |
|
|
return dict(zip(filtered_df['Nickname'], filtered_df['Id'])) |
|
|
except: |
|
|
filtered_df = filtered_df.sort_values(by='Salary', ascending=False).drop_duplicates(subset=['Name']) |
|
|
return dict(zip(filtered_df['Name'], filtered_df['Id'])) |
|
|
|
|
|
except Exception as e: |
|
|
st.error(f"Error creating position export dict for {column_name}: {str(e)}") |
|
|
return {} |
|
|
|
|
|
def parse_portfolio_on_mapped(portfolio, map_dict, map_key, filter_keys_pos, filter_keys_team, low_threshold, high_threshold, column_choices): |
|
|
mapping_port = portfolio[column_choices] |
|
|
mapping_port = mapping_port.map(map_dict[map_key]) |
|
|
if column_choices == 'CPT': |
|
|
mapping_port = mapping_port * 1.5 |
|
|
|
|
|
if map_key not in ['team_map', 'pos_map']: |
|
|
|
|
|
low_mask = mapping_port > low_threshold |
|
|
high_mask = mapping_port < high_threshold |
|
|
mask = low_mask & high_mask |
|
|
else: |
|
|
pos_mask = False |
|
|
team_mask = False |
|
|
|
|
|
if filter_keys_pos: |
|
|
|
|
|
pos_pattern = '|'.join([f'\\b{pos}\\b' for pos in filter_keys_pos]) |
|
|
pos_mask = mapping_port.str.contains(pos_pattern, case=False, na=False, regex=True) |
|
|
|
|
|
if filter_keys_team: |
|
|
team_mask = mapping_port.isin(filter_keys_team) |
|
|
|
|
|
mask = pos_mask | team_mask |
|
|
|
|
|
return portfolio[mask] |
|
|
|
|
|
def recalc_stacks_sizes(df, player_columns, map_dict): |
|
|
team_map = map_dict['team_map'] |
|
|
df['Stack'] = df.apply( |
|
|
lambda row: Counter( |
|
|
team_map.get(player, '') for player in row[stack_column_dict[site_var][type_var][sport_var]] |
|
|
if team_map.get(player, '') != '' |
|
|
).most_common(1)[0][0] if any(team_map.get(player, '') for player in row[stack_column_dict[site_var][type_var][sport_var]]) else '', |
|
|
axis=1 |
|
|
) |
|
|
df['Size'] = df.apply( |
|
|
lambda row: Counter( |
|
|
team_map.get(player, '') for player in row[stack_column_dict[site_var][type_var][sport_var]] |
|
|
if team_map.get(player, '') != '' |
|
|
).most_common(1)[0][1] if any(team_map.get(player, '') for player in row[stack_column_dict[site_var][type_var][sport_var]]) else 0, |
|
|
axis=1 |
|
|
) |
|
|
return df |
|
|
|
|
|
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() |
|
|
st.session_state['pricing_loaded'] = False |
|
|
st.session_state['projections_loaded'] = False |
|
|
st.session_state['portfolio_loaded'] = False |
|
|
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', 'COD', 'TENNIS', 'NASCAR', 'GOLF', 'WNBA', 'F1'], key='sport_var') |
|
|
|
|
|
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 |
|
|
|
|
|
with st.expander("Info and Filters"): |
|
|
prio_col, optimals_site_col, optimals_salary_col, optimals_stacks_col = st.columns(4) |
|
|
|
|
|
with prio_col: |
|
|
prio_var = st.radio("Which priority variable do you want to use?", ('proj', 'Own', 'Mix'), key='prio_var_radio') |
|
|
prio_mix = st.number_input("If Mix, what split of Projection/Ownership to dedicate to Projection?", min_value=0, max_value=100, value=50, step=1) |
|
|
lineup_num_var = st.number_input("How many lineups do you want to work with?", min_value=100, max_value=10000, value=1000, step=100, key='lineup_download_var_input') |
|
|
|
|
|
with optimals_site_col: |
|
|
if site_var == 'Draftkings': |
|
|
if sport_var == 'NBA': |
|
|
slate_var3 = st.radio("Which slate data are you loading?", (nba_slate_names_dk if type_var == 'Showdown' else ['Main', 'Secondary', 'Auxiliary']), key='slate_var3_radio') |
|
|
elif sport_var == 'NFL': |
|
|
slate_var3 = st.radio("Which slate data are you loading?", (nfl_slate_names_dk if type_var == 'Showdown' else ['Main', 'Secondary', 'Auxiliary']), key='slate_var3_radio') |
|
|
elif sport_var == 'NHL': |
|
|
slate_var3 = st.radio("Which slate data are you loading?", (nhl_slate_names_dk if type_var == 'Showdown' else ['Main', 'Secondary', 'Auxiliary']), key='slate_var3_radio') |
|
|
elif sport_var == 'MMA': |
|
|
slate_var3 = st.radio("Which slate data are you loading?", (['Main', 'Secondary', 'Auxiliary']), key='slate_var3_radio') |
|
|
elif sport_var == 'GOLF': |
|
|
slate_var3 = st.radio("Which slate data are you loading?", (['Main', 'Secondary', 'Auxiliary']), key='slate_var3_radio') |
|
|
else: |
|
|
slate_var3 = st.radio("Which slate data are you loading?", (['Main', 'Secondary', 'Auxiliary']), key='slate_var3_radio') |
|
|
elif site_var == 'Fanduel': |
|
|
if sport_var == 'NBA': |
|
|
slate_var3 = st.radio("Which slate data are you loading?", (nba_slate_names_fd if type_var == 'Showdown' else ['Main', 'Secondary', 'Auxiliary']), key='slate_var3_radio') |
|
|
elif sport_var == 'NFL': |
|
|
slate_var3 = st.radio("Which slate data are you loading?", (nfl_slate_names_fd if type_var == 'Showdown' else ['Main', 'Secondary', 'Auxiliary']), key='slate_var3_radio') |
|
|
elif sport_var == 'NHL': |
|
|
slate_var3 = st.radio("Which slate data are you loading?", (nhl_slate_names_fd if type_var == 'Showdown' else ['Main', 'Secondary', 'Auxiliary']), key='slate_var3_radio') |
|
|
elif sport_var == 'MMA': |
|
|
slate_var3 = st.radio("Which slate data are you loading?", (['Main', 'Secondary', 'Auxiliary']), key='slate_var3_radio') |
|
|
elif sport_var == 'GOLF': |
|
|
slate_var3 = st.radio("Which slate data are you loading?", (['Main', 'Secondary', 'Auxiliary']), key='slate_var3_radio') |
|
|
else: |
|
|
slate_var3 = st.radio("Which slate data are you loading?", (['Main', 'Secondary', 'Auxiliary']), key='slate_var3_radio') |
|
|
|
|
|
with optimals_salary_col: |
|
|
if site_var == 'Draftkings': |
|
|
salary_min_var = st.number_input("Minimum salary used", min_value = 0, max_value = 50000, value = 49000, step = 100, key = 'salary_min_var_dk') |
|
|
salary_max_var = st.number_input("Maximum salary used", min_value = 0, max_value = 50000, value = 50000, step = 100, key = 'salary_max_var_dk') |
|
|
elif site_var == 'Fanduel': |
|
|
if sport_var == 'NHL': |
|
|
salary_min_var = st.number_input("Minimum salary used", min_value = 0, max_value = 55000, value = 54000, step = 100, key = 'salary_min_var_fd') |
|
|
salary_max_var = st.number_input("Maximum salary used", min_value = 0, max_value = 55000, value = 55000, step = 100, key = 'salary_max_var_fd') |
|
|
else: |
|
|
salary_min_var = st.number_input("Minimum salary used", min_value = 0, max_value = 60000, value = 59000, step = 100, key = 'salary_min_var_fd') |
|
|
salary_max_var = st.number_input("Maximum salary used", min_value = 0, max_value = 60000, value = 60000, step = 100, key = 'salary_max_var_fd') |
|
|
with optimals_stacks_col: |
|
|
if site_var == 'Draftkings': |
|
|
min_stacks_var = st.number_input("Minimum stacks used", min_value = 0, max_value = 5, value = 1, step = 1, key = 'min_stacks_var_dk') |
|
|
max_stacks_var = st.number_input("Maximum stacks used", min_value = 0, max_value = 5, value = 5, step = 1, key = 'max_stacks_var_dk') |
|
|
elif site_var == 'Fanduel': |
|
|
min_stacks_var = st.number_input("Minimum stacks used", min_value = 0, max_value = 4, value = 1, step = 1, key = 'min_stacks_var_fd') |
|
|
max_stacks_var = st.number_input("Maximum stacks used", min_value = 0, max_value = 4, value = 4, step = 1, key = 'max_stacks_var_fd') |
|
|
|
|
|
try: |
|
|
nfl_reg_salaries = grab_nfl_reg_salaries(slate_var3) |
|
|
except: |
|
|
nfl_reg_salaries = None |
|
|
try: |
|
|
nfl_showdown_salaries = grab_nfl_showdown_salaries() |
|
|
except: |
|
|
nfl_showdown_salaries = None |
|
|
try: |
|
|
nba_reg_salaries = grab_nba_reg_salaries(slate_var3) |
|
|
except: |
|
|
nba_reg_salaries = None |
|
|
try: |
|
|
nba_showdown_salaries = grab_nba_showdown_salaries() |
|
|
except: |
|
|
nba_showdown_salaries = None |
|
|
try: |
|
|
nhl_reg_salaries = grab_nhl_reg_salaries(slate_var3) |
|
|
except: |
|
|
nhl_reg_salaries = None |
|
|
try: |
|
|
nhl_showdown_salaries = grab_nhl_showdown_salaries() |
|
|
except: |
|
|
nhl_showdown_salaries = None |
|
|
try: |
|
|
mma_reg_salaries = grab_mma_reg_salaries(slate_var3) |
|
|
except: |
|
|
mma_reg_salaries = None |
|
|
try: |
|
|
mma_showdown_salaries = grab_mma_showdown_salaries() |
|
|
except: |
|
|
mma_showdown_salaries = None |
|
|
try: |
|
|
pga_reg_salaries = grab_pga_reg_salaries(slate_var3) |
|
|
except: |
|
|
pga_reg_salaries = None |
|
|
try: |
|
|
pga_showdown_salaries = grab_pga_showdown_salaries() |
|
|
except: |
|
|
pga_showdown_salaries = None |
|
|
|
|
|
try: |
|
|
selected_tab = st.segmented_control( |
|
|
"Select Tab", |
|
|
options=["Data Load", "Projections Management", "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", "Projections Management", "Manage Portfolio"], |
|
|
selection_mode='single', |
|
|
default='Data Load', |
|
|
label_visibility='collapsed', |
|
|
key='tab_selector' |
|
|
) |
|
|
|
|
|
if selected_tab == 'Data Load': |
|
|
col1, col2, col3 = st.columns(3) |
|
|
|
|
|
with col1: |
|
|
st.subheader("Draftkings/Fanduel CSV") |
|
|
with st.expander('Upload Info'): |
|
|
st.info("Upload the player pricing CSV from the site you are playing on") |
|
|
st.warning("Database load is active and in testing for Draftkings, not for Fanduel") |
|
|
|
|
|
pricing_source = st.selectbox("Select a pricing source", options=['Paydirt DB', 'User Upload']) |
|
|
if 'csv_file' not in st.session_state: |
|
|
st.session_state['pricing_loaded'] = False |
|
|
|
|
|
upload_csv_col, csv_template_col = st.columns([3, 1]) |
|
|
if pricing_source == 'Paydirt DB': |
|
|
if st.button("Load from Paydirt DB"): |
|
|
if 'csv_file' in st.session_state: |
|
|
del st.session_state['csv_file'] |
|
|
if sport_var == 'NBA': |
|
|
if type_var == 'Classic': |
|
|
st.session_state['csv_file'] = load_csv(nba_reg_salaries) |
|
|
elif type_var == 'Showdown': |
|
|
st.session_state['csv_file'] = load_csv(nba_showdown_salaries) |
|
|
elif sport_var == 'NFL': |
|
|
if type_var == 'Classic': |
|
|
st.session_state['csv_file'] = load_csv(nfl_reg_salaries) |
|
|
elif type_var == 'Showdown': |
|
|
st.session_state['csv_file'] = load_csv(nfl_showdown_salaries) |
|
|
elif sport_var == 'NHL': |
|
|
if type_var == 'Classic': |
|
|
st.session_state['csv_file'] = load_csv(nhl_reg_salaries) |
|
|
elif type_var == 'Showdown': |
|
|
st.session_state['csv_file'] = load_csv(nhl_showdown_salaries) |
|
|
elif sport_var == 'MMA': |
|
|
if type_var == 'Classic': |
|
|
st.session_state['csv_file'] = load_csv(mma_reg_salaries) |
|
|
elif type_var == 'Showdown': |
|
|
st.session_state['csv_file'] = load_csv(mma_showdown_salaries) |
|
|
elif sport_var == 'GOLF': |
|
|
if type_var == 'Classic': |
|
|
st.session_state['csv_file'] = load_csv(pga_reg_salaries) |
|
|
elif type_var == 'Showdown': |
|
|
st.session_state['csv_file'] = load_csv(pga_showdown_salaries) |
|
|
st.session_state['pricing_loaded'] = True |
|
|
|
|
|
try: |
|
|
st.session_state['csv_file']['Salary'] = st.session_state['csv_file']['Salary'].astype(str).str.replace(',', '').astype(int) |
|
|
except: |
|
|
pass |
|
|
else: |
|
|
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) |
|
|
if csv_file is not None: |
|
|
st.session_state['pricing_loaded'] = True |
|
|
try: |
|
|
st.session_state['csv_file']['Salary'] = st.session_state['csv_file']['Salary'].astype(str).str.replace(',', '').astype(int) |
|
|
except: |
|
|
pass |
|
|
|
|
|
if st.session_state['pricing_loaded']: |
|
|
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' |
|
|
if site_var == 'Fanduel': |
|
|
try: |
|
|
st.session_state['csv_file']['Position'] = st.session_state['csv_file']['Position'].replace('D', 'DST', regex=False) |
|
|
except: |
|
|
pass |
|
|
if st.session_state['csv_file'] is not None: |
|
|
st.success('Projections file loaded successfully!') |
|
|
st.dataframe(st.session_state['csv_file'].head(10)) |
|
|
|
|
|
with col2: |
|
|
st.subheader("Portfolio File") |
|
|
with st.expander('Upload Info'): |
|
|
st.info("Go ahead and upload a portfolio file here. Only include player columns.") |
|
|
st.warning("Database load is active and in testing for NBA, NFL, NHL, MMA, and PGA, both Classic and Regular") |
|
|
|
|
|
upload_toggle = st.selectbox("What source are you uploading from?", options=['Paydirt DB', 'SaberSim (Just IDs)', 'Draftkings/Fanduel (Names + IDs)', 'Other (Just Names)']) |
|
|
if 'portfolio' not in st.session_state: |
|
|
st.session_state['portfolio_loaded'] = False |
|
|
if upload_toggle == 'Paydirt DB': |
|
|
if st.button("Load from Database after inserting site CSV"): |
|
|
if site_var == 'Draftkings': |
|
|
if type_var != 'Showdown': |
|
|
if sport_var == 'NBA': |
|
|
portfolio_load = init_DK_NBA_lineups(type_var, slate_var3, prio_var, 50, dk_nba_showdown_db_translation, lineup_num_var, salary_min_var, salary_max_var, []) |
|
|
elif sport_var == 'NFL': |
|
|
portfolio_load = init_DK_NFL_lineups(type_var, slate_var3, prio_var, 50, dk_nfl_showdown_db_translation, lineup_num_var, salary_min_var, salary_max_var, []) |
|
|
elif sport_var == 'NHL': |
|
|
portfolio_load = init_DK_NHL_lineups(type_var, slate_var3, prio_var, 50, dk_nhl_showdown_db_translation, lineup_num_var, salary_min_var, salary_max_var, []) |
|
|
elif sport_var == 'MMA': |
|
|
portfolio_load = init_DK_MMA_lineups(type_var, slate_var3, prio_var, 50, lineup_num_var, salary_min_var, salary_max_var, []) |
|
|
elif sport_var == 'GOLF': |
|
|
portfolio_load = init_DK_PGA_lineups(type_var, slate_var3, prio_var, 50, lineup_num_var, salary_min_var, salary_max_var, []) |
|
|
else: |
|
|
if sport_var == 'NBA': |
|
|
portfolio_load = init_DK_NBA_lineups(type_var, nba_slate_name_lookup_dk[slate_var3], prio_var, 50, dk_nba_showdown_db_translation, lineup_num_var, salary_min_var, salary_max_var, []) |
|
|
elif sport_var == 'NFL': |
|
|
portfolio_load = init_DK_NFL_lineups(type_var, nfl_slate_name_lookup_dk[slate_var3], prio_var, 50, dk_nfl_showdown_db_translation, lineup_num_var, salary_min_var, salary_max_var, []) |
|
|
elif sport_var == 'NHL': |
|
|
portfolio_load = init_DK_NHL_lineups(type_var, nhl_slate_name_lookup_dk[slate_var3], prio_var, 50, dk_nhl_showdown_db_translation, lineup_num_var, salary_min_var, salary_max_var, []) |
|
|
elif sport_var == 'MMA': |
|
|
portfolio_load = init_DK_MMA_lineups(type_var, slate_var3, prio_var, 50, lineup_num_var, salary_min_var, salary_max_var, []) |
|
|
elif sport_var == 'GOLF': |
|
|
portfolio_load = init_DK_PGA_lineups(type_var, slate_var3, prio_var, 50, lineup_num_var, salary_min_var, salary_max_var, []) |
|
|
|
|
|
st.session_state['db_portfolio_file'] = pd.DataFrame(portfolio_load) |
|
|
st.session_state['portfolio_loaded'] = True |
|
|
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: |
|
|
if type_var != 'Showdown': |
|
|
if sport_var == 'NBA': |
|
|
portfolio_load = init_FD_NBA_lineups(type_var, slate_var3, prio_var, 50, fd_nba_showdown_db_translation, lineup_num_var, salary_min_var, salary_max_var, []) |
|
|
elif sport_var == 'NFL': |
|
|
portfolio_load = init_FD_NFL_lineups(type_var, slate_var3, prio_var, 50, fd_nfl_showdown_db_translation, lineup_num_var, salary_min_var, salary_max_var, []) |
|
|
elif sport_var == 'NHL': |
|
|
portfolio_load = init_FD_NHL_lineups(type_var, slate_var3, prio_var, 50, fd_nhl_showdown_db_translation, lineup_num_var, salary_min_var, salary_max_var, []) |
|
|
elif sport_var == 'MMA': |
|
|
portfolio_load = init_FD_MMA_lineups(type_var, slate_var3, prio_var, 50, lineup_num_var, salary_min_var, salary_max_var, []) |
|
|
elif sport_var == 'GOLF': |
|
|
portfolio_load = init_FD_PGA_lineups(type_var, slate_var3, prio_var, 50, lineup_num_var, salary_min_var, salary_max_var, []) |
|
|
else: |
|
|
if sport_var == 'NBA': |
|
|
portfolio_load = init_FD_NBA_lineups(type_var, nba_slate_name_lookup_fd[slate_var3], prio_var, 50, fd_nba_showdown_db_translation, lineup_num_var, salary_min_var, salary_max_var, []) |
|
|
elif sport_var == 'NFL': |
|
|
portfolio_load = init_FD_NFL_lineups(type_var, nfl_slate_name_lookup_fd[slate_var3], prio_var, 50, fd_nfl_showdown_db_translation, lineup_num_var, salary_min_var, salary_max_var, []) |
|
|
elif sport_var == 'NHL': |
|
|
portfolio_load = init_FD_NHL_lineups(type_var, nhl_slate_name_lookup_fd[slate_var3], prio_var, 50, fd_nhl_showdown_db_translation, lineup_num_var, salary_min_var, salary_max_var, []) |
|
|
elif sport_var == 'MMA': |
|
|
portfolio_load = init_FD_MMA_lineups(type_var, slate_var3, prio_var, 50, lineup_num_var, salary_min_var, salary_max_var, []) |
|
|
elif sport_var == 'GOLF': |
|
|
portfolio_load = init_FD_PGA_lineups(type_var, slate_var3, prio_var, 50, lineup_num_var, salary_min_var, salary_max_var, []) |
|
|
|
|
|
st.session_state['db_portfolio_file'] = pd.DataFrame(portfolio_load) |
|
|
st.session_state['portfolio_loaded'] = True |
|
|
if 'portfolio' in st.session_state: |
|
|
del st.session_state['portfolio'] |
|
|
if 'export_portfolio' in st.session_state: |
|
|
del st.session_state['export_portfolio'] |
|
|
|
|
|
elif 'db_portfolio_file' in st.session_state: |
|
|
st.session_state['portfolio_loaded'] = True |
|
|
|
|
|
elif 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']) |
|
|
st.session_state['portfolio_loaded'] = True |
|
|
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']) |
|
|
st.session_state['portfolio_loaded'] = True |
|
|
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 st.session_state['portfolio_loaded']: |
|
|
|
|
|
if upload_toggle == 'Paydirt DB': |
|
|
portfolio_file = st.session_state['db_portfolio_file'] |
|
|
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) |
|
|
|
|
|
elif upload_toggle == 'SaberSim (Just IDs)': |
|
|
if portfolio_file is not None: |
|
|
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)': |
|
|
if portfolio_file is not None: |
|
|
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: |
|
|
if portfolio_file is not None: |
|
|
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) |
|
|
|
|
|
if st.session_state['portfolio'] is not None: |
|
|
|
|
|
|
|
|
st.session_state['portfolio'] = optimize_dataframe_dtypes(st.session_state['portfolio']) |
|
|
|
|
|
st.success('Portfolio file loaded successfully!') |
|
|
for col in st.session_state['portfolio'].select_dtypes(include=['object', 'category']).columns: |
|
|
if st.session_state['portfolio'][col].dtype == 'category': |
|
|
|
|
|
st.session_state['portfolio'][col] = st.session_state['portfolio'][col].cat.rename_categories( |
|
|
lambda x: player_right_names_mlb.get(x, x) if x in player_wrong_names_mlb else x |
|
|
) |
|
|
else: |
|
|
|
|
|
st.session_state['portfolio'][col] = st.session_state['portfolio'][col].replace(player_wrong_names_mlb) |
|
|
st.dataframe(st.session_state['portfolio'].head(10)) |
|
|
|
|
|
with col3: |
|
|
st.subheader("Projections File") |
|
|
with st.expander('Upload Info'): |
|
|
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.") |
|
|
st.warning("Database load is active and in testing for NBA, NFL, NHL, MMA, and PGA, both Classic and Regular") |
|
|
proj_options = st.selectbox("Select a projections source", options=['Paydirt DB', 'User Upload']) |
|
|
|
|
|
upload_col, template_col = st.columns([3, 1]) |
|
|
|
|
|
with upload_col: |
|
|
if 'portfolio' not in st.session_state: |
|
|
st.session_state['projections_loaded'] = False |
|
|
if proj_options == 'User Upload': |
|
|
projections_file = st.file_uploader("Upload Projections File (CSV or Excel)", type=['csv', 'xlsx', 'xls']) |
|
|
st.session_state['db_projections_file'] = projections_file |
|
|
st.session_state['projections_loaded'] = True |
|
|
elif proj_options == 'Paydirt DB': |
|
|
if st.button("Load from Database"): |
|
|
if sport_var == 'NBA': |
|
|
if site_var == 'Draftkings': |
|
|
if type_var == 'Classic': |
|
|
projections_file = init_nba_baselines(type_var, site_var, slate_var3)[0] |
|
|
elif type_var == 'Showdown': |
|
|
projections_file = init_nba_baselines(type_var, site_var, slate_var3)[2] |
|
|
elif site_var == 'Fanduel': |
|
|
if type_var == 'Classic': |
|
|
projections_file = init_nba_baselines(type_var, site_var, slate_var3)[1] |
|
|
elif type_var == 'Showdown': |
|
|
projections_file = init_nba_baselines(type_var, site_var, slate_var3)[3] |
|
|
elif sport_var == 'NFL': |
|
|
if site_var == 'Draftkings': |
|
|
if type_var == 'Classic': |
|
|
projections_file = init_nfl_baselines(type_var, site_var, slate_var3)[0] |
|
|
elif type_var == 'Showdown': |
|
|
projections_file = init_nfl_baselines(type_var, site_var, slate_var3)[2] |
|
|
elif site_var == 'Fanduel': |
|
|
if type_var == 'Classic': |
|
|
projections_file = init_nfl_baselines(type_var, site_var, slate_var3)[1] |
|
|
elif type_var == 'Showdown': |
|
|
projections_file = init_nfl_baselines(type_var, site_var, slate_var3)[3] |
|
|
elif sport_var == 'NHL': |
|
|
if site_var == 'Draftkings': |
|
|
if type_var == 'Classic': |
|
|
projections_file = init_nhl_baselines(type_var, site_var, slate_var3)[0] |
|
|
elif type_var == 'Showdown': |
|
|
projections_file = init_nhl_baselines(type_var, site_var, slate_var3)[2] |
|
|
elif site_var == 'Fanduel': |
|
|
if type_var == 'Classic': |
|
|
projections_file = init_nhl_baselines(type_var, site_var, slate_var3)[1] |
|
|
elif type_var == 'Showdown': |
|
|
projections_file = init_nhl_baselines(type_var, site_var, slate_var3)[3] |
|
|
elif sport_var == 'MMA': |
|
|
if site_var == 'Draftkings': |
|
|
if type_var == 'Classic': |
|
|
projections_file = init_mma_baselines(type_var, site_var, slate_var3)[0] |
|
|
elif type_var == 'Showdown': |
|
|
projections_file = init_mma_baselines(type_var, site_var, slate_var3)[2] |
|
|
elif site_var == 'Fanduel': |
|
|
if type_var == 'Classic': |
|
|
projections_file = init_mma_baselines(type_var, site_var, slate_var3)[1] |
|
|
elif type_var == 'Showdown': |
|
|
projections_file = init_mma_baselines(type_var, site_var, slate_var3)[3] |
|
|
elif sport_var == 'GOLF': |
|
|
if site_var == 'Draftkings': |
|
|
if type_var == 'Classic': |
|
|
projections_file = init_pga_baselines(type_var, site_var, slate_var3)[0] |
|
|
elif type_var == 'Showdown': |
|
|
projections_file = init_pga_baselines(type_var, site_var, slate_var3)[2] |
|
|
elif site_var == 'Fanduel': |
|
|
if type_var == 'Classic': |
|
|
projections_file = init_pga_baselines(type_var, site_var, slate_var3)[1] |
|
|
elif type_var == 'Showdown': |
|
|
projections_file = init_pga_baselines(type_var, site_var, slate_var3)[3] |
|
|
st.session_state['db_projections_file'] = projections_file |
|
|
st.session_state['projections_loaded'] = True |
|
|
if 'projections_df' in st.session_state: |
|
|
del st.session_state['projections_df'] |
|
|
|
|
|
with template_col: |
|
|
if proj_options == 'User Upload': |
|
|
template_df = pd.DataFrame(columns=['player_names', 'position', 'team', 'salary', 'median', 'ownership', 'captain ownership']) |
|
|
st.download_button( |
|
|
label="Template", |
|
|
data=template_df.to_csv(index=False), |
|
|
file_name="projections_template.csv", |
|
|
mime="text/csv" |
|
|
) |
|
|
|
|
|
if st.session_state['projections_loaded']: |
|
|
export_projections, projections = load_file(st.session_state['db_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('int32') |
|
|
projections['ownership'] = projections['ownership'].astype('float32') |
|
|
|
|
|
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['captain ownership'] = projections['captain ownership'].astype('float32') |
|
|
projections['median'] = projections['median'].astype('float32') |
|
|
|
|
|
for col in projections.select_dtypes(include=['object']).columns: |
|
|
projections[col] = projections[col].replace(player_wrong_names_mlb) |
|
|
|
|
|
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 st.session_state['portfolio_loaded'] and st.session_state['projections_loaded']: |
|
|
if st.session_state['portfolio'] is not None and projections is not None: |
|
|
|
|
|
st.subheader("Name Matching Analysis") |
|
|
|
|
|
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() |
|
|
|
|
|
portfolio_match_dict, unmatched_names = chunk_name_matching(portfolio_names, csv_names) |
|
|
|
|
|
player_columns = [col for col in st.session_state['portfolio'].columns |
|
|
if col not in ['salary', 'median', 'Own']] |
|
|
|
|
|
for col in player_columns: |
|
|
st.session_state['portfolio'][col] = st.session_state['portfolio'][col].map(lambda x: portfolio_match_dict.get(x, x)) |
|
|
|
|
|
projections_match_dict, unmatched_proj_names = chunk_name_matching(projection_names, csv_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']) |
|
|
|
|
|
projections_match_dict2, unmatched_proj_names2 = chunk_name_matching(projection_names, portfolio_names) |
|
|
|
|
|
projections['player_names'] = projections['player_names'].map(lambda x: projections_match_dict2.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: |
|
|
st.session_state['map_dict'] = create_comprehensive_mappings( |
|
|
projections, |
|
|
st.session_state['portfolio'], |
|
|
st.session_state['csv_file'], |
|
|
site_var, |
|
|
type_var, |
|
|
sport_var |
|
|
) |
|
|
|
|
|
st.session_state['portfolio'] = st.session_state['portfolio'].astype(str) |
|
|
st.session_state['portfolio'] = st.session_state['portfolio'][~st.session_state['portfolio'].isin(['', 'nan', 'None', 'NaN']).any(axis=1)].reset_index(drop=True) |
|
|
buffer = io.BytesIO() |
|
|
st.session_state['portfolio'].to_parquet(buffer, compression='snappy') |
|
|
st.session_state['origin_portfolio'] = buffer.getvalue() |
|
|
|
|
|
portfolio_inc_proj = pd.DataFrame() |
|
|
portfolio_inc_proj['player_names'] = get_portfolio_names(st.session_state['portfolio']) + st.session_state['projections_df']['player_names'].tolist() |
|
|
portfolio_inc_proj = portfolio_inc_proj.drop_duplicates(subset=['player_names'], keep='first').reset_index(drop=True) |
|
|
portfolio_inc_proj['position'] = portfolio_inc_proj['player_names'].map(lambda x: st.session_state['map_dict']['pos_map'].get(x, 'FLEX')) |
|
|
portfolio_inc_proj['team'] = portfolio_inc_proj['player_names'].map(lambda x: st.session_state['map_dict']['team_map'].get(x, 'Unknown')) |
|
|
portfolio_inc_proj['salary'] = portfolio_inc_proj['player_names'].map(lambda x: st.session_state['map_dict']['salary_map'].get(x, 0)) |
|
|
portfolio_inc_proj['median'] = portfolio_inc_proj['player_names'].map(lambda x: st.session_state['map_dict']['proj_map'].get(x, 0.0)) |
|
|
portfolio_inc_proj['ownership'] = portfolio_inc_proj['player_names'].map(lambda x: st.session_state['map_dict']['own_map'].get(x, 0.0)) |
|
|
portfolio_inc_proj['captain ownership'] = portfolio_inc_proj['player_names'].map(lambda x: st.session_state['map_dict']['own_map'].get(x, 0.0)) |
|
|
st.session_state['portfolio_inc_proj'] = portfolio_inc_proj.reset_index(drop=True) |
|
|
|
|
|
del st.session_state['portfolio'], st.session_state['export_portfolio'] |
|
|
|
|
|
|
|
|
if selected_tab == 'Projections Management': |
|
|
if 'portfolio_inc_proj' in st.session_state and st.session_state['portfolio_inc_proj'] is not None: |
|
|
st.subheader("Edit Player Projections") |
|
|
st.caption("Modify median, ownership, or captain ownership values directly in the table below. Changes will update both the projections and all related mappings.") |
|
|
|
|
|
projections_editor_df = st.session_state['portfolio_inc_proj'].copy() |
|
|
|
|
|
if 'origin_portfolio' in st.session_state and 'map_dict' in st.session_state: |
|
|
portfolio_df = pd.read_parquet(io.BytesIO(st.session_state['origin_portfolio'])) |
|
|
portfolio_players = set(get_portfolio_names(portfolio_df)) |
|
|
projection_players = set(projections_editor_df['player_names'].tolist()) |
|
|
|
|
|
|
|
|
missing_players = portfolio_players - projection_players |
|
|
|
|
|
if missing_players: |
|
|
|
|
|
missing_rows = [] |
|
|
for player in missing_players: |
|
|
missing_rows.append({ |
|
|
'player_names': player, |
|
|
'position': st.session_state['map_dict']['pos_map'].get(player, 'FLEX'), |
|
|
'team': st.session_state['map_dict']['team_map'].get(player, 'Unknown'), |
|
|
'salary': st.session_state['map_dict']['salary_map'].get(player, 0), |
|
|
'median': st.session_state['map_dict']['proj_map'].get(player, 0.0), |
|
|
'ownership': st.session_state['map_dict']['own_map'].get(player, 0.0), |
|
|
'captain ownership': st.session_state['map_dict'].get('cpt_own_map', {}).get(player, 0.0) |
|
|
}) |
|
|
|
|
|
|
|
|
missing_df = pd.DataFrame(missing_rows) |
|
|
projections_editor_df = pd.concat([projections_editor_df, missing_df], ignore_index=True) |
|
|
|
|
|
st.info(f"📌 Found {len(missing_players)} player(s) in portfolio not in projections. They have been added below with values of 0 for median, ownership, and captain ownership.") |
|
|
|
|
|
|
|
|
column_config = { |
|
|
'player_names': st.column_config.TextColumn( |
|
|
'Player', |
|
|
width='medium' |
|
|
), |
|
|
'position': st.column_config.TextColumn( |
|
|
'Position', |
|
|
width='small' |
|
|
), |
|
|
'team': st.column_config.TextColumn( |
|
|
'Team', |
|
|
width='small' |
|
|
), |
|
|
'salary': st.column_config.NumberColumn( |
|
|
'Salary', |
|
|
width='small', |
|
|
format='$%d' |
|
|
), |
|
|
'median': st.column_config.NumberColumn( |
|
|
'Median', |
|
|
min_value=0.0, |
|
|
max_value=100.0, |
|
|
step=0.1, |
|
|
format='%.2f', |
|
|
width='small' |
|
|
), |
|
|
'ownership': st.column_config.NumberColumn( |
|
|
'Ownership %', |
|
|
min_value=0.0, |
|
|
max_value=100.0, |
|
|
step=0.1, |
|
|
format='%.2f', |
|
|
width='small' |
|
|
), |
|
|
'captain ownership': st.column_config.NumberColumn( |
|
|
'Captain Own %', |
|
|
min_value=0.0, |
|
|
max_value=100.0, |
|
|
step=0.1, |
|
|
format='%.2f', |
|
|
width='small' |
|
|
) |
|
|
} |
|
|
|
|
|
|
|
|
search_col, team_filter_col, position_filter_col = st.columns([2, 1, 1]) |
|
|
with search_col: |
|
|
player_search = st.text_input("🔍 Search players", placeholder="Type player name...", key='proj_player_search') |
|
|
with team_filter_col: |
|
|
team_options = ['All Teams'] + sorted(projections_editor_df['team'].unique().tolist()) |
|
|
team_filter = st.selectbox("Filter by Team", options=team_options, key='proj_team_filter') |
|
|
with position_filter_col: |
|
|
position_options = ['All Positions'] + sorted(projections_editor_df['position'].unique().tolist()) |
|
|
position_filter = st.selectbox("Filter by Position", options=position_options, key='proj_position_filter') |
|
|
|
|
|
|
|
|
filtered_df = projections_editor_df.copy() |
|
|
if player_search: |
|
|
filtered_df = filtered_df[filtered_df['player_names'].str.contains(player_search, case=False, na=False)] |
|
|
if team_filter != 'All Teams': |
|
|
filtered_df = filtered_df[filtered_df['team'] == team_filter] |
|
|
if position_filter != 'All Positions': |
|
|
filtered_df = filtered_df[filtered_df['position'] == position_filter] |
|
|
|
|
|
|
|
|
edited_df = st.data_editor( |
|
|
filtered_df, |
|
|
column_config=column_config, |
|
|
use_container_width=True, |
|
|
hide_index=True, |
|
|
num_rows='fixed', |
|
|
key='projections_editor' |
|
|
) |
|
|
|
|
|
if not edited_df.equals(filtered_df): |
|
|
changed_mask = ~(edited_df[['player_names', 'position', 'team', 'salary', 'median', 'ownership', 'captain ownership']] == filtered_df[['player_names', 'position', 'team', 'salary', 'median', 'ownership', 'captain ownership']]).all(axis=1) |
|
|
changed_rows = edited_df[changed_mask] |
|
|
|
|
|
if len(changed_rows) > 0: |
|
|
|
|
|
for idx, row in changed_rows.iterrows(): |
|
|
player_name = row['player_names'] |
|
|
|
|
|
|
|
|
orig_idx = st.session_state['portfolio_inc_proj'][st.session_state['portfolio_inc_proj']['player_names'] == player_name].index |
|
|
if len(orig_idx) > 0: |
|
|
|
|
|
st.session_state['portfolio_inc_proj'].loc[orig_idx[0], 'player_names'] = row['player_names'] |
|
|
st.session_state['portfolio_inc_proj'].loc[orig_idx[0], 'position'] = row['position'] |
|
|
st.session_state['portfolio_inc_proj'].loc[orig_idx[0], 'team'] = row['team'] |
|
|
st.session_state['portfolio_inc_proj'].loc[orig_idx[0], 'salary'] = row['salary'] |
|
|
st.session_state['portfolio_inc_proj'].loc[orig_idx[0], 'median'] = row['median'] |
|
|
st.session_state['portfolio_inc_proj'].loc[orig_idx[0], 'ownership'] = row['ownership'] |
|
|
st.session_state['portfolio_inc_proj'].loc[orig_idx[0], 'captain ownership'] = row['captain ownership'] |
|
|
else: |
|
|
|
|
|
new_row = pd.DataFrame([{ |
|
|
'player_names': player_name, |
|
|
'position': row['position'], |
|
|
'team': row['team'], |
|
|
'salary': row['salary'], |
|
|
'median': row['median'], |
|
|
'ownership': row['ownership'], |
|
|
'captain ownership': row['captain ownership'] |
|
|
}]) |
|
|
st.session_state['portfolio_inc_proj'] = pd.concat([st.session_state['portfolio_inc_proj'], new_row], ignore_index=True) |
|
|
|
|
|
|
|
|
if 'map_dict' in st.session_state: |
|
|
st.session_state['map_dict']['team_map'][player_name] = str(row['team']) |
|
|
st.session_state['map_dict']['pos_map'][player_name] = str(row['position']) |
|
|
st.session_state['map_dict']['salary_map'][player_name] = int(row['salary']) |
|
|
st.session_state['map_dict']['proj_map'][player_name] = float(row['median']) |
|
|
st.session_state['map_dict']['own_map'][player_name] = float(row['ownership']) |
|
|
|
|
|
|
|
|
ownership_series = pd.Series(st.session_state['map_dict']['own_map']) |
|
|
st.session_state['map_dict']['own_percent_rank'] = dict(ownership_series.rank(pct=True).astype('float32')) |
|
|
|
|
|
|
|
|
if 'cpt_proj_map' in st.session_state['map_dict']: |
|
|
|
|
|
if site_var == 'Draftkings': |
|
|
if type_var == 'Showdown' and sport_var == 'GOLF': |
|
|
st.session_state['map_dict']['cpt_proj_map'][player_name] = float(row['median']) |
|
|
else: |
|
|
st.session_state['map_dict']['cpt_proj_map'][player_name] = float(row['median']) * 1.5 |
|
|
elif site_var == 'Fanduel': |
|
|
st.session_state['map_dict']['cpt_proj_map'][player_name] = float(row['median']) * 1.5 |
|
|
|
|
|
if 'cpt_own_map' in st.session_state['map_dict']: |
|
|
|
|
|
if type_var == 'Showdown' and sport_var == 'GOLF': |
|
|
st.session_state['map_dict']['cpt_own_map'][player_name] = float(row['ownership']) |
|
|
else: |
|
|
st.session_state['map_dict']['cpt_own_map'][player_name] = float(row['captain ownership']) |
|
|
|
|
|
|
|
|
if 'working_frame' in st.session_state: |
|
|
del st.session_state['working_frame'] |
|
|
|
|
|
st.success(f"✅ Updated {len(changed_rows)} player(s). Portfolio metrics will recalculate on next view.") |
|
|
st.rerun() |
|
|
else: |
|
|
st.info("📋 No projections file loaded yet. Please upload projections in the Data Load tab first.") |
|
|
|
|
|
if selected_tab == 'Manage Portfolio': |
|
|
if 'base_frame_names' not in st.session_state: |
|
|
st.session_state['base_frame_names'] = {} |
|
|
if 'origin_portfolio' in st.session_state and 'portfolio_inc_proj' in st.session_state: |
|
|
with st.container(): |
|
|
reset_port_col, recalc_stacks_col, recalc_div_col, set_base_col, blank_reset_col, contest_size_col = st.columns([.15, .10, .10, .10, .30, .25]) |
|
|
with reset_port_col: |
|
|
with st.popover("Reset Portfolio"): |
|
|
st.markdown("choose a base to reset to:") |
|
|
if st.session_state['base_frame_names']: |
|
|
base_choice = st.selectbox("Base Choice", options=list(st.session_state['base_frame_names'].keys()), index=0) |
|
|
if st.button("Load Selected Base"): |
|
|
st.session_state['working_frame'] = load_base_frame(base_choice) |
|
|
st.rerun() |
|
|
else: |
|
|
st.info("No saved base frames available") |
|
|
with recalc_stacks_col: |
|
|
if st.button("Recalculate Stacks"): |
|
|
st.session_state['working_frame'] = recalc_stacks_sizes(st.session_state['working_frame'], st.session_state['player_columns'], st.session_state['map_dict']) |
|
|
st.rerun() |
|
|
with recalc_div_col: |
|
|
if st.button("Recalculate Diversity"): |
|
|
st.session_state['working_frame']['Diversity'] = recalc_diversity(st.session_state['display_frame'], st.session_state['player_columns']) |
|
|
st.rerun() |
|
|
with set_base_col: |
|
|
with st.popover("New Base Setting"): |
|
|
st.markdown("Name of new base:") |
|
|
new_base_name = st.text_input("New Base Name", value='New Base') |
|
|
if st.button("Save Current as Base"): |
|
|
if new_base_name and new_base_name not in st.session_state['base_frame_names']: |
|
|
save_base_frame(new_base_name, st.session_state['working_frame']) |
|
|
st.success(f"Base '{new_base_name}' saved successfully!") |
|
|
elif new_base_name in st.session_state['base_frame_names']: |
|
|
st.error("Base name already exists") |
|
|
else: |
|
|
st.error("Please enter a base name") |
|
|
|
|
|
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: |
|
|
if 'working_frame' in st.session_state: |
|
|
del st.session_state['working_frame'] |
|
|
|
|
|
excluded_cols = ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Stack', 'Size', 'Win%', 'Lineup Edge', 'Lineup Edge_Raw', 'Weighted Own', 'Geomean', 'Diversity', 'SE Score'] |
|
|
|
|
|
|
|
|
if 'working_frame' not in st.session_state: |
|
|
st.session_state['settings_base'] = True |
|
|
|
|
|
|
|
|
initial_frame = pd.read_parquet(io.BytesIO(st.session_state['origin_portfolio'])) |
|
|
st.session_state['player_columns'] = [col for col in initial_frame.columns if col not in excluded_cols] |
|
|
|
|
|
|
|
|
processed_frame = calculate_lineup_metrics( |
|
|
initial_frame, |
|
|
st.session_state['player_columns'], |
|
|
st.session_state['map_dict'], |
|
|
type_var, |
|
|
sport_var, |
|
|
st.session_state['portfolio_inc_proj'] if 'stack_dict' in st.session_state else None |
|
|
) |
|
|
processed_frame = processed_frame[processed_frame['salary'] <= salary_max] |
|
|
|
|
|
if 'stack_dict' in st.session_state: |
|
|
processed_frame['Stack'] = processed_frame.index.map(st.session_state['stack_dict']) |
|
|
processed_frame['Size'] = processed_frame.index.map(st.session_state['size_dict']) |
|
|
|
|
|
|
|
|
final_base_frame = predict_dupes(processed_frame, st.session_state['map_dict'], site_var, type_var, Contest_Size, strength_var, sport_var, salary_max) |
|
|
|
|
|
|
|
|
save_base_frame('Default', final_base_frame) |
|
|
st.session_state['working_frame'] = final_base_frame.copy() |
|
|
|
|
|
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': 1500.0, |
|
|
'Finish_percentile': 1.0, |
|
|
'Diversity': 1.0 |
|
|
} |
|
|
with st.expander('Macro Filter Options'): |
|
|
|
|
|
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=1500.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) |
|
|
min_weighted_own = st.number_input("Min acceptable Weighted Own?", value=0.0, min_value=0.0, max_value=500.0, step=1.0) |
|
|
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=1500.0, min_value=0.0, max_value=1500.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) |
|
|
max_weighted_own = st.number_input("Max acceptable Weighted Own?", value=500.0, min_value=0.0, max_value=500.0, step=1.0) |
|
|
|
|
|
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 |
|
|
|
|
|
|
|
|
filter_mask = ( |
|
|
(st.session_state['working_frame']['salary'] >= min_salary) & |
|
|
(st.session_state['working_frame']['salary'] <= max_salary) & |
|
|
(st.session_state['working_frame']['median'] >= min_proj) & |
|
|
(st.session_state['working_frame']['median'] <= max_proj) & |
|
|
(st.session_state['working_frame']['Own'] >= min_own) & |
|
|
(st.session_state['working_frame']['Own'] <= max_own) & |
|
|
(st.session_state['working_frame']['Dupes'] >= min_dupes) & |
|
|
(st.session_state['working_frame']['Dupes'] <= max_dupes) & |
|
|
(st.session_state['working_frame']['Finish_percentile'] >= min_finish_percentile) & |
|
|
(st.session_state['working_frame']['Finish_percentile'] <= max_finish_percentile) & |
|
|
(st.session_state['working_frame']['Lineup Edge'] >= min_lineup_edge) & |
|
|
(st.session_state['working_frame']['Lineup Edge'] <= max_lineup_edge) & |
|
|
(st.session_state['working_frame']['Weighted Own'] >= min_weighted_own) & |
|
|
(st.session_state['working_frame']['Weighted Own'] <= max_weighted_own) |
|
|
) |
|
|
|
|
|
|
|
|
|
|
|
if 'Stack' in st.session_state['working_frame'].columns: |
|
|
if stack_include_toggle != 'All Stacks': |
|
|
filter_mask &= st.session_state['working_frame']['Stack'].isin(stack_selections) |
|
|
if stack_remove_toggle == 'Yes': |
|
|
filter_mask &= ~st.session_state['working_frame']['Stack'].isin(stack_remove) |
|
|
|
|
|
|
|
|
st.session_state['working_frame'] = st.session_state['working_frame'][filter_mask].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 |
|
|
|
|
|
|
|
|
export_filter_mask = ( |
|
|
(st.session_state['export_base']['salary'] >= min_salary) & |
|
|
(st.session_state['export_base']['salary'] <= max_salary) & |
|
|
(st.session_state['export_base']['median'] >= min_proj) & |
|
|
(st.session_state['export_base']['median'] <= max_proj) & |
|
|
(st.session_state['export_base']['Own'] >= min_own) & |
|
|
(st.session_state['export_base']['Own'] <= max_own) & |
|
|
(st.session_state['export_base']['Dupes'] >= min_dupes) & |
|
|
(st.session_state['export_base']['Dupes'] <= max_dupes) & |
|
|
(st.session_state['export_base']['Finish_percentile'] >= min_finish_percentile) & |
|
|
(st.session_state['export_base']['Finish_percentile'] <= max_finish_percentile) & |
|
|
(st.session_state['export_base']['Lineup Edge'] >= min_lineup_edge) & |
|
|
(st.session_state['export_base']['Lineup Edge'] <= max_lineup_edge) & |
|
|
(st.session_state['export_base']['Weighted Own'] >= min_weighted_own) & |
|
|
(st.session_state['export_base']['Weighted Own'] <= max_weighted_own) |
|
|
) |
|
|
|
|
|
if 'Stack' in st.session_state['export_base'].columns: |
|
|
if stack_include_toggle != 'All Stacks': |
|
|
export_filter_mask &= st.session_state['export_base']['Stack'].isin(stack_selections) |
|
|
if stack_remove_toggle == 'Yes': |
|
|
export_filter_mask &= ~st.session_state['export_base']['Stack'].isin(stack_remove) |
|
|
|
|
|
st.session_state['export_base'] = st.session_state['export_base'][export_filter_mask].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['portfolio_inc_proj']['team'].unique()))), default=[]) |
|
|
team_remove = st.multiselect("Remove teams?", options=sorted(list(set(st.session_state['portfolio_inc_proj']['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 = [] |
|
|
if sport_var == 'NFL': |
|
|
qb_force = st.selectbox("Force QB Stacks?", options=['No', 'Yes'], index=0) |
|
|
else: |
|
|
qb_force = 'No' |
|
|
|
|
|
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: |
|
|
|
|
|
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: |
|
|
|
|
|
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']) |
|
|
) |
|
|
|
|
|
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: |
|
|
|
|
|
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']) |
|
|
) |
|
|
|
|
|
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)] |
|
|
|
|
|
if qb_force == 'Yes': |
|
|
if type_var == 'Classic': |
|
|
|
|
|
team_frame = parsed_frame.iloc[:, 0].map(st.session_state['map_dict']['team_map']) |
|
|
|
|
|
|
|
|
include_mask = team_frame == parsed_frame['Stack'] |
|
|
parsed_frame = parsed_frame[include_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() |
|
|
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: |
|
|
|
|
|
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']) |
|
|
) |
|
|
|
|
|
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: |
|
|
|
|
|
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']) |
|
|
) |
|
|
|
|
|
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('Position Filtering'): |
|
|
with st.form(key='position_filtering_form'): |
|
|
position_choice = st.selectbox("Position to filter", options=[col for col in st.session_state['working_frame'].columns if col not in excluded_cols], index=0) |
|
|
position_filter = st.selectbox("Filter on:", options=pos_parse_options) |
|
|
position_low_threshold = st.number_input("if filtering on Projection/Ownership/Salary, Low Threshold", value=0.0, min_value=0.0, step=1.0) |
|
|
position_high_threshold = st.number_input("if filtering on Projection/Ownership/Salary, High Threshold", value=20000.0, min_value=0.0, step=1.0) |
|
|
filter_keys_pos = st.multiselect("if filtering on Position, Position(s) to keep", options=sport_position_lists[site_var][sport_var], default=[]) |
|
|
filter_keys_team = st.multiselect("if filtering on Team, Team(s) to keep", options=st.session_state['portfolio_inc_proj']['team'].unique(), default=[]) |
|
|
submitted_col, export_col = st.columns(2) |
|
|
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 = parse_portfolio_on_mapped(parsed_frame, st.session_state['map_dict'], pos_parse_mapping[position_filter], filter_keys_pos, filter_keys_team, position_low_threshold, position_high_threshold, position_choice) |
|
|
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 = parse_portfolio_on_mapped(parsed_frame, st.session_state['map_dict'], pos_parse_mapping[position_filter], filter_keys_pos, filter_keys_team, position_low_threshold, position_high_threshold, position_choice) |
|
|
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('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['portfolio_inc_proj'], 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['portfolio_inc_proj'], 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', 'SE Score', '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)'): |
|
|
|
|
|
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() |
|
|
|
|
|
|
|
|
if conditional_side_alpha and conditional_side_beta: |
|
|
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 |
|
|
|
|
|
|
|
|
rows_to_process = alpha_mask |
|
|
|
|
|
|
|
|
if conditional_var == 'Any': |
|
|
|
|
|
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': |
|
|
|
|
|
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': |
|
|
|
|
|
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) |
|
|
|
|
|
|
|
|
final_condition = rows_to_process & beta_mask |
|
|
|
|
|
|
|
|
if keep_remove_var == 'Keep': |
|
|
parsed_frame = parsed_frame[~rows_to_process | final_condition] |
|
|
else: |
|
|
parsed_frame = parsed_frame[~final_condition] |
|
|
|
|
|
elif conditional_side_alpha: |
|
|
|
|
|
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: |
|
|
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() |
|
|
|
|
|
|
|
|
if conditional_side_alpha and conditional_side_beta: |
|
|
|
|
|
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 |
|
|
|
|
|
|
|
|
rows_to_process = alpha_mask |
|
|
|
|
|
|
|
|
if conditional_var == 'Any': |
|
|
|
|
|
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': |
|
|
|
|
|
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': |
|
|
|
|
|
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) |
|
|
|
|
|
|
|
|
final_condition = rows_to_process & beta_mask |
|
|
|
|
|
|
|
|
if keep_remove_var == 'Keep': |
|
|
parsed_frame = parsed_frame[~rows_to_process | final_condition] |
|
|
else: |
|
|
parsed_frame = parsed_frame[~final_condition] |
|
|
|
|
|
elif conditional_side_alpha: |
|
|
|
|
|
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: |
|
|
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('Conditionals Manager (combos)'): |
|
|
|
|
|
with st.form(key='conditional_combos_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()) |
|
|
|
|
|
replace_player = st.selectbox("Replace player:", options=sorted(list(player_names)), key='replace_player') |
|
|
replace_slot = st.selectbox("In slot:", options=['Overall', 'CPT', 'FLEX'], index=0, key='replace_slot') |
|
|
containing_player = st.selectbox("In Lineups containing:", options=sorted(list(player_names)), key='containing_player') |
|
|
containing_slot = st.selectbox("In slot:", options=['Overall', 'CPT', 'FLEX'], index=0, key='containing_slot') |
|
|
|
|
|
specific_replacements_combo = st.multiselect("Specific replacements?", options=sorted(list(player_names)), default=[], key='specific_replacements_combo') |
|
|
specific_exclusions_combo = st.multiselect("Specific exclusions?", options=sorted(list(player_names)), default=[], key='specific_exclusions_combo') |
|
|
|
|
|
comp_salary_below_combo = st.number_input("Comp Salary Below", value=-5000, min_value=-5000, max_value=0, step=100, key='comp_salary_below_combo') |
|
|
comp_salary_above_combo = st.number_input("Comp Salary Above", value=5000, min_value=0, max_value=5000, step=100, key='comp_salary_above_combo') |
|
|
|
|
|
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 replace_player and containing_player and replace_player != containing_player: |
|
|
|
|
|
containing_mask = pd.Series([False] * len(parsed_frame), index=parsed_frame.index) |
|
|
|
|
|
if type_var == 'Showdown': |
|
|
if containing_slot == 'Overall': |
|
|
containing_mask = parsed_frame.apply(lambda row: containing_player in row.values, axis=1) |
|
|
elif containing_slot == 'CPT': |
|
|
containing_mask = parsed_frame.iloc[:, 0].apply(lambda row: containing_player in row) |
|
|
elif containing_slot == 'FLEX': |
|
|
containing_mask = parsed_frame.iloc[:, 1:].apply(lambda row: containing_player in row.values, axis=1) |
|
|
else: |
|
|
containing_mask = parsed_frame.apply(lambda row: containing_player in row.values, axis=1) |
|
|
|
|
|
|
|
|
target_rows = parsed_frame[containing_mask] |
|
|
|
|
|
if not target_rows.empty: |
|
|
|
|
|
target_rows_reset = target_rows.reset_index(drop=True) |
|
|
|
|
|
|
|
|
target_rows_prepared = prepare_dataframe_for_exposure_spread(target_rows_reset, st.session_state['player_columns']) |
|
|
|
|
|
|
|
|
|
|
|
modified_rows = exposure_spread( |
|
|
target_rows_prepared, |
|
|
replace_player, |
|
|
0, |
|
|
comp_salary_below_combo, |
|
|
comp_salary_above_combo, |
|
|
[], |
|
|
[], |
|
|
specific_replacements_combo, |
|
|
specific_exclusions_combo, |
|
|
st.session_state['player_columns'] if replace_slot == 'Overall' else |
|
|
([st.session_state['player_columns'][0]] if replace_slot == 'CPT' else st.session_state['player_columns'][1:]), |
|
|
st.session_state['portfolio_inc_proj'], |
|
|
sport_var, |
|
|
type_var, |
|
|
salary_max, |
|
|
stacking_sports |
|
|
) |
|
|
|
|
|
|
|
|
parsed_frame.loc[containing_mask] = modified_rows.values |
|
|
|
|
|
|
|
|
parsed_frame = calculate_lineup_metrics( |
|
|
parsed_frame, |
|
|
st.session_state['player_columns'], |
|
|
st.session_state['map_dict'], |
|
|
type_var, |
|
|
sport_var, |
|
|
st.session_state['portfolio_inc_proj'] |
|
|
) |
|
|
|
|
|
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 replace_player and containing_player and replace_player != containing_player: |
|
|
containing_mask = pd.Series([False] * len(parsed_frame), index=parsed_frame.index) |
|
|
|
|
|
if type_var == 'Showdown': |
|
|
if containing_slot == 'Overall': |
|
|
containing_mask = parsed_frame.apply(lambda row: containing_player in row.values, axis=1) |
|
|
elif containing_slot == 'CPT': |
|
|
containing_mask = parsed_frame.iloc[:, 0].apply(lambda row: containing_player in row) |
|
|
elif containing_slot == 'FLEX': |
|
|
containing_mask = parsed_frame.iloc[:, 1:].apply(lambda row: containing_player in row.values, axis=1) |
|
|
else: |
|
|
containing_mask = parsed_frame.apply(lambda row: containing_player in row.values, axis=1) |
|
|
|
|
|
|
|
|
target_rows = parsed_frame[containing_mask] |
|
|
|
|
|
if not target_rows.empty: |
|
|
target_rows_reset = target_rows.reset_index(drop=True) |
|
|
|
|
|
target_rows_prepared = prepare_dataframe_for_exposure_spread(target_rows_reset, st.session_state['player_columns']) |
|
|
|
|
|
modified_rows = exposure_spread( |
|
|
target_rows_prepared, |
|
|
replace_player, |
|
|
0, |
|
|
comp_salary_below_combo, |
|
|
comp_salary_above_combo, |
|
|
[], |
|
|
[], |
|
|
specific_replacements_combo, |
|
|
specific_exclusions_combo, |
|
|
st.session_state['player_columns'] if replace_slot == 'Overall' else |
|
|
([st.session_state['player_columns'][0]] if replace_slot == 'CPT' else st.session_state['player_columns'][1:]), |
|
|
st.session_state['portfolio_inc_proj'], |
|
|
sport_var, |
|
|
type_var, |
|
|
salary_max, |
|
|
stacking_sports |
|
|
) |
|
|
|
|
|
parsed_frame.loc[containing_mask] = modified_rows.values |
|
|
|
|
|
parsed_frame = calculate_lineup_metrics( |
|
|
parsed_frame, |
|
|
st.session_state['player_columns'], |
|
|
st.session_state['map_dict'], |
|
|
type_var, |
|
|
sport_var, |
|
|
st.session_state['portfolio_inc_proj'] |
|
|
) |
|
|
|
|
|
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(get_portfolio_names(st.session_state['working_frame']) + st.session_state['portfolio_inc_proj']['player_names'].tolist()))), key='exposure_player') |
|
|
exposure_target = st.number_input("Target Exposure", value=.50, min_value=0.0, max_value=1.0, step=0.01) |
|
|
comp_salary_below = st.number_input("Comp Salary Below", value=-5000, min_value=-5000, max_value=0, step=100) |
|
|
comp_salary_above = st.number_input("Comp Salary Above", value=5000, min_value=0, max_value=5000, step=100) |
|
|
if 'Stack' in st.session_state['working_frame'].columns: |
|
|
ignore_stacks = st.multiselect("Ignore Specific Stacks?", options=sorted(list(set(st.session_state['portfolio_inc_proj']['team'].unique()))), default=[]) |
|
|
else: |
|
|
ignore_stacks = [] |
|
|
remove_teams_exposure = st.multiselect("Removed/Locked teams?", options=sorted(list(set(st.session_state['portfolio_inc_proj']['team'].unique()))), default=[]) |
|
|
specific_replacements = st.multiselect("Specific Replacements?", options=sorted(list(set(get_portfolio_names(st.session_state['working_frame']) + st.session_state['portfolio_inc_proj']['player_names'].tolist()))), default=[]) |
|
|
specific_exclusions = st.multiselect("Specific exclusions?", options=sorted(list(set(get_portfolio_names(st.session_state['working_frame']) + st.session_state['portfolio_inc_proj']['player_names'].tolist()))), default=[]) |
|
|
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 |
|
|
working_frame_prepared = prepare_dataframe_for_exposure_spread(st.session_state['working_frame'], st.session_state['player_columns']) |
|
|
parsed_frame = exposure_spread(working_frame_prepared, st.session_state['exposure_player'], exposure_target, comp_salary_below, comp_salary_above, ignore_stacks, remove_teams_exposure, specific_replacements, specific_exclusions, specific_columns, st.session_state['portfolio_inc_proj'], sport_var, type_var, salary_max, stacking_sports) |
|
|
|
|
|
|
|
|
parsed_frame = calculate_lineup_metrics( |
|
|
parsed_frame, |
|
|
st.session_state['player_columns'], |
|
|
st.session_state['map_dict'], |
|
|
type_var, |
|
|
sport_var, |
|
|
st.session_state['portfolio_inc_proj'] |
|
|
) |
|
|
|
|
|
st.session_state['working_frame'] = parsed_frame.reset_index(drop=True) |
|
|
default_base = load_base_frame('Default') |
|
|
st.session_state['working_frame'] = reassess_edge(st.session_state['working_frame'], default_base, st.session_state['map_dict'], site_var, type_var, Contest_Size, strength_var, sport_var, salary_max) |
|
|
team_dict = dict(zip(st.session_state['portfolio_inc_proj']['player_names'], st.session_state['portfolio_inc_proj']['team'])) |
|
|
if 'Stack' in st.session_state['working_frame'].columns: |
|
|
st.session_state['working_frame']['Stack'] = st.session_state['working_frame'].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['working_frame']['Size'] = st.session_state['working_frame'].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['export_merge'] = st.session_state['working_frame'].copy() |
|
|
elif exp_submitted: |
|
|
st.session_state['settings_base'] = False |
|
|
export_base_prepared = prepare_dataframe_for_exposure_spread(st.session_state['export_base'], st.session_state['player_columns']) |
|
|
parsed_frame = exposure_spread(export_base_prepared, st.session_state['exposure_player'], exposure_target, comp_salary_below, comp_salary_above, ignore_stacks, remove_teams_exposure, specific_replacements, specific_exclusions, specific_columns, st.session_state['portfolio_inc_proj'], sport_var, type_var, salary_max, stacking_sports) |
|
|
|
|
|
|
|
|
parsed_frame = calculate_lineup_metrics( |
|
|
parsed_frame, |
|
|
st.session_state['player_columns'], |
|
|
st.session_state['map_dict'], |
|
|
type_var, |
|
|
sport_var, |
|
|
st.session_state['portfolio_inc_proj'] |
|
|
) |
|
|
|
|
|
st.session_state['export_base'] = parsed_frame.reset_index(drop=True) |
|
|
default_base = load_base_frame('Default') |
|
|
st.session_state['export_base'] = reassess_edge(st.session_state['export_base'], default_base, st.session_state['map_dict'], site_var, type_var, Contest_Size, strength_var, sport_var, salary_max) |
|
|
team_dict = dict(zip(st.session_state['portfolio_inc_proj']['player_names'], st.session_state['portfolio_inc_proj']['team'])) |
|
|
if 'Stack' in st.session_state['export_base'].columns: |
|
|
st.session_state['export_base']['Stack'] = st.session_state['export_base'].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['export_base']['Size'] = st.session_state['export_base'].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['export_merge'] = st.session_state['export_base'].copy() |
|
|
|
|
|
with st.expander('Lineup Reoptimization'): |
|
|
with st.form(key='Reoptimize'): |
|
|
optimize_by = st.selectbox("Optimize By", options=['median', 'ownership'], key='optimize_by') |
|
|
lock_teams_optimize = st.multiselect( |
|
|
"Locked Teams", |
|
|
options=sorted(list(set(st.session_state['portfolio_inc_proj']['team'].unique()))), |
|
|
default=[], |
|
|
key='lock_teams_optimize' |
|
|
) |
|
|
opt_submitted_col, opt_export_col = st.columns(2) |
|
|
st.info("Portfolio Button applies to your overall Portfolio, Export button applies to your Custom Export") |
|
|
with opt_submitted_col: |
|
|
opt_reg_submitted = st.form_submit_button("Portfolio") |
|
|
with opt_export_col: |
|
|
opt_exp_submitted = st.form_submit_button("Export") |
|
|
|
|
|
if opt_reg_submitted: |
|
|
st.session_state['settings_base'] = False |
|
|
|
|
|
|
|
|
original_frame = st.session_state['working_frame'][st.session_state['player_columns']].copy() |
|
|
|
|
|
|
|
|
optimized_frame = optimize_lineup( |
|
|
working_frame=st.session_state['working_frame'], |
|
|
projections_df=st.session_state['portfolio_inc_proj'], |
|
|
player_columns=st.session_state['player_columns'], |
|
|
map_dict=st.session_state['map_dict'], |
|
|
lock_teams=lock_teams_optimize, |
|
|
site_var=site_var, |
|
|
type_var=type_var, |
|
|
sport_var=sport_var, |
|
|
salary_max=salary_max, |
|
|
optimize_by=optimize_by |
|
|
) |
|
|
|
|
|
|
|
|
st.session_state['optimization_changes_mask'] = ( |
|
|
original_frame != optimized_frame[st.session_state['player_columns']] |
|
|
) |
|
|
|
|
|
|
|
|
optimized_frame = calculate_lineup_metrics( |
|
|
optimized_frame, |
|
|
st.session_state['player_columns'], |
|
|
st.session_state['map_dict'], |
|
|
type_var, |
|
|
sport_var, |
|
|
st.session_state['portfolio_inc_proj'] |
|
|
) |
|
|
|
|
|
st.session_state['working_frame'] = optimized_frame.reset_index(drop=True) |
|
|
|
|
|
|
|
|
default_base = load_base_frame('Default') |
|
|
st.session_state['working_frame'] = reassess_edge( |
|
|
st.session_state['working_frame'], |
|
|
default_base, |
|
|
st.session_state['map_dict'], |
|
|
site_var, |
|
|
type_var, |
|
|
Contest_Size, |
|
|
strength_var, |
|
|
sport_var, |
|
|
salary_max |
|
|
) |
|
|
|
|
|
|
|
|
team_dict = dict(zip(st.session_state['portfolio_inc_proj']['player_names'], st.session_state['portfolio_inc_proj']['team'])) |
|
|
if 'Stack' in st.session_state['working_frame'].columns: |
|
|
st.session_state['working_frame']['Stack'] = st.session_state['working_frame'].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['working_frame']['Size'] = st.session_state['working_frame'].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['export_merge'] = st.session_state['working_frame'].copy() |
|
|
|
|
|
elif opt_exp_submitted: |
|
|
st.session_state['settings_base'] = False |
|
|
|
|
|
|
|
|
original_frame = st.session_state['export_base'][st.session_state['player_columns']].copy() |
|
|
|
|
|
|
|
|
optimized_frame = optimize_lineup( |
|
|
working_frame=st.session_state['export_base'], |
|
|
projections_df=st.session_state['portfolio_inc_proj'], |
|
|
player_columns=st.session_state['player_columns'], |
|
|
map_dict=st.session_state['map_dict'], |
|
|
lock_teams=lock_teams_optimize, |
|
|
site_var=site_var, |
|
|
type_var=type_var, |
|
|
sport_var=sport_var, |
|
|
salary_max=salary_max, |
|
|
optimize_by=optimize_by |
|
|
) |
|
|
|
|
|
|
|
|
st.session_state['optimization_changes_mask'] = ( |
|
|
original_frame != optimized_frame[st.session_state['player_columns']] |
|
|
) |
|
|
|
|
|
|
|
|
optimized_frame = calculate_lineup_metrics( |
|
|
optimized_frame, |
|
|
st.session_state['player_columns'], |
|
|
st.session_state['map_dict'], |
|
|
type_var, |
|
|
sport_var, |
|
|
st.session_state['portfolio_inc_proj'] |
|
|
) |
|
|
|
|
|
st.session_state['export_base'] = optimized_frame.reset_index(drop=True) |
|
|
|
|
|
|
|
|
default_base = load_base_frame('Default') |
|
|
st.session_state['export_base'] = reassess_edge( |
|
|
st.session_state['export_base'], |
|
|
default_base, |
|
|
st.session_state['map_dict'], |
|
|
site_var, |
|
|
type_var, |
|
|
Contest_Size, |
|
|
strength_var, |
|
|
sport_var, |
|
|
salary_max |
|
|
) |
|
|
|
|
|
|
|
|
team_dict = dict(zip(st.session_state['portfolio_inc_proj']['player_names'], st.session_state['portfolio_inc_proj']['team'])) |
|
|
if 'Stack' in st.session_state['export_base'].columns: |
|
|
st.session_state['export_base']['Stack'] = st.session_state['export_base'].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['export_base']['Size'] = st.session_state['export_base'].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['export_merge'] = st.session_state['export_base'].copy() |
|
|
|
|
|
|
|
|
if st.button("Clear Optimization Highlighting", key='clear_opt_highlight'): |
|
|
if 'optimization_changes_mask' in st.session_state: |
|
|
del st.session_state['optimization_changes_mask'] |
|
|
|
|
|
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: |
|
|
|
|
|
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 |
|
|
|
|
|
|
|
|
if 'current_page' not in st.session_state: |
|
|
st.session_state.current_page = 1 |
|
|
|
|
|
|
|
|
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}" |
|
|
) |
|
|
|
|
|
|
|
|
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 |
|
|
) |
|
|
|
|
|
|
|
|
start_idx = (st.session_state.current_page - 1) * rows_per_page |
|
|
end_idx = min(start_idx + rows_per_page, total_rows) |
|
|
|
|
|
|
|
|
current_page_data = st.session_state['display_frame'].iloc[start_idx:end_idx] |
|
|
|
|
|
|
|
|
def highlight_optimization_changes(df): |
|
|
styles = pd.DataFrame('', index=df.index, columns=df.columns) |
|
|
if 'optimization_changes_mask' in st.session_state: |
|
|
mask = st.session_state['optimization_changes_mask'] |
|
|
for col in mask.columns: |
|
|
if col in styles.columns: |
|
|
common_idx = mask.index.intersection(df.index) |
|
|
for idx in common_idx: |
|
|
if mask.loc[idx, col]: |
|
|
styles.loc[idx, col] = 'background-color: #DAA520; color: black' |
|
|
return styles |
|
|
|
|
|
|
|
|
st.dataframe( |
|
|
current_page_data.style |
|
|
.apply(highlight_optimization_changes, axis=None) |
|
|
.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 type_var == 'Showdown': |
|
|
position_parse_options = ['All', *showdown_position_lists] |
|
|
else: |
|
|
position_parse_options = ['All', *sport_position_lists[site_var][sport_var]] |
|
|
position_parse = st.selectbox("Parse by:", options=position_parse_options, index=0, key='position_parse') |
|
|
|
|
|
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], |
|
|
'Team': st.session_state['map_dict']['team_map'][player], |
|
|
'ProjOwn': st.session_state['map_dict']['own_map'][player] / 100.0, |
|
|
'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: |
|
|
|
|
|
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': 'CPT', |
|
|
'Team': st.session_state['map_dict']['team_map'][player], |
|
|
'ProjOwn': st.session_state['map_dict']['cpt_own_map'][player] / 100.0, |
|
|
'Exposure': cpt_mask.sum() / len(st.session_state['display_frame']), |
|
|
'Own_Edge': st.session_state['map_dict']['cpt_own_map'][player] / 100.0 - (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(), |
|
|
}) |
|
|
|
|
|
|
|
|
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': 'FLEX', |
|
|
'Team': st.session_state['map_dict']['team_map'][player], |
|
|
'ProjOwn': (st.session_state['map_dict']['own_map'][player] - st.session_state['map_dict']['cpt_own_map'][player]) / 100.0, |
|
|
'Exposure': flex_mask.sum() / len(st.session_state['display_frame']), |
|
|
'Own_Edge': (st.session_state['map_dict']['own_map'][player] - st.session_state['map_dict']['cpt_own_map'][player]) / 100.0 - (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': |
|
|
|
|
|
for player in player_names: |
|
|
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': 'CPT', |
|
|
'Team': st.session_state['map_dict']['team_map'][player], |
|
|
'ProjOwn': st.session_state['map_dict']['cpt_own_map'][player] / 100.0, |
|
|
'Exposure': cpt_mask.sum() / len(st.session_state['display_frame']), |
|
|
'Own_Edge': st.session_state['map_dict']['cpt_own_map'][player] / 100.0 - (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(), |
|
|
}) |
|
|
|
|
|
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': 'FLEX', |
|
|
'Team': st.session_state['map_dict']['team_map'][player], |
|
|
'ProjOwn': (st.session_state['map_dict']['own_map'][player] - st.session_state['map_dict']['cpt_own_map'][player]) / 100.0, |
|
|
'Exposure': flex_mask.sum() / len(st.session_state['display_frame']), |
|
|
'Own_Edge': (st.session_state['map_dict']['own_map'][player] - st.session_state['map_dict']['cpt_own_map'][player]) / 100.0 - (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': |
|
|
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], |
|
|
'Team': st.session_state['map_dict']['team_map'][player], |
|
|
'ProjOwn': st.session_state['map_dict']['own_map'][player] / 100.0, |
|
|
'Exposure': player_mask.sum() / len(st.session_state['display_frame']), |
|
|
'Own_Edge': st.session_state['map_dict']['own_map'][player] / 100.0 - (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('Exposure', 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() |
|
|
|
|
|
if position_parse != 'All': |
|
|
st.session_state['player_summary'] = st.session_state['player_summary'][st.session_state['player_summary']['Position'].str.contains(position_parse)] |
|
|
else: |
|
|
st.session_state['player_summary'] = st.session_state['player_summary'] |
|
|
|
|
|
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({ |
|
|
'ProjOwn': '{:.2%}', |
|
|
'Own_Edge': '{:.2%}', |
|
|
'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") |
|
|
|
|
|
|
|
|
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 |
|
|
) |
|
|
|
|
|
|
|
|
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.") |
|
|
|
