apmtools 0.2.55__tar.gz → 0.2.57__tar.gz

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

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

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

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

@@ -1011,7 +1011,7 @@ class Group(pd.DataFrame):
 
 class Summary(pd.DataFrame):
 
-    _metadata = ['metadata', 'plots', 'variable', 'description']
+    _metadata = ['metadata', 'views', 'variable', 'description']
 
     @property
     def _constructor(self):
@@ -1023,11 +1023,20 @@ 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):
@@ -1036,7 +1045,11 @@ class Summary(pd.DataFrame):
         # Some older pickles contain an instance-level _metadata list, which
         # masks the corrected class declaration and breaks future copies.
         self.__dict__.pop("_metadata", None)
-        for name, default in (("plots", None), ("variable", 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)
@@ -1046,7 +1059,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, "plots", None)
+            self.views = getattr(other, "views", getattr(other, "plots", None))
 
         return self
 
@@ -1076,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'}:
@@ -1171,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):
@@ -1211,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:
 
@@ -1542,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)
 
@@ -1598,7 +1598,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.55 → apmtools-0.2.57}/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")
@@ -86,22 +129,13 @@ class PlotApp:
             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-outline-primary"),
-                ui.div(id="standalone-save-dataset-slot"),
+                ui.input_action_button("save_dataset_root", "Save dataset", class_="btn-outline-primary"),
                 ui.output_text("dataset_status", inline=True),
                 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.tags.script("""
-              (() => {
-                const move = () => {
-                  const slot = document.getElementById('standalone-save-dataset-slot');
-                  const button = document.querySelector('#summary-dataset-toolbar button');
-                  if (slot && button && button.parentElement !== slot) slot.appendChild(button);
-                };
-                new MutationObserver(move).observe(document.body, {childList:true, subtree:true});
-                document.addEventListener('DOMContentLoaded', move);
-                move();
-              })();
+            ui.tags.style("""
+              body:has(#standalone-toolbar-collapse-toggle) #summary-dataset-toolbar {display:none !important;}
             """),
             ui.output_ui("dataset_workspace"),
             title="PlotApp",
@@ -124,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.55 → 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
@@ -10,6 +11,13 @@ def _json_ready(value):
     return json.loads(json.dumps(value, allow_nan=False))
 
 
+
+def validate_saved_plots(plots):
+    """Backward-compatible name for strict saved-view structural validation."""
+    from .view_schema import validate_saved_views
+    return validate_saved_views(plots)
+
+
 class PlotConfigManager:
     """Keep live tab drafts separate from explicitly retained Summary.plots.
 
@@ -26,7 +34,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 +127,60 @@ 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.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.plots = items
+        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 [])
+        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.57/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.55 → 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