apmtools 0.2.20__tar.gz → 0.2.22__tar.gz

{apmtools-0.2.20 → apmtools-0.2.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: apmtools
-Version: 0.2.020
+Version: 0.2.022
 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.20 → apmtools-0.2.22}/pyproject.toml

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

{apmtools-0.2.20 → apmtools-0.2.22}/src/apmtools/shiny/summary.py

@@ -1,13 +1,13 @@
-"""Interactive Plotly/Shiny application for apmtools Summary objects."""
+"""Interactive Plotly/Shiny application for :class:`apmtools.Summary`."""
 
 from __future__ import annotations
 
 import threading
 from collections.abc import Sequence
+
 import numpy as np
 import pandas as pd
 
-
 PLOT_TYPES = {
     "bar": "Bar",
     "box": "Boxplot",
@@ -19,11 +19,11 @@ PLOT_TYPES = {
 # ``None`` means row-level plotting.  The other values are passed directly to
 # Summary.group_stat(frequency=...).
 FREQUENCIES = {
+    "Day": "day",
+    "Hour": "hour",
+    "Minute": "minute",
     "None (raw data)": None,
     "Second": "second",
-    "Minute": "minute",
-    "Hour": "hour",
-    "Day": "day",
     "Week": "week",
     "Weekday": "weekday",
 }
@@ -38,22 +38,24 @@ AGGREGATES = {
     "Sum": "sum",
 }
 
+
 def _default_x(data: pd.DataFrame) -> str:
-    """Return the first datetime column, or otherwise the first column."""
+    """Return ``time`` when available, otherwise the first column."""
+    if "time" in data.columns:
+        return "time"
     datetime_columns = [
         column
         for column in data.columns
         if pd.api.types.is_datetime64_any_dtype(data[column])
     ]
-    if "time" in datetime_columns:
-        return "time"
-    else:
-        return str(datetime_columns[0] if datetime_columns else data.columns[0])
+    return str(datetime_columns[0] if datetime_columns else data.columns[0])
+
 
 def _default_group(data: pd.DataFrame) -> str | None:
     """Return ``identifier`` when available."""
     return "identifier" if "identifier" in data.columns else None
 
+
 def _numeric_columns(data: pd.DataFrame) -> list[str]:
     """Return numeric column names as strings."""
     return sorted([
@@ -100,6 +102,11 @@ def _timedelta_columns(data: pd.DataFrame) -> list[str]:
     )
 
 
+def _alphabetical(values) -> list[str]:
+    """Return string values sorted alphabetically, case-insensitively."""
+    return sorted((str(value) for value in values), key=str.casefold)
+
+
 def _normalise_y(data: pd.DataFrame, x: str, y: str | Sequence[str] | None) -> list[str]:
     """Validate and normalise an initial Y selection."""
     numeric = _numeric_columns(data)
@@ -112,15 +119,10 @@ def _normalise_y(data: pd.DataFrame, x: str, y: str | Sequence[str] | None) -> l
     return [str(column) for column in values]
 
 
-def _alphabetical(values) -> list[str]:
-    """Return string values sorted alphabetically, case-insensitively."""
-    return sorted((str(value) for value in values), key=str.casefold)
-
-
-
 def _subset_choices(data: pd.DataFrame, column: str) -> tuple[dict[str, str], dict[str, object]]:
     """Build stable Shiny choices and their corresponding original values."""
-    values = pd.unique(data[column].dropna())
+    values = sorted(pd.unique(data[column].dropna()),
+                    key=lambda value: str(value).casefold())
     choices: dict[str, str] = {}
     value_map: dict[str, object] = {}
     for i, value in enumerate(values):
@@ -179,6 +181,16 @@ def _aggregate(data, value_columns, frequency, grouping_by, aggregate):
     return result
 
 
+def _aggregated_value_columns(data, value_columns, aggregate):
+    """Return the columns produced by Summary.group_stat()."""
+    columns = []
+    for column in value_columns:
+        aggregated = f"{column}_{aggregate}"
+        if aggregated in data.columns:
+            columns.append(aggregated)
+    return columns
+
+
 def _histogram_figure(
     data: pd.DataFrame,
     x_column: str,
@@ -294,6 +306,7 @@ def _histogram_figure(
     )
     return fig
 
+
 def _frequency_timedelta(frequency: str) -> pd.Timedelta | None:
     """Convert a timestamp aggregation frequency to its expected spacing."""
     if not frequency or frequency == "weekday":
@@ -436,7 +449,72 @@ def create_summary_app(
     subset_columns = columns
 
     app_ui = ui.page_sidebar(
-        ui.sidebar(
+        ui.div(
+            ui.tags.style("""
+            /* Allow the main pane to consume all width remaining after the sidebar. */
+            .bslib-sidebar-layout > .main,
+            .bslib-sidebar-layout > main,
+            .bslib-sidebar-layout .main {
+                min-width: 0;
+                width: 100%;
+                max-width: none;
+            }
+            /* Remove the default Bootstrap container width limit, if present. */
+            .container, .container-fluid { max-width: none !important; }
+            .summary-plot-container {
+                width: 100%;
+                max-width: none;
+                aspect-ratio: 2 / 1;
+                min-width: 0;
+                min-height: 0;
+                padding: 0;
+                margin: 0;
+                position: relative;
+            }
+            .summary-plot-container > .html-widget-output,
+            .summary-plot-container > .shiny-plot-output,
+            .summary-plot-container > #plot {
+                width: 100% !important;
+                height: 100% !important;
+                max-width: none !important;
+            }
+        """),
+            ui.tags.script("""
+            // Plotly sometimes retains the pixel width measured before the
+            // Shiny sidebar and widget have finished laying out.
+            (() => {
+              function resizePlot() {
+                const container = document.querySelector('.summary-plot-container');
+                if (!container || !window.Plotly) return;
+                const graph = container.querySelector('.js-plotly-plot');
+                if (graph) window.Plotly.Plots.resize(graph);
+              }
+              const observer = new ResizeObserver(resizePlot);
+              const attach = () => {
+                const container = document.querySelector('.summary-plot-container');
+                if (!container) return false;
+                observer.observe(container);
+                resizePlot();
+                return true;
+              };
+              document.addEventListener('DOMContentLoaded', attach);
+              window.addEventListener('resize', resizePlot);
+              if (!attach()) {
+                const startup = new MutationObserver((_, watcher) => {
+                  if (attach()) watcher.disconnect();
+                });
+                startup.observe(document.documentElement, {
+                  childList: true, subtree: true
+                });
+              }
+            })();
+        """),
+            ui.div(
+                output_widget("plot", height="100%", width="100%"),
+                class_="summary-plot-container",
+            ),
+        ),
+        sidebar=ui.sidebar(
             ui.h4("Plot controls"),
             ui.input_select("plot_type", "Plot type",
                             choices=PLOT_TYPES, selected=plot_type),
@@ -500,13 +578,6 @@ def create_summary_app(
                 "Summary.group_stat()."
             ),
         ),
-        ui.div(
-                    output_widget("plot", height="100%", width="100%"),
-                    style=(
-                        "width: 100%; max-width: 100%; aspect-ratio: 16 / 9; "
-                        "min-height: 0; margin: 0; padding: 0;"
-                    ),
-                ),
     )
 
     def server(input, output, session):