apmtools 0.2.56__tar.gz → 0.2.57__tar.gz

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

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

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

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

@@ -1224,7 +1224,12 @@ class Summary(pd.DataFrame):
                     print(f"{v} not in  Summary columns")
                     return None
 
-        df = self.dropna(subset=[time_col]).copy()
+        # Non-temporal grouping also works on previously aggregated frames.
+        # Only operations involving a frequency need the source time column.
+        if frequency is not None and time_col not in self.columns:
+            raise KeyError(f"Temporal aggregation requires column {time_col!r}")
+        df = (self.dropna(subset=[time_col]).copy()
+              if frequency is not None else self.copy())
 
         if frequency != None:
 
@@ -1555,38 +1560,20 @@ class Summary(pd.DataFrame):
                                 df[freq] = df["datetime"].map(
                                     lambda x: (x.weekday//mult))*mult
 
-        if isinstance(frequency, str):
-            if grouping_by != None:
-                output = df.groupby(grouping_by+[frequency], dropna=False)
-            else:
-                output = df.groupby([frequency], dropna=False)
-        if isinstance(frequency, list):
-            if grouping_by != None:
-                output = df.groupby(grouping_by+frequency, dropna=False)
-            else:
-                output = df.groupby(frequency, dropna=False)
-        if frequency == None:
-            if grouping_by != None:
-                output = df.groupby(grouping_by, dropna=False)
-            else:
-                output = df
+        # A frequency may also be an explicitly selected grouping variable.
+        # pandas allows repeated group keys but reset_index() then attempts to
+        # insert the same column twice (e.g. "cannot insert hour, already exists").
+        # Preserve the requested order while grouping each key only once.
+        grouping_keys = list(dict.fromkeys(
+            list(grouping_by or []) +
+            ([frequency] if isinstance(frequency, str) else
+             list(frequency) if isinstance(frequency, list) else [])
+        ))
+        if frequency is not None or grouping_by is not None:
+            output = df.groupby(grouping_keys, dropna=False) if aggregate is not None else df[grouping_keys]
+        else:
+            output = df
 
-        if isinstance(frequency, str) and aggregate is None:
-            if grouping_by != None:
-                output = df[grouping_by+[frequency]]
-            else:
-                output = df[[frequency]]
-        if isinstance(frequency, list) and aggregate is None:
-            if grouping_by != None:
-                output = df[grouping_by+frequency]
-            else:
-                output = df[frequency]
-        if frequency == None and aggregate is None:
-            if grouping_by != None:
-                output = df[grouping_by]
-            else:
-                output = df
-                
         if aggregate is not None:
             output = output[value_cols].agg(aggregate)
 

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

@@ -1,5 +1,6 @@
 """Plot configuration lifecycle: reactive drafts and explicitly retained presets."""
 from __future__ import annotations
+from .shiny.profiling import traced
 import copy
 import json
 import uuid
@@ -12,27 +13,10 @@ def _json_ready(value):
 
 
 def validate_saved_plots(plots):
-    """Validate the structure of retained presets without altering their values.
+    """Backward-compatible name for strict saved-view structural validation."""
+    from .view_schema import validate_saved_views
+    return validate_saved_views(plots)
 
-    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.
@@ -195,11 +179,8 @@ class PlotConfigManager:
         self.revision += 1
 
     def saved(self):
-        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
+        from .view_schema import migrate_saved_views
+        return migrate_saved_views(self.summary.views)
 
     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 → apmtools-0.2.57}/src/apmtools/shiny/data.py

@@ -1,5 +1,6 @@
 """Filtering, aggregation and temporal segmentation."""
 from __future__ import annotations
+from .profiling import traced
 import threading
 from datetime import date, datetime, time, timedelta
 from collections.abc import Sequence
@@ -82,6 +83,7 @@ def _parse_datetime_filter(value):
 
 
 
+@traced('_apply_filters', kind="data" if 'shiny/data.py' not in ("plot_configs.py", "shiny/matplotlib_renderer.py") else "service")
 def _apply_filters(data, subset_filters, datetime_start=None, datetime_end=None):
     """Apply Summary filters, accepting dates, times and full datetimes.
 
@@ -123,6 +125,7 @@ def _apply_filters(data, subset_filters, datetime_start=None, datetime_end=None)
 
 
 
+@traced('_aggregate', kind="data" if 'shiny/data.py' not in ("plot_configs.py", "shiny/matplotlib_renderer.py") else "service")
 def _aggregate(data, value_columns, frequency, grouping_by, aggregate, *,
                only_complete=True, flooring_timestamp=True):
     """Aggregate through ``Summary.group_stat``.
@@ -138,13 +141,10 @@ def _aggregate(data, value_columns, frequency, grouping_by, aggregate, *,
         # Return empty rather than breaking Shiny's reactive graph.
         return pd.DataFrame()
 
-    result = data.group_stat(
-        value_cols=value_columns,
-        frequency=frequency,
-        grouping_by=grouping_by,
-        aggregate=[aggregate],
-        **({"only_complete": only_complete, "flooring_timestamp": flooring_timestamp}
-           if frequency is not None else {}),
+    from .view_aggregation import aggregate_view
+    result = aggregate_view(
+        data, value_columns, frequency, grouping_by, aggregate,
+        only_complete=only_complete, flooring_timestamp=flooring_timestamp,
     )
     if result is None:
         # group_stat() may return None when no rows survive completeness

apmtools-0.2.57/src/apmtools/shiny/derived_views.py

@@ -0,0 +1,35 @@
+"""Headless, configuration-only table source preparation for Shiny tab actions.
+
+The application creates tables from the owning Summary and ordered view
+settings, never from snapshots of already rendered plot/table data.
+"""
+from __future__ import annotations
+
+import pandas as pd
+
+from .inherited_source import source_frame, source_steps
+
+
+def prepare_table_source(summary, *, parent_kind=None, parent_settings=None,
+                         parent_steps=None, restored_settings=None):
+    """Return (display-ready frame, lineage steps) for new/loaded tables.
+
+    ``parent_kind`` is ``'plot'``, ``'table'`` or ``None`` (Info tab).
+    For restoration, pass ``restored_settings`` instead; its saved lineage is
+    replayed without modification.  No parent DataFrame is copied or cached.
+    """
+    if restored_settings is not None:
+        steps = restored_settings.get('source_steps', [])
+    elif parent_kind in ('plot', 'table'):
+        if parent_settings is None:
+            raise ValueError('Parent view settings must be supplied')
+        steps = source_steps(parent_steps if parent_kind == 'table' else [],
+                             parent_settings, parent_kind)
+    elif parent_kind is None:
+        steps = []
+    else:
+        raise ValueError(f'Unknown parent view kind: {parent_kind!r}')
+    frame = source_frame(summary, steps)
+    frame = frame.reset_index(drop=True)
+    frame.columns = [str(column) for column in frame.columns]
+    return frame, steps

{apmtools-0.2.56 → apmtools-0.2.57}/src/apmtools/shiny/inherited_source.py

@@ -1,11 +1,14 @@
 """Replay configuration-only source transformations for derived tables."""
 from __future__ import annotations
+from .profiling import traced
 import copy
+import os
 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
+from .view_aggregation import normalize_statistics
 
 
 def _plot_columns(current, step):
@@ -19,15 +22,16 @@ def _plot_columns(current, step):
     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]
+    groups = [str(g) for g in groups if g not in ('variables_x', 'variables_y', 'statistics') 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:
+    if kind in ('bar', 'box') and bool(normalize_statistics(step.get('aggregate'))):
         groups = list(dict.fromkeys(groups + x_columns))
-    if kind == 'scatter' and AGGREGATES.get(step.get('aggregate')) is not None:
+    if kind == 'scatter' and bool(normalize_statistics(step.get('aggregate'))):
         values = list(dict.fromkeys(x_columns + values))
     return kind, values, groups, x_columns
 
 
+@traced('_plot_source', kind="data" if 'shiny/inherited_source.py' not in ("plot_configs.py", "shiny/matplotlib_renderer.py") else "service")
 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)
@@ -38,9 +42,9 @@ def _plot_source(current, step):
     current = current.loc[current[values].notna().any(axis=1)].copy()
     if current.empty:
         return current
-    aggregate = AGGREGATES.get(step.get('aggregate'))
+    aggregate = normalize_statistics(step.get('aggregate'))
     frequency = FREQUENCIES.get(step.get('frequency'))
-    if aggregate is not None:
+    if aggregate:
         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:
@@ -58,7 +62,7 @@ def _plot_source(current, step):
     return current.loc[:, keep].copy()
 
 
-def source_frame(summary, steps):
+def _legacy_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.
@@ -93,11 +97,13 @@ def source_frame(summary, steps):
         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:
+            aggregate = normalize_statistics(step.get('aggregate'))
+            if aggregate 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()]
+                numeric = [c for c in (step.get('aggregate_columns') if step.get('aggregate_columns') is not None
+                                       else _numeric_columns(current))
+                           if c in current.columns and 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,
@@ -110,3 +116,17 @@ def source_steps(parent_steps, parent_settings, kind):
     step = copy.deepcopy(parent_settings)
     step['_source_kind'] = kind
     return copy.deepcopy(parent_steps or []) + [step]
+
+
+@traced('source_frame', kind='data')
+def source_frame(summary, steps):
+    """Reconstruct derived table data with the unified executor by default.
+
+    Set ``APMTOOLS_TRANSFORM_ENGINE=0`` (also ``false``, ``no``, or
+    ``legacy``) to temporarily retain the historical processing behavior.
+    Errors from the selected executor propagate without silent fallback.
+    """
+    if os.getenv('APMTOOLS_TRANSFORM_ENGINE', '').strip().lower() not in ('0', 'false', 'no', 'legacy'):
+        from .transformations import execute_view, from_legacy_source_steps
+        return execute_view(summary, from_legacy_source_steps(steps))
+    return _legacy_source_frame(summary, steps)

{apmtools-0.2.56 → apmtools-0.2.57}/src/apmtools/shiny/matplotlib_renderer.py

@@ -1,5 +1,6 @@
 """Native and converted Matplotlib figures and panel layout."""
 from __future__ import annotations
+from .profiling import traced
 import threading
 from datetime import date, datetime, time, timedelta
 from collections.abc import Sequence
@@ -293,21 +294,25 @@ def _place_outside_legend(fig, axes, position="right", font_size=12, ncol=1,
     A single legend is shared across panels. Only one full canvas draw is used
     for measuring; no automatic column search or placement fallback.
     """
+    # Entry identity is positional within a panel, not its editable label.
+    # This retains two distinct handles renamed to the same displayed text,
+    # while collapsing corresponding entries repeated across panels.
     seen = {}
     for ax in axes:
         old = ax.get_legend()
         if old is None:
             continue
-        for handle, label in zip(old.legend_handles,
-                                 [t.get_text() for t in old.get_texts()]):
-            if label and label not in seen:
-                seen[label] = handle
+        for index, (handle, label) in enumerate(zip(old.legend_handles,
+                                 [t.get_text() for t in old.get_texts()])):
+            if label and index not in seen:
+                seen[index] = (handle, label)
         old.set_visible(False)
         old.set_in_layout(False)
     if not seen:
         fig.tight_layout()
         return
-    labels, handles = list(seen), list(seen.values())
+    handles = [entry[0] for entry in seen.values()]
+    labels = [entry[1] for entry in seen.values()]
     pos = position if position in ("right", "left", "top", "bottom") else "right"
     ncol = max(1, min(int(ncol or 1), len(labels)))
     legend = fig.legend(handles, labels, ncol=ncol, loc="center",
@@ -343,6 +348,7 @@ def _place_outside_legend(fig, axes, position="right", font_size=12, ncol=1,
         # between facet axes.  This changes only the internal subplot gaps.
         fig.subplots_adjust(wspace=panel_wspace, hspace=panel_hspace)
 
+@traced('_matplotlib_direct_figure', kind="data" if 'shiny/matplotlib_renderer.py' not in ("plot_configs.py", "shiny/matplotlib_renderer.py") else "service")
 def _matplotlib_direct_figure(spec, *, title="", x_label="", y_label="",
                               legend_labels="", trace_colors="", palette="Default",
                               x_min="", x_max="", y_min="", y_max="",
@@ -767,9 +773,8 @@ def _matplotlib_direct_figure(spec, *, title="", x_label="", y_label="",
 
     if kind not in ("box", "bar") and not spec.get("multi_axis"):
         handles, texts = ax.get_legend_handles_labels()
-        unique = dict(zip(texts, handles))
-        if unique and not spec.get("_hide_ungrouped_legend", not bool(spec["groups"])):
-            ax.legend(unique.values(), unique.keys(), title="Legend")
+        if handles and not spec.get("_hide_ungrouped_legend", not bool(spec["groups"])):
+            ax.legend(handles, texts, title="Legend")
     if multi_y:
         from matplotlib.lines import Line2D
         # Independent legend keys for the two dimensions, with explicit headings.

apmtools-0.2.57/src/apmtools/shiny/multi_stat_plot.py

@@ -0,0 +1,53 @@
+"""Convert multi-statistic wide results to renderer-compatible plot data."""
+from __future__ import annotations
+
+import pandas as pd
+
+
+def prepare_multi_stat_plot(frame, sources, statistics, *, split_statistics=False,
+                            split_variables=False):
+    """Return a plot frame and Y columns with optional virtual dimensions.
+
+    When split_statistics is disabled, every source/statistic combination is
+    displayed as a separate Y series. When enabled, the statistics dimension
+    becomes a categorical grouping key, while series remain source-specific.
+    Missing source/statistic combinations stay as all-NA columns.
+    """
+    sources = list(dict.fromkeys(sources))
+    statistics = list(dict.fromkeys(statistics))
+    columns = [f"{source}_{stat}" for source in sources for stat in statistics]
+    work = pd.DataFrame(frame).copy()
+    for col in columns:
+        if col not in work:
+            work[col] = float('nan')
+    if not split_statistics and not split_variables:
+        return work, columns
+
+    # Always copy Y values before melting so that scatter X columns which
+    # overlap selected Y variables remain available to the renderer.
+    temporaries = []
+    names = {}
+    for i, source in enumerate(sources):
+        for stat in statistics:
+            temp = f"__multi_stat_y_{i}_{stat}"
+            while temp in work:
+                temp += "_"
+            work[temp] = work[f"{source}_{stat}"]
+            temporaries.append(temp)
+            names[temp] = (source, stat)
+    work = work.melt(id_vars=[c for c in work if c not in temporaries],
+                     value_vars=temporaries, var_name="__stat_source", value_name="__stat_value")
+    work["variables_y"] = work["__stat_source"].map(lambda k: str(names[k][0]))
+    work["statistics"] = work["__stat_source"].map(lambda k: str(names[k][1]))
+    work = work.drop(columns=["__stat_source"])
+    # Restrict the groups if only one of the two virtual dimensions is selected
+    # by combining the other dimension into the plot series label.
+    if split_statistics and split_variables:
+        return work, ["__stat_value"]
+    if split_statistics:
+        if len(sources) == 1:
+            return work, ["__stat_value"]
+        # Multiple sources must remain distinct series under a statistic group.
+        # Group composition is handled by the caller.
+        return work, ["__stat_value"]
+    return work, ["__stat_value"]

apmtools-0.2.57/src/apmtools/shiny/profile_report.py

@@ -0,0 +1,51 @@
+"""Summarize opt-in Shiny traces: python -m apmtools.shiny.profile_report trace.jsonl"""
+from __future__ import annotations
+import argparse
+from collections import defaultdict
+import json
+from pathlib import Path
+
+
+def summarize(path):
+    groups = defaultdict(list)
+    failures = defaultdict(int)
+    for line in Path(path).read_text(encoding='utf-8').splitlines():
+        if not line.strip():
+            continue
+        try:
+            record = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if record.get('event') != 'execution':
+            continue
+        key = (record.get('kind', 'unknown'), record.get('name', 'unknown'))
+        groups[key].append(float(record.get('duration_ms', 0)))
+        if record.get('error'):
+            failures[key] += 1
+    rows = []
+    for key, durations in groups.items():
+        ordered = sorted(durations)
+        rows.append({'kind': key[0], 'name': key[1], 'calls': len(ordered),
+                     'total_ms': round(sum(ordered), 2),
+                     'mean_ms': round(sum(ordered)/len(ordered), 2),
+                     'p95_ms': ordered[min(len(ordered)-1, int(.95*(len(ordered)-1)))],
+                     'max_ms': ordered[-1], 'errors': failures[key]})
+    return sorted(rows, key=lambda r: r['total_ms'], reverse=True)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('trace', help='Path to APMTOOLS_TRACE_PATH JSONL file')
+    parser.add_argument('--top', type=int, default=35)
+    parser.add_argument('--json', action='store_true')
+    args = parser.parse_args()
+    rows = summarize(args.trace)
+    if args.json:
+        print(json.dumps(rows[:args.top], indent=2))
+        return
+    print(f"{'kind':17} {'name':37} {'calls':>6} {'total ms':>10} {'p95 ms':>10} {'errors':>6}")
+    for r in rows[:args.top]:
+        print(f"{r['kind'][:17]:17} {r['name'][:37]:37} {r['calls']:6} {r['total_ms']:10.2f} {r['p95_ms']:10.2f} {r['errors']:6}")
+
+if __name__ == '__main__':
+    main()

apmtools-0.2.57/src/apmtools/shiny/profiling.py

@@ -0,0 +1,103 @@
+"""Opt-in, low-overhead JSONL tracing for Shiny callbacks and data operations.
+
+Set APMTOOLS_TRACE_PATH to a writable .jsonl path before launching the app.
+Records invocations (not Shiny internal invalidation notifications). Never logs
+row values or input contents. Each record is one JSON object.
+"""
+from __future__ import annotations
+
+import contextvars
+import functools
+import json
+import os
+from pathlib import Path
+import threading
+import time
+import uuid
+
+_current_span = contextvars.ContextVar('apmtools_trace_span', default=None)
+_lock = threading.RLock()
+_session = uuid.uuid4().hex[:12]
+
+
+def enabled():
+    return bool(os.environ.get('APMTOOLS_TRACE_PATH'))
+
+
+def _emit(event):
+    path = os.environ.get('APMTOOLS_TRACE_PATH')
+    if not path:
+        return
+    record = {'timestamp_ns': time.time_ns(), 'session': _session, **event}
+    try:
+        with _lock:
+            destination = Path(path).expanduser()
+            destination.parent.mkdir(parents=True, exist_ok=True)
+            with destination.open('a', encoding='utf-8') as stream:
+                stream.write(json.dumps(record, default=str, separators=(',', ':')) + '\n')
+    except OSError:
+        # Profiling must never interrupt the Shiny application.
+        pass
+
+
+def traced(label=None, *, kind='function', trigger=None):
+    """Instrument a synchronous or asynchronous callable without altering its API."""
+    def decorate(func):
+        name = label or f'{func.__module__}.{func.__qualname__}'
+        if hasattr(func, '__wrapped_by_apmtools_trace__'):
+            return func
+        if __import__('inspect').iscoroutinefunction(func):
+            @functools.wraps(func)
+            async def wrapped(*args, **kwargs):
+                return await _run_async(func, name, kind, trigger, args, kwargs)
+        else:
+            @functools.wraps(func)
+            def wrapped(*args, **kwargs):
+                if not enabled():
+                    return func(*args, **kwargs)
+                parent = _current_span.get()
+                span = uuid.uuid4().hex[:12]
+                token = _current_span.set(span)
+                start = time.perf_counter_ns()
+                error = None
+                try:
+                    return func(*args, **kwargs)
+                except BaseException as exc:
+                    error = type(exc).__name__
+                    raise
+                finally:
+                    duration = time.perf_counter_ns() - start
+                    _current_span.reset(token)
+                    _emit({'event': 'execution', 'kind': kind, 'name': name,
+                           'trigger': trigger, 'span': span, 'parent': parent,
+                           'duration_ms': round(duration / 1e6, 3), 'error': error})
+        wrapped.__wrapped_by_apmtools_trace__ = True
+        return wrapped
+    return decorate
+
+
+async def _run_async(func, name, kind, trigger, args, kwargs):
+    if not enabled():
+        return await func(*args, **kwargs)
+    parent = _current_span.get()
+    span = uuid.uuid4().hex[:12]
+    token = _current_span.set(span)
+    start = time.perf_counter_ns()
+    error = None
+    try:
+        return await func(*args, **kwargs)
+    except BaseException as exc:
+        error = type(exc).__name__
+        raise
+    finally:
+        duration = time.perf_counter_ns() - start
+        _current_span.reset(token)
+        _emit({'event': 'execution', 'kind': kind, 'name': name,
+               'trigger': trigger, 'span': span, 'parent': parent,
+               'duration_ms': round(duration / 1e6, 3), 'error': error})
+
+
+def marker(name, **metadata):
+    """Mark a user interaction or application lifecycle event (no raw data)."""
+    if enabled():
+        _emit({'event': 'marker', 'name': name, 'parent': _current_span.get(), **metadata})

{apmtools-0.2.56 → apmtools-0.2.57}/src/apmtools/shiny/state.py

@@ -51,3 +51,17 @@ def snapshot_inputs(current, input_values):
         if key in SNAPSHOT_INPUT_KEYS and value is not None:
             result[key] = list(value) if isinstance(value, (tuple, list)) else value
     return result
+
+
+def restore_panel_selection(groups, current, saved, pending=False):
+    """Reconcile facet choices without erasing a not-yet-mounted saved facet.
+
+    Returns (selection, pending).  Once restored, user edits take precedence.
+    """
+    groups = list(groups or [])
+    saved = list(saved or [])
+    if pending:
+        if not all(name in groups for name in saved):
+            return [], True
+        return [name for name in saved if name in groups], False
+    return [name for name in (current or []) if name in groups], False

apmtools-0.2.57/src/apmtools/shiny/tab_initialization.py

@@ -0,0 +1,74 @@
+"""Headless preparation of new and restored Shiny tabs.
+
+The UI still owns Shiny module creation, reactive counters and DOM mounting.
+This module resolves the data and settings needed *before* mounting a tab.
+"""
+from __future__ import annotations
+
+import copy
+from dataclasses import dataclass
+from typing import Any
+import pandas as pd
+
+from .derived_views import prepare_table_source
+
+
+@dataclass(frozen=True)
+class PlotInitialization:
+    label: str
+    settings: dict
+
+
+@dataclass(frozen=True)
+class TableInitialization:
+    label: str
+    frame: pd.DataFrame
+    settings: dict | None
+    lineage: list
+
+
+class TabInitializer:
+    """Resolve plot/table initialization without importing Shiny."""
+
+    def __init__(self, workspace, views, summary):
+        self.workspace = workspace
+        self.views = views
+        self.summary = summary
+
+    def new_plot(self, selected, number):
+        # A partially initialized input can fail during a snapshot; preserve
+        # the existing 'start with defaults' behavior for this operation.
+        inherited = {}
+        if self.workspace.kind(selected) == 'plot':
+            try:
+                inherited = copy.deepcopy(self.workspace.plot_snapshots[selected]())
+            except Exception:
+                inherited = {}
+        return PlotInitialization(f'Plot {number}', inherited)
+
+    def restored_plot(self, preset_id, tab_id, number):
+        preset = self.views.preset(preset_id)
+        inherited = self.views.restore_plot(preset_id, tab_id)
+        return PlotInitialization(preset.get('name') or f'Plot {number}', inherited)
+
+    def new_table(self, selected, number):
+        kind = self.workspace.kind(selected)
+        if kind == 'table':
+            frame, steps = prepare_table_source(
+                self.summary, parent_kind='table',
+                parent_steps=self.workspace.table_lineage.get(selected, []),
+                parent_settings=self.workspace.table_settings[selected]())
+        elif kind == 'plot':
+            frame, steps = prepare_table_source(
+                self.summary, parent_kind='plot',
+                parent_settings=self.workspace.plot_snapshots[selected]())
+        else:
+            frame, steps = prepare_table_source(self.summary)
+        return TableInitialization(f'Table {number}', frame, None, steps)
+
+    def restored_table(self, preset_id, number):
+        preset = self.views.preset(preset_id)
+        _source, settings = self.views.restore_table(preset_id)
+        frame, steps = prepare_table_source(self.summary, restored_settings=settings)
+        return TableInitialization(preset.get('name') or f'Table {number}',
+                                   frame, settings, steps)