Update version to 0.1.2 in pyproject.toml. Add new commands to CLI for fetching meter readings and current consumption, and enhance README.md with usage examples for these commands. Introduce new models for MeterReading and CurrentConsumption in models.py.

Author: fjfricke

README.md

@@ -48,6 +48,19 @@ poetry run brunata readings --kind heating
 poetry run brunata readings --kind hot_water
 ```
 
+Zählerstand abrufen:
+
+```bash
+poetry run brunata meter
+```
+
+Aktuellen Verbrauch (wie im Dashboard) abrufen:
+
+```bash
+poetry run brunata current --kind heating
+poetry run brunata current --kind hot_water
+```
+
 ## Nutzung als Library (Home Assistant)
 
 Der Client ist async und für HA-Coordinator-Patterns geeignet:

pyproject.toml

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

src/brunata_api/cli.py

@@ -100,6 +100,28 @@ async def _cmd_readings(args: argparse.Namespace) -> int:
     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]
+        print(json.dumps(payload, indent=2))
+    return 0
+
+
+async def _cmd_current(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:
+        cur = await c.get_current_consumption(kind)
+        print(json.dumps(cur.model_dump(mode="json"), indent=2))
+    return 0
+
+
 def build_parser() -> argparse.ArgumentParser:
     p = argparse.ArgumentParser(prog="brunata")
     sub = p.add_subparsers(dest="cmd", required=True)
@@ -115,6 +137,13 @@ 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_meter = sub.add_parser("meter", help="Fetch Zählerstand (cumulative meter readings).")
+    p_meter.set_defaults(func=_cmd_meter)
+
+    p_current = sub.add_parser("current", help="Fetch dashboard 'aktueller Verbrauch' (kWh).")
+    p_current.add_argument("--kind", choices=[k.value for k in ReadingKind], required=True)
+    p_current.set_defaults(func=_cmd_current)
+
     return p
 
 

src/brunata_api/client.py

@@ -13,7 +13,7 @@
 import httpx
 
 from .errors import LoginError
-from .models import Reading, ReadingKind
+from .models import CurrentConsumption, MeterReading, Reading, ReadingKind
 
 
 def _default_headers() -> dict[str, str]:
@@ -495,6 +495,98 @@ async def get_dashboard_dates(self) -> dict[str, Any]:
         )
         return await self._dashboard_batch_get(rel)
 
+    @staticmethod
+    def _parse_sap_number(value: str) -> float:
+        # Values may be padded with spaces and use dot decimals.
+        return float(value.strip().replace(",", "."))
+
+    async def get_meter_reading(self, *, cost_type: str) -> MeterReading:
+        """
+        Get the cumulative meter/index value (Zählerstand) for a cost type.
+
+        Uses `NP_DASHBOARD_SRV/CumuConsumptionSet`.
+        """
+        if not self._logged_in:
+            await self.login()
+        if not self._user_unit_id:
+            raise LoginError("Missing UserUnitID.")
+
+        dates = await self.get_dashboard_dates()
+        results = (dates.get("d") or {}).get("results") or []
+        if not results:
+            raise LoginError("No dashboard periods found.")
+
+        period = next((p for p in results if isinstance(p, dict)), None)
+        if not period:
+            raise LoginError("No dashboard period object found.")
+
+        bis_raw = period.get("Bisdatum")
+        if not isinstance(bis_raw, str):
+            raise LoginError("Missing Bisdatum in dashboard period.")
+
+        bis_dt = self._sap_date_to_datetime(bis_raw)
+        if not bis_dt:
+            raise LoginError("Could not parse Bisdatum.")
+
+        bis_filter_dt = bis_dt.replace(hour=0, minute=0, second=0, microsecond=0) + timedelta(
+            hours=23
+        )
+        bis_filter = bis_filter_dt.strftime("%Y-%m-%dT%H:%M:%S")
+
+        rel = (
+            f"CumuConsumptionSet?sap-client={quote(self.sap_client)}&$filter="
+            f"Nutzein%20eq%20%27{quote(self._user_unit_id)}%27%20and%20"
+            f"Bis%20eq%20datetime%27{quote(bis_filter)}%27%20and%20"
+            f"Kotyp%20eq%20%27{quote(cost_type)}%27"
+        )
+
+        data = await self._dashboard_batch_get(rel)
+        rows = (data.get("d") or {}).get("results") or []
+        if not rows:
+            raise LoginError(f"No CumuConsumptionSet results for cost type {cost_type}.")
+
+        row = rows[0]
+        val_raw = row.get("Verbrauch")
+        if not isinstance(val_raw, str):
+            raise LoginError("CumuConsumptionSet missing Verbrauch.")
+        value = self._parse_sap_number(val_raw)
+        unit = row.get("MassreadTxt") or row.get("Massread")
+        unit_s = str(unit) if unit else None
+        kind = ReadingKind.heating if cost_type.startswith("HZ") else ReadingKind.hot_water
+
+        # CumuConsumptionSet uses the period end (Bis) as the timestamp.
+        return MeterReading(
+            timestamp=bis_dt,
+            value=value,
+            unit=unit_s,
+            cost_type=cost_type,
+            kind=kind,
+        )
+
+    async def get_meter_readings(self) -> list[MeterReading]:
+        """
+        Convenience helper: return meter readings for the first HZ.. and WW.. cost types.
+        """
+        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 [])
+        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))
+        return out
+
     async def get_supported_cost_types(self) -> dict[str, set[str]]:
         """
         Return cost types available per period.
@@ -590,6 +682,51 @@ async def get_monthly_consumption(
 
         return []
 
+    async def get_current_consumption(self, kind: ReadingKind) -> CurrentConsumption:
+        """
+        Returns the value shown in the dashboard cards:
+        'aktueller Verbrauch' and 'aktueller Verbrauch vom <date>'.
+
+        Implementation: sum the monthly kWh series for the active period.
+        """
+        if not self._logged_in:
+            await self.login()
+
+        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:
+            raise LoginError("No dashboard period found.")
+
+        bis_raw = period.get("Bisdatum")
+        if not isinstance(bis_raw, str):
+            raise LoginError("Missing Bisdatum in dashboard period.")
+        as_of = self._sap_date_to_datetime(bis_raw)
+        if not as_of:
+            raise LoginError("Could not parse Bisdatum.")
+
+        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)
+        ]
+
+        if kind == ReadingKind.heating:
+            cost_type = next((ct for ct in cost_types if ct.startswith("HZ")), "HZ01")
+        else:
+            cost_type = next((ct for ct in cost_types if ct.startswith("WW")), "WW01")
+
+        monthly = await self.get_monthly_consumption(cost_type=cost_type, in_kwh=True)
+        total = round(sum(r.value for r in monthly), 3)
+        return CurrentConsumption(
+            as_of=as_of,
+            value=total,
+            unit="kWh",
+            kind=kind,
+            cost_type=cost_type,
+        )
+
     async def get_readings(self, kind: ReadingKind) -> list[Reading]:
         if not self._logged_in:
             await self.login()

src/brunata_api/models.py

@@ -24,3 +24,23 @@ class Reading(BaseModel):
     unit: str | None = Field(default=None, description="Optional unit, if known.")
     kind: ReadingKind
 
+
+class MeterReading(BaseModel):
+    """A cumulative meter/index reading (Zählerstand) for a given cost type."""
+
+    timestamp: datetime = Field(..., description="Timestamp for the reading (period end).")
+    value: float = Field(..., description="Numeric value of the meter/index.")
+    unit: str | None = Field(default=None, description="Unit label (e.g. m³, Einh.).")
+    cost_type: str = Field(..., description="Portal cost type (e.g. HZ01, WW01).")
+    kind: ReadingKind
+
+
+class CurrentConsumption(BaseModel):
+    """Current cumulative consumption (e.g. year-to-date) shown in the dashboard cards."""
+
+    as_of: datetime = Field(..., description="The dashboard's 'as of' date.")
+    value: float = Field(..., description="Cumulative consumption up to as_of.")
+    unit: str = Field(..., description="Unit label (typically kWh in the dashboard toggle).")
+    kind: ReadingKind
+    cost_type: str
+