apmtools 0.2.52__tar.gz → 0.2.54__tar.gz

{apmtools-0.2.52 → apmtools-0.2.54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: apmtools
-Version: 0.2.52
+Version: 0.2.54
 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.52 → apmtools-0.2.54}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "apmtools"
-version = "0.2.52"
+version = "0.2.54"
 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.52 → apmtools-0.2.54}/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.52 → apmtools-0.2.54}/src/apmtools/shiny/matplotlib_renderer.py

@@ -47,6 +47,17 @@ def _axis_bounds_from_spec(spec, *, bins=30, density=False, stacked=False, cumul
     if "error" in spec:
         return {key: "" for key in ("x_min", "x_max", "y_min", "y_max")}
     df, kind, x, ys = spec["data"], spec["kind"], spec["x"], spec["ys"]
+    # A long-form Y grouping must render its value column, not a source
+    # column removed by melt(). Normalize the local spec before faceting.
+    if kind == "scatter" and "__axis_y_value" in df.columns and any(y not in df.columns for y in ys):
+        ys = ["__axis_y_value"]
+        spec = {**spec, "ys": ys}
+
+    # Reactive selection changes can briefly expose a specification whose
+    # original Y names are no longer present after a melt/reshape.
+    ys = [y for y in ys if y in df.columns]
+    if x not in df.columns or (kind != "histogram" and not ys):
+        return {key: "" for key in ("x_min", "x_max", "y_min", "y_max")}
     if df.empty:
         return {key: "" for key in ("x_min", "x_max", "y_min", "y_max")}
     bounds = {key: "" for key in ("x_min", "x_max", "y_min", "y_max")}
@@ -364,6 +375,12 @@ def _matplotlib_direct_figure(spec, *, title="", x_label="", y_label="",
         return fig
 
     df, kind, x, ys = spec["data"], spec["kind"], spec["x"], spec["ys"]
+    # A long-form Y grouping must render its value column, not a source
+    # column removed by melt(). Normalize the local spec before faceting.
+    if kind == "scatter" and "__axis_y_value" in df.columns and any(y not in df.columns for y in ys):
+        ys = ["__axis_y_value"]
+        spec = {**spec, "ys": ys}
+
     # Facet only the native Matplotlib renderer.  Each panel receives the
     # same filtered/aggregated data subset and the same appearance settings.
     if panel_by and _axes is None:
@@ -404,19 +421,23 @@ def _matplotlib_direct_figure(spec, *, title="", x_label="", y_label="",
                     stacked=stacked, histtype=histtype, cumulative=cumulative, _axes=panel_ax,
                     x_major_ticks=x_major_ticks, y_major_ticks=y_major_ticks,
                     x_minor_ticks=x_minor_ticks, y_minor_ticks=y_minor_ticks)
-            for extra in list(axes.flat)[len(partitions):]:
-                extra.set_visible(False)
+            # Resolve the axes once; reuse the same ordered panel collection for
+            # legend layout rather than repeatedly materializing axes.flat.
+            flat_axes = axes.flat
+            active_axes = [flat_axes[i] for i in range(len(partitions))]
+            for i in range(len(partitions), axes.size):
+                flat_axes[i].set_visible(False)
             if legend_inside:
-                for panel_ax in list(axes.flat)[:len(partitions)]:
+                for panel_ax in active_axes:
                     if panel_ax.get_legend() is not None:
                         panel_ax.get_legend().set_in_layout(False)
                 fig.tight_layout()
                 # V77 used tight_layout for facets; reserve generous gutters
                 # without changing V83's legend behaviour or column control.
                 fig.subplots_adjust(wspace=panel_wspace, hspace=panel_hspace)
-                _fit_inside_legends(fig, list(axes.flat)[:len(partitions)], legend_font_size, legend_columns)
+                _fit_inside_legends(fig, active_axes, legend_font_size, legend_columns)
             else:
-                _place_outside_legend(fig, list(axes.flat)[:len(partitions)],
+                _place_outside_legend(fig, active_axes,
                                       legend_position, legend_font_size, legend_columns,
                                       panel_hspace=panel_hspace, panel_wspace=panel_wspace)
             return fig
@@ -457,27 +478,45 @@ def _matplotlib_direct_figure(spec, *, title="", x_label="", y_label="",
         variable_names = list(ys)
         x_names = list(spec.get("x_variables", [x]))
         group_names = style_groups if group_col else []
+        # Reuse stable positions for per-variable markers and hatches.
+        x_position = {name: i for i, name in enumerate(x_names)}
+        y_position = {name: i for i, name in enumerate(ys)}
+        group_position = {name: i for i, name in enumerate(group_names)}
         active = set()
         if kind == "scatter":
             scatter_markers = ['o', 's', 'D', 'x', '^', 'v', 'P', '*']
             for key, group, y, xv, category, rows in entries:
                 g = group if group_col else None
                 active.add((y, g))
+                # Use the same editable series keys as the appearance controls.
+                # Previously this multi-axis branch ignored all three overrides.
+                candidates = (key, f"{g}, {y}" if g is not None else str(y),
+                              str(g) if g is not None else str(y), str(y))
+                def override(mapping, fallback):
+                    return next((mapping[name] for name in candidates if name in mapping), fallback)
+                size = _bounded_float({"value": override(sizes, marker_size)}, "value", marker_size, 0.1, 100)
+                alpha = _bounded_float({"value": override(marker_alphas, 1)}, "value", 1, 0, 1)
+                default_marker = scatter_markers[x_position[xv] % len(scatter_markers)]
+                marker = (_scatter_marker({"value": override(markers, "dot")}, "value")
+                          if any(name in markers for name in candidates) else default_marker)
                 ax.scatter(rows[xv], rows[y], color=color_map[(y, g)],
-                           marker=scatter_markers[x_names.index(xv) % len(scatter_markers)],
-                           s=marker_size**2, alpha=.8)
+                           marker=marker, s=size**2, alpha=alpha)
         else:
             cats = list(pd.unique(df[x].astype(str)))
             combinations = [(g, y) for g in (group_names or ['All observations']) for y in ys]
             n = max(1, len(combinations))
             width = .82 / n
+            # Resolve categorical positions once rather than scanning both
+            # lists for every multi-axis trace. Keep the original ordering.
+            combination_index = {item: i for i, item in enumerate(combinations)}
+            category_index = {item: i for i, item in enumerate(cats)}
             from collections import defaultdict
             buckets = defaultdict(list)
             for key, group, y, xv, category, rows in entries:
                 g = group if group_col else None
                 active.add((y, g))
-                idx = combinations.index((group, y))
-                pos = cats.index(category) + (idx - (n - 1)/2)*width
+                idx = combination_index[(group, y)]
+                pos = category_index[category] + (idx - (n - 1)/2)*width
                 values = pd.to_numeric(rows[y], errors='coerce').dropna().to_numpy(dtype=float)
                 buckets[(pos, y, g)].extend(values)
             for (pos, y, g), values in buckets.items():
@@ -485,7 +524,7 @@ def _matplotlib_direct_figure(spec, *, title="", x_label="", y_label="",
                     continue
                 color = color_map[(y, g)]
                 hatch_options = ['', '/', '\\', 'x', '.', '+', '-']
-                hatch_index = ys.index(y) if multi_y_color_by == 'group' else (group_names.index(g) if g in group_names else 0)
+                hatch_index = y_position[y] if multi_y_color_by == 'group' else group_position.get(g, 0)
                 hatch = '' if multi_y_color_by in ('none', 'both') else hatch_options[hatch_index % len(hatch_options)]
                 if kind == 'bar':
                     ax.bar(pos, sum(values), width=width*.92*bar_box_width, color=color, hatch=hatch)
@@ -584,11 +623,14 @@ def _matplotlib_direct_figure(spec, *, title="", x_label="", y_label="",
         elif spec["frequency"] is not None and id_col is None:
             line_df = _add_gap_sections(df, x_column=x, group_columns=spec["groups"], frequency=spec["frequency"])
             section_col = "__line_section"
+        # Partition the line data once, not once per Y variable.  This
+        # preserves group order and the existing equality semantics while
+        # avoiding repeated full-column masks for multi-Y plots.
+        grouped_line_rows = ([(n, line_df.loc[line_df[group_col] == n]) for n in labels]
+                             if group_col else None)
         for y in ys:
-            if group_col:
-                sets = [(n, line_df.loc[line_df[group_col] == n]) for n in labels]
-            else:
-                sets = [(str(y) if len(ys) > 1 else "All observations", line_df)]
+            sets = (grouped_line_rows if grouped_line_rows is not None else
+                    [(str(y) if len(ys) > 1 else "All observations", line_df)])
             for name, rows in sets:
                 rows = rows.loc[rows[y].notna()]
                 if rows.empty:

{apmtools-0.2.52 → apmtools-0.2.54}/src/apmtools/shiny/ui.py

@@ -607,16 +607,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 +677,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
@@ -963,6 +963,18 @@ if (!window.__apmColorPickerInstalled) {
                     return
                 _last_axis_group_choices.set(signature)
                 selected = [g for g in current if g in choices]
+                # The virtual axis groups are not part of the static selectize
+                # choices at mount time. On restoring a saved plot, Shiny may
+                # discard them before this effect populates the choices.
+                # Restore only eligible saved virtual groups; do not override
+                # physical groups or subsequent user changes.
+                if previous is None:
+                    restored = initial_filters.get("group_by", []) or []
+                    if isinstance(restored, str):
+                        restored = [restored]
+                    for name in restored:
+                        if name in ("variables_x", "variables_y") and name in choices and name not in selected:
+                            selected.append(name)
                 ui.update_selectize("group_by", choices={c: c for c in choices}, selected=selected)
 
             @reactive.calc
@@ -1136,9 +1148,24 @@ if (!window.__apmColorPickerInstalled) {
 
                 if (selected_plot == "scatter" and "variables_x" in selected_groups
                         and len(x_variables) > 1):
-                    id_columns = [c for c in plot_df.columns if c not in x_variables]
-                    plot_df = plot_df.melt(id_vars=id_columns, value_vars=x_variables,
+                    # Melt copies rather than the original X columns.  A source
+                    # variable can simultaneously be an X and a Y selection;
+                    # removing it here leaves the subsequent Y melt and the
+                    # renderer with a stale reference to a missing column.
+                    plot_df = plot_df.copy()
+                    x_copies = []
+                    x_names = {}
+                    for index, column in enumerate(x_variables):
+                        temporary = f"__plot_x_melt_{index}"
+                        while temporary in plot_df.columns:
+                            temporary += "_"
+                        plot_df[temporary] = plot_df[column]
+                        x_copies.append(temporary)
+                        x_names[temporary] = column
+                    id_columns = [c for c in plot_df.columns if c not in x_copies]
+                    plot_df = plot_df.melt(id_vars=id_columns, value_vars=x_copies,
                                            var_name="variables_x", value_name="__axis_x_value")
+                    plot_df["variables_x"] = plot_df["variables_x"].map(x_names)
                     x_column = "__axis_x_value"
                     x_variables = [x_column]
 
@@ -1150,9 +1177,30 @@ if (!window.__apmColorPickerInstalled) {
                 if "variables_y" in selected_groups and len(y_columns) > 1:
                     # Make the selected Y variable an actual categorical dimension,
                     # so it works with ordinary grouping and panel partitioning.
-                    id_columns = [c for c in plot_df.columns if c not in y_columns]
-                    plot_df = plot_df.melt(id_vars=id_columns, value_vars=y_columns,
-                                           var_name="variables_y", value_name="__axis_y_value")
+                    # A variable may be selected as both scatter X and Y.
+                    # Melting the original Y columns would remove it from the
+                    # frame, leaving the X axis pointing at a missing column.
+                    # Melt temporary Y copies instead, retaining X columns.
+                    overlapping = set(y_columns).intersection(x_variables)
+                    if overlapping:
+                        plot_df = plot_df.copy()
+                        copies = []
+                        original_names = {}
+                        for index, column in enumerate(y_columns):
+                            temporary = f"__plot_y_melt_{index}"
+                            while temporary in plot_df.columns:
+                                temporary += "_"
+                            plot_df[temporary] = plot_df[column]
+                            copies.append(temporary)
+                            original_names[temporary] = column
+                        id_columns = [c for c in plot_df.columns if c not in copies]
+                        plot_df = plot_df.melt(id_vars=id_columns, value_vars=copies,
+                                               var_name="variables_y", value_name="__axis_y_value")
+                        plot_df["variables_y"] = plot_df["variables_y"].map(original_names)
+                    else:
+                        id_columns = [c for c in plot_df.columns if c not in y_columns]
+                        plot_df = plot_df.melt(id_vars=id_columns, value_vars=y_columns,
+                                               var_name="variables_y", value_name="__axis_y_value")
                     y_columns = ["__axis_y_value"]
                     # The categorical X labels have already been computed above.
                     # Scatter and bar/box now use the standard single-Y renderer.
@@ -1185,6 +1233,12 @@ if (!window.__apmColorPickerInstalled) {
                         _composite_labels(plot_df, group_columns)
                     )
 
+                # The scatter Y-variable grouping uses a long-form value column.
+                # Keep the spec synchronized with that column even during
+                # reactive transitions between single- and multi-Y selections.
+                if selected_plot == "scatter" and "__axis_y_value" in plot_df.columns:
+                    y_columns = ["__axis_y_value"]
+
                 return {"data": plot_df, "kind": selected_plot, "x": x_column,
                         "ys": y_columns, "groups": group_columns,
                         "categories": x_columns if selected_plot in ("box", "bar") else None,
@@ -1365,6 +1419,12 @@ if (!window.__apmColorPickerInstalled) {
             # prepared.  The effect depends on the plot specification, not on
             # 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,
@@ -1403,9 +1463,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,
@@ -1480,9 +1562,19 @@ if (!window.__apmColorPickerInstalled) {
                 elif kind == "histogram":
                     ui.update_text_area("hist_alpha", value="\n".join(f"{name}=0.65" for name in names))
                 elif kind == "scatter":
-                    ui.update_text_area("scatter_size", value="\n".join(f"{name}=7" for name in names))
-                    ui.update_text_area("scatter_marker", value="\n".join(f"{name}=dot" for name in names))
-                    ui.update_text_area("scatter_alpha", value="\n".join(f"{name}=1" for name in names))
+                    # Preserve user edits across preparation updates; only
+                    # synchronize when the actual trace identities change.
+                    current_keys = tuple(names)
+                    previous_keys = _last_scatter_style_keys[0]
+                    _last_scatter_style_keys[0] = current_keys
+                    if previous_keys != current_keys:
+                        for field, default in (("scatter_size", "7"), ("scatter_marker", "dot"), ("scatter_alpha", "1")):
+                            if previous_keys is None and same_restored_data and field in initial_filters:
+                                continue
+                            with reactive.isolate():
+                                existing = _parse_label_map(_optional_input(field, ""))
+                            ui.update_text_area(field, value="\n".join(
+                                f"{name}={existing.get(name, default)}" for name in names))
                 if backend == "matplotlib":
                     panel_variables = ((list(_optional_input("panel_by", []) or []) or selected_groups) if len(selected_groups) > 1
                                        else selected_groups)
@@ -1967,12 +2059,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).
@@ -2330,6 +2428,8 @@ if (!window.__apmColorPickerInstalled) {
                     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"),
+                    ui.input_action_button("delete_saved_plot", "Delete plot", class_="btn-outline-danger"),
+                    ui.input_action_button("save_dataset_pickle", "Save dataset", class_="btn-outline-primary"),
                     class_="summary-toolbar-actions",
                 ),
                 # Exactly one app-wide theme picker, outside dynamically added
@@ -2408,6 +2508,86 @@ if (!window.__apmColorPickerInstalled) {
             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 will not be overwritten."),
+                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}")
+                    if target.exists():
+                        raise FileExistsError(f"File already exists: {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)
+                            pickle.dump(manager.summary, stream, protocol=pickle.HIGHEST_PROTOCOL)
+                            stream.flush()
+                            os.fsync(stream.fileno())
+                        os.link(temp_path, target)  # fails if target already exists
+                    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():