masster 0.4.4__py3-none-any.whl → 0.4.6__py3-none-any.whl

masster/sample/helpers.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import polars as pl
-import numpy as np
 
 
 # Parameters removed - using hardcoded defaults
@@ -79,10 +78,14 @@ 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"]
 
@@ -110,7 +113,9 @@ 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.")
 
@@ -143,7 +148,9 @@ 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()
@@ -164,7 +171,9 @@ 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
@@ -190,7 +199,9 @@ 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
@@ -198,7 +209,9 @@ 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:
@@ -315,7 +328,9 @@ 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"):
@@ -325,7 +340,9 @@ 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
@@ -391,7 +408,8 @@ 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)
@@ -442,7 +460,8 @@ 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)
@@ -519,7 +538,8 @@ 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)
@@ -530,7 +550,9 @@ 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(
@@ -551,23 +573,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
 
@@ -576,20 +598,26 @@ 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
@@ -687,7 +715,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
@@ -696,7 +724,9 @@ 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()):
@@ -708,12 +738,16 @@ 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:
@@ -725,7 +759,9 @@ 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):
@@ -748,14 +784,19 @@ 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.")
 
@@ -787,7 +828,9 @@ 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
@@ -809,7 +852,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
@@ -827,15 +870,23 @@ 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)
@@ -845,7 +896,9 @@ 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):
@@ -889,7 +942,9 @@ 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}")
 
@@ -897,89 +952,90 @@ 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:

masster/sample/load.py

@@ -177,7 +177,7 @@ def load_study(
 ):
     """
     Backward compatibility alias for load_noms1().
-    
+
     This method is deprecated. Use load_noms1() instead.
     """
     return self.load_noms1(filename=filename, ondisk=ondisk, type=type, label=label)
@@ -263,12 +263,16 @@ def _load_mzML(
             energy = None
         else:
             prec_mz = s.getPrecursors()[0].getMZ()
-            precursorIsolationWindowLowerMZ = s.getPrecursors()[0].getIsolationWindowLowerOffset()
-            precursorIsolationWindowUpperMZ = s.getPrecursors()[0].getIsolationWindowUpperOffset()
+            precursorIsolationWindowLowerMZ = s.getPrecursors()[
+                0
+            ].getIsolationWindowLowerOffset()
+            precursorIsolationWindowUpperMZ = s.getPrecursors()[
+                0
+            ].getIsolationWindowUpperOffset()
             prec_intyensity = s.getPrecursors()[0].getIntensity()
             # Try to get collision energy from meta values first, fallback to getActivationEnergy()
             try:
-                energy = s.getPrecursors()[0].getMetaValue('collision energy')
+                energy = s.getPrecursors()[0].getMetaValue("collision energy")
                 if energy is None or energy == 0.0:
                     energy = s.getPrecursors()[0].getActivationEnergy()
             except Exception:
@@ -553,9 +557,9 @@ def _load_wiff(
 ):
     try:
         # Use masster's own implementation first
-        from masster.sample.sciex import SciexWiffData as MassterSciexWiffData
+        from masster.sample.sciex import SciexWiffData as MasterSciexWiffData
 
-        SciexWiffDataClass = MassterSciexWiffData
+        SciexWiffDataClass = MasterSciexWiffData
     except ImportError:
         # Fallback to alpharaw if masster implementation fails
         from alpharaw.sciex import SciexWiffData as AlpharawSciexWiffData
@@ -985,7 +989,9 @@ def index_file(self):
         self.logger.info("Index raw data...")
         raw_data.import_raw(self.file_source)
         self.file_obj = raw_data
-    elif os.path.exists(self.file_source) and self.file_source.lower().endswith(".mzml"):
+    elif os.path.exists(self.file_source) and self.file_source.lower().endswith(
+        ".mzml",
+    ):
         self.file_interface = "oms"
         omsexp: oms.OnDiscMSExperiment | oms.MSExperiment
         if self.ondisk:
@@ -995,7 +1001,9 @@ def index_file(self):
             omsexp = oms.MSExperiment()
             oms.MzMLFile().load(self.file_source, omsexp)
             self.file_obj = omsexp
-    elif os.path.exists(self.file_source) and self.file_source.lower().endswith(".sample5"):
+    elif os.path.exists(self.file_source) and self.file_source.lower().endswith(
+        ".sample5",
+    ):
         # this is an old save, try to see if
         if os.path.exists(self.file_source.replace(".sample5", ".wiff")):
             self.set_source(self.file_source.replace(".sample5", ".wiff"))
@@ -1009,7 +1017,9 @@ def index_file(self):
             )
         self.index_file()
     else:
-        raise FileNotFoundError(f"File {self.file_source} not found. Did the path change? Consider running source().")
+        raise FileNotFoundError(
+            f"File {self.file_source} not found. Did the path change? Consider running source().",
+        )
 
 
 def _load_ms2data(
@@ -1214,7 +1224,9 @@ def chrom_extract(
             scan_uid = trace["scan_uid"]
             # find all ms1 data with scan_uid and mz between q1-mz_tol and q1+mz_tol
             d = self.ms1_df.filter(
-                (pl.col("scan_uid").is_in(scan_uid)) & (pl.col("mz") >= q1 - mz_tol) & (pl.col("mz") <= q1 + mz_tol),
+                (pl.col("scan_uid").is_in(scan_uid))
+                & (pl.col("mz") >= q1 - mz_tol)
+                & (pl.col("mz") <= q1 + mz_tol),
             )
             # for all unique rt values, find the maximum inty
             eic_rt = d.group_by("rt").agg(pl.col("inty").max())
@@ -1233,7 +1245,9 @@ def chrom_extract(
             scan_uid = trace["scan_uid"]
             # find all ms2 data with scan_uid and mz between q3-mz_tol and q3+mz_tol
             d = self.ms2data.filter(
-                (pl.col("scan_uid").is_in(scan_uid)) & (pl.col("mz") >= q3 - mz_tol) & (pl.col("mz") <= q3 + mz_tol),
+                (pl.col("scan_uid").is_in(scan_uid))
+                & (pl.col("mz") >= q3 - mz_tol)
+                & (pl.col("mz") <= q3 + mz_tol),
             )
             # for all unique rt values, find the maximum inty
             eic_rt = d.group_by("rt").agg(pl.col("inty").max())

masster/sample/plot.py

@@ -144,7 +144,7 @@ def _display_plot(plot_object, layout=None):
 def _handle_sample_plot_output(self, plot_obj, filename=None, plot_type="bokeh"):
     """
     Helper function to handle consistent save/display behavior for sample plots.
-    
+
     Parameters:
         plot_obj: The plot object (bokeh figure, holoviews layout, or panel object)
         filename: Optional filename to save the plot
@@ -155,10 +155,10 @@ def _handle_sample_plot_output(self, plot_obj, filename=None, plot_type="bokeh")
         import os
         if hasattr(self, 'folder') and self.folder and not os.path.isabs(filename):
             filename = os.path.join(self.folder, filename)
-        
+
         # Convert to absolute path for logging
         abs_filename = os.path.abspath(filename)
-        
+
         if filename.endswith(".html"):
             if plot_type == "panel":
                 plot_obj.save(filename, embed=True)  # type: ignore[attr-defined]
@@ -375,7 +375,7 @@ def plot_chrom(
 
     layout = layout.cols(1)
     layout = panel.Column(layout)
-    
+
     # Use consistent save/display behavior
     self._handle_sample_plot_output(layout, filename, "panel")
 
@@ -927,7 +927,7 @@ def plot_2d(
         layout = panel.Column(overlay)
 
     if filename is not None:
-        # Use consistent save/display behavior  
+        # Use consistent save/display behavior
         self._handle_sample_plot_output(layout, filename, "panel")
         return None
     else: