app.py

import streamlit as st
st.set_page_config(layout="wide")
import numpy as np
import pandas as pd
import time
from fuzzywuzzy import process
from collections import Counter

## import global functions
from global_func.clean_player_name import clean_player_name
from global_func.load_contest_file import load_contest_file
from global_func.load_file import load_file
from global_func.load_ss_file import load_ss_file
from global_func.find_name_mismatches import find_name_mismatches
from global_func.predict_dupes import predict_dupes
from global_func.highlight_rows import highlight_changes, highlight_changes_winners, highlight_changes_losers
from global_func.load_csv import load_csv
from global_func.find_csv_mismatches import find_csv_mismatches

player_exposure_format = {'Exposure Overall': '{:.2%}', 'Exposure Top 1%': '{:.2%}', 'Exposure Top 5%': '{:.2%}', 'Exposure Top 10%': '{:.2%}', 'Exposure Top 20%': '{:.2%}'}

tab1, tab2 = st.tabs(["Data Load", "Contest Analysis"])
with tab1:
    if st.button('Clear data', key='reset1'):
        st.session_state.clear()
    sport_select = st.selectbox("Select Sport", ['MLB', 'NBA', 'NFL'])
    # Add file uploaders to your app
    col1, col2 = st.columns(2)
    
    with col1:
        st.subheader("Contest File")
        st.info("Go ahead and upload a Contest file here. Only include player columns and an optional 'Stack' column if you are playing MLB.")
        Contest_file = st.file_uploader("Upload Contest File (CSV or Excel)", type=['csv', 'xlsx', 'xls'])
        if 'Contest' in st.session_state:
            del st.session_state['Contest']

        if Contest_file:
            contest_base, ownership_df, fpts_df, st.session_state['entry_list'] = load_contest_file(Contest_file, sport_select)
            contest_base = contest_base.dropna(how='all')
            contest_base = contest_base.reset_index(drop=True)
            if contest_base is not None:
                st.success('Contest file loaded successfully!')
                st.dataframe(contest_base.head(10))

    with col2:
        st.subheader("Projections File")
        st.info("upload a projections file that has 'player_names', 'salary', 'median', 'ownership', and 'captain ownership' (Needed for Showdown) columns. Note that the salary for showdown needs to be the FLEX salary, not the captain salary.")
        
        # Create two columns for the uploader and template button
        upload_col, template_col = st.columns([3, 1])
        
        with upload_col:
            projections_file = st.file_uploader("Upload Projections File (CSV or Excel)", type=['csv', 'xlsx', 'xls'])
            if 'projections_df' in st.session_state:
                del st.session_state['projections_df']
        
        with template_col:
            # Create empty DataFrame with required columns
            template_df = pd.DataFrame(columns=['player_names', 'position', 'team', 'salary', 'median', 'ownership', 'captain ownership'])
            # Add download button for template
            st.download_button(
                label="Template",
                data=template_df.to_csv(index=False),
                file_name="projections_template.csv",
                mime="text/csv"
            )
            
        if projections_file:
            export_projections, projections = load_file(projections_file)
            if projections is not None:
                st.success('Projections file loaded successfully!')
                st.dataframe(projections.head(10))

    if Contest_file and projections_file:
        if 'Contest' not in st.session_state and 'projections_df' not in st.session_state:
            if contest_base is not None and projections is not None:
                st.subheader("Name Matching functions")
                st.session_state['Contest'], st.session_state['projections_df'], ownership_dict, actual_dict = find_name_mismatches(contest_base, projections, ownership_df, fpts_df)
                st.session_state['projections_df']['salary'] = (st.session_state['projections_df']['salary'].astype(str).str.replace(',', '').astype(float).astype(int))

with tab2:
    if 'Contest' in st.session_state and 'projections_df' in st.session_state:
        col1, col2 = st.columns([1, 8])
        excluded_cols = ['BaseName', 'EntryCount']
        player_columns = [col for col in st.session_state['Contest'].columns if col not in excluded_cols]
        for col in player_columns:
            st.session_state['Contest'][col] = st.session_state['Contest'][col].astype(str)
        
        # Create mapping dictionaries
        map_dict = {
            'pos_map': dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])),
            'team_map': dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])),
            'salary_map': dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
            'proj_map': dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])),
            'own_map': dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'])),
            'own_percent_rank': dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))),
            'cpt_salary_map': dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
            'cpt_proj_map': dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'] * 1.5)),
            'cpt_own_map': dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['captain ownership']))
        }
        # Create a copy of the dataframe for calculations
        working_df = st.session_state['Contest'].copy()

        with col1:
            with st.expander("Info and filters"):
                if st.button('Clear data', key='reset3'):
                    st.session_state.clear()
                with st.form(key='filter_form'):
                    type_var = st.selectbox("Select Game Type", ['Classic', 'Showdown'])
                    entry_parse_var = st.selectbox("Do you want to view a specific player(s) or a group of players?", ['All', 'Specific'])
                    entry_names = st.multiselect("Select players", options=st.session_state['entry_list'], default=[])
                    submitted = st.form_submit_button("Submit")
                    if submitted:
                        if 'player_frame' in st.session_state:
                            del st.session_state['player_frame']
                        if 'stack_frame' in st.session_state:
                            del st.session_state['stack_frame']
                        # Apply entry name filter if specific entries are selected
                        if entry_parse_var == 'Specific' and entry_names:
                            working_df = working_df[working_df['BaseName'].isin(entry_names)]

        # Calculate metrics based on game type
        st.write(actual_dict)
        if type_var == 'Classic':
            working_df['stack'] = working_df.apply(
                lambda row: Counter(
                    map_dict['team_map'].get(player, '') for player in row[4:]
                    if map_dict['team_map'].get(player, '') != ''
                ).most_common(1)[0][0] if any(map_dict['team_map'].get(player, '') for player in row[4:]) else '',
                axis=1
            )
            working_df['stack_size'] = working_df.apply(
                lambda row: Counter(
                    map_dict['team_map'].get(player, '') for player in row[4:]
                    if map_dict['team_map'].get(player, '') != ''
                ).most_common(1)[0][1] if any(map_dict['team_map'].get(player, '') for player in row[4:]) else '',
                axis=1
            )
            working_df['salary'] = working_df.apply(lambda row: sum(map_dict['salary_map'].get(player, 0) for player in row), axis=1)
            working_df['median'] = working_df.apply(lambda row: sum(map_dict['proj_map'].get(player, 0) for player in row), axis=1)
            working_df['actual_fpts'] = working_df.apply(lambda row: sum(actual_dict.get(player, 0) for player in row), axis=1)
            working_df['Own'] = working_df.apply(lambda row: sum(map_dict['own_map'].get(player, 0) for player in row), axis=1)
            working_df['actual_own'] = working_df.apply(lambda row: sum(ownership_dict.get(player, 0) for player in row), axis=1)
            working_df['sorted'] = working_df[player_columns].apply(
                lambda row: ','.join(sorted(row.values)),
                axis=1
            )
            working_df['dupes'] = working_df.groupby('sorted').transform('size')
            working_df = working_df.reset_index()
            working_df['percentile_finish'] = working_df['index'].rank(pct=True)
            working_df = working_df.drop(['sorted', 'index'], axis=1)
        elif type_var == 'Showdown':
            working_df['stack'] = working_df.apply(
                lambda row: Counter(
                    map_dict['team_map'].get(player, '') for player in row
                    if map_dict['team_map'].get(player, '') != ''
                ).most_common(1)[0][0] if any(map_dict['team_map'].get(player, '') for player in row) else '',
                axis=1
            )
            working_df['stack_size'] = working_df.apply(
                lambda row: Counter(
                    map_dict['team_map'].get(player, '') for player in row
                    if map_dict['team_map'].get(player, '') != ''
                ).most_common(1)[0][1] if any(map_dict['team_map'].get(player, '') for player in row) else '',
                axis=1
            )
            working_df['salary'] = working_df.apply(
                lambda row: map_dict['cpt_salary_map'].get(row.iloc[0], 0) + 
                            sum(map_dict['salary_map'].get(player, 0) for player in row.iloc[1:]),
                axis=1
            )
            working_df['median'] = working_df.apply(
                lambda row: map_dict['cpt_proj_map'].get(row.iloc[0], 0) + 
                            sum(map_dict['proj_map'].get(player, 0) for player in row.iloc[1:]),
                axis=1
            )
            working_df['Own'] = working_df.apply(
                lambda row: map_dict['cpt_own_map'].get(row.iloc[0], 0) + 
                            sum(map_dict['own_map'].get(player, 0) for player in row.iloc[1:]),
                axis=1
            )
            working_df['sorted'] = working_df[player_columns].apply(
                lambda row: row[0] + '|' + ','.join(sorted(row[1:].values)),
                axis=1
            )
            working_df['dupes'] = working_df.groupby('sorted').transform('size')
            working_df = working_df.reset_index()
            working_df['percentile_finish'] = working_df['index'].rank(pct=True)
            working_df = working_df.drop(['sorted', 'index'], axis=1)
        
        # Initialize pagination in session state if not exists
        if 'current_page' not in st.session_state:
            st.session_state.current_page = 1

        # Calculate total pages
        rows_per_page = 500
        total_rows = len(working_df)
        total_pages = (total_rows + rows_per_page - 1) // rows_per_page

        # Create pagination controls in a single row
        pagination_cols = st.columns([4, 1, 1, 1, 4])
        with pagination_cols[1]:
            if st.button(f"Previous Page"):
                if st.session_state['current_page'] > 1:
                    st.session_state.current_page -= 1
                else:
                    st.session_state.current_page = 1
                    if 'player_frame' in st.session_state:
                        del st.session_state['player_frame']
                    if 'stack_frame' in st.session_state:
                        del st.session_state['stack_frame']

        with pagination_cols[3]:
            if st.button(f"Next Page"):
                st.session_state.current_page += 1
                if 'player_frame' in st.session_state:
                    del st.session_state['player_frame']
                if 'stack_frame' in st.session_state:
                    del st.session_state['stack_frame']

        # Calculate start and end indices for current page
        start_idx = (st.session_state.current_page - 1) * rows_per_page
        end_idx = min((st.session_state.current_page) * rows_per_page, total_rows)
        st.dataframe(
            working_df.iloc[start_idx:end_idx].style
            .background_gradient(axis=0)
            .background_gradient(cmap='RdYlGn')
            .format(precision=2), 
            height=500,
            use_container_width=True,
            hide_index=True
        )

        with st.container():
            tab1, tab2, tab3 = st.tabs(['Player Used Info', 'Stack Used Info', 'Duplication Info'])
            with tab1:
                if entry_parse_var == 'All':
                    overall_players = pd.Series(list(working_df[player_columns].values.flatten())).value_counts()
                    top_1per_players = pd.Series(list(working_df[working_df['percentile_finish'] <= 0.01][player_columns].values.flatten())).value_counts()
                    top_5per_players = pd.Series(list(working_df[working_df['percentile_finish'] <= 0.05][player_columns].values.flatten())).value_counts()
                    top_10per_players = pd.Series(list(working_df[working_df['percentile_finish'] <= 0.10][player_columns].values.flatten())).value_counts()
                    top_20per_players = pd.Series(list(working_df[working_df['percentile_finish'] <= 0.20][player_columns].values.flatten())).value_counts()
                    contest_len = len(working_df)
                    len_1per = len(working_df[working_df['percentile_finish'] <= 0.01])
                    len_5per = len(working_df[working_df['percentile_finish'] <= 0.05])
                    len_10per = len(working_df[working_df['percentile_finish'] <= 0.10])
                    len_20per = len(working_df[working_df['percentile_finish'] <= 0.20])
                    each_set_name = ['Overall', ' Top 1%', ' Top 5%', 'Top 10%', 'Top 20%']
                    each_frame_set = [overall_players, top_1per_players, top_5per_players, top_10per_players, top_20per_players]
                    each_len_set = [contest_len, len_1per, len_5per, len_10per, len_20per]
                    player_count_var = 0
                    for each_set in each_frame_set:
                        set_frame = each_set.to_frame().reset_index().rename(columns={'index': 'Player', 'count': 'Count'})
                        set_frame['Percent'] = set_frame['Count'] / each_len_set[player_count_var]
                        set_frame = set_frame[['Player', 'Percent']]
                        set_frame = set_frame.rename(columns={'Percent': f'Exposure {each_set_name[player_count_var]}'})
                        if 'player_frame' not in st.session_state:
                            st.session_state['player_frame'] = set_frame
                        else:
                            st.session_state['player_frame'] = pd.merge(st.session_state['player_frame'], set_frame, on='Player', how='outer')
                        player_count_var += 1
                    st.dataframe(st.session_state['player_frame'].
                        sort_values(by='Exposure Overall', ascending=False).
                        style.background_gradient(cmap='RdYlGn').
                        format(formatter='{:.2%}', subset=st.session_state['player_frame'].select_dtypes(include=['number']).columns),
                        hide_index=True)
                else:
                    overall_players = pd.Series(list(working_df[working_df['BaseName'].isin(entry_names)][player_columns].values.flatten())).value_counts()
                    top_1per_players = pd.Series(list(working_df[working_df['percentile_finish'] <= 0.01][player_columns].values.flatten())).value_counts()
                    top_5per_players = pd.Series(list(working_df[working_df['percentile_finish'] <= 0.05][player_columns].values.flatten())).value_counts()
                    top_10per_players = pd.Series(list(working_df[working_df['percentile_finish'] <= 0.10][player_columns].values.flatten())).value_counts()
                    top_20per_players = pd.Series(list(working_df[working_df['percentile_finish'] <= 0.20][player_columns].values.flatten())).value_counts()
                    contest_len = len(working_df)
                    len_1per = len(working_df[working_df['percentile_finish'] <= 0.01])
                    len_5per = len(working_df[working_df['percentile_finish'] <= 0.05])
                    len_10per = len(working_df[working_df['percentile_finish'] <= 0.10])
                    len_20per = len(working_df[working_df['percentile_finish'] <= 0.20])
                    each_set_name = ['Overall', ' Top 1%', ' Top 5%', 'Top 10%', 'Top 20%']
                    each_frame_set = [overall_players, top_1per_players, top_5per_players, top_10per_players, top_20per_players]
                    each_len_set = [contest_len, len_1per, len_5per, len_10per, len_20per]
                    player_count_var = 0
                    for each_set in each_frame_set:
                        set_frame = each_set.to_frame().reset_index().rename(columns={'index': 'Player', 'count': 'Count'})
                        set_frame['Percent'] = set_frame['Count'] / each_len_set[player_count_var]
                        set_frame = set_frame[['Player', 'Percent']]
                        set_frame = set_frame.rename(columns={'Percent': f'Exposure {each_set_name[player_count_var]}'})
                        if 'player_frame' not in st.session_state:
                            st.session_state['player_frame'] = set_frame
                        else:
                            st.session_state['player_frame'] = pd.merge(st.session_state['player_frame'], set_frame, on='Player', how='outer')
                        player_count_var += 1
                    st.dataframe(st.session_state['player_frame'].
                        sort_values(by='Exposure Overall', ascending=False).
                        style.background_gradient(cmap='RdYlGn').
                        format(formatter='{:.2%}', subset=st.session_state['player_frame'].select_dtypes(include=['number']).columns),
                        hide_index=True)
            with tab2:
                if entry_parse_var == 'All':
                    overall_stacks = pd.Series(list(working_df['stack'])).value_counts()
                    top_1per_stacks = pd.Series(list(working_df[working_df['percentile_finish'] <= 0.01]['stack'])).value_counts()
                    top_5per_stacks = pd.Series(list(working_df[working_df['percentile_finish'] <= 0.05]['stack'])).value_counts()
                    top_10per_stacks = pd.Series(list(working_df[working_df['percentile_finish'] <= 0.10]['stack'])).value_counts()
                    top_20per_stacks = pd.Series(list(working_df[working_df['percentile_finish'] <= 0.20]['stack'])).value_counts()
                    stacks_contest_len = len(working_df)
                    stacks_len_1per = len(working_df[working_df['percentile_finish'] <= 0.01])
                    stacks_len_5per = len(working_df[working_df['percentile_finish'] <= 0.05])
                    stacks_len_10per = len(working_df[working_df['percentile_finish'] <= 0.10])
                    stacks_len_20per = len(working_df[working_df['percentile_finish'] <= 0.20])
                    each_set_name = ['Overall', ' Top 1%', ' Top 5%', 'Top 10%', 'Top 20%']
                    each_stacks_set = [overall_stacks, top_1per_stacks, top_5per_stacks, top_10per_stacks, top_20per_stacks]
                    each_stacks_len_set = [stacks_contest_len, stacks_len_1per, stacks_len_5per, stacks_len_10per, stacks_len_20per]
                    stack_count_var = 0
                    for each_stack in each_stacks_set:
                        stack_frame = each_stack.to_frame().reset_index().rename(columns={'index': 'Stack', 'count': 'Count'})
                        stack_frame['Percent'] = stack_frame['Count'] / each_stacks_len_set[stack_count_var]
                        stack_frame = stack_frame[['Stack', 'Percent']]
                        stack_frame = stack_frame.rename(columns={'Percent': f'Exposure {each_set_name[stack_count_var]}'})
                        if 'stack_frame' not in st.session_state:
                            st.session_state['stack_frame'] = stack_frame
                        else:
                            st.session_state['stack_frame'] = pd.merge(st.session_state['stack_frame'], stack_frame, on='Stack', how='outer')
                        stack_count_var += 1
                    st.dataframe(st.session_state['stack_frame'].
                        sort_values(by='Exposure Overall', ascending=False).
                        style.background_gradient(cmap='RdYlGn').
                        format(formatter='{:.2%}', subset=st.session_state['stack_frame'].select_dtypes(include=['number']).columns),
                        hide_index=True)
                else:
                    overall_stacks = pd.Series(list(working_df[working_df['BaseName'].isin(entry_names)]['stack'])).value_counts()
                    top_1per_stacks = pd.Series(list(working_df[working_df['percentile_finish'] <= 0.01]['stack'])).value_counts()
                    top_5per_stacks = pd.Series(list(working_df[working_df['percentile_finish'] <= 0.05]['stack'])).value_counts()
                    top_10per_stacks = pd.Series(list(working_df[working_df['percentile_finish'] <= 0.10]['stack'])).value_counts()
                    top_20per_stacks = pd.Series(list(working_df[working_df['percentile_finish'] <= 0.20]['stack'])).value_counts()
                    stacks_contest_len = len(working_df)
                    stacks_len_1per = len(working_df[working_df['percentile_finish'] <= 0.01])
                    stacks_len_5per = len(working_df[working_df['percentile_finish'] <= 0.05])
                    stacks_len_10per = len(working_df[working_df['percentile_finish'] <= 0.10])
                    stacks_len_20per = len(working_df[working_df['percentile_finish'] <= 0.20])
                    each_set_name = ['Overall', ' Top 1%', ' Top 5%', 'Top 10%', 'Top 20%']
                    each_stacks_set = [overall_stacks, top_1per_stacks, top_5per_stacks, top_10per_stacks, top_20per_stacks]
                    each_stacks_len_set = [stacks_contest_len, stacks_len_1per, stacks_len_5per, stacks_len_10per, stacks_len_20per]
                    stack_count_var = 0
                    for each_stack in each_stacks_set:
                        stack_frame = each_stack.to_frame().reset_index().rename(columns={'index': 'Stack', 'count': 'Count'})
                        stack_frame['Percent'] = stack_frame['Count'] / each_stacks_len_set[stack_count_var]
                        stack_frame = stack_frame[['Stack', 'Percent']]
                        stack_frame = stack_frame.rename(columns={'Percent': f'Exposure {each_set_name[stack_count_var]}'})
                        if 'stack_frame' not in st.session_state:
                            st.session_state['stack_frame'] = stack_frame
                        else:
                            st.session_state['stack_frame'] = pd.merge(st.session_state['stack_frame'], stack_frame, on='Stack', how='outer')
                        stack_count_var += 1
                    st.dataframe(st.session_state['stack_frame'].
                        sort_values(by='Exposure Overall', ascending=False).
                        style.background_gradient(cmap='RdYlGn').
                        format(formatter='{:.2%}', subset=st.session_state['stack_frame'].select_dtypes(include=['number']).columns),
                        hide_index=True)
            with tab3:
                st.write('holding')