masster 0.5.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

masster/_version.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 
-__version__ = "0.5.0"
+__version__ = "0.5.1"
 
 
 def get_version():

masster/data/libs/aa.csv

@@ -0,0 +1,22 @@
+name,smiles,inchikey,formula,db_id,db
+L-Glutamic acid,N[C@@H](CCC(O)=O)C(O)=O,WHUUTDBJXJRKMK-VKHMYHEASA-N,C5H9NO4,CID:33032,pubchem
+L-Tyrosine,N[C@@H](CC1=CC=C(O)C=C1)C(O)=O,OUYCCCASQSFEME-QMMMGPOBSA-N,C9H11NO3,CID:6057,pubchem
+L-Phenylalanine,N[C@@H](CC1=CC=CC=C1)C(O)=O,COLNVLDHVKWLRT-QMMMGPOBSA-N,C9H11NO2,CID:6140,pubchem
+L-Alanine,C[C@H](N)C(O)=O,QNAYBMKLOCPYGJ-REOHCLBHSA-N,C3H7NO2,CID:5950,pubchem
+L-Proline,OC(=O)[C@@H]1CCCN1,ONIBWKKTOPOVIA-BYPYZUCNSA-N,C5H9NO2,CID:145742,pubchem
+L-Threonine,C[C@@H](O)[C@H](N)C(O)=O,AYFVYJQAPQTCCC-GBXIJSLDSA-N,C4H9NO3,CID:6288,pubchem
+L-Asparagine,N[C@@H](CC(N)=O)C(O)=O,DCXYFEDJOCDNAF-REOHCLBHSA-N,C4H8N2O3,CID:6267,pubchem
+L-Isoleucine,CC[C@H](C)[C@H](N)C(O)=O,AGPKZVBTJJNPAG-WHFBIAKZSA-N,C6H13NO2,CID:6306,pubchem
+L-Histidine,N[C@@H](CC1=CN=CN1)C(O)=O,HNDVDQJCIGZPNO-YFKPBYRVSA-N,C6H9N3O2,CID:6274,pubchem
+L-Lysine,NCCCC[C@H](N)C(O)=O,KDXKERNSBIXSRK-YFKPBYRVSA-N,C6H14N2O2,CID:5962,pubchem
+L-Serine,N[C@@H](CO)C(O)=O,MTCFGRXMJLQNBG-REOHCLBHSA-N,C3H7NO3,CID:5951,pubchem
+L-Aspartic acid,N[C@@H](CC(O)=O)C(O)=O,CKLJMWTZIZZHCS-REOHCLBHSA-N,C4H7NO4,CID:5960,pubchem
+L-Cystine,N[C@@H](CSSC[C@H](N)C(O)=O)C(O)=O,LEVWYRKDKASIDU-IMJSIDKUSA-N,C6H12N2O4S2,CID:67678,pubchem
+L-Arginine,N[C@@H](CCCNC(N)=N)C(O)=O,ODKSFYDXXFIFQN-BYPYZUCNSA-N,C6H14N4O2,CID:6322,pubchem
+L-Cysteine,N[C@@H](CS)C(O)=O,XUJNEKJLAYXESH-REOHCLBHSA-N,C3H7NO2S,CID:5862,pubchem
+L-Glutamine,N[C@@H](CCC(N)=O)C(O)=O,ZDXPYRJPNDTMRX-VKHMYHEASA-N,C5H10N2O3,CID:5961,pubchem
+L-Leucine,CC(C)C[C@H](N)C(O)=O,ROHFNLRQFUQHCH-YFKPBYRVSA-N,C6H13NO2,CID:6106,pubchem
+L-Methionine,CSCC[C@H](N)C(O)=O,FFEARJCKVFRZRR-BYPYZUCNSA-N,C5H11NO2S,CID:6137,pubchem
+L-Valine,CC(C)[C@H](N)C(O)=O,KZSNJWFQEVHDMF-BYPYZUCNSA-N,C5H11NO2,CID:6287,pubchem
+L-Tryptophan,N[C@@H](CC1=CNC2=C1C=CC=C2)C(O)=O,QIVBCDIJIAJPQS-VIFPVBQESA-N,C11H12N2O2,CID:6305,pubchem
+Glycine,NCC(O)=O,QNAYBMKLOCPYGJ-UHFFFAOYSA-N,C2H5NO2,CID:750,Glycine

masster/lib/lib.py

@@ -123,11 +123,13 @@ class Lib:
             "inchi": pl.Series([], dtype=pl.Utf8),
             "inchikey": pl.Series([], dtype=pl.Utf8),
             "formula": pl.Series([], dtype=pl.Utf8),
+            "iso": pl.Series([], dtype=pl.Int64),
             "adduct": pl.Series([], dtype=pl.Utf8),
             "m": pl.Series([], dtype=pl.Float64),
             "z": pl.Series([], dtype=pl.Int8),
             "mz": pl.Series([], dtype=pl.Float64),
             "rt": pl.Series([], dtype=pl.Float64),
+            "quant_group": pl.Series([], dtype=pl.Int64),
             "db_id": pl.Series([], dtype=pl.Utf8),
             "db": pl.Series([], dtype=pl.Utf8),
         })
@@ -245,11 +247,13 @@ class Lib:
                 "inchi": compound_data.get("inchi", ""),
                 "inchikey": compound_data.get("inchikey", ""),
                 "formula": compound_data["formula"],
+                "iso": 0,  # Default to zero
                 "adduct": adduct,
                 "m": adducted_mass,
                 "z": charge,
                 "mz": mz,
                 "rt": compound_data.get("rt", None),
+                "quant_group": counter,  # Use same as lib_uid for default
                 "db_id": compound_data.get("db_id", None),
                 "db": compound_data.get("db", None),
             }
@@ -526,12 +530,14 @@ class Lib:
                     "source_id": match_row.get("source_id"),
                     "name": match_row["name"],
                     "formula": match_row["formula"],
+                    "iso": match_row.get("iso", 0),
                     "adduct": match_row["adduct"],
                     "smiles": match_row["smiles"],
                     "inchi": match_row["inchi"],
                     "inchikey": match_row["inchikey"],
                     "lib_mz": match_row["mz"],
                     "lib_rt": match_row["rt"],
+                    "quant_group": match_row.get("quant_group"),
                     "delta_mz": abs(feature_mz - match_row["mz"]),
                     "delta_rt": abs(feature_rt - match_row["rt"]) if feature_rt is not None and match_row["rt"] is not None else None,
                 }

masster/study/defaults/fill_def.py

@@ -58,7 +58,7 @@ class fill_defaults:
                 "dtype": int,
                 "description": "Minimum absolute samples threshold",
                 "default": 5,
-                "min_value": 1,
+                "min_value": 0,
                 "max_value": 100,
             },
         },

masster/study/h5.py

@@ -2007,6 +2007,9 @@ def _load_study5(self, filename=None):
             f"Successfully migrated {sample_count} samples to indexed map_id format (0 to {sample_count - 1})",
         )
 
+    # Sanitize null feature_id and consensus_id values with new UIDs (same method as merge)
+    self._sanitize_null_ids()
+
     self.logger.debug("Study loaded")
 
 

masster/study/id.py

@@ -15,6 +15,7 @@ def lib_load(
     lib_source,
     polarity: str | None = None,
     adducts: list | None = None,
+    iso: str | None = None,
 ):
     """Load a compound library into the study.
 
@@ -23,6 +24,7 @@ def lib_load(
         lib_source: either a CSV file path (str) or a Lib instance
         polarity: ionization polarity ("positive" or "negative") - used when lib_source is a CSV path
         adducts: specific adducts to generate - used when lib_source is a CSV path
+        iso: isotope generation mode ("13C" to generate 13C isotopes, None for no isotopes)
 
     Side effects:
         sets study.lib_df to a Polars DataFrame and stores the lib object on
@@ -97,6 +99,56 @@ def lib_load(
     # Store pointer and DataFrame on study
     study._lib = lib_obj
 
+    # Add source_id column with filename (without path) if loading from CSV
+    if isinstance(lib_source, str):
+        import os
+        filename_only = os.path.basename(lib_source)
+        filtered_lf = filtered_lf.with_columns(pl.lit(filename_only).alias("source_id"))
+
+    # Ensure required columns exist and set correct values
+    required_columns = {
+        "quant_group": pl.Int64,
+        "iso": pl.Int64
+    }
+    
+    for col_name, col_dtype in required_columns.items():
+        if col_name == "quant_group":
+            # Set quant_group using cmpd_uid (same for isotopomers of same compound)
+            if "cmpd_uid" in filtered_lf.columns:
+                filtered_lf = filtered_lf.with_columns(pl.col("cmpd_uid").cast(col_dtype).alias("quant_group"))
+            else:
+                # Fallback to lib_uid if cmpd_uid doesn't exist
+                filtered_lf = filtered_lf.with_columns(pl.col("lib_uid").cast(col_dtype).alias("quant_group"))
+        elif col_name == "iso":
+            if col_name not in filtered_lf.columns:
+                # Default to zero for iso
+                filtered_lf = filtered_lf.with_columns(pl.lit(0).cast(col_dtype).alias(col_name))
+    
+    # Generate 13C isotopes if requested
+    original_count = len(filtered_lf)
+    if iso == '13C':
+        filtered_lf = _generate_13c_isotopes(filtered_lf)
+        # Update the log message to show the correct count after isotope generation
+        if isinstance(lib_source, str):
+            import os
+            filename_only = os.path.basename(lib_source)
+            print(f"Generated 13C isotopes: {len(filtered_lf)} total entries ({original_count} original + {len(filtered_lf) - original_count} isotopes) from {filename_only}")
+
+    # Reorder columns to place quant_group after rt and iso after formula
+    column_order = []
+    columns_list = list(filtered_lf.columns)
+    
+    for col in columns_list:
+        if col not in column_order:  # Only add if not already added
+            column_order.append(col)
+            if col == "rt" and "quant_group" in columns_list and "quant_group" not in column_order:
+                column_order.append("quant_group")
+            elif col == "formula" and "iso" in columns_list and "iso" not in column_order:
+                column_order.append("iso")
+    
+    # Apply the column ordering
+    filtered_lf = filtered_lf.select(column_order)
+
     # Add to existing lib_df instead of replacing
     if (
         hasattr(study, "lib_df")
@@ -127,7 +179,7 @@ def lib_load(
     if hasattr(study, "update_history"):
         study.update_history(
             ["lib_load"],
-            {"lib_source": str(lib_source), "polarity": polarity, "adducts": adducts},
+            {"lib_source": str(lib_source), "polarity": polarity, "adducts": adducts, "iso": iso},
         )
 
 
@@ -349,6 +401,7 @@ def _update_identification_results(study, results, logger):
                 "rt_delta": match["rt_delta"],
                 "matcher": match["matcher"],
                 "score": match["score"],
+                "iso": 0,  # Default to zero
             })
     
     # Convert to DataFrame and append to existing results
@@ -356,6 +409,13 @@ def _update_identification_results(study, results, logger):
     
     if not new_results_df.is_empty():
         if hasattr(study, "id_df") and study.id_df is not None and not study.id_df.is_empty():
+            # Check if existing id_df has the iso column
+            if "iso" not in study.id_df.columns:
+                # Add iso column to existing id_df with default value 0
+                study.id_df = study.id_df.with_columns(pl.lit(0).alias("iso"))
+                if logger:
+                    logger.debug("Added 'iso' column to existing id_df for schema compatibility")
+            
             study.id_df = pl.concat([study.id_df, new_results_df])
         else:
             study.id_df = new_results_df
@@ -1043,8 +1103,10 @@ def lib_reset(study):
     - study.id_df (identification results DataFrame)
     - study.lib_df (library DataFrame)
     - study._lib (library object reference)
+    - Consensus features created by lib_to_consensus() (number_samples = -1 or 0)
     - 'identify' from study.history
     - 'lib_load' from study.history (if exists)
+    - 'lib_to_consensus' from study.history (if exists)
     - Resets id_top_* columns in consensus_df to null
 
     Args:
@@ -1053,6 +1115,36 @@ def lib_reset(study):
     # Get logger from study if available
     logger = getattr(study, "logger", None)
 
+    # Remove consensus features created by lib_to_consensus()
+    # These are identified by number_samples = -1 or 0
+    if hasattr(study, "consensus_df") and not study.consensus_df.is_empty():
+        if logger:
+            logger.debug("Checking for consensus features created by lib_to_consensus()")
+        
+        try:
+            # Filter for features with number_samples = -1 or 0
+            # Since consensus_select doesn't support list of discrete values, use direct filtering
+            lib_consensus_features = study.consensus_df.filter(
+                (pl.col("number_samples") == -1) | (pl.col("number_samples") == 0)
+            )
+            
+            if lib_consensus_features is not None and not lib_consensus_features.is_empty():
+                num_lib_features = len(lib_consensus_features)
+                if logger:
+                    logger.info(f"Removing {num_lib_features} consensus features created by lib_to_consensus()")
+                
+                # Use consensus_delete to remove these features and all dependent data
+                study.consensus_delete(lib_consensus_features)
+                
+                if logger:
+                    logger.debug("Successfully removed library-derived consensus features")
+            else:
+                if logger:
+                    logger.debug("No library-derived consensus features found to remove")
+        except Exception as e:
+            if logger:
+                logger.warning(f"Error removing library-derived consensus features: {e}")
+
     # Remove id_df
     if hasattr(study, "id_df"):
         if logger:
@@ -1099,6 +1191,11 @@ def lib_reset(study):
             if logger:
                 logger.debug("Removing 'lib_load' from history")
             del study.history["lib_load"]
+            
+        if "lib_to_consensus" in study.history:
+            if logger:
+                logger.debug("Removing 'lib_to_consensus' from history")
+            del study.history["lib_to_consensus"]
 
     if logger:
         logger.info("Library and identification data reset completed")
@@ -1438,3 +1535,447 @@ def _format_adduct_name(components: list[dict]) -> str:
         )
 
     return f"[M{formula}]{charge_str}"
+
+
+def _generate_13c_isotopes(lib_df):
+    """
+    Generate 13C isotope variants for library entries.
+    
+    For each compound with n carbon atoms, creates n+1 entries:
+    - iso=0: original compound (no 13C)
+    - iso=1: one 13C isotope (+1.00335 Da)
+    - iso=2: two 13C isotopes (+2.00670 Da)
+    - ...
+    - iso=n: n 13C isotopes (+n*1.00335 Da)
+    
+    All isotopomers share the same quant_group.
+    
+    Args:
+        lib_df: Polars DataFrame with library entries
+        
+    Returns:
+        Polars DataFrame with additional 13C isotope entries
+    """
+    if lib_df.is_empty():
+        return lib_df
+    
+    # First, ensure all original entries have iso=0
+    original_df = lib_df.with_columns(pl.lit(0).alias("iso"))
+    
+    isotope_entries = []
+    next_lib_uid = lib_df["lib_uid"].max() + 1 if len(lib_df) > 0 else 1
+    
+    # Mass difference for one 13C isotope
+    c13_mass_shift = 1.00335  # Mass difference between 13C and 12C
+    
+    for row in original_df.iter_rows(named=True):
+        formula = row.get("formula", "")
+        if not formula:
+            continue
+            
+        # Count carbon atoms in the formula
+        carbon_count = _count_carbon_atoms(formula)
+        if carbon_count == 0:
+            continue
+            
+        # Get the original quant_group to keep it consistent across isotopes
+        # All isotopomers of the same compound should have the same quant_group
+        quant_group = row.get("quant_group", row.get("cmpd_uid", row.get("lib_uid", 1)))
+        
+        # Generate isotope variants (1 to n 13C atoms)
+        for iso_num in range(1, carbon_count + 1):
+            # Calculate mass shift for this number of 13C isotopes
+            mass_shift = iso_num * c13_mass_shift
+            
+            # Create new entry
+            isotope_entry = dict(row)  # Copy all fields
+            isotope_entry["lib_uid"] = next_lib_uid
+            isotope_entry["iso"] = iso_num
+            isotope_entry["m"] = row["m"] + mass_shift
+            isotope_entry["mz"] = (row["m"] + mass_shift) / abs(row["z"]) if row["z"] != 0 else row["m"] + mass_shift
+            isotope_entry["quant_group"] = quant_group  # Keep same quant_group
+            
+            isotope_entries.append(isotope_entry)
+            next_lib_uid += 1
+    
+    # Combine original entries (now with iso=0) with isotope entries
+    if isotope_entries:
+        isotope_df = pl.DataFrame(isotope_entries)
+        # Ensure schema compatibility by aligning data types
+        try:
+            return pl.concat([original_df, isotope_df])
+        except Exception as e:
+            # If concat fails due to schema mismatch, convert to compatible types
+            # Get common schema
+            original_schema = original_df.schema
+            isotope_schema = isotope_df.schema
+            
+            # Cast isotope_df columns to match original_df schema where possible
+            cast_exprs = []
+            for col_name in isotope_df.columns:
+                if col_name in original_schema:
+                    target_dtype = original_schema[col_name]
+                    cast_exprs.append(pl.col(col_name).cast(target_dtype, strict=False))
+                else:
+                    cast_exprs.append(pl.col(col_name))
+            
+            isotope_df_cast = isotope_df.select(cast_exprs)
+            return pl.concat([original_df, isotope_df_cast])
+    else:
+        return original_df
+
+
+def _count_carbon_atoms(formula: str) -> int:
+    """
+    Count the number of carbon atoms in a molecular formula.
+    
+    Args:
+        formula: Molecular formula string like "C6H12O6"
+        
+    Returns:
+        Number of carbon atoms
+    """
+    import re
+    
+    if not formula or not isinstance(formula, str):
+        return 0
+    
+    # Look for carbon followed by optional number
+    # C followed by digits, or just C (which means 1)
+    carbon_matches = re.findall(r'C(\d*)', formula)
+    
+    total_carbons = 0
+    for match in carbon_matches:
+        if match == '':
+            # Just 'C' without number means 1 carbon
+            total_carbons += 1
+        else:
+            # 'C' followed by number
+            total_carbons += int(match)
+    
+    return total_carbons
+
+
+def lib_to_consensus(study, chrom_fhwm: float = 5.0, mz_tol: float = 0.01, rt_tol: float = 2.0):
+    """Create consensus features from library entries instead of features_df.
+    
+    This method takes all rows from lib_df and creates corresponding entries in
+    consensus_df with the same columns as merge(). Instead of relying on 
+    features_df, it populates consensus features directly from library data.
+    
+    Before creating new features, it checks for pre-existing consensus features:
+    - If rt in lib_df is null: picks consensus feature with matching mz and largest inty_mean
+    - If rt is not null: picks consensus feature with matching mz and rt within tolerance
+    - If a match is found, skips to the next library entry
+    
+    Args:
+        study: Study instance with lib_df populated
+        chrom_fhwm: Chromatographic full width at half maximum in seconds 
+                   to infer rt_start_mean and rt_end_mean (default: 5.0)
+        mz_tol: m/z tolerance for matching existing consensus features (default: 0.01)
+        rt_tol: RT tolerance for matching existing consensus features (default: 2.0)
+    
+    Side effects:
+        Adds rows to study.consensus_df and study.consensus_mapping_df
+        Calls study.find_ms2() at the end
+    """
+    # Get logger from study if available
+    logger = getattr(study, "logger", None)
+    
+    # Validate inputs
+    if getattr(study, "lib_df", None) is None or study.lib_df.is_empty():
+        if logger:
+            logger.error("Library (study.lib_df) is empty; call lib_load() first")
+        raise ValueError("Library (study.lib_df) is empty; call lib_load() first")
+    
+    if logger:
+        logger.info(f"Creating consensus features from {len(study.lib_df)} library entries")
+    
+    # Initialize consensus DataFrames if they don't exist
+    if not hasattr(study, "consensus_df") or study.consensus_df is None:
+        study.consensus_df = pl.DataFrame()
+    if not hasattr(study, "consensus_mapping_df") or study.consensus_mapping_df is None:
+        study.consensus_mapping_df = pl.DataFrame()
+    
+    # Get cached adducts for consistent adduct handling
+    cached_adducts_df = None
+    cached_valid_adducts = None
+    try:
+        cached_adducts_df = _get_adducts(study)
+        if not cached_adducts_df.is_empty():
+            cached_valid_adducts = set(cached_adducts_df["name"].to_list())
+        else:
+            cached_valid_adducts = set()
+    except Exception as e:
+        if logger:
+            logger.warning(f"Could not retrieve study adducts: {e}")
+        cached_valid_adducts = set()
+    
+    # Always allow '?' adducts
+    cached_valid_adducts.add("?")
+    
+    # Get starting consensus_uid counter
+    if not study.consensus_df.is_empty():
+        max_existing_uid = study.consensus_df["consensus_uid"].max()
+        consensus_uid_counter = int(max_existing_uid) + 1 if max_existing_uid is not None else 0
+    else:
+        consensus_uid_counter = 0
+    
+    # Track [M+H] iso=0 and [M-H] iso=0 entries for adduct grouping
+    base_adduct_groups = {}  # key: (mz, adduct_base), value: adduct_group
+    
+    # Process each library entry
+    consensus_metadata = []
+    consensus_mapping_list = []
+    matched_count = 0
+    skipped_count = 0
+    
+    for lib_row in study.lib_df.iter_rows(named=True):
+        # Extract basic library data
+        lib_uid = lib_row.get("lib_uid")
+        mz = lib_row.get("mz")
+        rt = lib_row.get("rt")
+        iso = lib_row.get("iso", 0)
+        adduct = lib_row.get("adduct")
+        z = lib_row.get("z", 1)  # charge
+        
+        # Skip entries without essential data
+        if mz is None:
+            if logger:
+                logger.warning(f"Skipping library entry {lib_uid} - no m/z value")
+            continue
+        
+        # Check for pre-existing consensus features
+        existing_match = None
+        if not study.consensus_df.is_empty():
+            # Filter by m/z tolerance first
+            mz_matches = study.consensus_df.filter(
+                (pl.col("mz") >= mz - mz_tol) & (pl.col("mz") <= mz + mz_tol)
+            )
+            
+            if not mz_matches.is_empty():
+                if rt is None:
+                    # If rt is null, pick the consensus feature with largest inty_mean
+                    existing_match = mz_matches.sort("inty_mean", descending=True).head(1)
+                else:
+                    # If rt is not null, filter by RT tolerance and pick largest inty_mean
+                    rt_tolerance = chrom_fhwm  # Use chrom_fhwm as RT tolerance range
+                    rt_matches = mz_matches.filter(
+                        (pl.col("rt") >= rt - rt_tolerance) & (pl.col("rt") <= rt + rt_tolerance)
+                    )
+                    if not rt_matches.is_empty():
+                        existing_match = rt_matches.sort("inty_mean", descending=True).head(1)
+        
+        if existing_match is not None and len(existing_match) > 0:
+            # Found a matching consensus feature, skip this library entry
+            matched_count += 1
+            if logger and matched_count <= 5:  # Log first few matches
+                match_uid = existing_match["consensus_uid"][0]
+                match_mz = existing_match["mz"][0]
+                match_rt = existing_match["rt"][0]
+                logger.debug(f"Library entry {lib_uid} (mz={mz:.4f}, rt={rt}) matched existing consensus {match_uid} (mz={match_mz:.4f}, rt={match_rt})")
+            continue
+        
+        # No match found, create new consensus feature
+        # Handle missing RT - use 0 as placeholder
+        if rt is None:
+            rt = 0.0
+            if logger and skipped_count < 5:  # Log first few
+                logger.debug(f"Library entry {lib_uid} has no RT, using 0.0")
+        
+        # Calculate RT range based on chrom_fhwm
+        half_width = chrom_fhwm / 2.0
+        rt_start = rt - half_width
+        rt_end = rt + half_width
+        
+        # Get adduct information
+        adduct_top = adduct if adduct else "?"
+        adduct_charge_top = None
+        adduct_mass_shift_top = None
+        adduct_mass_neutral_top = None
+        
+        # Parse adduct to get charge and mass shift
+        if adduct_top and cached_adducts_df is not None and not cached_adducts_df.is_empty():
+            # Look for exact match in study adducts
+            matching_adduct = cached_adducts_df.filter(pl.col("name") == adduct_top)
+            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"]
+        
+        # Fallback to default values if not found
+        if adduct_charge_top is None:
+            adduct_charge_top = int(z) if z else 1
+            # Default based on study polarity
+            study_polarity = getattr(study, "polarity", "positive")
+            if study_polarity in ["negative", "neg"]:
+                if adduct_charge_top > 0:
+                    adduct_charge_top = -adduct_charge_top
+                adduct_mass_shift_top = -1.007825
+                if adduct_top == "?":
+                    adduct_top = "[M-?]1-"
+            else:
+                if adduct_charge_top < 0:
+                    adduct_charge_top = -adduct_charge_top
+                adduct_mass_shift_top = 1.007825
+                if adduct_top == "?":
+                    adduct_top = "[M+?]1+"
+        
+        # Calculate neutral mass
+        if adduct_charge_top and adduct_mass_shift_top is not None:
+            adduct_mass_neutral_top = mz * abs(adduct_charge_top) - adduct_mass_shift_top
+        
+        # Determine adduct group for isotopologues and related adducts
+        adduct_group = consensus_uid_counter  # Default: each entry gets its own group
+        adduct_of = 0  # Default: this is the base adduct
+        
+        # Track base adducts ([M+H] iso=0 or [M-H] iso=0) for grouping
+        base_adduct_key = None
+        if iso == 0 and adduct_top in ["[M+H]+", "[M+H]1+", "[M-H]-", "[M-H]1-"]:
+            # This is a base adduct with iso=0
+            base_adduct_key = (round(mz, 4), adduct_top)
+            base_adduct_groups[base_adduct_key] = consensus_uid_counter
+        elif iso > 0:
+            # This is an isotopologue, try to find the base adduct
+            # Calculate the base m/z (subtract isotope mass shifts)
+            c13_mass_shift = 1.00335
+            base_mz = mz - (iso * c13_mass_shift / abs(adduct_charge_top))
+            
+            # Look for matching base adduct
+            for (stored_mz, stored_adduct), stored_group in base_adduct_groups.items():
+                if abs(stored_mz - base_mz) < mz_tol and stored_adduct == adduct_top:
+                    adduct_group = stored_group
+                    adduct_of = stored_group
+                    break
+        
+        # Create adduct values list with proper structure (format: structured data with fields: adduct, count, percentage, mass)
+        adduct_values = [{"adduct": adduct_top, "count": 1, "percentage": 100.0, "mass": 0.0}]
+        
+        # Generate unique consensus_id string
+        import uuid
+        consensus_id_str = str(uuid.uuid4()).replace('-', '')[:16]
+        
+        # Build consensus metadata with requested modifications for new entries
+        metadata = {
+            "consensus_uid": consensus_uid_counter,
+            "consensus_id": consensus_id_str,
+            "quality": 1.0,
+            "number_samples": 0.0,  # Set to 0.0 for library entries
+            "rt": float(rt),
+            "mz": float(mz),
+            "rt_min": float(rt),  # Set to rt as requested
+            "rt_max": float(rt),  # Set to rt as requested
+            "rt_mean": float(rt),  # Set to rt as requested
+            "rt_start_mean": float(rt_start),
+            "rt_end_mean": float(rt_end),
+            "rt_delta_mean": 0.0,  # Set to 0.0 as requested
+            "mz_min": float(mz),  # Set to mz as requested
+            "mz_max": float(mz),  # Set to mz as requested
+            "mz_mean": float(mz),  # Set to mz as requested
+            "mz_start_mean": float(mz),  # Set to mz as requested
+            "mz_end_mean": float(mz),  # Set to mz as requested
+            "inty_mean": -1.0,  # Set to -1.0 as requested
+            "bl": -1.0,
+            "chrom_coherence_mean": -1.0,  # Set to -1.0 as requested
+            "chrom_prominence_mean": -1.0,  # Set to -1.0 as requested
+            "chrom_prominence_scaled_mean": -1.0,  # Set to -1.0 as requested
+            "chrom_height_scaled_mean": -1.0,  # Set to -1.0 as requested
+            "iso": iso,  # Set to iso from lib_df as requested
+            "iso_mean": float(iso),  # Set to iso from lib_df as requested
+            "charge_mean": float(abs(z)) if z else 1.0,  # Set to z as requested
+            "number_ms2": 0,  # Will be updated by find_ms2
+            "adducts": adduct_values,
+            "adduct_charge_top": adduct_charge_top,
+            "adduct_group": adduct_group,  # Use calculated adduct group
+            "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,
+            "adduct_of": adduct_of,  # Use calculated adduct_of
+            "adduct_top": adduct_top,
+            "id_top_name": None,  # Set to null as requested
+            "id_top_class": None,  # Set to null as requested
+            "id_top_adduct": None,  # Set to null as requested
+            "id_top_score": None,  # Set to null as requested
+        }
+        
+        consensus_metadata.append(metadata)
+        
+        # Create mapping entry (maps to library entry as "virtual" feature)
+        # Use lib_uid as the feature_uid and a virtual sample_uid of 0
+        # Match existing consensus_mapping_df column order: consensus_uid, feature_uid, sample_uid
+        consensus_mapping_list.append({
+            "consensus_uid": consensus_uid_counter,
+            "feature_uid": lib_uid,  # Use lib_uid as feature reference
+            "sample_uid": 0,  # Virtual sample for library entries
+        })
+        
+        consensus_uid_counter += 1
+    
+    # Log matching statistics
+    if logger:
+        total_processed = matched_count + len(consensus_metadata)
+        logger.info(f"Processed {total_processed} library entries: {matched_count} matched existing consensus features, {len(consensus_metadata)} created new features")
+    
+    # Convert to DataFrames with proper schema alignment
+    if consensus_metadata:
+        new_consensus_df = pl.DataFrame(consensus_metadata, strict=False)
+        
+        # Ensure schema compatibility with existing consensus_df
+        if not study.consensus_df.is_empty():
+            # Cast columns to match existing schema
+            existing_schema = study.consensus_df.schema
+            cast_exprs = []
+            for col_name in new_consensus_df.columns:
+                if col_name in existing_schema:
+                    target_dtype = existing_schema[col_name]
+                    if target_dtype == pl.Null:
+                        # For Null columns, use lit(None) to maintain Null type
+                        cast_exprs.append(pl.lit(None).alias(col_name))
+                    else:
+                        cast_exprs.append(pl.col(col_name).cast(target_dtype, strict=False))
+                else:
+                    cast_exprs.append(pl.col(col_name))
+            
+            new_consensus_df = new_consensus_df.select(cast_exprs)
+        
+        new_consensus_mapping_df = pl.DataFrame(consensus_mapping_list, strict=False)
+        
+        # Append to existing DataFrames
+        if not study.consensus_df.is_empty():
+            study.consensus_df = pl.concat([study.consensus_df, new_consensus_df])
+        else:
+            study.consensus_df = new_consensus_df
+            
+        if not study.consensus_mapping_df.is_empty():
+            study.consensus_mapping_df = pl.concat([study.consensus_mapping_df, new_consensus_mapping_df])
+        else:
+            study.consensus_mapping_df = new_consensus_mapping_df
+        
+        if logger:
+            logger.info(f"Added {len(consensus_metadata)} consensus features from library")
+    else:
+        if logger:
+            logger.warning("No valid consensus features created from library")
+        return
+    
+    # Store operation in history
+    if hasattr(study, "update_history"):
+        study.update_history(
+            ["lib_to_consensus"],
+            {"chrom_fhwm": chrom_fhwm, "lib_entries": len(study.lib_df)},
+        )
+    
+    # Perform find_ms2 at the end
+    try:
+        if hasattr(study, "find_ms2"):
+            if logger:
+                logger.info("Running find_ms2 to link MS2 spectra to library-derived consensus features")
+            study.find_ms2()
+        else:
+            if logger:
+                logger.warning("find_ms2 method not available on study object")
+    except Exception as e:
+        if logger:
+            logger.warning(f"find_ms2 failed: {e}")
+    
+    if logger:
+        logger.info(f"lib_to_consensus completed: {len(consensus_metadata)} features added")

masster/study/load.py

@@ -261,9 +261,14 @@ def _fill_chrom_single_impl(
     min_number_abs = 1
     if isinstance(min_samples_rel, float) and min_samples_rel > 0:
         min_number_rel = int(min_samples_rel * len(self.samples_df))
-    if isinstance(min_samples_abs, int) and min_samples_abs > 0:
-        min_number_abs = int(min_samples_abs)
+    if isinstance(min_samples_abs, int) and min_samples_abs >= 0:
+        min_number_abs = int(min_samples_abs) if min_samples_abs > 0 else 0
     min_number = max(min_number_rel, min_number_abs)
+    
+    # Special case: if min_samples_abs is explicitly 0, allow 0-sample features (like library features)
+    if isinstance(min_samples_abs, int) and min_samples_abs == 0:
+        min_number = 0
+        
     self.logger.debug(f"Threshold for gap filling: number_samples>={min_number}")
 
     if min_number > 0:
@@ -277,7 +282,7 @@ def _fill_chrom_single_impl(
         )
     self.logger.debug("Identifying missing features...")
     # Instead of building full chromatogram matrix, identify missing consensus/sample combinations directly
-    missing_combinations = self._get_missing_consensus_sample_combinations(uids)
+    missing_combinations = _get_missing_consensus_sample_combinations(self,uids)
     if not missing_combinations:
         self.logger.info("No missing features found to fill.")
         return
@@ -754,10 +759,14 @@ def _fill_chrom_impl(
     min_number_abs = 1
     if isinstance(min_samples_rel, float) and min_samples_rel > 0:
         min_number_rel = int(min_samples_rel * len(self.samples_df))
-    if isinstance(min_samples_abs, int) and min_samples_abs > 0:
-        min_number_abs = int(min_samples_abs)
+    if isinstance(min_samples_abs, int) and min_samples_abs >= 0:
+        min_number_abs = int(min_samples_abs) if min_samples_abs > 0 else 0
     min_number = max(min_number_rel, min_number_abs)
 
+    # Special case: if min_samples_abs is explicitly 0, allow 0-sample features (like library features)
+    if isinstance(min_samples_abs, int) and min_samples_abs == 0:
+        min_number = 0
+
     self.logger.debug(f"Threshold for gap filling: number_samples>={min_number}")
 
     if min_number > 0:
@@ -770,7 +779,7 @@ def _fill_chrom_impl(
 
     # Get missing consensus/sample combinations using the optimized method
     self.logger.debug("Identifying missing features...")
-    missing_combinations = self._get_missing_consensus_sample_combinations(uids)
+    missing_combinations = _get_missing_consensus_sample_combinations(self, uids)
 
     if not missing_combinations or len(missing_combinations) == 0:
         self.logger.info("No missing features found to fill.")
@@ -846,7 +855,7 @@ def _fill_chrom_impl(
         future_to_sample = {}
         for sample_info in samples_to_process:
             future = executor.submit(
-                self._process_sample_for_parallel_fill,
+                _process_sample_for_parallel_fill, self,
                 sample_info,
                 consensus_info,
                 uids,

masster/study/merge.py

@@ -505,13 +505,99 @@ def _merge_kd(study, params: merge_defaults) -> oms.ConsensusMap:
     return consensus_map
 
 
+def _generate_feature_maps_from_samples(study):
+    """
+    Generate feature maps using Study-level features_df instead of Sample-level loading.
+    This uses the study's existing features_df which is already loaded.
+    
+    Args:
+        study: Study object containing features_df
+    
+    Returns:
+        list: List of temporary FeatureMap objects built from Study-level data
+    """
+    import pyopenms as oms
+    
+    temp_feature_maps = []
+    
+    study.logger.info(f"Building feature maps using Study-level features_df from {len(study.samples_df)} samples")
+    
+    # Use the features_df from the study that's already loaded
+    if not hasattr(study, 'features_df') or study.features_df is None or study.features_df.is_empty():
+        study.logger.warning("No features_df available - features must be loaded first")
+        return temp_feature_maps
+    
+    # Group features by sample
+    study.logger.info(f"Processing {len(study.features_df)} features grouped by sample")
+    
+    # Get unique sample names/indices
+    if 'sample_uid' in study.features_df.columns:
+        sample_groups = study.features_df.group_by('sample_uid')
+        study.logger.debug("Grouping features by 'sample_uid' column")
+    elif 'sample_id' in study.features_df.columns:
+        sample_groups = study.features_df.group_by('sample_id')
+        study.logger.debug("Grouping features by 'sample_id' column")
+    elif 'sample' in study.features_df.columns:
+        sample_groups = study.features_df.group_by('sample')
+        study.logger.debug("Grouping features by 'sample' column")
+    else:
+        study.logger.warning("No sample grouping column found in features_df")
+        study.logger.info(f"Available columns: {study.features_df.columns}")
+        return temp_feature_maps
+    
+    # Process each sample group
+    processed_samples = 0
+    for sample_key, sample_features in sample_groups:
+        try:
+            feature_map = oms.FeatureMap()
+            feature_count = 0
+            
+            # Build features from this sample's features
+            for row in sample_features.iter_rows(named=True):
+                try:
+                    feature = oms.Feature()
+                    
+                    # Set feature properties
+                    if row.get("feature_id") is not None:
+                        feature.setUniqueId(int(row["feature_id"]))
+                    if row.get("mz") is not None:
+                        feature.setMZ(float(row["mz"]))
+                    if row.get("rt") is not None:
+                        feature.setRT(float(row["rt"]))
+                    if row.get("inty") is not None:
+                        feature.setIntensity(float(row["inty"]))
+                    if row.get("quality") is not None:
+                        feature.setOverallQuality(float(row["quality"]))
+                    if row.get("charge") is not None:
+                        feature.setCharge(int(row["charge"]))
+                    
+                    feature_map.push_back(feature)
+                    feature_count += 1
+                    
+                except (ValueError, TypeError) as e:
+                    study.logger.warning(f"Skipping feature in sample {sample_key} due to conversion error: {e}")
+                    continue
+            
+            temp_feature_maps.append(feature_map)
+            processed_samples += 1
+            study.logger.debug(f"Built feature map for sample {sample_key} with {feature_count} features")
+            
+        except Exception as e:
+            study.logger.warning(f"Failed to process sample group {sample_key}: {e}")
+            # Add empty feature map for failed samples to maintain sample order
+            temp_feature_maps.append(oms.FeatureMap())
+    
+    study.logger.info(f"Generated {len(temp_feature_maps)} feature maps from {processed_samples} samples using Study-level features_df")
+    return temp_feature_maps
+
+
 def _generate_feature_maps_on_demand(study):
     """
-    Generate feature maps on-demand from study.features_df for merge operations.
+    Generate feature maps on-demand using Sample-level _load_ms1() for merge operations.
     Returns temporary feature maps that are not cached in the study.
     
     Args:
-        study: Study object containing features_df and samples_df
+        study: Study object containing samples
     
     Returns:
         list: List of temporary FeatureMap objects
@@ -520,6 +606,15 @@ def _generate_feature_maps_on_demand(study):
     import pyopenms as oms
     import numpy as np
     
+    # Check if we should use Sample-level loading instead of features_df
+    use_sample_loading = True  # Default to Sample-level loading as requested
+    
+    # Use Sample-level loading if requested and samples_df is available
+    if use_sample_loading and hasattr(study, 'samples_df') and study.samples_df is not None and len(study.samples_df) > 0:
+        study.logger.debug("Building feature maps using Sample-level _load_ms1() instead of features_df")
+        return _generate_feature_maps_from_samples(study)
+    
+    # Fallback to original features_df approach
     if study.features_df is None or len(study.features_df) == 0:
         study.logger.error("No features_df available for generating feature maps")
         return []

masster/study/processing.py

@@ -62,16 +62,8 @@ def _generate_feature_maps_on_demand_for_align(study):
                 if feature_row["inty"] is None:
                     study.logger.warning("Skipping feature due to missing inty")
                     continue
-                
-                # Handle missing feature_id by generating a new one
-                if feature_row["feature_id"] is None:
-                    # Use a simple incremental ID for alignment purposes
-                    feature_id = len(temp_feature_maps) * 100000 + feature_map.size() + 1
-                    study.logger.debug(f"Generated new feature_id {feature_id} for feature with missing ID in sample {sample_name}")
-                else:
-                    feature_id = int(feature_row["feature_id"])
-                
-                feature.setUniqueId(feature_id)
+
+                feature.setUniqueId(int(feature_row["feature_id"]))
                 feature.setMZ(float(feature_row["mz"]))
                 feature.setRT(float(feature_row["rt"]))
                 feature.setIntensity(float(feature_row["inty"]))

masster/study/study.py

@@ -440,6 +440,11 @@ class Study:
     
     # === Identification and Library Matching ===
     lib_load = lib_load
+    
+    def lib_to_consensus(self, **kwargs):
+        """Create consensus features from library entries."""
+        from masster.study.id import lib_to_consensus as _lib_to_consensus
+        return _lib_to_consensus(self, **kwargs)
     identify = identify
     get_id = get_id
     id_reset = id_reset
@@ -562,6 +567,83 @@ class Study:
         except Exception as e:
             self.logger.error(f"Failed to reload current module {current_module}: {e}")
 
+    def _sanitize_null_ids(self):
+        """
+        Sanitize null feature_id and consensus_id values by replacing them with new integer IDs.
+        For feature_id: generates large sequential integers that can be converted by merge/align functions.
+        For consensus_id: uses 16-character UUID strings (as expected by merge function).
+        """
+        import uuid
+        import polars as pl
+        import time
+        
+        # Sanitize features_df feature_id column
+        if hasattr(self, 'features_df') and self.features_df is not None and not self.features_df.is_empty():
+            # Check for null feature_ids
+            null_feature_ids = self.features_df.filter(pl.col("feature_id").is_null()).shape[0]
+            if null_feature_ids > 0:
+                self.logger.info(f"Sanitizing {null_feature_ids} null feature_id values with new integer IDs")
+                
+                # Find the maximum existing feature_id (convert strings to int if possible)
+                max_existing_id = 0
+                existing_ids = self.features_df.filter(pl.col("feature_id").is_not_null())["feature_id"].to_list()
+                for fid in existing_ids:
+                    try:
+                        int_id = int(fid)
+                        max_existing_id = max(max_existing_id, int_id)
+                    except (ValueError, TypeError):
+                        # Skip non-integer IDs
+                        pass
+                
+                # Generate new sequential integer IDs starting from max + timestamp offset
+                # Use timestamp to ensure uniqueness across different sanitization runs
+                base_id = max(max_existing_id + 1, int(time.time() * 1000000))  # Microsecond timestamp
+                new_int_ids = [str(base_id + i) for i in range(null_feature_ids)]
+                uid_index = 0
+                
+                # Create a list to store all feature_ids
+                feature_ids = []
+                for feature_id in self.features_df["feature_id"].to_list():
+                    if feature_id is None:
+                        feature_ids.append(new_int_ids[uid_index])
+                        uid_index += 1
+                    else:
+                        feature_ids.append(feature_id)
+                
+                # Update the DataFrame with sanitized feature_ids
+                self.features_df = self.features_df.with_columns(
+                    pl.Series("feature_id", feature_ids, dtype=pl.Utf8)
+                )
+                
+                self.logger.info(f"Successfully sanitized {null_feature_ids} feature_id values")
+        
+        # Sanitize consensus_df consensus_id column
+        if hasattr(self, 'consensus_df') and self.consensus_df is not None and not self.consensus_df.is_empty():
+            if "consensus_id" in self.consensus_df.columns:
+                null_consensus_ids = self.consensus_df.filter(pl.col("consensus_id").is_null()).shape[0]
+                if null_consensus_ids > 0:
+                    self.logger.info(f"Sanitizing {null_consensus_ids} null consensus_id values with new UIDs")
+                    
+                    # Generate new UIDs for null values using the same method as merge()
+                    new_uids = [str(uuid.uuid4()).replace('-', '')[:16] for _ in range(null_consensus_ids)]
+                    uid_index = 0
+                    
+                    # Create a list to store all consensus_ids
+                    consensus_ids = []
+                    for consensus_id in self.consensus_df["consensus_id"].to_list():
+                        if consensus_id is None:
+                            consensus_ids.append(new_uids[uid_index])
+                            uid_index += 1
+                        else:
+                            consensus_ids.append(consensus_id)
+                    
+                    # Update the DataFrame with sanitized consensus_ids
+                    self.consensus_df = self.consensus_df.with_columns(
+                        pl.Series("consensus_id", consensus_ids, dtype=pl.Utf8)
+                    )
+                    
+                    self.logger.info(f"Successfully sanitized {null_consensus_ids} consensus_id values")
+
     def __dir__(self):
         """
         Custom __dir__ implementation to hide internal methods starting with '_' 

masster/study/study5_schema.json

@@ -327,6 +327,9 @@
       "formula": {
         "dtype": "pl.String"
       },
+      "iso": {
+        "dtype": "pl.Int64"
+      },
       "adduct": {
         "dtype": "pl.String"
       },
@@ -342,6 +345,9 @@
       "rt": {
         "dtype": "pl.Null"
       },
+      "quant_group": {
+        "dtype": "pl.Int64"
+      },
       "db_id": {
         "dtype": "pl.String"
       },
@@ -369,6 +375,9 @@
       },
       "score": {
         "dtype": "pl.Float64"
+      },
+      "iso": {
+        "dtype": "pl.Int64"
       }
     }
   }

{masster-0.5.0.dist-info → masster-0.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: masster
-Version: 0.5.0
+Version: 0.5.1
 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.5.0.dist-info → masster-0.5.1.dist-info}/RECORD

@@ -1,5 +1,5 @@
 masster/__init__.py,sha256=ueZ224WPNRRjQEYTaQUol818nwQgJwB93HbEfmtPRmg,1041
-masster/_version.py,sha256=P5MV1QkrG88uczENqaXQiyOnJWkFQaZ4FsWNCqYySbg,256
+masster/_version.py,sha256=dkqPLCQGfsGL65orxLHNgDpbEE9aMOWq4b_vYspojyk,256
 masster/chromatogram.py,sha256=iYpdv8C17zVnlWvOFgAn9ns2uFGiF-GgoYf5QVVAbHs,19319
 masster/logger.py,sha256=tR65N23zfrNpcZNbZm2ot_Aual9XrGB1MWjLrovZkMs,16749
 masster/spectrum.py,sha256=XJSUrqXZSzfpWnD8v5IMClXMRZLKLYIk014qaMOS9_k,49738
@@ -8,6 +8,7 @@ masster/data/dda/20250530_VH_IQX_KW_RP_HSST3_100mm_12min_pos_v4_DDA_OT_C-MiLUT_Q
 masster/data/dda/20250530_VH_IQX_KW_RP_HSST3_100mm_12min_pos_v4_MS1_C-MiLUT_C008_v6_r38_01.sample5,sha256=dSd2cIgYYdRcNSzkhqlZCeWKi3x8Hhhcx8BFMuiVG4c,11382948
 masster/data/dda/20250530_VH_IQX_KW_RP_HSST3_100mm_12min_pos_v4_MS1_C-MiLUT_C008_v7_r37_01.sample5,sha256=wER8CHSBz54Yx1kwmU7ghPPWVwYvxv_lXGB8-8a1xpQ,9508434
 masster/data/dda/20250530_VH_IQX_KW_RP_HSST3_100mm_12min_pos_v4_MS1_C-MiLUT_C017_v5_r99_01.sample5,sha256=h2OOAWWTwKXzTNewhiYeL-cMYdp_JYLPya8Q9Nv9Lvw,12389587
+masster/data/libs/aa.csv,sha256=Sja1DyMsiaM2NfLcct4kAAcXYwPCukJJW8sDkup9w_c,1924
 masster/data/libs/ccm.csv,sha256=Q6nylV1152uTpX-ydqWeGrc6L9kgv45xN_fBZ4f7Tvo,12754
 masster/data/libs/urine.csv,sha256=iRrR4N8Wzb8KDhHJA4LqoQC35pp93FSaOKvXPrgFHis,653736
 masster/data/wiff/2025_01_14_VW_7600_LpMx_DBS_CID_2min_TOP15_030msecMS1_005msecReac_CE35_DBS-ON_3.timeseries.data,sha256=01vC6m__Qqm2rLvlTMZoeKIKowFvovBTUnrNl8Uav3E,24576
@@ -15,7 +16,7 @@ masster/data/wiff/2025_01_14_VW_7600_LpMx_DBS_CID_2min_TOP15_030msecMS1_005msecR
 masster/data/wiff/2025_01_14_VW_7600_LpMx_DBS_CID_2min_TOP15_030msecMS1_005msecReac_CE35_DBS-ON_3.wiff.scan,sha256=ahi1Y3UhAj9Bj4Q2MlbgPekNdkJvMOoMXVOoR6CeIxc,13881220
 masster/data/wiff/2025_01_14_VW_7600_LpMx_DBS_CID_2min_TOP15_030msecMS1_005msecReac_CE35_DBS-ON_3.wiff2,sha256=TFB0HW4Agkig6yht7FtgjUdbXax8jjKaHpSZSvuU5vs,3252224
 masster/lib/__init__.py,sha256=TcePNx3SYZHz6763TL9Sg4gUNXaRWjlrOtyS6vsu-hg,178
-masster/lib/lib.py,sha256=mxUYBCBmkSBZB82557smSHCS25BAusuCewvW8zwsLGg,27130
+masster/lib/lib.py,sha256=SSN06UtiM-hIdjS3eCiIHsJ_8S4YHRGOLGmdPIh-efo,27481
 masster/sample/__init__.py,sha256=HL0m1ept0PMAYUCQtDDnkdOS12IFl6oLAq4TZQz83uY,170
 masster/sample/adducts.py,sha256=S7meba3L1tSdjoDhkSiTI71H2NJLu4i1dtJwfDKWI1M,32591
 masster/sample/h5.py,sha256=B0gAmhrnoFoybotqsqiT8s-PkeZWUdIQfI-4cnM52Zc,115430
@@ -39,22 +40,22 @@ masster/sample/defaults/sample_def.py,sha256=keoXyMyrm_iLgbYqfIbqCpJ3XHBVlNwCNmb
 masster/study/__init__.py,sha256=55axdFuqRX4aXtJ8ocnhcLB32fNtmmJpCi58moO0r4g,237
 masster/study/analysis.py,sha256=L-wXBnGZCLB5UUDrjIdOiMG9zdej3Tw_SftcEmmTukM,84264
 masster/study/export.py,sha256=Rp1vc5iDl-XFWo_RBVCJDGBNSKakq9f8aC2FeUCP9GA,59398
-masster/study/h5.py,sha256=eINlVmcJuntwbkkZHwzm10c63Kg7zib49vkzLDj1PyU,84790
+masster/study/h5.py,sha256=6_nyjMGg_dkKkrx_Mv77wGg5SmWsVOZxu7HZasoXbRU,84916
 masster/study/helpers.py,sha256=dU2YxAGPmu1w55mpcgNoHPpg2fNW-vK944aJy3YwLsU,163555
-masster/study/id.py,sha256=L5S0etAeEmtkzE06M32PNo3rp-WE01sLU6M5_TdNC3w,55266
-masster/study/load.py,sha256=x0OvfOoSY-6lQ8_B9KeDUh_E99eYRm1WGLnCY3CGqF8,71222
-masster/study/merge.py,sha256=MvvEwS2_UCWIrxROtuYTkJOu3pk8EasorbrfWug2e68,159736
+masster/study/id.py,sha256=r_vZQYNxqNXf_pjgk_CLkl1doLnLa956mTuVmlHN52o,80075
+masster/study/load.py,sha256=W4mljmYVR71sas4no7vKWIVfdnQjb-rTcEUhE0ZMr0k,71696
+masster/study/merge.py,sha256=XF4NxNuLSxwf2j1__ReIInXVRGDRoSHFeKdcCSayKU4,164298
 masster/study/parameters.py,sha256=bTvmcwX9INxzcrEAmTiFH8qeWVhwkvMTZjuP394pz5o,3279
 masster/study/plot.py,sha256=pAN5uQKYPUpupQVtKBloWjKOKpM_C9o2e3VWkJ-aZN8,102041
-masster/study/processing.py,sha256=hf8FEPONXz4x6G1fke6SEUnCJCv47cGeo--6h1c1Sis,56441
+masster/study/processing.py,sha256=TKeTzRLmaMxUKCt66pXPfx_7xc-R5__ZwEZdFHOxg6A,55916
 masster/study/save.py,sha256=47AP518epJJ9TjaGGyrLKsMsyjIk8_J4ka7bmsnRtFQ,9268
-masster/study/study.py,sha256=YLt6tqCPkWvmKGBvhiyh1LeZgr165f9eqgiIV5OLomY,38393
-masster/study/study5_schema.json,sha256=ghBeAXFS4a4Uavdn6TUVs9GaR1QOTnADCjQTOkN0tjU,7563
+masster/study/study.py,sha256=vbP_bPa62-KYN0OTUN6PpSyCoFcW-TdbLbx67ShkEx0,42930
+masster/study/study5_schema.json,sha256=0IZxM9VVI0TUlx74BPzJDT44kySi6NZZ6iLR0j8bU_s,7736
 masster/study/defaults/__init__.py,sha256=m3Z5KXGqsTdh7GjYzZoENERt39yRg0ceVRV1DeCt1P0,610
 masster/study/defaults/align_def.py,sha256=hHQbGgsOqMRHHr0Wn8Onr8XeaRz3-fFE0qGE-OMst80,20324
 masster/study/defaults/export_def.py,sha256=eXl3h4aoLX88XkHTpqahLd-QZ2gjUqrmjq8IJULXeWo,1203
 masster/study/defaults/fill_chrom_def.py,sha256=hB6-tyC9bhx-IpGj2HC8FinQdW4VLYj_pn5t1rlj-Ew,8887
-masster/study/defaults/fill_def.py,sha256=TdDqOt-fva44JptLvxOy7GNUCR5isOKz1jR2xj_V8sQ,8869
+masster/study/defaults/fill_def.py,sha256=H-ZNKyiXxBLWdLoCMqxfvphNyc9wrDVFMC7TyRNYEm0,8869
 masster/study/defaults/find_consensus_def.py,sha256=2KRRMsCDP7pwNrLCC6eI5uQgMXqiNdiI6pSvxNJ8L5M,8598
 masster/study/defaults/find_ms2_def.py,sha256=RL0DFG41wQ05U8UQKUGr3vzSl3mU0m0knQus8DpSoJE,5070
 masster/study/defaults/identify_def.py,sha256=96rxoCAPQj_yX-3mRoD2LTkTLJgG27eJQqwarLv5jL0,10580
@@ -66,8 +67,8 @@ masster/wizard/README.md,sha256=mL1A3YWJZOefpJ6D0-HqGLkVRmUlOpwyVFdvJBeeoZM,1414
 masster/wizard/__init__.py,sha256=a2hcZnHASjfuw1lqZhZnvTR58rc33rRnoGAY_JfvGhI,683
 masster/wizard/example.py,sha256=xEZFTH9UZ8HKOm6s3JL8Js0Uw5ChnISWBHSZCL32vsM,7983
 masster/wizard/wizard.py,sha256=esgaifLRyaGxytif9qOkTy-21VxlUQxrvl47K-l-BpE,37666
-masster-0.5.0.dist-info/METADATA,sha256=HSAp3U_YG6chyHAIJ6YAzyQbN0OQ1L2dxs_S0p_CGns,45113
-masster-0.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-masster-0.5.0.dist-info/entry_points.txt,sha256=ZHguQ_vPmdbpqq2uGtmEOLJfgP-DQ1T0c07Lxh30wc8,58
-masster-0.5.0.dist-info/licenses/LICENSE,sha256=bx5iLIKjgAdYQ7sISn7DsfHRKkoCUm1154sJJKhgqnU,35184
-masster-0.5.0.dist-info/RECORD,,
+masster-0.5.1.dist-info/METADATA,sha256=01v713yHW9RJPqFXY89wd5e21Ls3crfs6kEBDhDrUlc,45113
+masster-0.5.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+masster-0.5.1.dist-info/entry_points.txt,sha256=ZHguQ_vPmdbpqq2uGtmEOLJfgP-DQ1T0c07Lxh30wc8,58
+masster-0.5.1.dist-info/licenses/LICENSE,sha256=bx5iLIKjgAdYQ7sISn7DsfHRKkoCUm1154sJJKhgqnU,35184
+masster-0.5.1.dist-info/RECORD,,