masster 0.4.0__py3-none-any.whl → 0.4.1__py3-none-any.whl

masster/study/plot.py

@@ -26,71 +26,65 @@ def _isolated_save_plot(plot_object, filename, abs_filename, logger, plot_title=
         # 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")
+        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:
+        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")
+            html_filename = filename.replace('.png', '.html')
             from bokeh.resources import Resources
             from bokeh.embed import file_html
-
-            resources = Resources(mode="cdn")
+            
+            resources = Resources(mode='cdn')
             html = file_html(plot_object, resources, title=plot_title)
-
-            with open(html_filename, "w", encoding="utf-8") as f:
+            
+            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}",
-            )
+                
+            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")
+            html_filename = filename.replace('.pdf', '.html')
             from bokeh.resources import Resources
             from bokeh.embed import file_html
-
-            resources = Resources(mode="cdn")
+            
+            resources = Resources(mode='cdn')
             html = file_html(plot_object, resources, title=plot_title)
-
-            with open(html_filename, "w", encoding="utf-8") as f:
+            
+            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}",
-            )
+                
+            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")
+        
+        resources = Resources(mode='cdn')
         html = file_html(plot_object, resources, title=plot_title)
-
-        with open(filename, "w", encoding="utf-8") as f:
+        
+        with open(filename, 'w', encoding='utf-8') as f:
             f.write(html)
-
+            
         logger.info(f"Plot saved to: {abs_filename}")
 
 
@@ -103,36 +97,28 @@ def _isolated_show_notebook(plot_object):
     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")
+    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,
-        )
-
+        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")
-
+            
+            # Reset Holoviews to notebook mode  
+            hv.extension('bokeh', logo=False)
+            hv.output(backend='bokeh', mode='jupyter')
+            
             # Show in notebook
             show(plot_object)
         finally:
@@ -143,16 +129,16 @@ def _isolated_show_notebook(plot_object):
 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
+        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:
@@ -161,44 +147,38 @@ def _isolated_save_panel_plot(panel_obj, filename, abs_filename, logger, plot_ti
             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")
+            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}",
-                )
+                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")
+            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}",
-                )
+                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:
@@ -213,33 +193,31 @@ def _isolated_save_panel_plot(panel_obj, filename, abs_filename, logger, plot_ti
 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 on.extension and display inline
-    import panel as on
-
+    
+    # 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
-        on.extension("bokeh", inline=True, comms="vscode")
+        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
@@ -274,7 +252,7 @@ def plot_alignment(
     """
     # Local imports so the module can be used even if bokeh isn't needed elsewhere
     from bokeh.models import ColumnDataSource, HoverTool
-    from bokeh.plotting import figure
+    from bokeh.plotting import figure, show, output_file
     import pandas as pd
 
     # Get sample_uids to filter by if specified
@@ -298,42 +276,32 @@ def plot_alignment(
         # 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()
-            ):
+            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()
-
+                
                 # Filter samples_info to only selected sample_uids and get their map_ids
-                selected_samples = samples_info[
-                    samples_info["sample_uid"].isin(sample_uids)
-                ]
+                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.",
-                    )
+                    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:
-                self.logger.warning(
-                    "Cannot filter feature maps: no samples_df available",
-                )
+                self.logger.warning("Cannot filter feature maps: no samples_df available")
 
         if not fmaps:
             self.logger.error("No feature maps available after filtering.")
@@ -347,52 +315,40 @@ def plot_alignment(
         max_ref_inty = max(ref_inty) if ref_inty else 1
 
         # 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():
+        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"
+                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"
+                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"
 
         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,
-                },
-            )
+            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):
@@ -422,33 +378,17 @@ def plot_alignment(
             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()
-            ):
+            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",
-                    )
+                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:
                     # 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",
-                        )
+                        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"
@@ -457,32 +397,28 @@ def plot_alignment(
                 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
@@ -497,14 +433,12 @@ def plot_alignment(
             return
 
         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.",
-            )
+            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))
@@ -512,9 +446,7 @@ def plot_alignment(
                 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
@@ -542,9 +474,7 @@ def plot_alignment(
                     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"]
@@ -554,30 +484,26 @@ def plot_alignment(
                 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,
-                    },
-                )
-                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,
-                    },
-                )
+                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,
+                })
+                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,
+                })
 
     # Get sample colors from samples_df using sample indices
     # Extract unique sample information from the dictionaries we created
@@ -598,19 +524,14 @@ def plot_alignment(
             .select(["sample_uid", "sample_color"])
             .to_dict(as_series=False)
         )
-        uid_to_color = dict(
-            zip(sample_colors["sample_uid"], sample_colors["sample_color"]),
-        )
+        uid_to_color = dict(zip(sample_colors["sample_uid"], sample_colors["sample_color"]))
     else:
         uid_to_color = {}
 
     # Create color map for sample indices
     color_map: dict[int, str] = {}
     for sample_idx, sample_uid in sample_idx_to_uid.items():
-        color_map[sample_idx] = uid_to_color.get(
-            sample_uid,
-            "#1f77b4",
-        )  # fallback to blue
+        color_map[sample_idx] = uid_to_color.get(sample_uid, "#1f77b4")  # fallback to blue
 
     # Add sample_color to data dictionaries before creating DataFrames
     if before_data:
@@ -655,11 +576,7 @@ def plot_alignment(
     p2.min_border = 0
 
     # Get unique sample indices for iteration
-    unique_samples = (
-        sorted(list({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 = []
@@ -671,26 +588,12 @@ def plot_alignment(
 
         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
@@ -728,21 +631,14 @@ def plot_alignment(
     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",
-        )
+        _isolated_save_plot(layout, filename, abs_filename, self.logger, "Alignment Plot")
     else:
         # Show in notebook when no filename provided
         _isolated_show_notebook(layout)
@@ -789,13 +685,9 @@ def plot_consensus_2d(
 
     # Filter by mz_range and rt_range if provided
     if mz_range is not None:
-        data = data.filter(
-            (pl.col("mz") >= mz_range[0]) & (pl.col("mz") <= mz_range[1]),
-        )
+        data = data.filter((pl.col("mz") >= mz_range[0]) & (pl.col("mz") <= mz_range[1]))
     if rt_range is not None:
-        data = data.filter(
-            (pl.col("rt") >= rt_range[0]) & (pl.col("rt") <= rt_range[1]),
-        )
+        data = data.filter((pl.col("rt") >= rt_range[0]) & (pl.col("rt") <= rt_range[1]))
 
     if colorby not in data.columns:
         self.logger.error(f"Column {colorby} not found in consensus_df.")
@@ -809,25 +701,19 @@ def plot_consensus_2d(
         if sizeby in ["inty_mean"]:
             # use log10 of sizeby
             # Filter out empty or all-NA entries before applying np.log10
-            data = data.with_columns(
-                [
-                    pl.when(
-                        (pl.col(sizeby).is_not_null())
-                        & (pl.col(sizeby).is_finite())
-                        & (pl.col(sizeby) > 0),
-                    )
-                    .then((pl.col(sizeby).log10() * markersize / 12).pow(2))
-                    .otherwise(markersize)
-                    .alias("markersize"),
-                ],
-            )
+            data = data.with_columns([
+                pl.when(
+                    (pl.col(sizeby).is_not_null()) & (pl.col(sizeby).is_finite()) & (pl.col(sizeby) > 0),
+                )
+                .then((pl.col(sizeby).log10() * markersize / 12).pow(2))
+                .otherwise(markersize)
+                .alias("markersize"),
+            ])
         else:
             max_size = data[sizeby].max()
-            data = data.with_columns(
-                [
-                    (pl.col(sizeby) / max_size * markersize).alias("markersize"),
-                ],
-            )
+            data = data.with_columns([
+                (pl.col(sizeby) / max_size * markersize).alias("markersize"),
+            ])
     else:
         data = data.with_columns([pl.lit(markersize).alias("markersize")])
     # sort by ascending colorby
@@ -835,22 +721,18 @@ def plot_consensus_2d(
     # convert consensus_id to string - check if column exists
     if "consensus_id" in data.columns:
         # Handle Object dtype by converting to string first
-        data = data.with_columns(
-            [
-                pl.col("consensus_id")
-                .map_elements(
-                    lambda x: str(x) if x is not None else None,
-                    return_dtype=pl.Utf8,
-                )
-                .alias("consensus_id"),
-            ],
-        )
+        data = data.with_columns([
+            pl.col("consensus_id")
+            .map_elements(
+                lambda x: str(x) if x is not None else None,
+                return_dtype=pl.Utf8,
+            )
+            .alias("consensus_id"),
+        ])
     elif "consensus_uid" in data.columns:
-        data = data.with_columns(
-            [
-                pl.col("consensus_uid").cast(pl.Utf8).alias("consensus_id"),
-            ],
-        )
+        data = data.with_columns([
+            pl.col("consensus_uid").cast(pl.Utf8).alias("consensus_id"),
+        ])
 
     if cmap is None:
         cmap = "viridis"
@@ -864,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]
@@ -911,9 +794,7 @@ def plot_consensus_2d(
                 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",
-        )
+        self.logger.warning(f"Could not interpret colormap '{cmap}': {e}, falling back to viridis")
         palette = viridis(256)
 
     color_mapper = LinearColorMapper(
@@ -981,13 +862,12 @@ def plot_consensus_2d(
     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, "Consensus 2D Plot")
     else:
@@ -1033,7 +913,8 @@ def plot_samples_2d(
     """
 
     # Local bokeh imports to avoid heavy top-level dependency
-    from bokeh.plotting import figure
+    from bokeh.plotting import figure, show, output_file
+    from bokeh.io.export import export_png
     from bokeh.models import ColumnDataSource, HoverTool
 
     sample_uids = self._get_sample_uids(samples)
@@ -1063,13 +944,9 @@ def plot_samples_2d(
 
     # Filter by mz_range and rt_range if provided
     if mz_range is not None:
-        features_batch = features_batch.filter(
-            (pl.col("mz") >= mz_range[0]) & (pl.col("mz") <= mz_range[1]),
-        )
+        features_batch = features_batch.filter((pl.col("mz") >= mz_range[0]) & (pl.col("mz") <= mz_range[1]))
     if rt_range is not None:
-        features_batch = features_batch.filter(
-            (pl.col("rt") >= rt_range[0]) & (pl.col("rt") <= rt_range[1]),
-        )
+        features_batch = features_batch.filter((pl.col("rt") >= rt_range[0]) & (pl.col("rt") <= rt_range[1]))
 
     if features_batch.is_empty():
         self.logger.error("No features found for the selected samples.")
@@ -1165,11 +1042,7 @@ def plot_samples_2d(
                 "inty": sample_data["inty"].values,
                 "alpha": sample_data["alpha"].values,
                 "sample": np.full(len(sample_data), sample_name, dtype=object),
-                "sample_color": np.full(
-                    len(sample_data),
-                    color_values[uid],
-                    dtype=object,
-                ),
+                "sample_color": np.full(len(sample_data), color_values[uid], dtype=object),
             },
         )
 
@@ -1218,18 +1091,17 @@ 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
-
+    
     # 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:
@@ -1257,9 +1129,10 @@ def plot_bpc(
                          If False (default), return current/aligned RTs.
     """
     # Local imports to avoid heavy top-level deps / circular imports
-    from bokeh.plotting import figure
+    from bokeh.plotting import figure, show, output_file
     from bokeh.models import ColumnDataSource, HoverTool
-    from master.study.helpers import get_bpc
+    from bokeh.io.export import export_png
+    from masster.study.helpers import get_bpc
 
     sample_uids = self._get_sample_uids(samples)
     if not sample_uids:
@@ -1294,12 +1167,7 @@ def plot_bpc(
         except Exception:
             continue
 
-    p = figure(
-        width=width,
-        height=height,
-        title=plot_title,
-        tools="pan,wheel_zoom,box_zoom,reset,save",
-    )
+    p = figure(width=width, height=height, title=plot_title, tools="pan,wheel_zoom,box_zoom,reset,save")
     p.xaxis.axis_label = f"Retention Time ({rt_unit})"
     p.yaxis.axis_label = "Intensity"
 
@@ -1371,22 +1239,10 @@ def plot_bpc(
             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),
-        }
+        data = {"rt": rt, "inty": inty, "sample": [sample_name] * len(rt), "sample_color": [color] * len(rt)}
         src = ColumnDataSource(data)
 
-        r_line = p.line(
-            "rt",
-            "inty",
-            source=src,
-            line_width=1,
-            color=color,
-            legend_label=str(sample_name),
-        )
+        r_line = p.line("rt", "inty", source=src, line_width=1, color=color, legend_label=str(sample_name))
         r_points = p.scatter("rt", "inty", source=src, size=2, color=color, alpha=0.6)
         renderers.append(r_line)
 
@@ -1413,13 +1269,12 @@ def plot_bpc(
     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:
@@ -1451,9 +1306,10 @@ def plot_eic(
         mz_tol: m/z tolerance in Da. If None, uses study.parameters.eic_mz_tol as default.
     """
     # Local imports to avoid heavy top-level deps / circular imports
-    from bokeh.plotting import figure
+    from bokeh.plotting import figure, show, output_file
     from bokeh.models import ColumnDataSource, HoverTool
-    from master.study.helpers import get_eic
+    from bokeh.io.export import export_png
+    from masster.study.helpers import get_eic
 
     # Use study's eic_mz_tol parameter as default if not provided
     if mz_tol is None:
@@ -1489,12 +1345,7 @@ def plot_eic(
         except Exception:
             continue
 
-    p = figure(
-        width=width,
-        height=height,
-        title=plot_title,
-        tools="pan,wheel_zoom,box_zoom,reset,save",
-    )
+    p = figure(width=width, height=height, title=plot_title, tools="pan,wheel_zoom,box_zoom,reset,save")
     p.xaxis.axis_label = f"Retention Time ({rt_unit})"
     p.yaxis.axis_label = "Intensity"
 
@@ -1560,22 +1411,10 @@ def plot_eic(
 
         color = color_map.get(uid, "#000000")
 
-        data = {
-            "rt": rt,
-            "inty": inty,
-            "sample": [sample_name] * len(rt),
-            "sample_color": [color] * len(rt),
-        }
+        data = {"rt": rt, "inty": inty, "sample": [sample_name] * len(rt), "sample_color": [color] * len(rt)}
         src = ColumnDataSource(data)
 
-        r_line = p.line(
-            "rt",
-            "inty",
-            source=src,
-            line_width=1,
-            color=color,
-            legend_label=str(sample_name),
-        )
+        r_line = p.line("rt", "inty", source=src, line_width=1, color=color, legend_label=str(sample_name))
         p.scatter("rt", "inty", source=src, size=2, color=color, alpha=0.6)
         renderers.append(r_line)
 
@@ -1601,13 +1440,12 @@ def plot_eic(
     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:
@@ -1630,7 +1468,7 @@ def plot_rt_correction(
 
     This uses the same color mapping as `plot_bpc` so curves for the same samples match.
     """
-    from bokeh.plotting import figure
+    from bokeh.plotting import figure, show, output_file
     from bokeh.models import ColumnDataSource, HoverTool
     import numpy as _np
 
@@ -1640,9 +1478,7 @@ def plot_rt_correction(
         return
 
     if "rt_original" not in self.features_df.columns:
-        self.logger.error(
-            "Column 'rt_original' not found in features_df. Alignment/backup RTs missing.",
-        )
+        self.logger.error("Column 'rt_original' not found in features_df. Alignment/backup RTs missing.")
         return
 
     sample_uids = self._get_sample_uids(samples)
@@ -1661,12 +1497,7 @@ def plot_rt_correction(
     # For RT correction plots, default to "s" since we're working with features_df directly
     rt_unit = "s"
 
-    p = figure(
-        width=width,
-        height=height,
-        title=title or "RT correction",
-        tools="pan,wheel_zoom,box_zoom,reset,save",
-    )
+    p = figure(width=width, height=height, title=title or "RT correction", tools="pan,wheel_zoom,box_zoom,reset,save")
     p.xaxis.axis_label = f"Retention Time ({rt_unit})"
     p.yaxis.axis_label = "RT - RT_original (s)"
 
@@ -1688,9 +1519,7 @@ def plot_rt_correction(
             elif "sample_name" in self.features_df.columns:
                 sample_feats = self.features_df.filter(pl.col("sample_name") == uid)
             else:
-                self.logger.debug(
-                    "No sample identifier column in features_df; skipping sample filtering",
-                )
+                self.logger.debug("No sample identifier column in features_df; skipping sample filtering")
                 continue
         except Exception as e:
             self.logger.debug(f"Error filtering features for sample {uid}: {e}")
@@ -1734,12 +1563,7 @@ def plot_rt_correction(
 
         color = color_map.get(uid, "#000000")
 
-        data = {
-            "rt": rt,
-            "delta": delta,
-            "sample": [sample_name] * len(rt),
-            "sample_color": [color] * len(rt),
-        }
+        data = {"rt": rt, "delta": delta, "sample": [sample_name] * len(rt), "sample_color": [color] * len(rt)}
         src = ColumnDataSource(data)
 
         r_line = p.line("rt", "delta", source=src, line_width=1, color=color)
@@ -1769,21 +1593,14 @@ def plot_rt_correction(
     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",
-        )
+        _isolated_save_plot(p, filename, abs_filename, self.logger, "RT Correction Plot")
     else:
         # Show in notebook when no filename provided
         _isolated_show_notebook(p)
@@ -1817,18 +1634,10 @@ 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", "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
+    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 = []
     self.logger.info(f"Plotting {chroms.shape[0]} chromatograms...")
@@ -1883,26 +1692,20 @@ def plot_chrom(
                     sorted_indices = np.argsort(rt)
                     rt = rt[sorted_indices]
                     inty = inty[sorted_indices]
-
+                    
                     # 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"],
+                        (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,
@@ -1912,8 +1715,8 @@ def plot_chrom(
                             ("Intensity", "@inty{0,0}"),
                             ("Sample Name", "@sample_name"),
                             ("Sample UID", "@sample_uid"),
-                            ("Sample Color", "$color[swatch]:sample_color"),
-                        ],
+                            ("Sample Color", "$color[swatch]:sample_color")
+                        ]
                     )
                     curves.append(curve)
 
@@ -1972,26 +1775,19 @@ 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:
         # 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",
-        )
+        _isolated_save_panel_plot(panel.panel(layout), filename, abs_filename, self.logger, "Chromatogram Plot")
     else:
         # Show in notebook when no filename provided
         # Convert Panel layout to Bokeh layout for consistent isolated display
@@ -2025,13 +1821,11 @@ def plot_consensus_stats(
     """
     from bokeh.layouts import gridplot
     from bokeh.models import ColumnDataSource, HoverTool
-    from bokeh.plotting import figure
+    from bokeh.plotting import figure, show, output_file
 
     # Check if consensus_df exists and has data
     if self.consensus_df is None or self.consensus_df.is_empty():
-        self.logger.error(
-            "No consensus data available. Run merge/find_consensus first.",
-        )
+        self.logger.error("No consensus data available. Run merge/find_consensus first.")
         return
 
     # Define the columns to plot
@@ -2062,9 +1856,7 @@ def plot_consensus_stats(
     final_columns = [col for col in columns if col in data_df.columns]
 
     if len(final_columns) < 2:
-        self.logger.error(
-            f"Need at least 2 columns for SPLOM. Available: {final_columns}",
-        )
+        self.logger.error(f"Need at least 2 columns for SPLOM. Available: {final_columns}")
         return
 
     self.logger.debug(f"Creating SPLOM with columns: {final_columns}")
@@ -2237,21 +2029,14 @@ def plot_consensus_stats(
     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",
-        )
+        _isolated_save_plot(grid, filename, abs_filename, self.logger, "Consensus Stats Plot")
     else:
         # Show in notebook when no filename provided
         _isolated_show_notebook(grid)
@@ -2283,9 +2068,10 @@ def plot_pca(
         title (str): Plot title (default: "PCA of Consensus Matrix")
     """
     from bokeh.models import ColumnDataSource, HoverTool, ColorBar, LinearColorMapper
-    from bokeh.plotting import figure
+    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
@@ -2300,32 +2086,25 @@ def plot_pca(
         return
 
     if consensus_matrix is None or consensus_matrix.shape[0] == 0:
-        self.logger.error(
-            "No consensus matrix available. Run merge/find_consensus first.",
-        )
+        self.logger.error("No consensus matrix available. Run merge/find_consensus first.")
         return
 
     if samples_df is None or samples_df.is_empty():
         self.logger.error("No samples dataframe available.")
         return
 
-    self.logger.debug(
-        f"Performing PCA on consensus matrix with shape: {consensus_matrix.shape}",
-    )
+    self.logger.debug(f"Performing PCA on consensus matrix with shape: {consensus_matrix.shape}")
 
     # 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:
         # Pandas DataFrame or other - drop consensus_uid column
-        matrix_sample_data = consensus_matrix.drop(
-            columns=["consensus_uid"],
-            errors="ignore",
-        )
+        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"):
@@ -2356,12 +2135,10 @@ def plot_pca(
     samples_pd = samples_df.to_pandas()
 
     # Create dataframe with PCA results and sample information
-    pca_df = pd.DataFrame(
-        {
-            "PC1": pca_result[:, 0],
-            "PC2": pca_result[:, 1] if n_components > 1 else np.zeros(len(pca_result)),
-        },
-    )
+    pca_df = pd.DataFrame({
+        "PC1": pca_result[:, 0],
+        "PC2": pca_result[:, 1] if n_components > 1 else np.zeros(len(pca_result)),
+    })
 
     # Add sample information to PCA dataframe
     if len(samples_pd) == len(pca_df):
@@ -2445,31 +2222,21 @@ def plot_pca(
             # 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"]),
-                )
+                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"]),
-                )
+                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
+            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
             source = ColumnDataSource(pca_df)
             scatter = p.scatter(
@@ -2494,17 +2261,7 @@ def plot_pca(
     tooltip_list = []
 
     # Columns to exclude from tooltips (file paths and internal/plot fields)
-    excluded_cols = {
-        "file_source",
-        "file_path",
-        "sample_path",
-        "map_id",
-        "PC1",
-        "PC2",
-        "ms1",
-        "ms2",
-        "size",
-    }
+    excluded_cols = {"file_source", "file_path", "sample_path", "map_id", "PC1", "PC2", "ms1", "ms2", "size"}
 
     # Add all sample dataframe columns to tooltips, skipping excluded ones
     for col in samples_pd.columns:
@@ -2536,13 +2293,12 @@ def plot_pca(
     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:
@@ -2566,9 +2322,10 @@ def plot_tic(
     Parameters and behavior mirror `plot_bpc` but use per-sample TICs (get_tic).
     """
     # Local imports to avoid heavy top-level deps / circular imports
-    from bokeh.plotting import figure
+    from bokeh.plotting import figure, show, output_file
     from bokeh.models import ColumnDataSource, HoverTool
-    from master.study.helpers import get_tic
+    from bokeh.io.export import export_png
+    from masster.study.helpers import get_tic
 
     sample_uids = self._get_sample_uids(samples)
     if not sample_uids:
@@ -2596,12 +2353,7 @@ def plot_tic(
         except Exception:
             continue
 
-    p = figure(
-        width=width,
-        height=height,
-        title=plot_title,
-        tools="pan,wheel_zoom,box_zoom,reset,save",
-    )
+    p = figure(width=width, height=height, title=plot_title, tools="pan,wheel_zoom,box_zoom,reset,save")
     p.xaxis.axis_label = f"Retention Time ({rt_unit})"
     p.yaxis.axis_label = "Intensity"
 
@@ -2665,22 +2417,10 @@ def plot_tic(
 
         color = color_map.get(uid, "#000000")
 
-        data = {
-            "rt": rt,
-            "inty": inty,
-            "sample": [sample_name] * len(rt),
-            "sample_color": [color] * len(rt),
-        }
+        data = {"rt": rt, "inty": inty, "sample": [sample_name] * len(rt), "sample_color": [color] * len(rt)}
         src = ColumnDataSource(data)
 
-        r_line = p.line(
-            "rt",
-            "inty",
-            source=src,
-            line_width=1,
-            color=color,
-            legend_label=str(sample_name),
-        )
+        r_line = p.line("rt", "inty", source=src, line_width=1, color=color, legend_label=str(sample_name))
         p.scatter("rt", "inty", source=src, size=2, color=color, alpha=0.6)
         renderers.append(r_line)
 
@@ -2707,13 +2447,12 @@ def plot_tic(
     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: