Refactor Streamlit app to integrate MongoDB connection and enhance data loading features. Added user interface elements for selecting sites, slates, and stack analysis options. Implemented position validation for player combinations and added CSV export functionality for stack options.

src/streamlit_app.py

@@ -1,40 +1,309 @@
-import altair as alt
 import numpy as np
 import pandas as pd
 import streamlit as st
+from itertools import combinations
+import pymongo
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+st.set_page_config(layout="wide")
+
+@st.cache_resource
+def init_conn():
+        
+        uri = st.secrets['mongo_uri']
+        client = pymongo.MongoClient(uri, retryWrites=True, serverSelectionTimeoutMS=500000)
+        db = client["MLB_Database"]
+
+        return db
+    
+db = init_conn()
+
+game_format = {'Win Percentage': '{:.2%}','First Inning Lead Percentage': '{:.2%}',
+              'Fifth Inning Lead Percentage': '{:.2%}', '8+ runs': '{:.2%}', 'DK LevX': '{:.2%}', 'FD LevX': '{:.2%}'}
+
+team_roo_format = {'Top Score%': '{:.2%}','0 Runs': '{:.2%}', '1 Run': '{:.2%}', '2 Runs': '{:.2%}', '3 Runs': '{:.2%}', '4 Runs': '{:.2%}',
+                   '5 Runs': '{:.2%}','6 Runs': '{:.2%}', '7 Runs': '{:.2%}', '8 Runs': '{:.2%}', '9 Runs': '{:.2%}', '10 Runs': '{:.2%}'}
+
+wrong_acro = ['WSH', 'AZ', 'CHW']
+right_acro = ['WAS', 'ARI', 'CWS']
+
+@st.cache_resource(ttl = 60)
+def init_stat_load():
+
+    collection = db["Player_Range_Of_Outcomes"] 
+    cursor = collection.find()
+
+    raw_display = pd.DataFrame(list(cursor))
+    raw_display = raw_display[['Player', 'Position', 'Team', 'Salary', 'Floor', 'Median', 'Ceiling', 'Own%', 'Site', 'Slate']]
+    raw_display = raw_display.rename(columns={'Own%': 'Own'})
+    initial_concat = raw_display.sort_values(by='Own', ascending=False)
+
+    return initial_concat
+
+@st.cache_data
+def convert_df_to_csv(df):
+    return df.to_csv().encode('utf-8')
+
+proj_raw = init_stat_load()
+
+col1, col2 = st.columns([1, 5])
+
+with col1:
+    with st.container():
+        if st.button("Load/Reset Data", key='reset1'):
+            st.cache_data.clear()
+            proj_raw = init_stat_load()
+            for key in st.session_state.keys():
+                del st.session_state[key]
+        site_var1 = st.radio("What site are you working with?", ('Draftkings', 'Fanduel'), key='site_var1')
+        slate_var1 = st.radio("What slate are you working with?", ('Main Slate', 'Secondary Slate'), key='slate_var1')
+        if site_var1 == 'Draftkings':
+            raw_baselines = proj_raw[proj_raw['Site'] == 'Draftkings']
+            if slate_var1 == 'Main Slate':
+                raw_baselines = raw_baselines[raw_baselines['Slate'] == 'main_slate']
+            elif slate_var1 == 'Secondary Slate':
+                raw_baselines = raw_baselines[raw_baselines['Slate'] == 'secondary_slate']
+            raw_baselines = raw_baselines.sort_values(by='Own', ascending=False)
+        elif site_var1 == 'Fanduel':
+            raw_baselines = proj_raw[proj_raw['Site'] == 'Fanduel']
+            if slate_var1 == 'Main Slate':
+                raw_baselines = raw_baselines[raw_baselines['Slate'] == 'main_slate']
+            elif slate_var1 == 'Secondary Slate':
+                raw_baselines = raw_baselines[raw_baselines['Slate'] == 'secondary_slate']
+            raw_baselines = raw_baselines.sort_values(by='Own', ascending=False)
+        split_var2 = st.radio("Would you like to run stack analysis for the full slate or individual teams?", ('Full Slate Run', 'Specific Teams'), key='split_var2')
+        if split_var2 == 'Specific Teams':
+            team_var2 = st.multiselect('Which teams would you like to include in the analysis?', options = raw_baselines['Team'].unique(), key='team_var2')
+        elif split_var2 == 'Full Slate Run':
+            team_var2 = raw_baselines.Team.unique().tolist()
+        pos_split2 = st.radio("Are you viewing all positions, specific groups, or specific positions?", ('All Positions', 'Specific Positions'), key='pos_split2')
+        if pos_split2 == 'Specific Positions':
+            pos_var2 = st.multiselect('What Positions would you like to view?', options = ['C', '1B', '2B', '3B', 'SS', 'OF'])
+        elif pos_split2 == 'All Positions':
+            pos_var2 = 'All'
+        if site_var1 == 'Draftkings':
+            max_sal2 = st.number_input('Max Salary', min_value = 5000, max_value = 50000, value = 35000, step = 100, key='max_sal2')
+        elif site_var1 == 'Fanduel':
+            max_sal2 = st.number_input('Max Salary', min_value = 5000, max_value = 35000, value = 25000, step = 100, key='max_sal2')
+        size_var2 = st.selectbox('What size of stacks are you analyzing?', options = ['3-man', '4-man', '5-man'])
+        if size_var2 == '3-man':
+            stack_size = 3
+        if size_var2 == '4-man':
+            stack_size = 4
+        if size_var2 == '5-man':
+            stack_size = 5
+
+        team_dict = dict(zip(raw_baselines.Player, raw_baselines.Team))
+        proj_dict = dict(zip(raw_baselines.Player, raw_baselines.Median))
+        own_dict = dict(zip(raw_baselines.Player, raw_baselines.Own))
+        cost_dict = dict(zip(raw_baselines.Player, raw_baselines.Salary))
+
+with col2:
+
+    if site_var1 == 'Draftkings':
+        position_limits = {
+            'C': 1,
+            '1B': 1,
+            '2B': 1,
+            '3B': 1,
+            'SS': 1,
+            'OF': 3,
+            # Add more as needed
+        }
+        max_salary = 50000
+        max_players = 10
+    else:
+        position_limits = {
+            'C_1B': 1,
+            '2B': 1,
+            '3B': 1,
+            'SS': 1,
+            'OF': 3,
+            'UTIL': 1,
+            # Add more as needed
+        }
+
+    stack_hold_container = st.empty()
+    comb_list = []
+    if pos_split2 == 'All Positions':
+        raw_baselines = raw_baselines
+    elif pos_split2 != 'All Positions':
+        raw_baselines = raw_baselines[raw_baselines['Position'].str.contains('|'.join(pos_var2))]
+
+    # Create a position dictionary mapping players to their eligible positions
+    pos_dict = dict(zip(raw_baselines.Player, raw_baselines.Position))
+
+    def is_valid_combination(combo):
+        # Count positions in this combination
+        position_counts = {pos: 0 for pos in position_limits.keys()}
+        
+        # For each player in the combination
+        for player in combo:
+            # Get their eligible positions
+            player_positions = pos_dict[player].split('/')
+            
+            # For each position they can play
+            for pos in player_positions:
+                # Handle special cases for FanDuel
+                if site_var1 == 'Fanduel':
+                    if pos in ['C', '1B']:
+                        position_counts['C_1B'] += 1
+                    elif pos == 'UTIL':
+                        # UTIL can be filled by any position
+                        for p in position_counts:
+                            position_counts[p] += 1
+                else:  # DraftKings
+                    if pos in position_counts:
+                        position_counts[pos] += 1
+        
+        # Check if any position exceeds its limit
+        for pos, limit in position_limits.items():
+            if position_counts[pos] > limit:
+                return False
+        
+        return True
+
+    # Modify the combination generation code
+    comb_list = []
+    for cur_team in team_var2:
+        working_baselines = raw_baselines
+        working_baselines = working_baselines[working_baselines['Team'] == cur_team]
+        working_baselines = working_baselines[working_baselines['Position'] != 'SP']
+        working_baselines = working_baselines[working_baselines['Position'] != 'P']
+        order_list = working_baselines['Player']
+
+        comb = combinations(order_list, stack_size)
+
+        # Only add combinations that satisfy position limits
+        for i in list(comb):
+            if is_valid_combination(i):
+                comb_list.append(i)
+
+    comb_DF = pd.DataFrame(comb_list)
+
+    if stack_size == 3:
+        comb_DF['Team'] = comb_DF[0].map(team_dict)
+
+        comb_DF['Proj'] = sum([comb_DF[0].map(proj_dict),
+                comb_DF[1].map(proj_dict),
+                comb_DF[2].map(proj_dict)])
+
+        comb_DF['Salary'] = sum([comb_DF[0].map(cost_dict),
+                comb_DF[1].map(cost_dict),
+                comb_DF[2].map(cost_dict)])
+
+        comb_DF['Own%'] = sum([comb_DF[0].map(own_dict),
+                comb_DF[1].map(own_dict),
+                comb_DF[2].map(own_dict)])
+    elif stack_size == 4:
+        comb_DF['Team'] = comb_DF[0].map(team_dict)
+
+        comb_DF['Proj'] = sum([comb_DF[0].map(proj_dict),
+                comb_DF[1].map(proj_dict),
+                comb_DF[2].map(proj_dict),
+                comb_DF[3].map(proj_dict)])
+
+        comb_DF['Salary'] = sum([comb_DF[0].map(cost_dict),
+                comb_DF[1].map(cost_dict),
+                comb_DF[2].map(cost_dict),
+                comb_DF[3].map(cost_dict)])
+
+        comb_DF['Own%'] = sum([comb_DF[0].map(own_dict),
+                comb_DF[1].map(own_dict),
+                comb_DF[2].map(own_dict),
+                comb_DF[3].map(own_dict)])
+    elif stack_size == 5:
+        comb_DF['Team'] = comb_DF[0].map(team_dict)
+
+        comb_DF['Proj'] = sum([comb_DF[0].map(proj_dict),
+                comb_DF[1].map(proj_dict),
+                comb_DF[2].map(proj_dict),
+                comb_DF[3].map(proj_dict),
+                comb_DF[4].map(proj_dict)])
+
+        comb_DF['Salary'] = sum([comb_DF[0].map(cost_dict),
+                comb_DF[1].map(cost_dict),
+                comb_DF[2].map(cost_dict),
+                comb_DF[3].map(cost_dict),
+                comb_DF[4].map(cost_dict)])
+
+        comb_DF['Own%'] = sum([comb_DF[0].map(own_dict),
+                comb_DF[1].map(own_dict),
+                comb_DF[2].map(own_dict),
+                comb_DF[3].map(own_dict),
+                comb_DF[4].map(own_dict)])
+
+    comb_DF = comb_DF.sort_values(by='Proj', ascending=False)
+    comb_DF = comb_DF.loc[comb_DF['Salary'] <= max_sal2]
+
+    cut_var = 0
+
+    if stack_size == 3:
+        while cut_var <= int(len(comb_DF)):
+            try:
+                if int(cut_var) == 0:
+                    cur_proj = float(comb_DF.iat[cut_var,4])
+                    cur_own = float(comb_DF.iat[cut_var,6])
+                elif int(cut_var) >= 1:
+                    check_own = float(comb_DF.iat[cut_var,6])
+                    if check_own > cur_own:
+                        comb_DF = comb_DF.drop([cut_var])
+                        cur_own = cur_own
+                        cut_var = cut_var - 1
+                        comb_DF = comb_DF.reset_index()
+                        comb_DF = comb_DF.drop(['index'], axis=1)
+                    elif check_own <= cur_own:
+                        cur_own = float(comb_DF.iat[cut_var,6])
+                        cut_var = cut_var
+                cut_var += 1
+            except:
+                cut_var += 1
+    elif stack_size == 4:
+        while cut_var <= int(len(comb_DF)):
+            try:
+                if int(cut_var) == 0:
+                    cur_proj = float(comb_DF.iat[cut_var,5])
+                    cur_own = float(comb_DF.iat[cut_var,7])
+                elif int(cut_var) >= 1:
+                    check_own = float(comb_DF.iat[cut_var,7])
+                    if check_own > cur_own:
+                        comb_DF = comb_DF.drop([cut_var])
+                        cur_own = cur_own
+                        cut_var = cut_var - 1
+                        comb_DF = comb_DF.reset_index()
+                        comb_DF = comb_DF.drop(['index'], axis=1)
+                    elif check_own <= cur_own:
+                        cur_own = float(comb_DF.iat[cut_var,7])
+                        cut_var = cut_var
+                cut_var += 1
+            except:
+                cut_var += 1
+    elif stack_size == 5:
+        while cut_var <= int(len(comb_DF)):
+            try:
+                if int(cut_var) == 0:
+                    cur_proj = float(comb_DF.iat[cut_var,6])
+                    cur_own = float(comb_DF.iat[cut_var,8])
+                elif int(cut_var) >= 1:
+                    check_own = float(comb_DF.iat[cut_var,8])
+                    if check_own > cur_own:
+                        comb_DF = comb_DF.drop([cut_var])
+                        cur_own = cur_own
+                        cut_var = cut_var - 1
+                        comb_DF = comb_DF.reset_index()
+                        comb_DF = comb_DF.drop(['index'], axis=1)
+                    elif check_own <= cur_own:
+                        cur_own = float(comb_DF.iat[cut_var,8])
+                        cut_var = cut_var
+                cut_var += 1
+            except:
+                cut_var += 1
+
+    with stack_hold_container:
+        stack_hold_container = st.empty()
+        st.dataframe(comb_DF.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(precision=2), use_container_width = True)
+    st.download_button(
+            label="Export Tables",
+            data=convert_df_to_csv(comb_DF),
+            file_name='MLB_Stack_Options_export.csv',
+            mime='text/csv',
+    )