masster 0.3.19__py3-none-any.whl → 0.3.20__py3-none-any.whl

masster/study/plot.py

@@ -17,18 +17,222 @@ hv.extension("bokeh")
 from bokeh.layouts import row as bokeh_row
 
 
-<<<<<<< Updated upstream
+def _isolated_save_plot(plot_object, filename, abs_filename, logger, plot_title="Plot"):
+    """
+    Save a plot using isolated file saving that doesn't affect global Bokeh state.
+    This prevents browser opening issues when mixing file and notebook outputs.
+    """
+    if filename.endswith(".html"):
+        # Use isolated file saving that doesn't affect global output state
+        from bokeh.resources import Resources
+        from bokeh.embed import file_html
+        
+        # Create HTML content without affecting global state
+        resources = Resources(mode='cdn')
+        html = file_html(plot_object, resources, title=plot_title)
+        
+        # Write directly to file
+        with open(filename, 'w', encoding='utf-8') as f:
+            f.write(html)
+        
+        logger.info(f"Plot saved to: {abs_filename}")
+        
+    elif filename.endswith(".png"):
+        try:
+            from bokeh.io.export import export_png
+            export_png(plot_object, filename=filename)
+            logger.info(f"Plot saved to: {abs_filename}")
+        except Exception:
+            # Fall back to HTML if PNG export not available
+            html_filename = filename.replace('.png', '.html')
+            from bokeh.resources import Resources
+            from bokeh.embed import file_html
+            
+            resources = Resources(mode='cdn')
+            html = file_html(plot_object, resources, title=plot_title)
+            
+            with open(html_filename, 'w', encoding='utf-8') as f:
+                f.write(html)
+                
+            logger.warning(f"PNG export not available, saved as HTML instead: {html_filename}")
+    elif filename.endswith(".pdf"):
+        # Try to save as PDF, fall back to HTML if not available
+        try:
+            from bokeh.io.export import export_pdf
+            export_pdf(plot_object, filename=filename)
+            logger.info(f"Plot saved to: {abs_filename}")
+        except ImportError:
+            # Fall back to HTML if PDF export not available
+            html_filename = filename.replace('.pdf', '.html')
+            from bokeh.resources import Resources
+            from bokeh.embed import file_html
+            
+            resources = Resources(mode='cdn')
+            html = file_html(plot_object, resources, title=plot_title)
+            
+            with open(html_filename, 'w', encoding='utf-8') as f:
+                f.write(html)
+                
+            logger.warning(f"PDF export not available, saved as HTML instead: {html_filename}")
+    else:
+        # Default to HTML for unknown extensions using isolated approach
+        from bokeh.resources import Resources
+        from bokeh.embed import file_html
+        
+        resources = Resources(mode='cdn')
+        html = file_html(plot_object, resources, title=plot_title)
+        
+        with open(filename, 'w', encoding='utf-8') as f:
+            f.write(html)
+            
+        logger.info(f"Plot saved to: {abs_filename}")
+
+
+def _isolated_show_notebook(plot_object):
+    """
+    Show a plot in notebook using isolated display that resets Bokeh state.
+    This prevents browser opening issues when mixing file and notebook outputs.
+    """
+    from bokeh.io import reset_output, output_notebook, show
+    import holoviews as hv
+    import warnings
+    import logging
+    
+    # Suppress both warnings and logging messages for the specific Bokeh callback warnings
+    # that occur when Panel components with Python callbacks are converted to standalone Bokeh
+    bokeh_logger = logging.getLogger('bokeh.embed.util')
+    original_level = bokeh_logger.level
+    bokeh_logger.setLevel(logging.ERROR)  # Suppress WARNING level messages
+    
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore", message=".*standalone HTML/JS output.*", category=UserWarning)
+        warnings.filterwarnings("ignore", message=".*real Python callbacks.*", category=UserWarning)
+        
+        try:
+            # First clear all output state
+            reset_output()
+            
+            # Set notebook mode
+            output_notebook(hide_banner=True)
+            
+            # Reset Holoviews to notebook mode  
+            hv.extension('bokeh', logo=False)
+            hv.output(backend='bokeh', mode='jupyter')
+            
+            # Show in notebook
+            show(plot_object)
+        finally:
+            # Restore original logging level
+            bokeh_logger.setLevel(original_level)
+
+
+def _isolated_save_panel_plot(panel_obj, filename, abs_filename, logger, plot_title):
+    """
+    Save a Panel plot using isolated approach that doesn't affect global Bokeh state.
+    
+    Args:
+        panel_obj: Panel object to save
+        filename: Target filename 
+        abs_filename: Absolute path for logging
+        logger: Logger instance
+        plot_title: Title for logging
+    """
+    import os  # Import os for path operations
+    
+    if filename.endswith(".html"):
+        # Panel save method should be isolated but let's be sure
+        try:
+            # Save directly without affecting global Bokeh state
+            panel_obj.save(filename, embed=True)
+            logger.info(f"{plot_title} saved to: {abs_filename}")
+        except Exception as e:
+            logger.error(f"Failed to save {plot_title}: {e}")
+            
+    elif filename.endswith(".png"):
+        try:
+            from panel.io.save import save_png
+            # Convert Panel to Bokeh models before saving
+            bokeh_layout = panel_obj.get_root()
+            save_png(bokeh_layout, filename=filename)
+            logger.info(f"{plot_title} saved to: {abs_filename}")
+        except Exception:
+            # Fall back to HTML if PNG export not available
+            html_filename = filename.replace('.png', '.html')
+            abs_html_filename = os.path.abspath(html_filename)
+            try:
+                panel_obj.save(html_filename, embed=True)
+                logger.warning(f"PNG export not available, saved as HTML instead: {abs_html_filename}")
+            except Exception as e:
+                logger.error(f"Failed to save {plot_title} as HTML fallback: {e}")
+                
+    elif filename.endswith(".pdf"):
+        # Try to save as PDF, fall back to HTML if not available
+        try:
+            from bokeh.io.export import export_pdf
+            bokeh_layout = panel_obj.get_root()
+            export_pdf(bokeh_layout, filename=filename)
+            logger.info(f"{plot_title} saved to: {abs_filename}")
+        except ImportError:
+            # Fall back to HTML if PDF export not available
+            html_filename = filename.replace('.pdf', '.html')
+            abs_html_filename = os.path.abspath(html_filename)
+            try:
+                panel_obj.save(html_filename, embed=True)
+                logger.warning(f"PDF export not available, saved as HTML instead: {abs_html_filename}")
+            except Exception as e:
+                logger.error(f"Failed to save {plot_title} as HTML fallback: {e}")
+    else:
+        # Default to HTML for unknown extensions
+        try:
+            panel_obj.save(filename, embed=True)
+            logger.info(f"{plot_title} saved to: {abs_filename}")
+        except Exception as e:
+            logger.error(f"Failed to save {plot_title}: {e}")
+
+
+def _isolated_show_panel_notebook(panel_obj):
+    """
+    Show a Panel plot in notebook with state isolation to prevent browser opening.
+    
+    Args:
+        panel_obj: Panel object to display
+    """
+    # Reset Bokeh state completely to prevent browser opening if output_file was called before
+    from bokeh.io import reset_output, output_notebook
+    import holoviews as hv
+    
+    # First clear all output state
+    reset_output()
+    
+    # Set notebook mode
+    output_notebook(hide_banner=True)
+    
+    # Reset Holoviews to notebook mode  
+    hv.extension('bokeh', logo=False)
+    hv.output(backend='bokeh', mode='jupyter')
+    
+    # For Panel objects in notebooks, use pn.extension and display inline
+    import panel as pn
+    try:
+        # Configure Panel for notebook display
+        pn.extension('bokeh', inline=True, comms='vscode')
+        # Use IPython display to show inline instead of show()
+        from IPython.display import display
+        display(panel_obj)
+    except Exception:
+        # Fallback to regular Panel show
+        panel_obj.show()
+
+
 def plot_alignment(
     self,
+    samples=None,
     maps: bool = True,
     filename: str | None = None,
     width: int = 450,
     height: int = 450,
     markersize: int = 3,
 ):
-=======
-def plot_alignment(self, maps: bool = True, samples: int | list[int | str] | None = None, filename: str | None = None, width: int = 450, height: int = 450, markersize: int = 3):
->>>>>>> Stashed changes
     """Visualize retention time alignment using two synchronized Bokeh scatter plots.
 
     - When ``maps=True`` the function reads ``self.features_maps`` (list of FeatureMap)
@@ -37,12 +241,8 @@ def plot_alignment(self, maps: bool = True, samples: int | list[int | str] | Non
       ``rt_original`` column (before) and ``rt`` column (after).
 
     Parameters
+    - samples: List of sample identifiers (sample_uids or sample_names), or single int for random selection, or None for all samples.
     - maps: whether to use feature maps (default True).
-    - samples: Sample selection parameter, interpreted like in plot_samples_2d:
-        - None: show all samples
-        - int: show a random subset of N samples  
-        - list of ints: show samples with these sample_uids
-        - list of strings: show samples with these sample_names
     - filename: optional HTML file path to save the plot.
     - width/height: pixel size of each subplot.
     - markersize: base marker size.
@@ -55,6 +255,9 @@ def plot_alignment(self, maps: bool = True, samples: int | list[int | str] | Non
     from bokeh.plotting import figure, show, output_file
     import pandas as pd
 
+    # Get sample_uids to filter by if specified
+    sample_uids = self._get_sample_uids(samples) if samples is not None else None
+
     # Build the before/after tabular data used for plotting
     before_data: list[dict[str, Any]] = []
     after_data: list[dict[str, Any]] = []
@@ -70,31 +273,39 @@ def plot_alignment(self, maps: bool = True, samples: int | list[int | str] | Non
             self.logger.error("No feature maps available for plotting.")
             return
 
-        # Get sample_uids to limit which samples to show
-        sample_uids_to_show = self._get_sample_uids(samples)
-        
-        # Filter feature maps based on sample selection
-        if sample_uids_to_show is not None:
-            # Get sample indices for the selected sample_uids
-            selected_indices = []
-            if hasattr(self, 'samples_df') and self.samples_df is not None and not self.samples_df.is_empty():
+        # Filter feature maps by selected samples if specified
+        if sample_uids is not None:
+            # Create mapping from sample_uid to map_id and filter accordingly
+            if hasattr(self, "samples_df") and self.samples_df is not None and not self.samples_df.is_empty():
                 samples_info = self.samples_df.to_pandas()
-                for idx, row in samples_info.iterrows():
-                    if row.get('sample_uid') in sample_uids_to_show:
-                        selected_indices.append(idx)
+                
+                # Filter samples_info to only selected sample_uids and get their map_ids
+                selected_samples = samples_info[samples_info["sample_uid"].isin(sample_uids)]
+                if selected_samples.empty:
+                    self.logger.error("No matching samples found for the provided sample_uids.")
+                    return
+                
+                # Get the map_ids for selected samples
+                selected_map_ids = selected_samples["map_id"].tolist()
+                
+                # Filter feature maps based on map_ids
+                filtered_maps = []
+                for map_id in selected_map_ids:
+                    if 0 <= map_id < len(fmaps):
+                        filtered_maps.append(fmaps[map_id])
+                
+                fmaps = filtered_maps
+                samples_info = selected_samples.reset_index(drop=True)
+                
+                if not fmaps:
+                    self.logger.error("No feature maps found for the selected samples.")
+                    return
             else:
-                # If no samples_df, just limit to the first N samples
-                if isinstance(samples, int):
-                    selected_indices = list(range(min(samples, len(fmaps))))
-                else:
-                    selected_indices = list(range(len(fmaps)))
-            
-            # Filter feature maps to only include selected indices
-            fmaps = [fmaps[i] for i in selected_indices if i < len(fmaps)]
-            
-            if not fmaps:
-                self.logger.error("No feature maps match the selected samples.")
-                return
+                self.logger.warning("Cannot filter feature maps: no samples_df available")
+
+        if not fmaps:
+            self.logger.error("No feature maps available after filtering.")
+            return
 
         # Reference (first) sample: use current RT for both before and after
         ref = fmaps[0]
@@ -103,9 +314,10 @@ def plot_alignment(self, maps: bool = True, samples: int | list[int | str] | Non
         ref_inty = [f.getIntensity() for f in ref]
         max_ref_inty = max(ref_inty) if ref_inty else 1
 
-        # sample metadata
+        # Get sample metadata for reference (first) sample
         if hasattr(self, "samples_df") and self.samples_df is not None and not self.samples_df.is_empty():
-            samples_info = self.samples_df.to_pandas()
+            if 'samples_info' not in locals():
+                samples_info = self.samples_df.to_pandas()
             ref_sample_uid = (
                 samples_info.iloc[0]["sample_uid"] if "sample_uid" in samples_info.columns else "Reference_UID"
             )
@@ -138,7 +350,7 @@ def plot_alignment(self, maps: bool = True, samples: int | list[int | str] | Non
                 "size": markersize + 2,
             })
 
-        # Remaining samples
+        # Remaining samples - now using filtered feature maps and samples_info
         for sample_idx, fm in enumerate(fmaps[1:], start=1):
             mz_vals = []
             inty_vals = []
@@ -165,14 +377,21 @@ def plot_alignment(self, maps: bool = True, samples: int | list[int | str] | Non
 
             max_inty = max(inty_vals)
 
+            # Get sample metadata from filtered samples_info
             if hasattr(self, "samples_df") and self.samples_df is not None and not self.samples_df.is_empty():
-                samples_info = self.samples_df.to_pandas()
-                if sample_idx < len(samples_info):
+                # Use filtered samples_info if it exists from the filtering above
+                if 'samples_info' in locals() and sample_idx < len(samples_info):
                     sample_name = samples_info.iloc[sample_idx].get("sample_name", f"Sample {sample_idx}")
                     sample_uid = samples_info.iloc[sample_idx].get("sample_uid", f"Sample_{sample_idx}_UID")
                 else:
-                    sample_name = f"Sample {sample_idx}"
-                    sample_uid = f"Sample_{sample_idx}_UID"
+                    # Fallback to original samples_df if filtered samples_info is not available
+                    all_samples_info = self.samples_df.to_pandas()
+                    if sample_idx < len(all_samples_info):
+                        sample_name = all_samples_info.iloc[sample_idx].get("sample_name", f"Sample {sample_idx}")
+                        sample_uid = all_samples_info.iloc[sample_idx].get("sample_uid", f"Sample_{sample_idx}_UID")
+                    else:
+                        sample_name = f"Sample {sample_idx}"
+                        sample_uid = f"Sample_{sample_idx}_UID"
             else:
                 sample_name = f"Sample {sample_idx}"
                 sample_uid = f"Sample_{sample_idx}_UID"
@@ -219,34 +438,19 @@ def plot_alignment(self, maps: bool = True, samples: int | list[int | str] | Non
 
         # Use Polars instead of pandas
         features_df = self.features_df
+        
+        # Filter by selected samples if specified
+        if sample_uids is not None:
+            features_df = features_df.filter(pl.col("sample_uid").is_in(sample_uids))
+            if features_df.is_empty():
+                self.logger.error("No features found for the selected samples.")
+                return
 
         sample_col = "sample_uid" if "sample_uid" in features_df.columns else "sample_name"
         if sample_col not in features_df.columns:
             self.logger.error("No sample identifier column found in features_df.")
             return
 
-        # Get sample_uids to limit which samples to show
-        sample_uids_to_show = self._get_sample_uids(samples)
-        
-        # Filter features_df based on sample selection if specified
-        if sample_uids_to_show is not None:
-            if sample_col == 'sample_uid':
-                features_df = features_df.filter(pl.col('sample_uid').is_in(sample_uids_to_show))
-            else:
-                # Need to convert sample names to sample_uids if using sample_name column
-                if 'sample_uid' in features_df.columns:
-                    # Filter by sample_uid even though we're using sample_name as the primary column
-                    features_df = features_df.filter(pl.col('sample_uid').is_in(sample_uids_to_show))
-                else:
-                    # Convert sample_uids to sample_names and filter
-                    sample_names_to_show = []
-                    if hasattr(self, 'samples_df') and self.samples_df is not None:
-                        for uid in sample_uids_to_show:
-                            matching_rows = self.samples_df.filter(pl.col("sample_uid") == uid)
-                            if not matching_rows.is_empty():
-                                sample_names_to_show.append(matching_rows.row(0, named=True)["sample_name"])
-                    features_df = features_df.filter(pl.col('sample_name').is_in(sample_names_to_show))
-
         # Get unique samples using Polars
         samples = features_df.select(pl.col(sample_col)).unique().to_series().to_list()
 
@@ -423,16 +627,21 @@ def plot_alignment(self, maps: bool = True, samples: int | list[int | str] | Non
     # Use the aliased bokeh_row and set sizing_mode, width and height to avoid validation warnings.
     layout = bokeh_row(p1, p2, sizing_mode="fixed", width=width, height=height)
 
-    # Output and show
-    if filename:
-        from bokeh.plotting import output_file, show
-
-        output_file(filename)
-        show(layout)
+    # Apply consistent save/display behavior
+    if filename is not None:
+        # Convert relative paths to absolute paths using study folder as base
+        import os
+        if not os.path.isabs(filename):
+            filename = os.path.join(self.folder, filename)
+        
+        # Convert to absolute path for logging
+        abs_filename = os.path.abspath(filename)
+        
+        # Use isolated file saving
+        _isolated_save_plot(layout, filename, abs_filename, self.logger, "Alignment Plot")
     else:
-        from bokeh.plotting import show
-
-        show(layout)
+        # Show in notebook when no filename provided
+        _isolated_show_notebook(layout)
 
     return layout
 
@@ -537,6 +746,7 @@ def plot_consensus_2d(
     from bokeh.models import ColumnDataSource
     from bokeh.models import HoverTool
     from bokeh.models import LinearColorMapper
+    from bokeh.io.export import export_png
 
     try:
         from bokeh.models import ColorBar  # type: ignore[attr-defined]
@@ -650,8 +860,19 @@ def plot_consensus_2d(
     p.add_layout(color_bar, "right")
 
     if filename is not None:
-        bp.output_file(filename)
-    bp.show(p)
+        # Convert relative paths to absolute paths using study folder as base
+        import os
+        if not os.path.isabs(filename):
+            filename = os.path.join(self.folder, filename)
+        
+        # Convert to absolute path for logging
+        abs_filename = os.path.abspath(filename)
+        
+        # Use isolated file saving
+        _isolated_save_plot(p, filename, abs_filename, self.logger, "Consensus 2D Plot")
+    else:
+        # Show in notebook when no filename provided
+        _isolated_show_notebook(p)
     return p
 
 
@@ -870,17 +1091,22 @@ def plot_samples_2d(
     # Only set legend properties if a legend was actually created to avoid Bokeh warnings
     if getattr(p, "legend", None) and len(p.legend) > 0:
         p.legend.visible = False
-    if filename:
-        if filename.endswith(".html"):
-            output_file(filename)
-            show(p)
-        elif filename.endswith(".png"):
-            export_png(p, filename=filename)
-        else:
-            output_file(filename)
-            show(p)
+    
+    # Apply consistent save/display behavior
+    if filename is not None:
+        # Convert relative paths to absolute paths using study folder as base
+        import os
+        if not os.path.isabs(filename):
+            filename = os.path.join(self.folder, filename)
+        
+        # Convert to absolute path for logging
+        abs_filename = os.path.abspath(filename)
+        
+        # Use isolated file saving
+        _isolated_save_plot(p, filename, abs_filename, self.logger, "Samples 2D Plot")
     else:
-        show(p)
+        # Show in notebook when no filename provided
+        _isolated_show_notebook(p)
     return
 
 
@@ -1039,22 +1265,21 @@ def plot_bpc(
     if getattr(p, "legend", None) and len(p.legend) > 0:
         p.legend.visible = False
 
-    if filename:
-        if filename.endswith(".html"):
-            output_file(filename)
-            show(p)
-        elif filename.endswith(".png"):
-            try:
-                export_png(p, filename=filename)
-            except Exception:
-                # fallback to saving HTML
-                output_file(filename.replace(".png", ".html"))
-                show(p)
-        else:
-            output_file(filename)
-            show(p)
+    # Apply consistent save/display behavior
+    if filename is not None:
+        # Convert relative paths to absolute paths using study folder as base
+        import os
+        if not os.path.isabs(filename):
+            filename = os.path.join(self.folder, filename)
+        
+        # Convert to absolute path for logging
+        abs_filename = os.path.abspath(filename)
+        
+        # Use isolated file saving
+        _isolated_save_plot(p, filename, abs_filename, self.logger, "BPC Plot")
     else:
-        show(p)
+        # Show in notebook when no filename provided
+        _isolated_show_notebook(p)
 
     return p
 
@@ -1211,21 +1436,21 @@ def plot_eic(
     if getattr(p, "legend", None) and len(p.legend) > 0:
         p.legend.visible = False
 
-    if filename:
-        if filename.endswith(".html"):
-            output_file(filename)
-            show(p)
-        elif filename.endswith(".png"):
-            try:
-                export_png(p, filename=filename)
-            except Exception:
-                output_file(filename.replace(".png", ".html"))
-                show(p)
-        else:
-            output_file(filename)
-            show(p)
+    # Apply consistent save/display behavior
+    if filename is not None:
+        # Convert relative paths to absolute paths using study folder as base
+        import os
+        if not os.path.isabs(filename):
+            filename = os.path.join(self.folder, filename)
+        
+        # Convert to absolute path for logging
+        abs_filename = os.path.abspath(filename)
+        
+        # Use isolated file saving
+        _isolated_save_plot(p, filename, abs_filename, self.logger, "EIC Plot")
     else:
-        show(p)
+        # Show in notebook when no filename provided
+        _isolated_show_notebook(p)
 
     return p
 
@@ -1364,23 +1589,21 @@ def plot_rt_correction(
     if getattr(p, "legend", None) and len(p.legend) > 0:
         p.legend.visible = False
 
-    if filename:
-        if filename.endswith(".html"):
-            output_file(filename)
-            show(p)
-        elif filename.endswith(".png"):
-            try:
-                from bokeh.io.export import export_png
-
-                export_png(p, filename=filename)
-            except Exception:
-                output_file(filename.replace(".png", ".html"))
-                show(p)
-        else:
-            output_file(filename)
-            show(p)
+    # Apply consistent save/display behavior
+    if filename is not None:
+        # Convert relative paths to absolute paths using study folder as base
+        import os
+        if not os.path.isabs(filename):
+            filename = os.path.join(self.folder, filename)
+        
+        # Convert to absolute path for logging
+        abs_filename = os.path.abspath(filename)
+        
+        # Use isolated file saving
+        _isolated_save_plot(p, filename, abs_filename, self.logger, "RT Correction Plot")
     else:
-        show(p)
+        # Show in notebook when no filename provided
+        _isolated_show_notebook(p)
 
     return p
 
@@ -1411,8 +1634,9 @@ def plot_chrom(
         return
 
     # Create color mapping by getting sample_color for each sample_name
-    samples_info = self.samples_df.select(["sample_name", "sample_color"]).to_dict(as_series=False)
+    samples_info = self.samples_df.select(["sample_name", "sample_color", "sample_uid"]).to_dict(as_series=False)
     sample_name_to_color = dict(zip(samples_info["sample_name"], samples_info["sample_color"]))
+    sample_name_to_uid = dict(zip(samples_info["sample_name"], samples_info["sample_uid"]))
     color_map = {name: sample_name_to_color.get(name, "#1f77b4") for name in sample_names}  # fallback to blue
 
     plots = []
@@ -1468,9 +1692,31 @@ def plot_chrom(
                     sorted_indices = np.argsort(rt)
                     rt = rt[sorted_indices]
                     inty = inty[sorted_indices]
-                    curve = hv.Curve((rt, inty), kdims=["RT"], vdims=["inty"]).opts(
+                    
+                    # Get sample uid for this sample name
+                    sample_uid = sample_name_to_uid.get(sample, None)
+                    sample_color = color_map.get(sample, "#1f77b4")
+                    
+                    # Create arrays with sample information for hover tooltips
+                    sample_names_array = [sample] * len(rt)
+                    sample_uids_array = [sample_uid] * len(rt)
+                    sample_colors_array = [sample_color] * len(rt)
+                    
+                    curve = hv.Curve(
+                        (rt, inty, sample_names_array, sample_uids_array, sample_colors_array), 
+                        kdims=["RT"], 
+                        vdims=["inty", "sample_name", "sample_uid", "sample_color"]
+                    ).opts(
                         color=color_map[sample],
                         line_width=1,
+                        tools=["hover"],
+                        hover_tooltips=[
+                            ("RT", "@RT{0.00}"),
+                            ("Intensity", "@inty{0,0}"),
+                            ("Sample Name", "@sample_name"),
+                            ("Sample UID", "@sample_uid"),
+                            ("Sample Color", "$color[swatch]:sample_color")
+                        ]
                     )
                     curves.append(curve)
 
@@ -1529,23 +1775,30 @@ def plot_chrom(
     # stack vertically.
     # Stack all plots vertically in a Panel column
     layout = panel.Column(*[panel.panel(plot) for plot in plots])
+    
+    # Apply consistent save/display behavior
     if filename is not None:
-        if filename.endswith(".html"):
-            panel.panel(layout).save(filename, embed=True)  # type: ignore[attr-defined]
-        else:
-            # Save as PNG using Panel's export_png if filename ends with .png
-            if filename.endswith(".png"):
-                from panel.io.save import save_png
-
-                # Convert Holoviews overlays to Bokeh models before saving
-                bokeh_layout = panel.panel(layout).get_root()  # type: ignore[attr-defined]
-                save_png(bokeh_layout, filename=filename)
-            else:
-                panel.panel(layout).save(filename, embed=True)  # type: ignore[attr-defined]
+        # Convert relative paths to absolute paths using study folder as base
+        import os
+        if not os.path.isabs(filename):
+            filename = os.path.join(self.folder, filename)
+        
+        # Convert to absolute path for logging
+        abs_filename = os.path.abspath(filename)
+        
+        # Use isolated Panel saving
+        _isolated_save_panel_plot(panel.panel(layout), filename, abs_filename, self.logger, "Chromatogram Plot")
     else:
-        # In a server context, return the panel object instead of showing or saving directly
-        # return panel.panel(layout)
-        panel.panel(layout).show()
+        # Show in notebook when no filename provided
+        # Convert Panel layout to Bokeh layout for consistent isolated display
+        try:
+            panel_obj = panel.panel(layout)
+            bokeh_layout = panel_obj.get_root()
+            # Use the regular isolated show method for Bokeh objects
+            _isolated_show_notebook(bokeh_layout)
+        except Exception:
+            # Fallback to Panel display if conversion fails
+            _isolated_show_panel_notebook(panel.panel(layout))
 
 
 def plot_consensus_stats(
@@ -1772,11 +2025,21 @@ def plot_consensus_stats(
     if hasattr(grid, "border_fill_color"):
         grid.border_fill_color = "white"
 
-    # Output and show
-    if filename:
-        output_file(filename)
-
-    show(grid)
+    # Apply consistent save/display behavior
+    if filename is not None:
+        # Convert relative paths to absolute paths using study folder as base
+        import os
+        if not os.path.isabs(filename):
+            filename = os.path.join(self.folder, filename)
+        
+        # Convert to absolute path for logging
+        abs_filename = os.path.abspath(filename)
+        
+        # Use isolated file saving
+        _isolated_save_plot(grid, filename, abs_filename, self.logger, "Consensus Stats Plot")
+    else:
+        # Show in notebook when no filename provided
+        _isolated_show_notebook(grid)
     return grid
 
 
@@ -1808,6 +2071,7 @@ def plot_pca(
     from bokeh.plotting import figure, show, output_file
     from bokeh.palettes import Category20, viridis
     from bokeh.transform import factor_cmap
+    from bokeh.io.export import export_png
     from sklearn.decomposition import PCA
     from sklearn.preprocessing import StandardScaler
     import pandas as pd
@@ -1831,21 +2095,22 @@ def plot_pca(
 
     self.logger.debug(f"Performing PCA on consensus matrix with shape: {consensus_matrix.shape}")
 
-    # Convert consensus matrix to numpy - handle both Polars and pandas DataFrames
-    if hasattr(consensus_matrix, "to_numpy"):
-        # Polars or pandas DataFrame
-        if hasattr(consensus_matrix, "select"):
-            # Polars DataFrame - exclude the consensus_uid column
-            numeric_cols = [col for col in consensus_matrix.columns if col != "consensus_uid"]
-            matrix_data = consensus_matrix.select(numeric_cols).to_numpy()
-        else:
-            # Pandas DataFrame
-            matrix_data = consensus_matrix.to_numpy()
-    elif hasattr(consensus_matrix, "values"):
-        # Pandas DataFrame
-        matrix_data = consensus_matrix.values
+    # Extract only the sample columns (exclude consensus_uid column)
+    sample_cols = [col for col in consensus_matrix.columns if col != "consensus_uid"]
+    
+    # Convert consensus matrix to numpy, excluding the consensus_uid column
+    if hasattr(consensus_matrix, "select"):
+        # Polars DataFrame
+        matrix_data = consensus_matrix.select(sample_cols).to_numpy()
     else:
-        matrix_data = np.array(consensus_matrix)
+        # Pandas DataFrame or other - drop consensus_uid column
+        matrix_sample_data = consensus_matrix.drop(columns=["consensus_uid"], errors="ignore")
+        if hasattr(matrix_sample_data, "values"):
+            matrix_data = matrix_sample_data.values
+        elif hasattr(matrix_sample_data, "to_numpy"):
+            matrix_data = matrix_sample_data.to_numpy()
+        else:
+            matrix_data = np.array(matrix_sample_data)
 
     # Transpose matrix so samples are rows and features are columns
     matrix_data = matrix_data.T
@@ -2024,11 +2289,21 @@ def plot_pca(
             p.legend.location = "top_left"
             p.legend.click_policy = "hide"
 
-    # Output and show
-    if filename:
-        output_file(filename)
-
-    show(p)
+    # Apply consistent save/display behavior
+    if filename is not None:
+        # Convert relative paths to absolute paths using study folder as base
+        import os
+        if not os.path.isabs(filename):
+            filename = os.path.join(self.folder, filename)
+        
+        # Convert to absolute path for logging
+        abs_filename = os.path.abspath(filename)
+        
+        # Use isolated file saving
+        _isolated_save_plot(p, filename, abs_filename, self.logger, "PCA Plot")
+    else:
+        # Show in notebook when no filename provided
+        _isolated_show_notebook(p)
     return p
 
 
@@ -2168,20 +2443,20 @@ def plot_tic(
     if getattr(p, "legend", None) and len(p.legend) > 0:
         p.legend.visible = False
 
-    if filename:
-        if filename.endswith(".html"):
-            output_file(filename)
-            show(p)
-        elif filename.endswith(".png"):
-            try:
-                export_png(p, filename=filename)
-            except Exception:
-                output_file(filename.replace(".png", ".html"))
-                show(p)
-        else:
-            output_file(filename)
-            show(p)
+    # Apply consistent save/display behavior
+    if filename is not None:
+        # Convert relative paths to absolute paths using study folder as base
+        import os
+        if not os.path.isabs(filename):
+            filename = os.path.join(self.folder, filename)
+        
+        # Convert to absolute path for logging
+        abs_filename = os.path.abspath(filename)
+        
+        # Use isolated file saving
+        _isolated_save_plot(p, filename, abs_filename, self.logger, "TIC Plot")
     else:
-        show(p)
+        # Show in notebook when no filename provided
+        _isolated_show_notebook(p)
 
     return p