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

masster/sample/helpers.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import polars as pl
+import numpy as np
 
 
 # Parameters removed - using hardcoded defaults
@@ -78,14 +79,10 @@ def _estimate_memory_usage(self):
 
     # Log the memory usage summary
     if hasattr(self, "logger"):
-        self.logger.debug(
-            f"Total DataFrame memory usage: {memory_usage['total']['mb']:.2f} MB",
-        )
+        self.logger.debug(f"Total DataFrame memory usage: {memory_usage['total']['mb']:.2f} MB")
         for df_name, stats in memory_usage.items():
             if df_name != "total" and stats["bytes"] > 0:
-                self.logger.debug(
-                    f"{df_name}: {stats['rows']} rows, {stats['mb']:.2f} MB",
-                )
+                self.logger.debug(f"{df_name}: {stats['rows']} rows, {stats['mb']:.2f} MB")
 
     return memory_usage["total"]["mb"]
 
@@ -113,9 +110,7 @@ def _get_scan_uids(self, scans=None, verbose=True):
         scans_uids = self.scans_df.get_column("scan_uid").to_list()
     elif isinstance(scans, list):
         # if scans is a list, ensure all elements are valid scan_uids
-        scans_uids = [
-            s for s in scans if s in self.scans_df.get_column("scan_uid").to_list()
-        ]
+        scans_uids = [s for s in scans if s in self.scans_df.get_column("scan_uid").to_list()]
         if verbose and not scans_uids:
             self.logger.error("No valid scan_uids provided.")
 
@@ -148,9 +143,7 @@ def _get_feature_uids(self, features=None, verbose=True):
         # If features is a list, ensure all elements are valid feature_uids
         if self.features_df is None:
             if verbose:
-                self.logger.warning(
-                    "No features_df available to validate feature UIDs.",
-                )
+                self.logger.warning("No features_df available to validate feature UIDs.")
             return []
 
         valid_feature_uids = self.features_df.get_column("feature_uid").to_list()
@@ -171,9 +164,7 @@ def _get_feature_uids(self, features=None, verbose=True):
 
                 if feature_column is None:
                     if verbose:
-                        self.logger.error(
-                            "No 'feature_uid' or 'feature_id' column found in polars DataFrame.",
-                        )
+                        self.logger.error("No 'feature_uid' or 'feature_id' column found in polars DataFrame.")
                     return []
 
                 # Get unique values from the column
@@ -199,9 +190,7 @@ def _get_feature_uids(self, features=None, verbose=True):
 
                 if feature_column is None:
                     if verbose:
-                        self.logger.error(
-                            "No 'feature_uid' or 'feature_id' column found in pandas DataFrame.",
-                        )
+                        self.logger.error("No 'feature_uid' or 'feature_id' column found in pandas DataFrame.")
                     return []
 
                 # Get unique values from the column
@@ -209,9 +198,7 @@ def _get_feature_uids(self, features=None, verbose=True):
 
             else:
                 if verbose:
-                    self.logger.error(
-                        "Invalid input type. Expected None, list, polars DataFrame, or pandas DataFrame.",
-                    )
+                    self.logger.error("Invalid input type. Expected None, list, polars DataFrame, or pandas DataFrame.")
                 return []
 
         except Exception as e:
@@ -328,9 +315,7 @@ def get_eic(self, mz, mz_tol=None):
         # Filter by mz window
         mz_min = mz - mz_tol
         mz_max = mz + mz_tol
-        matches = self.ms1_df.filter(
-            (pl.col("mz") >= mz_min) & (pl.col("mz") <= mz_max),
-        )
+        matches = self.ms1_df.filter((pl.col("mz") >= mz_min) & (pl.col("mz") <= mz_max))
 
         if len(matches) == 0:
             if hasattr(self, "logger"):
@@ -340,9 +325,7 @@ def get_eic(self, mz, mz_tol=None):
             return None
 
         # Aggregate intensities per retention time. Use sum in case multiple points per rt.
-        chrom = (
-            matches.group_by("rt").agg([pl.col("inty").sum().alias("inty")]).sort("rt")
-        )
+        chrom = matches.group_by("rt").agg([pl.col("inty").sum().alias("inty")]).sort("rt")
 
         # Attach to Sample
         self.chrom_df = chrom
@@ -408,8 +391,7 @@ def select(
             if isinstance(coherence, tuple) and len(coherence) == 2:
                 min_coherence, max_coherence = coherence
                 feats = feats.filter(
-                    (pl.col("chrom_coherence") >= min_coherence)
-                    & (pl.col("chrom_coherence") <= max_coherence),
+                    (pl.col("chrom_coherence") >= min_coherence) & (pl.col("chrom_coherence") <= max_coherence),
                 )
             else:
                 feats = feats.filter(pl.col("chrom_coherence") >= coherence)
@@ -460,8 +442,7 @@ def select(
         if isinstance(rt_delta, tuple) and len(rt_delta) == 2:
             min_rt_delta, max_rt_delta = rt_delta
             feats = feats.filter(
-                (pl.col("rt_delta") >= min_rt_delta)
-                & (pl.col("rt_delta") <= max_rt_delta),
+                (pl.col("rt_delta") >= min_rt_delta) & (pl.col("rt_delta") <= max_rt_delta),
             )
         else:
             feats = feats.filter(pl.col("rt_delta") >= rt_delta)
@@ -538,8 +519,7 @@ def select(
         if isinstance(prominence, tuple) and len(prominence) == 2:
             min_prominence, max_prominence = prominence
             feats = feats.filter(
-                (pl.col("chrom_prominence") >= min_prominence)
-                & (pl.col("chrom_prominence") <= max_prominence),
+                (pl.col("chrom_prominence") >= min_prominence) & (pl.col("chrom_prominence") <= max_prominence),
             )
         else:
             feats = feats.filter(pl.col("chrom_prominence") >= prominence)
@@ -550,9 +530,7 @@ def select(
     if height is not None:
         feats_len_before_filter = len(feats)
         # Check if chrom_height column exists, if not use chrom_height_scaled
-        height_col = (
-            "chrom_height" if "chrom_height" in feats.columns else "chrom_height_scaled"
-        )
+        height_col = "chrom_height" if "chrom_height" in feats.columns else "chrom_height_scaled"
         if isinstance(height, tuple) and len(height) == 2:
             min_height, max_height = height
             feats = feats.filter(
@@ -573,23 +551,23 @@ def select(
 def _features_sync(self):
     """
     Synchronizes the cached FeatureMap with features_df.
-
-    This ensures that the cached FeatureMap (_oms_features_map) contains only features
-    that exist in both the FeatureMap and the features_df. This is important
+    
+    This ensures that the cached FeatureMap (_oms_features_map) contains only features 
+    that exist in both the FeatureMap and the features_df. This is important 
     after operations that modify features_df but not the FeatureMap (like filtering).
-
+    
     Side Effects:
         Updates self._oms_features_map and self.features_df to contain only common features.
         Logs information about removed features.
     """
     if self.features_df is None or len(self.features_df) == 0:
         self.logger.debug("No features_df to synchronize")
-        if hasattr(self, "_oms_features_map"):
+        if hasattr(self, '_oms_features_map'):
             self._oms_features_map = None
         return
 
     # Check if we have a cached feature map
-    if not hasattr(self, "_oms_features_map") or self._oms_features_map is None:
+    if not hasattr(self, '_oms_features_map') or self._oms_features_map is None:
         self.logger.debug("No cached feature map to synchronize")
         return
 
@@ -598,26 +576,20 @@ def _features_sync(self):
     except ImportError:
         self.logger.warning("PyOpenMS not available, cannot sync FeatureMap")
         return
-
+    
     try:
         # Get feature IDs from both sources
         if "feature_id" in self.features_df.columns:
-            df_feature_ids = set(
-                self.features_df.get_column("feature_id").cast(str).to_list(),
-            )
+            df_feature_ids = set(self.features_df.get_column("feature_id").cast(str).to_list())
         else:
-            self.logger.warning(
-                "No feature_id column in features_df, cannot synchronize",
-            )
+            self.logger.warning("No feature_id column in features_df, cannot synchronize")
             return
 
         # Get feature IDs from FeatureMap
         feature_map_ids = set()
         for i in range(self._oms_features_map.size()):
             feature = self._oms_features_map[i]
-            unique_id = str(
-                feature.getUniqueId(),
-            )  # Convert to string to match DataFrame
+            unique_id = str(feature.getUniqueId())  # Convert to string to match DataFrame
             feature_map_ids.add(unique_id)
 
         # Find features that exist in both
@@ -715,7 +687,7 @@ def features_delete(self, features: list | None = None):
     )
 
     # Update the OpenMS FeatureMap by creating a new one with only features to keep
-    if hasattr(self, "_oms_features_map") and self._oms_features_map is not None:
+    if hasattr(self, '_oms_features_map') and self._oms_features_map is not None:
         try:
             # Import pyopenms
             import pyopenms as oms
@@ -724,9 +696,7 @@ def features_delete(self, features: list | None = None):
             filtered_map = oms.FeatureMap()
 
             # Get the feature UIDs that should remain after deletion
-            remaining_feature_uids = self.features_df.get_column(
-                "feature_uid",
-            ).to_list()
+            remaining_feature_uids = self.features_df.get_column("feature_uid").to_list()
 
             # Iterate through existing features and keep only those not in deletion list
             for i in range(self._oms_features_map.size()):
@@ -738,16 +708,12 @@ def features_delete(self, features: list | None = None):
 
             # Replace the original FeatureMap with the filtered one
             self._oms_features_map = filtered_map
-            self.logger.debug(
-                f"OpenMS FeatureMap updated with {filtered_map.size()} remaining features.",
-            )
+            self.logger.debug(f"OpenMS FeatureMap updated with {filtered_map.size()} remaining features.")
 
         except ImportError:
             self.logger.warning("PyOpenMS not available, only updating features_df")
         except Exception as e:
-            self.logger.warning(
-                f"Could not update OpenMS FeatureMap: {e}. FeatureMap may be out of sync.",
-            )
+            self.logger.warning(f"Could not update OpenMS FeatureMap: {e}. FeatureMap may be out of sync.")
 
     # Update scans_df to remove feature_uid associations for deleted features
     if hasattr(self, "scans_df") and self.scans_df is not None:
@@ -759,9 +725,7 @@ def features_delete(self, features: list | None = None):
         )
 
     deleted_count = original_count - len(self.features_df)
-    self.logger.info(
-        f"Deleted {deleted_count} features. Remaining features: {len(self.features_df)}",
-    )
+    self.logger.info(f"Deleted {deleted_count} features. Remaining features: {len(self.features_df)}")
 
 
 def _delete_ms2(self):
@@ -784,19 +748,14 @@ def _delete_ms2(self):
     self.logger.debug("Unlinking MS2 spectra from features...")
 
     # Set ms2_scans and ms2_specs to None using Polars syntax
-    self.features_df = self.features_df.with_columns(
-        [
-            pl.lit(None).alias("ms2_scans"),
-            pl.lit(None).alias("ms2_specs"),
-        ],
-    )
+    self.features_df = self.features_df.with_columns([
+        pl.lit(None).alias("ms2_scans"),
+        pl.lit(None).alias("ms2_specs"),
+    ])
 
     # Update scans_df to remove feature_uid association for linked MS2 spectra
     self.scans_df = self.scans_df.with_columns(
-        pl.when(pl.col("ms_level") == 2)
-        .then(None)
-        .otherwise(pl.col("feature_uid"))
-        .alias("feature_uid"),
+        pl.when(pl.col("ms_level") == 2).then(None).otherwise(pl.col("feature_uid")).alias("feature_uid"),
     )
     self.logger.info("MS2 spectra unlinked from features.")
 
@@ -828,9 +787,7 @@ def features_filter(self, features):
         return
 
     if features is None:
-        self.logger.warning(
-            "No features specified to keep. Use features_delete() to delete all features.",
-        )
+        self.logger.warning("No features specified to keep. Use features_delete() to delete all features.")
         return
 
     # Get the feature UIDs to keep
@@ -852,7 +809,7 @@ def features_filter(self, features):
     feature_uids_to_delete = list(all_feature_uids - set(feature_uids_to_keep))
 
     # Update the OpenMS FeatureMap by creating a new one with only features to keep
-    if hasattr(self, "_oms_features_map") and self._oms_features_map is not None:
+    if hasattr(self, '_oms_features_map') and self._oms_features_map is not None:
         try:
             # Import pyopenms
             import pyopenms as oms
@@ -870,23 +827,15 @@ def features_filter(self, features):
 
             # Replace the original FeatureMap with the filtered one
             self._oms_features_map = filtered_map
-            self.logger.debug(
-                f"OpenMS FeatureMap updated with {filtered_map.size()} remaining features.",
-            )
+            self.logger.debug(f"OpenMS FeatureMap updated with {filtered_map.size()} remaining features.")
 
         except ImportError:
             self.logger.warning("PyOpenMS not available, only updating features_df")
         except Exception as e:
-            self.logger.warning(
-                f"Could not update OpenMS FeatureMap: {e}. FeatureMap may be out of sync.",
-            )
+            self.logger.warning(f"Could not update OpenMS FeatureMap: {e}. FeatureMap may be out of sync.")
 
     # Update scans_df to remove feature_uid associations for deleted features
-    if (
-        hasattr(self, "scans_df")
-        and self.scans_df is not None
-        and feature_uids_to_delete
-    ):
+    if hasattr(self, "scans_df") and self.scans_df is not None and feature_uids_to_delete:
         self.scans_df = self.scans_df.with_columns(
             pl.when(pl.col("feature_uid").is_in(feature_uids_to_delete))
             .then(None)
@@ -896,9 +845,7 @@ def features_filter(self, features):
 
     kept_count = len(self.features_df)
     deleted_count = original_count - kept_count
-    self.logger.info(
-        f"Kept {kept_count} features, deleted {deleted_count} features. Remaining features: {kept_count}",
-    )
+    self.logger.info(f"Kept {kept_count} features, deleted {deleted_count} features. Remaining features: {kept_count}")
 
 
 def set_source(self, filename):
@@ -942,9 +889,7 @@ def set_source(self, filename):
 
     # Log the change
     if old_file_source is not None:
-        self.logger.info(
-            f"Updated file_source from {old_file_source} to {self.file_source}",
-        )
+        self.logger.info(f"Updated file_source from {old_file_source} to {self.file_source}")
     else:
         self.logger.info(f"Set file_source to {self.file_source}")
 
@@ -952,90 +897,89 @@ def set_source(self, filename):
 def _recreate_feature_map(self):
     """
     Recreate OpenMS FeatureMap from features_df.
-
+    
     This helper function creates a new OpenMS FeatureMap using the data from features_df.
     This allows us to avoid storing and loading featureXML files by default, while still
     being able to recreate the feature map when needed for OpenMS operations like
     find_features() or saving to featureXML format.
-
+    
     Returns:
         oms.FeatureMap: A new FeatureMap with features from features_df, or None if no features
-
+    
     Side Effects:
         Caches the created feature map in self._oms_features_map for reuse
     """
     if self.features_df is None or len(self.features_df) == 0:
         self.logger.debug("No features_df available to recreate feature map")
         return None
-
+    
     try:
         import pyopenms as oms
     except ImportError:
         self.logger.warning("PyOpenMS not available, cannot recreate feature map")
         return None
-
+    
     # Create new FeatureMap
     feature_map = oms.FeatureMap()
-
+    
     # Set the primary MS run path if available
-    if hasattr(self, "file_path") and self.file_path:
+    if hasattr(self, 'file_path') and self.file_path:
         feature_map.setPrimaryMSRunPath([self.file_path.encode()])
-
+    
     # Convert DataFrame features to OpenMS Features
     for i, feature_row in enumerate(self.features_df.iter_rows(named=True)):
         feature = oms.Feature()
-
+        
         # Set basic properties from DataFrame (handle missing values gracefully)
         try:
-            if feature_row.get("feature_id") is not None:
-                feature.setUniqueId(int(feature_row["feature_id"]))
+            if feature_row.get('feature_id') is not None:
+                feature.setUniqueId(int(feature_row['feature_id']))
             else:
                 feature.setUniqueId(i)  # Use index as fallback
-
-            if feature_row.get("mz") is not None:
-                feature.setMZ(float(feature_row["mz"]))
-            if feature_row.get("rt") is not None:
-                feature.setRT(float(feature_row["rt"]))
-            if feature_row.get("inty") is not None:
-                feature.setIntensity(float(feature_row["inty"]))
-            if feature_row.get("quality") is not None:
-                feature.setOverallQuality(float(feature_row["quality"]))
-            if feature_row.get("charge") is not None:
-                feature.setCharge(int(feature_row["charge"]))
-
+                
+            if feature_row.get('mz') is not None:
+                feature.setMZ(float(feature_row['mz']))
+            if feature_row.get('rt') is not None:
+                feature.setRT(float(feature_row['rt']))
+            if feature_row.get('inty') is not None:
+                feature.setIntensity(float(feature_row['inty']))
+            if feature_row.get('quality') is not None:
+                feature.setOverallQuality(float(feature_row['quality']))
+            if feature_row.get('charge') is not None:
+                feature.setCharge(int(feature_row['charge']))
+                
             # Add to feature map
             feature_map.push_back(feature)
-
+            
         except (ValueError, TypeError) as e:
             self.logger.warning(f"Skipping feature due to conversion error: {e}")
             continue
-
+    
     # Ensure unique IDs
     feature_map.ensureUniqueId()
-
+    
     # Cache the feature map
     self._oms_features_map = feature_map
-
-    self.logger.debug(
-        f"Recreated FeatureMap with {feature_map.size()} features from features_df",
-    )
+    
+    self.logger.debug(f"Recreated FeatureMap with {feature_map.size()} features from features_df")
     return feature_map
 
 
 def _get_feature_map(self):
     """
     Get the OpenMS FeatureMap, creating it from features_df if needed.
-
+    
     This property-like method returns the cached feature map if available,
-    or recreates it from features_df if not. This allows lazy loading of
+    or recreates it from features_df if not. This allows lazy loading of 
     feature maps only when needed for OpenMS operations.
-
+    
     Returns:
         oms.FeatureMap or None: The feature map, or None if not available
     """
     # Return cached feature map if available
-    if hasattr(self, "_oms_features_map") and self._oms_features_map is not None:
+    if hasattr(self, '_oms_features_map') and self._oms_features_map is not None:
         return self._oms_features_map
-
+    
     # Otherwise recreate from features_df
     return self._recreate_feature_map()
+

masster/sample/lib.py

@@ -1,8 +1,8 @@
 """
 lib.py
 
-This module provides the Lib class and utility functions for mass spectrometry compound library
-management and feature annotation. It contains core functionality for compound library management,
+This module provides the Lib class and utility functions for mass spectrometry compound library 
+management and feature annotation. It contains core functionality for compound library management, 
 target identification, adduct handling, and various analytical operations.
 
 Key Features:
@@ -34,7 +34,7 @@ Supported Adducts:
 
 Example Usage:
 ```python
-from master.sample.lib import Lib
+from masster.sample.lib import Lib
 
 # Create library instance
 lib = Lib()
@@ -63,7 +63,7 @@ import pyopenms as oms
 
 from tqdm import tqdm
 
-from master.chromatogram import Chromatogram
+from masster.chromatogram import Chromatogram
 # Parameters removed - using hardcoded defaults
 
 
@@ -251,9 +251,7 @@ def lib_link(
 
     for _index, row in self.lib.iterrows():
         # find all features that match the mz and rt is not None
-        mask = (self.features_df["mz"] >= row["mz"] - mz_tol_lib) & (
-            self.features_df["mz"] <= row["mz"] + mz_tol_lib
-        )
+        mask = (self.features_df["mz"] >= row["mz"] - mz_tol_lib) & (self.features_df["mz"] <= row["mz"] + mz_tol_lib)
         if row["rt"] is not None and rt_tol_lib is not np.nan:
             mask &= (self.features_df["rt"] >= row["rt"] - rt_tol_lib) & (
                 self.features_df["rt"] <= row["rt"] + rt_tol_lib
@@ -280,12 +278,8 @@ def lib_link(
                     "mz": f["mz"].values[0],
                     "delta_mz": row["mz"] - f["mz"].values[0],
                     "rt": f["rt"].values[0],
-                    "delta_rt": row["rt"] - f["rt"].values[0]
-                    if row["rt"] is not None
-                    else None,
-                    "ms2_scans": f["ms2_scans"].values[0]
-                    if "ms2_scans" in self.features_df.columns
-                    else None,
+                    "delta_rt": row["rt"] - f["rt"].values[0] if row["rt"] is not None else None,
+                    "ms2_scans": f["ms2_scans"].values[0] if "ms2_scans" in self.features_df.columns else None,
                     "eic": None,
                 }
                 lib_matches.append(new_match)
@@ -418,9 +412,7 @@ def save_lib_mgf(
             desc="Export MGF",
         ):
             # find the feature with feature_uid == matchrow["feature_uid"]
-            row = self.features_df[
-                self.features_df["feature_uid"] == matchrow["feature_uid"]
-            ].iloc[0]
+            row = self.features_df[self.features_df["feature_uid"] == matchrow["feature_uid"]].iloc[0]
             if row["ms2_scans"] is None:
                 skip = skip + 1
                 continue
@@ -546,9 +538,7 @@ def save_lib_mgf(
                         d = {
                             "PEPMASS": row["mz"],
                             "RTINSECONDS": row["rt"],
-                            "IONMODE": "positive"
-                            if matchrow["adduct"][-1] == "+"
-                            else "negative",
+                            "IONMODE": "positive" if matchrow["adduct"][-1] == "+" else "negative",
                             "CHARGE": "1" + matchrow["adduct"].split("]")[1],
                             "NAME": f"{matchrow['name']}",
                             "SMILES": matchrow["smiles"],
@@ -616,9 +606,7 @@ def save_lib_mgf(
                     d = {
                         "PEPMASS": row["mz"],
                         "RTINSECONDS": row["rt"],
-                        "IONMODE": "positive"
-                        if matchrow["adduct"][-1] == "+"
-                        else "negative",
+                        "IONMODE": "positive" if matchrow["adduct"][-1] == "+" else "negative",
                         "CHARGE": "1" + matchrow["adduct"].split("]")[1],
                         "NAME": f"{matchrow['name']}",
                         "SMILES": matchrow["smiles"],
@@ -653,18 +641,14 @@ def save_lib_mgf(
                                 spec = spec.centroid(
                                     tolerance=self.parameters["mz_tol_ms1_da"],
                                     ppm=self.parameters["mz_tol_ms1_ppm"],
-                                    min_points=self.parameters[
-                                        "centroid_min_points_ms1"
-                                    ],
+                                    min_points=self.parameters["centroid_min_points_ms1"],
                                     algo=centroid_algo,
                                 )
                             elif spec.ms_level == 2:
                                 spec = spec.centroid(
                                     tolerance=self.parameters["mz_tol_ms2_da"],
                                     ppm=self.parameters["mz_tol_ms2_ppm"],
-                                    min_points=self.parameters[
-                                        "centroid_min_points_ms2"
-                                    ],
+                                    min_points=self.parameters["centroid_min_points_ms2"],
                                     algo=centroid_algo,
                                 )
                         if deisotope:
@@ -699,9 +683,7 @@ def save_lib_mgf(
                         d = {
                             "PEPMASS": row["mz"],
                             "RTINSECONDS": row["rt"],
-                            "IONMODE": "positive"
-                            if matchrow["adduct"][-1] == "+"
-                            else "negative",
+                            "IONMODE": "positive" if matchrow["adduct"][-1] == "+" else "negative",
                             "CHARGE": "1" + matchrow["adduct"].split("]")[1],
                             "NAME": f"{matchrow['name']}",
                             "SMILES": matchrow["smiles"],
@@ -739,8 +721,7 @@ def save_lib_mgf(
                             kineticenergy = None
                             if mslevel > 1:
                                 if (
-                                    "CID" in filename.upper()
-                                    or "ZTS" in filename.upper()
+                                    "CID" in filename.upper() or "ZTS" in filename.upper()
                                 ) and "EAD" in filename.upper():
                                     activation = "CID-EAD"
                                     match = re.search(r"(\d+)KE", filename.upper())
@@ -752,17 +733,13 @@ def save_lib_mgf(
                                             kineticenergy = int(match.group(1))
                                         else:
                                             activation = "CID"
-                                energy = (
-                                    spec.energy if hasattr(spec, "energy") else None
-                                )
+                                energy = spec.energy if hasattr(spec, "energy") else None
 
                             spec = filter_peaks(spec, inty_min=inty_min)
                             d = {
                                 "PEPMASS": row["mz"],
                                 "RTINSECONDS": row["rt"],
-                                "IONMODE": "positive"
-                                if matchrow["adduct"][-1] == "+"
-                                else "negative",
+                                "IONMODE": "positive" if matchrow["adduct"][-1] == "+" else "negative",
                                 "CHARGE": "1" + matchrow["adduct"].split("]")[1],
                                 "NAME": f"{matchrow['name']}",
                                 "SMILES": matchrow["smiles"],
@@ -775,9 +752,7 @@ def save_lib_mgf(
                                 "FILENAME": filename,
                                 "SCANS": ms1_scan_uid,
                                 "FID": row["fid"],
-                                "MSLEVEL": 1
-                                if spec.ms_level is None
-                                else spec.ms_level,
+                                "MSLEVEL": 1 if spec.ms_level is None else spec.ms_level,
                             }
                             write_ion(f, d, spec)