apmtools 0.2.53__tar.gz → 0.2.55__tar.gz

{apmtools-0.2.53 → apmtools-0.2.55}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: apmtools
-Version: 0.2.53
+Version: 0.2.55
 Summary: A collection of tools for processing air pollution monitoring data
 Project-URL: Homepage, https://github.com/federlorenz/apmtools
 Author-email: Federico Lorenzetti <lorenzetti.federico@gmail.com>

{apmtools-0.2.53 → apmtools-0.2.55}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "apmtools"
-version = "0.2.53"
+version = "0.2.55"
 authors = [
   { name="Federico Lorenzetti", email="lorenzetti.federico@gmail.com" },
 ]
@@ -26,4 +26,4 @@ shiny = [
     "shinywidgets>=0.6",
     "shinyswatch>=0.12",
     "plotly>=6.0",
-]
+]

{apmtools-0.2.53 → apmtools-0.2.55}/src/apmtools/classes.py

@@ -1011,7 +1011,7 @@ class Group(pd.DataFrame):
 
 class Summary(pd.DataFrame):
 
-    _metadata = ['metadata', 'plots']
+    _metadata = ['metadata', 'plots', 'variable', 'description']
 
     @property
     def _constructor(self):
@@ -1030,6 +1030,17 @@ class Summary(pd.DataFrame):
             raise TypeError("Summary.plot must be None or a list")
         super().__setattr__(name, value)
 
+    def __setstate__(self, state):
+        """Restore DataFrame state and default metadata absent in older pickles."""
+        super().__setstate__(state)
+        # Some older pickles contain an instance-level _metadata list, which
+        # masks the corrected class declaration and breaks future copies.
+        self.__dict__.pop("_metadata", None)
+        for name, default in (("plots", None), ("variable", None),
+                              ("description", ""), ("metadata", set())):
+            if name not in self.__dict__:
+                object.__setattr__(self, name, default)
+
     def __finalize__(self, other, method=None, **kwargs):
         if isinstance(other, Summary):
             self.variable = getattr(other, "variable", None)

{apmtools-0.2.53 → apmtools-0.2.55}/src/apmtools/plot_app.py

@@ -83,12 +83,26 @@ class PlotApp:
         import shinyswatch
 
         app_ui = ui.page_fluid(
+            ui.tags.button("Hide toolbars", type="button", class_="btn btn-sm btn-outline-secondary my-0", id="standalone-toolbar-collapse-toggle", **{"aria-expanded": "true"}),
             ui.div(
-                ui.input_action_button("open_dataset", "Open Dataset", class_="btn-primary"),
+                ui.input_action_button("open_dataset", "Open Dataset", class_="btn-outline-primary"),
+                ui.div(id="standalone-save-dataset-slot"),
                 ui.output_text("dataset_status", inline=True),
-                class_="d-flex align-items-center gap-3 my-2",
+                ui.div(shinyswatch.theme_picker_ui(), class_="summary-app-theme ms-auto"),
+                class_="d-flex align-items-center gap-1 my-0 standalone-dataset-toolbar",
             ),
-            ui.div(shinyswatch.theme_picker_ui(), class_="summary-app-theme", style="position:absolute;right:1.5rem;top:.5rem;z-index:10"),
+            ui.tags.script("""
+              (() => {
+                const move = () => {
+                  const slot = document.getElementById('standalone-save-dataset-slot');
+                  const button = document.querySelector('#summary-dataset-toolbar button');
+                  if (slot && button && button.parentElement !== slot) slot.appendChild(button);
+                };
+                new MutationObserver(move).observe(document.body, {childList:true, subtree:true});
+                document.addEventListener('DOMContentLoaded', move);
+                move();
+              })();
+            """),
             ui.output_ui("dataset_workspace"),
             title="PlotApp",
         )

{apmtools-0.2.53 → apmtools-0.2.55}/src/apmtools/plot_configs.py

@@ -130,6 +130,15 @@ class PlotConfigManager:
         self.revision += 1
         return preset_id
 
+    def delete_saved(self, preset_id):
+        """Delete one explicitly saved plot by stable ID, not its open draft."""
+        items = copy.deepcopy(self.summary.plots or [])
+        remaining = [p for p in items if not (p.get('id') == preset_id and p.get('type') == 'plot')]
+        if len(remaining) == len(items):
+            raise KeyError(f'Unknown saved plot: {preset_id}')
+        self.summary.plots = remaining
+        self.revision += 1
+
     def saved(self):
         return copy.deepcopy(self.summary.plots or [])
 

{apmtools-0.2.53 → apmtools-0.2.55}/src/apmtools/shiny/ui.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 from .filter_config import filter_config_fields as _filter_config_fields
 import threading
+import json
 from datetime import date, datetime, time, timedelta
 from collections.abc import Sequence
 import numpy as np
@@ -607,16 +608,14 @@ if (!window.__apmColorPickerInstalled) {
                     _label_keys[field].set(keys)
 
             def _label_string(field):
-                # Internal adapter for the existing renderer/export APIs.
-                # Label discovery is downstream of figure rendering. Do not
-                # subscribe the figure to its own discovered key set: this
-                # otherwise forms plot -> legend keys -> plot feedback cycles.
-                with reactive.isolate():
-                    keys = _label_keys[field].get()
-                values = _editor_map(field)
-                active = keys if keys else tuple(values)
-                return "; ".join(f"{key}={values.get(key, key)}" for key in active
-                                 if values.get(key, key) != key)
+                # Pass the complete persisted mapping to the renderer, even
+                # before legend keys have been rediscovered on a loaded tab.
+                # The editor's key list controls visible inputs only; it must
+                # not decide which saved overrides reach Matplotlib.
+                # Watch appearance changes so edits invalidate the figure.
+                values = _editor_map(field, watch=(field == "legend_labels"))
+                return "; ".join(f"{key}={value}" for key, value in values.items()
+                                 if value != key)
 
             for _field in _label_fields:
                 def _make_editor(field):
@@ -679,9 +678,11 @@ if (!window.__apmColorPickerInstalled) {
                 return _editor_map("trace_colors", watch=watch)
 
             def _color_string():
-                keys = _color_keys.get()
+                # The colour-key discovery effect can run after the first
+                # restored render.  Do not discard persisted overrides while
+                # the key list is empty (or temporarily incomplete).
                 values = _color_map(watch=True)
-                return "; ".join(f"{key}={values[key]}" for key in keys if key in values)
+                return "; ".join(f"{key}={value}" for key, value in values.items())
 
             # Each rendered colour key has a stable swatch button. The popup
             # itself is mounted only on demand, avoiding text-input remounts
@@ -1420,6 +1421,11 @@ if (!window.__apmColorPickerInstalled) {
             # appearance inputs, so editing a label or colour cannot reset it.
             _last_line_style_keys = [None]
             _last_scatter_style_keys = [None]
+            # Arm automatic axis-label regeneration only after the restored
+            # X/Y selectors have actually reached their saved values. This
+            # avoids treating intermediate selector initialization as an edit.
+            _restored_axis_selection = [None]
+            _axis_selection_armed = [not bool(initial_filters)]
 
             @reactive.effect
             @reactive.event(prepared_plot, lambda: _optional_input("multi_panel", False) if input.group_by() else False,
@@ -1458,9 +1464,31 @@ if (!window.__apmColorPickerInstalled) {
                 )
                 if not same_restored_data or "title" not in initial_filters:
                     ui.update_text("title", value="Summary plot")
-                if not same_restored_data or "x_axis_label" not in initial_filters:
+                # Preserve restored labels during initialization, then reset
+                # them when the user changes either axis variable selection.
+                # Changes to grouping, panels or appearance do not reset labels.
+                current_axis_selection = (
+                    tuple(_optional_input("x", []) or []),
+                    tuple(_optional_input("y", []) or []),
+                )
+                saved_axis_selection = (
+                    tuple(initial_filters.get("x", []) or []),
+                    tuple(initial_filters.get("y", []) or []),
+                )
+                axis_selection_changed = False
+                if not _axis_selection_armed[0]:
+                    if current_axis_selection == saved_axis_selection:
+                        _axis_selection_armed[0] = True
+                        _restored_axis_selection[0] = current_axis_selection
+                elif _restored_axis_selection[0] is None:
+                    _restored_axis_selection[0] = current_axis_selection
+                elif current_axis_selection != _restored_axis_selection[0]:
+                    axis_selection_changed = True
+                    _restored_axis_selection[0] = current_axis_selection
+
+                if axis_selection_changed or "x_axis_label" not in initial_filters:
                     ui.update_text("x_axis_label", value=defaults["x_label"])
-                if not same_restored_data or "y_axis_label" not in initial_filters:
+                if axis_selection_changed or "y_axis_label" not in initial_filters:
                     ui.update_text_area("y_axis_label", value=defaults["y_label"])
                 limits = _axis_bounds_from_spec(
                     spec,
@@ -1501,6 +1529,21 @@ if (!window.__apmColorPickerInstalled) {
                         panel_bounds = {name: _pad_axis_bounds(bounds) for name, bounds in panel_bounds.items()}
                         limits = {key: _format_panel_bounds(panel_bounds, key) for key in limits}
                 for field, value in limits.items():
+                    # A restored plot's explicit axis bounds are authoritative.
+                    # The preparation observer fires after the saved inputs mount;
+                    # overwriting them here caused the saved limits to flash and
+                    # then revert to automatically calculated limits.  Continue
+                    # recalculating defaults when the user changes X/Y variables.
+                    # Restoration is asynchronous: the group, aggregation and
+                    # plot selectors can briefly disagree with the saved values
+                    # while mounting. That is NOT a user edit and must never
+                    # erase a persisted bound. Release the guard only when an
+                    # actual X/Y selection change has been observed after the
+                    # saved selectors were fully initialized.
+                    if (not axis_selection_changed
+                            and field in initial_filters
+                            and str(initial_filters[field]).strip()):
+                        continue
                     if backend == "matplotlib":
                         ui.update_text_area(field, value=value)
                     else:
@@ -1626,6 +1669,12 @@ if (!window.__apmColorPickerInstalled) {
             @reactive.effect
             @reactive.event(input.plot_type, ignore_init=True)
             def reset_on_plot_type_change():
+                # During a restored tab's initial mount, Shiny can report a
+                # transient plot type. Do not clear persisted axis bounds (or
+                # other appearance settings) until the restored selectors have
+                # settled and a real plot-type change can be observed.
+                if initial_filters and not _axis_selection_armed[0]:
+                    return
                 # Reset every plot-specific selection when the plot type changes.
                 for _i in range(max_subset_stages):
                     ui.update_select(f"subset_column_{_i}", selected="")
@@ -1754,6 +1803,16 @@ if (!window.__apmColorPickerInstalled) {
                     labels = [txt.get_text() for leg in legends for txt in leg.get_texts()]
                 excluded = ("Y variable", "Grouping", "Legend", "All observations")
                 labels = [label for label in labels if label.strip() and label not in excluded]
+                # A faceted plot can temporarily expose no legend while Shiny
+                # swaps axes (or when the panel variable consumes the only
+                # grouping dimension). Do not clear the editor identities in
+                # that transient state: remounting the text inputs on every
+                # panel transition can disconnect their reactive watchers.
+                with reactive.isolate():
+                    panel_mode = (backend == "matplotlib" and
+                                  bool(_optional_input("multi_panel", False)))
+                if panel_mode and not labels and known_keys:
+                    return
                 # If this is merely a relabelled rendering of the existing
                 # traces, do not rediscover/rename their identities.
                 expected = [mapping.get(key, key) for key in known_keys]
@@ -2032,12 +2091,18 @@ if (!window.__apmColorPickerInstalled) {
                 for field in _label_fields:
                     with reactive.isolate():
                         values = dict(_editor_map(field))
+                    # A restored tab may snapshot before its dynamic editors
+                    # have mounted. Preserve the saved mapping in that case.
+                    if not values and initial_filters.get(field):
+                        values = dict(_parse_label_map(initial_filters[field]))
                     result[field] = "; ".join(f"{key}={value}" for key, value in values.items()
                                               if value != key)
                 with reactive.isolate():
                     colors = dict(_color_map())
-                    chosen = configured_visibility()
-                    visible_keys = tuple(available_elements())
+                if not colors and initial_filters.get("trace_colors"):
+                    colors = dict(_parse_label_map(initial_filters["trace_colors"]))
+                chosen = configured_visibility()
+                visible_keys = tuple(available_elements())
                 result["trace_colors"] = "; ".join(f"{key}={value}" for key, value in colors.items())
                 # No available components must not erase visibility in a
                 # retained configuration (e.g. threshold above maximum).
@@ -2337,17 +2402,34 @@ if (!window.__apmColorPickerInstalled) {
             .summary-plot-container {width:100%; height:auto; aspect-ratio: 2 / 1; min-width:0; position:relative;}
             .summary-plot-container > * {width:100% !important;}
             .summary-plot-container .shiny-plot-output {min-height:400px;}
-            /* Keep the shared app theme picker right-aligned in the top toolbar.
-               This selector is independent of each plot's Plot appearance theme. */
-            .summary-top-toolbar {display:flex; align-items:flex-end; gap:0.75rem;
-                                  flex-wrap:wrap; margin-bottom:1rem;}
-            .summary-toolbar-actions {display:flex; gap:0.5rem; flex-wrap:wrap; align-items:center;}
-            .summary-app-theme {margin-left:auto; width:220px; max-width:100%;}
+            .summary-top-toolbar {display:flex; align-items:center; gap:0.5rem;
+                                  flex-wrap:nowrap; margin-bottom:0; min-width:0;}
+            .summary-toolbar-actions {display:flex; gap:0.4rem; flex-wrap:nowrap;
+                                      align-items:center; min-width:0; overflow-x:auto;}
+            .summary-toolbar-actions .btn {white-space:nowrap;}
+            .summary-toolbar-right {display:flex; gap:0.4rem; align-items:center;
+                                    margin-left:auto; flex-shrink:0;}
+            .summary-app-theme {width:200px; flex-shrink:0;}
             .summary-app-theme .shiny-input-container {width:100%; margin-bottom:0;}
-            @media (max-width: 480px) {
-                .summary-app-theme {width:100%;}
-            }
-        """),
+            .summary-dataset-toolbar {display:flex; align-items:center; gap:0.5rem;
+                                      margin-bottom:0; min-width:0;}
+            .summary-dataset-toolbar .btn {white-space:nowrap;}
+            .summary-dataset-toolbar .summary-app-theme {margin-left:auto;}
+            .summary-toolbar-collapse-toggle {margin-bottom:0; padding-top:0.12rem; padding-bottom:0.12rem;}
+            .summary-dataset-toolbar .shiny-input-container,
+            .summary-toolbar-actions .shiny-input-container {margin-bottom:0 !important;}
+             .summary-dataset-toolbar .btn, .summary-toolbar-actions .btn {padding:0.22rem 0.65rem; font-size:0.875rem; line-height:1.5;}
+            .summary-dataset-toolbar .shiny-input-container,
+            .standalone-dataset-toolbar .shiny-input-container {width:auto !important; flex:0 0 auto;}
+            .standalone-dataset-toolbar {margin-bottom:0 !important; gap:0.35rem !important;}
+            .standalone-dataset-toolbar .btn {padding:0.22rem 0.65rem; font-size:0.875rem; line-height:1.5;}
+            .summary-dataset-toolbar {gap:0.35rem;}
+            .summary-toolbar-collapsed .summary-dataset-toolbar,
+            .summary-toolbar-collapsed .summary-toolbar-actions {display:none !important;}
+            body:has(#standalone-toolbar-collapse-toggle) .summary-toolbar-collapse-toggle {display:none;}
+            body:has(#standalone-toolbar-collapse-toggle).summary-toolbar-collapsed
+                .standalone-dataset-toolbar {display:none !important;}
+                """),
         ui.tags.script("""
         (() => {
           // A Plotly relayout mutates its DOM. Observing all descendants and
@@ -2385,22 +2467,34 @@ if (!window.__apmColorPickerInstalled) {
           }).observe(document.body, {childList:true, subtree:true});
           document.addEventListener('shown.bs.tab', () => requestAnimationFrame(install));
           install();
+          // Delegated listener also works when a dataset workspace is replaced.
+          document.addEventListener('click', (event) => {
+            const toggle = event.target.closest('#summary-toolbar-collapse-toggle, #standalone-toolbar-collapse-toggle');
+            if (!toggle) return;
+            const collapsed = document.body.classList.toggle('summary-toolbar-collapsed');
+            document.querySelectorAll('#summary-toolbar-collapse-toggle, #standalone-toolbar-collapse-toggle').forEach(button => {
+              button.textContent = collapsed ? 'Show toolbars' : 'Hide toolbars';
+              button.setAttribute('aria-expanded', String(!collapsed));
+            });
+          });
         })();
         """),
         ui.div(
+            ui.tags.button("Hide toolbars", type="button", class_="btn btn-sm btn-outline-secondary summary-toolbar-collapse-toggle", id="summary-toolbar-collapse-toggle", **{"aria-expanded": "true"}),
             ui.div(
-                ui.div(
-                    ui.input_action_button("add_tab", "+ New plot", class_="btn-primary"),
-                    ui.input_action_button("add_table", "+ New table", class_="btn-primary"),
-                    ui.input_action_button("close_tab", "Close selected tab", class_="btn-outline-danger"),
-                    ui.input_action_button("retain_plot", "Save selected plot", class_="btn-outline-primary"),
-                    ui.input_action_button("restore_plot", "Load saved plot", class_="btn-outline-primary"),
-                    class_="summary-toolbar-actions",
-                ),
-                # Exactly one app-wide theme picker, outside dynamically added
-                # plot modules. shinyswatch provides its full theme catalogue.
-                ui.div(shinyswatch.theme_picker_ui(), class_="summary-app-theme") if include_theme_picker else ui.div(class_="summary-app-theme"),
-                class_="summary-top-toolbar",
+                ui.input_action_button("save_dataset_pickle", "Save dataset", class_="btn-outline-primary"),
+                ui.div(shinyswatch.theme_picker_ui(), class_="summary-app-theme") if include_theme_picker else ui.div(),
+                class_="summary-dataset-toolbar",
+                id="summary-dataset-toolbar",
+            ),
+            ui.div(
+                ui.input_action_button("add_tab", "New plot", class_="btn-primary"),
+                ui.input_action_button("add_table", "New table", class_="btn-primary"),
+                ui.input_action_button("retain_plot", "Save Plot", class_="btn-outline-primary"),
+                ui.input_action_button("restore_plot", "Load Plot", class_="btn-outline-primary"),
+                ui.input_action_button("delete_saved_plot", "Delete Plot", class_="btn-outline-danger"),
+                ui.input_action_button("close_tab", "Close tab", class_="btn-outline-danger"),
+                class_="summary-toolbar-actions summary-top-toolbar",
             ),
             ui.tags.style("""
                 .summary-info-content {max-width: 980px; margin: 1.2rem auto 3rem;
@@ -2468,11 +2562,130 @@ if (!window.__apmColorPickerInstalled) {
                     manager.update(selected, tab_filters[selected]())
                     manager.retain(selected, input.retained_plot_name())
                 saved_revision.set(saved_revision.get() + 1)
+                # Update the existing tab label without remounting its Shiny module.
+                # Replacing the nav panel would destroy the live plot controls.
+                saved_label = str(input.retained_plot_name()).strip()
+                ui.insert_ui(
+                    ui.tags.script(
+                        "(function(){const tab=" + json.dumps(selected) +
+                        ", label=" + json.dumps(saved_label) +
+                        "; const a=document.querySelector('[data-value=\"'+CSS.escape(tab)+'\"]');" +
+                        "if(a){const span=a.querySelector('span'); if(span)span.textContent=label; else a.textContent=label;}" +
+                        "})();"
+                    ),
+                    selector="body", where="beforeEnd",
+                )
                 ui.modal_remove()
                 ui.notification_show("Plot configuration retained in Summary.plots", type="message")
             except Exception as exc:
                 ui.notification_show(f"Could not save configuration: {exc}", type="error")
 
+        @reactive.effect
+        @reactive.event(input.delete_saved_plot)
+        def choose_plot_to_delete():
+            presets = [p for p in manager.saved() if p.get("type") == "plot"]
+            if not presets:
+                ui.notification_show("No saved plots to delete", type="warning")
+                return
+            ui.modal_show(ui.modal(
+                ui.input_select("delete_saved_plot_choice", "Saved plot to delete",
+                                choices={p["id"]: p.get("name", p["id"]) for p in presets}),
+                ui.p("This deletes the saved configuration from Summary.plots. Open tabs are not closed."),
+                title="Delete saved plot",
+                footer=ui.div(ui.modal_button("Cancel"),
+                              ui.input_action_button("confirm_delete_saved_plot", "Delete", class_="btn-danger")),
+            ))
+
+        @reactive.effect
+        @reactive.event(input.confirm_delete_saved_plot)
+        def confirm_delete_saved_plot():
+            try:
+                with reactive.isolate():
+                    manager.delete_saved(input.delete_saved_plot_choice())
+                saved_revision.set(saved_revision.get() + 1)
+                ui.modal_remove()
+                ui.notification_show("Saved plot deleted. Save the dataset to persist this change to disk.", type="message")
+            except Exception as exc:
+                ui.notification_show(f"Could not delete saved plot: {exc}", type="error")
+
+        @reactive.effect
+        @reactive.event(input.save_dataset_pickle)
+        def show_save_dataset_dialog():
+            ui.modal_show(ui.modal(
+                ui.p("Save the current Summary, including saved plot configurations, as a pickle file."),
+                ui.input_text("dataset_pickle_path", "Destination path on the computer running Shiny",
+                              value="summary.pkl", placeholder="/path/to/drive/summary.pkl"),
+                ui.p("For a mounted drive, enter its full directory path. Existing files can be overwritten if you confirm."),
+                ui.input_checkbox("overwrite_dataset_pickle", "Overwrite existing file", value=False),
+                title="Save dataset",
+                footer=ui.div(ui.modal_button("Cancel"),
+                              ui.input_action_button("confirm_save_dataset_pickle", "Save pickle", class_="btn-primary")),
+            ))
+
+        @reactive.effect
+        @reactive.event(input.confirm_save_dataset_pickle)
+        def confirm_save_dataset_pickle():
+            import os
+            import pickle
+            import tempfile
+            from pathlib import Path
+            try:
+                with reactive.isolate():
+                    raw = (input.dataset_pickle_path() or "").strip()
+                    if not raw:
+                        raise ValueError("Provide a destination path")
+                    target = Path(raw).expanduser().resolve()
+                    if target.suffix.lower() != ".pkl":
+                        raise ValueError("The filename must end in .pkl")
+                    if not target.parent.is_dir():
+                        raise FileNotFoundError(f"Directory does not exist: {target.parent}")
+                    overwrite = bool(input.overwrite_dataset_pickle())
+                    if target.exists() and not overwrite:
+                        raise FileExistsError(f"File already exists: {target}. Check Overwrite existing file to replace it.")
+                    if target.exists() and not target.is_file():
+                        raise ValueError(f"Destination is not a regular file: {target}")
+                    # Serialize to a temporary file, then publish atomically without
+                    # overwriting an existing file. Preserve the original on errors.
+                    temp_path = None
+                    try:
+                        with tempfile.NamedTemporaryFile(mode="wb", dir=target.parent,
+                                                         prefix=".apmtools-", suffix=".tmp",
+                                                         delete=False) as stream:
+                            temp_path = Path(stream.name)
+                            # The manager owns retained plot presets. Never serialize
+                            # the working plotting frame, which may have stale metadata.
+                            source = manager.summary
+                            retained = manager.saved()
+                            if not hasattr(source, "plots"):
+                                raise RuntimeError("Source Summary has no plots attribute")
+                            # Serialize an independent snapshot so that a concurrent
+                            # Shiny event cannot mutate metadata during the write.
+                            snapshot = source.copy(deep=False)
+                            snapshot.plots = retained
+                            pickle.dump(snapshot, stream, protocol=pickle.HIGHEST_PROTOCOL)
+                            stream.flush()
+                            os.fsync(stream.fileno())
+                        # Verify what was actually written before publishing it.
+                        with temp_path.open("rb") as check_stream:
+                            restored = pickle.load(check_stream)
+                        restored_plots = getattr(restored, "plots", None)
+                        if restored_plots != retained:
+                            raise RuntimeError(
+                                "Pickle verification failed: saved plot configurations "
+                                "were not preserved; no dataset file was published"
+                            )
+                        if overwrite:
+                            os.replace(temp_path, target)  # atomic replacement after verification
+                        else:
+                            os.link(temp_path, target)  # never overwrite unless explicitly requested
+                    finally:
+                        if temp_path is not None:
+                            temp_path.unlink(missing_ok=True)
+                ui.modal_remove()
+                ui.notification_show(f"Dataset saved to {target}", type="message", duration=8)
+            except Exception as exc:
+                ui.notification_show(f"Could not save dataset: {exc}", type="error", duration=10)
+
         @reactive.effect
         @reactive.event(input.restore_plot)
         def choose_saved():
@@ -2498,7 +2711,8 @@ if (!window.__apmColorPickerInstalled) {
                     number = next_tab.get() + 1
                     tab_id = f"plot_{number}"
                     inherited = manager.restore(preset_id, tab_id)
-                    panel = ui.nav_panel(f"Plot {number}", plot_tab_ui(tab_id, inherited), value=tab_id)
+                    saved_name = next((p.get("name") for p in manager.saved() if p.get("id") == preset_id), None)
+                    panel = ui.nav_panel(saved_name or f"Plot {number}", plot_tab_ui(tab_id, inherited), value=tab_id)
                     tab_filters[tab_id] = plot_tab_server(tab_id, inherited, config_tab_id=tab_id)
                     register_draft(tab_id, tab_filters[tab_id])
                     next_tab.set(number)