Highly graphical history: metric tabs + 24h tile sparklines

The History page used to chart one metric (power for day, energy for
the other ranges). It now offers five tabs across the top — Power,
Energy, Battery, Money, Alarms — driving a single chart underneath.
Each metric defines which ranges it supports (e.g. Battery is sample-
resolution only; Money is daily-rollup only), so unsupported range
options grey out when the active tab doesn't support them. Per-metric
colours, and the CSV download tracks the active metric.

The home dashboard tiles each gain a 24-hour SVG sparkline drawn from
station_samples. Paths are pre-rendered server-side (Python helper +
inline SVG), so there's no extra JS, no Chart.js for the tiles, and
they refresh automatically with the existing 30s tile swap.

Behind the scenes:
- HistoryService methods now take an optional `metric=` keyword and
  share a small registry that maps metric → field/label. Day-view
  metrics read from station_samples; aggregate-view metrics read from
  station_daily and respect per-row unit fields.
- New JSON/CSV history endpoints accept `?metric=`; without it,
  callers get the original default for that view.
- LiveTilesService swallows sparkline lookup failures — the home page
  must keep rendering if Mongo is slow or misbehaving on that one
  decorative path.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: jdrumgoole

CHANGELOG.md

@@ -4,6 +4,31 @@ All notable changes to **Solisdash** are documented here. Version numbers
 follow [Semantic Versioning](https://semver.org/). The package is published
 to PyPI on every `vX.Y.Z` tag push.
 
+## 0.8.0 — 2026-05-16
+
+### Added
+- **Metric tabs on the History page.** Power / Energy / Battery / Money /
+  Alarms sit across the top; the range selector greys out options that
+  aren't valid for the chosen metric (e.g. Money is daily-rollup only,
+  so the Day option disables when Money is active). Each metric gets its
+  own series colour. CSV download now follows the active metric.
+- **24-hour sparklines under each live tile** on the home page. Tiny SVG
+  trend lines drawn from `station_samples`, refreshed alongside the
+  tiles via the existing 30-second HTMX swap. Server-rendered SVG paths,
+  no extra JS or Chart.js needed.
+- New JSON/CSV history endpoints accept `?metric=` (`power`, `energy`,
+  `battery`, `money`, `alarms`). Existing callers without the parameter
+  keep getting the previous default (power for day, energy elsewhere).
+
+### Changed
+- `HistoryService.day_series`, `month_daily`, `year_monthly`, `all_time`
+  now take an optional `metric=` keyword. Defaults are unchanged.
+
+### Fixed
+- `LiveTilesService.get_tiles` falls through to the existing tile data
+  if the sparkline lookup fails. Sparklines are decorative; a Mongo
+  hiccup must never blank the home page.
+
 ## 0.7.3 — 2026-05-16
 
 ### Changed

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "solisdash"
-version = "0.7.3"
+version = "0.8.0"
 description = "Self-hosted dashboard for the SolisCloud (Ginlong Solis) platform"
 readme = "README.md"
 requires-python = ">=3.10"

src/solisdash/__init__.py

@@ -1 +1 @@
-__version__ = "0.7.3"
+__version__ = "0.8.0"

src/solisdash/app.py

@@ -35,7 +35,19 @@
 from solisdash.config import get_settings
 from solisdash.configfile import delete_toml, user_config_toml_path, write_toml
 from solisdash.db import ensure_indexes
-from solisdash.history import HistoryService, Series, parse_month
+from solisdash.history import (
+    METRIC_ENERGY,
+    METRIC_POWER,
+    METRIC_SUPPORTS,
+    VIEW_ALL,
+    VIEW_DAY,
+    VIEW_MONTH,
+    VIEW_YEAR,
+    HistoryService,
+    Series,
+    metric_supports,
+    parse_month,
+)
 from solisdash.poller import Poller
 from solisdash.ratelimit import TokenBucket
 from solisdash.scheduler import build_scheduler
@@ -778,70 +790,108 @@ async def history_poll_now(
     )
 
 
+_DAY_LABELS = {
+    "power": ("Power", "kW"),
+    "energy": ("Day energy", "kWh"),
+    "battery": ("Battery SOC", "%"),
+    "alarms": ("Open alarms", ""),
+}
+_DAILY_LABELS = {
+    "energy": {
+        "month": ("Daily energy", "kWh"),
+        "year": ("Monthly energy", "kWh"),
+        "all": ("Annual energy", "kWh"),
+    },
+    "money": {
+        "month": ("Daily revenue", ""),
+        "year": ("Monthly revenue", ""),
+        "all": ("Annual revenue", ""),
+    },
+}
+
+
+def _validate_metric(metric: str, view: str) -> None:
+    if metric not in METRIC_SUPPORTS:
+        raise HTTPException(status_code=400, detail=f"unknown metric: {metric!r}")
+    if not metric_supports(metric, view):
+        raise HTTPException(
+            status_code=400,
+            detail=f"metric {metric!r} is not available for the {view!r} view",
+        )
+
+
 @app.get("/history/day.json")
 async def history_day_json(
     station_id: str | None = Query(None),
     when: str = Query(..., description="YYYY-MM-DD"),
+    metric: str = Query(METRIC_POWER),
     history: HistoryService = Depends(get_history_service),
     user: dict[str, Any] = Depends(require_user),
 ) -> JSONResponse:
+    _validate_metric(metric, VIEW_DAY)
     sid = await _resolve_station_id(history, station_id)
     if sid is None:
-        return JSONResponse(_empty_series_response("Power", "kW", station_id=None))
+        label, unit = _DAY_LABELS.get(metric, ("Series", ""))
+        return JSONResponse(_empty_series_response(label, unit, station_id=None))
     try:
         when_date = date.fromisoformat(when)
     except ValueError as exc:
         raise HTTPException(status_code=400, detail=str(exc)) from exc
-    series = await history.day_series(sid, when_date)
+    series = await history.day_series(sid, when_date, metric=metric)
     return JSONResponse({"station_id": sid, **series.to_json()})
 
 
 @app.get("/history/month.json")
 async def history_month_json(
     station_id: str | None = Query(None),
     month: str = Query(..., description="YYYY-MM"),
+    metric: str = Query(METRIC_ENERGY),
     history: HistoryService = Depends(get_history_service),
     user: dict[str, Any] = Depends(require_user),
 ) -> JSONResponse:
+    _validate_metric(metric, VIEW_MONTH)
     sid = await _resolve_station_id(history, station_id)
     if sid is None:
-        return JSONResponse(_empty_series_response("Daily energy", "kWh", station_id=None))
+        label, unit = _DAILY_LABELS[metric]["month"]
+        return JSONResponse(_empty_series_response(label, unit, station_id=None))
     try:
         parse_month(month)
     except ValueError as exc:
         raise HTTPException(status_code=400, detail=str(exc)) from exc
-    series = await history.month_daily(sid, month)
+    series = await history.month_daily(sid, month, metric=metric)
     return JSONResponse({"station_id": sid, **series.to_json()})
 
 
 @app.get("/history/year.json")
 async def history_year_json(
     station_id: str | None = Query(None),
     year: int = Query(...),
+    metric: str = Query(METRIC_ENERGY),
     history: HistoryService = Depends(get_history_service),
     user: dict[str, Any] = Depends(require_user),
 ) -> JSONResponse:
+    _validate_metric(metric, VIEW_YEAR)
     sid = await _resolve_station_id(history, station_id)
     if sid is None:
-        return JSONResponse(
-            _empty_series_response("Monthly energy", "kWh", station_id=None)
-        )
-    series = await history.year_monthly(sid, year)
+        label, unit = _DAILY_LABELS[metric]["year"]
+        return JSONResponse(_empty_series_response(label, unit, station_id=None))
+    series = await history.year_monthly(sid, year, metric=metric)
     return JSONResponse({"station_id": sid, **series.to_json()})
 
 
 @app.get("/history/all.json")
 async def history_all_json(
     station_id: str | None = Query(None),
+    metric: str = Query(METRIC_ENERGY),
     history: HistoryService = Depends(get_history_service),
     user: dict[str, Any] = Depends(require_user),
 ) -> JSONResponse:
+    _validate_metric(metric, VIEW_ALL)
     sid = await _resolve_station_id(history, station_id)
     if sid is None:
-        return JSONResponse(
-            _empty_series_response("Annual energy", "kWh", station_id=None)
-        )
-    series = await history.all_time(sid)
+        label, unit = _DAILY_LABELS[metric]["all"]
+        return JSONResponse(_empty_series_response(label, unit, station_id=None))
+    series = await history.all_time(sid, metric=metric)
     return JSONResponse({"station_id": sid, **series.to_json()})
 
 
@@ -872,74 +922,82 @@ def _csv_response(body: str, filename: str) -> Response:
 async def history_day_csv(
     station_id: str | None = Query(None),
     when: str = Query(..., description="YYYY-MM-DD"),
+    metric: str = Query(METRIC_POWER),
     history: HistoryService = Depends(get_history_service),
     user: dict[str, Any] = Depends(require_user),
 ) -> Response:
+    _validate_metric(metric, VIEW_DAY)
     sid = await _resolve_station_id(history, station_id)
     if sid is None:
-        return _csv_response("timestamp_ms,power\n", "history-day.csv")
+        return _csv_response(f"timestamp_ms,{metric}\n", f"history-day-{metric}.csv")
     try:
         when_date = date.fromisoformat(when)
     except ValueError as exc:
         raise HTTPException(status_code=400, detail=str(exc)) from exc
-    series = await history.day_series(sid, when_date)
+    series = await history.day_series(sid, when_date, metric=metric)
     return _csv_response(
-        _series_to_csv(series, x_header="timestamp_ms", y_header="power"),
-        f"history-day-{sid}-{when}.csv",
+        _series_to_csv(series, x_header="timestamp_ms", y_header=metric),
+        f"history-day-{metric}-{sid}-{when}.csv",
     )
 
 
 @app.get("/history/month.csv")
 async def history_month_csv(
     station_id: str | None = Query(None),
     month: str = Query(..., description="YYYY-MM"),
+    metric: str = Query(METRIC_ENERGY),
     history: HistoryService = Depends(get_history_service),
     user: dict[str, Any] = Depends(require_user),
 ) -> Response:
+    _validate_metric(metric, VIEW_MONTH)
     sid = await _resolve_station_id(history, station_id)
     if sid is None:
-        return _csv_response("date,energy\n", "history-month.csv")
+        return _csv_response(f"date,{metric}\n", f"history-month-{metric}.csv")
     try:
         parse_month(month)
     except ValueError as exc:
         raise HTTPException(status_code=400, detail=str(exc)) from exc
-    series = await history.month_daily(sid, month)
+    series = await history.month_daily(sid, month, metric=metric)
     return _csv_response(
-        _series_to_csv(series, x_header="date", y_header="energy"),
-        f"history-month-{sid}-{month}.csv",
+        _series_to_csv(series, x_header="date", y_header=metric),
+        f"history-month-{metric}-{sid}-{month}.csv",
     )
 
 
 @app.get("/history/year.csv")
 async def history_year_csv(
     station_id: str | None = Query(None),
     year: int = Query(...),
+    metric: str = Query(METRIC_ENERGY),
     history: HistoryService = Depends(get_history_service),
     user: dict[str, Any] = Depends(require_user),
 ) -> Response:
+    _validate_metric(metric, VIEW_YEAR)
     sid = await _resolve_station_id(history, station_id)
     if sid is None:
-        return _csv_response("month,energy\n", "history-year.csv")
-    series = await history.year_monthly(sid, year)
+        return _csv_response(f"month,{metric}\n", f"history-year-{metric}.csv")
+    series = await history.year_monthly(sid, year, metric=metric)
     return _csv_response(
-        _series_to_csv(series, x_header="month", y_header="energy"),
-        f"history-year-{sid}-{year}.csv",
+        _series_to_csv(series, x_header="month", y_header=metric),
+        f"history-year-{metric}-{sid}-{year}.csv",
     )
 
 
 @app.get("/history/all.csv")
 async def history_all_csv(
     station_id: str | None = Query(None),
+    metric: str = Query(METRIC_ENERGY),
     history: HistoryService = Depends(get_history_service),
     user: dict[str, Any] = Depends(require_user),
 ) -> Response:
+    _validate_metric(metric, VIEW_ALL)
     sid = await _resolve_station_id(history, station_id)
     if sid is None:
-        return _csv_response("year,energy\n", "history-all.csv")
-    series = await history.all_time(sid)
+        return _csv_response(f"year,{metric}\n", f"history-all-{metric}.csv")
+    series = await history.all_time(sid, metric=metric)
     return _csv_response(
-        _series_to_csv(series, x_header="year", y_header="energy"),
-        f"history-all-{sid}.csv",
+        _series_to_csv(series, x_header="year", y_header=metric),
+        f"history-all-{metric}-{sid}.csv",
     )