Update 'Stack Finder' tab to 'Info and Filters', add 'Run Stack Analysis' button, and streamline combination generation logic for player selection in Streamlit app

src/streamlit_app.py

@@ -145,7 +145,7 @@ selected_tab = st.segmented_control(
 )
 
 if selected_tab == 'Stack Finder':
-    with st.expander("Stack Finder"):
+    with st.expander("Info and Filters"):
         app_info_column, slate_choice_column, filtering_column, stack_info_column = st.columns(4)
         with app_info_column:
             if st.button("Load/Reset Data", key='reset1'):
@@ -208,232 +208,233 @@ if selected_tab == 'Stack Finder':
             own_dict = dict(zip(raw_baselines.Player, raw_baselines.Own))
             cost_dict = dict(zip(raw_baselines.Player, raw_baselines.Salary))
             qb_dict = dict(zip(qb_lookup.Team, qb_lookup.Player))
+    if st.button("Run Stack Analysis", key='run_stack_analysis'):
+        if site_var == 'Draftkings':
+            position_limits = {
+                'QB': 1,
+                'RB': 2,
+                'WR': 3,
+                'TE': 1,
+                'UTIL': 1,
+                'DST': 1,
+                # Add more as needed
+            }
+            max_salary = max_sal2
+            max_players = 9
+        else:
+            position_limits = {
+                'QB': 1,
+                'RB': 2,
+                'WR': 3,
+                'TE': 1,
+                'UTIL': 1,
+                'DST': 1,
+                # Add more as needed
+            }
+            max_salary = max_sal2
+            max_players = 9
 
-    if site_var == 'Draftkings':
-        position_limits = {
-            'QB': 1,
-            'RB': 2,
-            'WR': 3,
-            'TE': 1,
-            'UTIL': 1,
-            'DST': 1,
-            # Add more as needed
-        }
-        max_salary = max_sal2
-        max_players = 9
-    else:
-        position_limits = {
-            'QB': 1,
-            'RB': 2,
-            'WR': 3,
-            'TE': 1,
-            'UTIL': 1,
-            'DST': 1,
-            # Add more as needed
-        }
-        max_salary = max_sal2
-        max_players = 9
-
-    stack_hold_container = st.empty()
-    comb_list = []
-    raw_baselines = raw_baselines[raw_baselines['Position'].str.contains('|'.join(pos_var2 + ['QB']))]
-
-    # 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('/')
+        stack_hold_container = st.empty()
+        comb_list = []
+        raw_baselines = raw_baselines[raw_baselines['Position'].str.contains('|'.join(pos_var2 + ['QB']))]
+
+        # 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 position they can play
-            for pos in player_positions:
-                if pos == 'UTIL':
-                    # UTIL can be filled by any position
-                    for p in position_counts:
-                        position_counts[p] += 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'] != 'DST']
-        working_baselines = working_baselines[working_baselines['Position'] != 'K']
-        qb_var = qb_dict[cur_team]
-        order_list = working_baselines['Player']
-
-        comb = combinations(order_list, stack_size)
-
-        for i in list(comb):
-            if qb_var in i:
-                comb_list.append(i)
-
-        # 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 == 2:
-                while cut_var <= int(len(comb_DF)):
-                    try:
-                        if int(cut_var) == 0:
-                            cur_proj = float(comb_DF.iat[cut_var, 3])
-                            cur_own = float(comb_DF.iat[cut_var, 5])
-                        elif int(cut_var) >= 1:
-                            check_own = float(comb_DF.iat[cut_var, 5])
-                            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:
+            # 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:
+                    if pos == 'UTIL':
+                        # UTIL can be filled by any position
+                        for p in position_counts:
+                            position_counts[p] += 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'] != 'DST']
+            working_baselines = working_baselines[working_baselines['Position'] != 'K']
+            qb_var = qb_dict[cur_team]
+            order_list = working_baselines['Player']
+
+            comb = combinations(order_list, stack_size)
+
+            for i in list(comb):
+                if qb_var in i:
+                    comb_list.append(i)
+
+            # 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 == 2:
+                    while cut_var <= int(len(comb_DF)):
+                        try:
+                            if int(cut_var) == 0:
+                                cur_proj = float(comb_DF.iat[cut_var, 3])
                                 cur_own = float(comb_DF.iat[cut_var, 5])
-                                cut_var = cut_var
-                        cut_var += 1
-                    except:
-                        cut_var += 1
-    elif 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:
+                            elif int(cut_var) >= 1:
+                                check_own = float(comb_DF.iat[cut_var, 5])
+                                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, 5])
+                                    cut_var = cut_var
+                            cut_var += 1
+                        except:
+                            cut_var += 1
+        elif 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])
-                        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:
+                    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])
-                        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:
+                    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])
-                        cut_var = cut_var
-                cut_var += 1
-            except:
-                cut_var += 1
-    st.session_state['display_frame'] = comb_DF
-    with stack_hold_container:
-        stack_hold_container = st.empty()
+                    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
+        st.session_state['display_frame'] = comb_DF
+    if 'display_frame' in st.session_state:
         st.dataframe(st.session_state['display_frame'].style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(precision=2), hide_index=True, use_container_width = True)
-    st.download_button(
-            label="Export Tables",
-            data=convert_df_to_csv(st.session_state['display_frame']),
-            file_name='NFL_Stack_Options_export.csv',
-            mime='text/csv',
-    )
+        st.download_button(
+                label="Export Tables",
+                data=convert_df_to_csv(st.session_state['display_frame']),
+                file_name='NFL_Stack_Options_export.csv',
+                mime='text/csv',
+        )
+    else:
+        st.info("When you run the stack analysis, the results will be displayed here. Open up the 'Info and Filters' tab to check the settings.")
 
 if selected_tab == 'User Upload':
     st.info("The Projections file can have any columns in any order, but must contain columns explicitly named: 'Player', 'Salary', 'Position', 'Team', 'Opp', 'Median', and 'Own'.")