masster 0.4.0__py3-none-any.whl → 0.4.1__py3-none-any.whl

masster/study/processing.py

@@ -8,7 +8,7 @@ import pyopenms as oms
 
 from tqdm import tqdm
 
-from master.study.defaults import (
+from masster.study.defaults import (
     align_defaults,
     find_ms2_defaults,
     integrate_defaults,
@@ -115,8 +115,7 @@ def align(self, **kwargs):
     # Pre-build sample_uid lookup for faster access
     self.logger.debug("Build sample_uid lookup for fast access...")
     sample_uid_lookup = {
-        idx: row_dict["sample_uid"]
-        for idx, row_dict in enumerate(self.samples_df.iter_rows(named=True))
+        idx: row_dict["sample_uid"] for idx, row_dict in enumerate(self.samples_df.iter_rows(named=True))
     }
 
     # Build the main lookup using feature_uid (not feature_id)
@@ -216,7 +215,7 @@ def align(self, **kwargs):
         self.features_df = self.features_df.with_columns(*new_cols)
 
     self.logger.debug("Alignment completed successfully.")
-
+    
     # Reset consensus data structures after alignment since RT changes invalidate consensus
     consensus_reset_count = 0
     if not self.consensus_df.is_empty():
@@ -228,7 +227,7 @@ def align(self, **kwargs):
     if not self.consensus_ms2.is_empty():
         self.consensus_ms2 = pl.DataFrame()
         consensus_reset_count += 1
-
+    
     # Remove merge and find_ms2 parameters from history since they need to be re-run
     keys_to_remove = ["merge", "find_ms2"]
     history_removed_count = 0
@@ -238,11 +237,9 @@ def align(self, **kwargs):
                 del self.history[key]
                 history_removed_count += 1
                 self.logger.debug(f"Removed {key} from history")
-
+    
     if consensus_reset_count > 0 or history_removed_count > 0:
-        self.logger.info(
-            f"Alignment reset: {consensus_reset_count} consensus structures cleared, {history_removed_count} history entries removed",
-        )
+        self.logger.info(f"Alignment reset: {consensus_reset_count} consensus structures cleared, {history_removed_count} history entries removed")
 
     if params.get("save_features"):
         self.save_samples()
@@ -293,10 +290,7 @@ def merge(self, **kwargs):
     algorithm = params.get("algorithm")
     min_samples = params.get("min_samples")
     link_ms2 = params.get("link_ms2")
-    mz_tol = kwargs.get(
-        "mz_tol",
-        0.01,
-    )  # Default values for parameters not in defaults class
+    mz_tol = kwargs.get("mz_tol", 0.01)  # Default values for parameters not in defaults class
     rt_tol = kwargs.get("rt_tol", 1.0)
 
     if len(self.samples_df) > 200 and algorithm == "qt":
@@ -405,10 +399,7 @@ def merge(self, **kwargs):
                 consensus_map.setUniqueIds()
 
     # create a dict to map uid to feature_uid using self.features_df
-    feature_uid_map = {
-        row["feature_id"]: row["feature_uid"]
-        for row in self.features_df.iter_rows(named=True)
-    }
+    feature_uid_map = {row["feature_id"]: row["feature_uid"] for row in self.features_df.iter_rows(named=True)}
     imax = consensus_map.size()
 
     # Pre-build fast lookup tables for features_df data
@@ -435,9 +426,7 @@ def merge(self, **kwargs):
 
     for row in self.features_df.iter_rows(named=True):
         feature_uid = row["feature_uid"]
-        features_lookup[feature_uid] = {
-            col: row[col] for col in feature_columns if col in self.features_df.columns
-        }
+        features_lookup[feature_uid] = {col: row[col] for col in feature_columns if col in self.features_df.columns}
 
     # create a list to store the consensus mapping
     consensus_mapping = []
@@ -464,13 +453,11 @@ def merge(self, **kwargs):
                 # this is a feature that was removed but is still in the feature maps
                 continue
             fuid = feature_uid_map[fuid]
-            consensus_mapping.append(
-                {
-                    "consensus_uid": i,
-                    "sample_uid": f.getMapIndex() + 1,
-                    "feature_uid": fuid,
-                },
-            )
+            consensus_mapping.append({
+                "consensus_uid": i,
+                "sample_uid": f.getMapIndex() + 1,
+                "feature_uid": fuid,
+            })
             uids.append(fuid)
 
             # Get feature data from lookup instead of DataFrame filtering
@@ -484,99 +471,43 @@ def merge(self, **kwargs):
 
         # Compute statistics using vectorized operations on collected data
         # Convert to numpy arrays for faster computation
-        rt_values = np.array(
-            [fd.get("rt", 0) for fd in feature_data_list if fd.get("rt") is not None],
-        )
-        mz_values = np.array(
-            [fd.get("mz", 0) for fd in feature_data_list if fd.get("mz") is not None],
-        )
-        rt_start_values = np.array(
-            [
-                fd.get("rt_start", 0)
-                for fd in feature_data_list
-                if fd.get("rt_start") is not None
-            ],
-        )
-        rt_end_values = np.array(
-            [
-                fd.get("rt_end", 0)
-                for fd in feature_data_list
-                if fd.get("rt_end") is not None
-            ],
-        )
-        rt_delta_values = np.array(
-            [
-                fd.get("rt_delta", 0)
-                for fd in feature_data_list
-                if fd.get("rt_delta") is not None
-            ],
-        )
-        mz_start_values = np.array(
-            [
-                fd.get("mz_start", 0)
-                for fd in feature_data_list
-                if fd.get("mz_start") is not None
-            ],
-        )
-        mz_end_values = np.array(
-            [
-                fd.get("mz_end", 0)
-                for fd in feature_data_list
-                if fd.get("mz_end") is not None
-            ],
-        )
-        inty_values = np.array(
-            [
-                fd.get("inty", 0)
-                for fd in feature_data_list
-                if fd.get("inty") is not None
-            ],
-        )
-        coherence_values = np.array(
-            [
-                fd.get("chrom_coherence", 0)
-                for fd in feature_data_list
-                if fd.get("chrom_coherence") is not None
-            ],
-        )
-        prominence_values = np.array(
-            [
-                fd.get("chrom_prominence", 0)
-                for fd in feature_data_list
-                if fd.get("chrom_prominence") is not None
-            ],
-        )
-        prominence_scaled_values = np.array(
-            [
-                fd.get("chrom_prominence_scaled", 0)
-                for fd in feature_data_list
-                if fd.get("chrom_prominence_scaled") is not None
-            ],
-        )
-        height_scaled_values = np.array(
-            [
-                fd.get("chrom_height_scaled", 0)
-                for fd in feature_data_list
-                if fd.get("chrom_height_scaled") is not None
-            ],
-        )
-        iso_values = np.array(
-            [fd.get("iso", 0) for fd in feature_data_list if fd.get("iso") is not None],
-        )
-        charge_values = np.array(
-            [
-                fd.get("charge", 0)
-                for fd in feature_data_list
-                if fd.get("charge") is not None
-            ],
-        )
+        rt_values = np.array([fd.get("rt", 0) for fd in feature_data_list if fd.get("rt") is not None])
+        mz_values = np.array([fd.get("mz", 0) for fd in feature_data_list if fd.get("mz") is not None])
+        rt_start_values = np.array([
+            fd.get("rt_start", 0) for fd in feature_data_list if fd.get("rt_start") is not None
+        ])
+        rt_end_values = np.array([fd.get("rt_end", 0) for fd in feature_data_list if fd.get("rt_end") is not None])
+        rt_delta_values = np.array([
+            fd.get("rt_delta", 0) for fd in feature_data_list if fd.get("rt_delta") is not None
+        ])
+        mz_start_values = np.array([
+            fd.get("mz_start", 0) for fd in feature_data_list if fd.get("mz_start") is not None
+        ])
+        mz_end_values = np.array([fd.get("mz_end", 0) for fd in feature_data_list if fd.get("mz_end") is not None])
+        inty_values = np.array([fd.get("inty", 0) for fd in feature_data_list if fd.get("inty") is not None])
+        coherence_values = np.array([
+            fd.get("chrom_coherence", 0) for fd in feature_data_list if fd.get("chrom_coherence") is not None
+        ])
+        prominence_values = np.array([
+            fd.get("chrom_prominence", 0) for fd in feature_data_list if fd.get("chrom_prominence") is not None
+        ])
+        prominence_scaled_values = np.array([
+            fd.get("chrom_prominence_scaled", 0)
+            for fd in feature_data_list
+            if fd.get("chrom_prominence_scaled") is not None
+        ])
+        height_scaled_values = np.array([
+            fd.get("chrom_height_scaled", 0) for fd in feature_data_list if fd.get("chrom_height_scaled") is not None
+        ])
+        iso_values = np.array([fd.get("iso", 0) for fd in feature_data_list if fd.get("iso") is not None])
+        charge_values = np.array([fd.get("charge", 0) for fd in feature_data_list if fd.get("charge") is not None])
 
         # adduct_values
         # Collect all adducts from feature_data_list to create consensus adduct information
         # Only consider adducts that are in study._get_adducts() plus items with '?'
         all_adducts = []
         adduct_masses = {}
-
+        
         # Get valid adducts from study._get_adducts()
         valid_adducts = set()
         try:
@@ -585,7 +516,7 @@ def merge(self, **kwargs):
                 valid_adducts.update(study_adducts_df["name"].to_list())
         except Exception as e:
             self.logger.warning(f"Could not retrieve study adducts: {e}")
-
+        
         # Always allow '?' adducts
         valid_adducts.add("?")
 
@@ -596,7 +527,7 @@ def merge(self, **kwargs):
 
             if adduct is not None:
                 # Only include adducts that are valid (from study._get_adducts() or contain '?')
-                if adduct in valid_adducts or "?" in adduct:
+                if adduct in valid_adducts or '?' in adduct:
                     all_adducts.append(adduct)
                     if adduct_mass is not None:
                         adduct_masses[adduct] = adduct_mass
@@ -604,37 +535,33 @@ def merge(self, **kwargs):
         # Calculate adduct_values for the consensus feature
         adduct_values = []
         if all_adducts:
-            adduct_counts = {
-                adduct: all_adducts.count(adduct) for adduct in set(all_adducts)
-            }
+            adduct_counts = {adduct: all_adducts.count(adduct) for adduct in set(all_adducts)}
             total_count = sum(adduct_counts.values())
             for adduct, count in adduct_counts.items():
                 percentage = (count / total_count) * 100 if total_count > 0 else 0
                 mass = adduct_masses.get(adduct, None)
                 # Store as list with [name, num, %] format for the adducts column
-                adduct_values.append(
-                    [
-                        str(adduct),
-                        int(count),
-                        float(round(percentage, 2)),
-                    ],
-                )
+                adduct_values.append([
+                    str(adduct), 
+                    int(count), 
+                    float(round(percentage, 2))
+                ])
 
         # Sort adduct_values by count in descending order
         adduct_values.sort(key=lambda x: x[1], reverse=True)  # Sort by count (index 1)
         # Store adduct_values for use in metadata
         consensus_adduct_values = adduct_values
-
+        
         # Extract top adduct information for new columns
         adduct_top = None
         adduct_charge_top = None
         adduct_mass_neutral_top = None
         adduct_mass_shift_top = None
-
+        
         if consensus_adduct_values:
             top_adduct_name = consensus_adduct_values[0][0]  # Get top adduct name
             adduct_top = top_adduct_name
-
+            
             # Parse adduct information to extract charge and mass shift
             # Handle "?" as "H" and parse common adduct formats
             if top_adduct_name == "?" or top_adduct_name == "[M+?]+":
@@ -650,37 +577,33 @@ def merge(self, **kwargs):
                     study_adducts_df = self._get_adducts()
                     if not study_adducts_df.is_empty():
                         # Look for exact match in study adducts
-                        matching_adduct = study_adducts_df.filter(
-                            pl.col("name") == top_adduct_name,
-                        )
+                        matching_adduct = study_adducts_df.filter(pl.col("name") == top_adduct_name)
                         if not matching_adduct.is_empty():
                             adduct_row = matching_adduct.row(0, named=True)
                             adduct_charge_top = adduct_row["charge"]
                             adduct_mass_shift_top = adduct_row["mass_shift"]
                             adduct_found = True
                 except Exception as e:
-                    self.logger.warning(
-                        f"Could not lookup adduct in study adducts: {e}",
-                    )
-
+                    self.logger.warning(f"Could not lookup adduct in study adducts: {e}")
+                
                 if not adduct_found:
                     # Fallback to regex parsing
                     import re
-
+                    
                     # Pattern for adducts like [M+H]+, [M-H]-, [M+Na]+, etc.
-                    pattern = r"\[M([+\-])([A-Za-z0-9]+)\]([0-9]*)([+\-])"
+                    pattern = r'\[M([+\-])([A-Za-z0-9]+)\]([0-9]*)([+\-])'
                     match = re.match(pattern, top_adduct_name)
-
+                    
                     if match:
                         sign = match.group(1)
                         element = match.group(2)
                         multiplier_str = match.group(3)
                         charge_sign = match.group(4)
-
+                        
                         multiplier = int(multiplier_str) if multiplier_str else 1
                         charge = multiplier if charge_sign == "+" else -multiplier
                         adduct_charge_top = charge
-
+                        
                         # Calculate mass shift based on element
                         element_masses = {
                             "H": 1.007825,
@@ -694,16 +617,9 @@ def merge(self, **kwargs):
                             "CH3COO": 59.013851,
                             "H2O": 18.010565,
                         }
-
-                        base_mass = element_masses.get(
-                            element,
-                            1.007825,
-                        )  # Default to H if unknown
-                        mass_shift = (
-                            base_mass * multiplier
-                            if sign == "+"
-                            else -base_mass * multiplier
-                        )
+                        
+                        base_mass = element_masses.get(element, 1.007825)  # Default to H if unknown
+                        mass_shift = base_mass * multiplier if sign == "+" else -base_mass * multiplier
                         adduct_mass_shift_top = mass_shift
                     else:
                         # Default fallback
@@ -711,8 +627,8 @@ def merge(self, **kwargs):
                         adduct_mass_shift_top = 1.007825
         else:
             # No valid adducts found - assign default based on study polarity
-            study_polarity = getattr(self, "polarity", "positive")
-            if study_polarity in ["negative", "neg"]:
+            study_polarity = getattr(self, 'polarity', 'positive')
+            if study_polarity in ['negative', 'neg']:
                 # Negative mode default
                 adduct_top = "[M-?]1-"
                 adduct_charge_top = -1
@@ -722,18 +638,14 @@ def merge(self, **kwargs):
                 adduct_top = "[M+?]1+"
                 adduct_charge_top = 1
                 adduct_mass_shift_top = 1.007825  # H mass (gain of proton)
-
+            
             # Create a single default adduct entry in the adducts list for consistency
             consensus_adduct_values = [[adduct_top, 1, 100.0]]
-
+        
         # Calculate neutral mass from consensus mz (for both cases)
-        consensus_mz = (
-            round(float(np.mean(mz_values)), 4) if len(mz_values) > 0 else 0.0
-        )
+        consensus_mz = round(float(np.mean(mz_values)), 4) if len(mz_values) > 0 else 0.0
         if adduct_charge_top and adduct_mass_shift_top is not None:
-            adduct_mass_neutral_top = (
-                consensus_mz * abs(adduct_charge_top) - adduct_mass_shift_top
-            )
+            adduct_mass_neutral_top = consensus_mz * abs(adduct_charge_top) - adduct_mass_shift_top
 
         # Calculate number of MS2 spectra
         ms2_count = 0
@@ -742,95 +654,48 @@ def merge(self, **kwargs):
             if ms2_scans is not None:
                 ms2_count += len(ms2_scans)
 
-        metadata_list.append(
-            {
-                "consensus_uid": int(i),  # "consensus_id": i,
-                "consensus_id": str(feature.getUniqueId()),
-                "quality": round(float(feature.getQuality()), 3),
-                "number_samples": len(feature_data_list),
-                # "number_ext": int(len(features_list)),
-                "rt": round(float(np.mean(rt_values)), 4)
-                if len(rt_values) > 0
-                else 0.0,
-                "mz": round(float(np.mean(mz_values)), 4)
-                if len(mz_values) > 0
-                else 0.0,
-                "rt_min": round(float(np.min(rt_values)), 3)
-                if len(rt_values) > 0
-                else 0.0,
-                "rt_max": round(float(np.max(rt_values)), 3)
-                if len(rt_values) > 0
-                else 0.0,
-                "rt_mean": round(float(np.mean(rt_values)), 3)
-                if len(rt_values) > 0
-                else 0.0,
-                "rt_start_mean": round(float(np.mean(rt_start_values)), 3)
-                if len(rt_start_values) > 0
-                else 0.0,
-                "rt_end_mean": round(float(np.mean(rt_end_values)), 3)
-                if len(rt_end_values) > 0
-                else 0.0,
-                "rt_delta_mean": round(float(np.ptp(rt_delta_values)), 3)
-                if len(rt_delta_values) > 0
-                else 0.0,
-                "mz_min": round(float(np.min(mz_values)), 4)
-                if len(mz_values) > 0
-                else 0.0,
-                "mz_max": round(float(np.max(mz_values)), 4)
-                if len(mz_values) > 0
-                else 0.0,
-                "mz_mean": round(float(np.mean(mz_values)), 4)
-                if len(mz_values) > 0
-                else 0.0,
-                "mz_start_mean": round(float(np.mean(mz_start_values)), 4)
-                if len(mz_start_values) > 0
-                else 0.0,
-                "mz_end_mean": round(float(np.mean(mz_end_values)), 4)
-                if len(mz_end_values) > 0
-                else 0.0,
-                "inty_mean": round(float(np.mean(inty_values)), 0)
-                if len(inty_values) > 0
-                else 0.0,
-                "bl": -1.0,
-                "chrom_coherence_mean": round(float(np.mean(coherence_values)), 3)
-                if len(coherence_values) > 0
-                else 0.0,
-                "chrom_prominence_mean": round(float(np.mean(prominence_values)), 0)
-                if len(prominence_values) > 0
-                else 0.0,
-                "chrom_prominence_scaled_mean": round(
-                    float(np.mean(prominence_scaled_values)),
-                    3,
-                )
-                if len(prominence_scaled_values) > 0
-                else 0.0,
-                "chrom_height_scaled_mean": round(
-                    float(np.mean(height_scaled_values)),
-                    3,
-                )
-                if len(height_scaled_values) > 0
-                else 0.0,
-                "iso_mean": round(float(np.mean(iso_values)), 2)
-                if len(iso_values) > 0
-                else 0.0,
-                "charge_mean": round(float(np.mean(charge_values)), 2)
-                if len(charge_values) > 0
-                else 0.0,
-                "number_ms2": int(ms2_count),
-                "adducts": consensus_adduct_values
-                if consensus_adduct_values
-                else [],  # Ensure it's always a list
-                # New columns for top-ranked adduct information
-                "adduct_top": adduct_top,
-                "adduct_charge_top": adduct_charge_top,
-                "adduct_mass_neutral_top": round(adduct_mass_neutral_top, 6)
-                if adduct_mass_neutral_top is not None
-                else None,
-                "adduct_mass_shift_top": round(adduct_mass_shift_top, 6)
-                if adduct_mass_shift_top is not None
-                else None,
-            },
-        )
+        metadata_list.append({
+            "consensus_uid": int(i),  # "consensus_id": i,
+            "consensus_id": str(feature.getUniqueId()),
+            "quality": round(float(feature.getQuality()), 3),
+            "number_samples": len(feature_data_list),
+            # "number_ext": int(len(features_list)),
+            "rt": round(float(np.mean(rt_values)), 4) if len(rt_values) > 0 else 0.0,
+            "mz": round(float(np.mean(mz_values)), 4) if len(mz_values) > 0 else 0.0,
+            "rt_min": round(float(np.min(rt_values)), 3) if len(rt_values) > 0 else 0.0,
+            "rt_max": round(float(np.max(rt_values)), 3) if len(rt_values) > 0 else 0.0,
+            "rt_mean": round(float(np.mean(rt_values)), 3) if len(rt_values) > 0 else 0.0,
+            "rt_start_mean": round(float(np.mean(rt_start_values)), 3) if len(rt_start_values) > 0 else 0.0,
+            "rt_end_mean": round(float(np.mean(rt_end_values)), 3) if len(rt_end_values) > 0 else 0.0,
+            "rt_delta_mean": round(float(np.ptp(rt_delta_values)), 3) if len(rt_delta_values) > 0 else 0.0,
+            "mz_min": round(float(np.min(mz_values)), 4) if len(mz_values) > 0 else 0.0,
+            "mz_max": round(float(np.max(mz_values)), 4) if len(mz_values) > 0 else 0.0,
+            "mz_mean": round(float(np.mean(mz_values)), 4) if len(mz_values) > 0 else 0.0,
+            "mz_start_mean": round(float(np.mean(mz_start_values)), 4) if len(mz_start_values) > 0 else 0.0,
+            "mz_end_mean": round(float(np.mean(mz_end_values)), 4) if len(mz_end_values) > 0 else 0.0,
+            "inty_mean": round(float(np.mean(inty_values)), 0) if len(inty_values) > 0 else 0.0,
+            "bl": -1.0,
+            "chrom_coherence_mean": round(float(np.mean(coherence_values)), 3) if len(coherence_values) > 0 else 0.0,
+            "chrom_prominence_mean": round(float(np.mean(prominence_values)), 0) if len(prominence_values) > 0 else 0.0,
+            "chrom_prominence_scaled_mean": round(
+                float(np.mean(prominence_scaled_values)),
+                3,
+            )
+            if len(prominence_scaled_values) > 0
+            else 0.0,
+            "chrom_height_scaled_mean": round(float(np.mean(height_scaled_values)), 3)
+            if len(height_scaled_values) > 0
+            else 0.0,
+            "iso_mean": round(float(np.mean(iso_values)), 2) if len(iso_values) > 0 else 0.0,
+            "charge_mean": round(float(np.mean(charge_values)), 2) if len(charge_values) > 0 else 0.0,
+            "number_ms2": int(ms2_count),
+            "adducts": consensus_adduct_values if consensus_adduct_values else [],  # Ensure it's always a list
+            # New columns for top-ranked adduct information
+            "adduct_top": adduct_top,
+            "adduct_charge_top": adduct_charge_top,
+            "adduct_mass_neutral_top": round(adduct_mass_neutral_top, 6) if adduct_mass_neutral_top is not None else None,
+            "adduct_mass_shift_top": round(adduct_mass_shift_top, 6) if adduct_mass_shift_top is not None else None,
+        })
 
     consensus_mapping_df = pl.DataFrame(consensus_mapping)
     # remove all rows in consensus_mapping_df where consensus_id is not in self.featured_df['uid']
@@ -871,74 +736,72 @@ def merge(self, **kwargs):
     )
 
     self.consensus_map = consensus_map
-
+    
     # Add adduct grouping and adduct_of assignment
     if len(self.consensus_df) > 0:
         # Get rt_tol and mz_tol from kwargs or use defaults from merge_defaults
         adduct_rt_tol = rt_tol  # Use the same rt_tol from merge parameters
         adduct_mz_tol = mz_tol  # Use the same mz_tol from merge parameters
-
+        
         # Initialize new columns
         adduct_group_list = []
         adduct_of_list = []
-
+        
         # Get relevant columns for grouping
         consensus_data = []
         for row in self.consensus_df.iter_rows(named=True):
-            consensus_data.append(
-                {
-                    "consensus_uid": row["consensus_uid"],
-                    "rt": row["rt"],
-                    "adduct_mass_neutral_top": row.get("adduct_mass_neutral_top"),
-                    "adduct_top": row.get("adduct_top"),
-                    "inty_mean": row.get("inty_mean", 0),
-                },
-            )
-
+            consensus_data.append({
+                "consensus_uid": row["consensus_uid"],
+                "rt": row["rt"],
+                "adduct_mass_neutral_top": row.get("adduct_mass_neutral_top"),
+                "adduct_top": row.get("adduct_top"),
+                "inty_mean": row.get("inty_mean", 0),
+            })
+        
         # Group features with similar neutral mass and RT
         group_id = 1
         assigned_groups = {}  # consensus_uid -> group_id
         groups = {}  # group_id -> [consensus_uids]
-
+        
         for i, feature in enumerate(consensus_data):
             consensus_uid = feature["consensus_uid"]
-
+            
             if consensus_uid in assigned_groups:
                 continue
-
+                
             neutral_mass = feature["adduct_mass_neutral_top"]
             rt = feature["rt"]
-
+            
             # Skip if neutral mass is None
             if neutral_mass is None:
                 assigned_groups[consensus_uid] = 0  # No group assignment
                 continue
-
+            
             # Find all features that could belong to the same group
             group_members = [consensus_uid]
-
+            
             for j, other_feature in enumerate(consensus_data):
                 if i == j:
                     continue
-
+                    
                 other_uid = other_feature["consensus_uid"]
                 if other_uid in assigned_groups:
                     continue
-
+                    
                 other_neutral_mass = other_feature["adduct_mass_neutral_top"]
                 other_rt = other_feature["rt"]
-
+                
                 if other_neutral_mass is None:
                     continue
-
+                
                 # Check if features have similar neutral mass and RT
                 mass_diff = abs(neutral_mass - other_neutral_mass)
                 rt_diff = abs(rt - other_rt) / 60.0  # Convert to minutes for rt_tol
-
+                
                 if mass_diff <= adduct_mz_tol and rt_diff <= adduct_rt_tol:
                     group_members.append(other_uid)
                     assigned_groups[other_uid] = group_id
-
+            
             if len(group_members) > 1:
                 # Multiple members - create a group
                 for member_uid in group_members:
@@ -950,29 +813,26 @@ def merge(self, **kwargs):
                 assigned_groups[consensus_uid] = group_id
                 groups[group_id] = [consensus_uid]
                 group_id += 1
-
+        
         # Determine adduct_of for each group
         group_adduct_of = {}  # group_id -> consensus_uid of most important adduct
-
+        
         for grp_id, member_uids in groups.items():
             # Find the most important adduct in this group
             # Priority: [M+H]+ > [M-H]- > highest intensity
             best_uid = None
             best_priority = -1
             best_intensity = 0
-
+            
             for uid in member_uids:
                 # Find the feature data
-                feature_data = next(
-                    (f for f in consensus_data if f["consensus_uid"] == uid),
-                    None,
-                )
+                feature_data = next((f for f in consensus_data if f["consensus_uid"] == uid), None)
                 if not feature_data:
                     continue
-
+                    
                 adduct = feature_data.get("adduct_top", "")
                 intensity = feature_data.get("inty_mean", 0)
-
+                
                 priority = 0
                 if adduct and ("[M+H]" in adduct or adduct == "H" or adduct == "?"):
                     priority = 3  # Highest priority for [M+H]+ or H
@@ -980,41 +840,34 @@ def merge(self, **kwargs):
                     priority = 2  # Second priority for [M-H]-
                 elif adduct and "M" in adduct:
                     priority = 1  # Third priority for other molecular adducts
-
+                
                 # Choose based on priority first, then intensity
-                if priority > best_priority or (
-                    priority == best_priority and intensity > best_intensity
-                ):
+                if (priority > best_priority or 
+                    (priority == best_priority and intensity > best_intensity)):
                     best_uid = uid
                     best_priority = priority
                     best_intensity = intensity
-
+            
             group_adduct_of[grp_id] = best_uid if best_uid else member_uids[0]
-
+        
         # Build the final lists in the same order as consensus_df
         for row in self.consensus_df.iter_rows(named=True):
             consensus_uid = row["consensus_uid"]
             group = assigned_groups.get(consensus_uid, 0)
             adduct_of = group_adduct_of.get(group, consensus_uid)
-
+            
             adduct_group_list.append(group)
             adduct_of_list.append(adduct_of)
-
+        
         # Add the new columns to consensus_df
-        self.consensus_df = self.consensus_df.with_columns(
-            [
-                pl.Series("adduct_group", adduct_group_list, dtype=pl.Int64),
-                pl.Series("adduct_of", adduct_of_list, dtype=pl.Int64),
-            ],
-        )
-
+        self.consensus_df = self.consensus_df.with_columns([
+            pl.Series("adduct_group", adduct_group_list, dtype=pl.Int64),
+            pl.Series("adduct_of", adduct_of_list, dtype=pl.Int64),
+        ])
+    
     # calculate the completeness of the consensus map
     if len(self.consensus_df) > 0 and len(self.samples_df) > 0:
-        c = (
-            len(self.consensus_mapping_df)
-            / len(self.consensus_df)
-            / len(self.samples_df)
-        )
+        c = len(self.consensus_mapping_df) / len(self.consensus_df) / len(self.samples_df)
         self.logger.info(
             f"Merging completed. Consensus features: {len(self.consensus_df)}. Completeness: {c:.2f}.",
         )
@@ -1085,9 +938,7 @@ def find_ms2(self, **kwargs):
     ]
     for row in feats.iter_rows(named=True):
         feature_uid = row["feature_uid"]
-        feature_lookup[feature_uid] = {
-            col: row[col] for col in relevant_cols if col in feats.columns
-        }
+        feature_lookup[feature_uid] = {col: row[col] for col in relevant_cols if col in feats.columns}
     tdqm_disable = self.log_level not in ["TRACE", "DEBUG", "INFO"]
 
     # Process consensus mapping in batch
@@ -1109,26 +960,20 @@ def find_ms2(self, **kwargs):
         for j in range(len(ms2_specs)):
             spec = ms2_specs[j]
             scanid = ms2_scans[j]
-            data.append(
-                {
-                    "consensus_uid": int(mapping_row["consensus_uid"]),
-                    "feature_uid": int(mapping_row["feature_uid"]),
-                    "sample_uid": int(mapping_row["sample_uid"]),
-                    "scan_id": int(scanid),
-                    "energy": round(spec.energy, 1)
-                    if hasattr(spec, "energy") and spec.energy is not None
-                    else None,
-                    "prec_inty": round(inty, 0) if inty is not None else None,
-                    "prec_coherence": round(chrom_coherence, 3)
-                    if chrom_coherence is not None
-                    else None,
-                    "prec_prominence_scaled": round(chrom_prominence_scaled, 3)
-                    if chrom_prominence_scaled is not None
-                    else None,
-                    "number_frags": len(spec.mz),
-                    "spec": spec,
-                },
-            )
+            data.append({
+                "consensus_uid": int(mapping_row["consensus_uid"]),
+                "feature_uid": int(mapping_row["feature_uid"]),
+                "sample_uid": int(mapping_row["sample_uid"]),
+                "scan_id": int(scanid),
+                "energy": round(spec.energy, 1) if hasattr(spec, "energy") and spec.energy is not None else None,
+                "prec_inty": round(inty, 0) if inty is not None else None,
+                "prec_coherence": round(chrom_coherence, 3) if chrom_coherence is not None else None,
+                "prec_prominence_scaled": round(chrom_prominence_scaled, 3)
+                if chrom_prominence_scaled is not None
+                else None,
+                "number_frags": len(spec.mz),
+                "spec": spec,
+            })
     self.consensus_ms2 = pl.DataFrame(data)
     if not self.consensus_ms2.is_empty():
         unique_consensus_features = self.consensus_ms2["consensus_uid"].n_unique()
@@ -1161,10 +1006,7 @@ def filter_consensus(
         else:
             if isinstance(coherence, tuple) and len(coherence) == 2:
                 min_coherence, max_coherence = coherence
-                cons = cons[
-                    (cons["chrom_coherence"] >= min_coherence)
-                    & (cons["chrom_coherence"] <= max_coherence)
-                ]
+                cons = cons[(cons["chrom_coherence"] >= min_coherence) & (cons["chrom_coherence"] <= max_coherence)]
             else:
                 cons = cons[cons["chrom_coherence"] >= coherence]
         after_coherence = len(cons)
@@ -1175,9 +1017,7 @@ def filter_consensus(
     if quality is not None:
         if isinstance(quality, tuple) and len(quality) == 2:
             min_quality, max_quality = quality
-            cons = cons[
-                (cons["quality"] >= min_quality) & (cons["quality"] <= max_quality)
-            ]
+            cons = cons[(cons["quality"] >= min_quality) & (cons["quality"] <= max_quality)]
         else:
             cons = cons[cons["quality"] >= quality]
         after_quality = len(cons)
@@ -1188,10 +1028,7 @@ def filter_consensus(
     if number_samples is not None:
         if isinstance(number_samples, tuple) and len(number_samples) == 2:
             min_number, max_number = number_samples
-            cons = cons[
-                (cons["number_samples"] >= min_number)
-                & (cons["number_samples"] <= max_number)
-            ]
+            cons = cons[(cons["number_samples"] >= min_number) & (cons["number_samples"] <= max_number)]
         else:
             cons = cons[cons["number_samples"] >= number_samples]
         after_number_samples = len(cons)
@@ -1268,13 +1105,11 @@ def _integrate_chrom_impl(self, **kwargs):
 
     # Merge consensus_mapping with consensus_df to get rt_start_mean and rt_end_mean
     # Use Polars join operation instead of pandas merge
-    consensus_subset = self.consensus_df.select(
-        [
-            "consensus_uid",
-            "rt_start_mean",
-            "rt_end_mean",
-        ],
-    )
+    consensus_subset = self.consensus_df.select([
+        "consensus_uid",
+        "rt_start_mean",
+        "rt_end_mean",
+    ])
     df1 = self.consensus_mapping_df.join(
         consensus_subset,
         on="consensus_uid",
@@ -1319,9 +1154,9 @@ def _integrate_chrom_impl(self, **kwargs):
         if chrom is None or len(chrom) == 0:
             update_rows.append(row_idx)
             chroms.append(None)
-            rt_starts.append(float("nan"))
-            rt_ends.append(float("nan"))
-            rt_deltas.append(float("nan"))
+            rt_starts.append(float('nan'))
+            rt_ends.append(float('nan'))
+            rt_deltas.append(float('nan'))
             chrom_areas.append(-1.0)
             continue
         ## TODO expose parameters
@@ -1351,13 +1186,9 @@ def _integrate_chrom_impl(self, **kwargs):
     if update_rows:
         # Create mapping from row index to new values
         row_to_chrom = {update_rows[i]: chroms[i] for i in range(len(update_rows))}
-        row_to_rt_start = {
-            update_rows[i]: rt_starts[i] for i in range(len(update_rows))
-        }
+        row_to_rt_start = {update_rows[i]: rt_starts[i] for i in range(len(update_rows))}
         row_to_rt_end = {update_rows[i]: rt_ends[i] for i in range(len(update_rows))}
-        row_to_rt_delta = {
-            update_rows[i]: rt_deltas[i] for i in range(len(update_rows))
-        }
+        row_to_rt_delta = {update_rows[i]: rt_deltas[i] for i in range(len(update_rows))}
         row_to_chrom_area = {
             update_rows[i]: float(chrom_areas[i]) if chrom_areas[i] is not None else 0.0
             for i in range(len(update_rows))
@@ -1371,60 +1202,58 @@ def _integrate_chrom_impl(self, **kwargs):
 
         # Update columns conditionally
         try:
-            self.features_df = df_with_index.with_columns(
-                [
-                    # Update chrom column - use when() to update only specific rows
-                    pl.when(update_mask)
-                    .then(
-                        pl.col("__row_idx").map_elements(
-                            lambda x: row_to_chrom.get(x, None),
-                            return_dtype=pl.Object,
-                        ),
-                    )
-                    .otherwise(pl.col("chrom"))
-                    .alias("chrom"),
-                    # Update rt_start column
-                    pl.when(update_mask)
-                    .then(
-                        pl.col("__row_idx").map_elements(
-                            lambda x: row_to_rt_start.get(x, None),
-                            return_dtype=pl.Float64,
-                        ),
-                    )
-                    .otherwise(pl.col("rt_start"))
-                    .alias("rt_start"),
-                    # Update rt_end column
-                    pl.when(update_mask)
-                    .then(
-                        pl.col("__row_idx").map_elements(
-                            lambda x: row_to_rt_end.get(x, None),
-                            return_dtype=pl.Float64,
-                        ),
-                    )
-                    .otherwise(pl.col("rt_end"))
-                    .alias("rt_end"),
-                    # Update rt_delta column
-                    pl.when(update_mask)
-                    .then(
-                        pl.col("__row_idx").map_elements(
-                            lambda x: row_to_rt_delta.get(x, None),
-                            return_dtype=pl.Float64,
-                        ),
-                    )
-                    .otherwise(pl.col("rt_delta"))
-                    .alias("rt_delta"),
-                    # Update chrom_area column
-                    pl.when(update_mask)
-                    .then(
-                        pl.col("__row_idx").map_elements(
-                            lambda x: row_to_chrom_area.get(x, 0),
-                            return_dtype=pl.Float64,
-                        ),
-                    )
-                    .otherwise(pl.col("chrom_area"))
-                    .alias("chrom_area"),
-                ],
-            ).drop("__row_idx")  # Remove the temporary row index column
+            self.features_df = df_with_index.with_columns([
+                # Update chrom column - use when() to update only specific rows
+                pl.when(update_mask)
+                .then(
+                    pl.col("__row_idx").map_elements(
+                        lambda x: row_to_chrom.get(x, None),
+                        return_dtype=pl.Object,
+                    ),
+                )
+                .otherwise(pl.col("chrom"))
+                .alias("chrom"),
+                # Update rt_start column
+                pl.when(update_mask)
+                .then(
+                    pl.col("__row_idx").map_elements(
+                        lambda x: row_to_rt_start.get(x, None),
+                        return_dtype=pl.Float64,
+                    ),
+                )
+                .otherwise(pl.col("rt_start"))
+                .alias("rt_start"),
+                # Update rt_end column
+                pl.when(update_mask)
+                .then(
+                    pl.col("__row_idx").map_elements(
+                        lambda x: row_to_rt_end.get(x, None),
+                        return_dtype=pl.Float64,
+                    ),
+                )
+                .otherwise(pl.col("rt_end"))
+                .alias("rt_end"),
+                # Update rt_delta column
+                pl.when(update_mask)
+                .then(
+                    pl.col("__row_idx").map_elements(
+                        lambda x: row_to_rt_delta.get(x, None),
+                        return_dtype=pl.Float64,
+                    ),
+                )
+                .otherwise(pl.col("rt_delta"))
+                .alias("rt_delta"),
+                # Update chrom_area column
+                pl.when(update_mask)
+                .then(
+                    pl.col("__row_idx").map_elements(
+                        lambda x: row_to_chrom_area.get(x, 0),
+                        return_dtype=pl.Float64,
+                    ),
+                )
+                .otherwise(pl.col("chrom_area"))
+                .alias("chrom_area"),
+            ]).drop("__row_idx")  # Remove the temporary row index column
 
             self.logger.debug(
                 f"Integration completed. Updated {len(update_rows)} features with chromatogram data.",
@@ -1514,22 +1343,10 @@ def _align_pose_clustering(study_obj, fmaps, params):
     params_oms.setValue("pairfinder:distance_intensity:log_transform", "disabled")
     params_oms.setValue("pairfinder:ignore_charge", "true")
     params_oms.setValue("max_num_peaks_considered", 1000)
-    params_oms.setValue(
-        "pairfinder:distance_RT:max_difference",
-        params.get("rt_max_diff"),
-    )
-    params_oms.setValue(
-        "pairfinder:distance_MZ:max_difference",
-        params.get("mz_max_diff"),
-    )
-    params_oms.setValue(
-        "superimposer:rt_pair_distance_fraction",
-        params.get("rt_pair_distance_frac"),
-    )
-    params_oms.setValue(
-        "superimposer:mz_pair_max_distance",
-        params.get("mz_pair_max_distance"),
-    )
+    params_oms.setValue("pairfinder:distance_RT:max_difference", params.get("rt_max_diff"))
+    params_oms.setValue("pairfinder:distance_MZ:max_difference", params.get("mz_max_diff"))
+    params_oms.setValue("superimposer:rt_pair_distance_fraction", params.get("rt_pair_distance_frac"))
+    params_oms.setValue("superimposer:mz_pair_max_distance", params.get("mz_pair_max_distance"))
     params_oms.setValue("superimposer:num_used_points", params.get("num_used_points"))
     params_oms.setValue("pairfinder:distance_MZ:exponent", 3.0)
     params_oms.setValue("pairfinder:distance_RT:exponent", 2.0)
@@ -1538,9 +1355,7 @@ def _align_pose_clustering(study_obj, fmaps, params):
     study_obj.logger.info("Starting alignment with PoseClustering")
 
     # Set ref_index to feature map index with largest number of features
-    ref_index = [
-        i[0] for i in sorted(enumerate([fm.size() for fm in fmaps]), key=lambda x: x[1])
-    ][-1]
+    ref_index = [i[0] for i in sorted(enumerate([fm.size() for fm in fmaps]), key=lambda x: x[1])][-1]
     study_obj.logger.debug(
         f"Reference map is {study_obj.samples_df.row(ref_index, named=True)['sample_name']}",
     )
@@ -1559,10 +1374,7 @@ def _align_pose_clustering(study_obj, fmaps, params):
     ):
         if index == ref_index:
             continue
-        if (
-            params.get("skip_blanks")
-            and study_obj.samples_df.row(index, named=True)["sample_type"] == "blank"
-        ):
+        if params.get("skip_blanks") and study_obj.samples_df.row(index, named=True)["sample_type"] == "blank":
             continue
         trafo = oms.TransformationDescription()
         aligner.align(fm, trafo)
@@ -1581,30 +1393,19 @@ def _align_kd_algorithm(study_obj, fmaps, params):
 
     # Pull parameter values - map standard align params to our algorithm
     # Use rt_max_diff (standard align param) instead of warp_rt_tol for RT tolerance
-    rt_pair_tol = (
-        float(params.get("rt_max_diff"))
-        if params.get("rt_max_diff") is not None
-        else 2.0
-    )
+    rt_pair_tol = float(params.get("rt_max_diff")) if params.get("rt_max_diff") is not None else 2.0
     # Use mz_max_diff (standard align param) converted to ppm
-    mz_max_diff_da = (
-        float(params.get("mz_max_diff"))
-        if params.get("mz_max_diff") is not None
-        else 0.02
-    )
+    mz_max_diff_da = float(params.get("mz_max_diff")) if params.get("mz_max_diff") is not None else 0.02
     # Convert Da to ppm (assuming ~400 m/z average for metabolomics): 0.01 Da / 400 * 1e6 = 25 ppm
     ppm_tol = mz_max_diff_da / 400.0 * 1e6
     # Allow override with warp_mz_tol if specifically set (but not from defaults)
     try:
         warp_mz_from_params = params.get("warp_mz_tol")
-        if (
-            warp_mz_from_params is not None
-            and warp_mz_from_params != params.__class__().warp_mz_tol
-        ):
+        if warp_mz_from_params is not None and warp_mz_from_params != params.__class__().warp_mz_tol:
             ppm_tol = float(warp_mz_from_params)
     except (KeyError, AttributeError):
         pass
-
+    
     # Safely retrieve optional parameter max_anchor_points (not yet part of defaults)
     try:
         _raw_mp = params.get("max_anchor_points")
@@ -1612,18 +1413,16 @@ def _align_kd_algorithm(study_obj, fmaps, params):
         _raw_mp = None
     max_points = int(_raw_mp) if _raw_mp is not None else 1000
     study_obj.logger.info(
-        f"Starting custom KD-style alignment (ref-based) with ppm_tol={ppm_tol:.1f}, rt_tol={rt_pair_tol:.1f}s, max_points={max_points}",
-    )
-    study_obj.logger.info(
-        f"Using rt_max_diff={params.get('rt_max_diff')}, mz_max_diff={params.get('mz_max_diff')}",
+        f"Starting custom KD-style alignment (ref-based) with ppm_tol={ppm_tol:.1f}, rt_tol={rt_pair_tol:.1f}s, max_points={max_points}"
     )
+    study_obj.logger.info(f"Using rt_max_diff={params.get('rt_max_diff')}, mz_max_diff={params.get('mz_max_diff')}")
 
     # Choose reference map (largest number of features)
     ref_index = max(range(len(fmaps)), key=lambda i: fmaps[i].size())
     ref_map = fmaps[ref_index]
     study_obj.alignment_ref_index = ref_index
     study_obj.logger.debug(
-        f"Reference map index {ref_index} (sample: {study_obj.samples_df.row(ref_index, named=True)['sample_name']}) size={ref_map.size()}",
+        f"Reference map index {ref_index} (sample: {study_obj.samples_df.row(ref_index, named=True)['sample_name']}) size={ref_map.size()}"
     )
 
     # Extract and sort reference features by m/z for binary search
@@ -1647,10 +1446,7 @@ def _align_kd_algorithm(study_obj, fmaps, params):
                     best_drt = drt
         return best
 
-    def _set_pairs(
-        td_obj: oms.TransformationDescription,
-        pairs,
-    ):  # Helper for pyopenms API variability
+    def _set_pairs(td_obj: 'oms.TransformationDescription', pairs):  # Helper for pyopenms API variability
         # Always provide list of lists to satisfy strict type expectations
         conv = [[float(a), float(b)] for a, b in pairs]
         try:
@@ -1732,7 +1528,7 @@ def _align_kd_algorithm(study_obj, fmaps, params):
             td.fitModel(model, oms.Param())
         except Exception as e:
             study_obj.logger.debug(
-                f"Map {i}: {model} fitting failed ({e}); fallback to linear two-point shift",
+                f"Map {i}: {model} fitting failed ({e}); fallback to linear two-point shift"
             )
             rts = [f.getRT() for f in fmap]
             lo, hi = (min(rts), max(rts)) if rts else (0.0, 1.0)
@@ -1744,7 +1540,7 @@ def _align_kd_algorithm(study_obj, fmaps, params):
                 pass
 
         study_obj.logger.debug(
-            f"Map {i}: anchors raw={len(pairs_raw)} used={len(pairs_use)} model={model} median_shift={med_shift:.4f}s",
+            f"Map {i}: anchors raw={len(pairs_raw)} used={len(pairs_use)} model={model} median_shift={med_shift:.4f}s"
         )
         transformations.append(td)
 
@@ -1762,7 +1558,7 @@ def _align_kd_algorithm(study_obj, fmaps, params):
             study_obj.logger.warning(f"Map {i}: failed applying transformation ({e})")
 
     study_obj.logger.info(
-        f"Custom KD alignment completed. Reference index {ref_index}. Applied {len(transformations)} transformations.",
+        f"Custom KD alignment completed. Reference index {ref_index}. Applied {len(transformations)} transformations."
     )
 
 
@@ -1771,21 +1567,13 @@ def _align_pose_clustering_fallback(study_obj, fmaps, params):
     import pyopenms as oms
 
     aligner = oms.MapAlignmentAlgorithmPoseClustering()
-    ref_index = [
-        i[0] for i in sorted(enumerate([fm.size() for fm in fmaps]), key=lambda x: x[1])
-    ][-1]
+    ref_index = [i[0] for i in sorted(enumerate([fm.size() for fm in fmaps]), key=lambda x: x[1])][-1]
 
     # Set up basic parameters for pose clustering
     pc_params = oms.Param()
     pc_params.setValue("max_num_peaks_considered", 1000)
-    pc_params.setValue(
-        "pairfinder:distance_RT:max_difference",
-        params.get("rt_max_diff"),
-    )
-    pc_params.setValue(
-        "pairfinder:distance_MZ:max_difference",
-        params.get("mz_max_diff"),
-    )
+    pc_params.setValue("pairfinder:distance_RT:max_difference", params.get("rt_max_diff"))
+    pc_params.setValue("pairfinder:distance_MZ:max_difference", params.get("mz_max_diff"))
 
     aligner.setParameters(pc_params)
     aligner.setReference(fmaps[ref_index])