apmtools 0.2.54__tar.gz → 0.2.56__tar.gz

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

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "apmtools"
-version = "0.2.54"
+version = "0.2.56"
 authors = [
   { name="Federico Lorenzetti", email="lorenzetti.federico@gmail.com" },
 ]

{apmtools-0.2.54 → apmtools-0.2.56}/src/apmtools/classes.py

@@ -1011,7 +1011,7 @@ class Group(pd.DataFrame):
 
 class Summary(pd.DataFrame):
 
-    _metadata = ['metadata', 'plots']
+    _metadata = ['metadata', 'views', 'variable', 'description']
 
     @property
     def _constructor(self):
@@ -1023,19 +1023,43 @@ class Summary(pd.DataFrame):
         self.metadata = metadata
         self.variable = variable
         self.description = description
-        self.plots = None
+        self.views = None
+
+    @property
+    def plots(self):
+        """Backward-compatible alias for saved plot and table views."""
+        return self.views
+
+    @plots.setter
+    def plots(self, value):
+        self.views = value
 
     def __setattr__(self, name, value):
-        if name == "plots" and value is not None and not isinstance(value, list):
-            raise TypeError("Summary.plot must be None or a list")
+        if name in ("plots", "views") and value is not None and not isinstance(value, list):
+            raise TypeError("Summary.views 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)
+        # Migrate saved configurations from older pickles transparently.
+        legacy = self.__dict__.pop("plots", None)
+        if "views" not in self.__dict__:
+            object.__setattr__(self, "views", legacy)
+        for name, default in (("views", 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)
             self.metadata = getattr(other, "metadata", set()).copy()
             self.description = getattr(other, "description", "")
-            self.plots = getattr(other, "plots", None)
+            self.views = getattr(other, "views", getattr(other, "plots", None))
 
         return self
 
@@ -1065,7 +1089,7 @@ class Summary(pd.DataFrame):
             return
 
         return_dict = copy.deepcopy(self)
-        return_dict.plots = None
+        return_dict.views = None
         a = {}
 
         if filter_style not in {'all', 'any', 'negative all', 'negative any'}:
@@ -1160,7 +1184,7 @@ class Summary(pd.DataFrame):
         self.description = self.description + \
             f"\nFiltered by {time_start if time_start != None else ""} till {time_end if time_end != None else ""}, {date_start if date_start != None else ""} till {date_end if date_end != None else ""}, {day if day != None else ""}"
         result = self.reset_index()
-        result.plots = None
+        result.views = None
         return result
 
     def set_attrib(self, attribute):
@@ -1587,7 +1611,7 @@ class Summary(pd.DataFrame):
         
         out = self.subset({"monitor": [value]})
         out = out.dropna(axis=1,how="all")
-        out.plots = None
+        out.views = None
         return out
 
 

{apmtools-0.2.54 → apmtools-0.2.56}/src/apmtools/plot_app.py

@@ -8,6 +8,8 @@ from __future__ import annotations
 from pathlib import Path
 import pickle
 import threading
+import os
+import tempfile
 
 
 def load_summary_pickle(path):
@@ -35,6 +37,47 @@ def load_summary_pickle(path):
     return data
 
 
+def save_summary_pickle(summary, destination, *, overwrite=False):
+    """Atomically persist the current source Summary and retained plot presets."""
+    from .classes import Summary
+    if not isinstance(summary, Summary):
+        raise TypeError("No Summary dataset is loaded")
+    target = Path(destination).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() and not overwrite:
+        raise FileExistsError(f"File already exists: {target}")
+    if target.exists() and not target.is_file():
+        raise ValueError(f"Destination is not a regular file: {target}")
+    from .plot_configs import validate_saved_plots
+    retained = validate_saved_plots(getattr(summary, "plots", None))
+    temporary = None
+    try:
+        with tempfile.NamedTemporaryFile(mode="wb", dir=target.parent,
+                                         prefix=".apmtools-", suffix=".tmp",
+                                         delete=False) as stream:
+            temporary = Path(stream.name)
+            snapshot = summary.copy(deep=False)
+            snapshot.plots = retained
+            pickle.dump(snapshot, stream, protocol=pickle.HIGHEST_PROTOCOL)
+            stream.flush()
+            os.fsync(stream.fileno())
+        with temporary.open("rb") as stream:
+            restored = pickle.load(stream)
+        if getattr(restored, "plots", None) != retained:
+            raise RuntimeError("Saved plot configurations failed pickle verification")
+        if overwrite:
+            os.replace(temporary, target)
+        else:
+            os.link(temporary, target)
+    finally:
+        if temporary is not None:
+            temporary.unlink(missing_ok=True)
+    return target
+
+
 class PlotApp:
     """Launch a Shiny plot workspace with an optional initial Summary.
 
@@ -45,7 +88,7 @@ class PlotApp:
     """
 
     def __init__(self, summary=None, *, x=None, y=None, group_by=None,
-                 plot_type="line", title="Summary plot", backend="plotly"):
+                 plot_type="line", title="Summary plot", backend="matplotlib"):
         from .classes import Summary
         if summary is not None and not isinstance(summary, Summary):
             raise TypeError("PlotApp expects an apmtools Summary or None")
@@ -83,12 +126,17 @@ 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.input_action_button("save_dataset_root", "Save dataset", class_="btn-outline-primary"),
                 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.style("""
+              body:has(#standalone-toolbar-collapse-toggle) #summary-dataset-toolbar {display:none !important;}
+            """),
             ui.output_ui("dataset_workspace"),
             title="PlotApp",
         )
@@ -110,6 +158,34 @@ class PlotApp:
             def dataset_status():
                 return status.get()
 
+            @reactive.effect
+            @reactive.event(input.save_dataset_root)
+            def show_root_save_dialog():
+                if self.original_summary is None:
+                    ui.notification_show("Open a dataset before saving", type="warning")
+                    return
+                ui.modal_show(ui.modal(
+                    ui.p("Save the loaded Summary and its saved plot configurations as a pickle."),
+                    ui.input_text("root_dataset_path", "Destination path on the computer running Shiny",
+                                  value="summary.pkl"),
+                    ui.input_checkbox("root_dataset_overwrite", "Overwrite existing file", value=False),
+                    title="Save dataset",
+                    footer=ui.div(ui.modal_button("Cancel"),
+                                  ui.input_action_button("root_confirm_save", "Save pickle", class_="btn-primary")),
+                ))
+
+            @reactive.effect
+            @reactive.event(input.root_confirm_save)
+            def save_root_dataset():
+                try:
+                    target = save_summary_pickle(
+                        self.original_summary, input.root_dataset_path(),
+                        overwrite=bool(input.root_dataset_overwrite()))
+                    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.open_dataset)
             def show_dataset_dialog():

{apmtools-0.2.54 → apmtools-0.2.56}/src/apmtools/plot_configs.py

@@ -10,6 +10,30 @@ def _json_ready(value):
     return json.loads(json.dumps(value, allow_nan=False))
 
 
+
+def validate_saved_plots(plots):
+    """Validate the structure of retained presets without altering their values.
+
+    Old snapshots remain supported: unknown settings are deliberately retained.
+    """
+    if plots is None:
+        return []
+    if not isinstance(plots, list):
+        raise TypeError("Summary.views must be a list or None")
+    seen = set()
+    for item in plots:
+        if not isinstance(item, dict):
+            raise ValueError("Saved plot entries must be dictionaries")
+        if item.get("schema_version") != 1 or item.get("type") not in ("plot", "table"):
+            raise ValueError("Unsupported saved plot configuration")
+        if not isinstance(item.get("settings"), dict):
+            raise ValueError("Saved plot settings must be a dictionary")
+        identifier = item.get("id")
+        if not isinstance(identifier, str) or not identifier or identifier in seen:
+            raise ValueError("Saved plot IDs must be unique nonempty strings")
+        seen.add(identifier)
+    return copy.deepcopy(plots)
+
 class PlotConfigManager:
     """Keep live tab drafts separate from explicitly retained Summary.plots.
 
@@ -26,7 +50,7 @@ class PlotConfigManager:
         if getattr(summary, 'plots', None) is None:
             summary.plots = []
         if not isinstance(summary.plots, list):
-            raise TypeError('Summary.plots must be a list or None')
+            raise TypeError('Summary.views must be a list or None')
 
     # Settings that affect filtering, grouping or aggregation. Everything else
     # is treated as presentation state. Panel layout (panel_by) is
@@ -119,28 +143,63 @@ class PlotConfigManager:
         preset_id = preset_id or uuid.uuid4().hex
         item = {'schema_version': 1, 'id': preset_id, 'name': name,
                 'type': 'plot', 'settings': self.get(tab_id)}
-        items = copy.deepcopy(self.summary.plots or [])
+        items = copy.deepcopy(self.summary.views or [])
         for i, old in enumerate(items):
             if old.get('id') == preset_id:
                 items[i] = item
                 break
         else:
             items.append(item)
-        self.summary.plots = items
+        self.summary.views = items
         self.revision += 1
         return preset_id
 
+    def retain_table(self, name, settings, frame=None, *, preset_id=None):
+        """Save table settings only; data are sourced from the owning Summary.
+
+        ``frame`` is accepted for compatibility with callers of the older API,
+        but is never serialized. Legacy table snapshots are migrated on save.
+        """
+        name = str(name).strip()
+        if not name:
+            raise ValueError('Configuration name must not be empty')
+        preset_id = preset_id or uuid.uuid4().hex
+        item = {'schema_version': 1, 'id': preset_id, 'name': name,
+                'type': 'table', 'settings': _json_ready(settings)}
+        items = self.saved()
+        for i, old in enumerate(items):
+            if old.get('id') == preset_id:
+                items[i] = item
+                break
+        else:
+            items.append(item)
+        self.summary.views = items
+        self.revision += 1
+        return preset_id
+
+    def restore_table(self, preset_id):
+        item = next((p for p in self.saved() if p.get('id') == preset_id), None)
+        if item is None or item.get('type') != 'table':
+            raise KeyError(preset_id)
+        # Legacy frame snapshots are intentionally ignored. All tables now
+        # resolve against the current owning dataset, not a frozen copy.
+        return self.summary.copy(deep=False), copy.deepcopy(item['settings'])
+
     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')]
+        items = copy.deepcopy(self.summary.views or [])
+        remaining = [p for p in items if not (p.get('id') == preset_id and p.get('type') in ('plot', 'table'))]
         if len(remaining) == len(items):
             raise KeyError(f'Unknown saved plot: {preset_id}')
-        self.summary.plots = remaining
+        self.summary.views = remaining
         self.revision += 1
 
     def saved(self):
-        return copy.deepcopy(self.summary.plots or [])
+        items = validate_saved_plots(self.summary.views)
+        for item in items:
+            if item.get('type') == 'table':
+                item.pop('frame', None)  # migrate legacy snapshot records
+        return items
 
     def restore(self, preset_id, tab_id):
         item = next((p for p in self.saved() if p.get('id') == preset_id), None)

apmtools-0.2.56/src/apmtools/shiny/appearance.py

@@ -0,0 +1,149 @@
+"""Figure labels and appearance controls."""
+from __future__ import annotations
+import re
+import threading
+from datetime import date, datetime, time, timedelta
+from collections.abc import Sequence
+import numpy as np
+import pandas as pd
+from ..units import upas_units, lascar_units, purple_units
+
+from .config import VARIABLE_UNITS, PLOT_TYPES, FREQUENCIES, AGGREGATES, _MPL_PALETTES
+
+
+def _axis_label(variable: str) -> str:
+    """Return a variable label with units, including aggregated columns.
+
+    Aggregation produces names such as ``pm25_mean`` or ``CO(ppm)_max``.
+    Strip only a *recognized* aggregation suffix, and only when the full
+    column name does not already have its own units entry.
+    """
+    name = str(variable)
+    unit = VARIABLE_UNITS.get(name)
+    if unit is None:
+        for suffix in ("count", "max", "mean", "median", "min", "std", "sum"):
+            marker = f"_{suffix}"
+            if name.endswith(marker):
+                unit = VARIABLE_UNITS.get(name[:-len(marker)])
+                if unit is not None:
+                    break
+    return f"{name} [{unit}]" if unit else name
+
+
+
+def _label_plot_axes(fig, plot_type, x_column, y_columns, *,
+                     category_columns=None, x_label_override=None):
+    """Label plot axes while retaining special histogram and facet labels."""
+    if plot_type == "histogram":
+        fig.update_xaxes(title_text=_axis_label(x_column))
+    elif plot_type in {"box", "bar"}:
+        categories = category_columns or [x_column]
+        fig.update_xaxes(title_text=" | ".join(_axis_label(c) for c in categories))
+        fig.update_yaxes(title_text="<br>".join(_axis_label(y) for y in y_columns))
+    elif plot_type == "line" and len(y_columns) > 1:
+        fig.update_xaxes(title_text=_axis_label(x_column))
+        fig.update_yaxes(title_text="<br>".join(_axis_label(y) for y in y_columns))
+        for annotation in fig.layout.annotations:
+            label = str(annotation.text)
+            if label.startswith("variable="):
+                annotation.text = _axis_label(label.split("=", 1)[1])
+    else:
+        fig.update_xaxes(title_text=_axis_label(x_column))
+        if y_columns:
+            fig.update_yaxes(title_text=_axis_label(y_columns[0]))
+    if x_label_override is not None:
+        fig.update_xaxes(title_text=x_label_override)
+    return fig
+
+
+
+def _parse_label_map(value):
+    """Parse semicolon-separated original=replacement entries."""
+    result = {}
+    for entry in re.split(r"[;\r\n]+", value or ""):
+        if "=" in entry:
+            key, replacement = entry.split("=", 1)
+            if key.strip() and replacement.strip():
+                result[key.strip()] = replacement.strip()
+    return result
+
+
+
+def _numeric_axis_controls(kind, box_orientation="vertical"):
+    """Return axes on which numeric/date tick-density controls apply."""
+    if kind in ("line", "scatter", "histogram"):
+        return True, True
+    if kind == "box" and box_orientation == "horizontal":
+        return True, False
+    return False, kind in ("box", "bar")
+
+
+
+def _matplotlib_tick_controls(ax, *, kind, box_orientation="vertical", show_grid=True,
+                              x_major_ticks=6, y_major_ticks=6,
+                              x_minor_ticks=False, y_minor_ticks=False):
+    from matplotlib.ticker import MaxNLocator, AutoMinorLocator
+    from matplotlib.dates import AutoDateLocator
+    use_x, use_y = _numeric_axis_controls(kind, box_orientation)
+    for active, axis, count, minor in ((use_x, ax.xaxis, x_major_ticks, x_minor_ticks),
+                                       (use_y, ax.yaxis, y_major_ticks, y_minor_ticks)):
+        if not active:
+            continue
+        count = max(2, min(30, int(count or 6)))
+        if axis.get_scale() == "linear":
+            if isinstance(axis.get_major_locator(), AutoDateLocator):
+                axis.set_major_locator(AutoDateLocator(minticks=max(2, count - 2), maxticks=count))
+            else:
+                axis.set_major_locator(MaxNLocator(nbins=count))
+        if minor:
+            axis.set_minor_locator(AutoMinorLocator())
+        else:
+            axis.set_minor_locator(__import__("matplotlib.ticker", fromlist=["NullLocator"]).NullLocator())
+        axis.grid(bool(show_grid and minor), which="minor")
+
+
+
+def _series_style_maps(line_alpha="", line_style="", scatter_size="", scatter_marker="", scatter_alpha=""):
+    """Parse per-trace styles, keyed by the original legend/series name."""
+    return tuple(_parse_label_map(v) for v in (line_alpha, line_style, scatter_size, scatter_marker, scatter_alpha))
+
+
+
+def _bounded_float(mapping, name, default, low, high):
+    try:
+        value = float(mapping.get(name, default))
+        return value if np.isfinite(value) and low <= value <= high else float(default)
+    except (ValueError, TypeError):
+        return float(default)
+
+
+
+def _line_style(mapping, name):
+    return {"solid": "-", "dotted": ":", "dashed": "--", "-": "-", ":": ":", "--": "--"}.get(
+        mapping.get(name, "solid").strip().lower(), "-")
+
+
+
+def _scatter_marker(mapping, name):
+    return {"dot": "o", "cross": "x", "o": "o", "x": "x"}.get(
+        mapping.get(name, "dot").strip().lower(), "o")
+
+
+
+def _parse_axis_limit(value, *, datetime_axis=False):
+    """Parse numeric bounds or an ISO timestamp for a datetime X axis."""
+    if value is None or not str(value).strip():
+        return None
+    if datetime_axis:
+        try:
+            parsed = pd.to_datetime(value, errors="raise")
+            if not pd.isna(parsed):
+                return parsed
+        except (TypeError, ValueError, OverflowError):
+            return None
+    try:
+        number = float(value)
+        return number if np.isfinite(number) else None
+    except (TypeError, ValueError):
+        return None
+

apmtools-0.2.56/src/apmtools/shiny/inherited_source.py

@@ -0,0 +1,112 @@
+"""Replay configuration-only source transformations for derived tables."""
+from __future__ import annotations
+import copy
+import pandas as pd
+import numpy as np
+from .data import _subset_choices, _apply_filters, _aggregate
+from .config import AGGREGATES, FREQUENCIES
+from .columns import _numeric_columns
+
+
+def _plot_columns(current, step):
+    """Resolve the plot's source columns without guessing aggregation suffixes."""
+    kind = step.get('plot_type', 'line')
+    x = step.get('x') or []
+    y = step.get('y') or []
+    x = [x] if isinstance(x, str) else list(x)
+    y = [y] if isinstance(y, str) else list(y)
+    values = x if kind == 'histogram' else y
+    values = [str(v) for v in values if str(v) in current.columns]
+    groups = step.get('group_by') or []
+    groups = [groups] if isinstance(groups, str) else list(groups)
+    groups = [str(g) for g in groups if g not in ('variables_x', 'variables_y') and str(g) in current.columns]
+    x_columns = [str(v) for v in x if str(v) in current.columns]
+    if kind in ('bar', 'box') and AGGREGATES.get(step.get('aggregate')) is not None:
+        groups = list(dict.fromkeys(groups + x_columns))
+    if kind == 'scatter' and AGGREGATES.get(step.get('aggregate')) is not None:
+        values = list(dict.fromkeys(x_columns + values))
+    return kind, values, groups, x_columns
+
+
+def _plot_source(current, step):
+    """Reconstruct the data contributing to a plot, with its exact aggregation."""
+    kind, values, groups, x_columns = _plot_columns(current, step)
+    if not values:
+        # Legacy plot steps did not capture axis selections.
+        return current
+    # Exclude observations that cannot contribute to any selected outcome.
+    current = current.loc[current[values].notna().any(axis=1)].copy()
+    if current.empty:
+        return current
+    aggregate = AGGREGATES.get(step.get('aggregate'))
+    frequency = FREQUENCIES.get(step.get('frequency'))
+    if aggregate is not None:
+        if kind == 'line' and x_columns and pd.api.types.is_timedelta64_dtype(current[x_columns[0]]):
+            return pd.DataFrame()
+        if frequency is None and not groups:
+            return pd.DataFrame()
+        result = _aggregate(current, values, frequency, groups, aggregate,
+                            only_complete=bool(step.get('only_complete', True)) if frequency is not None else True,
+                            flooring_timestamp=bool(step.get('flooring_timestamp', True)) if frequency is not None else True)
+        if result is None or result.empty:
+            return pd.DataFrame()
+        # group_stat already emits the grouping and frequency columns.
+        return result
+    keep = list(dict.fromkeys(x_columns + groups + values))
+    if 'datetime' in current.columns and 'datetime' not in keep:
+        keep.insert(0, 'datetime')
+    return current.loc[:, keep].copy()
+
+
+def source_frame(summary, steps):
+    """Rebuild a table source from its owning Summary and ordered settings.
+
+    Each step is a configuration snapshot, never a DataFrame snapshot.
+    """
+    current = summary.copy(deep=False)
+    for step in steps or []:
+        for item in step.get('subset_chain', []):
+            name = item.get('column')
+            if name not in current.columns:
+                raise ValueError(f'Inherited source column is unavailable: {name}')
+            _, mapping = _subset_choices(current, name)
+            selected = [mapping[k] for k in item.get('values', []) if k in mapping]
+            if selected:
+                current = current.subset({name: selected}, filter_style=item.get('style', 'all'))
+        current = _apply_filters(current, {}, step.get('datetime_start'), step.get('datetime_end'))
+        for name in step.get('numeric_subset_columns', []):
+            if name not in current.columns:
+                raise ValueError(f'Inherited numeric column is unavailable: {name}')
+            bounds = step.get('numeric_subset_bounds', {}).get(name, {})
+            for op in ('gt', 'lt'):
+                try:
+                    threshold = float(bounds.get(op, ''))
+                except (ValueError, TypeError):
+                    continue
+                if np.isfinite(threshold):
+                    values = pd.to_numeric(current[name], errors='coerce')
+                    matches = values.gt(threshold) if op == 'gt' else values.lt(threshold)
+                    current = current.loc[matches.fillna(False) | values.isna()].copy()
+        # Both plot and table transformations are replayed from the source.
+        # A plot-derived table must contain the actual plotted measurements,
+        # not all numeric columns from the unprocessed Summary.
+        if step.get('_source_kind') == 'plot':
+            current = _plot_source(current, step)
+        elif step.get('_source_kind') == 'table':
+            aggregate = AGGREGATES.get(step.get('aggregate'))
+            if aggregate is not None and not current.empty:
+                frequency = FREQUENCIES.get(step.get('frequency'))
+                groups = list(step.get('group_by') or [])
+                numeric = [c for c in _numeric_columns(current) if c not in groups and current[c].notna().any()]
+                if numeric:
+                    current = _aggregate(current, numeric, frequency, groups, aggregate,
+                        only_complete=bool(step.get('only_complete', True)) if frequency is not None else False,
+                        flooring_timestamp=bool(step.get('flooring_timestamp', True)))
+        current = summary._constructor(current) if not hasattr(current, 'subset') else current
+    return current
+
+
+def source_steps(parent_steps, parent_settings, kind):
+    step = copy.deepcopy(parent_settings)
+    step['_source_kind'] = kind
+    return copy.deepcopy(parent_steps or []) + [step]

apmtools-0.2.56/src/apmtools/shiny/legend_identity.py

@@ -0,0 +1,58 @@
+"""Legend identities based on original columns, not inferred name suffixes."""
+
+
+def variable_aliases(source_variables=(), aggregate=None):
+    """Return processed-column -> source-column identities from plot metadata.
+
+    Never strip suffixes from an arbitrary label: a source column may itself
+    legitimately be named ``temperature_mean``.
+    """
+    return {f"{source}_{aggregate}": str(source) for source in source_variables
+            if aggregate is not None and str(source)}
+
+
+def canonical_legend_key(key, aliases=None):
+    return (aliases or {}).get(str(key), str(key))
+
+
+def canonical_legend_map(mapping, preferred_suffix=None, aliases=None):
+    """Consolidate known aliases while preserving unrelated group identities.
+
+    ``preferred_suffix`` is retained for compatibility with older callers;
+    canonicalization requires explicit aliases to avoid guessing from names.
+    """
+    aliases = aliases or {}
+    groups = {}
+    for key, value in mapping.items():
+        base = canonical_legend_key(key, aliases)
+        groups.setdefault(base, []).append((str(key), value))
+    result = {}
+    for base, entries in groups.items():
+        preferred = next((value for key, value in entries if key in aliases), None)
+        direct = next((value for key, value in entries if key == base), None)
+        chosen = preferred if preferred is not None else direct if direct is not None else entries[0][1]
+        if chosen != base:
+            result[base] = chosen
+    return result
+
+
+def legend_label(mapping, key, aliases=None):
+    key = str(key)
+    return mapping.get(canonical_legend_key(key, aliases), mapping.get(key, key))
+
+
+def original_legend_keys(displayed, mapping, known_keys=(), preferred_suffix=None, aliases=None):
+    mapping = canonical_legend_map(mapping, aliases=aliases)
+    reverse = {}
+    for original, replacement in mapping.items():
+        reverse.setdefault(replacement, set()).add(original)
+    for original in known_keys:
+        base = canonical_legend_key(original, aliases)
+        reverse.setdefault(mapping.get(base, base), set()).add(base)
+    keys = []
+    for label in displayed:
+        matches = reverse.get(label, set())
+        original = next(iter(matches)) if len(matches) == 1 else label
+        if original not in keys:
+            keys.append(original)
+    return tuple(keys)