masster 0.3.1__tar.gz → 0.3.3__tar.gz

{masster-0.3.1 → masster-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: masster
-Version: 0.3.1
+Version: 0.3.3
 Summary: Mass spectrometry data analysis package
 Project-URL: homepage, https://github.com/zamboni-lab/masster
 Project-URL: repository, https://github.com/zamboni-lab/masster

{masster-0.3.1 → masster-0.3.3}/pyproject.toml

@@ -1,7 +1,7 @@
 
 [project]
 name = "masster"
-version = "0.3.1"
+version = "0.3.3"
 description = "Mass spectrometry data analysis package"
 authors = [
     { name = "Zamboni Lab" }

{masster-0.3.1 → masster-0.3.3}/src/masster/sample/plot.py

@@ -283,9 +283,12 @@ def plot_2d(
     cmap=None,
     marker="circle",
     markersize=10,
+    size="dynamic",
     raster_dynamic=True,
     raster_max_px=8,
     raster_threshold=0.8,
+    height=600,
+    width=800,
     mz_range=None,
     rt_range=None,
 ):
@@ -318,6 +321,11 @@ def plot_2d(
             Marker type to use for feature and MS2 points.
         markersize (int, default 10):
             Base size of the markers used for plotting points.
+        size (str, default 'dynamic'):
+            Controls marker sizing behavior. Options: 'dynamic', 'static', or 'slider'.
+            - 'dynamic': Uses coordinate-based sizing that scales with zoom level (markers get larger when zooming in)
+            - 'static': Uses screen-based sizing that remains constant regardless of zoom level
+            - 'slider': Provides an interactive slider to dynamically adjust marker size
         raster_dynamic (bool, default True):
             Whether to use dynamic rasterization for the background point cloud.
         raster_max_px (int, default 8):
@@ -357,9 +365,9 @@ def plot_2d(
     # keep only rt, mz, and inty
     spectradf = spectradf.select(["rt", "mz", "inty"])
     if mz_range is not None:
-        spectradf = spectradf[(spectradf["mz"] >= mz_range[0]) & (spectradf["mz"] <= mz_range[1])]
+        spectradf = spectradf.filter((pl.col("mz") >= mz_range[0]) & (pl.col("mz") <= mz_range[1]))
     if rt_range is not None:
-        spectradf = spectradf[(spectradf["rt"] >= rt_range[0]) & (spectradf["rt"] <= rt_range[1])]
+        spectradf = spectradf.filter((pl.col("rt") >= rt_range[0]) & (pl.col("rt") <= rt_range[1]))
     maxrt = spectradf["rt"].max()
     minrt = spectradf["rt"].min()
     maxmz = spectradf["mz"].max()
@@ -384,19 +392,81 @@ def plot_2d(
         tools=["hover"],
     )
 
-    size_1 = 1 * markersize
+    # 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'):
+                from bokeh.models import Circle
+                for renderer in plot.state.renderers:
+                    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":
+                            # Create a new Circle glyph with radius instead of size
+                            new_glyph = Circle(
+                                x=glyph.x,
+                                y=glyph.y,
+                                radius=base_radius,
+                                fill_color=glyph.fill_color,
+                                line_color=glyph.line_color,
+                                fill_alpha=glyph.fill_alpha,
+                                line_alpha=glyph.line_alpha,
+                            )
+                            renderer.glyph = new_glyph
+        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"
+        # Calculate radius based on data range for coordinate-based sizing
+        rtrange = maxrt - minrt
+        mzrange = maxmz - minmz
+        # Use a fraction of the smaller dimension for radius
+        base_radius = min(rtrange, mzrange) * 0.0005 * markersize
+        size_1 = markersize  # Use regular size initially, hook will convert to radius
+        size_2 = markersize
+        hooks = [dynamic_sizing_hook]
+    elif use_slider_sizing:
+        # Slider sizing: create an interactive slider for marker size
+        marker_type = marker  # Use the original marker parameter
+        size_1 = markersize  # Use markersize initially, will be updated by slider
+        size_2 = markersize
+        base_radius = None  # Not used in slider mode
+        hooks = []
+    else:
+        # Static sizing: use pixel-based sizing that stays fixed
+        marker_type = marker  # Use the original marker parameter
+        size_1 = markersize
+        size_2 = markersize
+        base_radius = None  # Not used in static mode
+        hooks = []
+    
     color_1 = "forestgreen"
-    size_2 = 1 * markersize
     color_2 = "darkorange"
     if filename is not None:
         dyn = False
         if not filename.endswith(".html"):
-            size_1 = 2
+            if use_dynamic_sizing:
+                # For exported files, use smaller coordinate-based size
+                size_1 = 2
+                size_2 = 2
+            else:
+                size_1 = 2
+                size_2 = 2
             color_1 = "forestgreen"
-            size_2 = 2
             color_2 = "darkorange"
             raster_dynamic = False
 
+    # For slider functionality, disable raster dynamic to avoid DynamicMap nesting
+    if use_slider_sizing:
+        raster_dynamic = False
+
     dyn = raster_dynamic
     raster = hd.rasterize(
         points,
@@ -408,8 +478,8 @@ def plot_2d(
         cmap=process_cmap(cmap, provider="bokeh"),  # blues
         tools=["hover"],
         hooks=[new_bounds_hook],
-        width=1000,
-        height=1000,
+        width=width,
+        height=height,
         cnorm="log",
         xlabel="Retention time (s)",
         ylabel="m/z",
@@ -448,6 +518,7 @@ def plot_2d(
         feats = feats[feats["iso"] == 0]
         # 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_points_1 = hv.Points(
             features_df,
             kdims=["rt", "mz"],
@@ -463,9 +534,10 @@ def plot_2d(
             label="Features with MS2 data",
         ).options(
             color=color_1,
-            marker=marker,
+            marker=marker_type,
             size=size_1,
             tools=["hover"],
+            hooks=hooks,
         )
         # find features without MS2 data
         features_df = feats[feats["ms2_scans"].isnull()]
@@ -483,9 +555,10 @@ def plot_2d(
             label="Features without MS2 data",
         ).options(
             color="red",
+            marker=marker_type,
             size=size_2,
-            marker=marker,
             tools=["hover"],
+            hooks=hooks,
         )
 
         if show_isotopes:
@@ -510,9 +583,10 @@ def plot_2d(
                 label="Isotopes",
             ).options(
                 color="violet",
-                marker=marker,
+                marker=marker_type,
                 size=size_1,
                 tools=["hover"],
+                hooks=hooks,
             )
     if show_ms2:
         # find all self.scans_df with mslevel 2 that are not linked to a feature
@@ -569,8 +643,119 @@ def plot_2d(
     if title is not None:
         overlay = overlay.opts(title=title)
 
-    # Create a panel layout
-    layout = panel.Column(overlay)
+    # Handle slider functionality
+    if use_slider_sizing:
+        # 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
+        
+        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
+            if feature_points_3 is not None:
+                updated_points_3 = feature_points_3.opts(size=size_val)
+                feature_overlay = updated_points_3 if feature_overlay is None else feature_overlay * updated_points_3
+            if feature_points_1 is not None:
+                updated_points_1 = feature_points_1.opts(size=size_val)
+                feature_overlay = updated_points_1 if feature_overlay is None else feature_overlay * updated_points_1
+            if not show_only_features_with_ms2 and feature_points_2 is not None:
+                updated_points_2 = feature_points_2.opts(size=size_val)
+                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
+                
+            # 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(
+            name="Marker Size",
+            start=1.0,
+            end=20.0,
+            step=0.5,
+            value=markersize,
+            width=300,
+            height=40,
+            margin=(5, 5),
+            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)),
+            size_slider,
+            height=60,
+            margin=10
+        )
+        
+        # Create slider widget
+        size_slider = pn.widgets.FloatSlider(
+            name="Marker Size",
+            start=1.0,
+            end=20.0,
+            step=0.5,
+            value=markersize,
+            width=300,
+            height=40,
+            margin=(5, 5),
+            show_value=True
+        )
+        
+        slider_widget = pn.Row(
+            pn.pane.HTML("<b>Marker Size:</b>", width=100, height=40, margin=(5, 10)),
+            size_slider,
+            height=60,
+            margin=10
+        )
+        
+        # Simple reactive plot - slider mode doesn't use dynamic rasterization
+        @pn.depends(size_slider.param.value)
+        def reactive_plot(size_val):
+            overlay = create_feature_overlay(float(size_val))
+            # Apply static rasterization for slider mode
+            if raster_dynamic:
+                return hd.rasterize(
+                    overlay,
+                    aggregator=ds.count(),
+                    width=raster_max_px,
+                    height=raster_max_px,
+                    dynamic=False  # Static raster for slider mode
+                ).opts(
+                    cnorm='eq_hist',
+                    tools=['hover'],
+                    width=width,
+                    height=height
+                )
+            else:
+                return overlay
+        
+        # Create layout
+        layout = pn.Column(slider_widget, reactive_plot, sizing_mode='stretch_width')
+        
+        return layout
+    else:
+        # Create a panel layout without slider
+        layout = panel.Column(overlay)
 
     if filename is not None:
         # if filename includes .html, save the panel layout to an HTML file
@@ -578,10 +763,17 @@ def plot_2d(
             layout.save(filename, embed=True)
         else:
             # save the panel layout as a png
-            hv.save(overlay, filename, fmt="png")
+            if use_slider_sizing:
+                # For slider plots, save the current state of the param_plot
+                hv.save(create_feature_overlay(markersize), filename, fmt="png")
+            else:
+                hv.save(overlay, filename, fmt="png")
     else:
         # Check if we're in a notebook environment and display appropriately
-        return _display_plot(overlay, layout)
+        if use_slider_sizing:
+            return _display_plot(layout, layout)
+        else:
+            return _display_plot(overlay, layout)
 
 
 def plot_2d_oracle(

{masster-0.3.1 → masster-0.3.3}/src/masster/sample/sample.py

@@ -287,7 +287,7 @@ class Sample:
         """
         # Reset logger configuration flags to allow proper reconfiguration after reload
         try:
-            import masster.sample.logger as logger_module
+            import masster.logger as logger_module
 
             if hasattr(logger_module, "_SAMPLE_LOGGER_CONFIGURED"):
                 logger_module._SAMPLE_LOGGER_CONFIGURED = False

{masster-0.3.1 → masster-0.3.3}/src/masster/study/plot.py

@@ -157,13 +157,43 @@ def plot_consensus_2d(
     colorby="number_samples",
     sizeby="inty_mean",
     markersize=6,
+    size="dynamic",
     alpha=0.7,
     cmap=None,
+    width=900,
+    height=900,
+    mz_range=None,
+    rt_range=None
 ):
+    """
+    Plot consensus features in a 2D scatter plot with retention time vs m/z.
+    
+    Parameters:
+        filename (str, optional): Path to save the plot
+        colorby (str): Column name to use for color mapping (default: "number_samples")
+        sizeby (str): Column name to use for size mapping (default: "inty_mean")
+        markersize (int): Base marker size (default: 6)
+        size (str): Controls whether points scale with zoom. Options:
+                   'dynamic' - points use circle() and scale with zoom
+                   'static' - points use scatter() and maintain fixed pixel size
+        alpha (float): Transparency level (default: 0.7)
+        cmap (str, optional): Color map name
+        width (int): Plot width in pixels (default: 900)
+        height (int): Plot height in pixels (default: 900)
+        mz_range (tuple, optional): m/z range for filtering consensus features (min_mz, max_mz)
+        rt_range (tuple, optional): Retention time range for filtering consensus features (min_rt, max_rt)
+    """
     if self.consensus_df is None:
         self.logger.error("No consensus map found.")
         return
     data = self.consensus_df.clone()
+    
+    # Filter by mz_range and rt_range if provided
+    if mz_range is not None:
+        data = data.filter((pl.col("mz") >= mz_range[0]) & (pl.col("mz") <= mz_range[1]))
+    if rt_range is not None:
+        data = data.filter((pl.col("rt") >= rt_range[0]) & (pl.col("rt") <= rt_range[1]))
+    
     if colorby not in data.columns:
         self.logger.error(f"Column {colorby} not found in consensus_df.")
         return
@@ -238,21 +268,33 @@ def plot_consensus_2d(
     )
     # scatter plot rt vs mz
     p = bp.figure(
-        width=800,
-        height=600,
+        width=width,
+        height=height,
         title="Consensus map",
     )
     p.xaxis.axis_label = "Retention Time (min)"
     p.yaxis.axis_label = "m/z"
-    scatter_renderer = p.scatter(
-        x="rt",
-        y="mz",
-        size="markersize",
-        fill_color={"field": colorby, "transform": color_mapper},
-        line_color=None,
-        alpha=alpha,
-        source=source,
-    )
+    scatter_renderer: Any = None
+    if size.lower() in ["dyn", "dynamic"]:
+        scatter_renderer = p.circle(
+            x="rt",
+            y="mz",
+            radius=markersize / 10,
+            fill_color={"field": colorby, "transform": color_mapper},
+            line_color=None,
+            alpha=alpha,
+            source=source,
+        )
+    else:
+        scatter_renderer = p.scatter(
+            x="rt",
+            y="mz",
+            size="markersize",
+            fill_color={"field": colorby, "transform": color_mapper},
+            line_color=None,
+            alpha=alpha,
+            source=source,
+        )
     # add hover tool
     hover = HoverTool(
         tooltips=[
@@ -292,16 +334,36 @@ def plot_samples_2d(
     samples=None,
     filename=None,
     markersize=2,
-    size="const",
+    size="dynamic",
     alpha_max=0.8,
     alpha="inty",
     cmap="Turbo256",
-    max_features=50000,  # Reduced default for better performance with many samples
+    max_features=50000,
+    width=900,
+    height=900,
+    mz_range=None,
+    rt_range=None
 ):
     """
     Plot all feature maps for sample_uid in parameter uids in an overlaid scatter plot.
     Each sample is a different color. Alpha scales with intensity.
     OPTIMIZED VERSION: Uses vectorized operations and batch processing.
+    
+    Parameters:
+        samples: Sample UIDs to plot
+        filename (str, optional): Path to save the plot
+        markersize (int): Base marker size (default: 2)
+        size (str): Controls whether points scale with zoom. Options:
+                   'dynamic' or 'dyn' - points use circle() and scale with zoom
+                   'const', 'static' or other - points use scatter() and maintain fixed pixel size
+        alpha_max (float): Maximum transparency level (default: 0.8)
+        alpha (str): Column name to use for alpha mapping (default: "inty")
+        cmap (str): Color map name (default: "Turbo256")
+        max_features (int): Maximum number of features to plot (default: 50000)
+        width (int): Plot width in pixels (default: 900)
+        height (int): Plot height in pixels (default: 900)
+        mz_range (tuple, optional): m/z range for filtering features (min_mz, max_mz)
+        rt_range (tuple, optional): Retention time range for filtering features (min_rt, max_rt)
     """
 
     sample_uids = self._get_sample_uids(samples)
@@ -314,8 +376,8 @@ def plot_samples_2d(
     color_map = {uid: colors[i * (256 // max(1, len(sample_uids)))] for i, uid in enumerate(sample_uids)}
 
     p = figure(
-        width=600,
-        height=600,
+        width=width,
+        height=height,
         title="Sample Features",
     )
     p.xaxis.axis_label = "Retention Time (RT)"
@@ -323,6 +385,12 @@ def plot_samples_2d(
 
     # OPTIMIZATION 1: Batch filter all features for selected samples at once
     features_batch = self.features_df.filter(pl.col("sample_uid").is_in(sample_uids))
+    
+    # Filter by mz_range and rt_range if provided
+    if mz_range is not None:
+        features_batch = features_batch.filter((pl.col("mz") >= mz_range[0]) & (pl.col("mz") <= mz_range[1]))
+    if rt_range is not None:
+        features_batch = features_batch.filter((pl.col("rt") >= rt_range[0]) & (pl.col("rt") <= rt_range[1]))
 
     if features_batch.is_empty():
         self.logger.error("No features found for the selected samples.")

{masster-0.3.1 → masster-0.3.3}/uv.lock

@@ -1585,7 +1585,7 @@ wheels = [
 
 [[package]]
 name = "masster"
-version = "0.3.1"
+version = "0.3.3"
 source = { editable = "." }
 dependencies = [
     { name = "alphabase" },