Add Conditionals Manager for player filtering in 'Manage Portfolio', allowing users to keep or remove lineups based on selected player conditions, enhancing lineup management capabilities.

app.py

@@ -1347,61 +1347,6 @@ if selected_tab == 'Manage Portfolio':
                             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('Conditional Manager'):
-            #     # a set of functions for removing lineups that contain a conditional between players and stacks
-            #     with st.form(key='conditional_manager_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())
-            #         conditional_remove_players = st.multiselect("Remove lineups containing player(s):", options=sorted(list(player_names)), default=[])
-            #         conditional_include_players = st.multiselect("If they also contain player(s):", options=sorted(list(player_names)), 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
-            #             parsed_frame = st.session_state['working_frame'].copy()
-
-            #             player_columns = [col for col in parsed_frame.columns if col not in excluded_cols]
-
-            #             # Test with a simpler approach
-            #             include_mask = parsed_frame[player_columns].apply(
-            #                 lambda row: all(player in row.values for player in conditional_include_players), axis=1
-            #             )
-                            
-            #             remove_mask = parsed_frame[player_columns].apply(
-            #                 lambda row: not any(player in row.values for player in conditional_remove_players), axis=1
-            #             )
-                        
-            #             parsed_frame = parsed_frame[include_mask & remove_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()
-                        
-            #             player_columns = [col for col in parsed_frame.columns if col not in excluded_cols]
-                        
-            #             # Test with a simpler approach
-            #             include_mask = parsed_frame[player_columns].apply(
-            #                 lambda row: all(player in row.values for player in conditional_include_players), axis=1
-            #             )
-                            
-            #             remove_mask = parsed_frame[player_columns].apply(
-            #                 lambda row: not any(player in row.values for player in conditional_remove_players), axis=1
-            #             )
-                        
-            #             parsed_frame = parsed_frame[include_mask & remove_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('Trimming Options'):
                 with st.form(key='trim_form'):
@@ -1510,6 +1455,128 @@ if selected_tab == 'Manage Portfolio':
                         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)'):
+                # a set of functions for removing lineups that contain a conditional between players and stacks
+                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=[])
+                    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=[])
+                    
+                    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()
+
+                        # Check if we have players selected for both alpha and beta sides
+                        if conditional_side_alpha and conditional_side_beta:
+                            # Create boolean mask for rows containing ALL players from alpha side
+                            alpha_mask = pd.Series([True] * len(parsed_frame), index=parsed_frame.index)
+                            for player in conditional_side_alpha:
+                                player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
+                                alpha_mask = alpha_mask & player_present
+                            
+                            # For rows that match alpha condition, check beta condition
+                            if conditional_var == 'Any':
+                                # Check if row contains ANY of the beta players
+                                beta_mask = pd.Series([False] * len(parsed_frame), index=parsed_frame.index)
+                                for player in conditional_side_beta:
+                                    player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
+                                    beta_mask = beta_mask | player_present
+                            elif conditional_var == 'All':
+                                # Check if row contains ALL of the beta players
+                                beta_mask = pd.Series([True] * len(parsed_frame), index=parsed_frame.index)
+                                for player in conditional_side_beta:
+                                    player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
+                                    beta_mask = beta_mask & player_present
+                            elif conditional_var == 'None':
+                                # Check if row contains NONE of the beta players
+                                beta_mask = pd.Series([True] * len(parsed_frame), index=parsed_frame.index)
+                                for player in conditional_side_beta:
+                                    player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
+                                    beta_mask = beta_mask & (~player_present)
+                            
+                            # Combine conditions: alpha_mask AND beta_mask
+                            final_condition = alpha_mask & beta_mask
+                            
+                            # Apply keep or remove logic
+                            if keep_remove_var == 'Keep':
+                                parsed_frame = parsed_frame[final_condition]
+                            else:  # Remove
+                                parsed_frame = parsed_frame[~final_condition]
+                        
+                        elif conditional_side_alpha:
+                            # Only alpha side specified - filter based on presence of alpha players
+                            alpha_mask = pd.Series([True] * len(parsed_frame), index=parsed_frame.index)
+                            for player in conditional_side_alpha:
+                                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:  # Remove
+                                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()
+
+                        # Same logic for export path
+                        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:
+                                player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
+                                alpha_mask = alpha_mask & player_present
+                            
+                            if conditional_var == 'Any':
+                                beta_mask = pd.Series([False] * len(parsed_frame), index=parsed_frame.index)
+                                for player in conditional_side_beta:
+                                    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:
+                                    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:
+                                    player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
+                                    beta_mask = beta_mask & (~player_present)
+                            
+                            final_condition = alpha_mask & beta_mask
+                            
+                            if keep_remove_var == 'Keep':
+                                parsed_frame = parsed_frame[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:
+                                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('Exposure Management'):
                 with st.form(key='Exposures'):
                     exposure_player = st.selectbox("Player", options=sorted(list(set(st.session_state['projections_df']['player_names'].unique()))), key='exposure_player')