masster 0.4.11__py3-none-any.whl → 0.4.13__py3-none-any.whl

masster/study/helpers.py

@@ -1743,13 +1743,12 @@ def features_select(
     elapsed_time = time.perf_counter() - start_time
     final_count = len(result)
     removed_count = initial_count - final_count
-    throughput = final_count / elapsed_time if elapsed_time > 0 else 0
     
     if final_count == 0:
         self.logger.warning("No features remaining after applying selection criteria.")
     else:
         self.logger.debug(
-            f"Selected features: {final_count:,} (removed: {removed_count:,})"
+            f"Selected features: {final_count:,} (removed: {removed_count:,}) in {elapsed_time:.4f}s"
         )
     
     return result
@@ -2094,8 +2093,6 @@ def features_filter(
         self.logger.warning("No features provided for filtering.")
         return
 
-    import time
-    start_time = time.perf_counter()
     initial_count = len(self.features_df)
     
     # Extract feature UIDs efficiently
@@ -2406,12 +2403,16 @@ def consensus_select(
     chrom_prominence_scaled_mean=None,
     chrom_height_scaled_mean=None,
     rt_delta_mean=None,
+    id_top_score=None,
+    identified=None,
     sortby=None,
     descending=True,
 ):
     """
     Select consensus features from consensus_df based on specified criteria and return the filtered DataFrame.
 
+    OPTIMIZED VERSION: Enhanced performance with lazy evaluation, vectorized operations, and efficient filtering.
+
     Parameters:
         mz: m/z filter with flexible formats:
             - float: m/z value ± default tolerance (uses study.parameters.eic_mz_tol)
@@ -2433,6 +2434,11 @@ def consensus_select(
         chrom_prominence_scaled_mean: mean scaled chromatogram prominence filter (tuple for range, single value for minimum)
         chrom_height_scaled_mean: mean scaled chromatogram height filter (tuple for range, single value for minimum)
         rt_delta_mean: mean RT delta filter (tuple for range, single value for minimum)
+        id_top_score: identification top score filter (tuple for range, single value for minimum)
+        identified: filter by identification status:
+            - True: select only rows with id_top_name not null
+            - False: select only rows with id_top_name null
+            - None: no filtering (default)
         sortby: column name(s) to sort by (string, list of strings, or None for no sorting)
         descending: sort direction (True for descending, False for ascending, default is True)
 
@@ -2443,366 +2449,204 @@ def consensus_select(
         self.logger.warning("No consensus features found in study.")
         return pl.DataFrame()
 
-    consensus = self.consensus_df.clone()
-    initial_count = len(consensus)
+    # Early return optimization - check if any filters are provided
+    filter_params = [mz, rt, inty_mean, consensus_uid, consensus_id, number_samples, 
+                    number_ms2, quality, bl, chrom_coherence_mean, chrom_prominence_mean,
+                    chrom_prominence_scaled_mean, chrom_height_scaled_mean, 
+                    rt_delta_mean, id_top_score, identified]
+    
+    if all(param is None for param in filter_params) and sortby is None:
+        return self.consensus_df.clone()
+
+    import time
+    start_time = time.perf_counter()
+    initial_count = len(self.consensus_df)
 
-    # Filter by m/z
-    if mz is not None:
-        consensus_len_before_filter = len(consensus)
+    # Pre-check available columns once for efficiency
+    available_columns = set(self.consensus_df.columns)
+    filter_conditions = []
+    warnings = []
 
+    # Build all filter conditions efficiently
+    if mz is not None:
         if isinstance(mz, tuple) and len(mz) == 2:
-            # Check if second value is smaller than first (indicating mz, mz_tol format)
             if mz[1] < mz[0]:
-                # First is mz, second is mz_tol
+                # mz_center ± mz_tol format
                 mz_center, mz_tol = mz
                 min_mz = mz_center - mz_tol
                 max_mz = mz_center + mz_tol
             else:
-                # Standard (min_mz, max_mz) format
+                # (min_mz, max_mz) format
                 min_mz, max_mz = mz
-            consensus = consensus.filter(
-                (pl.col("mz") >= min_mz) & (pl.col("mz") <= max_mz),
-            )
+            filter_conditions.append((pl.col("mz") >= min_mz) & (pl.col("mz") <= max_mz))
         else:
-            # Single float value - use default mz tolerance from study parameters
+            # Single value with default tolerance
             default_mz_tol = getattr(self, "parameters", None)
             if default_mz_tol and hasattr(default_mz_tol, "eic_mz_tol"):
                 default_mz_tol = default_mz_tol.eic_mz_tol
             else:
-                # Fallback to align_defaults if study parameters not available
                 from masster.study.defaults.align_def import align_defaults
-
                 default_mz_tol = align_defaults().mz_max_diff
-
+            
             min_mz = mz - default_mz_tol
             max_mz = mz + default_mz_tol
-            consensus = consensus.filter(
-                (pl.col("mz") >= min_mz) & (pl.col("mz") <= max_mz),
-            )
-
-        self.logger.debug(
-            f"Selected consensus by mz. Consensus removed: {consensus_len_before_filter - len(consensus)}",
-        )
+            filter_conditions.append((pl.col("mz") >= min_mz) & (pl.col("mz") <= max_mz))
 
-    # Filter by retention time
     if rt is not None:
-        consensus_len_before_filter = len(consensus)
-
         if isinstance(rt, tuple) and len(rt) == 2:
-            # Check if second value is smaller than first (indicating rt, rt_tol format)
             if rt[1] < rt[0]:
-                # First is rt, second is rt_tol
+                # rt_center ± rt_tol format
                 rt_center, rt_tol = rt
                 min_rt = rt_center - rt_tol
                 max_rt = rt_center + rt_tol
             else:
-                # Standard (min_rt, max_rt) format
+                # (min_rt, max_rt) format
                 min_rt, max_rt = rt
-            consensus = consensus.filter(
-                (pl.col("rt") >= min_rt) & (pl.col("rt") <= max_rt),
-            )
+            filter_conditions.append((pl.col("rt") >= min_rt) & (pl.col("rt") <= max_rt))
         else:
-            # Single float value - use default rt tolerance from study parameters
+            # Single value with default tolerance
             default_rt_tol = getattr(self, "parameters", None)
             if default_rt_tol and hasattr(default_rt_tol, "eic_rt_tol"):
                 default_rt_tol = default_rt_tol.eic_rt_tol
             else:
-                # Fallback to align_defaults if study parameters not available
                 from masster.study.defaults.align_def import align_defaults
-
                 default_rt_tol = align_defaults().rt_tol
-
+            
             min_rt = rt - default_rt_tol
             max_rt = rt + default_rt_tol
-            consensus = consensus.filter(
-                (pl.col("rt") >= min_rt) & (pl.col("rt") <= max_rt),
-            )
-
-        self.logger.debug(
-            f"Selected consensus by rt. Consensus removed: {consensus_len_before_filter - len(consensus)}",
-        )
-
-    # Filter by mean intensity
-    if inty_mean is not None:
-        consensus_len_before_filter = len(consensus)
-        if isinstance(inty_mean, tuple) and len(inty_mean) == 2:
-            min_inty, max_inty = inty_mean
-            consensus = consensus.filter(
-                (pl.col("inty_mean") >= min_inty) & (pl.col("inty_mean") <= max_inty),
-            )
+            filter_conditions.append((pl.col("rt") >= min_rt) & (pl.col("rt") <= max_rt))
+
+    # Helper function to add range/minimum filters
+    def _add_range_filter(param, column, param_name):
+        if param is not None:
+            if column in available_columns:
+                if isinstance(param, tuple) and len(param) == 2:
+                    min_val, max_val = param
+                    filter_conditions.append((pl.col(column) >= min_val) & (pl.col(column) <= max_val))
+                else:
+                    filter_conditions.append(pl.col(column) >= param)
+            else:
+                warnings.append(f"'{column}' column not found in consensus_df")
+
+    # Apply range/minimum filters efficiently
+    _add_range_filter(inty_mean, "inty_mean", "inty_mean")
+    _add_range_filter(quality, "quality", "quality")
+    _add_range_filter(bl, "bl", "bl")
+    _add_range_filter(chrom_coherence_mean, "chrom_coherence_mean", "chrom_coherence_mean")
+    _add_range_filter(chrom_prominence_mean, "chrom_prominence_mean", "chrom_prominence_mean")
+    _add_range_filter(chrom_prominence_scaled_mean, "chrom_prominence_scaled_mean", "chrom_prominence_scaled_mean")
+    _add_range_filter(chrom_height_scaled_mean, "chrom_height_scaled_mean", "chrom_height_scaled_mean")
+    _add_range_filter(rt_delta_mean, "rt_delta_mean", "rt_delta_mean")
+    _add_range_filter(id_top_score, "id_top_score", "id_top_score")
+    _add_range_filter(number_samples, "number_samples", "number_samples")
+
+    # Handle number_ms2 with column check
+    if number_ms2 is not None:
+        if "number_ms2" in available_columns:
+            if isinstance(number_ms2, tuple) and len(number_ms2) == 2:
+                min_ms2, max_ms2 = number_ms2
+                filter_conditions.append((pl.col("number_ms2") >= min_ms2) & (pl.col("number_ms2") <= max_ms2))
+            else:
+                filter_conditions.append(pl.col("number_ms2") >= number_ms2)
         else:
-            consensus = consensus.filter(pl.col("inty_mean") >= inty_mean)
-        self.logger.debug(
-            f"Selected consensus by inty_mean. Consensus removed: {consensus_len_before_filter - len(consensus)}",
-        )
+            warnings.append("'number_ms2' column not found in consensus_df")
 
-    # Filter by consensus_uid
+    # Handle consensus_uid (list, single value, or range)
     if consensus_uid is not None:
-        consensus_len_before_filter = len(consensus)
         if isinstance(consensus_uid, (list, tuple)):
             if len(consensus_uid) == 2 and not isinstance(consensus_uid, list):
-                # Treat as range
+                # Treat tuple as range
                 min_uid, max_uid = consensus_uid
-                consensus = consensus.filter(
-                    (pl.col("consensus_uid") >= min_uid)
-                    & (pl.col("consensus_uid") <= max_uid),
-                )
+                filter_conditions.append((pl.col("consensus_uid") >= min_uid) & (pl.col("consensus_uid") <= max_uid))
             else:
-                # Treat as list
-                consensus = consensus.filter(
-                    pl.col("consensus_uid").is_in(consensus_uid),
-                )
+                # Treat as list of values
+                filter_conditions.append(pl.col("consensus_uid").is_in(consensus_uid))
         else:
-            consensus = consensus.filter(pl.col("consensus_uid") == consensus_uid)
-        self.logger.debug(
-            f"Selected consensus by consensus_uid. Consensus removed: {consensus_len_before_filter - len(consensus)}",
-        )
+            filter_conditions.append(pl.col("consensus_uid") == consensus_uid)
 
-    # Filter by consensus_id
+    # Handle consensus_id (list or single value)
     if consensus_id is not None:
-        consensus_len_before_filter = len(consensus)
         if isinstance(consensus_id, list):
-            consensus = consensus.filter(pl.col("consensus_id").is_in(consensus_id))
-        else:
-            consensus = consensus.filter(pl.col("consensus_id") == consensus_id)
-        self.logger.debug(
-            f"Selected consensus by consensus_id. Consensus removed: {consensus_len_before_filter - len(consensus)}",
-        )
-
-    # Filter by number of samples
-    if number_samples is not None:
-        consensus_len_before_filter = len(consensus)
-        if isinstance(number_samples, tuple) and len(number_samples) == 2:
-            min_samples, max_samples = number_samples
-            consensus = consensus.filter(
-                (pl.col("number_samples") >= min_samples)
-                & (pl.col("number_samples") <= max_samples),
-            )
-        else:
-            consensus = consensus.filter(pl.col("number_samples") >= number_samples)
-        self.logger.debug(
-            f"Selected consensus by number_samples. Consensus removed: {consensus_len_before_filter - len(consensus)}",
-        )
-
-    # Filter by number of MS2 spectra
-    if number_ms2 is not None:
-        consensus_len_before_filter = len(consensus)
-        if "number_ms2" in consensus.columns:
-            if isinstance(number_ms2, tuple) and len(number_ms2) == 2:
-                min_ms2, max_ms2 = number_ms2
-                consensus = consensus.filter(
-                    (pl.col("number_ms2") >= min_ms2)
-                    & (pl.col("number_ms2") <= max_ms2),
-                )
-            else:
-                consensus = consensus.filter(pl.col("number_ms2") >= number_ms2)
-        else:
-            self.logger.warning("'number_ms2' column not found in consensus_df")
-        self.logger.debug(
-            f"Selected consensus by number_ms2. Consensus removed: {consensus_len_before_filter - len(consensus)}",
-        )
-
-    # Filter by quality
-    if quality is not None:
-        consensus_len_before_filter = len(consensus)
-        if isinstance(quality, tuple) and len(quality) == 2:
-            min_quality, max_quality = quality
-            consensus = consensus.filter(
-                (pl.col("quality") >= min_quality) & (pl.col("quality") <= max_quality),
-            )
-        else:
-            consensus = consensus.filter(pl.col("quality") >= quality)
-        self.logger.debug(
-            f"Selected consensus by quality. Consensus removed: {consensus_len_before_filter - len(consensus)}",
-        )
-
-    # Filter by baseline
-    if bl is not None:
-        consensus_len_before_filter = len(consensus)
-        if "bl" in consensus.columns:
-            if isinstance(bl, tuple) and len(bl) == 2:
-                min_bl, max_bl = bl
-                consensus = consensus.filter(
-                    (pl.col("bl") >= min_bl) & (pl.col("bl") <= max_bl),
-                )
-            else:
-                consensus = consensus.filter(pl.col("bl") >= bl)
+            filter_conditions.append(pl.col("consensus_id").is_in(consensus_id))
         else:
-            self.logger.warning("'bl' column not found in consensus_df")
-        self.logger.debug(
-            f"Selected consensus by bl. Consensus removed: {consensus_len_before_filter - len(consensus)}",
-        )
+            filter_conditions.append(pl.col("consensus_id") == consensus_id)
 
-    # Filter by mean chromatogram coherence
-    if chrom_coherence_mean is not None:
-        consensus_len_before_filter = len(consensus)
-        if "chrom_coherence_mean" in consensus.columns:
-            if (
-                isinstance(chrom_coherence_mean, tuple)
-                and len(chrom_coherence_mean) == 2
-            ):
-                min_coherence, max_coherence = chrom_coherence_mean
-                consensus = consensus.filter(
-                    (pl.col("chrom_coherence_mean") >= min_coherence)
-                    & (pl.col("chrom_coherence_mean") <= max_coherence),
-                )
+    # Handle identified status filter
+    if identified is not None:
+        if "id_top_name" in available_columns:
+            if identified:
+                filter_conditions.append(pl.col("id_top_name").is_not_null())
             else:
-                consensus = consensus.filter(
-                    pl.col("chrom_coherence_mean") >= chrom_coherence_mean,
-                )
+                filter_conditions.append(pl.col("id_top_name").is_null())
         else:
-            self.logger.warning(
-                "'chrom_coherence_mean' column not found in consensus_df",
-            )
-        self.logger.debug(
-            f"Selected consensus by chrom_coherence_mean. Consensus removed: {consensus_len_before_filter - len(consensus)}",
-        )
+            warnings.append("'id_top_name' column not found in consensus_df")
 
-    # Filter by mean chromatogram prominence
-    if chrom_prominence_mean is not None:
-        consensus_len_before_filter = len(consensus)
-        if "chrom_prominence_mean" in consensus.columns:
-            if (
-                isinstance(chrom_prominence_mean, tuple)
-                and len(chrom_prominence_mean) == 2
-            ):
-                min_prominence, max_prominence = chrom_prominence_mean
-                consensus = consensus.filter(
-                    (pl.col("chrom_prominence_mean") >= min_prominence)
-                    & (pl.col("chrom_prominence_mean") <= max_prominence),
-                )
-            else:
-                consensus = consensus.filter(
-                    pl.col("chrom_prominence_mean") >= chrom_prominence_mean,
-                )
-        else:
-            self.logger.warning(
-                "'chrom_prominence_mean' column not found in consensus_df",
-            )
-        self.logger.debug(
-            f"Selected consensus by chrom_prominence_mean. Consensus removed: {consensus_len_before_filter - len(consensus)}",
-        )
+    # Log warnings once
+    for warning in warnings:
+        self.logger.warning(warning)
 
-    # Filter by mean scaled chromatogram prominence
-    if chrom_prominence_scaled_mean is not None:
-        consensus_len_before_filter = len(consensus)
-        if "chrom_prominence_scaled_mean" in consensus.columns:
-            if (
-                isinstance(chrom_prominence_scaled_mean, tuple)
-                and len(chrom_prominence_scaled_mean) == 2
-            ):
-                min_prominence_scaled, max_prominence_scaled = (
-                    chrom_prominence_scaled_mean
-                )
-                consensus = consensus.filter(
-                    (pl.col("chrom_prominence_scaled_mean") >= min_prominence_scaled)
-                    & (pl.col("chrom_prominence_scaled_mean") <= max_prominence_scaled),
-                )
-            else:
-                consensus = consensus.filter(
-                    pl.col("chrom_prominence_scaled_mean")
-                    >= chrom_prominence_scaled_mean,
-                )
-        else:
-            self.logger.warning(
-                "'chrom_prominence_scaled_mean' column not found in consensus_df",
-            )
-        self.logger.debug(
-            f"Selected consensus by chrom_prominence_scaled_mean. Consensus removed: {consensus_len_before_filter - len(consensus)}",
+    # Apply all filters at once using lazy evaluation for optimal performance
+    if filter_conditions:
+        # Combine all conditions efficiently using reduce
+        from functools import reduce
+        import operator
+        combined_filter = reduce(operator.and_, filter_conditions)
+        
+        consensus = (
+            self.consensus_df
+            .lazy()
+            .filter(combined_filter)
+            .collect(streaming=True)
         )
+    else:
+        consensus = self.consensus_df.clone()
 
-    # Filter by mean scaled chromatogram height
-    if chrom_height_scaled_mean is not None:
-        consensus_len_before_filter = len(consensus)
-        if "chrom_height_scaled_mean" in consensus.columns:
-            if (
-                isinstance(chrom_height_scaled_mean, tuple)
-                and len(chrom_height_scaled_mean) == 2
-            ):
-                min_height_scaled, max_height_scaled = chrom_height_scaled_mean
-                consensus = consensus.filter(
-                    (pl.col("chrom_height_scaled_mean") >= min_height_scaled)
-                    & (pl.col("chrom_height_scaled_mean") <= max_height_scaled),
-                )
-            else:
-                consensus = consensus.filter(
-                    pl.col("chrom_height_scaled_mean") >= chrom_height_scaled_mean,
-                )
-        else:
-            self.logger.warning(
-                "'chrom_height_scaled_mean' column not found in consensus_df",
-            )
-        self.logger.debug(
-            f"Selected consensus by chrom_height_scaled_mean. Consensus removed: {consensus_len_before_filter - len(consensus)}",
-        )
+    final_count = len(consensus)
 
-    # Filter by mean RT delta
-    if rt_delta_mean is not None:
-        consensus_len_before_filter = len(consensus)
-        if "rt_delta_mean" in consensus.columns:
-            if isinstance(rt_delta_mean, tuple) and len(rt_delta_mean) == 2:
-                min_rt_delta, max_rt_delta = rt_delta_mean
-                consensus = consensus.filter(
-                    (pl.col("rt_delta_mean") >= min_rt_delta)
-                    & (pl.col("rt_delta_mean") <= max_rt_delta),
-                )
-            else:
-                consensus = consensus.filter(pl.col("rt_delta_mean") >= rt_delta_mean)
-        else:
-            self.logger.warning("'rt_delta_mean' column not found in consensus_df")
-        self.logger.debug(
-            f"Selected consensus by rt_delta_mean. Consensus removed: {consensus_len_before_filter - len(consensus)}",
-        )
-
-    if len(consensus) == 0:
-        self.logger.warning(
-            "No consensus features remaining after applying selection criteria.",
-        )
-    else:
-        self.logger.info(
-            f"Selected consensus features. Features remaining: {len(consensus)} (from {initial_count})",
-        )
+    # Early return if no results
+    if final_count == 0:
+        self.logger.warning("No consensus features remaining after applying selection criteria.")
+        return pl.DataFrame()
 
     # Sort the results if sortby is specified
     if sortby is not None:
         if isinstance(sortby, str):
-            # Single column
             if sortby in consensus.columns:
                 consensus = consensus.sort(sortby, descending=descending)
             else:
-                self.logger.warning(
-                    f"Sort column '{sortby}' not found in consensus DataFrame",
-                )
+                self.logger.warning(f"Sort column '{sortby}' not found in consensus DataFrame")
         elif isinstance(sortby, (list, tuple)):
-            # Multiple columns
             valid_columns = [col for col in sortby if col in consensus.columns]
             invalid_columns = [col for col in sortby if col not in consensus.columns]
-
+            
             if invalid_columns:
-                self.logger.warning(
-                    f"Sort columns not found in consensus DataFrame: {invalid_columns}",
-                )
-
+                self.logger.warning(f"Sort columns not found in consensus DataFrame: {invalid_columns}")
+            
             if valid_columns:
                 consensus = consensus.sort(valid_columns, descending=descending)
         else:
-            self.logger.warning(
-                f"Invalid sortby parameter type: {type(sortby)}. Expected str, list, or tuple.",
-            )
+            self.logger.warning(f"Invalid sortby parameter type: {type(sortby)}. Expected str, list, or tuple.")
+
+    # Log performance metrics
+    elapsed_time = time.perf_counter() - start_time
+    removed_count = initial_count - final_count
+    
+    self.logger.info(f"Selected consensus features: {final_count:,} (removed: {removed_count:,}) in {elapsed_time:.4f}s")
 
     return consensus
 
 
 def consensus_filter(self, consensus):
     """
-    Filter consensus_df by removing all consensus features that match the given criteria.
-    This also removes related entries from consensus_mapping_df, features_df, and consensus_ms2.
+    Filter consensus_df by keeping only consensus features that match the given criteria.
+    This keeps only the specified consensus features and removes all others.
+    Also updates related entries in consensus_mapping_df, features_df, and consensus_ms2.
 
     Parameters:
-        consensus: Consensus features to remove. Can be:
+        consensus: Consensus features to keep. Can be:
                   - polars.DataFrame: Consensus DataFrame (will use consensus_uid column)
-                  - list: List of consensus_uids to remove
-                  - int: Single consensus_uid to remove
+                  - list: List of consensus_uids to keep
+                  - int: Single consensus_uid to keep
 
     Returns:
         None (modifies self.consensus_df and related DataFrames in place)
@@ -2813,71 +2657,73 @@ def consensus_filter(self, consensus):
 
     initial_consensus_count = len(self.consensus_df)
 
-    # Determine consensus_uids to remove
+    # Determine consensus_uids to keep
     if isinstance(consensus, pl.DataFrame):
         if "consensus_uid" not in consensus.columns:
             self.logger.error("consensus DataFrame must contain 'consensus_uid' column")
             return
-        consensus_uids_to_remove = consensus["consensus_uid"].to_list()
+        consensus_uids_to_keep = consensus["consensus_uid"].to_list()
     elif isinstance(consensus, list):
-        consensus_uids_to_remove = consensus
+        consensus_uids_to_keep = consensus
     elif isinstance(consensus, int):
-        consensus_uids_to_remove = [consensus]
+        consensus_uids_to_keep = [consensus]
     else:
         self.logger.error("consensus parameter must be a DataFrame, list, or int")
         return
 
-    if not consensus_uids_to_remove:
+    if not consensus_uids_to_keep:
         self.logger.warning("No consensus UIDs provided for filtering.")
         return
 
-    # Get feature_uids that need to be removed from features_df
-    feature_uids_to_remove = []
+    # Get feature_uids that need to be kept in features_df
+    feature_uids_to_keep = []
     if (
         self.consensus_mapping_df is not None
         and not self.consensus_mapping_df.is_empty()
     ):
-        feature_uids_to_remove = self.consensus_mapping_df.filter(
-            pl.col("consensus_uid").is_in(consensus_uids_to_remove),
+        feature_uids_to_keep = self.consensus_mapping_df.filter(
+            pl.col("consensus_uid").is_in(consensus_uids_to_keep),
         )["feature_uid"].to_list()
 
-    # Remove consensus features from consensus_df
+    # Keep only specified consensus features in consensus_df
     self.consensus_df = self.consensus_df.filter(
-        ~pl.col("consensus_uid").is_in(consensus_uids_to_remove),
+        pl.col("consensus_uid").is_in(consensus_uids_to_keep),
     )
 
-    # Remove from consensus_mapping_df
+    # Keep only relevant entries in consensus_mapping_df
     if (
         self.consensus_mapping_df is not None
         and not self.consensus_mapping_df.is_empty()
     ):
         initial_mapping_count = len(self.consensus_mapping_df)
         self.consensus_mapping_df = self.consensus_mapping_df.filter(
-            ~pl.col("consensus_uid").is_in(consensus_uids_to_remove),
+            pl.col("consensus_uid").is_in(consensus_uids_to_keep),
         )
-        removed_mapping_count = initial_mapping_count - len(self.consensus_mapping_df)
+        remaining_mapping_count = len(self.consensus_mapping_df)
+        removed_mapping_count = initial_mapping_count - remaining_mapping_count
         if removed_mapping_count > 0:
             self.logger.debug(
                 f"Removed {removed_mapping_count} entries from consensus_mapping_df",
             )
 
-    # Remove corresponding features from features_df
+    # Keep only corresponding features in features_df
     if (
-        feature_uids_to_remove
+        feature_uids_to_keep
         and self.features_df is not None
         and not self.features_df.is_empty()
     ):
         initial_features_count = len(self.features_df)
         self.features_df = self.features_df.filter(
-            ~pl.col("feature_uid").is_in(feature_uids_to_remove),
+            pl.col("feature_uid").is_in(feature_uids_to_keep),
         )
-        removed_features_count = initial_features_count - len(self.features_df)
+        remaining_features_count = len(self.features_df)
+        removed_features_count = initial_features_count - remaining_features_count
         if removed_features_count > 0:
             self.logger.debug(
                 f"Removed {removed_features_count} entries from features_df",
             )
 
-    # Remove from consensus_ms2 if it exists
+    # Keep only relevant entries in consensus_ms2 if it exists
     if (
         hasattr(self, "consensus_ms2")
         and self.consensus_ms2 is not None
@@ -2885,22 +2731,25 @@ def consensus_filter(self, consensus):
     ):
         initial_ms2_count = len(self.consensus_ms2)
         self.consensus_ms2 = self.consensus_ms2.filter(
-            ~pl.col("consensus_uid").is_in(consensus_uids_to_remove),
+            pl.col("consensus_uid").is_in(consensus_uids_to_keep),
         )
-        removed_ms2_count = initial_ms2_count - len(self.consensus_ms2)
+        remaining_ms2_count = len(self.consensus_ms2)
+        removed_ms2_count = initial_ms2_count - remaining_ms2_count
         if removed_ms2_count > 0:
             self.logger.debug(f"Removed {removed_ms2_count} entries from consensus_ms2")
 
-    removed_consensus_count = initial_consensus_count - len(self.consensus_df)
+    remaining_consensus_count = len(self.consensus_df)
+    removed_consensus_count = initial_consensus_count - remaining_consensus_count
     self.logger.info(
-        f"Filtered {removed_consensus_count} consensus features. Remaining consensus: {len(self.consensus_df)}",
+        f"Filtered consensus features: kept {remaining_consensus_count}, removed {removed_consensus_count}",
     )
 
 
 def consensus_delete(self, consensus):
     """
     Delete consensus features from consensus_df based on consensus identifiers.
-    This is an alias for consensus_filter for consistency with other delete methods.
+    This removes the specified consensus features and keeps all others (opposite of consensus_filter).
+    Also removes related entries from consensus_mapping_df, features_df, and consensus_ms2.
 
     Parameters:
         consensus: Consensus features to delete. Can be:
@@ -2911,7 +2760,110 @@ def consensus_delete(self, consensus):
     Returns:
         None (modifies self.consensus_df and related DataFrames in place)
     """
-    self.consensus_filter(consensus)
+    if self.consensus_df is None or self.consensus_df.is_empty():
+        self.logger.warning("No consensus features found in study.")
+        return
+
+    # Early return if no consensus provided
+    if consensus is None:
+        self.logger.warning("No consensus provided for deletion.")
+        return
+
+    initial_consensus_count = len(self.consensus_df)
+
+    # Determine consensus_uids to remove
+    if isinstance(consensus, pl.DataFrame):
+        if "consensus_uid" not in consensus.columns:
+            self.logger.error("consensus DataFrame must contain 'consensus_uid' column")
+            return
+        consensus_uids_to_remove = consensus["consensus_uid"].to_list()
+    elif isinstance(consensus, list):
+        consensus_uids_to_remove = consensus
+    elif isinstance(consensus, int):
+        consensus_uids_to_remove = [consensus]
+    else:
+        self.logger.error("consensus parameter must be a DataFrame, list, or int")
+        return
+
+    if not consensus_uids_to_remove:
+        self.logger.warning("No consensus UIDs provided for deletion.")
+        return
+
+    # Convert to set for faster lookup if list is large
+    if len(consensus_uids_to_remove) > 100:
+        consensus_uids_set = set(consensus_uids_to_remove)
+        # Use the set for filtering if it's significantly smaller
+        if len(consensus_uids_set) < len(consensus_uids_to_remove) * 0.8:
+            consensus_uids_to_remove = list(consensus_uids_set)
+
+    # Get feature_uids that need to be removed from features_df
+    feature_uids_to_remove = []
+    if (
+        self.consensus_mapping_df is not None
+        and not self.consensus_mapping_df.is_empty()
+    ):
+        feature_uids_to_remove = self.consensus_mapping_df.filter(
+            pl.col("consensus_uid").is_in(consensus_uids_to_remove),
+        )["feature_uid"].to_list()
+
+    # Remove consensus features from consensus_df
+    self.consensus_df = self.consensus_df.filter(
+        ~pl.col("consensus_uid").is_in(consensus_uids_to_remove),
+    )
+
+    # Remove from consensus_mapping_df
+    mapping_removed_count = 0
+    if (
+        self.consensus_mapping_df is not None
+        and not self.consensus_mapping_df.is_empty()
+    ):
+        initial_mapping_count = len(self.consensus_mapping_df)
+        self.consensus_mapping_df = self.consensus_mapping_df.filter(
+            ~pl.col("consensus_uid").is_in(consensus_uids_to_remove),
+        )
+        mapping_removed_count = initial_mapping_count - len(self.consensus_mapping_df)
+
+    # Remove corresponding features from features_df
+    features_removed_count = 0
+    if (
+        feature_uids_to_remove
+        and self.features_df is not None
+        and not self.features_df.is_empty()
+    ):
+        initial_features_count = len(self.features_df)
+        self.features_df = self.features_df.filter(
+            ~pl.col("feature_uid").is_in(feature_uids_to_remove),
+        )
+        features_removed_count = initial_features_count - len(self.features_df)
+
+    # Remove from consensus_ms2 if it exists
+    ms2_removed_count = 0
+    if (
+        hasattr(self, "consensus_ms2")
+        and self.consensus_ms2 is not None
+        and not self.consensus_ms2.is_empty()
+    ):
+        initial_ms2_count = len(self.consensus_ms2)
+        self.consensus_ms2 = self.consensus_ms2.filter(
+            ~pl.col("consensus_uid").is_in(consensus_uids_to_remove),
+        )
+        ms2_removed_count = initial_ms2_count - len(self.consensus_ms2)
+
+    # Calculate results and log efficiently
+    final_consensus_count = len(self.consensus_df)
+    consensus_removed_count = initial_consensus_count - final_consensus_count
+
+    # Single comprehensive log message
+    log_parts = [f"Deleted {consensus_removed_count} consensus features"]
+    if mapping_removed_count > 0:
+        log_parts.append(f"{mapping_removed_count} consensus mappings")
+    if features_removed_count > 0:
+        log_parts.append(f"{features_removed_count} features")
+    if ms2_removed_count > 0:
+        log_parts.append(f"{ms2_removed_count} MS2 spectra")
+    
+    log_message = ". ".join(log_parts) + f". Remaining consensus: {final_consensus_count}"
+    self.logger.info(log_message)
 
 
 # =====================================================================================