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

masster/sample/plot.py

@@ -56,6 +56,7 @@ from bokeh.models import HoverTool
 from holoviews import dim
 from holoviews.plotting.util import process_cmap
 from matplotlib.colors import rgb2hex
+from masster.chromatogram import Chromatogram
 
 # Parameters removed - using hardcoded defaults
 
@@ -66,49 +67,51 @@ hv.extension("bokeh")
 def _is_notebook_environment():
     """
     Detect if code is running in a notebook environment (Jupyter, JupyterLab, or Marimo).
-    
+
     Returns:
         bool: True if running in a notebook, False otherwise
     """
     try:
         # Check for Jupyter/JupyterLab
         from IPython import get_ipython
+
         if get_ipython() is not None:
             # Check if we're in a notebook context
             shell = get_ipython().__class__.__name__
-            if shell in ['ZMQInteractiveShell', 'Shell']:  # Jupyter notebook/lab
+            if shell in ["ZMQInteractiveShell", "Shell"]:  # Jupyter notebook/lab
                 return True
-        
+
         # Check for Marimo
         import sys
-        if 'marimo' in sys.modules:
+
+        if "marimo" in sys.modules:
             return True
-        
+
         # Additional check for notebook environments
-        if hasattr(__builtins__, '__IPYTHON__') or hasattr(__builtins__, '_ih'):
+        if hasattr(__builtins__, "__IPYTHON__") or hasattr(__builtins__, "_ih"):
             return True
-            
+
     except ImportError:
         pass
-    
+
     return False
 
 
 def _display_plot(plot_object, layout=None):
     """
     Display a plot object in the appropriate way based on the environment.
-    
+
     Args:
         plot_object: The plot object to display (holoviews overlay, etc.)
         layout: Optional panel layout object
-        
+
     Returns:
         The layout object if in notebook environment, None otherwise
     """
     if _is_notebook_environment():
         # Display inline in notebook
         try:
-            # For Jupyter notebooks, just return the plot object - 
+            # For Jupyter notebooks, just return the plot object -
             # holoviews will handle the display automatically
             return plot_object
         except Exception:
@@ -395,17 +398,18 @@ def plot_2d(
     # Configure marker and size behavior based on size parameter
     use_dynamic_sizing = size.lower() in ["dyn", "dynamic"]
     use_slider_sizing = size.lower() == "slider"
-    
+
     def dynamic_sizing_hook(plot, element):
         """Hook to convert size-based markers to radius-based for dynamic behavior"""
         try:
-            if use_dynamic_sizing and hasattr(plot, 'state') and hasattr(plot.state, 'renderers'):
+            if use_dynamic_sizing and hasattr(plot, "state") and hasattr(plot.state, "renderers"):
                 from bokeh.models import Circle
+
                 for renderer in plot.state.renderers:
-                    if hasattr(renderer, 'glyph'):
+                    if hasattr(renderer, "glyph"):
                         glyph = renderer.glyph
                         # Check if it's a circle/scatter glyph that we can convert
-                        if hasattr(glyph, 'size') and marker_type == "circle":
+                        if hasattr(glyph, "size") and marker_type == "circle":
                             # Create a new Circle glyph with radius instead of size
                             new_glyph = Circle(
                                 x=glyph.x,
@@ -420,7 +424,7 @@ def plot_2d(
         except Exception:
             # Silently fail and use regular sizing if hook doesn't work
             pass
-    
+
     if use_dynamic_sizing:
         # Dynamic sizing: use coordinate-based sizing that scales with zoom
         marker_type = "circle"
@@ -446,7 +450,7 @@ def plot_2d(
         size_2 = markersize
         base_radius = None  # Not used in static mode
         hooks = []
-    
+
     color_1 = "forestgreen"
     color_2 = "darkorange"
     if filename is not None:
@@ -519,14 +523,16 @@ def plot_2d(
         # find features with ms2_scans not None  and iso==0
         features_df = feats[feats["ms2_scans"].notnull()]
         # Create feature points with proper sizing method
-        feature_hover_1 = HoverTool(tooltips=[
-            ("rt", "@rt"),
-            ("m/z", "@mz{0.0000}"),
-            ("feature_uid", "@feature_uid"),
-            ("inty", "@inty"),
-            ("quality", "@quality"),
-            ("rt_delta", "@rt_delta"),
-        ])
+        feature_hover_1 = HoverTool(
+            tooltips=[
+                ("rt", "@rt"),
+                ("m/z", "@mz{0.0000}"),
+                ("feature_uid", "@feature_uid"),
+                ("inty", "@inty"),
+                ("quality", "@quality"),
+                ("rt_delta", "@rt_delta"),
+            ],
+        )
         feature_points_1 = hv.Points(
             features_df,
             kdims=["rt", "mz"],
@@ -549,14 +555,16 @@ def plot_2d(
         )
         # find features without MS2 data
         features_df = feats[feats["ms2_scans"].isnull()]
-        feature_hover_2 = HoverTool(tooltips=[
-            ("rt", "@rt"),
-            ("m/z", "@mz{0.0000}"),
-            ("feature_uid", "@feature_uid"),
-            ("inty", "@inty"),
-            ("quality", "@quality"),
-            ("rt_delta", "@rt_delta"),
-        ])
+        feature_hover_2 = HoverTool(
+            tooltips=[
+                ("rt", "@rt"),
+                ("m/z", "@mz{0.0000}"),
+                ("feature_uid", "@feature_uid"),
+                ("inty", "@inty"),
+                ("quality", "@quality"),
+                ("rt_delta", "@rt_delta"),
+            ],
+        )
         feature_points_2 = hv.Points(
             features_df,
             kdims=["rt", "mz"],
@@ -583,16 +591,18 @@ def plot_2d(
             # Convert to pandas for plotting compatibility
             if hasattr(features_df, "to_pandas"):
                 features_df = features_df.to_pandas()
-            feature_hover_iso = HoverTool(tooltips=[
-                ("rt", "@rt"),
-                ("m/z", "@mz{0.0000}"),
-                ("feature_uid", "@feature_uid"),
-                ("inty", "@inty"),
-                ("quality", "@quality"),
-                ("rt_delta", "@rt_delta"),
-                ("iso", "@iso"),
-                ("iso_of", "@iso_of"),
-            ])
+            feature_hover_iso = HoverTool(
+                tooltips=[
+                    ("rt", "@rt"),
+                    ("m/z", "@mz{0.0000}"),
+                    ("feature_uid", "@feature_uid"),
+                    ("inty", "@inty"),
+                    ("quality", "@quality"),
+                    ("rt_delta", "@rt_delta"),
+                    ("iso", "@iso"),
+                    ("iso_of", "@iso_of"),
+                ],
+            )
             feature_points_iso = hv.Points(
                 features_df,
                 kdims=["rt", "mz"],
@@ -623,13 +633,15 @@ def plot_2d(
         if len(ms2_orphan) > 0:
             # pandalize
             ms2 = ms2_orphan.to_pandas()
-            ms2_hover_3 = HoverTool(tooltips=[
-                ("rt", "@rt"),
-                ("prec_mz", "@prec_mz{0.0000}"),
-                ("index", "@index"),
-                ("inty_tot", "@inty_tot"),
-                ("bl", "@bl"),
-            ])
+            ms2_hover_3 = HoverTool(
+                tooltips=[
+                    ("rt", "@rt"),
+                    ("prec_mz", "@prec_mz{0.0000}"),
+                    ("index", "@index"),
+                    ("inty_tot", "@inty_tot"),
+                    ("bl", "@bl"),
+                ],
+            )
             feature_points_3 = hv.Points(
                 ms2,
                 kdims=["rt", "prec_mz"],
@@ -648,13 +660,15 @@ def plot_2d(
         if len(ms2_linked) > 0:
             # pandalize
             ms2 = ms2_linked.to_pandas()
-            ms2_hover_4 = HoverTool(tooltips=[
-                ("rt", "@rt"),
-                ("prec_mz", "@prec_mz{0.0000}"),
-                ("index", "@index"),
-                ("inty_tot", "@inty_tot"),
-                ("bl", "@bl"),
-            ])
+            ms2_hover_4 = HoverTool(
+                tooltips=[
+                    ("rt", "@rt"),
+                    ("prec_mz", "@prec_mz{0.0000}"),
+                    ("index", "@index"),
+                    ("inty_tot", "@inty_tot"),
+                    ("bl", "@bl"),
+                ],
+            )
             feature_points_4 = hv.Points(
                 ms2,
                 kdims=["rt", "prec_mz"],
@@ -688,17 +702,17 @@ def plot_2d(
         # For slider functionality, we need to work with the feature points directly
         # and not nest DynamicMaps. We'll create the slider using param and panel.
         import param
-        import panel as pn
-        
+        import panel as on
+
         class MarkerSizeController(param.Parameterized):
             size_slider = param.Number(default=markersize, bounds=(1, 20), step=0.5)
-        
+
         controller = MarkerSizeController()
-        
+
         # Create a function that generates just the feature overlays with different sizes
         def create_feature_overlay(size_val):
             feature_overlay = None
-            
+
             if feature_points_4 is not None:
                 updated_points_4 = feature_points_4.opts(size=size_val)
                 feature_overlay = updated_points_4 if feature_overlay is None else feature_overlay * updated_points_4
@@ -713,22 +727,24 @@ def plot_2d(
                 feature_overlay = updated_points_2 if feature_overlay is None else feature_overlay * updated_points_2
             if feature_points_iso is not None:
                 updated_points_iso = feature_points_iso.opts(size=size_val)
-                feature_overlay = updated_points_iso if feature_overlay is None else feature_overlay * updated_points_iso
-                
+                feature_overlay = (
+                    updated_points_iso if feature_overlay is None else feature_overlay * updated_points_iso
+                )
+
             # Combine with the static raster background
             if feature_overlay is not None:
                 combined_overlay = raster * feature_overlay
             else:
                 combined_overlay = raster
-                
+
             if title is not None:
                 combined_overlay = combined_overlay.opts(title=title)
-                
+
             return combined_overlay
-        
+
         # Create a horizontal control widget on top of the plot
         # Create the slider widget with explicit visibility
-        size_slider = pn.widgets.FloatSlider(
+        size_slider = on.widgets.FloatSlider(
             name="Marker Size",
             start=1.0,
             end=20.0,
@@ -737,19 +753,19 @@ def plot_2d(
             width=300,
             height=40,
             margin=(5, 5),
-            show_value=True
+            show_value=True,
         )
-        
+
         # Create the slider widget row with clear styling
-        slider_widget = pn.Row(
-            pn.pane.HTML("<b>Marker Size Control:</b>", width=150, height=40, margin=(5, 10)),
+        slider_widget = on.Row(
+            on.pane.HTML("<b>Marker Size Control:</b>", width=150, height=40, margin=(5, 10)),
             size_slider,
             height=60,
-            margin=10
+            margin=10,
         )
-        
+
         # Create slider widget
-        size_slider = pn.widgets.FloatSlider(
+        size_slider = on.widgets.FloatSlider(
             name="Marker Size",
             start=1.0,
             end=20.0,
@@ -758,18 +774,18 @@ def plot_2d(
             width=300,
             height=40,
             margin=(5, 5),
-            show_value=True
+            show_value=True,
         )
-        
-        slider_widget = pn.Row(
-            pn.pane.HTML("<b>Marker Size:</b>", width=100, height=40, margin=(5, 10)),
+
+        slider_widget = on.Row(
+            on.pane.HTML("<b>Marker Size:</b>", width=100, height=40, margin=(5, 10)),
             size_slider,
             height=60,
-            margin=10
+            margin=10,
         )
-        
+
         # Simple reactive plot - slider mode doesn't use dynamic rasterization
-        @pn.depends(size_slider.param.value)
+        @on.depends(size_slider.param.value)
         def reactive_plot(size_val):
             overlay = create_feature_overlay(float(size_val))
             # Apply static rasterization for slider mode
@@ -779,19 +795,19 @@ def plot_2d(
                     aggregator=ds.count(),
                     width=raster_max_px,
                     height=raster_max_px,
-                    dynamic=False  # Static raster for slider mode
+                    dynamic=False,  # Static raster for slider mode
                 ).opts(
-                    cnorm='eq_hist',
-                    tools=['hover'],
+                    cnorm="eq_hist",
+                    tools=["hover"],
                     width=width,
-                    height=height
+                    height=height,
                 )
             else:
                 return overlay
-        
+
         # Create layout
-        layout = pn.Column(slider_widget, reactive_plot, sizing_mode='stretch_width')
-        
+        layout = on.Column(slider_widget, reactive_plot, sizing_mode="stretch_width")
+
         return layout
     else:
         # Create a panel layout without slider
@@ -1081,18 +1097,20 @@ def plot_2d_oracle(
     feat_df = feats.copy()
     feat_df = feat_df[feat_df["id_level"] == 2]
 
-    oracle_hover_1 = HoverTool(tooltips=[
-        ("rt", "@rt"),
-        ("m/z", "@mz{0.0000}"),
-        ("feature_uid", "@feature_uid"),
-        ("id_level", "@id_level"),
-        ("id_class", "@id_class"),
-        ("id_label", "@id_label"),
-        ("id_ion", "@id_ion"),
-        ("id_evidence", "@id_evidence"),
-        ("score", "@score"),
-        ("score2", "@score2"),
-    ])
+    oracle_hover_1 = HoverTool(
+        tooltips=[
+            ("rt", "@rt"),
+            ("m/z", "@mz{0.0000}"),
+            ("feature_uid", "@feature_uid"),
+            ("id_level", "@id_level"),
+            ("id_class", "@id_class"),
+            ("id_label", "@id_label"),
+            ("id_ion", "@id_ion"),
+            ("id_evidence", "@id_evidence"),
+            ("score", "@score"),
+            ("score2", "@score2"),
+        ],
+    )
     feature_points_1 = hv.Points(
         feat_df,
         kdims=["rt", "mz"],
@@ -1122,15 +1140,17 @@ def plot_2d_oracle(
     feat_df = feats.copy()
     feat_df = feat_df[(feat_df["ms2_scans"].notnull()) & (feat_df["id_level"] == 1)]
     if len(feat_df) > 0:
-        oracle_hover_2 = HoverTool(tooltips=[
-            ("rt", "@rt"),
-            ("m/z", "@mz{0.0000}"),
-            ("feature_uid", "@feature_uid"),
-            ("id_level", "@id_level"),
-            ("id_label", "@id_label"),
-            ("id_ion", "@id_ion"),
-            ("id_class", "@id_class"),
-        ])
+        oracle_hover_2 = HoverTool(
+            tooltips=[
+                ("rt", "@rt"),
+                ("m/z", "@mz{0.0000}"),
+                ("feature_uid", "@feature_uid"),
+                ("id_level", "@id_level"),
+                ("id_label", "@id_label"),
+                ("id_ion", "@id_ion"),
+                ("id_class", "@id_class"),
+            ],
+        )
         feature_points_2 = hv.Points(
             feat_df,
             kdims=["rt", "mz"],
@@ -1157,15 +1177,17 @@ def plot_2d_oracle(
     feat_df = feats.copy()
     feat_df = feat_df[(feat_df["ms2_scans"].isnull()) & (feat_df["id_level"] == 1)]
     if len(feat_df) > 0:
-        oracle_hover_3 = HoverTool(tooltips=[
-            ("rt", "@rt"),
-            ("m/z", "@mz{0.0000}"),
-            ("feature_uid", "@feature_uid"),
-            ("id_level", "@id_level"),
-            ("id_label", "@id_label"),
-            ("id_ion", "@id_ion"),
-            ("id_class", "@id_class"),
-        ])
+        oracle_hover_3 = HoverTool(
+            tooltips=[
+                ("rt", "@rt"),
+                ("m/z", "@mz{0.0000}"),
+                ("feature_uid", "@feature_uid"),
+                ("id_level", "@id_level"),
+                ("id_label", "@id_label"),
+                ("id_ion", "@id_ion"),
+                ("id_class", "@id_class"),
+            ],
+        )
         feature_points_3 = hv.Points(
             feat_df,
             kdims=["rt", "mz"],
@@ -1192,12 +1214,14 @@ def plot_2d_oracle(
     feat_df = feats.copy()
     feat_df = feat_df[(feat_df["ms2_scans"].notnull()) & (feat_df["id_level"] < 1)]
     if len(feat_df) > 0:
-        oracle_hover_4 = HoverTool(tooltips=[
-            ("rt", "@rt"),
-            ("m/z", "@mz{0.0000}"),
-            ("feature_uid", "@feature_uid"),
-            ("inty", "@inty"),
-        ])
+        oracle_hover_4 = HoverTool(
+            tooltips=[
+                ("rt", "@rt"),
+                ("m/z", "@mz{0.0000}"),
+                ("feature_uid", "@feature_uid"),
+                ("inty", "@inty"),
+            ],
+        )
         feature_points_4 = hv.Points(
             feat_df,
             kdims=["rt", "mz"],
@@ -1216,12 +1240,14 @@ def plot_2d_oracle(
     feat_df = feats.copy()
     feat_df = feat_df[(feat_df["ms2_scans"].isnull()) & (feat_df["id_level"] < 1)]
     if len(feat_df) > 0:
-        oracle_hover_5 = HoverTool(tooltips=[
-            ("rt", "@rt"),
-            ("m/z", "@mz{0.0000}"),
-            ("feature_uid", "@feature_uid"),
-            ("inty", "@inty"),
-        ])
+        oracle_hover_5 = HoverTool(
+            tooltips=[
+                ("rt", "@rt"),
+                ("m/z", "@mz{0.0000}"),
+                ("feature_uid", "@feature_uid"),
+                ("inty", "@inty"),
+            ],
+        )
         feature_points_5 = hv.Points(
             feat_df,
             kdims=["rt", "mz"],
@@ -1941,19 +1967,102 @@ def plot_tic(
     title=None,
     filename=None,
 ):
-    # get all ms_level ==1 scans from sefl.scans_df
-    scans = self.scans_df.filter(pl.col("ms_level") == 1)
-    # select rt, scan_uid and inty_tot, convert to pandas
-    data = scans[["rt", "scan_uid", "inty_tot"]].to_pandas()
-    # sort by rt
-    data = data.sort_values("rt")
-
-    # plot using hv.Curve
-    tic = hv.Curve(data, kdims=["rt"], vdims=["inty_tot"])
-    tic.opts(
-        title=title,
-        xlabel="Retention Time (min)",
-        ylabel="TIC",
-        height=250,
-        width=100,
-    )
+    """
+    Plot Total Ion Chromatogram (TIC) by summing MS1 peak intensities at each retention time.
+
+    Uses `self.ms1_df` (Polars DataFrame) and aggregates intensities by `rt` (sum).
+    Creates a `Chromatogram` object and uses its `plot()` method to display the result.
+    """
+    if self.ms1_df is None:
+        self.logger.error("No MS1 data available.")
+        return
+
+    # Import helper locally to avoid circular imports
+    from masster.study.helpers import get_tic
+
+    # Delegate TIC computation to study helper which handles ms1_df and scans_df fallbacks
+    try:
+        chrom = get_tic(self, label=title)
+    except Exception as e:
+        self.logger.exception("Failed to compute TIC via helper: %s", e)
+        return
+
+    if filename is not None:
+        try:
+            chrom.plot(width=1000, height=250)
+        except Exception:
+            import matplotlib.pyplot as plt
+
+            plt.figure(figsize=(10, 3))
+            plt.plot(chrom.rt, chrom.inty, color="black")
+            plt.xlabel("Retention time (s)")
+            plt.ylabel("Intensity")
+            if title:
+                plt.title(title)
+            plt.tight_layout()
+            plt.savefig(filename)
+        return None
+
+    chrom.plot(width=1000, height=250)
+    return None
+
+
+def plot_bpc(
+    self,
+    title=None,
+    filename=None,
+    rt_unit="s",
+):
+    """
+    Plot Base Peak Chromatogram (BPC) using MS1 data.
+
+    Aggregates MS1 points by retention time and selects the maximum intensity (base peak)
+    at each time point. Uses `self.ms1_df` (Polars DataFrame) as the source of MS1 peaks.
+
+    Parameters:
+        title (str, optional): Plot title.
+        filename (str, optional): If provided and ends with `.html` saves an interactive html,
+            otherwise saves a png. If None, returns a displayable object for notebooks.
+        rt_unit (str, optional): Unit label for the x-axis, default 's' (seconds).
+
+    Returns:
+        None or notebook display object (via _display_plot)
+    """
+    if self.ms1_df is None:
+        self.logger.error("No MS1 data available.")
+        return
+
+    # Import helper locally to avoid circular imports
+    from masster.study.helpers import get_bpc
+
+    # Delegate BPC computation to study helper
+    try:
+        chrom = get_bpc(self, rt_unit=rt_unit, label=title)
+    except Exception as e:
+        self.logger.exception("Failed to compute BPC via helper: %s", e)
+        return
+
+    # If filename was requested, save a static png using bokeh export via the chromatogram plotting
+    if filename is not None:
+        # chromatogram.plot() uses bokeh to show the figure; to save as png we rely on holoviews/hv.save
+        # Create a bokeh figure by plotting to an offscreen axis
+        try:
+            # Use Chromatogram.plot to generate and show the figure (will open in notebook/browser)
+            chrom.plot(width=1000, height=250)
+        except Exception:
+            # Last-resort: create a simple matplotlib plot and save
+            import matplotlib.pyplot as plt
+
+            plt.figure(figsize=(10, 3))
+            plt.plot(chrom.rt, chrom.inty, color="black")
+            plt.xlabel(f"Retention time ({rt_unit})")
+            plt.ylabel("Intensity")
+            if title:
+                plt.title(title)
+            plt.tight_layout()
+            plt.savefig(filename)
+        return None
+
+    # No filename: display using the chromatogram's built-in plotting (bokeh)
+    chrom.plot(width=1000, height=250)
+    return None