Enhance player and team filtering logic in 'app.py' for Showdown mode by implementing CPT/FLEX/Overall focus handling, improving clarity and consistency while maintaining performance.

app.py

@@ -1395,41 +1395,113 @@ if selected_tab == 'Manage Portfolio':
                         st.session_state['settings_base'] = False
                         parsed_frame = st.session_state['export_base'].copy()
                         if player_remove:
-                            # Create mask for lineups that contain any of the removed players
-                            remove_mask = parsed_frame[st.session_state['player_columns']].apply(
-                                lambda row: not any(player in list(row) for player in player_remove), axis=1
-                            )
+                            if type_var == 'Showdown':
+                                if cpt_flex_focus == 'CPT':
+                                    remove_mask = parsed_frame.iloc[:, 0].apply(
+                                        lambda player: not any(remove_player in str(player) for remove_player in player_remove)
+                                    )
+                                elif cpt_flex_focus == 'FLEX':
+                                    remove_mask = parsed_frame.iloc[:, 1:].apply(
+                                        lambda row: not any(player in list(row) for player in player_remove), axis=1
+                                    )
+                                elif cpt_flex_focus == 'Overall':
+                                    remove_mask = parsed_frame[st.session_state['player_columns']].apply(
+                                        lambda row: not any(player in list(row) for player in player_remove), axis=1
+                                    )
+                            else:
+                                remove_mask = parsed_frame[st.session_state['player_columns']].apply(
+                                    lambda row: not any(player in list(row) for player in player_remove), axis=1
+                                )
                             parsed_frame = parsed_frame[remove_mask]
                         
                         if player_lock:
-                            
-                            lock_mask = parsed_frame[st.session_state['player_columns']].apply(
-                                lambda row: all(player in list(row) for player in player_lock), axis=1
-                            )
+                            if type_var == 'Showdown':
+                                if cpt_flex_focus == 'CPT':
+                                    lock_mask = parsed_frame.iloc[:, 0].apply(
+                                        lambda player: any(lock_player in str(player) for lock_player in player_lock)
+                                    )
+                                elif cpt_flex_focus == 'FLEX':
+                                    lock_mask = parsed_frame.iloc[:, 1:].apply(
+                                        lambda row: all(player in list(row) for player in player_lock), axis=1
+                                    )
+                                elif cpt_flex_focus == 'Overall':
+                                    lock_mask = parsed_frame[st.session_state['player_columns']].apply(
+                                        lambda row: all(player in list(row) for player in player_lock), axis=1
+                                    )
+                            else:
+                                lock_mask = parsed_frame[st.session_state['player_columns']].apply(
+                                    lambda row: all(player in list(row) for player in player_lock), axis=1
+                                )
                             parsed_frame = parsed_frame[lock_mask]
                         
                         if team_include:
-                            # Create a copy of the frame with player names replaced by teams, excluding SP1 and SP2
-                            filtered_player_columns = [col for col in st.session_state['player_columns'] if col not in ['SP1', 'SP2']]
-                            team_frame = parsed_frame[filtered_player_columns].apply(
-                                lambda x: x.map(st.session_state['map_dict']['team_map'])
-                            )
-                            # Create mask for lineups that contain any of the included teams
-                            include_mask = team_frame.apply(
-                                lambda row: any(team in list(row) for team in team_include), axis=1
-                            )
+                            if type_var == 'Showdown':
+                                if cpt_flex_focus == 'CPT':
+                                    team_frame = parsed_frame.iloc[:, 0].apply(
+                                        lambda x: x.map(st.session_state['map_dict']['team_map'])
+                                    )
+                                    include_mask = team_frame.apply(
+                                        lambda row: any(team in list(row) for team in team_include), axis=1
+                                    )
+                                elif cpt_flex_focus == 'FLEX':
+                                    team_frame = parsed_frame.iloc[:, 1:].apply(
+                                        lambda x: x.map(st.session_state['map_dict']['team_map'])
+                                    )
+                                    include_mask = team_frame.apply(
+                                        lambda row: any(team in list(row) for team in team_include), axis=1
+                                    )
+                                elif cpt_flex_focus == 'Overall':
+                                    team_frame = parsed_frame[st.session_state['player_columns']].apply(
+                                        lambda x: x.map(st.session_state['map_dict']['team_map'])
+                                    )
+                                    include_mask = team_frame.apply(
+                                        lambda row: any(team in list(row) for team in team_include), axis=1
+                                    )
+                            else:
+                                # Create a copy of the frame with player names replaced by teams, excluding SP1 and SP2
+                                filtered_player_columns = [col for col in st.session_state['player_columns'] if col not in ['SP1', 'SP2']]
+                                team_frame = parsed_frame[filtered_player_columns].apply(
+                                    lambda x: x.map(st.session_state['map_dict']['team_map'])
+                                )
+                                # Create mask for lineups that contain any of the included teams
+                                include_mask = team_frame.apply(
+                                    lambda row: any(team in list(row) for team in team_include), axis=1
+                                )
                             parsed_frame = parsed_frame[include_mask]
                         
                         if team_remove:
-                            # Create a copy of the frame with player names replaced by teams, excluding SP1 and SP2
-                            filtered_player_columns = [col for col in st.session_state['player_columns'] if col not in ['SP1', 'SP2']]
-                            team_frame = parsed_frame[filtered_player_columns].apply(
-                                lambda x: x.map(st.session_state['map_dict']['team_map'])
-                            )
-                            # Create mask for lineups that don't contain any of the removed teams
-                            remove_mask = team_frame.apply(
-                                lambda row: not any(team in list(row) for team in team_remove), axis=1
-                            )
+                            if type_var == 'Showdown':
+                                if cpt_flex_focus == 'CPT':
+                                    team_frame = parsed_frame.iloc[:, 0].apply(
+                                        lambda x: x.map(st.session_state['map_dict']['team_map'])
+                                    )
+                                    remove_mask = team_frame.apply(
+                                        lambda row: not any(team in list(row) for team in team_remove), axis=1
+                                    )
+                                elif cpt_flex_focus == 'FLEX':
+                                    team_frame = parsed_frame.iloc[:, 1:].apply(
+                                        lambda x: x.map(st.session_state['map_dict']['team_map'])
+                                    )
+                                    remove_mask = team_frame.apply(
+                                        lambda row: not any(team in list(row) for team in team_remove), axis=1
+                                    )
+                                elif cpt_flex_focus == 'Overall':
+                                    team_frame = parsed_frame[st.session_state['player_columns']].apply(
+                                        lambda x: x.map(st.session_state['map_dict']['team_map'])
+                                    )
+                                    remove_mask = team_frame.apply(
+                                        lambda row: not any(team in list(row) for team in team_remove), axis=1
+                                    )
+                            else:
+                                # Create a copy of the frame with player names replaced by teams, excluding SP1 and SP2
+                                filtered_player_columns = [col for col in st.session_state['player_columns'] if col not in ['SP1', 'SP2']]
+                                team_frame = parsed_frame[filtered_player_columns].apply(
+                                    lambda x: x.map(st.session_state['map_dict']['team_map'])
+                                )
+                                # Create mask for lineups that don't contain any of the removed teams
+                                remove_mask = team_frame.apply(
+                                    lambda row: not any(team in list(row) for team in team_remove), axis=1
+                                )
                             parsed_frame = parsed_frame[remove_mask]
                         
                         if size_include: