apmtools 0.2.26__tar.gz → 0.2.28__tar.gz

{apmtools-0.2.26 → apmtools-0.2.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: apmtools
-Version: 0.2.026
+Version: 0.2.028
 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.26 → apmtools-0.2.28}/pyproject.toml

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

{apmtools-0.2.26 → apmtools-0.2.28}/src/apmtools/shiny/summary.py

@@ -508,279 +508,307 @@ def create_summary_app(
 
     @module.server
     def plot_tab_server(input, output, session, initial_filters=None):
-         initial_filters = initial_filters or {}
-
-          @render.ui
-           def subset_filters():
-                controls = []
-                for i, name in enumerate(list(input.subset_columns())):
-                    if name not in column_map:
-                        continue
-                    choices, _ = _subset_choices(summary, column_map[name])
-                    controls.append(ui.input_selectize(
-                        f"subset_values_{i}", f"{name} values", choices=choices,
-                        selected=initial_filters.get(
-                            "values", {}).get(name, []),
-                        multiple=True,
-                    ))
-                return ui.div(*controls) if controls else ui.help_text("Select columns to filter this plot.")
-
-            @reactive.calc
-            def filter_state():
-                names = list(input.subset_columns())
-                values = {}
-                for i, name in enumerate(names):
-                    if name in column_map:
-                        values[name] = list(input[f"subset_values_{i}"]())
-                return {"columns": names, "values": values,
-                        "start": input.datetime_start().strip(),
-                        "end": input.datetime_end().strip()}
-
-            @reactive.calc
-            def filtered_summary():
-                state = filter_state()
-                filters = {}
-                for name, keys in state["values"].items():
-                    _, mapping = _subset_choices(summary, column_map[name])
-                    selected = [mapping[key] for key in keys if key in mapping]
-                    if selected:
-                        filters[column_map[name]] = selected
-                return _apply_filters(summary, filters, state["start"], state["end"])
-
-            @render.data_frame
-            def plot_table():
-                df = selected_data()
-                return render.DataGrid(pd.DataFrame(df).reset_index(drop=True),
-                                       filters=True, height="420px")
-
-            @render.ui
-            def x_control():
-                kind = input.plot_type()
-                if kind in ("box", "bar"):
-                    choices = categorical_columns
-                    multiple = True
-                elif kind == "line":
-                    choices = datetime_columns
-                    multiple = False
-                else:
-                    choices = numeric_columns
-                    multiple = False
-
-                if not choices:
-                    return ui.help_text(f"No compatible X variables for {kind}.")
-                selected = [x] if x in choices else [choices[0]]
-                if multiple:
-                    return ui.input_selectize(
-                        "x", "X-axis / categories",
-                        choices={c: c for c in choices},
-                        selected=selected, multiple=True,
-                    )
-                return ui.input_select(
-                    "x", "X-axis / variable",
+        initial_filters = initial_filters or {}
+
+        @render.ui
+        def subset_filters():
+            controls = []
+            for i, name in enumerate(list(input.subset_columns())):
+                if name not in column_map:
+                    continue
+                choices, _ = _subset_choices(summary, column_map[name])
+                controls.append(ui.input_selectize(
+                    f"subset_values_{i}", f"{name} values", choices=choices,
+                    selected=initial_filters.get(
+                        "values", {}).get(name, []),
+                    multiple=True,
+                ))
+            return ui.div(*controls) if controls else ui.help_text("Select columns to filter this plot.")
+
+        @reactive.calc
+        def filter_state():
+            names = list(input.subset_columns())
+            values = {}
+            for i, name in enumerate(names):
+                if name in column_map:
+                    values[name] = list(input[f"subset_values_{i}"]())
+            return {"columns": names, "values": values,
+                    "start": input.datetime_start().strip(),
+                    "end": input.datetime_end().strip()}
+
+        @reactive.calc
+        def filtered_summary():
+            state = filter_state()
+            filters = {}
+            for name, keys in state["values"].items():
+                _, mapping = _subset_choices(summary, column_map[name])
+                selected = [mapping[key] for key in keys if key in mapping]
+                if selected:
+                    filters[column_map[name]] = selected
+            return _apply_filters(summary, filters, state["start"], state["end"])
+
+        @render.data_frame
+        def plot_table():
+            df = selected_data()
+            return render.DataGrid(pd.DataFrame(df).reset_index(drop=True),
+                                    filters=True, height="420px")
+
+        @render.ui
+        def x_control():
+            kind = input.plot_type()
+            if kind in ("box", "bar"):
+                choices = categorical_columns
+                multiple = True
+            elif kind == "line":
+                choices = datetime_columns
+                multiple = False
+            else:
+                choices = numeric_columns
+                multiple = False
+
+            if not choices:
+                return ui.help_text(f"No compatible X variables for {kind}.")
+            selected = [x] if x in choices else [choices[0]]
+            if multiple:
+                return ui.input_selectize(
+                    "x", "X-axis / categories",
                     choices={c: c for c in choices},
-                    selected=selected[0],
+                    selected=selected, multiple=True,
                 )
+            return ui.input_select(
+                "x", "X-axis / variable",
+                choices={c: c for c in choices},
+                selected=selected[0],
+            )
 
-            @render.ui
-            def y_control():
-                kind = input.plot_type()
-                if kind == "histogram":
-                    return ui.div()
-                if not numeric_columns:
-                    return ui.help_text("No numeric Y variables available.")
-                selected = next(
-                    (v for v in initial_y if v in numeric_columns), numeric_columns[0])
-                if kind in ("box", "bar", "scatter"):
-                    return ui.input_select(
-                        "y", "Y-axis / variable",
-                        choices={c: c for c in numeric_columns},
-                        selected=selected,
-                    )
-                return ui.input_selectize(
-                    "y", "Y-axis / variables",
+        @render.ui
+        def y_control():
+            kind = input.plot_type()
+            if kind == "histogram":
+                return ui.div()
+            if not numeric_columns:
+                return ui.help_text("No numeric Y variables available.")
+            selected = next(
+                (v for v in initial_y if v in numeric_columns), numeric_columns[0])
+            if kind in ("box", "bar", "scatter"):
+                return ui.input_select(
+                    "y", "Y-axis / variable",
                     choices={c: c for c in numeric_columns},
-                    selected=[v for v in initial_y if v in numeric_columns] or [
-                        selected],
-                    multiple=True,
+                    selected=selected,
                 )
+            return ui.input_selectize(
+                "y", "Y-axis / variables",
+                choices={c: c for c in numeric_columns},
+                selected=[v for v in initial_y if v in numeric_columns] or [
+                    selected],
+                multiple=True,
+            )
 
-            @reactive.calc
-            def selected_data():
-                current = filtered_summary()
-                kind = input.plot_type()
-                x_input = input.x()
-                selected_x = ([x_input] if isinstance(
-                    x_input, str) else list(x_input or []))
-                if not selected_x:
-                    return pd.DataFrame()
-
-                if kind == "histogram":
-                    value_names = selected_x
-                else:
-                    y_input = input.y()
-                    value_names = ([y_input] if isinstance(
-                        y_input, str) else list(y_input or []))
-                if not value_names:
-                    return pd.DataFrame()
-
-                selected_groups = list(input.group_by())
-                grouping_by = [column_map[c] for c in selected_groups]
-                frequency = FREQUENCIES[input.frequency()]
-                aggregate = AGGREGATES[input.aggregate()]
-                value_columns = [column_map[c] for c in value_names]
-
-                if kind in ("box", "bar"):
-                    for c in selected_x:
-                        if column_map[c] not in grouping_by:
-                            grouping_by.append(column_map[c])
-                if kind == "scatter" and frequency is not None:
-                    # Both numerical axes must be aggregated on the same rows.
-                    value_columns = list(dict.fromkeys(
-                        [column_map[selected_x[0]], *value_columns]
-                    ))
-                if frequency is not None:
-                    current = _aggregate(
-                        current, value_columns, frequency, grouping_by, aggregate
-                    )
-                return current
-
-            @render_plotly
-            def plot():
-                plot_df = selected_data()
-                selected_plot = input.plot_type()
-                x_input = input.x()
-                selected_x = ([x_input] if isinstance(
-                    x_input, str) else list(x_input or []))
-                y_input = None if selected_plot == "histogram" else input.y()
-                selected_y = ([y_input] if isinstance(
+        @reactive.calc
+        def selected_data():
+            current = filtered_summary()
+            kind = input.plot_type()
+            x_input = input.x()
+            selected_x = ([x_input] if isinstance(
+                x_input, str) else list(x_input or []))
+            if not selected_x:
+                return pd.DataFrame()
+
+            if kind == "histogram":
+                value_names = selected_x
+            else:
+                y_input = input.y()
+                value_names = ([y_input] if isinstance(
                     y_input, str) else list(y_input or []))
-                selected_groups = list(input.group_by())
-                frequency = FREQUENCIES[input.frequency()]
-
-                if plot_df.empty or not selected_x or (
-                    selected_plot != "histogram" and not selected_y
-                ):
-                    return px.scatter(title="No data for the selected filters")
-
-                aggregate = AGGREGATES[input.aggregate()]
-
-                def mapped(column):
-                    original = column_map[column]
-                    return f"{original}_{aggregate}" if frequency is not None else original
-
-                if selected_plot == "histogram":
-                    x_column = mapped(selected_x[0])
-                    y_columns = []
-                elif selected_plot in ("box", "bar"):
-                    x_columns = [column_map[c] for c in selected_x]
-                    x_column = x_columns[0]
-                    y_columns = [mapped(selected_y[0])]
-                elif selected_plot == "scatter":
-                    x_column = mapped(selected_x[0])
-                    y_columns = [mapped(selected_y[0])]
-                else:
-                    x_column = frequency if frequency is not None else column_map[selected_x[0]]
-                    y_columns = [mapped(c) for c in selected_y]
-
-                required = [x_column, *y_columns]
-                if selected_plot in ("box", "bar"):
-                    required.extend(x_columns)
-                if any(c not in plot_df.columns for c in required):
-                    return px.scatter(title="Selected variables are unavailable after aggregation")
-
-                if selected_plot in ("box", "bar"):
-                    plot_df = plot_df.copy()
-                    plot_df["__plot_category"] = plot_df[x_columns].astype(
+            if not value_names:
+                return pd.DataFrame()
+
+            selected_groups = list(input.group_by())
+            grouping_by = [column_map[c] for c in selected_groups]
+            frequency = FREQUENCIES[input.frequency()]
+            aggregate = AGGREGATES[input.aggregate()]
+            value_columns = [column_map[c] for c in value_names]
+
+            if kind in ("box", "bar"):
+                for c in selected_x:
+                    if column_map[c] not in grouping_by:
+                        grouping_by.append(column_map[c])
+            if kind == "scatter" and frequency is not None:
+                # Both numerical axes must be aggregated on the same rows.
+                value_columns = list(dict.fromkeys(
+                    [column_map[selected_x[0]], *value_columns]
+                ))
+            if frequency is not None:
+                current = _aggregate(
+                    current, value_columns, frequency, grouping_by, aggregate
+                )
+            return current
+
+        @render_plotly
+        def plot():
+            plot_df = selected_data()
+            selected_plot = input.plot_type()
+            x_input = input.x()
+            selected_x = ([x_input] if isinstance(
+                x_input, str) else list(x_input or []))
+            y_input = None if selected_plot == "histogram" else input.y()
+            selected_y = ([y_input] if isinstance(
+                y_input, str) else list(y_input or []))
+            selected_groups = list(input.group_by())
+            frequency = FREQUENCIES[input.frequency()]
+
+            if plot_df.empty or not selected_x or (
+                selected_plot != "histogram" and not selected_y
+            ):
+                return px.scatter(title="No data for the selected filters")
+
+            aggregate = AGGREGATES[input.aggregate()]
+
+            def mapped(column):
+                original = column_map[column]
+                return f"{original}_{aggregate}" if frequency is not None else original
+
+            if selected_plot == "histogram":
+                x_column = mapped(selected_x[0])
+                y_columns = []
+            elif selected_plot in ("box", "bar"):
+                x_columns = [column_map[c] for c in selected_x]
+                x_column = x_columns[0]
+                y_columns = [mapped(selected_y[0])]
+            elif selected_plot == "scatter":
+                x_column = mapped(selected_x[0])
+                y_columns = [mapped(selected_y[0])]
+            else:
+                x_column = frequency if frequency is not None else column_map[selected_x[0]]
+                y_columns = [mapped(c) for c in selected_y]
+
+            required = [x_column, *y_columns]
+            if selected_plot in ("box", "bar"):
+                required.extend(x_columns)
+            if any(c not in plot_df.columns for c in required):
+                return px.scatter(title="Selected variables are unavailable after aggregation")
+
+            if selected_plot in ("box", "bar"):
+                plot_df = plot_df.copy()
+                plot_df["__plot_category"] = plot_df[x_columns].astype(
+                    str).agg(" | ".join, axis=1)
+                x_column = "__plot_category"
+
+            # Multiple grouping columns are supported by group_stat(). For
+            # plotting, Plotly needs one color/category column, so combine the
+            # selected grouping columns into a readable composite label.
+            group_columns = [column_map[c] for c in selected_groups
+                                if column_map[c] in plot_df.columns]
+            if group_columns:
+                plot_df = plot_df.copy()
+                plot_df["__plot_group"] = (
+                    plot_df[group_columns].astype(
                         str).agg(" | ".join, axis=1)
-                    x_column = "__plot_category"
+                )
 
-                # Multiple grouping columns are supported by group_stat(). For
-                # plotting, Plotly needs one color/category column, so combine the
-                # selected grouping columns into a readable composite label.
-                group_columns = [column_map[c] for c in selected_groups
-                                 if column_map[c] in plot_df.columns]
-                if group_columns:
-                    plot_df = plot_df.copy()
-                    plot_df["__plot_group"] = (
-                        plot_df[group_columns].astype(
-                            str).agg(" | ".join, axis=1)
+            if selected_plot == "histogram":
+                fig = _histogram_figure(
+                    plot_df,
+                    x_column,
+                    group_column="__plot_group" if group_columns else None,
+                    bins=int(input.bins()),
+                    density=input.hist_density() == "True",
+                    stacked=input.hist_stacked() == "True",
+                    histtype=input.hist_type(),
+                    cumulative=int(input.hist_cumulative()),
+                )
+            elif selected_plot == "box":
+                fig = px.box(
+                    plot_df, x=x_column, y=y_columns[0],
+                    color="__plot_group" if group_columns else None,
+                    points="outliers",
+                )
+            elif selected_plot == "bar":
+                fig = px.bar(
+                    plot_df, x=x_column, y=y_columns[0],
+                    color="__plot_group" if group_columns else None,
+                    barmode="group",
+                )
+            elif selected_plot == "scatter":
+                fig = px.scatter(
+                    plot_df, x=x_column, y=y_columns[0],
+                    color="__plot_group" if group_columns else None,
+                )
+            else:
+                # ``identifier`` identifies an individual input monitor.  It
+                # must therefore be used as Plotly's line-group key even when
+                # it is not one of the user-selected colour/group columns.
+                # This prevents observations from two different monitors
+                # being connected by a line merely because they share the
+                # same selected group.  The identifier is deliberately NOT
+                # used for colour, so monitors in the same selected group
+                # retain the same colour.  After frequency aggregation,
+                # identifier is only available if it was selected as a
+                # grouping variable.  If it is absent, discontinuous runs are
+                # inferred from gaps larger than the selected frequency.
+                identifier_column = (
+                    column_map["identifier"]
+                    if (
+                        "identifier" in column_map
+                        and column_map["identifier"] in plot_df.columns
                     )
+                    else None
+                )
 
-                if selected_plot == "histogram":
-                    fig = _histogram_figure(
+                section_column = None
+                if frequency is not None and identifier_column is None:
+                    plot_df = _add_gap_sections(
                         plot_df,
-                        x_column,
-                        group_column="__plot_group" if group_columns else None,
-                        bins=int(input.bins()),
-                        density=input.hist_density() == "True",
-                        stacked=input.hist_stacked() == "True",
-                        histtype=input.hist_type(),
-                        cumulative=int(input.hist_cumulative()),
-                    )
-                elif selected_plot == "box":
-                    fig = px.box(
-                        plot_df, x=x_column, y=y_columns[0],
-                        color="__plot_group" if group_columns else None,
-                        points="outliers",
-                    )
-                elif selected_plot == "bar":
-                    fig = px.bar(
-                        plot_df, x=x_column, y=y_columns[0],
-                        color="__plot_group" if group_columns else None,
-                        barmode="group",
+                        x_column=x_column,
+                        group_columns=group_columns,
+                        frequency=frequency,
                     )
-                elif selected_plot == "scatter":
-                    fig = px.scatter(
-                        plot_df, x=x_column, y=y_columns[0],
-                        color="__plot_group" if group_columns else None,
+                    section_column = "__line_section"
+
+                if group_columns:
+                    group_column = "__plot_group"
+                    line_columns = [x_column, group_column, *y_columns]
+                    line_group_column = identifier_column or section_column
+                    if line_group_column is not None:
+                        line_columns.append(line_group_column)
+
+                    # Keep whichever column controls line segmentation as an
+                    # id_var during melt(). Otherwise pandas drops it and
+                    # Plotly cannot resolve line_group (e.g. __line_section).
+                    id_vars = [x_column, group_column]
+                    if line_group_column is not None:
+                        id_vars.append(line_group_column)
+
+                    long_df = plot_df[line_columns].melt(
+                        id_vars=id_vars,
+                        var_name="variable",
+                        value_name="value",
                     )
-                else:
-                    # ``identifier`` identifies an individual input monitor.  It
-                    # must therefore be used as Plotly's line-group key even when
-                    # it is not one of the user-selected colour/group columns.
-                    # This prevents observations from two different monitors
-                    # being connected by a line merely because they share the
-                    # same selected group.  The identifier is deliberately NOT
-                    # used for colour, so monitors in the same selected group
-                    # retain the same colour.  After frequency aggregation,
-                    # identifier is only available if it was selected as a
-                    # grouping variable.  If it is absent, discontinuous runs are
-                    # inferred from gaps larger than the selected frequency.
-                    identifier_column = (
-                        column_map["identifier"]
-                        if (
-                            "identifier" in column_map
-                            and column_map["identifier"] in plot_df.columns
-                        )
-                        else None
+                    fig = px.line(
+                        long_df,
+                        x=x_column,
+                        y="value",
+                        color=group_column,
+                        line_group=line_group_column,
+                        facet_row="variable" if len(
+                            y_columns) > 1 else None,
                     )
-
-                    section_column = None
-                    if frequency is not None and identifier_column is None:
-                        plot_df = _add_gap_sections(
+                elif identifier_column is not None:
+                    # With no explicit grouping, retain the normal Y-variable
+                    # colouring while using identifier to keep each monitor's
+                    # time series separate.
+                    if len(y_columns) == 1:
+                        fig = px.line(
                             plot_df,
-                            x_column=x_column,
-                            group_columns=group_columns,
-                            frequency=frequency,
+                            x=x_column,
+                            y=y_columns[0],
+                            line_group=identifier_column,
                         )
-                        section_column = "__line_section"
-
-                    if group_columns:
-                        group_column = "__plot_group"
-                        line_columns = [x_column, group_column, *y_columns]
-                        line_group_column = identifier_column or section_column
-                        if line_group_column is not None:
-                            line_columns.append(line_group_column)
-
-                        # Keep whichever column controls line segmentation as an
-                        # id_var during melt(). Otherwise pandas drops it and
-                        # Plotly cannot resolve line_group (e.g. __line_section).
-                        id_vars = [x_column, group_column]
-                        if line_group_column is not None:
-                            id_vars.append(line_group_column)
-
+                    else:
+                        line_columns = [
+                            x_column, identifier_column, *y_columns]
                         long_df = plot_df[line_columns].melt(
-                            id_vars=id_vars,
+                            id_vars=[x_column, identifier_column],
                             var_name="variable",
                             value_name="value",
                         )
@@ -788,74 +816,46 @@ def create_summary_app(
                             long_df,
                             x=x_column,
                             y="value",
-                            color=group_column,
-                            line_group=line_group_column,
-                            facet_row="variable" if len(
-                                y_columns) > 1 else None,
+                            color="variable",
+                            line_group=identifier_column,
+                            facet_row="variable",
+                        )
+                elif section_column is not None:
+                    if len(y_columns) == 1:
+                        fig = px.line(
+                            plot_df,
+                            x=x_column,
+                            y=y_columns[0],
+                            line_group=section_column,
                         )
-                    elif identifier_column is not None:
-                        # With no explicit grouping, retain the normal Y-variable
-                        # colouring while using identifier to keep each monitor's
-                        # time series separate.
-                        if len(y_columns) == 1:
-                            fig = px.line(
-                                plot_df,
-                                x=x_column,
-                                y=y_columns[0],
-                                line_group=identifier_column,
-                            )
-                        else:
-                            line_columns = [
-                                x_column, identifier_column, *y_columns]
-                            long_df = plot_df[line_columns].melt(
-                                id_vars=[x_column, identifier_column],
-                                var_name="variable",
-                                value_name="value",
-                            )
-                            fig = px.line(
-                                long_df,
-                                x=x_column,
-                                y="value",
-                                color="variable",
-                                line_group=identifier_column,
-                                facet_row="variable",
-                            )
-                    elif section_column is not None:
-                        if len(y_columns) == 1:
-                            fig = px.line(
-                                plot_df,
-                                x=x_column,
-                                y=y_columns[0],
-                                line_group=section_column,
-                            )
-                        else:
-                            line_columns = [
-                                x_column, section_column, *y_columns]
-                            long_df = plot_df[line_columns].melt(
-                                id_vars=[x_column, section_column],
-                                var_name="variable",
-                                value_name="value",
-                            )
-                            fig = px.line(
-                                long_df,
-                                x=x_column,
-                                y="value",
-                                color="variable",
-                                line_group=section_column,
-                                facet_row="variable",
-                            )
                     else:
-                        fig = px.line(plot_df, x=x_column, y=y_columns)
+                        line_columns = [
+                            x_column, section_column, *y_columns]
+                        long_df = plot_df[line_columns].melt(
+                            id_vars=[x_column, section_column],
+                            var_name="variable",
+                            value_name="value",
+                        )
+                        fig = px.line(
+                            long_df,
+                            x=x_column,
+                            y="value",
+                            color="variable",
+                            line_group=section_column,
+                            facet_row="variable",
+                        )
+                else:
+                    fig = px.line(plot_df, x=x_column, y=y_columns)
 
-                fig.update_layout(
-                    title=input.title(),
-                    hovermode="x unified" if selected_plot == "line" else "closest",
-                    margin=dict(l=60, r=30, t=70, b=60),
-                    autosize=True,
-                )
-                return fig
+            fig.update_layout(
+                title=input.title(),
+                hovermode="x unified" if selected_plot == "line" else "closest",
+                margin=dict(l=60, r=30, t=70, b=60),
+                autosize=True,
+            )
+            return fig
 
-            return filter_state
+        return filter_state
 
     app_ui = ui.page_fluid(
         ui.tags.style("""