Enhance baseline initialization by adding 'Opp', 'Team_Total', and 'Opp_Total' columns for both hitters and pitchers. Update player display logic to include new metrics and improve data handling for lineup building. Introduce a new 'Handbuilder' tab in the UI for streamlined player selection and lineup management, incorporating position limits and quick fill options.

app.py

@@ -3,6 +3,7 @@ import numpy as np
 import pandas as pd
 import gspread
 import pymongo
+import re
 
 st.set_page_config(layout="wide")
 
@@ -27,7 +28,7 @@ fd_columns = ['P', 'C_1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'UTIL', 'salar
 dk_sd_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']
 fd_sd_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']
 
-@st.cache_resource(ttl = 60)
+@st.cache_resource(ttl = 61)
 def init_baselines():
 
     collection = db["Hitter_Info"] 
@@ -53,9 +54,27 @@ def init_baselines():
     
     hold_frame['Order'] = np.where(hold_frame['pos_group'] == 'Hitters', hold_frame['Player'].map(RHP_Info.set_index('Player')['Order']), 0)
     hold_frame['Hand'] = np.where(hold_frame['pos_group'] == 'Hitters', hold_frame['Player'].map(RHP_Info.set_index('Player')['bats']), hold_frame['Player'].map(RHH_Info.set_index('Player')['Hand']))
-
-    roo_data.insert(3, 'Hand', hold_frame['Hand'])
-    roo_data.insert(4, 'Order', hold_frame['Order'].astype(int))
+    try:
+        hold_frame['Opp'] = hold_frame['Team'].map(RHH_Info.drop_duplicates(subset='Team').set_index('Team')['Opp'])
+    except:
+        hold_frame['Opp'] = np.nan
+    try:
+        hold_frame['Team_Total'] = hold_frame['Team'].map(RHH_Info.drop_duplicates(subset='Team').set_index('Opp')['Opp_TT'])
+    except:
+        hold_frame['Team_Total'] = np.nan
+    try:
+        hold_frame['Opp_Total'] = hold_frame['Team'].map(RHH_Info.drop_duplicates(subset='Team').set_index('Team')['Opp_TT'])
+    except:
+        hold_frame['Opp_Total'] = np.nan
+    
+    roo_data.insert(3, 'Opp', hold_frame['Opp'])
+    roo_data.insert(4, 'Hand', hold_frame['Hand'])
+    try:
+        roo_data.insert(5, 'Order', hold_frame['Order'].astype(int))
+    except:
+        roo_data.insert(5, 'Order', hold_frame['Order'])
+    roo_data.insert(6, 'Team_Total', hold_frame['Team_Total'])
+    roo_data.insert(7, 'Opp_Total', hold_frame['Opp_Total'])
     
     dk_roo = roo_data[roo_data['Site'] == 'Draftkings']
     dk_id_map = dict(zip(dk_roo['Player'], dk_roo['player_ID']))
@@ -68,7 +87,31 @@ def init_baselines():
 
     sd_roo_data = player_frame.drop(columns=['_id'])
     sd_roo_data['Salary'] = sd_roo_data['Salary'].astype(int)
-    sd_roo_data = sd_roo_data.rename(columns={'Own': 'Own%'})
+    sd_roo_data = sd_roo_data.rename(columns={'Own': 'Own%', 'Small_Own': 'Small Field Own%', 'Large_Own': 'Large Field Own%', 'Cash_Own': 'Cash Own%'})
+    sd_hold_frame = sd_roo_data.copy()
+    
+    sd_hold_frame['Order'] = np.where(sd_hold_frame['Position'] != 'SP', sd_hold_frame['Player'].map(RHP_Info.set_index('Player')['Order']), 0)
+    sd_hold_frame['Hand'] = np.where(sd_hold_frame['Position'] != 'SP', sd_hold_frame['Player'].map(RHP_Info.set_index('Player')['bats']), sd_hold_frame['Player'].map(RHH_Info.set_index('Player')['Hand']))
+    try:
+        sd_hold_frame['Opp'] = sd_hold_frame['Team'].map(RHH_Info.drop_duplicates(subset='Team').set_index('Team')['Opp'])
+    except:
+        sd_hold_frame['Opp'] = np.nan
+    try:
+        sd_hold_frame['Team_Total'] = sd_hold_frame['Team'].map(RHH_Info.drop_duplicates(subset='Team').set_index('Opp')['Opp_TT'])
+    except:
+        sd_hold_frame['Team_Total'] = np.nan
+    try:
+        sd_hold_frame['Opp_Total'] = sd_hold_frame['Team'].map(RHH_Info.drop_duplicates(subset='Team').set_index('Team')['Opp_TT'])
+    except:
+        sd_hold_frame['Opp_Total'] = np.nan
+    sd_roo_data.insert(3, 'Opp', sd_hold_frame['Opp'])
+    sd_roo_data.insert(4, 'Hand', sd_hold_frame['Hand'])
+    try:
+        sd_roo_data.insert(5, 'Order', sd_hold_frame['Order'].astype(int))
+    except:
+        sd_roo_data.insert(5, 'Order', sd_hold_frame['Order'])
+    sd_roo_data.insert(6, 'Team_Total', sd_hold_frame['Team_Total'])
+    sd_roo_data.insert(7, 'Opp_Total', sd_hold_frame['Opp_Total'])
 
     collection = db["Scoring_Percentages"] 
     cursor = collection.find()
@@ -258,7 +301,7 @@ with col2:
             site_var = st.selectbox("What site do you want to view?", ('Draftkings', 'Fanduel'), key='site_var')
         
 
-tab1, tab2, tab3 = st.tabs(["Scoring Percentages", "Player ROO", "Optimals"])
+tab1, tab2, tab3, tab4 = st.tabs(["Scoring Percentages", "Player ROO", "Optimals", "Handbuilder"])
 
 roo_data, sd_roo_data, scoring_percentages, dk_roo, fd_roo, dk_id_map, fd_id_map = init_baselines()
 hold_display = roo_data
@@ -448,7 +491,7 @@ with tab2:
             player_roo_disp = player_roo_disp.set_index('Player', drop=True)
             st.dataframe(player_roo_disp.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').background_gradient(cmap='RdYlGn_r', subset=['Order', 'Salary', 'Own%', 'Small Field Own%', 'Large Field Own%', 'Cash Own%']).format(player_roo_format, precision=2), height=750, use_container_width = True)
         except:
-            player_roo_disp = player_roo_disp.set_index('Player', drop=True)
+            # player_roo_disp = player_roo_disp.set_index('Player', drop=True)
             st.dataframe(player_roo_disp.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').background_gradient(cmap='RdYlGn_r', subset=['Order', 'Salary', 'Own%', 'Small Field Own%', 'Large Field Own%', 'Cash Own%']).format(player_roo_format, precision=2), height=750, use_container_width = True)
 
 with tab3:
@@ -763,4 +806,371 @@ with tab3:
                     data=convert_df_to_csv(summary_df),
                     file_name='MLB_seed_frame_frequency.csv',
                     mime='text/csv',
-                )
+                )
+
+with tab4:
+    col1, col2 = st.columns(2)
+    with col1:
+        st.header("Handbuilder")
+    with col2:
+        slate_var3 = st.selectbox("Slate Selection", options=['Main', 'Secondary', 'Auxiliary'])
+        if site_var == 'Draftkings':
+            if slate_var3 == 'Main':
+                handbuild_roo = dk_roo[dk_roo['Slate'] == 'main_slate']
+            elif slate_var3 == 'Secondary':
+                handbuild_roo = dk_roo[dk_roo['Slate'] == 'secondary_slate']
+            elif slate_var3 == 'Auxiliary':
+                handbuild_roo = dk_roo[dk_roo['Slate'] == 'turbo_slate']
+        else:
+            if slate_var3 == 'Main':
+                handbuild_roo = fd_roo[fd_roo['Slate'] == 'main_slate']
+            elif slate_var3 == 'Secondary':
+                handbuild_roo = fd_roo[fd_roo['Slate'] == 'secondary_slate']
+            elif slate_var3 == 'Auxiliary':
+                handbuild_roo = fd_roo[fd_roo['Slate'] == 'turbo_slate']
+
+    # --- POSITION LIMITS ---
+    if site_var == 'Draftkings':
+        position_limits = {
+            'SP': 2,
+            '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 = {
+            'P': 1,
+            'C_1B': 1,
+            '2B': 1,
+            '3B': 1,
+            'SS': 1,
+            'OF': 3,
+            'UTIL': 1,
+            # Add more as needed
+        }
+        max_salary = 35000
+        max_players = 9
+
+    # --- LINEUP STATE ---
+    if 'handbuilder_lineup' not in st.session_state:
+        st.session_state['handbuilder_lineup'] = pd.DataFrame(columns=['Player', 'Order', 'Position', 'Team', 'Team_Total', 'Opp_Total', 'Salary', 'Median', '2x%', 'Own%'])
+    if 'handbuilder_select_key' not in st.session_state:
+        st.session_state['handbuilder_select_key'] = 0
+
+    # Count positions in the current lineup
+    lineup = st.session_state['handbuilder_lineup']
+    slot_counts = lineup['Slot'].value_counts() if not lineup.empty else {}
+
+    # --- PLAYER FILTERS ---
+    with st.expander("Player Filters"):
+        col1, col2 = st.columns(2)
+        with col1:
+            pos_select3 = st.multiselect("Select your position(s)", options=['P', 'C', '1B', '2B', '3B', 'SS', 'OF'], key='pos_select3')
+        with col2:
+            salary_var = st.number_input("Salary Max", min_value = 0, max_value = 20000, value = 20000, step = 100)
+
+    # --- TEAM FILTER UI ---
+    with st.expander("Team Filters"):
+        all_teams = sorted(handbuild_roo['Team'].unique())
+        st.markdown("**Toggle teams to include:**")
+        team_cols = st.columns(len(all_teams) // 2 + 1)
+    
+    selected_teams = []
+    for idx, team in enumerate(all_teams):
+        col = team_cols[idx % len(team_cols)]
+        if f"handbuilder_team_{team}" not in st.session_state:
+            st.session_state[f"handbuilder_team_{team}"] = False
+        checked = col.toggle(team, value=st.session_state[f"handbuilder_team_{team}"], key=f"handbuilder_team_{team}")
+        if checked:
+            selected_teams.append(team)
+
+    # If no teams selected, show all teams
+    if selected_teams:
+        player_select_df = handbuild_roo[
+            handbuild_roo['Team'].isin(selected_teams)
+        ][['Player', 'Position', 'Team', 'Team_Total', 'Opp_Total', 'Salary', 'Median', '2x%', 'Order', 'Hand', 'Own%']].drop_duplicates(subset=['Player', 'Team']).sort_values(by='Order', ascending=True).copy()
+    else:
+        player_select_df = handbuild_roo[['Player', 'Position', 'Team', 'Team_Total', 'Opp_Total', 'Salary', 'Median', '2x%', 'Order', 'Hand', 'Own%']].drop_duplicates(subset=['Player', 'Team']).copy()
+    
+    # If no teams selected, show all teams
+    if pos_select3:
+        position_mask_2 = handbuild_roo['Position'].apply(lambda x: any(pos in x for pos in pos_select3))
+        player_select_df = player_select_df[position_mask_2][['Player', 'Position', 'Team', 'Team_Total', 'Opp_Total', 'Salary', 'Median', '2x%', 'Order', 'Hand', 'Own%']].drop_duplicates(subset=['Player', 'Team']).sort_values(by='Order', ascending=True).copy()
+    else:
+        player_select_df = player_select_df[['Player', 'Position', 'Team', 'Team_Total', 'Opp_Total', 'Salary', 'Median', '2x%', 'Order', 'Hand', 'Own%']].drop_duplicates(subset=['Player', 'Team']).copy()
+    
+    player_select_df = player_select_df[player_select_df['Salary'] <= salary_var]
+
+    
+    with st.expander("Quick Fill Options"):
+        auto_team_var = st.selectbox("Auto Fill Team", options=all_teams)
+        auto_size_var = st.selectbox("Auto Fill Size", options=[3, 4, 5])
+        auto_range_var = st.selectbox("Auto Fill Order", options=['Top (1-5)', 'Mid (4-8)', 'Wrap (7-2)'])
+        # --- QUICK FILL LOGIC ---
+        if st.button("Quick Fill", key="quick_fill"):
+            # 1. Get all eligible players from the selected team, not already in the lineup
+            current_players = set(st.session_state['handbuilder_lineup']['Player'])
+            team_players = player_select_df[
+                (player_select_df['Team'] == auto_team_var) &
+                (~player_select_df['Player'].isin(current_players))
+            ].copy()
+
+            # 2. Sort by Order
+            team_players = team_players.sort_values(by='Order')
+
+            # 3. Select the order range
+            if auto_range_var == 'Top (1-5)':
+                selected_players = team_players[team_players['Order'] > 0].head(auto_size_var)
+            elif auto_range_var == 'Mid (4-8)':
+                selected_players = team_players[team_players['Order'] > 0].iloc[3:3 + auto_size_var - 1]
+            elif auto_range_var == 'Wrap (7-2)':
+                first_three = team_players[team_players['Order'] > 0].head(2)
+                last_two = team_players[team_players['Order'] > 0].tail(3)
+                selected_players = pd.concat([first_three, last_two])
+            else:
+                selected_players = team_players[team_players['Order'] > 0].head(auto_size_var)
+
+            # 4. Add each player to the lineup, filling the first available eligible slot
+            for _, player_row in selected_players.iterrows():
+                eligible_positions = re.split(r'[/, ]+', player_row['Position'])
+                slot_to_fill = None
+
+                if site_var == 'Fanduel':
+                    # Logic for handling Fanduel Positions (with C/1B and UTIL)
+                    for slot in ['P', 'C_1B', '2B', '3B', 'SS', 'OF', 'UTIL']:
+                        if slot_counts.get(slot, 0) < position_limits.get(slot, 0):
+                            if slot == 'C_1B':
+                                if any(pos in eligible_positions for pos in ['C', '1B']):
+                                    slot_to_fill = slot
+                                    break
+                            elif slot == 'UTIL':
+                                if 'P' not in eligible_positions:
+                                    slot_to_fill = slot
+                                    break
+                            elif slot in eligible_positions:
+                                slot_to_fill = slot
+                                break
+                else:
+                    # General logic for handling Draftkings Positions
+                    for pos in eligible_positions:
+                        if slot_counts.get(pos, 0) < position_limits.get(pos, 0):
+                            slot_to_fill = pos
+                            break
+
+                if slot_to_fill is not None:
+                    # Avoid duplicates
+                    if player_row['Player'] not in st.session_state['handbuilder_lineup']['Player'].values:
+                        add_row = player_row.copy()
+                        add_row['Slot'] = slot_to_fill
+                        st.session_state['handbuilder_lineup'] = pd.concat(
+                            [st.session_state['handbuilder_lineup'], pd.DataFrame([add_row[[
+                                'Player', 'Order', 'Position', 'Team', 'Team_Total', 'Opp_Total', 'Salary', 'Median', '2x%', 'Own%', 'Slot'
+                            ]]])],
+                            ignore_index=True
+                        )
+                        # Update slot_counts for next player
+                        slot_counts[slot_to_fill] = slot_counts.get(slot_to_fill, 0) + 1
+            st.rerun()
+
+    # --- FILTER OUT PLAYERS WHOSE ALL ELIGIBLE POSITIONS ARE FILLED ---
+    def is_player_eligible(row):
+        eligible_positions = re.split(r'[/, ]+', row['Position'])
+        # Player is eligible if at least one of their positions is not at max
+        for pos in eligible_positions:
+            if slot_counts.get(pos, 0) < position_limits.get(pos, 0):
+                return True
+        return False
+
+    # player_select_df = player_select_df[player_select_df.apply(is_player_eligible, axis=1)]
+
+    col1, col2 = st.columns([1, 2])
+    with col2:
+        st.subheader("Player Select")
+        event = st.dataframe(
+            player_select_df.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').background_gradient(cmap='RdYlGn_r', subset=['Order', 'Salary', 'Own%']).format(precision=2),
+            on_select="rerun",
+            selection_mode=["single-row"],
+            key=f"handbuilder_select_{st.session_state['handbuilder_select_key']}",
+            height=500,
+            hide_index=True
+        )
+        # If a row is selected, add that player to the lineup and reset selection
+        if event and "rows" in event.selection and len(event.selection["rows"]) > 0:
+            idx = event.selection["rows"][0]
+            player_row = player_select_df.iloc[[idx]]
+            eligible_positions = re.split(r'[/, ]+', player_row['Position'].iloc[0])
+            # Find the first eligible slot that is not full
+            slot_to_fill = None
+
+            if site_var == 'Fanduel':
+                # Logic for handling Fanduel Positions (with C/1B and UTIL)
+                for slot in ['P', 'C_1B', '2B', '3B', 'SS', 'OF', 'UTIL']:
+                    if slot_counts.get(slot, 0) < position_limits.get(slot, 0):
+                        if slot == 'C_1B':
+                            if any(pos in eligible_positions for pos in ['C', '1B']):
+                                slot_to_fill = slot
+                                break
+                        elif slot == 'UTIL':
+                            if 'P' not in eligible_positions:
+                                slot_to_fill = slot
+                                break
+                        elif slot in eligible_positions:
+                            slot_to_fill = slot
+                            break
+            else:
+                # General logic for handling Draftkings Positions
+                for pos in eligible_positions:
+                    if slot_counts.get(pos, 0) < position_limits.get(pos, 0):
+                        slot_to_fill = pos
+                        break
+
+            if slot_to_fill is not None:
+                # Avoid duplicates
+                if not player_row['Player'].iloc[0] in st.session_state['handbuilder_lineup']['Player'].values:
+                    # Add the slot info
+                    player_row = player_row.assign(Slot=slot_to_fill)
+                    st.session_state['handbuilder_lineup'] = pd.concat(
+                        [st.session_state['handbuilder_lineup'], player_row[['Player', 'Order', 'Position', 'Team', 'Team_Total', 'Opp_Total', 'Salary', 'Median', '2x%', 'Own%', 'Slot']]],
+                        ignore_index=True
+                    )
+                st.session_state['handbuilder_select_key'] += 1
+                st.rerun()
+
+
+    with col1:
+        st.subheader("Lineup Build")
+
+        # --- EXPLICIT LINEUP ORDER ---
+        if site_var == 'Draftkings':
+            lineup_slots = ['SP', 'SP', 'C', '1B', '2B', '3B', 'SS', 'OF', 'OF', 'OF']
+        else:
+            lineup_slots = ['P', 'C_1B', '2B', '3B', 'SS', 'OF', 'OF', 'OF', 'UTIL']
+        display_columns = ['Slot', 'Player', 'Order', 'Team', 'Salary', 'Median', 'Own%']
+
+        filled_lineup = st.session_state['handbuilder_lineup']
+        display_rows = []
+        used_indices = set()
+        if not filled_lineup.empty:
+            for slot in lineup_slots:
+                match = filled_lineup[(filled_lineup['Slot'] == slot) & (~filled_lineup.index.isin(used_indices))]
+                if not match.empty:
+                    row = match.iloc[0]
+                    used_indices.add(match.index[0])
+                    display_rows.append({
+                        'Slot': slot,
+                        'Player': row['Player'],
+                        'Order': row['Order'],
+                        'Position': row['Position'],
+                        'Team': row['Team'],
+                        'Salary': row['Salary'],
+                        'Median': row['Median'],
+                        '2x%': row['2x%'],
+                        'Own%': row['Own%']
+                    })
+                else:
+                    display_rows.append({
+                        'Slot': slot,
+                        'Player': '',
+                        'Order': np.nan,
+                        'Position': '',
+                        'Team': '',
+                        'Salary': np.nan,
+                        'Median': np.nan,
+                        '2x%': np.nan,
+                        'Own%': np.nan
+                    })
+
+        lineup_display_df = pd.DataFrame(display_rows, columns=display_columns)
+
+        # Show the lineup table with single-row selection for removal
+        event_remove = st.dataframe(
+            lineup_display_df.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn', subset=['Median']).background_gradient(cmap='RdYlGn_r', subset=['Order', 'Salary', 'Own%']).format(precision=2),
+            on_select="rerun",
+            selection_mode=["single-row"],
+            key="lineup_remove",
+            height=445,
+            hide_index=True
+        )
+
+        # If a row is selected and not blank, remove that player from the lineup
+        if event_remove and "rows" in event_remove.selection and len(event_remove.selection["rows"]) > 0:
+            idx = event_remove.selection["rows"][0]
+            player_to_remove = lineup_display_df.iloc[idx]['Player']
+            slot_to_remove = lineup_display_df.iloc[idx]['Slot']
+            if player_to_remove:  # Only remove if not blank
+                st.session_state['handbuilder_lineup'] = filled_lineup[
+                    ~((filled_lineup['Player'] == player_to_remove) & (filled_lineup['Slot'] == slot_to_remove))
+                ]
+                st.rerun()
+
+        # --- SUMMARY ROW ---
+        if not filled_lineup.empty:
+            total_salary = filled_lineup['Salary'].sum()
+            total_median = filled_lineup['Median'].sum()
+            avg_2x = filled_lineup['2x%'].mean()
+            total_own = filled_lineup['Own%'].sum()
+            most_common_team = filled_lineup['Team'].mode()[0] if not filled_lineup['Team'].mode().empty else ""
+
+            summary_row = pd.DataFrame({
+                'Slot': [''],
+                'Player': ['TOTAL'],
+                'Order': [''],
+                'Position': [''],
+                'Team': [most_common_team],
+                'Salary': [total_salary],
+                'Median': [total_median],
+                '2x%': [avg_2x],
+                'Own%': [total_own]
+            })
+            summary_row = summary_row[['Salary', 'Median', 'Own%']].head(max_players)
+            
+            col1, col3 = st.columns([2, 3])
+
+            with col1:
+                if (max_players - len(filled_lineup)) > 0:
+                    st.markdown(f"""
+                            <div style='text-align: left; vertical-align: top; margin-top: 0; padding-top: 0;''>
+                                <b>💰 Per Player:</b> ${round((max_salary - total_salary) / (max_players - len(filled_lineup)), 0)} &nbsp;
+                            </div>
+                            """,
+                            unsafe_allow_html=True)
+                else:
+                    st.markdown(f"""
+                            <div style='text-align: left; vertical-align: top; margin-top: 0; padding-top: 0;''>
+                                <b>💰 Leftover:</b> ${round(max_salary - total_salary, 0)} &nbsp;
+                            </div>
+                            """,
+                            unsafe_allow_html=True)
+
+            with col3:
+                if total_salary <= max_salary:
+                    st.markdown(
+                        f"""
+                        <div style='text-align: right; vertical-align: top; margin-top: 0; padding-top: 0;''>
+                            <b>💰 Salary:</b> ${round(total_salary, 0)} &nbsp;
+                            <b>🔥 Median:</b> {round(total_median, 2)} &nbsp;
+                        </div>
+                        """,
+                        unsafe_allow_html=True
+                    )
+                else:
+                    st.markdown(
+                        f"""
+                        <div style='text-align: right; vertical-align: top; margin-top: 0; padding-top: 0;''>
+                            <b>❌ Salary:</b> ${round(total_salary, 0)} &nbsp;
+                            <b>🔥 Median:</b> {round(total_median, 2)} &nbsp;
+                        </div>
+                        """,
+                        unsafe_allow_html=True
+                    )
+
+    # Optionally, add a button to clear the lineup
+    if st.button("Clear Lineup", key='clear_lineup'):
+        st.session_state['handbuilder_lineup'] = pd.DataFrame(columns=['Player', 'Position', 'Team', 'Team_Total', 'Opp_Total', 'Salary', 'Median', '2x%', 'Own%', 'Slot', 'Order'])
+        st.rerun()