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

masster/study/plot.py

@@ -17,7 +17,222 @@ hv.extension("bokeh")
 from bokeh.layouts import row as bokeh_row
 
 
-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):
+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,
+):
     """Visualize retention time alignment using two synchronized Bokeh scatter plots.
 
     - When ``maps=True`` the function reads ``self.features_maps`` (list of FeatureMap)
@@ -26,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.
@@ -44,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]] = []
@@ -59,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]
@@ -92,20 +314,43 @@ 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
-        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()
-            ref_sample_uid = samples_info.iloc[0]['sample_uid'] if 'sample_uid' in samples_info.columns else 'Reference_UID'
-            ref_sample_name = samples_info.iloc[0]['sample_name'] if 'sample_name' in samples_info.columns else 'Reference'
+        # 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():
+            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"
+            )
+            ref_sample_name = (
+                samples_info.iloc[0]["sample_name"] if "sample_name" in samples_info.columns else "Reference"
+            )
         else:
-            ref_sample_uid = 'Reference_UID'
-            ref_sample_name = 'Reference'
+            ref_sample_uid = "Reference_UID"
+            ref_sample_name = "Reference"
 
         for rt, mz, inty in zip(ref_rt, ref_mz, ref_inty):
-            before_data.append({'rt': rt, 'mz': mz, 'inty': inty, 'alpha': inty / max_ref_inty, 'sample_idx': 0, 'sample_name': ref_sample_name, 'sample_uid': ref_sample_uid, 'size': markersize + 2})
-            after_data.append({'rt': rt, 'mz': mz, 'inty': inty, 'alpha': inty / max_ref_inty, 'sample_idx': 0, 'sample_name': ref_sample_name, 'sample_uid': ref_sample_uid, 'size': markersize + 2})
-
-        # Remaining samples
+            before_data.append({
+                "rt": rt,
+                "mz": mz,
+                "inty": inty,
+                "alpha": inty / max_ref_inty,
+                "sample_idx": 0,
+                "sample_name": ref_sample_name,
+                "sample_uid": ref_sample_uid,
+                "size": markersize + 2,
+            })
+            after_data.append({
+                "rt": rt,
+                "mz": mz,
+                "inty": inty,
+                "alpha": inty / max_ref_inty,
+                "sample_idx": 0,
+                "sample_name": ref_sample_name,
+                "sample_uid": ref_sample_uid,
+                "size": markersize + 2,
+            })
+
+        # Remaining samples - now using filtered feature maps and samples_info
         for sample_idx, fm in enumerate(fmaps[1:], start=1):
             mz_vals = []
             inty_vals = []
@@ -114,7 +359,7 @@ def plot_alignment(self, maps: bool = True, samples: int | list[int | str] | Non
 
             for f in fm:
                 try:
-                    orig = f.getMetaValue('original_RT')
+                    orig = f.getMetaValue("original_RT")
                 except Exception:
                     orig = None
 
@@ -132,23 +377,48 @@ def plot_alignment(self, maps: bool = True, samples: int | list[int | str] | Non
 
             max_inty = max(inty_vals)
 
-            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):
-                    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')
+            # 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():
+                # 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'
+                sample_name = f"Sample {sample_idx}"
+                sample_uid = f"Sample_{sample_idx}_UID"
 
             for rt, mz, inty in zip(original_rt, mz_vals, inty_vals):
-                before_data.append({'rt': rt, 'mz': mz, 'inty': inty, 'alpha': inty / max_inty, 'sample_idx': sample_idx, 'sample_name': sample_name, 'sample_uid': sample_uid, 'size': markersize})
+                before_data.append({
+                    "rt": rt,
+                    "mz": mz,
+                    "inty": inty,
+                    "alpha": inty / max_inty,
+                    "sample_idx": sample_idx,
+                    "sample_name": sample_name,
+                    "sample_uid": sample_uid,
+                    "size": markersize,
+                })
 
             for rt, mz, inty in zip(aligned_rt, mz_vals, inty_vals):
-                after_data.append({'rt': rt, 'mz': mz, 'inty': inty, 'alpha': inty / max_inty, 'sample_idx': sample_idx, 'sample_name': sample_name, 'sample_uid': sample_uid, 'size': markersize})
+                after_data.append({
+                    "rt": rt,
+                    "mz": mz,
+                    "inty": inty,
+                    "alpha": inty / max_inty,
+                    "sample_idx": sample_idx,
+                    "sample_name": sample_name,
+                    "sample_uid": sample_uid,
+                    "size": markersize,
+                })
 
     else:
         # Use features_df
@@ -156,88 +426,83 @@ def plot_alignment(self, maps: bool = True, samples: int | list[int | str] | Non
             self.logger.error("No features_df found. Load features first.")
             return
 
-        required_cols = ['rt', 'mz', 'inty']
+        required_cols = ["rt", "mz", "inty"]
         missing = [c for c in required_cols if c not in self.features_df.columns]
         if missing:
             self.logger.error(f"Missing required columns in features_df: {missing}")
             return
 
-        if 'rt_original' not in self.features_df.columns:
+        if "rt_original" not in self.features_df.columns:
             self.logger.error("Column 'rt_original' not found in features_df. Alignment may not have been performed.")
             return
 
         # 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'
+        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()
 
         for sample_idx, sample in enumerate(samples):
             # Filter sample data using Polars
             sample_data = features_df.filter(pl.col(sample_col) == sample)
-            
+
             # Calculate max intensity using Polars
-            max_inty = sample_data.select(pl.col('inty').max()).item()
+            max_inty = sample_data.select(pl.col("inty").max()).item()
             max_inty = max_inty if max_inty and max_inty > 0 else 1
-            
+
             sample_name = str(sample)
             # Get sample_uid - if sample_col is 'sample_uid', use sample directly
-            if sample_col == 'sample_uid':
+            if sample_col == "sample_uid":
                 sample_uid = sample
             else:
                 # Try to get sample_uid from the first row if it exists
-                if 'sample_uid' in sample_data.columns:
-                    sample_uid = sample_data.select(pl.col('sample_uid')).item()
+                if "sample_uid" in sample_data.columns:
+                    sample_uid = sample_data.select(pl.col("sample_uid")).item()
                 else:
                     sample_uid = sample
 
             # Convert to dict for iteration - more efficient than row-by-row processing
-            sample_dict = sample_data.select(['rt_original', 'rt', 'mz', 'inty']).to_dicts()
-            
+            sample_dict = sample_data.select(["rt_original", "rt", "mz", "inty"]).to_dicts()
+
             for row_dict in sample_dict:
-                rt_original = row_dict['rt_original']
-                rt_current = row_dict['rt']
-                mz = row_dict['mz']
-                inty = row_dict['inty']
+                rt_original = row_dict["rt_original"]
+                rt_current = row_dict["rt"]
+                mz = row_dict["mz"]
+                inty = row_dict["inty"]
                 alpha = inty / max_inty
                 size = markersize + 2 if sample_idx == 0 else markersize
-                
+
                 before_data.append({
-                    'rt': rt_original, 'mz': mz, 'inty': inty, 'alpha': alpha, 
-                    'sample_idx': sample_idx, 'sample_name': sample_name, 
-                    'sample_uid': sample_uid, 'size': size
+                    "rt": rt_original,
+                    "mz": mz,
+                    "inty": inty,
+                    "alpha": alpha,
+                    "sample_idx": sample_idx,
+                    "sample_name": sample_name,
+                    "sample_uid": sample_uid,
+                    "size": size,
                 })
                 after_data.append({
-                    'rt': rt_current, 'mz': mz, 'inty': inty, 'alpha': alpha, 
-                    'sample_idx': sample_idx, 'sample_name': sample_name, 
-                    'sample_uid': sample_uid, 'size': size
+                    "rt": rt_current,
+                    "mz": mz,
+                    "inty": inty,
+                    "alpha": alpha,
+                    "sample_idx": sample_idx,
+                    "sample_name": sample_name,
+                    "sample_uid": sample_uid,
+                    "size": size,
                 })
 
     # Get sample colors from samples_df using sample indices
@@ -246,17 +511,16 @@ def plot_alignment(self, maps: bool = True, samples: int | list[int | str] | Non
         # Create mapping from sample_idx to sample_uid more efficiently
         sample_idx_to_uid = {}
         for item in before_data:
-            if item['sample_idx'] not in sample_idx_to_uid:
-                sample_idx_to_uid[item['sample_idx']] = item['sample_uid']
+            if item["sample_idx"] not in sample_idx_to_uid:
+                sample_idx_to_uid[item["sample_idx"]] = item["sample_uid"]
     else:
         sample_idx_to_uid = {}
-    
+
     # Get colors from samples_df
     sample_uids_list = list(sample_idx_to_uid.values())
-    if sample_uids_list and hasattr(self, 'samples_df') and self.samples_df is not None:
+    if sample_uids_list and hasattr(self, "samples_df") and self.samples_df is not None:
         sample_colors = (
-            self.samples_df
-            .filter(pl.col("sample_uid").is_in(sample_uids_list))
+            self.samples_df.filter(pl.col("sample_uid").is_in(sample_uids_list))
             .select(["sample_uid", "sample_color"])
             .to_dict(as_series=False)
         )
@@ -272,69 +536,112 @@ def plot_alignment(self, maps: bool = True, samples: int | list[int | str] | Non
     # Add sample_color to data dictionaries before creating DataFrames
     if before_data:
         for item in before_data:
-            item['sample_color'] = color_map.get(item['sample_idx'], '#1f77b4')
-    
+            item["sample_color"] = color_map.get(item["sample_idx"], "#1f77b4")
+
     if after_data:
         for item in after_data:
-            item['sample_color'] = color_map.get(item['sample_idx'], '#1f77b4')
-    
+            item["sample_color"] = color_map.get(item["sample_idx"], "#1f77b4")
+
     # Now create DataFrames with the sample_color already included
     before_df = pd.DataFrame(before_data) if before_data else pd.DataFrame()
     after_df = pd.DataFrame(after_data) if after_data else pd.DataFrame()
 
     # Create Bokeh figures
-    p1 = figure(width=width, height=height, title='Original RT', x_axis_label='Retention Time (s)', y_axis_label='m/z', tools='pan,wheel_zoom,box_zoom,reset,save')
+    p1 = figure(
+        width=width,
+        height=height,
+        title="Original RT",
+        x_axis_label="Retention Time (s)",
+        y_axis_label="m/z",
+        tools="pan,wheel_zoom,box_zoom,reset,save",
+    )
     p1.outline_line_color = None
-    p1.background_fill_color = 'white'
-    p1.border_fill_color = 'white'
+    p1.background_fill_color = "white"
+    p1.border_fill_color = "white"
     p1.min_border = 0
 
-    p2 = figure(width=width, height=height, title='Current RT', x_axis_label='Retention Time (s)', y_axis_label='m/z', tools='pan,wheel_zoom,box_zoom,reset,save', x_range=p1.x_range, y_range=p1.y_range)
+    p2 = figure(
+        width=width,
+        height=height,
+        title="Current RT",
+        x_axis_label="Retention Time (s)",
+        y_axis_label="m/z",
+        tools="pan,wheel_zoom,box_zoom,reset,save",
+        x_range=p1.x_range,
+        y_range=p1.y_range,
+    )
     p2.outline_line_color = None
-    p2.background_fill_color = 'white'
-    p2.border_fill_color = 'white'
+    p2.background_fill_color = "white"
+    p2.border_fill_color = "white"
     p2.min_border = 0
-    
+
     # Get unique sample indices for iteration
-    unique_samples = sorted(list(set(item['sample_idx'] for item in before_data))) if before_data else []
+    unique_samples = sorted(list({item["sample_idx"] for item in before_data})) if before_data else []
 
     renderers_before = []
     renderers_after = []
 
     for sample_idx in unique_samples:
-        sb = before_df[before_df['sample_idx'] == sample_idx]
-        sa = after_df[after_df['sample_idx'] == sample_idx]
-        color = color_map.get(sample_idx, '#000000')
+        sb = before_df[before_df["sample_idx"] == sample_idx]
+        sa = after_df[after_df["sample_idx"] == sample_idx]
+        color = color_map.get(sample_idx, "#000000")
 
         if not sb.empty:
             src = ColumnDataSource(sb)
-            r = p1.scatter('rt', 'mz', size='size', color=color, alpha='alpha', source=src)
+            r = p1.scatter("rt", "mz", size="size", color=color, alpha="alpha", source=src)
             renderers_before.append(r)
 
         if not sa.empty:
             src = ColumnDataSource(sa)
-            r = p2.scatter('rt', 'mz', size='size', color=color, alpha='alpha', source=src)
+            r = p2.scatter("rt", "mz", size="size", color=color, alpha="alpha", source=src)
             renderers_after.append(r)
 
     # Add hover tools
-    hover1 = HoverTool(tooltips=[('Sample UID', '@sample_uid'), ('Sample Name', '@sample_name'), ('Sample Color', '$color[swatch]:sample_color'), ('RT', '@rt{0.00}'), ('m/z', '@mz{0.0000}'), ('Intensity', '@inty{0.0e0}')], renderers=renderers_before)
+    hover1 = HoverTool(
+        tooltips=[
+            ("Sample UID", "@sample_uid"),
+            ("Sample Name", "@sample_name"),
+            ("Sample Color", "$color[swatch]:sample_color"),
+            ("RT", "@rt{0.00}"),
+            ("m/z", "@mz{0.0000}"),
+            ("Intensity", "@inty{0.0e0}"),
+        ],
+        renderers=renderers_before,
+    )
     p1.add_tools(hover1)
 
-    hover2 = HoverTool(tooltips=[('Sample UID', '@sample_uid'), ('Sample Name', '@sample_name'), ('Sample Color', '$color[swatch]:sample_color'), ('RT', '@rt{0.00}'), ('m/z', '@mz{0.0000}'), ('Intensity', '@inty{0.0e0}')], renderers=renderers_after)
+    hover2 = HoverTool(
+        tooltips=[
+            ("Sample UID", "@sample_uid"),
+            ("Sample Name", "@sample_name"),
+            ("Sample Color", "$color[swatch]:sample_color"),
+            ("RT", "@rt{0.00}"),
+            ("m/z", "@mz{0.0000}"),
+            ("Intensity", "@inty{0.0e0}"),
+        ],
+        renderers=renderers_after,
+    )
     p2.add_tools(hover2)
 
     # Create layout with both plots side by side
     # 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)
+    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
 
@@ -439,20 +746,21 @@ 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]
     except ImportError:
         from bokeh.models.annotations import ColorBar
     from bokeh.palettes import viridis
-    
+
     # Import cmap for colormap handling
     from cmap import Colormap
 
     # Convert Polars DataFrame to pandas for Bokeh compatibility
     data_pd = data.to_pandas()
     source = ColumnDataSource(data_pd)
-    
+
     # Handle colormap using cmap.Colormap
     try:
         # Get colormap palette using cmap
@@ -461,6 +769,7 @@ def plot_consensus_2d(
             # Generate 256 colors and convert to hex
             import numpy as np
             import matplotlib.colors as mcolors
+
             colors = colormap(np.linspace(0, 1, 256))
             palette = [mcolors.rgb2hex(color) for color in colors]
         else:
@@ -473,19 +782,21 @@ def plot_consensus_2d(
                     # Fall back to generating colors manually
                     import numpy as np
                     import matplotlib.colors as mcolors
+
                     colors = colormap(np.linspace(0, 1, 256))
                     palette = [mcolors.rgb2hex(color) for color in colors]
             except AttributeError:
                 # Fall back to generating colors manually
                 import numpy as np
                 import matplotlib.colors as mcolors
+
                 colors = colormap(np.linspace(0, 1, 256))
                 palette = [mcolors.rgb2hex(color) for color in colors]
     except (AttributeError, ValueError, TypeError) as e:
         # Fallback to viridis if cmap interpretation fails
         self.logger.warning(f"Could not interpret colormap '{cmap}': {e}, falling back to viridis")
         palette = viridis(256)
-    
+
     color_mapper = LinearColorMapper(
         palette=palette,
         low=data[colorby].min(),
@@ -549,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
 
 
@@ -603,8 +925,7 @@ def plot_samples_2d(
 
     # Get sample colors from samples_df
     sample_colors = (
-        self.samples_df
-        .filter(pl.col("sample_uid").is_in(sample_uids))
+        self.samples_df.filter(pl.col("sample_uid").is_in(sample_uids))
         .select(["sample_uid", "sample_color"])
         .to_dict(as_series=False)
     )
@@ -770,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
 
 
@@ -794,7 +1120,7 @@ def plot_bpc(
     original: bool = False,
 ):
     """
-    Plot Base Peak Chromatograms (BPC) for selected samples overlayed using Bokeh.
+    Plot Base Peak Chromatograms (BPC) for selected samples overlaid using Bokeh.
 
     This collects per-sample BPCs via `get_bpc(self, sample=uid)` and overlays them.
     Colors are mapped per-sample using the same Turbo256 palette as `plot_samples_2d`.
@@ -818,8 +1144,7 @@ def plot_bpc(
 
     # Get sample colors from samples_df
     sample_colors = (
-        self.samples_df
-        .filter(pl.col("sample_uid").is_in(sample_uids))
+        self.samples_df.filter(pl.col("sample_uid").is_in(sample_uids))
         .select(["sample_uid", "sample_color"])
         .to_dict(as_series=False)
     )
@@ -836,7 +1161,7 @@ def plot_bpc(
     for uid in sample_uids:
         try:
             first_chrom = get_bpc(self, sample=uid, label=None, original=original)
-            if hasattr(first_chrom, 'rt_unit'):
+            if hasattr(first_chrom, "rt_unit"):
                 rt_unit = first_chrom.rt_unit
                 break
         except Exception:
@@ -867,7 +1192,11 @@ def plot_bpc(
         # extract arrays
         try:
             # prefer Chromatogram API
-            chrom_dict = chrom.to_dict() if hasattr(chrom, "to_dict") else {"rt": getattr(chrom, "rt"), "inty": getattr(chrom, "inty")}
+            chrom_dict = (
+                chrom.to_dict()
+                if hasattr(chrom, "to_dict")
+                else {"rt": getattr(chrom, "rt"), "inty": getattr(chrom, "inty")}
+            )
             rt = chrom_dict.get("rt")
             inty = chrom_dict.get("inty")
         except Exception:
@@ -907,7 +1236,7 @@ def plot_bpc(
 
         # Debug: log sample processing details
         self.logger.debug(
-            f"Processing BPC for sample_uid={uid}, sample_name={sample_name}, rt_len={rt.size}, color={color}"
+            f"Processing BPC for sample_uid={uid}, sample_name={sample_name}, rt_len={rt.size}, color={color}",
         )
 
         data = {"rt": rt, "inty": inty, "sample": [sample_name] * len(rt), "sample_color": [color] * len(rt)}
@@ -921,29 +1250,36 @@ def plot_bpc(
         self.logger.warning("No BPC curves to plot for the selected samples.")
         return
 
-    hover = HoverTool(tooltips=[("sample", "@sample"), ("sample_color", "$color[swatch]:sample_color"), ("rt", "@rt{0.00}"), ("inty", "@inty{0.00e0}")], renderers=renderers)
+    hover = HoverTool(
+        tooltips=[
+            ("sample", "@sample"),
+            ("sample_color", "$color[swatch]:sample_color"),
+            ("rt", "@rt{0.00}"),
+            ("inty", "@inty{0.00e0}"),
+        ],
+        renderers=renderers,
+    )
     p.add_tools(hover)
 
     # 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"):
-            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
 
@@ -990,8 +1326,7 @@ def plot_eic(
 
     # Get sample colors from samples_df
     sample_colors = (
-        self.samples_df
-        .filter(pl.col("sample_uid").is_in(sample_uids))
+        self.samples_df.filter(pl.col("sample_uid").is_in(sample_uids))
         .select(["sample_uid", "sample_color"])
         .to_dict(as_series=False)
     )
@@ -1004,7 +1339,7 @@ def plot_eic(
     for uid in sample_uids:
         try:
             first_chrom = get_eic(self, sample=uid, mz=mz, mz_tol=mz_tol, label=None)
-            if hasattr(first_chrom, 'rt_unit'):
+            if hasattr(first_chrom, "rt_unit"):
                 rt_unit = first_chrom.rt_unit
                 break
         except Exception:
@@ -1035,7 +1370,11 @@ def plot_eic(
         # extract arrays
         try:
             # prefer Chromatogram API
-            chrom_dict = chrom.to_dict() if hasattr(chrom, "to_dict") else {"rt": getattr(chrom, "rt"), "inty": getattr(chrom, "inty")}
+            chrom_dict = (
+                chrom.to_dict()
+                if hasattr(chrom, "to_dict")
+                else {"rt": getattr(chrom, "rt"), "inty": getattr(chrom, "inty")}
+            )
             rt = chrom_dict.get("rt")
             inty = chrom_dict.get("inty")
         except Exception:
@@ -1083,27 +1422,35 @@ def plot_eic(
         self.logger.warning("No EIC curves to plot for the selected samples.")
         return
 
-    hover = HoverTool(tooltips=[("sample", "@sample"), ("sample_color", "$color[swatch]:sample_color"), ("rt", "@rt{0.00}"), ("inty", "@inty{0.0e0}")], renderers=renderers)
+    hover = HoverTool(
+        tooltips=[
+            ("sample", "@sample"),
+            ("sample_color", "$color[swatch]:sample_color"),
+            ("rt", "@rt{0.00}"),
+            ("inty", "@inty{0.0e0}"),
+        ],
+        renderers=renderers,
+    )
     p.add_tools(hover)
 
     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
 
@@ -1117,7 +1464,7 @@ def plot_rt_correction(
     height: int = 300,
 ):
     """
-    Plot RT correction per sample: (rt - rt_original) vs rt overlayed for selected samples.
+    Plot RT correction per sample: (rt - rt_original) vs rt overlaid for selected samples.
 
     This uses the same color mapping as `plot_bpc` so curves for the same samples match.
     """
@@ -1141,8 +1488,7 @@ def plot_rt_correction(
 
     # Get sample colors from samples_df
     sample_colors = (
-        self.samples_df
-        .filter(pl.col("sample_uid").is_in(sample_uids))
+        self.samples_df.filter(pl.col("sample_uid").is_in(sample_uids))
         .select(["sample_uid", "sample_color"])
         .to_dict(as_series=False)
     )
@@ -1228,30 +1574,36 @@ def plot_rt_correction(
         self.logger.warning("No RT correction curves to plot for the selected samples.")
         return
 
-    hover = HoverTool(tooltips=[("sample", "@sample"), ("sample_color", "$color[swatch]:sample_color"), ("rt", "@rt{0.00}"), ("rt - rt_original", "@delta{0.00}")], renderers=renderers)
+    hover = HoverTool(
+        tooltips=[
+            ("sample", "@sample"),
+            ("sample_color", "$color[swatch]:sample_color"),
+            ("rt", "@rt{0.00}"),
+            ("rt - rt_original", "@delta{0.00}"),
+        ],
+        renderers=renderers,
+    )
     p.add_tools(hover)
 
     # 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"):
-            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
 
@@ -1280,10 +1632,11 @@ def plot_chrom(
     if not sample_names:
         self.logger.error("No sample names found in chromatogram data.")
         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 = []
@@ -1339,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)
 
@@ -1400,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(
@@ -1643,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
 
 
@@ -1679,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
@@ -1702,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
@@ -1753,7 +2147,7 @@ def plot_pca(
     else:
         self.logger.warning(
             f"Sample count mismatch: samples_df has {len(samples_pd)} rows, "
-            f"but consensus matrix has {len(pca_df)} samples"
+            f"but consensus matrix has {len(pca_df)} samples",
         )
 
     # Prepare color mapping
@@ -1824,25 +2218,23 @@ def plot_pca(
         if "sample_uid" in pca_df.columns or "sample_name" in pca_df.columns:
             # Choose the identifier to map colors by
             id_col = "sample_uid" if "sample_uid" in pca_df.columns else "sample_name"
-            
+
             # Get colors from samples_df based on the identifier
             if id_col == "sample_uid":
                 sample_colors = (
-                    self.samples_df
-                    .filter(pl.col("sample_uid").is_in(pca_df[id_col].unique()))
+                    self.samples_df.filter(pl.col("sample_uid").is_in(pca_df[id_col].unique()))
                     .select(["sample_uid", "sample_color"])
                     .to_dict(as_series=False)
                 )
                 color_map = dict(zip(sample_colors["sample_uid"], sample_colors["sample_color"]))
             else:  # sample_name
                 sample_colors = (
-                    self.samples_df
-                    .filter(pl.col("sample_name").is_in(pca_df[id_col].unique()))
+                    self.samples_df.filter(pl.col("sample_name").is_in(pca_df[id_col].unique()))
                     .select(["sample_name", "sample_color"])
                     .to_dict(as_series=False)
                 )
                 color_map = dict(zip(sample_colors["sample_name"], sample_colors["sample_color"]))
-            
+
             # Map colors into dataframe
             pca_df["color"] = [color_map.get(x, "#1f77b4") for x in pca_df[id_col]]  # fallback to blue
             # Update the ColumnDataSource with new color column
@@ -1878,7 +2270,7 @@ def plot_pca(
         if col in pca_df.columns:
             if col == "sample_color":
                 # Display sample_color as a colored swatch
-                tooltip_list.append(('color', "$color[swatch]:sample_color"))
+                tooltip_list.append(("color", "$color[swatch]:sample_color"))
             elif pca_df[col].dtype in ["float64", "float32"]:
                 tooltip_list.append((col, f"@{col}{{0.00}}"))
             else:
@@ -1897,13 +2289,24 @@ 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
 
+
 def plot_tic(
     self,
     samples=None,
@@ -1914,7 +2317,7 @@ def plot_tic(
     original: bool = False,
 ):
     """
-    Plot Total Ion Chromatograms (TIC) for selected samples overlayed using Bokeh.
+    Plot Total Ion Chromatograms (TIC) for selected samples overlaid using Bokeh.
 
     Parameters and behavior mirror `plot_bpc` but use per-sample TICs (get_tic).
     """
@@ -1931,8 +2334,7 @@ def plot_tic(
 
     # Get sample colors from samples_df
     sample_colors = (
-        self.samples_df
-        .filter(pl.col("sample_uid").is_in(sample_uids))
+        self.samples_df.filter(pl.col("sample_uid").is_in(sample_uids))
         .select(["sample_uid", "sample_color"])
         .to_dict(as_series=False)
     )
@@ -1945,7 +2347,7 @@ def plot_tic(
     for uid in sample_uids:
         try:
             first_chrom = get_tic(self, sample=uid, label=None)
-            if hasattr(first_chrom, 'rt_unit'):
+            if hasattr(first_chrom, "rt_unit"):
                 rt_unit = first_chrom.rt_unit
                 break
         except Exception:
@@ -1974,7 +2376,11 @@ def plot_tic(
 
         # extract arrays
         try:
-            chrom_dict = chrom.to_dict() if hasattr(chrom, "to_dict") else {"rt": getattr(chrom, "rt"), "inty": getattr(chrom, "inty")}
+            chrom_dict = (
+                chrom.to_dict()
+                if hasattr(chrom, "to_dict")
+                else {"rt": getattr(chrom, "rt"), "inty": getattr(chrom, "inty")}
+            )
             rt = chrom_dict.get("rt")
             inty = chrom_dict.get("inty")
         except Exception:
@@ -2022,27 +2428,35 @@ def plot_tic(
         self.logger.warning("No TIC curves to plot for the selected samples.")
         return
 
-    hover = HoverTool(tooltips=[("sample", "@sample"), ("sample_color", "$color[swatch]:sample_color"), ("rt", "@rt{0.00}"), ("inty", "@inty{0.00e0}")], renderers=renderers)
+    hover = HoverTool(
+        tooltips=[
+            ("sample", "@sample"),
+            ("sample_color", "$color[swatch]:sample_color"),
+            ("rt", "@rt{0.00}"),
+            ("inty", "@inty{0.00e0}"),
+        ],
+        renderers=renderers,
+    )
     p.add_tools(hover)
 
     # 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"):
-            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