masster 0.5.22__py3-none-any.whl → 0.5.24__py3-none-any.whl

masster/sample/plot.py

@@ -66,12 +66,12 @@ from cmap import Colormap
 def _process_cmap(cmap, fallback="viridis", logger=None):
     """
     Process colormap using the cmap package, similar to study's implementation.
-    
+
     Parameters:
         cmap: Colormap specification (string name, cmap.Colormap object, or None)
         fallback: Fallback colormap name if cmap processing fails
         logger: Logger for warnings (optional)
-        
+
     Returns:
         list: List of hex color strings for the colormap
     """
@@ -80,19 +80,20 @@ def _process_cmap(cmap, fallback="viridis", logger=None):
         cmap = "viridis"
     elif cmap == "grey":
         cmap = "greys"
-        
+
     # If cmap package is not available, fall back to process_cmap
     if Colormap is None:
         if logger:
             logger.warning("cmap package not available, using holoviews process_cmap")
         return process_cmap(cmap, provider="bokeh")
-    
+
     try:
         # Handle colormap using cmap.Colormap
         if isinstance(cmap, str):
             colormap = Colormap(cmap)
             # Generate 256 colors and convert to hex
             import matplotlib.colors as mcolors
+
             colors = colormap(np.linspace(0, 1, 256))
             palette = [mcolors.rgb2hex(color) for color in colors]
         else:
@@ -104,16 +105,18 @@ def _process_cmap(cmap, fallback="viridis", logger=None):
                 if not isinstance(palette, (list, tuple)):
                     # Fall back to generating colors manually
                     import matplotlib.colors as mcolors
+
                     colors = colormap(np.linspace(0, 1, 256))
                     palette = [mcolors.rgb2hex(color) for color in colors]
             except AttributeError:
                 # Fall back to generating colors manually
                 import matplotlib.colors as mcolors
+
                 colors = colormap(np.linspace(0, 1, 256))
                 palette = [mcolors.rgb2hex(color) for color in colors]
-        
+
         return palette
-        
+
     except (AttributeError, ValueError, TypeError) as e:
         # Fallback to process_cmap if cmap interpretation fails
         if logger:
@@ -202,60 +205,63 @@ def _display_plot(plot_object, layout=None):
 def _export_with_webdriver_manager(plot_obj, filename, format_type, logger=None):
     """
     Export plot to PNG or SVG using webdriver-manager for automatic driver management.
-    
+
     Parameters:
         plot_obj: Bokeh plot object or holoviews object to export
-        filename: Output filename 
+        filename: Output filename
         format_type: Either "png" or "svg"
         logger: Logger for error reporting (optional)
-        
+
     Returns:
         bool: True if export successful, False otherwise
     """
     try:
         # Convert holoviews to bokeh if needed
-        if hasattr(plot_obj, 'opts'):  # Likely a holoviews object
+        if hasattr(plot_obj, "opts"):  # Likely a holoviews object
             import holoviews as hv
+
             bokeh_plot = hv.render(plot_obj)
         else:
             bokeh_plot = plot_obj
-            
+
         # Try webdriver-manager export first
         try:
             from webdriver_manager.chrome import ChromeDriverManager
             from selenium import webdriver
             from selenium.webdriver.chrome.service import Service
             from selenium.webdriver.chrome.options import Options
-            
+
             # Set up Chrome options for headless operation
             chrome_options = Options()
             chrome_options.add_argument("--headless")
             chrome_options.add_argument("--no-sandbox")
             chrome_options.add_argument("--disable-dev-shm-usage")
             chrome_options.add_argument("--disable-gpu")
-            
+
             # Use webdriver-manager to automatically get the correct ChromeDriver
             service = Service(ChromeDriverManager().install())
             driver = webdriver.Chrome(service=service, options=chrome_options)
-            
+
             # Export with managed webdriver
             with warnings.catch_warnings():
                 warnings.simplefilter("ignore", category=UserWarning)
                 # Filter out bokeh.io.export warnings specifically
                 warnings.filterwarnings("ignore", module="bokeh.io.export")
-                
+
                 if format_type == "png":
                     from bokeh.io import export_png
+
                     export_png(bokeh_plot, filename=filename, webdriver=driver)
                 elif format_type == "svg":
                     from bokeh.io import export_svg
+
                     export_svg(bokeh_plot, filename=filename, webdriver=driver)
                 else:
                     raise ValueError(f"Unsupported format: {format_type}")
-                
+
             driver.quit()
             return True
-            
+
         except ImportError:
             if logger:
                 logger.debug(f"webdriver-manager not available, using default {format_type.upper()} export")
@@ -264,37 +270,43 @@ def _export_with_webdriver_manager(plot_obj, filename, format_type, logger=None)
                 warnings.simplefilter("ignore", category=UserWarning)
                 # Filter out bokeh.io.export warnings specifically
                 warnings.filterwarnings("ignore", module="bokeh.io.export")
-                
+
                 if format_type == "png":
                     from bokeh.io import export_png
+
                     export_png(bokeh_plot, filename=filename)
                 elif format_type == "svg":
                     from bokeh.io import export_svg
+
                     export_svg(bokeh_plot, filename=filename)
             return True
-            
+
         except Exception as e:
             if logger:
-                logger.debug(f"{format_type.upper()} export with webdriver-manager failed: {e}, using default {format_type.upper()} export")
+                logger.debug(
+                    f"{format_type.upper()} export with webdriver-manager failed: {e}, using default {format_type.upper()} export"
+                )
             try:
                 # Final fallback to default export
                 with warnings.catch_warnings():
                     warnings.simplefilter("ignore", category=UserWarning)
                     # Filter out bokeh.io.export warnings specifically
                     warnings.filterwarnings("ignore", module="bokeh.io.export")
-                    
+
                     if format_type == "png":
                         from bokeh.io import export_png
+
                         export_png(bokeh_plot, filename=filename)
                     elif format_type == "svg":
                         from bokeh.io import export_svg
+
                         export_svg(bokeh_plot, filename=filename)
                 return True
             except Exception as e2:
                 if logger:
                     logger.error(f"{format_type.upper()} export failed: {e2}")
                 return False
-                
+
     except Exception as e:
         if logger:
             logger.error(f"Export preparation failed: {e}")
@@ -313,7 +325,8 @@ def _handle_sample_plot_output(self, plot_obj, filename=None, plot_type="bokeh")
     if filename is not None:
         # Convert relative paths to absolute paths using sample folder as base
         import os
-        if hasattr(self, 'folder') and self.folder and not os.path.isabs(filename):
+
+        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
@@ -324,10 +337,12 @@ def _handle_sample_plot_output(self, plot_obj, filename=None, plot_type="bokeh")
                 plot_obj.save(filename, embed=True)  # type: ignore[attr-defined]
             elif plot_type == "holoviews":
                 import panel
+
                 panel.panel(plot_obj).save(filename, embed=True)  # type: ignore[attr-defined]
             elif plot_type == "bokeh":
                 from bokeh.plotting import output_file
                 from bokeh.io import save
+
                 output_file(filename)
                 save(plot_obj)
             self.logger.success(f"Plot saved to: {abs_filename}")
@@ -337,16 +352,18 @@ def _handle_sample_plot_output(self, plot_obj, filename=None, plot_type="bokeh")
                 self.logger.success(f"Plot saved to: {abs_filename}")
             else:
                 # Fall back to HTML if PNG export fails completely
-                html_filename = filename.replace('.png', '.html')
+                html_filename = filename.replace(".png", ".html")
                 abs_html_filename = os.path.abspath(html_filename)
                 if plot_type == "panel":
                     plot_obj.save(html_filename, embed=True)  # type: ignore[attr-defined]
                 elif plot_type == "holoviews":
                     import panel
+
                     panel.panel(plot_obj).save(html_filename, embed=True)  # type: ignore[attr-defined]
                 elif plot_type == "bokeh":
                     from bokeh.plotting import output_file
                     from bokeh.io import save
+
                     output_file(html_filename)
                     save(plot_obj)
                 self.logger.warning(f"PNG export not available, saved as HTML instead: {abs_html_filename}")
@@ -356,16 +373,18 @@ def _handle_sample_plot_output(self, plot_obj, filename=None, plot_type="bokeh")
                 self.logger.success(f"Plot saved to: {abs_filename}")
             else:
                 # Fall back to HTML if SVG export fails completely
-                html_filename = filename.replace('.svg', '.html')
+                html_filename = filename.replace(".svg", ".html")
                 abs_html_filename = os.path.abspath(html_filename)
                 if plot_type == "panel":
                     plot_obj.save(html_filename, embed=True)  # type: ignore[attr-defined]
                 elif plot_type == "holoviews":
                     import panel
+
                     panel.panel(plot_obj).save(html_filename, embed=True)  # type: ignore[attr-defined]
                 elif plot_type == "bokeh":
                     from bokeh.plotting import output_file
                     from bokeh.io import save
+
                     output_file(html_filename)
                     save(plot_obj)
                 self.logger.warning(f"SVG export not available, saved as HTML instead: {abs_html_filename}")
@@ -374,23 +393,27 @@ def _handle_sample_plot_output(self, plot_obj, filename=None, plot_type="bokeh")
             try:
                 if plot_type == "bokeh":
                     from bokeh.io.export import export_pdf
+
                     export_pdf(plot_obj, filename=filename)
                 elif plot_type in ["panel", "holoviews"]:
                     import holoviews as hv
+
                     hv.save(plot_obj, filename, fmt="pdf")
                 self.logger.success(f"Plot saved to: {abs_filename}")
             except ImportError:
                 # Fall back to HTML if PDF export not available
-                html_filename = filename.replace('.pdf', '.html')
+                html_filename = filename.replace(".pdf", ".html")
                 abs_html_filename = os.path.abspath(html_filename)
                 if plot_type == "panel":
                     plot_obj.save(html_filename, embed=True)  # type: ignore[attr-defined]
                 elif plot_type == "holoviews":
                     import panel
+
                     panel.panel(plot_obj).save(html_filename, embed=True)  # type: ignore[attr-defined]
                 elif plot_type == "bokeh":
                     from bokeh.plotting import output_file
                     from bokeh.io import save
+
                     output_file(html_filename)
                     save(plot_obj)
                 self.logger.warning(f"PDF export not available, saved as HTML instead: {abs_html_filename}")
@@ -400,10 +423,12 @@ def _handle_sample_plot_output(self, plot_obj, filename=None, plot_type="bokeh")
                 plot_obj.save(filename, embed=True)  # type: ignore[attr-defined]
             elif plot_type == "holoviews":
                 import panel
+
                 panel.panel(plot_obj).save(filename, embed=True)  # type: ignore[attr-defined]
             elif plot_type == "bokeh":
                 from bokeh.plotting import output_file
                 from bokeh.io import save
+
                 output_file(filename)
                 save(plot_obj)
             self.logger.success(f"Plot saved to: {abs_filename}")
@@ -413,9 +438,11 @@ def _handle_sample_plot_output(self, plot_obj, filename=None, plot_type="bokeh")
             plot_obj.show()  # type: ignore[attr-defined]
         elif plot_type == "holoviews":
             import panel
+
             return panel.panel(plot_obj)
         elif plot_type == "bokeh":
             from bokeh.plotting import show
+
             show(plot_obj)
 
 
@@ -554,12 +581,25 @@ def plot_chrom(
     self._handle_sample_plot_output(layout, filename, "panel")
 
 
-def _create_raster_plot(sample, mz_range=None, rt_range=None, raster_cmap='greys', 
-                       raster_log=True, raster_min=1, raster_dynamic=True, raster_threshold=0.8, raster_max_px=8,
-                       width=750, height=600, filename=None):
+def _create_raster_plot(
+    sample,
+    mz_range=None,
+    rt_range=None,
+    raster_cmap="greys",
+    raster_log=True,
+    raster_min=1,
+    raster_dynamic=True,
+    raster_threshold=0.8,
+    raster_max_px=8,
+    width=750,
+    height=600,
+    filename=None,
+):
     """Create the raster plot layer from MS1 data."""
     # Process colormap using the cmap package with proper error handling
-    raster_cmap_processed = _process_cmap(raster_cmap if raster_cmap is not None else 'greys', fallback="greys", logger=sample.logger)
+    raster_cmap_processed = _process_cmap(
+        raster_cmap if raster_cmap is not None else "greys", fallback="greys", logger=sample.logger
+    )
 
     # get columns rt, mz, inty from sample.ms1_df, It's polars DataFrame
     spectradf = sample.ms1_df.to_pandas()
@@ -620,7 +660,7 @@ def _create_raster_plot(sample, mz_range=None, rt_range=None, raster_cmap='greys
         ylabel="m/z",
         colorbar=True,
         colorbar_position="right",
-        axiswise=True
+        axiswise=True,
     )
     raster = hd.dynspread(
         raster,
@@ -629,17 +669,16 @@ def _create_raster_plot(sample, mz_range=None, rt_range=None, raster_cmap='greys
         shape="square",
         max_px=raster_max_px,
     )
-    
+
     return raster
 
 
-def _load_and_merge_oracle_data(sample, oracle_folder, link_by_feature_uid, 
-                               min_id_level, max_id_level, min_ms_level):
+def _load_and_merge_oracle_data(sample, oracle_folder, link_by_feature_uid, min_id_level, max_id_level, min_ms_level):
     """Load oracle data and merge with features."""
     if sample.features_df is None:
         sample.logger.error("Cannot plot 2D oracle: features_df is not available")
         return None
-        
+
     feats = sample.features_df.clone()
     sample.logger.debug(f"Features data shape: {len(feats)} rows")
 
@@ -651,7 +690,7 @@ def _load_and_merge_oracle_data(sample, oracle_folder, link_by_feature_uid,
     if oracle_folder is None:
         sample.logger.info("No oracle folder provided, plotting features only")
         return None
-    
+
     # try to read the annotationfile as a csv file and add it to feats
     oracle_file_path = os.path.join(oracle_folder, "diag", "summary_by_feature.csv")
     sample.logger.debug(f"Loading oracle data from: {oracle_file_path}")
@@ -664,16 +703,25 @@ def _load_and_merge_oracle_data(sample, oracle_folder, link_by_feature_uid,
 
     if link_by_feature_uid:
         cols_to_keep = [
-            "title", "scan_idx", "mslevel", "hits", "id_level", "id_label",
-            "id_ion", "id_class", "id_evidence", "score", "score2",
+            "title",
+            "scan_idx",
+            "mslevel",
+            "hits",
+            "id_level",
+            "id_label",
+            "id_ion",
+            "id_class",
+            "id_evidence",
+            "score",
+            "score2",
         ]
         oracle_data = oracle_data[cols_to_keep]
-        
+
         # extract feature_uid from title. It begins with "uid:XYZ,"
         sample.logger.debug("Extracting feature UIDs from oracle titles using pattern 'uid:(\\d+)'")
         oracle_data["feature_uid"] = oracle_data["title"].str.extract(r"uid:(\d+)")
         oracle_data["feature_uid"] = oracle_data["feature_uid"].astype(int)
-        
+
         # sort by id_level, remove duplicate feature_uid, keep the first one
         sample.logger.debug("Sorting by ID level and removing duplicates")
         oracle_data = oracle_data.sort_values(by=["id_level"], ascending=False)
@@ -681,12 +729,23 @@ def _load_and_merge_oracle_data(sample, oracle_folder, link_by_feature_uid,
         sample.logger.debug(f"After deduplication: {len(oracle_data)} unique oracle annotations")
     else:
         cols_to_keep = [
-            "precursor", "rt", "title", "scan_idx", "mslevel", "hits", "id_level",
-            "id_label", "id_ion", "id_class", "id_evidence", "score", "score2",
+            "precursor",
+            "rt",
+            "title",
+            "scan_idx",
+            "mslevel",
+            "hits",
+            "id_level",
+            "id_label",
+            "id_ion",
+            "id_class",
+            "id_evidence",
+            "score",
+            "score2",
         ]
         oracle_data = oracle_data[cols_to_keep]
         oracle_data["feature_uid"] = None
-        
+
         # iterate over the rows and find the feature_uid in feats by looking at the closest rt and mz
         for i, row in oracle_data.iterrows():
             candidates = feats[
@@ -716,7 +775,7 @@ def _load_and_merge_oracle_data(sample, oracle_folder, link_by_feature_uid,
     if min_ms_level is not None:
         feats = feats[(feats["mslevel"] >= min_ms_level)]
         sample.logger.debug(f"After min_ms_level filter ({min_ms_level}): {len(feats)} features")
-    
+
     sample.logger.info(f"Feature filtering complete: {initial_count} → {len(feats)} features remaining")
     return feats
 
@@ -724,12 +783,12 @@ def _load_and_merge_oracle_data(sample, oracle_folder, link_by_feature_uid,
 def _setup_color_mapping(sample, feats, colorby, cmap, legend_groups=None):
     """Set up categorical color mapping for features."""
     import matplotlib.colors as mcolors
-    
+
     feats["color"] = "black"  # Default fallback color
     cvalues = None
     color_column = "color"  # Default to fixed color
     colors = []
-    
+
     # Determine which column to use for categorical coloring
     if colorby in ["class", "hg", "id_class", "id_hg"]:
         categorical_column = "id_class"
@@ -739,33 +798,33 @@ def _setup_color_mapping(sample, feats, colorby, cmap, legend_groups=None):
         categorical_column = "id_ion"
         feats[categorical_column] = feats[categorical_column].fillna("mix")
     elif colorby in ["evidence", "id_evidence"]:
-        categorical_column = "id_evidence" 
+        categorical_column = "id_evidence"
         feats[categorical_column] = feats[categorical_column].fillna("mix")
     elif colorby in ["level", "id_level"]:
         categorical_column = "id_level"
         feats[categorical_column] = feats[categorical_column].fillna("mix")
     else:
         categorical_column = None
-    
+
     if categorical_column is not None:
         # Use provided legend_groups or derive from data
         if legend_groups is not None:
             # Use all specified groups to ensure consistent legend/coloring
             cvalues = legend_groups[:]  # Copy the list
             # Ensure 'mix' is always present as the last group if not already included
-            if 'mix' not in cvalues:
-                cvalues.append('mix')
+            if "mix" not in cvalues:
+                cvalues.append("mix")
             sample.logger.info(f"Using provided legend_groups for legend: {cvalues}")
-            
+
             # Check which provided groups actually have data
             present_groups = feats[categorical_column].unique()
             missing_groups = [grp for grp in cvalues if grp not in present_groups]
             if missing_groups:
                 sample.logger.warning(f"Provided legend_groups not found in data: {missing_groups}")
             sample.logger.info(f"Groups present in data: {sorted(present_groups)}")
-            
+
             # Assign any points not in legend_groups to 'mix'
-            feats.loc[~feats[categorical_column].isin(cvalues[:-1]), categorical_column] = 'mix'
+            feats.loc[~feats[categorical_column].isin(cvalues[:-1]), categorical_column] = "mix"
         else:
             # Original behavior: use only groups present in data
             cvalues = feats[categorical_column].unique()
@@ -784,7 +843,7 @@ def _setup_color_mapping(sample, feats, colorby, cmap, legend_groups=None):
     # Process colormap for categorical data
     if cvalues is not None:
         num_colors = len(cvalues)
-        
+
         # Use colormap for categorical data - use _process_cmap for proper handling
         try:
             colormap = Colormap(cmap)
@@ -794,7 +853,7 @@ def _setup_color_mapping(sample, feats, colorby, cmap, legend_groups=None):
                 t = i / (num_colors - 1) if num_colors > 1 else 0.5
                 color = colormap(t)
                 # Convert to hex - handle different color formats
-                if hasattr(color, '__len__') and len(color) >= 3:
+                if hasattr(color, "__len__") and len(color) >= 3:
                     # It's an array-like color (RGB or RGBA)
                     colors.append(mcolors.to_hex(color[:3]))
                 else:
@@ -826,22 +885,25 @@ def _setup_color_mapping(sample, feats, colorby, cmap, legend_groups=None):
     return cvalues, color_column, colors
 
 
-def _create_feature_overlay(sample, raster, feats, cvalues, color_column, colors,
-                           markersize, title, legend):
+def _create_feature_overlay(sample, raster, feats, cvalues, color_column, colors, markersize, title, legend):
     """Create feature overlay with identified and unidentified features."""
     # replace NaN with 0 in id_level
     feats["id_level"] = feats["id_level"].fillna(0)
-    
+
     # Create unified visualization with all features in single layer
     # This avoids the multiple layer legend conflicts that cause dark colors and shared toggling
     sample.logger.debug("Creating unified feature visualization with categorical coloring")
-    
+
     # Prepare categorical coloring for identified features only (id_level >= 1)
-    identified_feats = feats[feats["id_level"] >= 1].copy() if len(feats[feats["id_level"] >= 1]) > 0 else pd.DataFrame()
-    unidentified_feats = feats[feats["id_level"] < 1].copy() if len(feats[feats["id_level"] < 1]) > 0 else pd.DataFrame()
-    
+    identified_feats = (
+        feats[feats["id_level"] >= 1].copy() if len(feats[feats["id_level"] >= 1]) > 0 else pd.DataFrame()
+    )
+    unidentified_feats = (
+        feats[feats["id_level"] < 1].copy() if len(feats[feats["id_level"] < 1]) > 0 else pd.DataFrame()
+    )
+
     overlay = raster
-    
+
     # Single layer for identified features with categorical coloring
     if len(identified_feats) > 0 and cvalues is not None:
         # Create proper confidence-based marker styling
@@ -851,7 +913,7 @@ def _create_feature_overlay(sample, raster, feats, cvalues, color_column, colors
         identified_feats["fill_alpha"] = identified_feats["id_level"].apply(
             lambda x: 1.0 if x >= 2 else 0.3  # Full opacity for high conf, transparent for medium
         )
-        
+
         oracle_hover_identified = HoverTool(
             tooltips=[
                 ("rt", "@rt"),
@@ -866,10 +928,10 @@ def _create_feature_overlay(sample, raster, feats, cvalues, color_column, colors
                 ("score2", "@score2"),
             ],
         )
-        
+
         # Create completely separate overlay elements for each category
         overlays_to_combine = [raster]  # Start with raster base
-        
+
         for i, category in enumerate(cvalues):
             category_data = identified_feats[identified_feats[color_column] == category].copy()
             if len(category_data) > 0:
@@ -878,10 +940,18 @@ def _create_feature_overlay(sample, raster, feats, cvalues, color_column, colors
                     category_data,
                     kdims=["rt", "mz"],
                     vdims=[
-                        "inty", "feature_uid", "id_level", "id_class", "id_label",
-                        "id_ion", "id_evidence", "score", "score2", "fill_alpha"
+                        "inty",
+                        "feature_uid",
+                        "id_level",
+                        "id_class",
+                        "id_label",
+                        "id_ion",
+                        "id_evidence",
+                        "score",
+                        "score2",
+                        "fill_alpha",
                     ],
-                    label=str(category)  # This becomes the legend label
+                    label=str(category),  # This becomes the legend label
                 ).options(
                     color=colors[i],  # Use pre-computed hex color for this category
                     marker="circle",
@@ -893,17 +963,38 @@ def _create_feature_overlay(sample, raster, feats, cvalues, color_column, colors
                 overlays_to_combine.append(category_points)
             else:
                 # Create empty Points element for categories with no data to ensure they appear in legend
-                empty_data = pd.DataFrame(columns=['rt', 'mz', 'inty', 'feature_uid', 'id_level', 
-                                                  'id_class', 'id_label', 'id_ion', 'id_evidence', 
-                                                  'score', 'score2', 'fill_alpha'])
+                empty_data = pd.DataFrame(
+                    columns=[
+                        "rt",
+                        "mz",
+                        "inty",
+                        "feature_uid",
+                        "id_level",
+                        "id_class",
+                        "id_label",
+                        "id_ion",
+                        "id_evidence",
+                        "score",
+                        "score2",
+                        "fill_alpha",
+                    ]
+                )
                 category_points = hv.Points(
                     empty_data,
                     kdims=["rt", "mz"],
                     vdims=[
-                        "inty", "feature_uid", "id_level", "id_class", "id_label",
-                        "id_ion", "id_evidence", "score", "score2", "fill_alpha"
+                        "inty",
+                        "feature_uid",
+                        "id_level",
+                        "id_class",
+                        "id_label",
+                        "id_ion",
+                        "id_evidence",
+                        "score",
+                        "score2",
+                        "fill_alpha",
                     ],
-                    label=str(category)  # This becomes the legend label
+                    label=str(category),  # This becomes the legend label
                 ).options(
                     color=colors[i],  # Use pre-computed hex color for this category
                     marker="circle",
@@ -913,16 +1004,16 @@ def _create_feature_overlay(sample, raster, feats, cvalues, color_column, colors
                     show_legend=True,
                 )
                 overlays_to_combine.append(category_points)
-        
+
         # Combine all overlays
         overlay = overlays_to_combine[0]  # Start with raster
         for layer in overlays_to_combine[1:]:
             overlay = overlay * layer
-            
+
     else:
         # No categorical data - just set overlay to raster
         overlay = raster
-        
+
     # Separate layer for unidentified features (always black crosses)
     if len(unidentified_feats) > 0:
         oracle_hover_no_id = HoverTool(
@@ -933,20 +1024,20 @@ def _create_feature_overlay(sample, raster, feats, cvalues, color_column, colors
                 ("id_level", "@id_level"),
             ],
         )
-        
+
         feature_points_no_id = hv.Points(
             unidentified_feats,
             kdims=["rt", "mz"],
             vdims=["inty", "feature_uid", "id_level"],
         ).options(
             color="black",
-            marker="x", 
+            marker="x",
             size=markersize,
             alpha=1.0,
             tools=[oracle_hover_no_id],
             show_legend=False,
         )
-        
+
         overlay = overlay * feature_points_no_id
 
     if title is not None:
@@ -955,34 +1046,33 @@ def _create_feature_overlay(sample, raster, feats, cvalues, color_column, colors
 
     # Configure legend if requested and categorical coloring is available
     if legend is not None and cvalues is not None and len(cvalues) > 1:
-        sample.logger.debug(f"Configuring integrated legend at '{legend}' position with {len(cvalues)} categories: {cvalues}")
-        
+        sample.logger.debug(
+            f"Configuring integrated legend at '{legend}' position with {len(cvalues)} categories: {cvalues}"
+        )
+
         # Map legend position parameter to HoloViews legend position
         legend_position_map = {
             "top_right": "top_right",
-            "top_left": "top_left", 
+            "top_left": "top_left",
             "bottom_right": "bottom_right",
             "bottom_left": "bottom_left",
             "right": "right",
             "left": "left",
             "top": "top",
-            "bottom": "bottom"
+            "bottom": "bottom",
         }
-        
+
         hv_legend_pos = legend_position_map.get(legend, "bottom_right")
-        
+
         # Apply legend configuration to the overlay
-        overlay = overlay.opts(
-            legend_position=hv_legend_pos,
-            legend_opts={'title': '', 'padding': 2, 'spacing': 2}
-        )
-        
+        overlay = overlay.opts(legend_position=hv_legend_pos, legend_opts={"title": "", "padding": 2, "spacing": 2})
+
         sample.logger.debug(f"Applied integrated legend at position '{hv_legend_pos}'")
     elif legend is None:
         # Explicitly hide legend when legend=None
         overlay = overlay.opts(show_legend=False)
         sample.logger.debug("Legend hidden (legend=None)")
-        
+
     return overlay
 
 
@@ -1007,7 +1097,7 @@ def _handle_output(sample, overlay, filename):
                 sample.logger.warning(f"PNG export failed: {os.path.abspath(filename)}")
         else:
             # Default to PNG for any other format
-            png_filename = filename + ".png" if not filename.endswith(('.png', '.svg', '.html')) else filename
+            png_filename = filename + ".png" if not filename.endswith((".png", ".svg", ".html")) else filename
             success = _export_with_webdriver_manager(overlay, png_filename, "png", sample.logger)
             if success:
                 sample.logger.success(f"PNG exported: {os.path.abspath(png_filename)}")
@@ -1029,7 +1119,7 @@ def plot_2d(
     show_ms2=False,
     show_in_browser=False,
     title=None,
-    cmap='iridescent',
+    cmap="iridescent",
     marker="circle",
     markersize=5,
     size="static",
@@ -1043,7 +1133,7 @@ def plot_2d(
     mz_range=None,
     rt_range=None,
     legend=None,
-    colorby=None
+    colorby=None,
 ):
     """
     Plot a two-dimensional visualization of MS1 survey scan data with optional overlays
@@ -1089,7 +1179,7 @@ def plot_2d(
             Maximum pixel size for dynamic rasterization when using dynspread.
         raster_threshold (float, default 0.8):
             Threshold used for the dynspread process in dynamic rasterization.
-        legend (str, optional): 
+        legend (str, optional):
             Legend position for categorical feature coloring ("top_right", "bottom_left", etc.) or None.
             Only applies when colorby is not None and contains categorical data.
         colorby (str, optional):
@@ -1212,12 +1302,12 @@ def plot_2d(
 
     color_1 = "forestgreen"
     color_2 = "darkorange"
-    
+
     # Handle colorby parameter for feature coloring
     use_categorical_coloring = False
     feature_colors = {}
     categorical_groups = []
-    
+
     if filename is not None:
         dyn = False
         if not filename.endswith(".html"):
@@ -1290,21 +1380,22 @@ def plot_2d(
         if colorby is not None and colorby in feats.columns:
             # Check if colorby data is categorical (string-like)
             colorby_values = feats[colorby].dropna()
-            is_categorical = (
-                feats[colorby].dtype in ["object", "string", "category"] or
-                (len(colorby_values) > 0 and isinstance(colorby_values.iloc[0], str))
+            is_categorical = feats[colorby].dtype in ["object", "string", "category"] or (
+                len(colorby_values) > 0 and isinstance(colorby_values.iloc[0], str)
             )
-            
+
             if is_categorical:
                 use_categorical_coloring = True
                 # Get unique categories, sorted
                 categorical_groups = sorted(feats[colorby].dropna().unique())
-                
+
                 # Set up colors for categorical data using matplotlib colormap
                 from matplotlib.colors import to_hex
+
                 try:
                     from matplotlib.cm import get_cmap
-                    colormap_func = get_cmap(cmap if cmap != 'iridescent' else 'tab20')
+
+                    colormap_func = get_cmap(cmap if cmap != "iridescent" else "tab20")
                     feature_colors = {}
                     for i, group in enumerate(categorical_groups):
                         if len(categorical_groups) <= 20:
@@ -1324,13 +1415,13 @@ def plot_2d(
                 group_features = feats[feats[colorby] == group]
                 if len(group_features) == 0:
                     continue
-                    
+
                 # Split by MS2 status
                 group_with_ms2 = group_features[group_features["ms2_scans"].notnull()]
                 group_without_ms2 = group_features[group_features["ms2_scans"].isnull()]
-                
+
                 group_color = feature_colors.get(group, color_1)
-                
+
                 if len(group_with_ms2) > 0:
                     feature_hover = HoverTool(
                         tooltips=[
@@ -1370,7 +1461,7 @@ def plot_2d(
                         feature_points_1 = group_points_ms2
                     else:
                         feature_points_1 = feature_points_1 * group_points_ms2
-                        
+
                 if len(group_without_ms2) > 0:
                     feature_hover = HoverTool(
                         tooltips=[
@@ -1447,7 +1538,7 @@ def plot_2d(
                     tools=[feature_hover_1],
                     hooks=hooks,
                 )
-            
+
             # find features without MS2 data
             features_df = feats[feats["ms2_scans"].isnull()]
             feature_hover_2 = HoverTool(
@@ -1600,22 +1691,19 @@ def plot_2d(
         # Map legend position parameter to HoloViews legend position
         legend_position_map = {
             "top_right": "top_right",
-            "top_left": "top_left", 
+            "top_left": "top_left",
             "bottom_right": "bottom_right",
             "bottom_left": "bottom_left",
             "right": "right",
             "left": "left",
             "top": "top",
-            "bottom": "bottom"
+            "bottom": "bottom",
         }
-        
+
         hv_legend_pos = legend_position_map.get(legend, "bottom_right")
-        
+
         # Apply legend configuration to the overlay
-        overlay = overlay.opts(
-            legend_position=hv_legend_pos,
-            legend_opts={'title': '', 'padding': 2, 'spacing': 2}
-        )
+        overlay = overlay.opts(legend_position=hv_legend_pos, legend_opts={"title": "", "padding": 2, "spacing": 2})
     elif legend is None and use_categorical_coloring:
         # Explicitly hide legend when legend=None but categorical coloring is used
         overlay = overlay.opts(show_legend=False)
@@ -1766,8 +1854,8 @@ def plot_2d_oracle(
     colorby="hg",
     legend_groups=None,
     markersize=5,
-    cmap='Turbo',
-    raster_cmap='grey',
+    cmap="Turbo",
+    raster_cmap="grey",
     raster_log=True,
     raster_min=1,
     raster_dynamic=True,
@@ -1784,12 +1872,12 @@ def plot_2d_oracle(
     """
     Plot a 2D visualization combining MS1 raster data and oracle-annotated features.
 
-    Creates an interactive plot overlaying MS1 survey scan data with feature annotations 
+    Creates an interactive plot overlaying MS1 survey scan data with feature annotations
     from oracle files. Features are colored categorically based on identification class,
     ion type, or evidence level.
 
     Parameters:
-        oracle_folder (str, optional): Path to oracle folder containing 
+        oracle_folder (str, optional): Path to oracle folder containing
             "diag/summary_by_feature.csv". Required for oracle annotations.
         link_by_feature_uid (bool): Whether to link features by UID (True) or by m/z/RT proximity.
         min_id_level (int): Minimum identification confidence level to include.
@@ -1822,14 +1910,16 @@ def plot_2d_oracle(
     """
 
     self.logger.info(f"Starting plot_2d_oracle with oracle_folder: {oracle_folder}")
-    self.logger.debug(f"Parameters - link_by_feature_uid: {link_by_feature_uid}, min_id_level: {min_id_level}, max_id_level: {max_id_level}")
+    self.logger.debug(
+        f"Parameters - link_by_feature_uid: {link_by_feature_uid}, min_id_level: {min_id_level}, max_id_level: {max_id_level}"
+    )
     self.logger.debug(f"Plot parameters - colorby: {colorby}, markersize: {markersize}, filename: {filename}")
 
     # Early validation
     if self.features_df is None:
         self.logger.error("Cannot plot 2D oracle: features_df is not available")
         return
-        
+
     if oracle_folder is None:
         self.logger.info("No oracle folder provided, plotting features only")
         return
@@ -1847,7 +1937,7 @@ def plot_2d_oracle(
         raster_max_px=raster_max_px,
         width=width,
         height=height,
-        filename=filename
+        filename=filename,
     )
 
     # Load and process oracle data
@@ -1857,9 +1947,9 @@ def plot_2d_oracle(
         link_by_feature_uid=link_by_feature_uid,
         min_id_level=min_id_level,
         max_id_level=max_id_level,
-        min_ms_level=min_ms_level
+        min_ms_level=min_ms_level,
     )
-    
+
     if feats is None:
         return
 
@@ -1876,7 +1966,7 @@ def plot_2d_oracle(
         colors=colors,
         markersize=markersize,
         title=title,
-        legend=legend
+        legend=legend,
     )
 
     # Handle output: export or display
@@ -2369,7 +2459,7 @@ def plot_features_stats(
 
     # Apply log10 transformation to intensity (handling non-positive values)
     feats["inty"] = np.where(feats["inty"] <= 0, np.nan, np.log10(feats["inty"]))
-    
+
     # Apply log10 transformation to quality (handling non-positive values)
     feats["quality"] = np.where(feats["quality"] <= 0, np.nan, np.log10(feats["quality"]))
 
@@ -2380,7 +2470,7 @@ def plot_features_stats(
     # Define the specific metrics to plot
     cols_to_plot = [
         "mz",
-        "rt", 
+        "rt",
         "inty",  # Already log10 transformed above
         "rt_delta",
         "quality",  # Already log10 transformed above
@@ -2406,7 +2496,7 @@ def plot_features_stats(
             alpha=0.6,
         )
         dist_without = hv.Distribution(data_without, label="Without MS2").opts(
-            color="red", 
+            color="red",
             alpha=0.6,
         )
 
@@ -2416,7 +2506,7 @@ def plot_features_stats(
             title = "log10(inty)"
         elif col == "quality":
             title = "log10(quality)"
-            
+
         overlay = (dist_with * dist_without).opts(
             title=title,
             show_legend=True,