microgrid 0.1.2__tar.gz → 0.1.4__tar.gz

microgrid-0.1.4/CHANGELOG.md

@@ -0,0 +1,154 @@
+# Changelog
+
+Each user-visible change, under the release it ships in.
+
+## [Unreleased]
+
+## [0.1.4] - 2026-11-15
+
+### Added
+
+- The Home Assistant integration's plant builder asks only what a battery's
+  specification states (capacity, limits, reserve, inverter rating) and proposes it
+  from the Energy dashboard's battery sensors over the last week; its efficiencies and
+  the inverter's draw take the library's defaults.
+- `microgrid.cli.seen`: a battery's rating as its meters show it (the most it charged
+  and discharged, its capacity from the energy it took against its SOC).
+- The Home Assistant integration's setup proposes what Home Assistant already knows: the
+  price, PV and load forecast integrations installed (TariffKit, Nord Pool, Amber,
+  Tibber, Octopus, ENTSO-E, OpenEI, Solcast, EMHASS, Predbat), each read at once where
+  it needs nothing more; the measured entities and the battery's capacity the Energy
+  dashboard names. Each meter's sign is checked against two days of the recorder's
+  history and, where the records say it reads the other way, set on confirmation. A
+  plant file and a `sources/1` file can be imported together. A plant is set up once.
+- `microgrid.cli.signs`: each meter's sign, told from what the meters recorded (PV and
+  DC-bus loads positive, the battery against its SOC, the grid by the balance).
+- A Home Assistant integration (`custom_components/microgrid`, installed from Home Assistant's
+  Marketplace, from a release's `microgrid.zip`; Home Assistant 2026.11 or later): the plant (`plant/2`, pasted or built step by step),
+  its measured entities and its sources configured in Home Assistant, each checked by
+  the library and each source read once before it is kept. It publishes the valuation
+  (its slots in an unrecorded attribute), the live value (marginal cost, surplus,
+  regime, values by source), the prices in force and the battery's floor as entities,
+  a problem sensor, and `microgrid.get_valuation` (`valuation/2`, the live value); runs
+  the battery's ledger over the recorder's history; raises a repair issue for a source
+  that keeps failing. *Run it in Home Assistant* documents it.
+- Price readers for more Home Assistant integrations, in `sources/1`: Nord Pool
+  (`from = "nordpool"`), Amber Electric (`amber`), Tibber (`tibber`), Octopus Energy
+  (`octopus`), ENTSO-E (`entsoe`) and OpenEI (`openei`), each reading what the
+  integration publishes. OpenEI publishes no rate past the next change, so its prices,
+  and the valuation's horizon, end there.
+- `from = "action"`: any input from an action whose response holds rows, as an entity's
+  attribute would.
+- A fixed `export` price per kWh, for prices whose source publishes the import alone
+  (an entity's or an action's rows, and the named readers with no export price).
+  Import and export prices from separate entities are split at each change of either.
+- A forecast read from a source has each interval that starts or ends inside an engine
+  slot split where the slots begin, so quarter-hour prices are priced at 10-minute
+  slots, each slot at the mean of its pieces.
+- `microgrid.cli.sources.api.HomeAssistantApi`: what a reader asks of Home Assistant.
+  The readers take any client that answers it, and import without an HTTP client.
+  `read.read_forecast`, `read.source_name`, `config.forecast_source` and
+  `config.measured_source` are public.
+
+### Changed (documentation)
+
+- The documentation and the module docstrings no longer rebut what nobody said:
+  denials, disclaimers and contrasts with an alternative the text never raised are gone
+  ("not the average one", "never guessed", "not one class per topology", "fetches
+  none", "Pure: no I/O", ...). A contrast stays where the text argues it, as *The
+  marginal price* does the average cost.
+  - *Scope* keeps what a client brings and what the library can't model; its *Prices
+    energy, models no load* and *No I/O* sections are gone.
+  - *The plant model*'s section is *It models the plant's own rules*; *Replay*'s is
+    *What a replay reads*; *The make-up rule*'s *What the rule does not decide* is
+    *Grid charging*. R-5 is *Marginal*.
+  - Nothing is "yours to decide", "yours to add" or "the client's to correct": each
+    says who does what. No "your": *Describe a plant*, *Run a first valuation*, *Write
+    a plant model*, *Get prices from live sources*, and the text speaks of a plant, the
+    meters, the recorder.
+
+## [0.1.3] - 2026-10-18
+
+### Changed (documentation)
+
+- The README, the documentation's home page, the install page and the package
+  docstrings no longer say that the plant model stands alone; how to use it without the
+  prices is its how-to (*Use the plant model on its own*).
+
+## [0.1.2] - 2026-10-18
+
+### Fixed (documentation)
+
+- The documentation's home page: *What makes it different* is *How it prices*; the
+  parts name `microgrid.plant`, the plant model, apart from `microgrid.engine`; the
+  line saying to install from the git repository is gone (it is on PyPI).
+
+## [0.1.1] - 2026-10-18
+
+### Changed (documentation)
+
+- The README, the documentation's home page and the package's summary say what the
+  library takes and returns, without the "data in, data out" slogan; why it does no I/O
+  is in *Scope* (`docs/methodology/scope.md`).
+
+## [0.1.0] - 2026-10-18
+
+The first version, under the MIT license.
+
+### Added (library)
+
+- **The plant model, `microgrid.plant`.** A plant described as data (`plant/2`): PV
+  arrays of either coupling, a battery on its own inverter or on a hybrid's DC bus,
+  loads on either bus, the grid's limits, grid-charge and export windows, hold rules
+  and the meters. `Plant.project` runs it slot by slot. It stands alone: importing it
+  loads none of the price code. Four example plants (`microgrid.plant.examples`), and
+  a port for a plant model of your own (`microgrid.plant.port`: `PlantModel`,
+  `Storage`), checked by `microgrid.engine.testing.assert_plant_model_contract`.
+- **The price model, `microgrid.engine`.** Marginal prices from inputs given as time
+  series (`Inputs`: prices, PV forecast quantiles, the load forecast, the SOC, the
+  battery's lots). For each slot it gives:
+  - the marginal cost, and the same for a dull day (the PV forecast's p10);
+  - the regime, the certainties and the surplus;
+  - the supply stack;
+  - the value of a PV kWh and of a battery kWh diverted to a flexible load.
+
+  `Engine.value` gives these as a valuation (`valuation/2`). `Engine.live_session`
+  gives a live value between valuations.
+  - **A battery kWh** is priced at the running average cost of what the battery holds
+    (`Pricing.battery_value = "stored_cost"`), or by the make-up rule (`"replacement"`).
+  - **Missing or stale inputs** move values toward the import price, and the valuation
+    names them in `degraded`.
+  - **Configuration:** `engine/2`.
+- **Series and units** (`microgrid.engine.series`, `microgrid.engine.units`).
+  - Forecasts are series of issues, read as a client had them at a moment.
+  - Units are converted at the edge.
+  - Money is in the prices' currency, never converted, and no name says one.
+- **The battery's lots** (`microgrid.engine.ledger`): what the battery holds by source,
+  and what it cost.
+- **Analysis** (`microgrid.engine.analysis`): the plant model scored against its meters,
+  and valuations scored against what each kWh realised.
+
+### Added (command)
+
+- **`microgrid` on a dataset** (`dataset/1`): `value`, `live`, `replay`, `check-plant`,
+  `ledger`, `fit-battery`, `config check` and `schema`. A dataset whose prices name two
+  currencies is refused.
+- **`microgrid` on live sources** (`sources/1`, the `sources` extra): `sources`, `now` and
+  `fetch`. Each input comes from a provider's Home Assistant integration (TariffKit,
+  Solcast, EMHASS, Predbat) or an entity.
+- **The example dataset** (`examples/dataset`): a synthetic week of an example plant in
+  Europe/Berlin, across the DST change, with the outputs it is expected to give.
+
+### Added (releases)
+
+- **Versions and releases:** semantic versioning, explained beside the formats', the
+  API's and the model's versions (`docs/reference/versions.md`); `microgrid --version`
+  prints the release with the API (`engine-api/5`) and the model (`pricing/1.3`) it
+  carries. Releases are published to
+  PyPI from a tag (`vX.Y.Z`).
+
+### Added (documentation)
+
+- **The documentation:** the methodology and the library's requirements (R-1 to R-9),
+  the concepts, how-to guides and the reference, published with each release at
+  `https://eman.github.io/microgrid/`.

{microgrid-0.1.2 → microgrid-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: microgrid
-Version: 0.1.2
+Version: 0.1.4
 Summary: A plant model and marginal energy prices for a solar + battery microgrid
 Project-URL: Homepage, https://github.com/eman/microgrid
 Project-URL: Documentation, https://eman.github.io/microgrid/
@@ -30,8 +30,7 @@ Description-Content-Type: text/markdown
 
 `microgrid` is a library that models a solar + battery plant (`microgrid.plant`) and
 produces **marginal energy prices** from it (`microgrid.engine`): what one more kWh
-costs, slot by slot over a horizon, and the value of energy by source. The plant model
-also stands alone, without the price code.
+costs, slot by slot over a horizon, and the value of energy by source.
 
 You describe the plant (`plant/2`: PV of either coupling, a battery on its own inverter
 or on a hybrid's DC bus, loads on either bus, the grid's limits and charge windows) and
@@ -49,6 +48,10 @@ pip install microgrid                # or: uv add microgrid
 pip install "microgrid[sources]"     # with the readers of live sources (Home Assistant)
 ```
 
+In Home Assistant, the integration (`custom_components/microgrid`, through its Marketplace) installs
+it and runs it on Home Assistant's own entities
+([Run it in Home Assistant](https://github.com/eman/microgrid/blob/main/docs/how-to/home-assistant.md)).
+
 Python 3.14 or later. Before 1.0 a minor release may change a format, the API or the
 model: pin the minor release you tested with (`microgrid ~= 0.1.0`,
 [Versions](https://github.com/eman/microgrid/blob/main/docs/reference/versions.md)).
@@ -76,8 +79,8 @@ uv run microgrid config check --data examples/dataset   # its plant/2 and engine
 uv run microgrid schema                                 # the outputs' schema
 ```
 
-With a `sources/1` file naming a provider per input (any of several, none assumed; the
-`sources` extra, `microgrid[sources]`), it reads live inputs instead of a dataset:
+With a `sources/1` file naming a provider per input (the `sources`
+extra, `microgrid[sources]`), it reads live inputs instead of a dataset:
 
 ```sh
 uv run microgrid sources --sources sources.toml   # what each input is read from, or why not

{microgrid-0.1.2 → microgrid-0.1.4}/README.md

@@ -2,8 +2,7 @@
 
 `microgrid` is a library that models a solar + battery plant (`microgrid.plant`) and
 produces **marginal energy prices** from it (`microgrid.engine`): what one more kWh
-costs, slot by slot over a horizon, and the value of energy by source. The plant model
-also stands alone, without the price code.
+costs, slot by slot over a horizon, and the value of energy by source.
 
 You describe the plant (`plant/2`: PV of either coupling, a battery on its own inverter
 or on a hybrid's DC bus, loads on either bus, the grid's limits and charge windows) and
@@ -21,6 +20,10 @@ pip install microgrid                # or: uv add microgrid
 pip install "microgrid[sources]"     # with the readers of live sources (Home Assistant)
 ```
 
+In Home Assistant, the integration (`custom_components/microgrid`, through its Marketplace) installs
+it and runs it on Home Assistant's own entities
+([Run it in Home Assistant](https://github.com/eman/microgrid/blob/main/docs/how-to/home-assistant.md)).
+
 Python 3.14 or later. Before 1.0 a minor release may change a format, the API or the
 model: pin the minor release you tested with (`microgrid ~= 0.1.0`,
 [Versions](https://github.com/eman/microgrid/blob/main/docs/reference/versions.md)).
@@ -48,8 +51,8 @@ uv run microgrid config check --data examples/dataset   # its plant/2 and engine
 uv run microgrid schema                                 # the outputs' schema
 ```
 
-With a `sources/1` file naming a provider per input (any of several, none assumed; the
-`sources` extra, `microgrid[sources]`), it reads live inputs instead of a dataset:
+With a `sources/1` file naming a provider per input (the `sources`
+extra, `microgrid[sources]`), it reads live inputs instead of a dataset:
 
 ```sh
 uv run microgrid sources --sources sources.toml   # what each input is read from, or why not

{microgrid-0.1.2 → microgrid-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "microgrid"
-version = "0.1.2"
+version = "0.1.4"
 description = "A plant model and marginal energy prices for a solar + battery microgrid"
 readme = "README.md"
 requires-python = ">=3.14"
@@ -55,6 +55,10 @@ dev = [
     { include-group = "docs" },
     # The sources extra, so the gate covers the readers.
     "microgrid[sources]",
+    # The Home Assistant integration's tests (custom_components/microgrid).
+    # Home Assistant's own harness, released with each Home Assistant version (it pins
+    # that version); Home Assistant 2026.11 needs Python 3.14.2.
+    "pytest-homeassistant>=2026.11.1; python_full_version >= '3.14.2'",
 ]
 
 [project.scripts]
@@ -86,11 +90,13 @@ include = [
     "/LICENSE",
     "/pyproject.toml",
 ]
+# The Home Assistant integration's tests need the integration, which the sdist leaves out.
+exclude = ["/tests/ha", "/tests/ha_fixtures.py", "/tests/test_manifest.py"]
 
 [tool.ruff]
 line-length = 100
 target-version = "py314"
-src = ["src", "tests"]
+src = ["src", "tests", "custom_components"]
 
 [tool.ruff.lint]
 select = ["E", "F", "W", "I", "N", "UP", "B", "A", "ANN", "C4", "RET", "SIM", "PTH", "RUF"]
@@ -98,18 +104,30 @@ ignore = ["ANN401"]
 
 [tool.ruff.lint.per-file-ignores]
 "tests/**" = ["ANN"]
+# The Home Assistant integration follows Home Assistant's conventions.
+"custom_components/**" = ["A002", "N805"]
 
 [tool.mypy]
 strict = true
 warn_unreachable = true
 python_version = "3.14"
 plugins = ["pydantic.mypy"]
-files = ["src", "tests", "scripts"]
+files = ["src", "tests", "scripts", "custom_components/microgrid"]
+mypy_path = ["$MYPY_CONFIG_FILE_DIR/src", "$MYPY_CONFIG_FILE_DIR/tests", "$MYPY_CONFIG_FILE_DIR"]
+explicit_package_bases = true
+
+[[tool.mypy.overrides]]
+# Home Assistant's test harness ships no type information.
+module = ["pytest_homeassistant.*"]
+ignore_missing_imports = true
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
-addopts = "-q --strict-markers"
-asyncio_mode = "strict"
+# The repository (custom_components) and the tests' shared modules.
+pythonpath = [".", "tests"]
+# respx's plugin imports httpx before Home Assistant aliases it to httpx2.
+addopts = "-q --strict-markers -p no:respx"
+asyncio_mode = "auto"
 markers = [
     "live: needs the site's HA, EMQX or InfluxDB; never run by the local gate",
 ]

{microgrid-0.1.2 → microgrid-0.1.4}/scripts/ci_local.sh

@@ -33,17 +33,24 @@ if [ "${1:-}" = "--docs" ]; then
 fi
 
 step "ruff check"
-uv run --locked ruff check src tests scripts
+uv run --locked ruff check src tests scripts custom_components
 
 step "ruff format --check"
-uv run --locked ruff format --check src tests scripts
+uv run --locked ruff format --check src tests scripts custom_components
 
 step "mypy (strict)"
 uv run --locked mypy
 
 docs
 
-step "pytest"
-uv run --locked pytest -m "not live" --cov --cov-report=term
+step "pytest (the library, without Home Assistant)"
+# Home Assistant's harness loads in every session, and Home Assistant 2026.11 makes
+# `import httpx` resolve to httpx2 process-wide: the library outside Home Assistant runs
+# on httpx itself, so it is tested without the harness.
+uv run --locked pytest -m "not live" --ignore=tests/ha -p no:pytest_homeassistant \
+  --cov --cov-report=
+
+step "pytest (the Home Assistant integration)"
+uv run --locked pytest -m "not live" tests/ha --cov --cov-append --cov-report=term
 
 printf '\nlocal CI: all checks passed\n'

{microgrid-0.1.2 → microgrid-0.1.4}/src/microgrid/__init__.py

@@ -1,11 +1,10 @@
 """microgrid: a solar + battery plant modelled, and its marginal energy prices.
 
-- :mod:`microgrid.plant`: the plant model and its simulator, on their own: a plant
+- :mod:`microgrid.plant`: the plant model and its simulator: a plant
   described as data (``plant/2``), projected slot by slot.
 - :mod:`microgrid.engine`: the marginal prices, a client of the plant model.
 - :mod:`microgrid.cli`: the ``microgrid`` command, the library run on a dataset's files
-  (``dataset/1``) or on a site's live sources (``sources/1``, the ``sources`` extra). A
-  client of the public names, as any other.
+  (``dataset/1``) or on a site's live sources (``sources/1``, the ``sources`` extra).
 
 A requirement cited as R-n is the documentation's (``docs/methodology/requirements.md``).
 """

{microgrid-0.1.2 → microgrid-0.1.4}/src/microgrid/cli/__init__.py

@@ -9,6 +9,8 @@ files (``dataset/1``), or on a site's live sources (``sources/1``: ``now``, ``so
   battery's lots.
 - :mod:`.offline`, :mod:`.replay`, :mod:`.check_plant`, :mod:`.fit_battery`,
   :mod:`.evaluation`: the commands' work on a dataset.
+- :mod:`.signs`: each meter's sign, told from what it recorded; :mod:`.seen`, a
+  battery's rating as its meters show it.
 - :mod:`.sources`: the readers of the live sources a ``sources/1`` file names (Home
   Assistant, TariffKit, Solcast, EMHASS, Predbat, any entity), behind the ``sources``
   extra. A service that runs the library on a site builds on them.
@@ -16,8 +18,7 @@ files (``dataset/1``), or on a site's live sources (``sources/1``: ``now``, ``so
 **The public surface** is each module's ``__all__``: what another client may import. The
 library's architecture test holds every module to declaring one.
 
-It reads and writes files and the network; the engine (:mod:`microgrid.engine`) does no
-I/O, and this package uses only the engine's public names.
+It reads and writes files and the network.
 """
 
 __all__ = [
@@ -30,6 +31,8 @@ __all__ = [
     "main",
     "offline",
     "replay",
+    "seen",
+    "signs",
     "sources",
     "toml_text",
 ]

{microgrid-0.1.2 → microgrid-0.1.4}/src/microgrid/cli/dataset.py

@@ -1,7 +1,7 @@
 """A dataset: a directory of the library's series (``dataset/1``), so every command
 runs without the plant it came from.
 
-**The format, ``dataset/1``,** is the library's own terms, not any integration's:
+**The format, ``dataset/1``,** is the library's own terms:
 
 - ``manifest.json``: ``{"format": "dataset/1", "entries": {name: {"file": ...,
   "kind": ..., "forecasts": bool}}}``. An entry's ``kind`` is how its values read:

{microgrid-0.1.2 → microgrid-0.1.4}/src/microgrid/cli/history.py

@@ -13,9 +13,9 @@ battery and a DC-bus load, allocated at every change, only while the path was al
 within the heartbeat's limit where the bindings name one, else wherever each series is
 known), the SOC read at each slot boundary, and the prices each slot was charged at as
 the time-weighted mean of the recorded price in force over it (``series.means``): any
-price resolution, on any slot, and no price read before it took effect. A recorder that
-writes a change late (a sensor updating seconds after the hour) is the client's to
-correct at its edge, as for any series. A PV lot's basis is the export price when it was
+price resolution, on any slot, and no price read before it took effect. A client corrects
+a recorder that writes a change late (a sensor updating seconds after the hour) at
+its edge, as for any series. A PV lot's basis is the export price when it was
 charged (what the site gave up to store it), a grid lot's the import price
 (docs/methodology/lots.md). Every function takes the slot it works on
 (``EngineConfig.slot``; :data:`~microgrid.engine.series.SLOT` by default).

microgrid-0.1.4/src/microgrid/cli/seen.py

@@ -0,0 +1,114 @@
+"""What a battery's meters show of its rating: the most it was seen to charge and
+discharge, and its capacity from the energy it took against its SOC's change.
+
+A proposal for a plant's file, where the battery's own figures are not to hand, not a
+fit: the most seen is a floor on the battery's limit (a week may never reach it), and
+the capacity is the energy charged and discharged over the SOC's travel, which leaves
+the conversion's losses out to first order (charging overstates it and discharging
+understates it by about as much). Pure: the caller reads the meters.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from typing import Final
+
+from microgrid.engine.series import Series, means, value_at
+
+__all__ = ["BatterySeen", "battery_seen", "rounded"]
+
+#: The span the most seen is taken over: a slot's mean, so a reading's spike is not
+#: taken for the battery's rate.
+PEAK_SLOT: Final = timedelta(minutes=5)
+#: The SOC must travel this far (a fraction, summed) for the capacity to be told.
+_TRAVEL_MIN: Final = 0.3
+#: An hour that moved less than this (kWh) is idle: what the SOC does then (a drift,
+#: a standby draw the meter does not see) is not the meter's energy.
+_IDLE_KWH: Final = 0.05
+#: A SOC this close to the highest or lowest it reached is at its bound: held there, it
+#: cannot step to follow what the meter shows (a battery kept full by PV, still
+#: balancing at full). The bound is what the sensor reached, not 1 or 0: some top out
+#: at 99 %.
+_AT_BOUND: Final = 0.005
+_HOUR: Final = timedelta(hours=1)
+
+
+@dataclass(frozen=True, slots=True)
+class BatterySeen:
+    """The battery's figures its meters show; None where they do not."""
+
+    #: The most it charged and discharged, kW, as a :data:`PEAK_SLOT` mean.
+    charge_kw: float | None
+    discharge_kw: float | None
+    #: Its capacity, kWh.
+    capacity_kwh: float | None
+
+
+def _slots(start: datetime, end: datetime, step: timedelta) -> list[datetime]:
+    return [start + i * step for i in range(int((end - start) / step))]
+
+
+def battery_seen(
+    power: Series[float], soc: Series[float] | None, start: datetime, end: datetime
+) -> BatterySeen:
+    """The figures ``power`` (kW, positive charging) and ``soc`` (a fraction) show
+    between ``start`` and ``end`` (whole hours)."""
+    peaks = [v for v in means(power, _slots(start, end, PEAK_SLOT), PEAK_SLOT) if v is not None]
+    charge = max((v for v in peaks if v > 0), default=None)
+    discharge = max((-v for v in peaks if v < 0), default=None)
+    return BatterySeen(
+        charge, discharge, None if soc is None else _capacity(power, soc, start, end)
+    )
+
+
+def _capacity(
+    power: Series[float], soc: Series[float], start: datetime, end: datetime
+) -> float | None:
+    """The energy moved over the SOC's travel. An hour the SOC did not step keeps its
+    energy: over a run of hours the SOC's travel adds up to the true change within one
+    step, so leaving such hours out would leave energy out and no travel. An hour where
+    the meter and the SOC go opposite ways (a step from the hour before, a meter out of
+    step) is left out, as is an hour the SOC spends at the highest or lowest it reached,
+    where it cannot move however the meter reads."""
+    starts = _slots(start, end, _HOUR)
+    kw = means(power, starts, _HOUR)
+    reached = [s.value for s in soc.samples if s.value is not None and start <= s.at <= end]
+    if not reached:
+        return None
+    top, bottom = max(reached), min(reached)
+    moved: list[float] = []
+    travelled: list[float] = []
+    for hour, mean in zip(starts, kw, strict=True):
+        before, after = value_at(soc, hour), value_at(soc, hour + _HOUR)
+        if mean is None or before is None or after is None:
+            continue
+        kwh, change = mean * 1.0, after - before
+        if abs(kwh) < _IDLE_KWH or kwh * change < 0 or _held(before, after, top, bottom):
+            continue
+        moved.append(abs(kwh))
+        travelled.append(abs(change))
+    total = math.fsum(travelled)
+    if total < _TRAVEL_MIN:
+        return None
+    return math.fsum(moved) / total
+
+
+def _held(before: float, after: float, top: float, bottom: float) -> bool:
+    """Whether the SOC was at the same bound (the highest or lowest it reached) at both
+    ends of an hour."""
+    return min(before, after) >= top - _AT_BOUND or max(before, after) <= bottom + _AT_BOUND
+
+
+def _round_up(value: float | None, step: float = 0.1) -> float | None:
+    return None if value is None else round(math.ceil(value / step - 1e-9) * step, 1)
+
+
+def rounded(seen: BatterySeen) -> BatterySeen:
+    """``seen`` to a tenth: the limits up, the capacity to the nearest."""
+    return BatterySeen(
+        charge_kw=_round_up(seen.charge_kw),
+        discharge_kw=_round_up(seen.discharge_kw),
+        capacity_kwh=None if seen.capacity_kwh is None else round(seen.capacity_kwh, 1),
+    )