masster 0.3.8__py3-none-any.whl → 0.3.10__py3-none-any.whl

masster/sample/defaults/find_features_def.py

@@ -17,102 +17,100 @@ from typing import Any
 
 @dataclass
 class find_features_defaults:
+    """Configuration defaults for the feature-finding pipeline.
+
+    This dataclass centralizes parameters used by the `find_features()` routine
+    (mass-trace detection, elution-peak detection and feature assembly).  The
+    purpose of this docstring is to explain the role and impact of the main
+    parameters users commonly tune.
+
+    Main parameters (what they mean, units and guidance):
+
+    - chrom_fwhm (float, seconds):
+        Expected chromatographic peak full-width at half-maximum (FWHM) in
+        seconds. This value informs the peak detection algorithms about the
+        typical temporal width of chromatographic peaks. It is used for
+        smoothing, window sizes when searching for local maxima and when
+        calculating RT-based tolerances. Use a value that matches your LC
+        method: smaller values for sharp, fast chromatography and larger values
+        for broader peaks. Default: 1.0 s.
+
+    - noise (float, intensity units):
+        Intensity threshold used to filter out low-intensity signals before
+        mass-trace and peak detection. Points with intensity below this
+        threshold are treated as background and typically ignored. Raising
+        `noise` reduces false positives from background fluctuations but may
+        remove low-abundance true peaks; lowering it increases sensitivity at
+        the cost of more noise. Default: 200.0 (instrument-dependent).
+
+    - chrom_peak_snr (float, unitless):
+        Minimum signal-to-noise ratio required to accept a detected
+        chromatographic peak. SNR is typically computed as peak height
+        (or crest intensity) divided by an estimate of local noise. A higher
+        `chrom_peak_snr` makes detection stricter (fewer false positives),
+        while a lower value makes detection more permissive (more low-SNR
+        peaks accepted). Typical values range from ~3 (relaxed) to >10
+        (stringent). Default: 10.0.
+
+    Use these three parameters together to balance sensitivity and
+    specificity for your dataset: tune `chrom_fwhm` to match chromatographic
+    peak shapes, set `noise` to a conservative background level for your
+    instrument, then adjust `chrom_peak_snr` to control how aggressively
+    peaks are accepted or rejected.
+
+    The class also contains many other configuration options (mass tolerances,
+    isotope handling, post-processing and reporting flags). See individual
+    parameter metadata (`_param_metadata`) for allowed ranges and types.
     """
-    Parameters for mass spectrometry feature detection using OpenMS algorithms.
-
-    This class consolidates all parameters used in the find_features() method including
-    mass trace detection (MTD), elution peak detection (EPD), and feature finding (FFM).
-    It provides type checking, validation, and comprehensive parameter descriptions.
-
-    Mass Trace Detection (MTD) Parameters:
-        tol_ppm: Mass error tolerance in parts-per-million for mass trace detection.
-        noise: Noise threshold intensity to filter out low-intensity signals.
-        min_trace_length_multiplier: Multiplier for minimum trace length (multiplied by chrom_fwhm_min).
-        trace_termination_outliers: Number of outliers allowed before terminating a trace.
-
-    Elution Peak Detection (EPD) Parameters:
-        chrom_fwhm: Full width at half maximum for chromatographic peak shape.
-        chrom_fwhm_min: Minimum FWHM for chromatographic peak detection.
-        chrom_peak_snr: Signal-to-noise ratio required for chromatographic peaks.
-        masstrace_snr_filtering: Whether to apply SNR filtering to mass traces.
-        mz_scoring_13C: Whether to enable scoring of 13C isotopic patterns.
-        width_filtering: Width filtering method for mass traces.
-
-    Feature Finding (FFM) Parameters:
-        remove_single_traces: Whether to remove mass traces without satellite isotopic traces.
-        report_convex_hulls: Whether to report convex hulls for features.
-        report_summed_ints: Whether to report summed intensities.
-        report_chromatograms: Whether to report chromatograms.
-
-    Post-processing Parameters:
-        deisotope: Whether to perform deisotoping of detected features.
-        deisotope_mz_tol: m/z tolerance for deisotoping.
-        deisotope_rt_tol_factor: RT tolerance factor for deisotoping (multiplied by chrom_fwhm_min/4).
-        eic_mz_tol: m/z tolerance for EIC extraction.
-        eic_rt_tol: RT tolerance for EIC extraction.
-
-    Available Methods:
-        - validate(param_name, value): Validate a single parameter value
-        - validate_all(): Validate all parameters at once
-        - to_dict(): Convert parameters to dictionary
-        - set_from_dict(param_dict, validate=True): Update multiple parameters from dict
-        - set(param_name, value, validate=True): Set parameter value with validation
-        - get(param_name): Get parameter value
-        - get_description(param_name): Get parameter description
-        - get_info(param_name): Get full parameter metadata
-        - list_parameters(): Get list of all parameter names
-    """
-
+    
+    # Main params
+    noise: float = 200.0
+    chrom_fwhm: float = 1.0
+    chrom_peak_snr: float = 10.0
+    
     # Mass Trace Detection parameters
     tol_ppm: float = 30.0
-    noise: float = 200.0
-    min_trace_length_multiplier: float = 1.0
-    trace_termination_outliers: int = 2
+    reestimate_mt_sd: bool = True
+    quant_method: str = "area"
+    trace_termination_criterion: str = "outlier"
+    trace_termination_outliers: int = 5
+    min_sample_rate: float = 0.5
+
+    min_trace_length: float = 0.5
+    min_trace_length_multiplier: float = 0.2
+    max_trace_length: float = -1.0   
 
     # Elution Peak Detection parameters
-    chrom_fwhm: float = 1.0
-    chrom_fwhm_min: float = 0.5
-    chrom_peak_snr: float = 10.0
-    masstrace_snr_filtering: bool = False
-    mz_scoring_13C: bool = False
+    enabled: bool = True
+    chrom_fwhm_min: float = 0.2
+    chrom_fwhm_max: float = 60.0
     width_filtering: str = "fixed"
+    masstrace_snr_filtering: bool = False
 
     # Feature Finding parameters
+    local_rt_range: float = 1.0
+    local_mz_range: float = 5.0
+    charge_lower_bound: int = 0
+    charge_upper_bound: int = 5
+
+    report_smoothed_intensities: bool = False
     remove_single_traces: bool = False
     report_convex_hulls: bool = True
     report_summed_ints: bool = False
     report_chromatograms: bool = True
+    mz_scoring_13C: bool = False
+
+    threads: int = 1
+    no_progress: bool = False
+    debug: bool = False
 
     # Post-processing parameters
     deisotope: bool = True
     deisotope_mz_tol: float = 0.02
-    deisotope_rt_tol_factor: float = 0.25  # Will be multiplied by chrom_fwhm_min/4
-    eic_mz_tol: float = 0.01
-    eic_rt_tol: float = 10.0
+    deisotope_rt_tol_factor: float = 0.5  # Will be multiplied by chrom_fwhm
 
-    # Additional OpenMS FeatureFinderMetabo parameters
-    threads: int = 1
-    no_progress: bool = False
-    debug: bool = False
-    min_sample_rate: float = 0.5
-    min_trace_length: int = 5
-    min_fwhm: float = 1.0
-    max_fwhm: float = 60.0
-    
-    # Additional Mass Trace Detection parameters
-    trace_termination_criterion: str = "outlier"
-    reestimate_mt_sd: bool = True
-    quant_method: str = "area"
-    
-    # Additional Elution Peak Detection parameters
-    enabled: bool = True
-    
-    # Additional Feature Finding parameters
-    local_rt_range: float = 10.0
-    local_mz_range: float = 6.5
-    charge_lower_bound: int = 1
-    charge_upper_bound: int = 3
-    report_smoothed_intensities: bool = False
+    # chrom extraction parameters
+   
 
     # Parameter metadata for validation and description
     _param_metadata: dict[str, dict[str, Any]] = field(
@@ -132,8 +130,8 @@ class find_features_defaults:
             "min_trace_length_multiplier": {
                 "dtype": float,
                 "description": "Multiplier for minimum trace length calculation (multiplied by chrom_fwhm_min)",
-                "min_value": 1.0,
-                "max_value": 10.0,
+                "min_value": 0.1,
+                "max_value": 2.0,
             },
             "trace_termination_outliers": {
                 "dtype": int,
@@ -204,18 +202,6 @@ class find_features_defaults:
                 "min_value": 0.1,
                 "max_value": 2.0,
             },
-            "eic_mz_tol": {
-                "dtype": float,
-                "description": "m/z tolerance for EIC extraction (Da)",
-                "min_value": 0.001,
-                "max_value": 0.1,
-            },
-            "eic_rt_tol": {
-                "dtype": float,
-                "description": "RT tolerance for EIC extraction (seconds)",
-                "min_value": 1.0,
-                "max_value": 60.0,
-            },
             "threads": {
                 "dtype": int,
                 "description": "Number of threads to use for parallel processing",
@@ -242,13 +228,13 @@ class find_features_defaults:
                 "min_value": 2,
                 "max_value": 100,
             },
-            "min_fwhm": {
+'''            "min_fwhm": {
                 "dtype": float,
                 "description": "Minimum full width at half maximum for peaks (seconds)",
                 "min_value": 0.1,
                 "max_value": 10.0,
-            },
-            "max_fwhm": {
+            },'''
+            "chrom_fwhm_max": {
                 "dtype": float,
                 "description": "Maximum full width at half maximum for peaks (seconds)",
                 "min_value": 1.0,

masster/sample/defaults/sample_def.py

@@ -53,6 +53,9 @@ class sample_defaults:
     centroid_prominence: int = -1
     max_points_per_spectrum: int = 50000
     dia_window: float | None = None
+    
+    eic_mz_tol: float = 0.01
+    eic_rt_tol: float = 10.0
 
     _param_metadata: dict[str, dict[str, Any]] = field(
         default_factory=lambda: {
@@ -163,6 +166,18 @@ class sample_defaults:
                 "default": None,
                 "min_value": 0.0,
             },
+            "eic_mz_tol": {
+                "dtype": float,
+                "description": "m/z tolerance for EIC extraction (Da)",
+                "min_value": 0.001,
+                "max_value": 1.0,
+            },
+            "eic_rt_tol": {
+                "dtype": float,
+                "description": "RT tolerance for EIC extraction (seconds)",
+                "min_value": 0.2,
+                "max_value": 60.0,
+            },
         },
         repr=False,
     )

masster/sample/lib.py

@@ -421,14 +421,14 @@ def save_lib_mgf(
             # trim spectrum 2 Da lower and 10 Da higher than precursor m/z
             spec = spec.mz_trim(mz_min=row["mz"] - 2.0, mz_max=row["mz"] + 10.0)
 
-            filename: str = os.path.basename(self.file_path)
+            file_basename: str = os.path.basename(self.file_path)
             mslevel = 1 if spec.ms_level is None else spec.ms_level
             activation = None
             energy = None
             kineticenergy = None
             if mslevel > 1:
-                if "CID" in filename.upper() or "ZTS" in filename.upper():
-                    if "EAD" in filename.upper():
+                if "CID" in file_basename.upper() or "ZTS" in file_basename.upper():
+                    if "EAD" in file_basename.upper():
                         activation = "CID-EAD"
                         # search ([0-9]*KE) in filename.upper() using regex
                         match = re.search(r"(\d+)KE", str(filename.upper()))
@@ -440,14 +440,14 @@ def save_lib_mgf(
                                 kineticenergy = int(match.group(1))
                     else:
                         activation = "CID"
-                elif "EAD" in filename.upper():
+                elif "EAD" in file_basename.upper():
                     activation = "EAD"
                     # search ([0-9]*KE) in filename.upper() using regex
-                    match = re.search(r"(\d+)KE", filename.upper())
+                    match = re.search(r"(\d+)KE", file_basename.upper())
                     if match:
                         kineticenergy = int(match.group(1))
                     else:
-                        match = re.search(r"(\d+)EV", filename.upper())
+                        match = re.search(r"(\d+)EV", file_basename.upper())
                         if match:
                             kineticenergy = int(match.group(1))
                 energy = spec.energy if hasattr(spec, "energy") else None
@@ -515,14 +515,14 @@ def save_lib_mgf(
                                         kineticenergy = int(match.group(1))
                             else:
                                 activation = "CID"
-                        elif "EAD" in filename.upper():
+                        elif "EAD" in file_basename.upper():
                             activation = "EAD"
-                            # search ([0-9]*KE) in filename.upper() using regex
-                            match = re.search(r"(\d+)KE", filename.upper())
+                            # search ([0-9]*KE) in file_basename.upper() using regex
+                            match = re.search(r"(\d+)KE", file_basename.upper())
                             if match:
                                 kineticenergy = int(match.group(1))
                             else:
-                                match = re.search(r"(\d+)EV", filename.upper())
+                                match = re.search(r"(\d+)EV", file_basename.upper())
                                 if match:
                                     kineticenergy = int(match.group(1))
                             energy = spec.energy if hasattr(spec, "energy") else None
@@ -541,7 +541,7 @@ def save_lib_mgf(
                             "ACTIVATION": activation,
                             "COLLISIONENERGY": energy,
                             "KINETICENERGY": kineticenergy,
-                            "FILENAME": filename,
+                            "FILENAME": file_basename,
                             "SCANS": ms1_scan_uid,
                             "FID": row["feature_uid"],
                             "MSLEVEL": 1 if spec.ms_level is None else spec.ms_level,

masster/sample/plot.py

@@ -519,6 +519,14 @@ def plot_2d(
         # find features with ms2_scans not None  and iso==0
         features_df = feats[feats["ms2_scans"].notnull()]
         # Create feature points with proper sizing method
+        feature_hover_1 = HoverTool(tooltips=[
+            ("rt", "@rt"),
+            ("m/z", "@mz{0.0000}"),
+            ("feature_uid", "@feature_uid"),
+            ("inty", "@inty"),
+            ("quality", "@quality"),
+            ("rt_delta", "@rt_delta"),
+        ])
         feature_points_1 = hv.Points(
             features_df,
             kdims=["rt", "mz"],
@@ -536,11 +544,19 @@ def plot_2d(
             color=color_1,
             marker=marker_type,
             size=size_1,
-            tools=["hover"],
+            tools=[feature_hover_1],
             hooks=hooks,
         )
         # find features without MS2 data
         features_df = feats[feats["ms2_scans"].isnull()]
+        feature_hover_2 = HoverTool(tooltips=[
+            ("rt", "@rt"),
+            ("m/z", "@mz{0.0000}"),
+            ("feature_uid", "@feature_uid"),
+            ("inty", "@inty"),
+            ("quality", "@quality"),
+            ("rt_delta", "@rt_delta"),
+        ])
         feature_points_2 = hv.Points(
             features_df,
             kdims=["rt", "mz"],
@@ -557,7 +573,7 @@ def plot_2d(
             color="red",
             marker=marker_type,
             size=size_2,
-            tools=["hover"],
+            tools=[feature_hover_2],
             hooks=hooks,
         )
 
@@ -567,6 +583,16 @@ def plot_2d(
             # Convert to pandas for plotting compatibility
             if hasattr(features_df, "to_pandas"):
                 features_df = features_df.to_pandas()
+            feature_hover_iso = HoverTool(tooltips=[
+                ("rt", "@rt"),
+                ("m/z", "@mz{0.0000}"),
+                ("feature_uid", "@feature_uid"),
+                ("inty", "@inty"),
+                ("quality", "@quality"),
+                ("rt_delta", "@rt_delta"),
+                ("iso", "@iso"),
+                ("iso_of", "@iso_of"),
+            ])
             feature_points_iso = hv.Points(
                 features_df,
                 kdims=["rt", "mz"],
@@ -585,7 +611,7 @@ def plot_2d(
                 color="violet",
                 marker=marker_type,
                 size=size_1,
-                tools=["hover"],
+                tools=[feature_hover_iso],
                 hooks=hooks,
             )
     if show_ms2:
@@ -597,6 +623,13 @@ def plot_2d(
         if len(ms2_orphan) > 0:
             # pandalize
             ms2 = ms2_orphan.to_pandas()
+            ms2_hover_3 = HoverTool(tooltips=[
+                ("rt", "@rt"),
+                ("prec_mz", "@prec_mz{0.0000}"),
+                ("index", "@index"),
+                ("inty_tot", "@inty_tot"),
+                ("bl", "@bl"),
+            ])
             feature_points_3 = hv.Points(
                 ms2,
                 kdims=["rt", "prec_mz"],
@@ -606,7 +639,7 @@ def plot_2d(
                 color=color_2,
                 marker="x",
                 size=size_2,
-                tools=["hover"],
+                tools=[ms2_hover_3],
             )
 
         ms2_linked = self.scans_df.filter(pl.col("ms_level") == 2).filter(
@@ -615,6 +648,13 @@ def plot_2d(
         if len(ms2_linked) > 0:
             # pandalize
             ms2 = ms2_linked.to_pandas()
+            ms2_hover_4 = HoverTool(tooltips=[
+                ("rt", "@rt"),
+                ("prec_mz", "@prec_mz{0.0000}"),
+                ("index", "@index"),
+                ("inty_tot", "@inty_tot"),
+                ("bl", "@bl"),
+            ])
             feature_points_4 = hv.Points(
                 ms2,
                 kdims=["rt", "prec_mz"],
@@ -624,7 +664,7 @@ def plot_2d(
                 color=color_1,
                 marker="x",
                 size=size_2,
-                tools=["hover"],
+                tools=[ms2_hover_4],
             )
 
     overlay = raster
@@ -1041,6 +1081,18 @@ def plot_2d_oracle(
     feat_df = feats.copy()
     feat_df = feat_df[feat_df["id_level"] == 2]
 
+    oracle_hover_1 = HoverTool(tooltips=[
+        ("rt", "@rt"),
+        ("m/z", "@mz{0.0000}"),
+        ("feature_uid", "@feature_uid"),
+        ("id_level", "@id_level"),
+        ("id_class", "@id_class"),
+        ("id_label", "@id_label"),
+        ("id_ion", "@id_ion"),
+        ("id_evidence", "@id_evidence"),
+        ("score", "@score"),
+        ("score2", "@score2"),
+    ])
     feature_points_1 = hv.Points(
         feat_df,
         kdims=["rt", "mz"],
@@ -1062,7 +1114,7 @@ def plot_2d_oracle(
         marker="circle",
         size=markersize,
         fill_alpha=1.0,
-        tools=["hover"],
+        tools=[oracle_hover_1],
     )
 
     # feature_points_2 are all features that have ms2_scans not null and id_level ==1
@@ -1070,6 +1122,15 @@ def plot_2d_oracle(
     feat_df = feats.copy()
     feat_df = feat_df[(feat_df["ms2_scans"].notnull()) & (feat_df["id_level"] == 1)]
     if len(feat_df) > 0:
+        oracle_hover_2 = HoverTool(tooltips=[
+            ("rt", "@rt"),
+            ("m/z", "@mz{0.0000}"),
+            ("feature_uid", "@feature_uid"),
+            ("id_level", "@id_level"),
+            ("id_label", "@id_label"),
+            ("id_ion", "@id_ion"),
+            ("id_class", "@id_class"),
+        ])
         feature_points_2 = hv.Points(
             feat_df,
             kdims=["rt", "mz"],
@@ -1088,7 +1149,7 @@ def plot_2d_oracle(
             marker="circle",
             size=markersize,
             fill_alpha=0.0,
-            tools=["hover"],
+            tools=[oracle_hover_2],
         )
 
     # feature_points_3 are all features that have ms2_scans null and id_level ==1
@@ -1096,6 +1157,15 @@ def plot_2d_oracle(
     feat_df = feats.copy()
     feat_df = feat_df[(feat_df["ms2_scans"].isnull()) & (feat_df["id_level"] == 1)]
     if len(feat_df) > 0:
+        oracle_hover_3 = HoverTool(tooltips=[
+            ("rt", "@rt"),
+            ("m/z", "@mz{0.0000}"),
+            ("feature_uid", "@feature_uid"),
+            ("id_level", "@id_level"),
+            ("id_label", "@id_label"),
+            ("id_ion", "@id_ion"),
+            ("id_class", "@id_class"),
+        ])
         feature_points_3 = hv.Points(
             feat_df,
             kdims=["rt", "mz"],
@@ -1114,7 +1184,7 @@ def plot_2d_oracle(
             marker="diamond",
             size=markersize,
             fill_alpha=0.0,
-            tools=["hover"],
+            tools=[oracle_hover_3],
         )
 
     # feature_points_4 are all features that have ms2_scans null and id_level ==0
@@ -1122,6 +1192,12 @@ def plot_2d_oracle(
     feat_df = feats.copy()
     feat_df = feat_df[(feat_df["ms2_scans"].notnull()) & (feat_df["id_level"] < 1)]
     if len(feat_df) > 0:
+        oracle_hover_4 = HoverTool(tooltips=[
+            ("rt", "@rt"),
+            ("m/z", "@mz{0.0000}"),
+            ("feature_uid", "@feature_uid"),
+            ("inty", "@inty"),
+        ])
         feature_points_4 = hv.Points(
             feat_df,
             kdims=["rt", "mz"],
@@ -1132,14 +1208,20 @@ def plot_2d_oracle(
             marker="circle",
             size=markersize,
             fill_alpha=0.0,
-            tools=["hover"],
+            tools=[oracle_hover_4],
         )
 
-    # feature_points_4 are all features that have ms2_scans null and id_level ==0
+    # feature_points_5 are all features that have ms2_scans null and id_level ==0
     feature_points_5 = None
     feat_df = feats.copy()
     feat_df = feat_df[(feat_df["ms2_scans"].isnull()) & (feat_df["id_level"] < 1)]
     if len(feat_df) > 0:
+        oracle_hover_5 = HoverTool(tooltips=[
+            ("rt", "@rt"),
+            ("m/z", "@mz{0.0000}"),
+            ("feature_uid", "@feature_uid"),
+            ("inty", "@inty"),
+        ])
         feature_points_5 = hv.Points(
             feat_df,
             kdims=["rt", "mz"],
@@ -1150,7 +1232,7 @@ def plot_2d_oracle(
             marker="diamond",
             fill_alpha=0.0,
             size=markersize,
-            tools=["hover"],
+            tools=[oracle_hover_5],
         )
 
     overlay = raster

masster/sample/processing.py

@@ -19,55 +19,34 @@ from .defaults.get_spectrum_def import get_spectrum_defaults
 
 
 def get_spectrum(self, scan, **kwargs):
-    """
-    Retrieve and process a spectrum from the data file based on the given scan identifier.
-
-    This method locates the scan in the internal DataFrame, extracts the metadata (such as energy,
-    MS level, and retention time), and then retrieves the corresponding spectrum data from the file.
-    Depending on the file interface (either 'oms' or 'alpharaw'), the spectrum data is obtained
-    and processed (including optional denoising, centroiding, deisotoping, and precursor m/z trimming).
-
-    Parameters:
-        scan (int): Unique identifier of the scan to retrieve. This is a mandatory parameter.
-        **kwargs: Keyword arguments for spectrum retrieval parameters. Can include:
-            - A get_spectrum_defaults instance to set all parameters at once
-            - Individual parameter names and values (see get_spectrum_defaults for details)
-
-    Key Parameters:
-        precursor_trim (int, optional): Value used to trim the precursor m/z for MS2 spectra.
-                                        If provided and the spectrum's MS level is greater than 1,
-                                        m/z values above (precursor_mz - precursor_trim) will be trimmed.
-                                        Default is 20.
-        max_peaks (int, optional): Maximum number of peaks to retain in the spectrum. Default is 100.
-        centroid (bool, optional): Flag indicating whether the spectrum should be centroided.
-                                    If True and the spectrum is not already centroided, the method
-                                    applies denoising followed by centroiding using parameters from self.parameters.
-                                    Default is True.
-        deisotope (bool, optional): Flag indicating whether deisotoping should be performed. Default is False.
-        dia_stats (optional): Flag or parameter for processing DIA (data-independent acquisition)
-                                statistics. If provided (and if applicable to the file type), additional
-                                statistics will be computed for 'ztscan' files. Default is None.
-        feature (optional): An optional identifier used when computing DIA statistics. Default is None.
-        label (str, optional): Optional label to assign to the spectrum. If not provided,
-                                a default name is generated based on the MS level and retention time.
-                                Default is None.
-        centroid_algo (str, optional): Algorithm to use for centroiding. Default is None.
+    """Retrieve a single spectrum and optionally post-process it.
+
+    The function locates the requested scan in ``self.scans_df`` and returns a
+    :class:`Spectrum` object. Processing steps (centroiding, deisotoping,
+    trimming and optional DIA statistics) are controlled by parameters defined
+    in :class:`get_spectrum_defaults`. Pass an instance of that class via
+    ``**kwargs`` or override individual parameters (they will be validated
+    against the defaults class).
+
+    Main parameters (from ``get_spectrum_defaults``):
+
+    - scan (list[int]): Scan id(s) to retrieve. A single integer or a list is accepted.
+    - precursor_trim (int): m/z window used to trim precursor region for MS2 (default: -10).
+    - max_peaks (int | None): Maximum number of peaks to keep; ``None`` keeps all.
+    - centroid (bool): Whether to centroid the spectrum (default: True).
+    - deisotope (bool): Whether to apply deisotoping (default: True).
+    - dia_stats (bool | None): Collect DIA/ztscan statistics when applicable (default: False).
+    - feature (int | None): Optional feature id used for computing DIA statistics.
+    - label (str | None): Optional label to assign to the returned Spectrum.
+    - centroid_algo (str | None): Centroiding algorithm to use (allowed: 'lmp', 'cwt', 'gaussian').
 
     Returns:
-        spectrum: A processed spectrum object containing:
-                    - m/z and intensity arrays
-                    - metadata such as MS level, retention time, energy, and an assigned label
-                    Depending on the processing steps (centroiding, trimming, deisotoping, etc.), the
-                    returned spectrum is modified accordingly.
-                    Returns None or an empty spectrum if the scan is not found or if an error occurs.
+        Spectrum or None: Processed spectrum object (may be an empty Spectrum if
+        the scan is missing or on error).
 
     Notes:
-        - For the 'oms' file interface, the spectrum is retrieved via self.file_obj.getSpectrum
-            and handled accordingly.
-        - For the 'alpharaw' file interface, the method uses internal DataFrame attributes to locate the
-            scan and its associated peaks.
-        - The method applies additional processing (denoising, centroiding, deisotoping, trimming) based on
-            the input flags and the MS level of the spectrum.
+        This wrapper validates provided parameters against ``get_spectrum_defaults``.
+        Use the defaults class to discover parameter constraints and allowed values.
     """
 
     # parameters initialization
@@ -510,40 +489,47 @@ def _spec_to_mat(
 
 
 def find_features(self, **kwargs):
-    """
-    Detect features in mass spectrometry data by processing MS1 spectra, performing mass trace detection,
-    elution peak detection, and feature detection. Optionally, deisotope features and remove low-quality peaks.
+    """Detect features from MS1 data (mass-trace detection, peak deconvolution, feature assembly).
 
-    This method leverages an MSExperiment constructed from the object's ms1_df, where each cycle in the data
-    corresponds to an MSSpectrum. It then runs mass trace detection using set parameters, deconvolutes the mass
-    traces to detect chromatographic peaks, and finally identifies features with a feature finding algorithm. The
-    resulting feature map is cleaned, deisotoped (if enabled), and assigned unique IDs before being stored.
+    The method converts internal MS1 data into an MSExperiment (one MSSpectrum per cycle), runs mass-trace
+    detection, deconvolutes mass traces to find chromatographic peaks, and assembles features. Results are
+    cleaned, optionally deisotoped, assigned unique IDs and stored in ``self.features`` / ``self.features_df``.
 
     Parameters:
-        **kwargs: Keyword arguments for feature detection parameters. Can include:
-            - A find_features_defaults instance to set all parameters at once
-            - Individual parameter names and values (see find_features_defaults for details)
-
-    Key Parameters:
-        tol_ppm (float): Mass error tolerance in parts-per-million for mass trace detection (default: 30.0).
-        noise (float): Noise threshold intensity to filter out low-intensity signals (default: 200.0).
-        chrom_fwhm (float): Full width at half maximum for chromatographic peak shape (default: 1.0).
-        chrom_fwhm_min (float): Minimum FWHM for chromatographic peak detection (default: 0.5).
-        chrom_peak_snr (float): Signal-to-noise ratio required for chromatographic peaks (default: 10.0).
-        mz_scoring_13C (bool): Whether to enable scoring of 13C isotopic patterns (default: False).
-        masstrace_snr_filtering (bool): Whether to apply SNR filtering to mass traces (default: False).
-        deisotope (bool): Whether to perform deisotoping of detected features (default: True).
+        **kwargs: Keyword overrides for any parameter available in :class:`find_features_defaults`.
+            You may pass a full ``find_features_defaults`` instance or individual parameter values.
+
+    Main parameters (what they mean, units and tuning guidance):
+
+    - chrom_fwhm (float, seconds):
+        Expected chromatographic peak full-width at half-maximum (FWHM) in seconds. This guides smoothing,
+        peak-finding window sizes and RT-based tolerances. Choose a value that matches your LC peak widths:
+        small values (e.g. 0.2–0.8 s) for sharp/fast separations, larger values (several seconds) for broad peaks.
+        Default: 1.0 s.
+
+    - noise (float, intensity units):
+        Intensity threshold used to ignore background points before mass-trace and peak detection. Raising
+        ``noise`` reduces false positives from baseline fluctuations but may discard low-abundance true signals;
+        lowering it increases sensitivity but raises the false-positive rate. Set this to a conservative estimate of
+        your instrument baseline (default: 200.0, instrument-dependent).
+
+    - chrom_peak_snr (float, unitless):
+        Minimum signal-to-noise ratio required to accept an elution peak during peak deconvolution. SNR is usually
+        computed as peak height divided by a local noise estimate. Higher values make detection stricter (fewer
+        low-quality peaks), lower values make it more permissive. Typical tuning range: ~3 (relaxed) to >10
+        (stringent). Default: 10.0.
+
+    Tuning recommendation: first set ``chrom_fwhm`` to match your LC peak shape, then set ``noise`` to a baseline
+    intensity filter for your data, and finally adjust ``chrom_peak_snr`` to reach the desired balance between
+    sensitivity and specificity.
 
     Attributes set:
-        self.features: An updated feature map with unique IDs after feature detection and deisotoping.
-        self.features_df: A cleaned DataFrame of features, with peaks of zero quality removed, representing the final
-                            detected features.
+        self.features: OpenMS FeatureMap produced by the routine (after ensureUniqueId).
+        self.features_df: cleaned polars DataFrame of detected features (zero-quality peaks removed).
 
     Notes:
-        - The method processes the ms1_df by iterating over cycles to build an MSExperiment.
-        - External OMS modules (e.g., MSExperiment, MSSpectrum, MassTraceDetection, ElutionPeakDetection,
-            FeatureFindingMetabo) are used throughout the processing.
-        - After feature detection, additional cleaning is performed via internal helper methods.
+        The implementation relies on OpenMS components (MassTraceDetection, ElutionPeakDetection,
+        FeatureFindingMetabo). See ``find_features_defaults`` for the full list of adjustable parameters.
     """
     if self.ms1_df is None:
         self.logger.error("No MS1 data found. Please load a file first.")
@@ -570,14 +556,20 @@ def find_features(self, **kwargs):
                 self.logger.warning(f"Unknown parameter {key} ignored")
 
     # Set global parameters
-    if params.get('threads') is not None:
-        oms.OpenMSConfig.setNumThreads(params['threads'])
+    if hasattr(params, 'threads') and params.threads is not None:
+        try:
+            # Try setting via OpenMP environment variable first (newer approach)
+            import os
+            os.environ['OMP_NUM_THREADS'] = str(params.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")
     
     # Set debug mode if enabled
-    if params.get('debug'):
-        oms.OpenMSConfig.setLogLevel(oms.LogType.DEBUG)
-    elif params.get('no_progress', False):
-        oms.OpenMSConfig.setLogLevel(oms.LogType.NONE)
+    if hasattr(params, 'debug') and params.debug:
+        self.logger.debug("Debug mode enabled")
+    elif hasattr(params, 'no_progress') and params.no_progress:
+        self.logger.debug("No progress mode enabled")
     
     self.logger.info("Starting feature detection...")
     self.logger.debug(
@@ -610,8 +602,7 @@ def find_features(self, **kwargs):
     # Apply MTD parameters
     mtd_par.setValue("mass_error_ppm", float(params.get("tol_ppm")))
     mtd_par.setValue("noise_threshold_int", float(params.get("noise")))
-    mtd_par.setValue(
-        "min_trace_length",
+    mtd_par.setValue("min_trace_length",
         float(params.get("min_trace_length_multiplier")) * float(params.get("chrom_fwhm_min")),
     )
     mtd_par.setValue(
@@ -622,7 +613,7 @@ 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", int(params.get("min_trace_length")))
+    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("quant_method", params.get("quant_method"))
@@ -638,6 +629,7 @@ def find_features(self, **kwargs):
     # Apply EPD parameters using our parameter class
     epd_par.setValue("width_filtering", params.get("width_filtering"))
     epd_par.setValue("min_fwhm", float(params.get("chrom_fwhm_min")))
+    epd_par.setValue("max_fwhm", float(params.get("chrom_fwhm_max")))
     epd_par.setValue("chrom_fwhm", float(params.get("chrom_fwhm")))
     epd_par.setValue("chrom_peak_snr", float(params.get("chrom_peak_snr")))
     if params.get("masstrace_snr_filtering"):
@@ -648,10 +640,6 @@ def find_features(self, **kwargs):
     # Additional EPD parameters
     epd_par.setValue("enabled", "true" if params.get("enabled") else "false")
     
-    # Set min/max FWHM parameters
-    epd_par.setValue("min_fwhm", float(params.get("min_fwhm")))
-    epd_par.setValue("max_fwhm", float(params.get("max_fwhm")))
-
     epd.setParameters(epd_par)
     epd.detectPeaks(mass_traces, mass_traces_deconvol)
 
@@ -678,18 +666,19 @@ def find_features(self, **kwargs):
         "report_chromatograms",
         "true" if params.get("report_chromatograms") else "false",
     )
-    
+    ffm_par.setValue(
+        "report_smoothed_intensities",
+        "true" if params.get("report_smoothed_intensities") else "false",
+    )
     # Additional FFM parameters
     ffm_par.setValue("local_rt_range", float(params.get("local_rt_range")))
     ffm_par.setValue("local_mz_range", float(params.get("local_mz_range")))
     ffm_par.setValue("charge_lower_bound", int(params.get("charge_lower_bound")))
     ffm_par.setValue("charge_upper_bound", int(params.get("charge_upper_bound")))
-    ffm_par.setValue(
-        "report_smoothed_intensities",
-        "true" if params.get("report_smoothed_intensities") else "false",
-    )
+    
 
     ffm.setParameters(ffm_par)
+
     self.logger.debug("Running feature finding with parameters:")
     self.logger.debug(ffm_par)
     ffm.run(mass_traces_deconvol, feature_map, chrom_out)
@@ -706,7 +695,7 @@ def find_features(self, **kwargs):
     df = self._features_deisotope(
         df,
         mz_tol=params.get("deisotope_mz_tol"),
-        rt_tol=params.get("chrom_fwhm_min") / 4 * params.get("deisotope_rt_tol_factor"),
+        rt_tol=params.get("chrom_fwhm") * params.get("deisotope_rt_tol_factor"),
     )
     if params.get("deisotope"):
         # record size before deisotoping
@@ -723,8 +712,8 @@ def find_features(self, **kwargs):
     prominence_scaleds: list[float] = []
     height_scaleds: list[float] = []
 
-    mz_tol = params.get("eic_mz_tol")
-    rt_tol = params.get("eic_rt_tol")
+    mz_tol = self.parameters.get("eic_mz_tol")
+    rt_tol = self.parameters.get("eic_rt_tol")
 
     # iterate over all rows in df using polars iteration
     self.logger.debug("Extracting EICs...")
@@ -801,27 +790,44 @@ def find_features(self, **kwargs):
 
 
 def find_adducts(self, **kwargs):
-    """
-    Detect adducts in mass spectrometry features using OpenMS MetaboliteFeatureDeconvolution.
+    """Detect adduct relationships among detected features.
 
-    This method analyzes detected features to identify adduct relationships based on mass differences,
-    charge states, and retention time proximity. It groups features that likely represent the same
-    metabolite in different ionization states.
+    This method groups features that are likely adducts of the same molecular entity
+    using OpenMS MetaboliteFeatureDeconvolution. Parameters are taken from the
+    :class:`find_adducts_defaults` dataclass; you can pass an instance of that class
+    via ``**kwargs`` or override individual parameter names (they will be validated
+    against the defaults class).
 
-    Parameters:
-        **kwargs: Keyword arguments for adduct detection parameters. Can include:
-            - A find_adducts_defaults instance to set all parameters at once
-            - Individual parameter names and values (see find_adducts_defaults for details)
+    Main parameters (from ``find_adducts_defaults``):
 
-    Key Parameters:
-        adducts (Union[List[str], str, None]): List of potential adducts or ionization mode string.
-        charge_min (int): Minimal possible charge state (default: 1).
-        charge_max (int): Maximal possible charge state (default: 2).
-        retention_max_diff (float): Maximum retention time difference for grouping (default: 1.0).
+    - adducts (list[str] | str | None):
+        List of potential adduct strings formatted for OpenMS, or a short ionization
+        mode string (``'pos'``/``'neg'``). When ``None`` a sensible positive-mode
+        default set is used.
 
-    Attributes set:
-        self.features_df: Updated with adduct information including 'adduct', 'adduct_mass',
-                         and 'adduct_group' columns.
+    - charge_min (int):
+        Minimum allowed charge state for grouping (default: 1).
+
+    - charge_max (int):
+        Maximum allowed charge state for grouping (default: 2).
+
+    - charge_span_max (int):
+        Maximum span between different charge states within the same adduct group
+        (default: 2).
+
+    - retention_max_diff (float, minutes):
+        Global maximum retention-time difference allowed for grouping (default: 1.0).
+
+    - retention_max_diff_local (float, minutes):
+        A tighter, local RT tolerance used for fine-grained grouping (default: 1.0).
+
+    Side effects:
+        Updates ``self.features_df`` with columns ``adduct``, ``adduct_mass`` and
+        ``adduct_group`` populated from the OpenMS results.
+
+    Notes:
+        Use ``find_adducts_defaults`` to inspect available parameters and their
+        canonical descriptions/constraints.
     """
     params = find_adducts_defaults()
     for key, value in kwargs.items():
@@ -1171,54 +1177,44 @@ def analyze_dda(self):
 
 
 def find_ms2(self, **kwargs):
-    """
-    Link MS2 spectra to features in the dataset.
-    This method matches MS2 spectra from the scans dataframe with features in the features dataframe
-    based on retention time (RT) and precursor m/z tolerance criteria. For each feature in the provided
-    or inferred list of feature ids (feature_uid), it computes the RT difference between the feature and available
-    MS2 spectra. It then selects MS2 spectra that fall within a computed RT radius (based on the feature's
-    start and end times) and a specified m/z tolerance. For each feature, it chooses one MS2 spectrum per
-    unique cycle based on the closest RT difference, and it updates the feature with the list of matched
-    scan ids and the spectrum corresponding to the first matching scan id. Additionally, the scan dataframe
-    is updated to associate matched scan ids with the corresponding feature id.
+    """Link MS2 spectra to detected features.
 
-    Parameters:
-        **kwargs: Keyword arguments for MS2 linking parameters. Can include:
-            - A find_ms2_defaults instance to set all parameters at once
-            - Individual parameter names and values (see find_ms2_defaults for details)
-
-    Key Parameters:
-        features (int or list of int, optional): A specific feature id or a list of feature ids to process.
-            If an individual feature_uid is provided and equals -1, all features with no associated MS2 data will be processed.
-            If None, all features in the features dataframe are processed.
-        mz_tol (float, optional): The precursor m/z tolerance to consider when matching MS2 spectra. If not provided,
-            it defaults to 0.5, except for certain file types ('ztscan' or 'dia') which set it to 4.
-        centroid (bool, optional): If True, the returned spectrum will be centroided. Default is True.
-        deisotope (bool, optional): Flag indicating whether deisotoping should be performed. Default is False.
-        dia_stats (bool, optional): A flag to collect additional DIA-related statistics when retrieving a spectrum.
-            Default is False.
+    Matches MS2 scans from ``self.scans_df`` to features in ``self.features_df`` using
+    retention time and precursor m/z criteria. Parameters are defined in
+    :class:`find_ms2_defaults`; pass an instance via ``**kwargs`` or override
+    individual parameters (they will be validated against the defaults class).
 
-    Returns:
-        None
+    Main parameters (from ``find_ms2_defaults``):
+
+    - mz_tol (float):
+        Precursor m/z tolerance used for matching. The effective tolerance may be
+        adjusted by file type (the defaults class provides ``get_mz_tolerance(file_type)``).
+        Default: 0.5 (ztscan/DIA defaults may be larger).
+
+    - centroid (bool):
+        If True, retrieved spectra will be centroided (default: True).
 
-    Side Effects:
-        Updates self.features_df with new columns 'ms2_scans' (a list of scan ids) and 'ms2_specs' (containing
-        the retrieved spectrum for the first matched scan id). Also, self.scans_df is updated by setting the 'feature_uid'
-        column for matched MS2 spectra.
+    - deisotope (bool):
+        If True, spectra will be deisotoped before returning (default: False).
+
+    - dia_stats (bool):
+        Collect additional DIA/ztscan statistics when retrieving spectra (default: False).
+
+    - features (int | list[int] | None):
+        Specific feature uid or list of uids to process. Use ``None`` to process all
+        features. An empty list is treated as ``None``.
+
+    - mz_tol_ztscan (float):
+        m/z tolerance used for ztscan/DIA file types (default: 4.0).
+
+    Side effects:
+        Updates ``self.features_df`` with columns ``ms2_scans`` and ``ms2_specs`` and
+        updates ``self.scans_df`` to set the ``feature_uid`` for matched scans.
 
     Notes:
-        - The function uses vectorized operations to quickly filter MS2 spectra with ms_level equal to 2.
-        - If no MS2 spectra are available or if features_df is not loaded, appropriate messages are printed and the
-            method exits early.
-        - The function assumes that self.features_df and self.scans_df are already set up and contain the expected
-            columns ('feature_uid', 'rt', 'rt_start', 'rt_end', 'mz' for features and 'scan_uid', 'rt', 'prec_mz', 'cycle', 'ms_level'
-            for scans).
-
-    Examples:
-        Assume the current instance has features and scans data loaded, then to link MS2 spectra for all features:
-            instance.find_ms2()
-        To link MS2 spectra for a specific list of feature ids:
-            instance.find_ms2(feature_uid=[1, 3, 5])
+        The function is implemented to be efficient by vectorizing the matching
+        and performing batch updates. Use ``find_ms2_defaults`` to inspect all
+        available parameters and their canonical descriptions.
     """
 
     # parameters initialization
@@ -1368,6 +1364,7 @@ def find_ms2(self, **kwargs):
 
     self.logger.debug("Update features.")
     # Convert to polars if needed and batch update features_df
+    # Convert to polars if needed and batch update features_df
     if not isinstance(features_df, pl.DataFrame):
         features_df = pl.from_pandas(features_df)
 

masster/study/processing.py

@@ -17,22 +17,19 @@ from masster.study.defaults import (
 
 
 def align(self, **kwargs):
-    """
-    Aligns feature maps using pose clustering and updates retention times in the features DataFrame.
-
-    Parameters:
-        **kwargs: Keyword arguments for alignment parameters. Can include:
-            - An align_defaults instance to set all parameters at once
-            - Individual parameter names and values (see align_defaults for details)
-
-    Key Parameters:
-        rt_max_diff (float): Maximum RT difference for alignment (default: 60.0).
-        mz_max_diff (float): Maximum m/z difference for alignment (default: 0.01).
-        rt_pair_distance_frac (float): RT pair distance fraction for superimposer (default: 0.2).
-        mz_pair_max_distance (float): Maximum m/z pair distance for superimposer (default: 0.01).
-        num_used_points (int): Number of points used for superimposer (default: 1000).
-        save_features (bool): Whether to save features after alignment (default: True).
-        skip_blanks (bool): Whether to skip blank samples during alignment  (default: True).
+    """Align feature maps using pose clustering and update feature RTs.
+
+    Parameters can be provided as an ``align_defaults`` instance or as
+    individual keyword arguments; they are validated against the defaults class.
+
+    Key parameters (from ``align_defaults``):
+        - rt_max_diff (float): Maximum RT difference for pair finding (seconds).
+        - mz_max_diff (float): Maximum m/z difference for pair finding (Da).
+        - rt_pair_distance_frac (float): RT fraction used by the superimposer.
+        - mz_pair_max_distance (float): Max m/z distance for pair selection.
+        - num_used_points (int): Number of points to use for alignment estimation.
+        - save_features (bool): If True, save updated features after alignment.
+        - skip_blanks (bool): If True, skip blank samples during alignment.
     """
     # parameters initialization
     params = align_defaults()
@@ -225,20 +222,17 @@ def align(self, **kwargs):
 
 
 def merge(self, **kwargs):
-    """
-    Groups features across samples into consensus features using the specified algorithm.
+    """Group features across samples into consensus features.
 
-    Parameters:
-        **kwargs: Keyword arguments for consensus parameters. Can include:
-            - A merge_defaults instance to set all parameters at once
-            - Individual parameter names and values (see merge_defaults for details)
-
-    Key Parameters:
-        algorithm (str): Feature grouping algorithm ('kd', 'unlabeled', 'sequential', or default 'qt').
-        min_samples (int): Minimum number of samples for a consensus feature.
-        link_ms2 (bool): Whether to link MS2 spectra to consensus features.
-        mz_tol (float): m/z tolerance for grouping (default: 0.01).
-        rt_tol (float): RT tolerance for grouping (default: 1.0).
+    Parameters can be provided as a ``merge_defaults`` instance or as
+    individual keyword arguments; they are validated against the defaults class.
+
+    Key parameters (from ``merge_defaults``):
+        - algorithm (str): Grouping algorithm to use ('qt', 'kd', 'unlabeled', 'sequential').
+        - min_samples (int): Minimum number of samples required for a consensus feature.
+        - link_ms2 (bool): Whether to attach/link MS2 spectra to consensus features.
+        - mz_tol (float): m/z tolerance for grouping (Da).
+        - rt_tol (float): RT tolerance for grouping (seconds).
     """
     # Reset consensus-related DataFrames at the start
     self.consensus_df = pl.DataFrame()
@@ -768,17 +762,20 @@ def filter_consensus(
 
 ## TODO is uid supposed to be a list? rt_tol 0?
 def _integrate_chrom_impl(self, **kwargs):
-    """
-    Given a consensus_id, integrate the intensity of all features in the consensus map.
+    """Integrate chromatogram intensities for consensus features.
 
-    Parameters:
-        **kwargs: Keyword arguments for integration parameters. Can include:
-            - An integrate_chrom_defaults instance to set all parameters at once
-            - Individual parameter names and values (see integrate_chrom_defaults for details)
+    Integrates EICs for consensus features using parameters defined in
+    :class:`integrate_defaults`. Pass an ``integrate_defaults`` instance via
+    ``**kwargs`` or override individual parameters (they will be validated
+    against the defaults class).
+
+    Main parameters (from ``integrate_defaults``):
+
+    - uids (Optional[list]): List of consensus UIDs to integrate; ``None`` means all.
+    - rt_tol (float): RT tolerance (seconds) used when locating integration boundaries.
 
-    Key Parameters:
-        uids: List of consensus UIDs to integrate (default: all consensus features).
-        rt_tol: RT tolerance for integration boundaries.
+    Notes:
+        This function batches updates to the study's feature table for efficiency.
     """
     # parameters initialization
     params = integrate_defaults()
@@ -984,17 +981,11 @@ def _integrate_chrom_impl(self, **kwargs):
 
 
 def integrate(self, **kwargs):
-    """
-    Integrate chromatograms across consensus features.
-
-    Parameters:
-        **kwargs: Keyword arguments for integration parameters. Can include:
-            - An integrate_defaults instance to set all parameters at once
-            - Individual parameter names and values (see integrate_defaults for details)
+    """Integrate chromatograms across consensus features.
 
-    Key Parameters:
-        uids (Optional[list]): List of consensus UIDs to integrate (None for all).
-        rt_tol (float): RT tolerance for integration boundaries (default: 0.0).
+    Wrapper that extracts parameters from :class:`integrate_defaults` and
+    calls the underlying implementation. See ``integrate_defaults`` for
+    the canonical parameter list and descriptions.
     """
     # parameters initialization
     params = integrate_defaults()

{masster-0.3.8.dist-info → masster-0.3.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: masster
-Version: 0.3.8
+Version: 0.3.10
 Summary: Mass spectrometry data analysis package
 Project-URL: homepage, https://github.com/zamboni-lab/masster
 Project-URL: repository, https://github.com/zamboni-lab/masster

{masster-0.3.8.dist-info → masster-0.3.10.dist-info}/RECORD

@@ -13,11 +13,11 @@ masster/data/examples/2025_01_14_VW_7600_LpMx_DBS_CID_2min_TOP15_030msecMS1_005m
 masster/sample/__init__.py,sha256=HL0m1ept0PMAYUCQtDDnkdOS12IFl6oLAq4TZQz83uY,170
 masster/sample/h5.py,sha256=aGj3vJsM08wiWFKryRCn5ROKBSRX85vE0Z-jiPSqLjI,63817
 masster/sample/helpers.py,sha256=OEgvR3bptA-tEqHAFVPjWpbagKXAU1h0bePPi9ttHa4,34842
-masster/sample/lib.py,sha256=9r2XlF_BaJ4WNAsQo8hElieRLwsAv0yrbYq4DJ0iVOM,33496
+masster/sample/lib.py,sha256=l5YdU9TxEWJI0kJxXxrRCxgDDwbzO5zBf1_Qi_HY87w,33556
 masster/sample/load.py,sha256=y-KUJ2nCFX_06FHPUOh-CzRRvaTx14xNcXoL19bU8qY,47562
 masster/sample/parameters.py,sha256=Gg2KcuNbV_wZ_Wwv93QlM5J19ji0oSIvZLPV1NoBmq0,4456
-masster/sample/plot.py,sha256=uUJAd2qxhVG6Ev2hLuU406zFA2TDkkBz2MG12P9fLik,71449
-masster/sample/processing.py,sha256=Ee0jpu314cLFxhfpARcWTCObm70LWhCCmyNYOFI6hwc,59861
+masster/sample/plot.py,sha256=2fEHy3rQDj6JOZEev__xyA7_6de1y4s_U2hj2xiAU5w,74439
+masster/sample/processing.py,sha256=NOx8c_y6oXVY3LCnxY9Rw4ekr_nqbIEf8LLlsYva_oY,57503
 masster/sample/quant.py,sha256=tHNjvUFTdehKR31BXBZnVsBxMD9XJHgaltITOjr71uE,7562
 masster/sample/sample.py,sha256=ekS-qBfzx3_Lb2KLMu-s90owRlk3lK4616mmiAiiHTc,16726
 masster/sample/sample5_schema.json,sha256=3SPFQZH4SooLYUt_lW-PCOE9rHnl56Vhc2XG-r1nyEQ,3586
@@ -25,10 +25,10 @@ masster/sample/save.py,sha256=o9eFSqqr7KYwvCD3gOJt_nZ4h3pkflWqs0n0oSLM-sU,31970
 masster/sample/sciex.py,sha256=q6PdcjCtV2PWnJiXuvfISu09zjkaTR_fvHvWN9OvOcM,46870
 masster/sample/defaults/__init__.py,sha256=A09AOP44cxD_oYohyt7XFUho0zndRcrzVD4DUaGnKH4,447
 masster/sample/defaults/find_adducts_def.py,sha256=6CcGRlz4VeosoBT_W0bkR1Kjj11Rq3QvuuOnkizIZyk,11630
-masster/sample/defaults/find_features_def.py,sha256=Qh-_HT2uPn7xdG7p-j0nOvS2kMammxQYyD0Hl8L_Zcw,17924
+masster/sample/defaults/find_features_def.py,sha256=qTf9G3h6zhfxUk7TEPT5hAwgQ3gZthavoN89okhVVeQ,17193
 masster/sample/defaults/find_ms2_def.py,sha256=KTELMAnioGLYbhzAwOgK14TZqboPEvzeBN0HC-v0Z5A,9872
 masster/sample/defaults/get_spectrum_def.py,sha256=o62p31PhGd-LiIkTOzKQhwPtnO2AtQDHcPu-O-YoQPs,11460
-masster/sample/defaults/sample_def.py,sha256=t8vrb8MoBBsFQcRzlaT0-q0hAssOxWO7vhCAJU3_THs,14068
+masster/sample/defaults/sample_def.py,sha256=Q_yal7iYBnGEty4uPlOiAp9OKX5392HsAKezA3xCb34,14583
 masster/study/__init__.py,sha256=Zspv6U8jFqjkHGYdNdDy1rfUnCSolCzUdgSSg98PRgE,166
 masster/study/export.py,sha256=bm3e6AEwkXqBO6Pwd-2pWhxOmzQTFlOSauXFnaiSJDI,29019
 masster/study/h5.py,sha256=EcpyYfMknDzzdA6XTyMU_ppY92_DsPSPYGE0kpVN7T8,66429
@@ -37,7 +37,7 @@ masster/study/helpers_optimized.py,sha256=EgOgPaL3c2LA8jDhnlEHvzb7O9Um-vnMIcnNao
 masster/study/load.py,sha256=TLxVhXu0HHb51lGggXitQLtfNxz2JJfKMkAXJbxhvhM,46880
 masster/study/parameters.py,sha256=0elaF7YspTsB7qyajWAbRNL2VfKlGz5GJLifmO8IGkk,3276
 masster/study/plot.py,sha256=NW31XdM9Bf5wNvIAs-56AIoPA8VLTqBzr6qJInfZmhc,25159
-masster/study/processing.py,sha256=BQuSBO7O8iTlCjXenECyg0_PAsPF1NNiUllypuemPZI,46101
+masster/study/processing.py,sha256=c7rMc5LA6lcGkj9qfQSr9pMFbHWPa9spMUUV4LQPm6M,45670
 masster/study/save.py,sha256=bcRADWTvhTER9WRkT9zNU5mDUPQZkZB2cuJwpRsYmrM,6589
 masster/study/study.py,sha256=4jItwNGUZUv9uDwAcfFYT3GRh-ACJ1bddSGQaiQs6YM,29002
 masster/study/study5_schema.json,sha256=A_xDPzB97xt2EFeQsX9j8Ut7yC4_DS7BZ24ucotOXIw,5103
@@ -52,8 +52,8 @@ masster/study/defaults/integrate_chrom_def.py,sha256=Rih3-vat7fHGVfIvRitjNJJI3zL
 masster/study/defaults/integrate_def.py,sha256=Vf4SAzdBfnsSZ3IRaF0qZvWu3gMDPHdgPfMYoPKeWv8,7246
 masster/study/defaults/merge_def.py,sha256=EBsKE3hsAkTEzN9dpdRD5W3_suTKy_WZ_96rwS0uBuE,8572
 masster/study/defaults/study_def.py,sha256=hj8bYtEPwzdowC95yfyoCFt6fZkQePLjpJtmpNz9Z5M,9533
-masster-0.3.8.dist-info/METADATA,sha256=BgeLAnayzxrXBCTRe9MHqt8uB5twHhDOTbLtinIghLQ,44292
-masster-0.3.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-masster-0.3.8.dist-info/entry_points.txt,sha256=ZHguQ_vPmdbpqq2uGtmEOLJfgP-DQ1T0c07Lxh30wc8,58
-masster-0.3.8.dist-info/licenses/LICENSE,sha256=bx5iLIKjgAdYQ7sISn7DsfHRKkoCUm1154sJJKhgqnU,35184
-masster-0.3.8.dist-info/RECORD,,
+masster-0.3.10.dist-info/METADATA,sha256=cC-8Ghfpd_dNFIzSiuEj3hx5F81GW6S0oOR0cE37rDs,44293
+masster-0.3.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+masster-0.3.10.dist-info/entry_points.txt,sha256=ZHguQ_vPmdbpqq2uGtmEOLJfgP-DQ1T0c07Lxh30wc8,58
+masster-0.3.10.dist-info/licenses/LICENSE,sha256=bx5iLIKjgAdYQ7sISn7DsfHRKkoCUm1154sJJKhgqnU,35184
+masster-0.3.10.dist-info/RECORD,,