masster 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

masster/sample/plot.py

@@ -22,13 +22,13 @@ Dependencies:
 - `numpy`: For numerical computations.
 
 Functions:
-- `plot_eic()`: Generate extracted ion chromatograms with feature overlays.
+- `plot_chrom()`: Generate chromatograms with feature overlays.
 - `plot_2d()`: Create 2D mass spectrometry data visualizations.
 - `plot_features()`: Visualize detected features in retention time vs m/z space.
 - Various utility functions for plot styling and configuration.
 
 Supported Plot Types:
-- Extracted Ion Chromatograms (EIC)
+- Chromatograms
 - Total Ion Chromatograms (TIC)
 - Base Peak Chromatograms (BPC)
 - 2D intensity maps (RT vs m/z)
@@ -63,7 +63,74 @@ from matplotlib.colors import rgb2hex
 hv.extension("bokeh")
 
 
-def plot_eic(
+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
+                return True
+        
+        # Check for Marimo
+        import sys
+        if 'marimo' in sys.modules:
+            return True
+        
+        # Additional check for notebook environments
+        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 - 
+            # holoviews will handle the display automatically
+            return plot_object
+        except Exception:
+            # Fallback to panel display for other notebook environments
+            if layout is not None:
+                return layout
+            else:
+                # Create a simple layout if none provided
+                simple_layout = panel.Column(plot_object)
+                return simple_layout
+    else:
+        # Display in browser (original behavior)
+        if layout is not None:
+            layout.show()
+        else:
+            # Create a simple layout for browser display
+            simple_layout = panel.Column(plot_object)
+            simple_layout.show()
+        return None
+
+
+def plot_chrom(
     self,
     feature_uid=None,
     filename=None,
@@ -74,16 +141,16 @@ def plot_eic(
     link_x=False,
 ):
     """
-    Plot Extracted Ion Chromatograms (EICs) for one or more features using MS1 data and feature metadata.
+    Plot chromatograms for one or more features using MS1 data and feature metadata.
 
     This function filters MS1 data based on retention time (rt) and mass-to-charge ratio (mz) windows
-    derived from feature information in `features_df`. It then generates interactive EIC plots using
+    derived from feature information in `features_df`. It then generates interactive chromatogram plots using
     HoloViews, with feature retention time windows annotated. Plots can be displayed interactively or
     saved to a file.
 
     Parameters:
         feature_uid (int or list of int, optional):
-            Feature identifier(s) for EIC generation. If None, EICs for all features in `features_df` are plotted.
+            Feature identifier(s) for chromatogram generation. If None, chromatograms for all features in `features_df` are plotted.
         filename (str, optional):
             Output file path. If ending with `.html`, saves as interactive HTML; otherwise, saves as PNG.
             If not provided, displays the plot interactively.
@@ -96,7 +163,7 @@ def plot_eic(
         mz_tol_factor_plot (float, default=1):
             m/z time tolerance factor.
         link_x (bool, default=True):
-            If True, links the x-axes (retention time) across all EIC subplots.
+            If True, links the x-axes (retention time) across all chromatogram subplots.
 
     Returns:
         None
@@ -106,7 +173,7 @@ def plot_eic(
         - Aggregates MS1 intensities by retention time.
         - Utilizes HoloViews for visualization and Panel for layout/display.
     """
-    # plots the EIC for a given feature id
+    # plots the chromatogram for a given feature id
     # If rt or mz are not provided, they are extracted from features_df using the supplied feature id (feature_uid)
 
     feature_uids = feature_uid
@@ -121,7 +188,7 @@ def plot_eic(
 
     # make sure feature_uid is a list of integers
 
-    eic_plots = []
+    chrom_plots = []
     feature_uids = feats["feature_uid"].values.tolist()
     mz_tol_plot = mz_tol * mz_tol_factor_plot
     rt_tol_plot = rt_tol * rt_tol_factor_plot
@@ -137,29 +204,29 @@ def plot_eic(
         mz_end = feature_row["mz_end"].values[0]
 
         # filter self.ms1_df with rt_start, rt_end, mz_start, mz_end
-        eic_df = self.ms1_df.filter(
+        chrom_df = self.ms1_df.filter(
             pl.col("rt") >= rt_start - rt_tol_plot,
             pl.col("rt") <= rt_end + rt_tol_plot,
         )
-        eic_df = eic_df.filter(
+        chrom_df = chrom_df.filter(
             pl.col("mz") >= mz_start - mz_tol_plot,
             pl.col("mz") <= mz_end + mz_tol_plot,
         )
 
-        if eic_df.is_empty():
+        if chrom_df.is_empty():
             print("No MS1 data found in the specified window.")
             continue
 
         # convert to pandas DataFrame
-        eic_df = eic_df.to_pandas()
+        chrom_df = chrom_df.to_pandas()
         # aggregate all points with the same rt using the sum of inty
-        eic_df = eic_df.groupby("rt").agg({"inty": "sum"}).reset_index()
+        chrom_df = chrom_df.groupby("rt").agg({"inty": "sum"}).reset_index()
         yname = f"inty_{feature_uid}"
-        eic_df.rename(columns={"inty": yname}, inplace=True)
+        chrom_df.rename(columns={"inty": yname}, inplace=True)
 
-        # Plot the EIC using bokeh and ensure axes are independent by setting axiswise=True
-        eic = hv.Curve(eic_df, kdims=["rt"], vdims=[yname]).opts(
-            title=f"EIC for feature {feature_uid}, mz = {mz:.4f}",
+        # Plot the chromatogram using bokeh and ensure axes are independent by setting axiswise=True
+        chrom = hv.Curve(chrom_df, kdims=["rt"], vdims=[yname]).opts(
+            title=f"Chromatogram for feature {feature_uid}, mz = {mz:.4f}",
             xlabel="Retention time (s)",
             ylabel="Intensity",
             width=1000,
@@ -170,13 +237,13 @@ def plot_eic(
         )
 
         # Add vertical lines at the start and end of the retention time
-        eic = eic * hv.VLine(rt_start).opts(
+        chrom = chrom * hv.VLine(rt_start).opts(
             color="blue",
             line_width=1,
             line_dash="dashed",
             axiswise=True,
         )
-        eic = eic * hv.VLine(rt_end).opts(
+        chrom = chrom * hv.VLine(rt_end).opts(
             color="blue",
             line_width=1,
             line_dash="dashed",
@@ -184,12 +251,12 @@ def plot_eic(
         )
 
         # Append the subplot without linking axes
-        eic_plots.append(eic)
+        chrom_plots.append(chrom)
     if link_x:
-        # Create a layout with shared x-axis for all EIC plots
-        layout = hv.Layout(eic_plots).opts(shared_axes=True)
+        # Create a layout with shared x-axis for all chromatogram plots
+        layout = hv.Layout(chrom_plots).opts(shared_axes=True)
     else:
-        layout = hv.Layout(eic_plots).opts(shared_axes=False)
+        layout = hv.Layout(chrom_plots).opts(shared_axes=False)
 
     layout = layout.cols(1)
     layout = panel.Column(layout)
@@ -201,8 +268,8 @@ def plot_eic(
             # save the panel layout as a png
             hv.save(layout, filename, fmt="png")
     else:
-        # Display the panel layout
-        layout.show()
+        # Check if we're in a notebook environment and display appropriately
+        return _display_plot(layout.object, layout)
 
 
 def plot_2d(
@@ -216,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,
 ):
@@ -251,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):
@@ -290,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()
@@ -317,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,
@@ -341,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",
@@ -381,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"],
@@ -396,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()]
@@ -416,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:
@@ -443,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
@@ -502,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
@@ -511,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:
-        # Display the panel layout
-        layout.show()
+        # Check if we're in a notebook environment and display appropriately
+        if use_slider_sizing:
+            return _display_plot(layout, layout)
+        else:
+            return _display_plot(overlay, layout)
 
 
 def plot_2d_oracle(
@@ -922,8 +1181,8 @@ def plot_2d_oracle(
             # save the panel layout as a png
             hv.save(overlay, filename, fmt="png")
     else:
-        # Display the panel layout
-        layout.show()
+        # Check if we're in a notebook environment and display appropriately
+        return _display_plot(overlay, layout)
 
 
 def plot_ms2_eic(
@@ -1070,7 +1329,9 @@ def plot_ms2_eic(
         else:
             hv.save(layout, filename, fmt="png")
     else:
-        panel.panel(layout).show()
+        # Check if we're in a notebook environment and display appropriately
+        layout_obj = panel.panel(layout)
+        return _display_plot(layout, layout_obj)
 
 
 def plot_ms2_cycle(
@@ -1290,8 +1551,8 @@ def plot_ms2_cycle(
             # save the panel layout as a png
             hv.save(overlay, filename, fmt="png")
     else:
-        # Display the panel layout
-        layout.show()
+        # Check if we're in a notebook environment and display appropriately
+        return _display_plot(overlay, layout)
 
 
 def plot_ms2_q1(
@@ -1393,7 +1654,9 @@ def plot_ms2_q1(
         else:
             hv.save(layout, filename, fmt="png")
     else:
-        panel.panel(layout).show()
+        # Check if we're in a notebook environment and display appropriately
+        layout_obj = panel.panel(layout)
+        return _display_plot(layout, layout_obj)
 
 
 def plot_dda_stats(
@@ -1468,7 +1731,9 @@ def plot_dda_stats(
         else:
             hv.save(layout, filename, fmt="png")
     else:
-        panel.panel(layout).show()
+        # Check if we're in a notebook environment and display appropriately
+        layout_obj = panel.panel(layout)
+        return _display_plot(layout, layout_obj)
 
 
 def plot_feature_stats(
@@ -1584,7 +1849,9 @@ def plot_feature_stats(
         else:
             hv.save(layout, filename, fmt="png")
     else:
-        panel.panel(layout).show()
+        # Check if we're in a notebook environment and display appropriately
+        layout_obj = panel.panel(layout)
+        return _display_plot(layout, layout_obj)
 
 
 def plot_tic(

masster/sample/sample.py

@@ -71,7 +71,7 @@ from masster.logger import MassterLogger
 from masster.sample.plot import plot_2d
 from masster.sample.plot import plot_2d_oracle
 from masster.sample.plot import plot_dda_stats
-from masster.sample.plot import plot_eic
+from masster.sample.plot import plot_chrom
 from masster.sample.plot import plot_feature_stats
 from masster.sample.plot import plot_ms2_cycle
 from masster.sample.plot import plot_ms2_eic
@@ -221,7 +221,7 @@ class Sample:
     plot_2d = plot_2d
     plot_2d_oracle = plot_2d_oracle
     plot_dda_stats = plot_dda_stats
-    plot_eic = plot_eic
+    plot_chrom = plot_chrom
     plot_feature_stats = plot_feature_stats
     plot_ms2_cycle = plot_ms2_cycle
     plot_ms2_eic = plot_ms2_eic
@@ -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
@@ -312,6 +312,7 @@ class Sample:
             f"{base_modname}._version",
             f"{base_modname}.chromatogram",
             f"{base_modname}.spectrum",
+            f"{base_modname}.logger",
         ]
 
         # Add study submodules
@@ -321,14 +322,15 @@ class Sample:
             if module_name.startswith(study_module_prefix) and module_name != current_module:
                 study_modules.append(module_name)
 
-        # Add parameters submodules
+        ''' # Add parameters submodules
         parameters_modules = []
         parameters_module_prefix = f"{base_modname}.parameters."
         for module_name in sys.modules:
             if module_name.startswith(parameters_module_prefix) and module_name != current_module:
                 parameters_modules.append(module_name)
-
-        all_modules_to_reload = core_modules + sample_modules + study_modules + parameters_modules
+        '''
+    
+        all_modules_to_reload = core_modules + sample_modules + study_modules #+ parameters_modules
 
         # Reload all discovered modules
         for full_module_name in all_modules_to_reload:

masster/study/h5.py

@@ -1289,6 +1289,8 @@ def _load_study5(self, filename=None):
                         "size": [],
                         "map_id": [],
                         "file_source": [],
+                        "ms1": [],
+                        "ms2": [],
                     },
                     schema={
                         "sample_uid": pl.Int64,
@@ -1298,6 +1300,8 @@ def _load_study5(self, filename=None):
                         "size": pl.Int64,
                         "map_id": pl.Utf8,
                         "file_source": pl.Utf8,
+                        "ms1": pl.Int64,
+                        "ms2": pl.Int64,
                     },
                 )
             pbar.update(1)
@@ -1317,6 +1321,8 @@ def _load_study5(self, filename=None):
                         "size": [],
                         "map_id": [],
                         "file_source": [],
+                        "ms1": [],
+                        "ms2": [],
                     },
                     schema={
                         "sample_uid": pl.Int64,
@@ -1326,6 +1332,8 @@ def _load_study5(self, filename=None):
                         "size": pl.Int64,
                         "map_id": pl.Utf8,
                         "file_source": pl.Utf8,
+                        "ms1": pl.Int64,
+                        "ms2": pl.Int64,
                     },
                 )
             pbar.update(1)

masster/study/helpers.py

@@ -1197,24 +1197,24 @@ def features_select(
     if final_count == 0:
         self.logger.warning("No features remaining after applying selection criteria.")
     else:
-        removed_count = initial_count - final_count
-        self.logger.info(f"Features selected: {final_count} (removed: {removed_count})")
-    
+        #removed_count = initial_count - final_count
+        self.logger.info(f"Features selected: {final_count} (out of {initial_count})")
+
     return feats
 
 
 def features_filter(self, features):
     """
-    Filter features_df by removing all features that match the given criteria.
-    This is the inverse of features_select - it removes the selected features.
+    Filter features_df by keeping only features that match the given criteria.
+    This keeps only the specified features and removes all others.
     
     OPTIMIZED VERSION: Batch operations and reduced overhead for better performance.
     
     Parameters:
-        features: Features to remove. Can be:
+        features: Features to keep. Can be:
                  - polars.DataFrame: Features DataFrame (will use feature_uid column)
-                 - list: List of feature_uids to remove
-                 - int: Single feature_uid to remove
+                 - list: List of feature_uids to keep
+                 - int: Single feature_uid to keep
     
     Returns:
         None (modifies self.features_df in place)
@@ -1230,34 +1230,34 @@ def features_filter(self, features):
     
     initial_count = len(self.features_df)
     
-    # Determine feature_uids to remove - optimized type checking
+    # Determine feature_uids to keep - optimized type checking
     if isinstance(features, pl.DataFrame):
         if "feature_uid" not in features.columns:
             self.logger.error("features DataFrame must contain 'feature_uid' column")
             return
-        feature_uids_to_remove = features["feature_uid"].to_list()
+        feature_uids_to_keep = features["feature_uid"].to_list()
     elif isinstance(features, (list, tuple)):
-        feature_uids_to_remove = list(features)  # Convert tuple to list if needed
+        feature_uids_to_keep = list(features)  # Convert tuple to list if needed
     elif isinstance(features, int):
-        feature_uids_to_remove = [features]
+        feature_uids_to_keep = [features]
     else:
         self.logger.error("features parameter must be a DataFrame, list, tuple, or int")
         return
     
-    # Early return if no UIDs to remove
-    if not feature_uids_to_remove:
+    # Early return if no UIDs to keep
+    if not feature_uids_to_keep:
         self.logger.warning("No feature UIDs provided for filtering.")
         return
     
     # Convert to set for faster lookup if list is large
-    if len(feature_uids_to_remove) > 100:
-        feature_uids_set = set(feature_uids_to_remove)
+    if len(feature_uids_to_keep) > 100:
+        feature_uids_set = set(feature_uids_to_keep)
         # Use the set for filtering if it's significantly smaller
-        if len(feature_uids_set) < len(feature_uids_to_remove) * 0.8:
-            feature_uids_to_remove = list(feature_uids_set)
+        if len(feature_uids_set) < len(feature_uids_to_keep) * 0.8:
+            feature_uids_to_keep = list(feature_uids_set)
     
-    # Create filter condition once
-    filter_condition = ~pl.col("feature_uid").is_in(feature_uids_to_remove)
+    # Create filter condition once - keep only the specified features
+    filter_condition = pl.col("feature_uid").is_in(feature_uids_to_keep)
     
     # Apply filter to features_df using lazy evaluation for better performance
     self.features_df = self.features_df.lazy().filter(filter_condition).collect()
@@ -1280,15 +1280,15 @@ def features_filter(self, features):
     
     # Single comprehensive log message
     if mapping_removed_count > 0:
-        self.logger.info(f"Filtered {removed_count} features and {mapping_removed_count} consensus mappings. Remaining features: {final_count}")
+        self.logger.info(f"Kept {final_count} features and removed {mapping_removed_count} consensus mappings. Filtered out {removed_count} features.")
     else:
-        self.logger.info(f"Filtered {removed_count} features. Remaining features: {final_count}")
+        self.logger.info(f"Kept {final_count} features. Filtered out {removed_count} features.")
 
 
 def features_delete(self, features):
     """
     Delete features from features_df based on feature identifiers.
-    This is an alias for features_filter for consistency with sample.features_delete().
+    This removes the specified features and keeps all others (opposite of features_filter).
     
     Parameters:
         features: Features to delete. Can be:
@@ -1299,7 +1299,70 @@ def features_delete(self, features):
     Returns:
         None (modifies self.features_df in place)
     """
-    self.features_filter(features)
+    if self.features_df is None or self.features_df.is_empty():
+        self.logger.warning("No features found in study.")
+        return
+    
+    # Early return if no features provided
+    if features is None:
+        self.logger.warning("No features provided for deletion.")
+        return
+    
+    initial_count = len(self.features_df)
+    
+    # Determine feature_uids to remove - optimized type checking
+    if isinstance(features, pl.DataFrame):
+        if "feature_uid" not in features.columns:
+            self.logger.error("features DataFrame must contain 'feature_uid' column")
+            return
+        feature_uids_to_remove = features["feature_uid"].to_list()
+    elif isinstance(features, (list, tuple)):
+        feature_uids_to_remove = list(features)  # Convert tuple to list if needed
+    elif isinstance(features, int):
+        feature_uids_to_remove = [features]
+    else:
+        self.logger.error("features parameter must be a DataFrame, list, tuple, or int")
+        return
+    
+    # Early return if no UIDs to remove
+    if not feature_uids_to_remove:
+        self.logger.warning("No feature UIDs provided for deletion.")
+        return
+    
+    # Convert to set for faster lookup if list is large
+    if len(feature_uids_to_remove) > 100:
+        feature_uids_set = set(feature_uids_to_remove)
+        # Use the set for filtering if it's significantly smaller
+        if len(feature_uids_set) < len(feature_uids_to_remove) * 0.8:
+            feature_uids_to_remove = list(feature_uids_set)
+    
+    # Create filter condition - remove specified features
+    filter_condition = ~pl.col("feature_uid").is_in(feature_uids_to_remove)
+    
+    # Apply filter to features_df using lazy evaluation for better performance
+    self.features_df = self.features_df.lazy().filter(filter_condition).collect()
+    
+    # Apply filter to consensus_mapping_df if it exists - batch operation
+    mapping_removed_count = 0
+    if self.consensus_mapping_df is not None and not self.consensus_mapping_df.is_empty():
+        initial_mapping_count = len(self.consensus_mapping_df)
+        self.consensus_mapping_df = (
+            self.consensus_mapping_df
+            .lazy()
+            .filter(filter_condition)
+            .collect()
+        )
+        mapping_removed_count = initial_mapping_count - len(self.consensus_mapping_df)
+    
+    # Calculate results once and log efficiently
+    final_count = len(self.features_df)
+    removed_count = initial_count - final_count
+    
+    # Single comprehensive log message
+    if mapping_removed_count > 0:
+        self.logger.info(f"Deleted {removed_count} features and {mapping_removed_count} consensus mappings. Remaining features: {final_count}")
+    else:
+        self.logger.info(f"Deleted {removed_count} features. Remaining features: {final_count}")
 
 
 def consensus_select(

masster/study/load.py

@@ -189,15 +189,50 @@ def add_sample(self, file, type=None, reset=False, adducts=None):
         sample_type = "blank"
     map_id_value = str(ddaobj.features.getUniqueId())
 
+    # Determine the final sample path based on file type
+    if file.endswith(".sample5"):
+        # If input is already .sample5, keep it in original location
+        final_sample_path = file
+        self.logger.debug(f"Using existing .sample5 file at original location: {final_sample_path}")
+        
+        # Check if there's a corresponding featureXML file in the same directory
+        featurexml_path = file.replace(".sample5", ".featureXML")
+        if os.path.exists(featurexml_path):
+            self.logger.debug(f"Found corresponding featureXML file: {featurexml_path}")
+        else:
+            self.logger.debug(f"No corresponding featureXML file found at: {featurexml_path}")
+    else:
+        # For .wiff, .mzML, .raw files, save to study folder (original behavior)
+        if self.folder is not None:
+            if not os.path.exists(self.folder):
+                os.makedirs(self.folder)
+            final_sample_path = os.path.join(self.folder, sample_name + ".sample5")
+            ddaobj.save(final_sample_path)
+            self.logger.debug(f"Saved converted sample to study folder: {final_sample_path}")
+        else:
+            # If no study folder is set, save in current directory
+            final_sample_path = os.path.join(os.getcwd(), sample_name + ".sample5")
+            ddaobj.save(final_sample_path)
+            self.logger.debug(f"Saved converted sample to current directory: {final_sample_path}")
+
+    # Count MS1 and MS2 scans from the loaded sample
+    ms1_count = 0
+    ms2_count = 0
+    if hasattr(ddaobj, 'scans_df') and ddaobj.scans_df is not None and not ddaobj.scans_df.is_empty():
+        ms1_count = int(ddaobj.scans_df.filter(pl.col("ms_level") == 1).height)
+        ms2_count = int(ddaobj.scans_df.filter(pl.col("ms_level") == 2).height)
+
     new_sample = pl.DataFrame(
         {
             "sample_uid": [int(len(self.samples_df) + 1)],
             "sample_name": [sample_name],
-            "sample_path": [file],
+            "sample_path": [final_sample_path],  # Use the determined path
             "sample_type": [sample_type],
             "size": [int(ddaobj.features.size())],
             "map_id": [map_id_value],
             "file_source": [getattr(ddaobj, 'file_source', file)],
+            "ms1": [ms1_count],
+            "ms2": [ms2_count],
         },
         schema={
             "sample_uid": pl.Int64,
@@ -207,15 +242,10 @@ def add_sample(self, file, type=None, reset=False, adducts=None):
             "size": pl.Int64,
             "map_id": pl.Utf8,
             "file_source": pl.Utf8,
+            "ms1": pl.Int64,
+            "ms2": pl.Int64,
         },
     )
-    # save ddaobj to folder if it is set
-    if self.folder is not None:
-        if not os.path.exists(self.folder):
-            os.makedirs(self.folder)
-        basename = os.path.basename(file)
-        sample_name = os.path.splitext(basename)[0]
-        ddaobj.save(os.path.join(self.folder, sample_name + ".sample5"))
     self.samples_df = pl.concat([self.samples_df, new_sample])
 
     # Optimized DataFrame operations - chain operations instead of multiple clones

masster/study/plot.py

@@ -157,9 +157,28 @@ def plot_consensus_2d(
     colorby="number_samples",
     sizeby="inty_mean",
     markersize=6,
+    size="dynamic",
     alpha=0.7,
     cmap=None,
+    width=900,
+    height=900
 ):
+    """
+    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)
+    """
     if self.consensus_df is None:
         self.logger.error("No consensus map found.")
         return
@@ -238,21 +257,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 +323,32 @@ 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
 ):
     """
     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)
     """
 
     sample_uids = self._get_sample_uids(samples)
@@ -314,8 +361,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)"

masster/study/save.py

@@ -105,6 +105,8 @@ def save_samples(self, samples=None):
         # save ddaobj
         ddaobj.save()
         sample_name = sample_row.row(0, named=True)["sample_name"]
+        sample_path = sample_row.row(0, named=True)["sample_path"]
+        
         # Find the index of this sample in the original order for features_maps
         sample_index = next(
             (
@@ -114,19 +116,29 @@ def save_samples(self, samples=None):
             ),
             None,
         )
-        if self.folder is not None:
-            filename = os.path.join(
-                self.folder,
-                sample_name + ".featureXML",
-            )
+        
+        # Determine where to save the featureXML file based on sample_path location
+        if sample_path.endswith(".sample5"):
+            # If sample_path is a .sample5 file, save featureXML in the same directory
+            featurexml_filename = sample_path.replace(".sample5", ".featureXML")
+            self.logger.debug(f"Saving featureXML alongside .sample5 file: {featurexml_filename}")
         else:
-            filename = os.path.join(
-                os.getcwd(),
-                sample_name + ".featureXML",
-            )
+            # Fallback to study folder or current directory (original behavior)
+            if self.folder is not None:
+                featurexml_filename = os.path.join(
+                    self.folder,
+                    sample_name + ".featureXML",
+                )
+            else:
+                featurexml_filename = os.path.join(
+                    os.getcwd(),
+                    sample_name + ".featureXML",
+                )
+            self.logger.debug(f"Saving featureXML to default location: {featurexml_filename}")
+        
         fh = oms.FeatureXMLFile()
         if sample_index is not None and sample_index < len(self.features_maps):
-            fh.store(filename, self.features_maps[sample_index])
+            fh.store(featurexml_filename, self.features_maps[sample_index])
 
     self.logger.debug("All samples saved successfully.")
 

masster/study/study.py

@@ -243,6 +243,8 @@ class Study:
                 "size": [],
                 "map_id": [],
                 "file_source": [],
+                "ms1": [],
+                "ms2": [],
             },
             schema={
                 "sample_uid": pl.Int64,
@@ -252,6 +254,8 @@ class Study:
                 "size": pl.Int64,
                 "map_id": pl.Utf8,
                 "file_source": pl.Utf8,
+                "ms1": pl.Int64,
+                "ms2": pl.Int64,
             },
         )
         self.features_maps = []
@@ -387,15 +391,17 @@ class Study:
             f"{base_modname}._version",
             f"{base_modname}.chromatogram",
             f"{base_modname}.spectrum",
-            f"{base_modname}.parameters",
+            f"{base_modname}.logger",
         ]
 
-        # Add any parameters submodules that are loaded
+        # Add sample submodules
+        sample_modules = []
+        sample_module_prefix = f"{base_modname}.sample."
         for module_name in sys.modules:
-            if module_name.startswith(f"{base_modname}.parameters.") and module_name not in core_modules:
-                core_modules.append(module_name)
+            if module_name.startswith(sample_module_prefix) and module_name != current_module:
+                sample_modules.append(module_name)
 
-        all_modules_to_reload = core_modules + study_modules
+        all_modules_to_reload = core_modules + sample_modules + study_modules
 
         # Reload all discovered modules
         for full_module_name in all_modules_to_reload:

masster/study/study5_schema.json

@@ -241,6 +241,12 @@
       },
       "size": {
         "dtype": "pl.Int64"
+      },
+      "ms1": {
+        "dtype": "pl.Int64"
+      },
+      "ms2": {
+        "dtype": "pl.Int64"
       }
     }
   }

{masster-0.3.0.dist-info → masster-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: masster
-Version: 0.3.0
+Version: 0.3.2
 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.0.dist-info → masster-0.3.2.dist-info}/RECORD

@@ -16,10 +16,10 @@ masster/sample/helpers.py,sha256=OEgvR3bptA-tEqHAFVPjWpbagKXAU1h0bePPi9ttHa4,348
 masster/sample/lib.py,sha256=9r2XlF_BaJ4WNAsQo8hElieRLwsAv0yrbYq4DJ0iVOM,33496
 masster/sample/load.py,sha256=y-KUJ2nCFX_06FHPUOh-CzRRvaTx14xNcXoL19bU8qY,47562
 masster/sample/parameters.py,sha256=Gg2KcuNbV_wZ_Wwv93QlM5J19ji0oSIvZLPV1NoBmq0,4456
-masster/sample/plot.py,sha256=9N3KHWFSSzXOiNKHfpnA8-DT-BfF1Ul5jS-9EAUsw3A,59747
+masster/sample/plot.py,sha256=uUJAd2qxhVG6Ev2hLuU406zFA2TDkkBz2MG12P9fLik,71449
 masster/sample/processing.py,sha256=NjNLt47Fy0UF3Xs35NBhADg57qTC6Lfa4Xz8Y30v83A,58250
 masster/sample/quant.py,sha256=tHNjvUFTdehKR31BXBZnVsBxMD9XJHgaltITOjr71uE,7562
-masster/sample/sample.py,sha256=zKRn8PmsHx0csWBnhGxkBVrEQdImIN71p_NkFFG3teI,16118
+masster/sample/sample.py,sha256=7ivuAMb3JlFikLOxZjTGwYmuqGehLz9d47gQxfSRtf4,16178
 masster/sample/sample5_schema.json,sha256=3SPFQZH4SooLYUt_lW-PCOE9rHnl56Vhc2XG-r1nyEQ,3586
 masster/sample/save.py,sha256=o9eFSqqr7KYwvCD3gOJt_nZ4h3pkflWqs0n0oSLM-sU,31970
 masster/sample/sciex.py,sha256=q6PdcjCtV2PWnJiXuvfISu09zjkaTR_fvHvWN9OvOcM,46870
@@ -31,16 +31,16 @@ masster/sample/defaults/get_spectrum_def.py,sha256=o62p31PhGd-LiIkTOzKQhwPtnO2At
 masster/sample/defaults/sample_def.py,sha256=t8vrb8MoBBsFQcRzlaT0-q0hAssOxWO7vhCAJU3_THs,14068
 masster/study/__init__.py,sha256=Zspv6U8jFqjkHGYdNdDy1rfUnCSolCzUdgSSg98PRgE,166
 masster/study/export.py,sha256=bm3e6AEwkXqBO6Pwd-2pWhxOmzQTFlOSauXFnaiSJDI,29019
-masster/study/h5.py,sha256=dTrolB9qQ6ExYh0c1jjxqxhEaIO5IAfcbX5Bm6ElP8k,66117
-masster/study/helpers.py,sha256=_n_CjbuJ6Jfzaxv9pa4Nl_A-1G2szHpYR6Ip4Rg1Nww,72052
+masster/study/h5.py,sha256=EcpyYfMknDzzdA6XTyMU_ppY92_DsPSPYGE0kpVN7T8,66429
+masster/study/helpers.py,sha256=SeW17rA3BIM2I2Whiye6wegRRSCabIpQoCsjOCafjKw,74888
 masster/study/helpers_optimized.py,sha256=EgOgPaL3c2LA8jDhnlEHvzb7O9Um-vnMIcnNaoH90gA,13620
-masster/study/load.py,sha256=wIE9JQGgeE1Yy3Tx2q0InqvyIG1bO70ymyF0yV5pWCM,45219
+masster/study/load.py,sha256=TLxVhXu0HHb51lGggXitQLtfNxz2JJfKMkAXJbxhvhM,46880
 masster/study/parameters.py,sha256=0elaF7YspTsB7qyajWAbRNL2VfKlGz5GJLifmO8IGkk,3276
-masster/study/plot.py,sha256=hOG8bBT3mYV63FieEk-gYKtOyIXWppkTu21VeGbRnGk,21918
+masster/study/plot.py,sha256=4i3u4geOinCefsambnEGVPF4XuyKTK-_eT5xAWgC7Ik,24045
 masster/study/processing.py,sha256=BQuSBO7O8iTlCjXenECyg0_PAsPF1NNiUllypuemPZI,46101
-masster/study/save.py,sha256=jev_E_nU2JVAjiWrwnocB1oKObND_YzeQneai9cX-io,5825
-masster/study/study.py,sha256=UrT-bUvZE_zIubZDWcuB20lZh5OVqA_PdQCNIrDlQVQ,26882
-masster/study/study5_schema.json,sha256=C3zineTQj6oEhFNwC_pAwVbV1jfyMUZDeGUJVAk8N0s,4993
+masster/study/save.py,sha256=bcRADWTvhTER9WRkT9zNU5mDUPQZkZB2cuJwpRsYmrM,6589
+masster/study/study.py,sha256=5TZgG7tr7mzqHh1tm48V8SEcvRcWiFYG9iDqz0U9ACc,27073
+masster/study/study5_schema.json,sha256=A_xDPzB97xt2EFeQsX9j8Ut7yC4_DS7BZ24ucotOXIw,5103
 masster/study/defaults/__init__.py,sha256=m3Z5KXGqsTdh7GjYzZoENERt39yRg0ceVRV1DeCt1P0,610
 masster/study/defaults/align_def.py,sha256=9aM7kY4_ecgG8QC6v57AASiRRkPxwG77r3-PlQ2BkHk,9139
 masster/study/defaults/export_def.py,sha256=eXl3h4aoLX88XkHTpqahLd-QZ2gjUqrmjq8IJULXeWo,1203
@@ -52,8 +52,8 @@ masster/study/defaults/integrate_chrom_def.py,sha256=Rih3-vat7fHGVfIvRitjNJJI3zL
 masster/study/defaults/integrate_def.py,sha256=Vf4SAzdBfnsSZ3IRaF0qZvWu3gMDPHdgPfMYoPKeWv8,7246
 masster/study/defaults/merge_def.py,sha256=EBsKE3hsAkTEzN9dpdRD5W3_suTKy_WZ_96rwS0uBuE,8572
 masster/study/defaults/study_def.py,sha256=hj8bYtEPwzdowC95yfyoCFt6fZkQePLjpJtmpNz9Z5M,9533
-masster-0.3.0.dist-info/METADATA,sha256=gDpvLu0f2SpOZa9BFUkHBxqSWLy2FGAGDyX0H1-RlPU,44356
-masster-0.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-masster-0.3.0.dist-info/entry_points.txt,sha256=ZHguQ_vPmdbpqq2uGtmEOLJfgP-DQ1T0c07Lxh30wc8,58
-masster-0.3.0.dist-info/licenses/LICENSE,sha256=bx5iLIKjgAdYQ7sISn7DsfHRKkoCUm1154sJJKhgqnU,35184
-masster-0.3.0.dist-info/RECORD,,
+masster-0.3.2.dist-info/METADATA,sha256=LTK6jfDeryui93xgzncpurTiYrc_iuzRMao82DQ0eMI,44356
+masster-0.3.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+masster-0.3.2.dist-info/entry_points.txt,sha256=ZHguQ_vPmdbpqq2uGtmEOLJfgP-DQ1T0c07Lxh30wc8,58
+masster-0.3.2.dist-info/licenses/LICENSE,sha256=bx5iLIKjgAdYQ7sISn7DsfHRKkoCUm1154sJJKhgqnU,35184
+masster-0.3.2.dist-info/RECORD,,