Update client to return all HZ/WW cost types.

get_meter_readings() now returns a dict keyed by cost_type, add get_monthly_consumptions() for all series, and update CLI/README/tests accordingly.

Author: fjfricke

README.md

@@ -48,6 +48,13 @@ poetry run brunata readings --kind heating
 poetry run brunata readings --kind hot_water
 ```
 
+Verbrauchsdaten für **alle** CostTypes abrufen (z.B. `HZ01`, `HZ02`, ... / `WW01`, `WW02`, ...):
+
+```bash
+poetry run brunata readings-all --kind heating
+poetry run brunata readings-all --kind hot_water
+```
+
 Zählerstand abrufen:
 
 ```bash
@@ -87,6 +94,8 @@ Wichtige Methoden:
 - `BrunataClient.get_supported_cost_types()`
 - `BrunataClient.get_readings(...)`
 - `BrunataClient.get_monthly_consumption(cost_type=..., in_kwh=...)`
+- `BrunataClient.get_monthly_consumptions(kind, in_kwh=...)` (alle passenden CostTypes)
+- `BrunataClient.get_meter_readings()` (alle `HZ..` und `WW..`, keyed by `cost_type`)
 
 ## Entwicklung
 

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "brunata-api"
-version = "0.1.2"
+version = "0.1.3"
 description = "Async client for BRUdirekt (Brunata) portal"
 authors = [
     {name = "Felix Fricke"}

src/brunata_api/cli.py

@@ -100,13 +100,29 @@ async def _cmd_readings(args: argparse.Namespace) -> int:
     return 0
 
 
+async def _cmd_readings_all(args: argparse.Namespace) -> int:
+    base_url, username, password, sap_client = _load_config()
+    kind = ReadingKind(args.kind)
+    async with BrunataClient(
+        base_url=base_url, username=username, password=password, sap_client=sap_client
+    ) as c:
+        series = await c.get_monthly_consumptions(kind)
+        payload: dict[str, list[dict[str, Any]]] = {
+            ct: [r.model_dump(mode="json") for r in readings] for ct, readings in series.items()
+        }
+        print(json.dumps(payload, indent=2))
+    return 0
+
+
 async def _cmd_meter(_: argparse.Namespace) -> int:
     base_url, username, password, sap_client = _load_config()
     async with BrunataClient(
         base_url=base_url, username=username, password=password, sap_client=sap_client
     ) as c:
         readings = await c.get_meter_readings()
-        payload: list[dict[str, Any]] = [r.model_dump(mode="json") for r in readings]
+        payload: dict[str, dict[str, Any]] = {
+            ct: r.model_dump(mode="json") for ct, r in readings.items()
+        }
         print(json.dumps(payload, indent=2))
     return 0
 
@@ -137,6 +153,12 @@ def build_parser() -> argparse.ArgumentParser:
     p_readings.add_argument("--kind", choices=[k.value for k in ReadingKind], required=True)
     p_readings.set_defaults(func=_cmd_readings)
 
+    p_readings_all = sub.add_parser(
+        "readings-all", help="Fetch monthly series for all cost types (HZ../WW..)."
+    )
+    p_readings_all.add_argument("--kind", choices=[k.value for k in ReadingKind], required=True)
+    p_readings_all.set_defaults(func=_cmd_readings_all)
+
     p_meter = sub.add_parser("meter", help="Fetch Zählerstand (cumulative meter readings).")
     p_meter.set_defaults(func=_cmd_meter)
 

src/brunata_api/client.py

@@ -563,28 +563,31 @@ async def get_meter_reading(self, *, cost_type: str) -> MeterReading:
             kind=kind,
         )
 
-    async def get_meter_readings(self) -> list[MeterReading]:
+    async def get_meter_readings(self) -> dict[str, MeterReading]:
         """
-        Convenience helper: return meter readings for the first HZ.. and WW.. cost types.
+        Convenience helper: return meter readings for *all* HZ.. and WW.. cost types.
+
+        Output is keyed by `cost_type` (stable mapping for HA entity IDs).
         """
         dates = await self.get_dashboard_dates()
         results = (dates.get("d") or {}).get("results") or []
         period = next((p for p in results if isinstance(p, dict)), None)
         if not period:
-            return []
+            return {}
+
         unit_rows = ((period.get("Units") or {}).get("results") or [])
-        cost_types = [
-            r.get("CostType")
-            for r in unit_rows
-            if isinstance(r, dict) and isinstance(r.get("CostType"), str)
-        ]
-        hz = next((ct for ct in cost_types if ct.startswith("HZ")), None)
-        ww = next((ct for ct in cost_types if ct.startswith("WW")), None)
-        out: list[MeterReading] = []
-        if hz:
-            out.append(await self.get_meter_reading(cost_type=hz))
-        if ww:
-            out.append(await self.get_meter_reading(cost_type=ww))
+        all_cost_types = sorted(
+            {
+                r["CostType"]
+                for r in unit_rows
+                if isinstance(r, dict) and isinstance(r.get("CostType"), str)
+            }
+        )
+        wanted = [ct for ct in all_cost_types if ct.startswith(("HZ", "WW"))]
+
+        out: dict[str, MeterReading] = {}
+        for ct in wanted:
+            out[ct] = await self.get_meter_reading(cost_type=ct)
         return out
 
     async def get_supported_cost_types(self) -> dict[str, set[str]]:
@@ -682,6 +685,39 @@ async def get_monthly_consumption(
 
         return []
 
+    async def get_monthly_consumptions(
+        self,
+        kind: ReadingKind,
+        *,
+        in_kwh: bool = True,
+    ) -> dict[str, list[Reading]]:
+        """
+        Fetch monthly consumption series for *all* cost types matching `kind`.
+
+        Output is keyed by `cost_type` (e.g. HZ01, HZ02, WW01...).
+        """
+        dates = await self.get_dashboard_dates()
+        results = (dates.get("d") or {}).get("results") or []
+        period = next((p for p in results if isinstance(p, dict)), None)
+        if not period:
+            return {}
+
+        unit_rows = ((period.get("Units") or {}).get("results") or [])
+        all_cost_types = sorted(
+            {
+                r["CostType"]
+                for r in unit_rows
+                if isinstance(r, dict) and isinstance(r.get("CostType"), str)
+            }
+        )
+        prefix = "HZ" if kind == ReadingKind.heating else "WW"
+        wanted = [ct for ct in all_cost_types if ct.startswith(prefix)]
+
+        out: dict[str, list[Reading]] = {}
+        for ct in wanted:
+            out[ct] = await self.get_monthly_consumption(cost_type=ct, in_kwh=in_kwh)
+        return out
+
     async def get_current_consumption(self, kind: ReadingKind) -> CurrentConsumption:
         """
         Returns the value shown in the dashboard cards:

tests/test_client.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
 import asyncio
+from datetime import UTC, datetime
 
 import httpx
 
 from brunata_api.client import BrunataClient
+from brunata_api.models import MeterReading, Reading, ReadingKind
 
 
 def test_extract_json_objects_finds_embedded_json():
@@ -104,3 +106,89 @@ async def fake_dashboard_batch_get(_: str):
     assert readings[0].value == 10.0
     assert readings[1].value == 20.0
 
+
+def test_get_meter_readings_returns_all_hz_ww_cost_types_without_network():
+    client = BrunataClient(base_url="https://example.invalid", username="u", password="p")
+    client._logged_in = True  # avoid login()
+
+    async def fake_get_dashboard_dates():
+        return {
+            "d": {
+                "results": [
+                    {
+                        "Units": {
+                            "results": [
+                                {"CostType": "HZ01"},
+                                {"CostType": "HZ02"},
+                                {"CostType": "WW01"},
+                                {"CostType": "XX99"},
+                            ]
+                        }
+                    }
+                ]
+            }
+        }
+
+    async def fake_get_meter_reading(*, cost_type: str) -> MeterReading:
+        kind = ReadingKind.heating if cost_type.startswith("HZ") else ReadingKind.hot_water
+        return MeterReading(
+            timestamp=datetime(2025, 1, 1, tzinfo=UTC),
+            value=1.0,
+            unit="Einh.",
+            cost_type=cost_type,
+            kind=kind,
+        )
+
+    client.get_dashboard_dates = fake_get_dashboard_dates  # type: ignore[method-assign]
+    client.get_meter_reading = fake_get_meter_reading  # type: ignore[method-assign]
+
+    out = asyncio.run(client.get_meter_readings())
+    assert set(out.keys()) == {"HZ01", "HZ02", "WW01"}
+    assert out["HZ02"].cost_type == "HZ02"
+
+
+def test_get_monthly_consumptions_returns_all_cost_types_without_network():
+    client = BrunataClient(base_url="https://example.invalid", username="u", password="p")
+    client._logged_in = True  # avoid login()
+
+    async def fake_get_dashboard_dates():
+        return {
+            "d": {
+                "results": [
+                    {
+                        "Units": {
+                            "results": [
+                                {"CostType": "HZ01"},
+                                {"CostType": "HZ02"},
+                                {"CostType": "WW01"},
+                            ]
+                        }
+                    }
+                ]
+            }
+        }
+
+    seen: list[tuple[str, bool]] = []
+
+    async def fake_get_monthly_consumption(*, cost_type: str, in_kwh: bool = True) -> list[Reading]:
+        seen.append((cost_type, in_kwh))
+        kind = ReadingKind.heating if cost_type.startswith("HZ") else ReadingKind.hot_water
+        return [
+            Reading(
+                timestamp=datetime(2025, 1, 31, tzinfo=UTC),
+                value=10.0,
+                unit="kWh" if in_kwh else "m³",
+                kind=kind,
+            )
+        ]
+
+    client.get_dashboard_dates = fake_get_dashboard_dates  # type: ignore[method-assign]
+    client.get_monthly_consumption = fake_get_monthly_consumption  # type: ignore[method-assign]
+
+    out_hz = asyncio.run(client.get_monthly_consumptions(ReadingKind.heating, in_kwh=True))
+    assert set(out_hz.keys()) == {"HZ01", "HZ02"}
+    assert seen and all(in_kwh is True for _, in_kwh in seen)
+
+    out_ww = asyncio.run(client.get_monthly_consumptions(ReadingKind.hot_water, in_kwh=False))
+    assert set(out_ww.keys()) == {"WW01"}
+