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

masster/sample/processing.py

@@ -8,14 +8,13 @@ import pyopenms as oms
 
 from tqdm import tqdm
 
-from master.spectrum import Spectrum
+from masster.spectrum import Spectrum
 from .defaults.find_features_def import find_features_defaults
 from .defaults.find_ms2_def import find_ms2_defaults
 from .defaults.get_spectrum_def import get_spectrum_defaults
 
 
-from master.chromatogram import Chromatogram
-
+from masster.chromatogram import Chromatogram
 
 def get_spectrum(self, scan, **kwargs):
     """Retrieve a single spectrum and optionally post-process it.
@@ -253,8 +252,7 @@ def get_spectrum(self, scan, **kwargs):
                 spec=spect,
                 scan_uid=scan_uid,
                 feature_uid=scan_info["feature_uid"][0]
-                if "feature_uid" in scan_info
-                and scan_info["feature_uid"][0] is not None
+                if "feature_uid" in scan_info and scan_info["feature_uid"][0] is not None
                 else feature_uid,
                 q1_step=2,
                 deisotope=deisotope,
@@ -447,9 +445,7 @@ def _spec_to_mat(
             closest_index = np.argmin(np.abs(ar2 - val1))
             closest_indices.append((i, closest_index))
         # filter out pairs that are not within the specified tolerance
-        closest_indices = [
-            (i, j) for i, j in closest_indices if np.abs(ar1[i] - ar2[j]) <= tol
-        ]
+        closest_indices = [(i, j) for i, j in closest_indices if np.abs(ar1[i] - ar2[j]) <= tol]
         # remove duplicates from the list of indices
         closest_indices = list(set(closest_indices))
         # sort the list of indices by the first element (i) in ascending order
@@ -568,13 +564,9 @@ def find_features(self, **kwargs):
             import os
 
             os.environ["OMP_NUM_THREADS"] = str(params.threads)
-            self.logger.debug(
-                f"Set thread count to {params.threads} via OMP_NUM_THREADS",
-            )
+            self.logger.debug(f"Set thread count to {params.threads} via OMP_NUM_THREADS")
         except Exception:
-            self.logger.warning(
-                f"Could not set thread count to {params.threads} - using default",
-            )
+            self.logger.warning(f"Could not set thread count to {params.threads} - using default")
 
     # Set debug mode if enabled
     if hasattr(params, "debug") and params.debug:
@@ -615,8 +607,7 @@ def find_features(self, **kwargs):
     mtd_par.setValue("noise_threshold_int", float(params.get("noise")))
     mtd_par.setValue(
         "min_trace_length",
-        float(params.get("min_trace_length_multiplier"))
-        * float(params.get("chrom_fwhm_min")),
+        float(params.get("min_trace_length_multiplier")) * float(params.get("chrom_fwhm_min")),
     )
     mtd_par.setValue(
         "trace_termination_outliers",
@@ -627,14 +618,8 @@ def find_features(self, **kwargs):
     # Additional MTD parameters
     mtd_par.setValue("min_sample_rate", float(params.get("min_sample_rate")))
     mtd_par.setValue("min_trace_length", float(params.get("min_trace_length")))
-    mtd_par.setValue(
-        "trace_termination_criterion",
-        params.get("trace_termination_criterion"),
-    )
-    mtd_par.setValue(
-        "reestimate_mt_sd",
-        "true" if params.get("reestimate_mt_sd") else "false",
-    )
+    mtd_par.setValue("trace_termination_criterion", params.get("trace_termination_criterion"))
+    mtd_par.setValue("reestimate_mt_sd", "true" if params.get("reestimate_mt_sd") else "false")
     mtd_par.setValue("quant_method", params.get("quant_method"))
 
     mtd.setParameters(mtd_par)  # set the new parameters
@@ -703,7 +688,7 @@ def find_features(self, **kwargs):
     df = feature_map.get_df(export_peptide_identifications=False)  # type: ignore[attr-defined]
     # Sets the file path to the primary MS run (usually the mzML file)
     feature_map.setPrimaryMSRunPath([self.file_path.encode()])
-
+    
     # Store feature map in both attributes for compatibility
     self.features = feature_map
     self._oms_features_map = feature_map
@@ -784,15 +769,13 @@ def find_features(self, **kwargs):
             height_scaleds.append(None)
 
     # Add the computed columns to the dataframe
-    df = df.with_columns(
-        [
-            pl.Series("chrom", chroms, dtype=pl.Object),
-            pl.Series("chrom_coherence", coherences, dtype=pl.Float64),
-            pl.Series("chrom_prominence", prominences, dtype=pl.Float64),
-            pl.Series("chrom_prominence_scaled", prominence_scaleds, dtype=pl.Float64),
-            pl.Series("chrom_height_scaled", height_scaleds, dtype=pl.Float64),
-        ],
-    )
+    df = df.with_columns([
+        pl.Series("chrom", chroms, dtype=pl.Object),
+        pl.Series("chrom_coherence", coherences, dtype=pl.Float64),
+        pl.Series("chrom_prominence", prominences, dtype=pl.Float64),
+        pl.Series("chrom_prominence_scaled", prominence_scaleds, dtype=pl.Float64),
+        pl.Series("chrom_height_scaled", height_scaleds, dtype=pl.Float64),
+    ])
 
     self.features_df = df
     self._features_sync()
@@ -813,10 +796,10 @@ def find_features(self, **kwargs):
 def _clean_features_df(self, df):
     """Clean and standardize features DataFrame."""
     # Convert pandas DataFrame to polars if needed
-    if hasattr(df, "index"):  # pandas DataFrame
+    if hasattr(df, 'index'):  # pandas DataFrame
         df = df.copy()
         df["feature_id"] = df.index
-
+    
     if hasattr(df, "columns") and not isinstance(df, pl.DataFrame):
         df_pl = pl.from_pandas(df)
     else:
@@ -826,37 +809,35 @@ def _clean_features_df(self, df):
     df2 = df_pl.filter(pl.col("quality") != 0)
 
     # Create new dataframe with required columns and transformations
-    df_result = df2.select(
-        [
-            pl.int_range(pl.len()).alias("feature_uid"),
-            pl.col("feature_id").cast(pl.String).alias("feature_id"),
-            pl.col("mz").round(5),
-            pl.col("RT").round(3).alias("rt"),
-            pl.col("RT").round(3).alias("rt_original"),
-            pl.col("RTstart").round(3).alias("rt_start"),
-            pl.col("RTend").round(3).alias("rt_end"),
-            (pl.col("RTend") - pl.col("RTstart")).round(3).alias("rt_delta"),
-            pl.col("MZstart").round(5).alias("mz_start"),
-            pl.col("MZend").round(5).alias("mz_end"),
-            pl.col("intensity").alias("inty"),
-            pl.col("quality"),
-            pl.col("charge"),
-            pl.lit(0).alias("iso"),
-            pl.lit(None, dtype=pl.Int64).alias("iso_of"),
-            pl.lit(None, dtype=pl.Utf8).alias("adduct"),
-            pl.lit(None, dtype=pl.Float64).alias("adduct_charge"),
-            pl.lit(None, dtype=pl.Float64).alias("adduct_mass_shift"),
-            pl.lit(None, dtype=pl.Float64).alias("adduct_mass_neutral"),
-            pl.lit(None, dtype=pl.Int64).alias("adduct_group"),
-            pl.lit(None, dtype=pl.Object).alias("chrom"),
-            pl.lit(None, dtype=pl.Float64).alias("chrom_coherence"),
-            pl.lit(None, dtype=pl.Float64).alias("chrom_prominence"),
-            pl.lit(None, dtype=pl.Float64).alias("chrom_prominence_scaled"),
-            pl.lit(None, dtype=pl.Float64).alias("chrom_height_scaled"),
-            pl.lit(None, dtype=pl.Object).alias("ms2_scans"),
-            pl.lit(None, dtype=pl.Object).alias("ms2_specs"),
-        ],
-    )
+    df_result = df2.select([
+        pl.int_range(pl.len()).alias("feature_uid"),
+        pl.col("feature_id").cast(pl.String).alias("feature_id"),
+        pl.col("mz").round(5),
+        pl.col("RT").round(3).alias("rt"),
+        pl.col("RT").round(3).alias("rt_original"),
+        pl.col("RTstart").round(3).alias("rt_start"),
+        pl.col("RTend").round(3).alias("rt_end"),
+        (pl.col("RTend") - pl.col("RTstart")).round(3).alias("rt_delta"),
+        pl.col("MZstart").round(5).alias("mz_start"),
+        pl.col("MZend").round(5).alias("mz_end"),
+        pl.col("intensity").alias("inty"),
+        pl.col("quality"),
+        pl.col("charge"),
+        pl.lit(0).alias("iso"),
+        pl.lit(None, dtype=pl.Int64).alias("iso_of"),
+        pl.lit(None, dtype=pl.Utf8).alias("adduct"),
+        pl.lit(None, dtype=pl.Float64).alias("adduct_charge"),
+        pl.lit(None, dtype=pl.Float64).alias("adduct_mass_shift"),
+        pl.lit(None, dtype=pl.Float64).alias("adduct_mass_neutral"),
+        pl.lit(None, dtype=pl.Int64).alias("adduct_group"),
+        pl.lit(None, dtype=pl.Object).alias("chrom"),
+        pl.lit(None, dtype=pl.Float64).alias("chrom_coherence"),
+        pl.lit(None, dtype=pl.Float64).alias("chrom_prominence"),
+        pl.lit(None, dtype=pl.Float64).alias("chrom_prominence_scaled"),
+        pl.lit(None, dtype=pl.Float64).alias("chrom_height_scaled"),
+        pl.lit(None, dtype=pl.Object).alias("ms2_scans"),
+        pl.lit(None, dtype=pl.Object).alias("ms2_specs"),
+    ])
 
     return df_result
 
@@ -878,12 +859,10 @@ def _features_deisotope(
         df = pl.from_pandas(df)
 
     # Initialize new columns
-    df = df.with_columns(
-        [
-            pl.lit(0).alias("iso"),
-            pl.col("feature_uid").alias("iso_of"),
-        ],
-    )
+    df = df.with_columns([
+        pl.lit(0).alias("iso"),
+        pl.col("feature_uid").alias("iso_of"),
+    ])
 
     # Sort by 'mz'
     df = df.sort("mz")
@@ -910,13 +889,13 @@ def _features_deisotope(
         for isotope_offset in [1, 2, 3]:
             offset_mz = isotope_offset * mz_diff
             tolerance_factor = 1.0 if isotope_offset == 1 else 1.5
-
+            
             t_lower = base_mz + offset_mz - tolerance_factor * mz_tol
             t_upper = base_mz + offset_mz + tolerance_factor * mz_tol
-
+            
             li = np.searchsorted(mz_arr, t_lower, side="left")
             ri = np.searchsorted(mz_arr, t_upper, side="right")
-
+            
             if li < ri:
                 cand_idx = np.arange(li, ri)
                 mask = (
@@ -925,23 +904,22 @@ def _features_deisotope(
                     & (intensity_arr[cand_idx] < 2 * base_int)
                 )
                 valid_cand = cand_idx[mask]
-
+                
                 for cand in valid_cand:
                     if cand != i and iso_of_arr[cand] == feature_uid_arr[cand]:
                         iso_arr[cand] = iso_arr[i] + isotope_offset
                         iso_of_arr[cand] = base_feature_uid
 
     # Update the dataframe with isotope assignments
-    df = df.with_columns(
-        [
-            pl.Series("iso", iso_arr),
-            pl.Series("iso_of", iso_of_arr),
-        ],
-    )
+    df = df.with_columns([
+        pl.Series("iso", iso_arr),
+        pl.Series("iso_of", iso_of_arr),
+    ])
 
     return df
 
 
+
 def analyze_dda(self):
     # Preallocate variables
     cycle_records = []
@@ -1128,9 +1106,7 @@ def find_ms2(self, **kwargs):
     feature_rt_start = features_subset.select("rt_start").to_numpy().flatten()
     feature_rt_end = features_subset.select("rt_end").to_numpy().flatten()
     feature_uids = features_subset.select("feature_uid").to_numpy().flatten()
-    feature_indices = (
-        features_subset.with_row_index().select("index").to_numpy().flatten()
-    )
+    feature_indices = features_subset.with_row_index().select("index").to_numpy().flatten()
 
     # Pre-compute RT radius for all features
     rt_radius = np.minimum(feature_rt - feature_rt_start, feature_rt_end - feature_rt)
@@ -1183,17 +1159,15 @@ def find_ms2(self, **kwargs):
 
         scan_uids = ms2_index_arr[final_indices].tolist()
         scan_uid_lists.append(scan_uids)
-        spec_lists.append(
-            [
-                self.get_spectrum(
-                    scan_uids[0],
-                    centroid=centroid,
-                    deisotope=deisotope,
-                    dia_stats=dia_stats,
-                    feature_uid=feature_uid,
-                ),
-            ],
-        )
+        spec_lists.append([
+            self.get_spectrum(
+                scan_uids[0],
+                centroid=centroid,
+                deisotope=deisotope,
+                dia_stats=dia_stats,
+                feature_uid=feature_uid,
+            ),
+        ])
 
         # Collect updates for batch processing
         updated_feature_uids.extend([feature_uid] * len(final_indices))
@@ -1207,13 +1181,11 @@ def find_ms2(self, **kwargs):
         features_df = pl.from_pandas(features_df)
 
     # Update the features_df
-    update_df = pl.DataFrame(
-        {
-            "temp_idx": feature_indices,
-            "ms2_scans": pl.Series("ms2_scans", scan_uid_lists, dtype=pl.Object),
-            "ms2_specs": pl.Series("ms2_specs", spec_lists, dtype=pl.Object),
-        },
-    )
+    update_df = pl.DataFrame({
+        "temp_idx": feature_indices,
+        "ms2_scans": pl.Series("ms2_scans", scan_uid_lists, dtype=pl.Object),
+        "ms2_specs": pl.Series("ms2_specs", spec_lists, dtype=pl.Object),
+    })
 
     # Join and update
     features_df = (
@@ -1224,18 +1196,16 @@ def find_ms2(self, **kwargs):
             how="left",
             suffix="_new",
         )
-        .with_columns(
-            [
-                pl.when(pl.col("ms2_scans_new").is_not_null())
-                .then(pl.col("ms2_scans_new"))
-                .otherwise(pl.col("ms2_scans"))
-                .alias("ms2_scans"),
-                pl.when(pl.col("ms2_specs_new").is_not_null())
-                .then(pl.col("ms2_specs_new"))
-                .otherwise(pl.col("ms2_specs"))
-                .alias("ms2_specs"),
-            ],
-        )
+        .with_columns([
+            pl.when(pl.col("ms2_scans_new").is_not_null())
+            .then(pl.col("ms2_scans_new"))
+            .otherwise(pl.col("ms2_scans"))
+            .alias("ms2_scans"),
+            pl.when(pl.col("ms2_specs_new").is_not_null())
+            .then(pl.col("ms2_specs_new"))
+            .otherwise(pl.col("ms2_specs"))
+            .alias("ms2_specs"),
+        ])
         .drop(["temp_idx", "ms2_scans_new", "ms2_specs_new"])
     )
 
@@ -1272,4 +1242,4 @@ def find_ms2(self, **kwargs):
     self.store_history(["find_ms2"], params.to_dict())
     self.logger.debug(
         "Parameters stored to find_ms2",
-    )
+    )

masster/sample/quant.py

@@ -53,25 +53,23 @@ def chrom_from_csv(
 
         traces = []
         for _, row in df.iterrows():
-            traces.append(
-                {
-                    "chid": row[col_qid],
-                    "type": "mrm",
-                    "name": row["name"],
-                    "group": row[col_group],
-                    "prec_mz": row[col_q1],
-                    "prod_mz": row[col_q3] if col_q3 else None,
-                    "rt": row[col_rt],
-                    "rt_start": None,
-                    "rt_end": None,
-                    "istd": row[col_istd] if col_istd else None,
-                    "adduct": row[col_adduct] if col_adduct else None,
-                    "class": row[col_class] if col_class else None,
-                    "formula": row[col_formula] if col_formula else None,
-                    "inchikey": row[col_inchikey] if col_inchikey else None,
-                    "smiles": row[col_smiles] if col_smiles else None,
-                },
-            )
+            traces.append({
+                "chid": row[col_qid],
+                "type": "mrm",
+                "name": row["name"],
+                "group": row[col_group],
+                "prec_mz": row[col_q1],
+                "prod_mz": row[col_q3] if col_q3 else None,
+                "rt": row[col_rt],
+                "rt_start": None,
+                "rt_end": None,
+                "istd": row[col_istd] if col_istd else None,
+                "adduct": row[col_adduct] if col_adduct else None,
+                "class": row[col_class] if col_class else None,
+                "formula": row[col_formula] if col_formula else None,
+                "inchikey": row[col_inchikey] if col_inchikey else None,
+                "smiles": row[col_smiles] if col_smiles else None,
+            })
         self.chrom_df = pd.DataFrame(traces)
         return
 
@@ -143,25 +141,23 @@ def chrom_from_oracle(
                 oracle_data.at[i, "lib_frags"] = frags
                 for _key, value in frags.items():
                     # add the fragment to the row
-                    traces.append(
-                        {
-                            "chid": qid,
-                            "type": "mrm",
-                            "name": row["name"] + " " + row["ion"],
-                            "group": row["name"] + " " + row["ion"],
-                            "prec_mz": row["mz"],
-                            "prod_mz": value,
-                            "rt": row["rt"],
-                            "rt_start": None,
-                            "rt_end": None,
-                            "istd": None,
-                            "adduct": row["ion"],
-                            "class": row["hg"],
-                            "formula": row["formula"],
-                            "inchikey": None,
-                            "smiles": None,
-                        },
-                    )
+                    traces.append({
+                        "chid": qid,
+                        "type": "mrm",
+                        "name": row["name"] + " " + row["ion"],
+                        "group": row["name"] + " " + row["ion"],
+                        "prec_mz": row["mz"],
+                        "prod_mz": value,
+                        "rt": row["rt"],
+                        "rt_start": None,
+                        "rt_end": None,
+                        "istd": None,
+                        "adduct": row["ion"],
+                        "class": row["hg"],
+                        "formula": row["formula"],
+                        "inchikey": None,
+                        "smiles": None,
+                    })
                     qid += 1
     self.chrom_df = pd.DataFrame(traces)
     return
@@ -190,25 +186,23 @@ def chrom_from_features(
         if row["feature_uid"] not in feature_uid:
             continue
 
-        traces.append(
-            {
-                "chid": chid,
-                "type": "ms1",
-                "name": f"MS1 fid:{row['feature_uid']} ({row['mz']:.4f})",
-                "group": f"fid:{row['feature_uid']}",
-                "prec_mz": row["mz"],
-                "prod_mz": None,
-                "rt": row["rt"],
-                "rt_start": row["rt_start"],
-                "rt_end": row["rt_end"],
-                "istd": None,
-                "adduct": None,
-                "class": None,
-                "formula": None,
-                "inchikey": None,
-                "smiles": None,
-            },
-        )
+        traces.append({
+            "chid": chid,
+            "type": "ms1",
+            "name": f"MS1 fid:{row['feature_uid']} ({row['mz']:.4f})",
+            "group": f"fid:{row['feature_uid']}",
+            "prec_mz": row["mz"],
+            "prod_mz": None,
+            "rt": row["rt"],
+            "rt_start": row["rt_start"],
+            "rt_end": row["rt_end"],
+            "istd": None,
+            "adduct": None,
+            "class": None,
+            "formula": None,
+            "inchikey": None,
+            "smiles": None,
+        })
         chid += 1
 
     self.chrom_df = pd.DataFrame(traces)