apmtools 0.2.51__tar.gz → 0.2.53__tar.gz

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

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

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

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

@@ -1011,7 +1011,7 @@ class Group(pd.DataFrame):
 
 class Summary(pd.DataFrame):
 
-    _metadata = ['metadata', 'plot']
+    _metadata = ['metadata', 'plots']
 
     @property
     def _constructor(self):
@@ -1026,7 +1026,7 @@ class Summary(pd.DataFrame):
         self.plots = None
 
     def __setattr__(self, name, value):
-        if name == "plot" and value is not None and not isinstance(value, list):
+        if name == "plots" and value is not None and not isinstance(value, list):
             raise TypeError("Summary.plot must be None or a list")
         super().__setattr__(name, value)
 
@@ -1035,7 +1035,7 @@ class Summary(pd.DataFrame):
             self.variable = getattr(other, "variable", None)
             self.metadata = getattr(other, "metadata", set()).copy()
             self.description = getattr(other, "description", "")
-            self.plots = getattr(other, "plot", None)
+            self.plots = getattr(other, "plots", None)
 
         return self
 

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

@@ -71,11 +71,15 @@ class PlotApp:
         # Do not change process-wide pandas settings here.
         # With older pandas and CoW disabled, a shallow copy may share writes.
         self.summary = summary.copy(deep=False)
+        # Explicitly retained presets belong to the source Summary. Avoid
+        # mutating a shared list accidentally through the working frame.
+        self.summary.plots = None if getattr(summary, "plots", None) is None else list(summary.plots)
 
     def create_app(self):
         """Build an app whose complete plotting workspace is replaced on load."""
         from shiny import App, module, reactive, render, ui
         from .shiny.ui import _build_summary_ui_server
+        from .plot_configs import PlotConfigManager
         import shinyswatch
 
         app_ui = ui.page_fluid(
@@ -150,16 +154,17 @@ class PlotApp:
                 # Building inner_ui before entering @module.ui leaves toolbar
                 # inputs unprefixed, while the module server listens for
                 # dataset_N-add_tab / dataset_N-add_table.
+                manager = PlotConfigManager(self.original_summary)
                 @module.ui
                 def workspace_ui():
                     inner_ui, _ = _build_summary_ui_server(
-                        data, **self.options, include_theme_picker=False)
+                        data, **self.options, include_theme_picker=False, config_manager=manager)
                     return inner_ui
 
                 @module.server
                 def workspace_server(input, output, session):
                     _, inner_server = _build_summary_ui_server(
-                        data, **self.options, include_theme_picker=False)
+                        data, **self.options, include_theme_picker=False, config_manager=manager)
                     return inner_server(input, output, session)
 
                 ui_factories[name] = workspace_ui

apmtools-0.2.53/src/apmtools/plot_configs.py

@@ -0,0 +1,143 @@
+"""Plot configuration lifecycle: reactive drafts and explicitly retained presets."""
+from __future__ import annotations
+import copy
+import json
+import uuid
+
+
+def _json_ready(value):
+    """Require portable, plain JSON-compatible configuration values."""
+    return json.loads(json.dumps(value, allow_nan=False))
+
+
+class PlotConfigManager:
+    """Keep live tab drafts separate from explicitly retained Summary.plots.
+
+    All mutations go through methods. When used within Shiny, each tab has
+    independent reactive signals for data and appearance changes. Retained
+    presets are snapshots and are never modified by draft updates.
+    """
+
+    def __init__(self, summary):
+        self.summary = summary
+        self.drafts = {}
+        self.revision = 0  # Backwards-compatible diagnostic counter, not reactive.
+        self._signals = {}
+        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')
+
+    # Settings that affect filtering, grouping or aggregation. Everything else
+    # is treated as presentation state. Panel layout (panel_by) is
+    # presentation-only: it must not invalidate filtering or aggregation. Unknown settings remain in the full
+    # snapshot and are conservatively classified as appearance-only until
+    # explicitly added here.
+    DATA_KEYS = frozenset({
+        'plot_type', 'x', 'y', 'numeric_subset_columns',
+        'numeric_subset_bounds', 'subset_chain', 'datetime_start',
+        'datetime_end', 'group_by', 'frequency', 'aggregate',
+        'only_complete', 'flooring_timestamp', 'multi_y_color_by',
+    })
+
+    def _signal(self, tab_id, kind):
+        # Created only for a tab that is actually used. Shiny is imported
+        # lazily so the manager remains usable outside a Shiny session.
+        from shiny import reactive
+        signals = self._signals.setdefault(tab_id, {})
+        if kind not in signals:
+            signals[kind] = reactive.value(0)
+        return signals[kind]
+
+    def watch(self, tab_id, kind='all'):
+        """Declare a per-tab reactive dependency (all/data/appearance/visibility)."""
+        if kind not in ('all', 'data', 'appearance', 'visibility'):
+            raise ValueError('Unknown configuration signal')
+        return self._signal(tab_id, kind).get()
+
+    def update(self, tab_id, config):
+        config = _json_ready(config)
+        previous = self.drafts.get(tab_id)
+        if previous == config:
+            return False
+        self.drafts[tab_id] = config
+        self.revision += 1
+        changed = set(config) | set(previous or {})
+        changed = {k for k in changed if (previous or {}).get(k) != config.get(k)}
+        kinds = {'all'}
+        if changed & self.DATA_KEYS:
+            kinds.add('data')
+        if changed - self.DATA_KEYS:
+            kinds.add('appearance')
+        if 'visible_elements' in changed:
+            kinds.add('visibility')
+        # Only notify signals that have subscribers; don't create signals
+        # for every tab and category when nobody observes them.
+        for kind in kinds:
+            signal = self._signals.get(tab_id, {}).get(kind)
+            if signal is not None:
+                signal.set(signal.get() + 1)
+        return True
+
+    def get(self, tab_id, *, watch=False, kind='all'):
+        if watch:
+            self.watch(tab_id, kind)
+        return copy.deepcopy(self.drafts[tab_id])
+
+
+    def patch(self, tab_id, changes):
+        """Apply a partial UI change to the canonical tab configuration.
+
+        Retain unrelated fields (including settings in inactive sidebar tabs).
+        Return False for no-op updates; never mutate a retained preset.
+        """
+        if not isinstance(changes, dict):
+            raise TypeError('Configuration changes must be a dictionary')
+        current = self.get(tab_id) if tab_id in self.drafts else {}
+        current.update(_json_ready(changes))
+        return self.update(tab_id, current)
+
+    def value(self, tab_id, key, default=None, *, watch=False):
+        """Read a setting from one tab without exposing mutable state."""
+        if watch:
+            self.watch(tab_id)
+        return copy.deepcopy(self.drafts.get(tab_id, {}).get(key, default))
+
+    def discard(self, tab_id):
+        if tab_id in self.drafts:
+            del self.drafts[tab_id]
+            self.revision += 1
+            self._signals.pop(tab_id, None)
+
+    def retain(self, tab_id, name, *, preset_id=None):
+        """Persist only this explicitly chosen draft in Summary.plots."""
+        if tab_id not in self.drafts:
+            raise KeyError(f'No live configuration for {tab_id}')
+        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': 'plot', 'settings': self.get(tab_id)}
+        items = copy.deepcopy(self.summary.plots 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.revision += 1
+        return preset_id
+
+    def saved(self):
+        return copy.deepcopy(self.summary.plots or [])
+
+    def restore(self, preset_id, tab_id):
+        item = next((p for p in self.saved() if p.get('id') == preset_id), None)
+        if item is None:
+            raise KeyError(preset_id)
+        if item.get('schema_version') != 1 or item.get('type') != 'plot':
+            raise ValueError('Unsupported saved configuration')
+        self.update(tab_id, item['settings'])
+        return self.get(tab_id)

apmtools-0.2.53/src/apmtools/shiny/filter_config.py

@@ -0,0 +1,22 @@
+"""Pure transformations for canonical plot-filter configuration.
+
+No Shiny reactive reads or writes belong here. Both the renderer-facing
+filter state and explicit saved snapshots use this same mapping.
+"""
+from __future__ import annotations
+import copy
+
+
+def filter_config_fields(state):
+    """Return independent JSON-compatible draft fields for effective filters.
+
+    The stage order and selected numerical-column order are preserved.
+    Copies prevent later UI mutations from altering a saved snapshot.
+    """
+    return {
+        "subset_chain": copy.deepcopy(state["stages"]),
+        "numeric_subset_bounds": copy.deepcopy(state["numeric_bounds"]),
+        "numeric_subset_columns": list(state["numeric_bounds"]),
+        "datetime_start": state["start"],
+        "datetime_end": state["end"],
+    }

{apmtools-0.2.51 → apmtools-0.2.53}/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")}
@@ -170,11 +181,15 @@ def _panel_trace_defaults(spec, panel_by, *, palette="Default"):
     columns are facets, each panel contains an ungrouped "All observations"
     trace; when some grouping columns remain, their values label the traces.
     """
+    # Preserve first-seen order while avoiding a linear scan for every
+    # repeated trace name across panels (particularly with many facets).
     names = []
+    seen_names = set()
     for _, part, remaining in _panel_partitions(spec, panel_by):
         panel_spec = {**spec, "data": part, "groups": remaining}
         for name in _matplotlib_defaults(panel_spec, palette=palette)["names"]:
-            if name not in names:
+            if name not in seen_names:
+                seen_names.add(name)
                 names.append(name)
     if not names:
         return _matplotlib_defaults(spec, palette=palette)
@@ -360,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:
@@ -400,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
@@ -453,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():
@@ -481,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)
@@ -580,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:
@@ -596,7 +642,9 @@ def _matplotlib_direct_figure(spec, *, title="", x_label="", y_label="",
                     key = (str(y), str(name) if group_col else None)
                     ax.plot(part[x], part[y], color=(multi_colors[key] if multi_y else colors.get(name, palette_values[0])),
                             linewidth=float(line_width),
-                            linestyle=(multi_dashes[key] if multi_y else _line_style(styles, name)),
+                            linestyle=(_line_style(styles, name) if not multi_y else
+                                       _line_style(styles, name) if name in styles and len(ys) == 1 else
+                                       multi_dashes[key]),
                             alpha=_bounded_float(alphas, name, 1, 0, 1),
                             label=("_nolegend_" if multi_y else rename.get(name, name)))
     elif kind in ("box", "bar"):

{apmtools-0.2.51 → apmtools-0.2.53}/src/apmtools/shiny/multi_y.py

@@ -44,10 +44,16 @@ def multi_y_styles(variables, groups, palette, mode="group", colors=None, styles
             # For colour-by-variable, the grouping dimension must control dashes.
             # Do not let a variable-level style override erase that distinction.
             default_dash = dash_values[secondary.index(q) % len(dash_values)] if q in secondary else "-"
+            # With a single Y variable, newly introduced groups should not
+            # inherit a previous ungrouped line style or an implicit dash cycle.
+            if len(variables) == 1 and groups and mode == "group":
+                default_dash = "-"
             # The Shiny appearance panel automatically populates each group with
             # "solid".  Those generated defaults must not collapse the
             # group-specific dash cycle in colour-by-variable mode.
             override = styles.get(q)
+            if override is None and not groups:
+                override = styles.get(var, styles.get("All observations"))
             if mode == "variable" and groups and override in ("solid", "-"):
                 override = None
             dash_map[(var, group)] = override if override is not None else default_dash