masster 0.3.9__py3-none-any.whl → 0.3.11__py3-none-any.whl

masster/study/helpers.py

@@ -7,7 +7,7 @@ import pandas as pd
 import polars as pl
 
 from tqdm import tqdm
-    
+
 
 def get_chrom(self, uids=None, samples=None):
     # Check if consensus_df is empty or doesn't have required columns
@@ -113,6 +113,7 @@ def get_chrom(self, uids=None, samples=None):
     # Return as Polars DataFrame (can handle complex objects like Chromatogram)
     return df2_pivoted
 
+
 def set_folder(self, folder):
     """
     Set the folder for saving and loading files.
@@ -408,17 +409,21 @@ def _get_sample_uids(self, samples=None, seed=42):
         sample_uids = list(set(sample_uids))
         return sample_uids
 
+
 def get_orphans(self):
-    """ 
+    """
     Get all features that are not in the consensus mapping.
     """
-    not_in_consensus = self.features_df.filter(~self.features_df['feature_uid'].is_in(self.consensus_mapping_df['feature_uid'].to_list()))
+    not_in_consensus = self.features_df.filter(
+        ~self.features_df["feature_uid"].is_in(self.consensus_mapping_df["feature_uid"].to_list())
+    )
     return not_in_consensus
 
+
 def compress(self, features=True, ms2=True, chrom=False, ms2_max=5):
     """
     Perform compress_features, compress_ms2, and compress_chrom operations.
-    
+
     Parameters:
         max_replicates (int): Maximum number of MS2 replicates to keep per consensus_uid and energy combination
     """
@@ -441,48 +446,50 @@ def compress_features(self):
     if self.features_df is None or self.features_df.is_empty():
         self.logger.warning("No features_df found.")
         return
-    
+
     if self.consensus_mapping_df is None or self.consensus_mapping_df.is_empty():
         self.logger.warning("No consensus_mapping_df found.")
         return
-    
+
     initial_count = len(self.features_df)
-    
+
     # Get feature_uids that are associated with consensus features
     consensus_feature_uids = self.consensus_mapping_df["feature_uid"].to_list()
-    
+
     # Filter features_df to keep only features associated with consensus
     self.features_df = self.features_df.filter(
-        pl.col("feature_uid").is_in(consensus_feature_uids)
+        pl.col("feature_uid").is_in(consensus_feature_uids),
     )
-    
+
     # Set ms2_specs column to None if it exists
     if "ms2_specs" in self.features_df.columns:
         # Create a list of None values with the same length as the dataframe
         # This preserves the Object dtype instead of converting to Null
         none_values = [None] * len(self.features_df)
         self.features_df = self.features_df.with_columns(
-            pl.Series("ms2_specs", none_values, dtype=pl.Object)
+            pl.Series("ms2_specs", none_values, dtype=pl.Object),
         )
-    
+
     removed_count = initial_count - len(self.features_df)
-    self.logger.info(f"Compressed features: removed {removed_count} features not in consensus, cleared ms2_specs column")
+    self.logger.info(
+        f"Compressed features: removed {removed_count} features not in consensus, cleared ms2_specs column"
+    )
 
 
 def restore_features(self, samples=None, maps=False):
     """
-    Update specific columns (chrom, chrom_area, ms2_scans, ms2_specs) in features_df 
+    Update specific columns (chrom, chrom_area, ms2_scans, ms2_specs) in features_df
     from the corresponding samples by reading features_df from the sample5 file.
     Use the feature_id for matching.
 
     Parameters:
-        samples (list, optional): List of sample_uids or sample_names to restore. 
+        samples (list, optional): List of sample_uids or sample_names to restore.
                                  If None, restores all samples.
         maps (bool, optional): If True, also load featureXML data and update study.feature_maps.
     """
     import datetime
     from masster.sample.sample import Sample
-    
+
     if self.features_df is None or self.features_df.is_empty():
         self.logger.error("No features_df found in study.")
         return
@@ -499,8 +506,8 @@ def restore_features(self, samples=None, maps=False):
         return
 
     # Columns to update from sample data
-    columns_to_update = ['chrom', 'chrom_area', 'ms2_scans', 'ms2_specs']
-    
+    columns_to_update = ["chrom", "chrom_area", "ms2_scans", "ms2_specs"]
+
     self.logger.info(f"Restoring columns {columns_to_update} from {len(sample_uids)} samples...")
 
     # Create a mapping of (sample_uid, feature_id) to feature_uid from study.features_df
@@ -512,10 +519,12 @@ def restore_features(self, samples=None, maps=False):
 
     # Process each sample
     tqdm_disable = self.log_level not in ["TRACE", "DEBUG", "INFO"]
-    for sample_uid in tqdm(sample_uids, 
-                           unit="sample",
-                           disable=tqdm_disable,
-                           desc=f"{datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]} | INFO     | {self.log_label}Restoring samples"):
+    for sample_uid in tqdm(
+        sample_uids,
+        unit="sample",
+        disable=tqdm_disable,
+        desc=f"{datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]} | INFO     | {self.log_label}Restoring samples",
+    ):
         # Get sample info
         sample_row = self.samples_df.filter(pl.col("sample_uid") == sample_uid)
         if sample_row.is_empty():
@@ -534,7 +543,7 @@ def restore_features(self, samples=None, maps=False):
             # Load sample to get its features_df
             # Use a direct load call with map=False to prevent feature synchronization
             # which would remove filled features that don't exist in the original FeatureMap
-            sample = Sample(log_level='DEBUG')
+            sample = Sample(log_level="DEBUG")
             sample._load_sample5(sample_path, map=False)
 
             if sample.features_df is None or sample.features_df.is_empty():
@@ -547,34 +556,34 @@ def restore_features(self, samples=None, maps=False):
                 feature_id = row.get("feature_id")
                 if feature_id is None:
                     continue
-                    
+
                 key = (sample_uid, feature_id)
                 if key in study_feature_mapping:
                     feature_uid = study_feature_mapping[key]
-                    
+
                     # Update the specific columns in study.features_df
                     for col in columns_to_update:
                         if col in row and col in self.features_df.columns:
                             # Get the original column dtype to preserve it
                             original_dtype = self.features_df[col].dtype
-                            
+
                             # Update the specific row and column, preserving dtype
                             mask = (pl.col("feature_uid") == feature_uid) & (pl.col("sample_uid") == sample_uid)
-                            
+
                             # Handle object columns (like Chromatogram) differently
                             if original_dtype == pl.Object:
                                 self.features_df = self.features_df.with_columns(
                                     pl.when(mask)
                                     .then(pl.lit(row[col], dtype=original_dtype, allow_object=True))
                                     .otherwise(pl.col(col))
-                                    .alias(col)
+                                    .alias(col),
                                 )
                             else:
                                 self.features_df = self.features_df.with_columns(
                                     pl.when(mask)
                                     .then(pl.lit(row[col], dtype=original_dtype))
                                     .otherwise(pl.col(col))
-                                    .alias(col)
+                                    .alias(col),
                                 )
                     updates_made += 1
 
@@ -582,7 +591,7 @@ def restore_features(self, samples=None, maps=False):
 
             # If maps is True, load featureXML data
             if maps:
-                if hasattr(sample, 'feature_maps'):
+                if hasattr(sample, "feature_maps"):
                     self.feature_maps.extend(sample.feature_maps)
 
         except Exception as e:
@@ -595,14 +604,14 @@ def restore_features(self, samples=None, maps=False):
 def restore_chrom(self, samples=None, mz_tol=0.010, rt_tol=10.0):
     """
     Restore chromatograms from individual .sample5 files and gap-fill missing ones.
-    
+
     This function combines the functionality of restore_features() and fill_chrom():
     1. First restores chromatograms from individual .sample5 files (like restore_features)
     2. Then gap-fills any remaining empty chromatograms (like fill_chrom)
     3. ONLY updates the 'chrom' column, not chrom_area or other derived values
-    
+
     Parameters:
-        samples (list, optional): List of sample_uids or sample_names to process. 
+        samples (list, optional): List of sample_uids or sample_names to process.
                                  If None, processes all samples.
         mz_tol (float): m/z tolerance for gap filling (default: 0.010)
         rt_tol (float): RT tolerance for gap filling (default: 10.0)
@@ -611,7 +620,7 @@ def restore_chrom(self, samples=None, mz_tol=0.010, rt_tol=10.0):
     import numpy as np
     from masster.sample.sample import Sample
     from masster.chromatogram import Chromatogram
-    
+
     if self.features_df is None or self.features_df.is_empty():
         self.logger.error("No features_df found in study.")
         return
@@ -627,7 +636,7 @@ def restore_chrom(self, samples=None, mz_tol=0.010, rt_tol=10.0):
         return
 
     self.logger.info(f"Restoring chromatograms from {len(sample_uids)} samples...")
-    
+
     # Create mapping of (sample_uid, feature_id) to feature_uid
     study_feature_mapping = {}
     for row in self.features_df.iter_rows(named=True):
@@ -638,12 +647,13 @@ def restore_chrom(self, samples=None, mz_tol=0.010, rt_tol=10.0):
     # Phase 1: Restore from individual .sample5 files (like restore_features)
     restored_count = 0
     tqdm_disable = self.log_level not in ["TRACE", "DEBUG", "INFO"]
-    
+
     self.logger.info("Phase 1: Restoring chromatograms from .sample5 files...")
-    for sample_uid in tqdm(sample_uids, 
-                           desc=f"{datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]} | INFO     | {self.log_label}Restoring from samples",
-                           disable=tqdm_disable):
-        
+    for sample_uid in tqdm(
+        sample_uids,
+        desc=f"{datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]} | INFO     | {self.log_label}Restoring from samples",
+        disable=tqdm_disable,
+    ):
         # Get sample info
         sample_row = self.samples_df.filter(pl.col("sample_uid") == sample_uid)
         if sample_row.is_empty():
@@ -660,7 +670,7 @@ def restore_chrom(self, samples=None, mz_tol=0.010, rt_tol=10.0):
 
         try:
             # Load sample (with map=False to prevent feature synchronization)
-            sample = Sample(log_level='WARNING')
+            sample = Sample(log_level="WARNING")
             sample._load_sample5(sample_path, map=False)
 
             if sample.features_df is None or sample.features_df.is_empty():
@@ -671,21 +681,21 @@ def restore_chrom(self, samples=None, mz_tol=0.010, rt_tol=10.0):
             for row in sample.features_df.iter_rows(named=True):
                 feature_id = row.get("feature_id")
                 chrom = row.get("chrom")
-                
+
                 if feature_id is None or chrom is None:
                     continue
-                    
+
                 key = (sample_uid, feature_id)
                 if key in study_feature_mapping:
                     feature_uid = study_feature_mapping[key]
-                    
+
                     # Update only the chrom column
                     mask = (pl.col("feature_uid") == feature_uid) & (pl.col("sample_uid") == sample_uid)
                     self.features_df = self.features_df.with_columns(
                         pl.when(mask)
                         .then(pl.lit(chrom, dtype=pl.Object, allow_object=True))
                         .otherwise(pl.col("chrom"))
-                        .alias("chrom")
+                        .alias("chrom"),
                     )
                     restored_count += 1
 
@@ -694,20 +704,22 @@ def restore_chrom(self, samples=None, mz_tol=0.010, rt_tol=10.0):
             continue
 
     self.logger.info(f"Phase 1 complete: Restored {restored_count} chromatograms from .sample5 files")
-    
+
     # Phase 2: Gap-fill remaining empty chromatograms (like fill_chrom)
     self.logger.info("Phase 2: Gap-filling remaining empty chromatograms...")
-    
+
     # Count how many chromatograms are still missing
     empty_chroms = self.features_df.filter(pl.col("chrom").is_null()).height
     total_chroms = len(self.features_df)
-    
-    self.logger.debug(f"Chromatograms still missing: {empty_chroms}/{total_chroms} ({empty_chroms/total_chroms*100:.1f}%)")
-    
+
+    self.logger.debug(
+        f"Chromatograms still missing: {empty_chroms}/{total_chroms} ({empty_chroms / total_chroms * 100:.1f}%)"
+    )
+
     if empty_chroms == 0:
         self.logger.info("All chromatograms restored from .sample5 files. No gap-filling needed.")
         return
-    
+
     # Get consensus info for gap filling
     consensus_info = {}
     for row in self.consensus_df.iter_rows(named=True):
@@ -717,23 +729,23 @@ def restore_chrom(self, samples=None, mz_tol=0.010, rt_tol=10.0):
             "mz": row["mz"],
             "rt": row["rt"],
         }
-    
+
     filled_count = 0
-    
+
     # Process each sample that has missing chromatograms
-    for sample_uid in tqdm(sample_uids, 
-                           desc=f"{datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]} | INFO     | {self.log_label}Gap-filling missing chromatograms",
-                           disable=tqdm_disable):
-        
+    for sample_uid in tqdm(
+        sample_uids,
+        desc=f"{datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]} | INFO     | {self.log_label}Gap-filling missing chromatograms",
+        disable=tqdm_disable,
+    ):
         # Get features with missing chromatograms for this sample
         missing_features = self.features_df.filter(
-            (pl.col("sample_uid") == sample_uid) & 
-            (pl.col("chrom").is_null())
+            (pl.col("sample_uid") == sample_uid) & (pl.col("chrom").is_null()),
         )
-        
+
         if missing_features.is_empty():
             continue
-            
+
         # Get sample info
         sample_row = self.samples_df.filter(pl.col("sample_uid") == sample_uid)
         sample_info = sample_row.row(0, named=True)
@@ -745,10 +757,10 @@ def restore_chrom(self, samples=None, mz_tol=0.010, rt_tol=10.0):
 
         try:
             # Load sample for MS1 data extraction
-            sample = Sample(log_level='WARNING')
+            sample = Sample(log_level="WARNING")
             sample._load_sample5(sample_path, map=False)
 
-            if not hasattr(sample, 'ms1_df') or sample.ms1_df is None or sample.ms1_df.is_empty():
+            if not hasattr(sample, "ms1_df") or sample.ms1_df is None or sample.ms1_df.is_empty():
                 continue
 
             # Process each missing feature
@@ -758,15 +770,15 @@ def restore_chrom(self, samples=None, mz_tol=0.010, rt_tol=10.0):
                 rt = feature_row["rt"]
                 rt_start = feature_row.get("rt_start", rt - rt_tol)
                 rt_end = feature_row.get("rt_end", rt + rt_tol)
-                
+
                 # Extract EIC from MS1 data
                 d = sample.ms1_df.filter(
-                    (pl.col("mz") >= mz - mz_tol) &
-                    (pl.col("mz") <= mz + mz_tol) &
-                    (pl.col("rt") >= rt_start - rt_tol) &
-                    (pl.col("rt") <= rt_end + rt_tol)
+                    (pl.col("mz") >= mz - mz_tol)
+                    & (pl.col("mz") <= mz + mz_tol)
+                    & (pl.col("rt") >= rt_start - rt_tol)
+                    & (pl.col("rt") <= rt_end + rt_tol),
                 )
-                
+
                 # Create chromatogram
                 if d.is_empty():
                     # Create empty chromatogram
@@ -784,7 +796,7 @@ def restore_chrom(self, samples=None, mz_tol=0.010, rt_tol=10.0):
                 else:
                     # Create real chromatogram from data
                     eic_rt = d.group_by("rt").agg(pl.col("inty").max()).sort("rt")
-                    
+
                     if len(eic_rt) > 4:
                         eic = Chromatogram(
                             eic_rt["rt"].to_numpy(),
@@ -809,14 +821,14 @@ def restore_chrom(self, samples=None, mz_tol=0.010, rt_tol=10.0):
                             feature_end=rt_end,
                             feature_apex=rt,
                         )
-                
+
                 # Update the chromatogram in the study
                 mask = pl.col("feature_uid") == feature_uid
                 self.features_df = self.features_df.with_columns(
                     pl.when(mask)
                     .then(pl.lit(eic, dtype=pl.Object, allow_object=True))
                     .otherwise(pl.col("chrom"))
-                    .alias("chrom")
+                    .alias("chrom"),
                 )
                 filled_count += 1
 
@@ -825,12 +837,14 @@ def restore_chrom(self, samples=None, mz_tol=0.010, rt_tol=10.0):
             continue
 
     self.logger.info(f"Phase 2 complete: Gap-filled {filled_count} chromatograms")
-    
+
     # Final summary
     final_non_null = self.features_df.filter(pl.col("chrom").is_not_null()).height
     final_total = len(self.features_df)
-    
-    self.logger.info(f"Chromatogram restoration complete: {final_non_null}/{final_total} ({final_non_null/final_total*100:.1f}%)")
+
+    self.logger.info(
+        f"Chromatogram restoration complete: {final_non_null}/{final_total} ({final_non_null / final_total * 100:.1f}%)"
+    )
     self.logger.info(f"Restored from .sample5 files: {restored_count}, Gap-filled from raw data: {filled_count}")
 
 
@@ -839,41 +853,39 @@ def compress_ms2(self, max_replicates=5):
     Reduce the number of entries matching any pair of (consensus and energy) to max XY rows.
     Groups all rows by consensus_uid and energy. For each group, sort by number_frags * prec_inty,
     and then pick the top XY rows. Discard the others.
-    
+
     Parameters:
         max_replicates (int): Maximum number of replicates to keep per consensus_uid and energy combination
     """
     if self.consensus_ms2 is None or self.consensus_ms2.is_empty():
         self.logger.warning("No consensus_ms2 found.")
         return
-    
+
     initial_count = len(self.consensus_ms2)
-    
+
     # Create a ranking score based on number_frags * prec_inty
     # Handle None values by treating them as 0
     self.consensus_ms2 = self.consensus_ms2.with_columns([
-        (
-            pl.col("number_frags").fill_null(0) * 
-            pl.col("prec_inty").fill_null(0)
-        ).alias("ranking_score")
+        (pl.col("number_frags").fill_null(0) * pl.col("prec_inty").fill_null(0)).alias("ranking_score"),
     ])
-    
+
     # Group by consensus_uid and energy, then rank by score and keep top max_replicates
     compressed_ms2 = (
-        self.consensus_ms2
-        .with_row_count("row_id")  # Add row numbers for stable sorting
+        self.consensus_ms2.with_row_count("row_id")  # Add row numbers for stable sorting
         .sort(["consensus_uid", "energy", "ranking_score", "row_id"], descending=[False, False, True, False])
         .with_columns([
-            pl.int_range(pl.len()).over(["consensus_uid", "energy"]).alias("rank")
+            pl.int_range(pl.len()).over(["consensus_uid", "energy"]).alias("rank"),
         ])
         .filter(pl.col("rank") < max_replicates)
         .drop(["ranking_score", "row_id", "rank"])
     )
-    
+
     self.consensus_ms2 = compressed_ms2
-    
+
     removed_count = initial_count - len(self.consensus_ms2)
-    self.logger.info(f"Compressed MS2 data: removed {removed_count} entries, kept max {max_replicates} per consensus/energy pair")
+    self.logger.info(
+        f"Compressed MS2 data: removed {removed_count} entries, kept max {max_replicates} per consensus/energy pair"
+    )
 
 
 def compress_chrom(self):
@@ -886,49 +898,49 @@ def compress_chrom(self):
     if self.features_df is None or self.features_df.is_empty():
         self.logger.warning("No features_df found.")
         return
-    
+
     if "chrom" not in self.features_df.columns:
         self.logger.warning("No 'chrom' column found in features_df.")
         return
-    
+
     # Count non-null chromatograms before compression
     non_null_count = self.features_df.filter(pl.col("chrom").is_not_null()).height
-    
+
     # Set chrom column to None while keeping dtype as object
     self.features_df = self.features_df.with_columns(
-        pl.lit(None, dtype=pl.Object).alias("chrom")
+        pl.lit(None, dtype=pl.Object).alias("chrom"),
     )
-    
+
     self.logger.info(f"Compressed chromatograms: cleared {non_null_count} chromatogram objects from features_df")
 
 
 def set_source(self, filename):
     """
-    Reassign file_source for all samples in samples_df. If filename contains only a path, 
-    keep the current basename and build an absolute path. Check that the new file exists 
+    Reassign file_source for all samples in samples_df. If filename contains only a path,
+    keep the current basename and build an absolute path. Check that the new file exists
     before overwriting the old file_source.
-    
+
     Parameters:
         filename (str): New file path or directory path for all samples
-    
+
     Returns:
         None
     """
     import os
-    
+
     if self.samples_df is None or len(self.samples_df) == 0:
         self.logger.warning("No samples found in study.")
         return
-    
+
     updated_count = 0
     failed_count = 0
-    
+
     # Get all current file_source values
     current_sources = self.samples_df.get_column("file_source").to_list()
     sample_names = self.samples_df.get_column("sample_name").to_list()
-    
+
     new_sources = []
-    
+
     for i, (current_source, sample_name) in enumerate(zip(current_sources, sample_names)):
         # Check if filename is just a directory path
         if os.path.isdir(filename):
@@ -937,7 +949,7 @@ def set_source(self, filename):
                 new_sources.append(current_source)
                 failed_count += 1
                 continue
-            
+
             # Get the basename from current file_source
             current_basename = os.path.basename(current_source)
             # Build new absolute path
@@ -945,26 +957,26 @@ def set_source(self, filename):
         else:
             # filename is a full path, make it absolute
             new_file_path = os.path.abspath(filename)
-        
+
         # Check if the new file exists
         if not os.path.exists(new_file_path):
             self.logger.warning(f"File does not exist for sample '{sample_name}': {new_file_path}")
             new_sources.append(current_source)
             failed_count += 1
             continue
-        
+
         # File exists, update source
         new_sources.append(new_file_path)
         updated_count += 1
-        
+
         # Log individual updates at debug level
         self.logger.debug(f"Updated file_source for sample '{sample_name}': {current_source} -> {new_file_path}")
-    
+
     # Update the samples_df with new file_source values
     self.samples_df = self.samples_df.with_columns(
-        pl.Series("file_source", new_sources).alias("file_source")
+        pl.Series("file_source", new_sources).alias("file_source"),
     )
-    
+
     # Log summary
     if updated_count > 0:
         self.logger.info(f"Updated file_source for {updated_count} samples")
@@ -990,9 +1002,9 @@ def features_select(
 ):
     """
     Select features from features_df based on specified criteria and return the filtered DataFrame.
-    
+
     OPTIMIZED VERSION: Combines all filters into a single operation for better performance.
-    
+
     Parameters:
         mz: m/z range filter (tuple for range, single value for minimum)
         rt: retention time range filter (tuple for range, single value for minimum)
@@ -1007,30 +1019,42 @@ def features_select(
         chrom_prominence: chromatogram prominence filter (tuple for range, single value for minimum)
         chrom_prominence_scaled: scaled chromatogram prominence filter (tuple for range, single value for minimum)
         chrom_height_scaled: scaled chromatogram height filter (tuple for range, single value for minimum)
-    
+
     Returns:
         polars.DataFrame: Filtered features DataFrame
     """
     if self.features_df is None or self.features_df.is_empty():
         self.logger.warning("No features found in study.")
         return pl.DataFrame()
-    
+
     # Early return if no filters provided - performance optimization
-    filter_params = [mz, rt, inty, sample_uid, sample_name, consensus_uid, 
-                     feature_uid, filled, quality, chrom_coherence, 
-                     chrom_prominence, chrom_prominence_scaled, chrom_height_scaled]
+    filter_params = [
+        mz,
+        rt,
+        inty,
+        sample_uid,
+        sample_name,
+        consensus_uid,
+        feature_uid,
+        filled,
+        quality,
+        chrom_coherence,
+        chrom_prominence,
+        chrom_prominence_scaled,
+        chrom_height_scaled,
+    ]
     if all(param is None for param in filter_params):
         return self.features_df.clone()
-    
+
     initial_count = len(self.features_df)
-    
+
     # Pre-check available columns once for efficiency
     available_columns = set(self.features_df.columns)
-    
+
     # Build all filter conditions first, then apply them all at once
     filter_conditions = []
     warnings = []
-    
+
     # Filter by m/z
     if mz is not None:
         if isinstance(mz, tuple) and len(mz) == 2:
@@ -1038,7 +1062,7 @@ def features_select(
             filter_conditions.append((pl.col("mz") >= min_mz) & (pl.col("mz") <= max_mz))
         else:
             filter_conditions.append(pl.col("mz") >= mz)
-    
+
     # Filter by retention time
     if rt is not None:
         if isinstance(rt, tuple) and len(rt) == 2:
@@ -1046,7 +1070,7 @@ def features_select(
             filter_conditions.append((pl.col("rt") >= min_rt) & (pl.col("rt") <= max_rt))
         else:
             filter_conditions.append(pl.col("rt") >= rt)
-    
+
     # Filter by intensity
     if inty is not None:
         if isinstance(inty, tuple) and len(inty) == 2:
@@ -1054,7 +1078,7 @@ def features_select(
             filter_conditions.append((pl.col("inty") >= min_inty) & (pl.col("inty") <= max_inty))
         else:
             filter_conditions.append(pl.col("inty") >= inty)
-    
+
     # Filter by sample_uid
     if sample_uid is not None:
         if isinstance(sample_uid, (list, tuple)):
@@ -1067,24 +1091,24 @@ def features_select(
                 filter_conditions.append(pl.col("sample_uid").is_in(sample_uid))
         else:
             filter_conditions.append(pl.col("sample_uid") == sample_uid)
-    
+
     # Filter by sample_name (requires pre-processing)
     if sample_name is not None:
         # Get sample_uids for the given sample names
         if isinstance(sample_name, list):
             sample_uids_for_names = self.samples_df.filter(
-                pl.col("sample_name").is_in(sample_name)
+                pl.col("sample_name").is_in(sample_name),
             )["sample_uid"].to_list()
         else:
             sample_uids_for_names = self.samples_df.filter(
-                pl.col("sample_name") == sample_name
+                pl.col("sample_name") == sample_name,
             )["sample_uid"].to_list()
-        
+
         if sample_uids_for_names:
             filter_conditions.append(pl.col("sample_uid").is_in(sample_uids_for_names))
         else:
             filter_conditions.append(pl.lit(False))  # No matching samples
-    
+
     # Filter by consensus_uid
     if consensus_uid is not None:
         if isinstance(consensus_uid, (list, tuple)):
@@ -1097,7 +1121,7 @@ def features_select(
                 filter_conditions.append(pl.col("consensus_uid").is_in(consensus_uid))
         else:
             filter_conditions.append(pl.col("consensus_uid") == consensus_uid)
-    
+
     # Filter by feature_uid
     if feature_uid is not None:
         if isinstance(feature_uid, (list, tuple)):
@@ -1110,7 +1134,7 @@ def features_select(
                 filter_conditions.append(pl.col("feature_uid").is_in(feature_uid))
         else:
             filter_conditions.append(pl.col("feature_uid") == feature_uid)
-    
+
     # Filter by filled status
     if filled is not None:
         if "filled" in available_columns:
@@ -1120,7 +1144,7 @@ def features_select(
                 filter_conditions.append(~pl.col("filled") | pl.col("filled").is_null())
         else:
             warnings.append("'filled' column not found in features_df")
-    
+
     # Filter by quality
     if quality is not None:
         if "quality" in available_columns:
@@ -1131,73 +1155,83 @@ def features_select(
                 filter_conditions.append(pl.col("quality") >= quality)
         else:
             warnings.append("'quality' column not found in features_df")
-    
+
     # Filter by chromatogram coherence
     if chrom_coherence is not None:
         if "chrom_coherence" in available_columns:
             if isinstance(chrom_coherence, tuple) and len(chrom_coherence) == 2:
                 min_coherence, max_coherence = chrom_coherence
-                filter_conditions.append((pl.col("chrom_coherence") >= min_coherence) & (pl.col("chrom_coherence") <= max_coherence))
+                filter_conditions.append(
+                    (pl.col("chrom_coherence") >= min_coherence) & (pl.col("chrom_coherence") <= max_coherence)
+                )
             else:
                 filter_conditions.append(pl.col("chrom_coherence") >= chrom_coherence)
         else:
             warnings.append("'chrom_coherence' column not found in features_df")
-    
+
     # Filter by chromatogram prominence
     if chrom_prominence is not None:
         if "chrom_prominence" in available_columns:
             if isinstance(chrom_prominence, tuple) and len(chrom_prominence) == 2:
                 min_prominence, max_prominence = chrom_prominence
-                filter_conditions.append((pl.col("chrom_prominence") >= min_prominence) & (pl.col("chrom_prominence") <= max_prominence))
+                filter_conditions.append(
+                    (pl.col("chrom_prominence") >= min_prominence) & (pl.col("chrom_prominence") <= max_prominence)
+                )
             else:
                 filter_conditions.append(pl.col("chrom_prominence") >= chrom_prominence)
         else:
             warnings.append("'chrom_prominence' column not found in features_df")
-    
+
     # Filter by scaled chromatogram prominence
     if chrom_prominence_scaled is not None:
         if "chrom_prominence_scaled" in available_columns:
             if isinstance(chrom_prominence_scaled, tuple) and len(chrom_prominence_scaled) == 2:
                 min_prominence_scaled, max_prominence_scaled = chrom_prominence_scaled
-                filter_conditions.append((pl.col("chrom_prominence_scaled") >= min_prominence_scaled) & (pl.col("chrom_prominence_scaled") <= max_prominence_scaled))
+                filter_conditions.append(
+                    (pl.col("chrom_prominence_scaled") >= min_prominence_scaled)
+                    & (pl.col("chrom_prominence_scaled") <= max_prominence_scaled)
+                )
             else:
                 filter_conditions.append(pl.col("chrom_prominence_scaled") >= chrom_prominence_scaled)
         else:
             warnings.append("'chrom_prominence_scaled' column not found in features_df")
-    
+
     # Filter by scaled chromatogram height
     if chrom_height_scaled is not None:
         if "chrom_height_scaled" in available_columns:
             if isinstance(chrom_height_scaled, tuple) and len(chrom_height_scaled) == 2:
                 min_height_scaled, max_height_scaled = chrom_height_scaled
-                filter_conditions.append((pl.col("chrom_height_scaled") >= min_height_scaled) & (pl.col("chrom_height_scaled") <= max_height_scaled))
+                filter_conditions.append(
+                    (pl.col("chrom_height_scaled") >= min_height_scaled)
+                    & (pl.col("chrom_height_scaled") <= max_height_scaled)
+                )
             else:
                 filter_conditions.append(pl.col("chrom_height_scaled") >= chrom_height_scaled)
         else:
             warnings.append("'chrom_height_scaled' column not found in features_df")
-    
+
     # Log all warnings once at the end for efficiency
     for warning in warnings:
         self.logger.warning(warning)
-    
+
     # Apply all filters at once using lazy evaluation for optimal performance
     if filter_conditions:
         # Combine all conditions with AND
         combined_filter = filter_conditions[0]
         for condition in filter_conditions[1:]:
             combined_filter = combined_filter & condition
-        
+
         # Apply the combined filter using lazy evaluation
         feats = self.features_df.lazy().filter(combined_filter).collect()
     else:
         feats = self.features_df.clone()
-    
+
     final_count = len(feats)
-    
+
     if final_count == 0:
         self.logger.warning("No features remaining after applying selection criteria.")
     else:
-        #removed_count = initial_count - final_count
+        # removed_count = initial_count - final_count
         self.logger.info(f"Features selected: {final_count} (out of {initial_count})")
 
     return feats
@@ -1207,29 +1241,29 @@ def features_filter(self, features):
     """
     Filter features_df by keeping only features that match the given criteria.
     This keeps only the specified features and removes all others.
-    
+
     OPTIMIZED VERSION: Batch operations and reduced overhead for better performance.
-    
+
     Parameters:
         features: Features to keep. Can be:
                  - polars.DataFrame: Features DataFrame (will use feature_uid column)
                  - list: List of feature_uids to keep
                  - int: Single feature_uid to keep
-    
+
     Returns:
         None (modifies self.features_df in place)
     """
     if self.features_df is None or self.features_df.is_empty():
         self.logger.warning("No features found in study.")
         return
-    
+
     # Early return if no features provided
     if features is None:
         self.logger.warning("No features provided for filtering.")
         return
-    
+
     initial_count = len(self.features_df)
-    
+
     # Determine feature_uids to keep - optimized type checking
     if isinstance(features, pl.DataFrame):
         if "feature_uid" not in features.columns:
@@ -1243,44 +1277,41 @@ def features_filter(self, features):
     else:
         self.logger.error("features parameter must be a DataFrame, list, tuple, or int")
         return
-    
+
     # Early return if no UIDs to keep
     if not feature_uids_to_keep:
         self.logger.warning("No feature UIDs provided for filtering.")
         return
-    
+
     # Convert to set for faster lookup if list is large
     if len(feature_uids_to_keep) > 100:
         feature_uids_set = set(feature_uids_to_keep)
         # Use the set for filtering if it's significantly smaller
         if len(feature_uids_set) < len(feature_uids_to_keep) * 0.8:
             feature_uids_to_keep = list(feature_uids_set)
-    
+
     # Create filter condition once - keep only the specified features
     filter_condition = pl.col("feature_uid").is_in(feature_uids_to_keep)
-    
+
     # Apply filter to features_df using lazy evaluation for better performance
     self.features_df = self.features_df.lazy().filter(filter_condition).collect()
-    
+
     # Apply filter to consensus_mapping_df if it exists - batch operation
     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
-            .lazy()
-            .filter(filter_condition)
-            .collect()
-        )
+        self.consensus_mapping_df = self.consensus_mapping_df.lazy().filter(filter_condition).collect()
         mapping_removed_count = initial_mapping_count - len(self.consensus_mapping_df)
-    
+
     # Calculate results once and log efficiently
     final_count = len(self.features_df)
     removed_count = initial_count - final_count
-    
+
     # Single comprehensive log message
     if mapping_removed_count > 0:
-        self.logger.info(f"Kept {final_count} features and removed {mapping_removed_count} consensus mappings. Filtered out {removed_count} features.")
+        self.logger.info(
+            f"Kept {final_count} features and removed {mapping_removed_count} consensus mappings. Filtered out {removed_count} features."
+        )
     else:
         self.logger.info(f"Kept {final_count} features. Filtered out {removed_count} features.")
 
@@ -1289,27 +1320,27 @@ def features_delete(self, features):
     """
     Delete features from features_df based on feature identifiers.
     This removes the specified features and keeps all others (opposite of features_filter).
-    
+
     Parameters:
         features: Features to delete. Can be:
                  - polars.DataFrame: Features DataFrame (will use feature_uid column)
                  - list: List of feature_uids to delete
                  - int: Single feature_uid to delete
-    
+
     Returns:
         None (modifies self.features_df in place)
     """
     if self.features_df is None or self.features_df.is_empty():
         self.logger.warning("No features found in study.")
         return
-    
+
     # Early return if no features provided
     if features is None:
         self.logger.warning("No features provided for deletion.")
         return
-    
+
     initial_count = len(self.features_df)
-    
+
     # Determine feature_uids to remove - optimized type checking
     if isinstance(features, pl.DataFrame):
         if "feature_uid" not in features.columns:
@@ -1323,44 +1354,41 @@ def features_delete(self, features):
     else:
         self.logger.error("features parameter must be a DataFrame, list, tuple, or int")
         return
-    
+
     # Early return if no UIDs to remove
     if not feature_uids_to_remove:
         self.logger.warning("No feature UIDs provided for deletion.")
         return
-    
+
     # Convert to set for faster lookup if list is large
     if len(feature_uids_to_remove) > 100:
         feature_uids_set = set(feature_uids_to_remove)
         # Use the set for filtering if it's significantly smaller
         if len(feature_uids_set) < len(feature_uids_to_remove) * 0.8:
             feature_uids_to_remove = list(feature_uids_set)
-    
+
     # Create filter condition - remove specified features
     filter_condition = ~pl.col("feature_uid").is_in(feature_uids_to_remove)
-    
+
     # Apply filter to features_df using lazy evaluation for better performance
     self.features_df = self.features_df.lazy().filter(filter_condition).collect()
-    
+
     # Apply filter to consensus_mapping_df if it exists - batch operation
     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
-            .lazy()
-            .filter(filter_condition)
-            .collect()
-        )
+        self.consensus_mapping_df = self.consensus_mapping_df.lazy().filter(filter_condition).collect()
         mapping_removed_count = initial_mapping_count - len(self.consensus_mapping_df)
-    
+
     # Calculate results once and log efficiently
     final_count = len(self.features_df)
     removed_count = initial_count - final_count
-    
+
     # Single comprehensive log message
     if mapping_removed_count > 0:
-        self.logger.info(f"Deleted {removed_count} features and {mapping_removed_count} consensus mappings. Remaining features: {final_count}")
+        self.logger.info(
+            f"Deleted {removed_count} features and {mapping_removed_count} consensus mappings. Remaining features: {final_count}"
+        )
     else:
         self.logger.info(f"Deleted {removed_count} features. Remaining features: {final_count}")
 
@@ -1384,7 +1412,7 @@ def consensus_select(
 ):
     """
     Select consensus features from consensus_df based on specified criteria and return the filtered DataFrame.
-    
+
     Parameters:
         mz: m/z range filter (tuple for range, single value for minimum)
         rt: retention time range filter (tuple for range, single value for minimum)
@@ -1400,17 +1428,17 @@ 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)
-    
+
     Returns:
         polars.DataFrame: Filtered consensus DataFrame
     """
     if self.consensus_df is None or self.consensus_df.is_empty():
         self.logger.warning("No consensus features found in study.")
         return pl.DataFrame()
-    
+
     consensus = self.consensus_df.clone()
     initial_count = len(consensus)
-    
+
     # Filter by m/z
     if mz is not None:
         consensus_len_before_filter = len(consensus)
@@ -1420,9 +1448,9 @@ def consensus_select(
         else:
             consensus = consensus.filter(pl.col("mz") >= mz)
         self.logger.debug(
-            f"Selected consensus by mz. Consensus removed: {consensus_len_before_filter - len(consensus)}"
+            f"Selected consensus by mz. Consensus removed: {consensus_len_before_filter - len(consensus)}",
         )
-    
+
     # Filter by retention time
     if rt is not None:
         consensus_len_before_filter = len(consensus)
@@ -1432,9 +1460,9 @@ def consensus_select(
         else:
             consensus = consensus.filter(pl.col("rt") >= rt)
         self.logger.debug(
-            f"Selected consensus by rt. Consensus removed: {consensus_len_before_filter - len(consensus)}"
+            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)
@@ -1444,9 +1472,9 @@ def consensus_select(
         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)}"
+            f"Selected consensus by inty_mean. Consensus removed: {consensus_len_before_filter - len(consensus)}",
         )
-    
+
     # Filter by consensus_uid
     if consensus_uid is not None:
         consensus_len_before_filter = len(consensus)
@@ -1454,16 +1482,18 @@ def consensus_select(
             if len(consensus_uid) == 2 and not isinstance(consensus_uid, list):
                 # Treat as range
                 min_uid, max_uid = consensus_uid
-                consensus = consensus.filter((pl.col("consensus_uid") >= min_uid) & (pl.col("consensus_uid") <= max_uid))
+                consensus = consensus.filter(
+                    (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))
         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)}"
+            f"Selected consensus by consensus_uid. Consensus removed: {consensus_len_before_filter - len(consensus)}",
         )
-    
+
     # Filter by consensus_id
     if consensus_id is not None:
         consensus_len_before_filter = len(consensus)
@@ -1472,21 +1502,23 @@ def consensus_select(
         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)}"
+            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))
+            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)}"
+            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)
@@ -1499,9 +1531,9 @@ def consensus_select(
         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)}"
+            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)
@@ -1511,9 +1543,9 @@ def consensus_select(
         else:
             consensus = consensus.filter(pl.col("quality") >= quality)
         self.logger.debug(
-            f"Selected consensus by quality. Consensus removed: {consensus_len_before_filter - len(consensus)}"
+            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)
@@ -1526,89 +1558,103 @@ def consensus_select(
         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)}"
+            f"Selected consensus by bl. Consensus removed: {consensus_len_before_filter - len(consensus)}",
         )
-    
+
     # 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))
+                consensus = consensus.filter(
+                    (pl.col("chrom_coherence_mean") >= min_coherence)
+                    & (pl.col("chrom_coherence_mean") <= max_coherence)
+                )
             else:
                 consensus = consensus.filter(pl.col("chrom_coherence_mean") >= chrom_coherence_mean)
         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)}"
+            f"Selected consensus by chrom_coherence_mean. Consensus removed: {consensus_len_before_filter - len(consensus)}",
         )
-    
+
     # 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))
+                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)}"
+            f"Selected consensus by chrom_prominence_mean. Consensus removed: {consensus_len_before_filter - len(consensus)}",
         )
-    
+
     # 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))
+                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)}"
+            f"Selected consensus by chrom_prominence_scaled_mean. Consensus removed: {consensus_len_before_filter - len(consensus)}",
         )
-    
+
     # 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))
+                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)}"
+            f"Selected consensus by chrom_height_scaled_mean. Consensus removed: {consensus_len_before_filter - 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))
+                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)}"
+            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})")
-    
+
     return consensus
 
 
@@ -1616,22 +1662,22 @@ 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.
-    
+
     Parameters:
         consensus: Consensus features to remove. Can be:
                   - polars.DataFrame: Consensus DataFrame (will use consensus_uid column)
                   - list: List of consensus_uids to remove
                   - int: Single consensus_uid to remove
-    
+
     Returns:
         None (modifies self.consensus_df and related DataFrames in place)
     """
     if self.consensus_df is None or self.consensus_df.is_empty():
         self.logger.warning("No consensus features found in study.")
         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:
@@ -1645,68 +1691,70 @@ def consensus_filter(self, 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 filtering.")
         return
-    
+
     # 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)
+            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)
+        ~pl.col("consensus_uid").is_in(consensus_uids_to_remove),
     )
-    
+
     # Remove from 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_remove),
         )
         removed_mapping_count = initial_mapping_count - len(self.consensus_mapping_df)
         if removed_mapping_count > 0:
             self.logger.debug(f"Removed {removed_mapping_count} entries from consensus_mapping_df")
-    
+
     # Remove corresponding features from features_df
     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)
+            ~pl.col("feature_uid").is_in(feature_uids_to_remove),
         )
         removed_features_count = initial_features_count - len(self.features_df)
         if removed_features_count > 0:
             self.logger.debug(f"Removed {removed_features_count} entries from features_df")
-    
+
     # Remove from consensus_ms2 if it exists
-    if hasattr(self, 'consensus_ms2') and self.consensus_ms2 is not None and not self.consensus_ms2.is_empty():
+    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)
+            ~pl.col("consensus_uid").is_in(consensus_uids_to_remove),
         )
         removed_ms2_count = initial_ms2_count - len(self.consensus_ms2)
         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)
-    self.logger.info(f"Filtered {removed_consensus_count} consensus features. Remaining consensus: {len(self.consensus_df)}")
+    self.logger.info(
+        f"Filtered {removed_consensus_count} consensus features. Remaining consensus: {len(self.consensus_df)}"
+    )
 
 
 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.
-    
+
     Parameters:
         consensus: Consensus features to delete. Can be:
                   - polars.DataFrame: Consensus DataFrame (will use consensus_uid column)
                   - list: List of consensus_uids to delete
                   - int: Single consensus_uid to delete
-    
+
     Returns:
         None (modifies self.consensus_df and related DataFrames in place)
     """