apmtools 0.2.52__tar.gz → 0.2.53__tar.gz

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

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

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

{apmtools-0.2.52 → 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")}
@@ -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.53}/src/apmtools/shiny/ui.py

@@ -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,7 @@ 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]
 
             @reactive.effect
             @reactive.event(prepared_plot, lambda: _optional_input("multi_panel", False) if input.group_by() else False,
@@ -1480,9 +1535,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)