garo-entity-pro 0.1.0__tar.gz

garo_entity_pro-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dodg3r
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

garo_entity_pro-0.1.0/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: garo-entity-pro
+Version: 0.1.0
+Summary: Async client for the Garo Entity Pro charger local HTTPS API (/status/...).
+License: MIT
+Keywords: garo,evcharger,ocpp,aiohttp,home-assistant
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Home Automation
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.9.0
+Requires-Dist: yarl>=1.9.0
+Provides-Extra: ha
+Requires-Dist: homeassistant>=2024.1.0; extra == "ha"
+Requires-Dist: voluptuous>=0.13; extra == "ha"
+Dynamic: license-file
+
+# garo-entity-pro
+
+Async Python client for the **Garo Entity Pro** wallbox local HTTPS API (`/status/energy-meter`, `/status/temperatures`, etc.).
+
+## Install
+
+```bash
+pip install garo-entity-pro
+```
+
+## Library usage
+
+```python
+from garo_entity_pro import GaroApiClient
+
+async def main():
+    async with GaroApiClient("https://192.168.1.10", "user", "pass", verify_ssl=False) as client:
+        data = await client.get_status()
+```
+
+Parsing helpers live under `garo_entity_pro.parsing` (OCPP-style meter payloads, state labels).
+
+## Home Assistant
+
+The custom integration in `custom_components/garo_entity_pro/` depends on this package (see `manifest.json`). Install the integration and ensure Home Assistant can install requirements, or run `pip install -e .` from this repository when developing.
+
+## Development
+
+```bash
+pip install -e ".[ha]"
+```
+
+Build a wheel:
+
+```bash
+pip install build && python -m build
+```

garo_entity_pro-0.1.0/README.md

@@ -0,0 +1,37 @@
+# garo-entity-pro
+
+Async Python client for the **Garo Entity Pro** wallbox local HTTPS API (`/status/energy-meter`, `/status/temperatures`, etc.).
+
+## Install
+
+```bash
+pip install garo-entity-pro
+```
+
+## Library usage
+
+```python
+from garo_entity_pro import GaroApiClient
+
+async def main():
+    async with GaroApiClient("https://192.168.1.10", "user", "pass", verify_ssl=False) as client:
+        data = await client.get_status()
+```
+
+Parsing helpers live under `garo_entity_pro.parsing` (OCPP-style meter payloads, state labels).
+
+## Home Assistant
+
+The custom integration in `custom_components/garo_entity_pro/` depends on this package (see `manifest.json`). Install the integration and ensure Home Assistant can install requirements, or run `pip install -e .` from this repository when developing.
+
+## Development
+
+```bash
+pip install -e ".[ha]"
+```
+
+Build a wheel:
+
+```bash
+pip install build && python -m build
+```

garo_entity_pro-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[project]
+name = "garo-entity-pro"
+version = "0.1.0"
+description = "Async client for the Garo Entity Pro charger local HTTPS API (/status/...)."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+keywords = ["garo", "evcharger", "ocpp", "aiohttp", "home-assistant"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Home Automation",
+]
+dependencies = [
+  "aiohttp>=3.9.0",
+  "yarl>=1.9.0",
+]
+
+[project.optional-dependencies]
+ha = [
+  "homeassistant>=2024.1.0",
+  "voluptuous>=0.13",
+]
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+garo_entity_pro = ["py.typed"]

garo_entity_pro-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

garo_entity_pro-0.1.0/src/garo_entity_pro/__init__.py

@@ -0,0 +1,19 @@
+"""Garo Entity Pro local API — async client and response parsing.
+
+Install from PyPI: ``pip install garo-entity-pro`` (import name ``garo_entity_pro``).
+"""
+
+from __future__ import annotations
+
+from .client import GaroApiClient
+from .exceptions import GaroApiError, GaroAuthError, GaroConnectionError, GaroHttpError
+from .parsing import CHARGING_STATE_LABELS
+
+__all__ = [
+    "CHARGING_STATE_LABELS",
+    "GaroApiClient",
+    "GaroApiError",
+    "GaroAuthError",
+    "GaroConnectionError",
+    "GaroHttpError",
+]

garo_entity_pro-0.1.0/src/garo_entity_pro/client.py

@@ -0,0 +1,239 @@
+"""Async HTTPS client for the Garo Entity Pro local REST API (aiohttp)."""
+
+from __future__ import annotations
+
+import json
+import ssl
+from typing import Any, Final
+
+import aiohttp
+from aiohttp import ClientTimeout, helpers
+from yarl import URL
+
+from .exceptions import GaroAuthError, GaroConnectionError, GaroHttpError
+
+_DEFAULT_TIMEOUT: Final = ClientTimeout(total=20, connect=10)
+# Entity Pro uses /status/... (not legacy /api/v1/... on older chargers).
+_DEFAULT_STATUS_PATH: Final = "/status/energy-meter"
+_DEFAULT_METER_PATH: Final = "/status/energy-meter"
+_DEFAULT_TEMPERATURES_PATH: Final = "/status/temperatures"
+_DEFAULT_METERVALUE_SAMPLE_PATH: Final = "/status/metervalue-sample"
+_DEFAULT_CHARGING_STATE_PATH: Final = "/status/charging-state"
+
+
+class GaroApiClient:
+    """HTTPS client using HTTP Basic authentication for Garo Entity Pro REST API."""
+
+    def __init__(
+        self,
+        host: str,
+        username: str,
+        password: str,
+        *,
+        port: int | None = None,
+        verify_ssl: bool = True,
+        timeout: ClientTimeout | None = None,
+        status_path: str = _DEFAULT_STATUS_PATH,
+        meter_path: str = _DEFAULT_METER_PATH,
+        temperatures_path: str = _DEFAULT_TEMPERATURES_PATH,
+        metervalue_sample_path: str = _DEFAULT_METERVALUE_SAMPLE_PATH,
+        charging_state_path: str = _DEFAULT_CHARGING_STATE_PATH,
+    ) -> None:
+        self._username = username.strip()
+        self._password = password.strip()
+        self._timeout = timeout or _DEFAULT_TIMEOUT
+        self._status_path = status_path
+        self._meter_path = meter_path
+        self._temperatures_path = temperatures_path
+        self._metervalue_sample_path = metervalue_sample_path
+        self._charging_state_path = charging_state_path
+        self._session: aiohttp.ClientSession | None = None
+
+        base = host.strip()
+        if not base.lower().startswith(("http://", "https://")):
+            base = f"https://{base}"
+        url = URL(base)
+        if port is not None:
+            url = url.with_port(port)
+        self._base_url: Final[URL] = url
+
+        if verify_ssl:
+            self._ssl: bool | ssl.SSLContext = True
+        else:
+            self._ssl = False
+
+    @property
+    def base_url(self) -> str:
+        """Configured base URL (scheme + host + optional port)."""
+        return str(self._base_url)
+
+    @property
+    def status_path(self) -> str:
+        """Configured GET path for primary telemetry (e.g. energy meter)."""
+        return self._status_path
+
+    @property
+    def meter_path(self) -> str:
+        """Configured GET path for meter data (may match status on Entity Pro)."""
+        return self._meter_path
+
+    @property
+    def temperatures_path(self) -> str:
+        """Configured GET path for CPU / baseboard temperatures."""
+        return self._temperatures_path
+
+    @property
+    def metervalue_sample_path(self) -> str:
+        """GET path for latest OCPP sampledValue snapshot."""
+        return self._metervalue_sample_path
+
+    @property
+    def charging_state_path(self) -> str:
+        """GET path for charging state (JSON string or object)."""
+        return self._charging_state_path
+
+    async def __aenter__(self) -> GaroApiClient:
+        await self._ensure_session()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: object | None,
+    ) -> None:
+        await self.close()
+
+    async def close(self) -> None:
+        """Close the underlying HTTP session."""
+        if self._session is not None and not self._session.closed:
+            await self._session.close()
+        self._session = None
+
+    async def _ensure_session(self) -> aiohttp.ClientSession:
+        if self._session is None or self._session.closed:
+            connector = aiohttp.TCPConnector(limit=10, ssl=self._ssl)
+            self._session = aiohttp.ClientSession(
+                timeout=self._timeout,
+                connector=connector,
+                raise_for_status=False,
+            )
+        return self._session
+
+    async def get_status(self) -> dict[str, Any]:
+        """GET primary telemetry (default: /status/energy-meter)."""
+        return await self.get_json(self._status_path)
+
+    async def get_meter(self) -> dict[str, Any]:
+        """GET meter data (default: /status/energy-meter; may equal status on Entity Pro)."""
+        return await self.get_json(self._meter_path)
+
+    async def get_temperatures(self) -> dict[str, Any]:
+        """GET /status/temperatures (CPU and baseboard; JSON object or array)."""
+        session = await self._ensure_session()
+        url = str(self._base_url.join(URL(self._temperatures_path)))
+        return await self._request_json(session, "GET", url, json_body=None)
+
+    async def get_metervalue_sample(self) -> dict[str, Any]:
+        """GET /status/metervalue-sample (single OCPP block with sampledValue)."""
+        return await self.get_json(self._metervalue_sample_path)
+
+    async def get_charging_state(self) -> dict[str, Any]:
+        """GET /status/charging-state (may be a JSON string, number, or object)."""
+        return await self.get_json(self._charging_state_path)
+
+    async def get_json(self, path: str) -> dict[str, Any]:
+        """GET request; returns parsed JSON object."""
+        session = await self._ensure_session()
+        url = str(self._base_url.join(URL(path)))
+        return await self._request_json(session, "GET", url, json_body=None)
+
+    def _basic_header(self) -> str:
+        return helpers.BasicAuth(self._username, self._password).encode()
+
+    async def _request_json(
+        self,
+        session: aiohttp.ClientSession,
+        method: str,
+        url: str,
+        *,
+        json_body: dict[str, Any] | None,
+    ) -> dict[str, Any]:
+        text, status = await self._send_with_auth(session, method, url, json_body=json_body)
+        self._raise_for_status(status, text)
+        if not text.strip():
+            return {}
+        try:
+            data = json.loads(text)
+        except json.JSONDecodeError as err:
+            msg = "Response is not valid JSON"
+            raise GaroHttpError(msg, status=status, body=text) from err
+        if isinstance(data, dict):
+            return data
+        if data is None:
+            return {}
+        # Entity Pro /status/energy-meter can return [] before the meter is ready.
+        if isinstance(data, list):
+            return {"_list": data}
+        # /status/charging-state may return a bare JSON string, number, or boolean.
+        if isinstance(data, str):
+            return {"state": data, "charging_state": data}
+        if isinstance(data, (int, float)):
+            return {"state": data, "charging_state": data}
+        if isinstance(data, bool):
+            return {"state": data, "charging_state": data, "charging": data}
+        msg = "Unexpected JSON value in response"
+        raise GaroHttpError(msg, status=status, body=text)
+
+    async def _send_with_auth(
+        self,
+        session: aiohttp.ClientSession,
+        method: str,
+        url: str,
+        *,
+        json_body: dict[str, Any] | None,
+    ) -> tuple[str, int]:
+        """Send request with HTTP Basic Authorization header."""
+        req_kwargs: dict[str, Any] = {
+            "method": method,
+            "url": url,
+            "headers": {"Authorization": self._basic_header()},
+            "ssl": self._ssl,
+        }
+        if json_body is not None:
+            req_kwargs["json"] = json_body
+
+        try:
+            async with session.request(**req_kwargs) as resp:
+                text = await resp.text(encoding="utf-8")
+                return text, resp.status
+        except aiohttp.ClientConnectorError as err:
+            msg = f"Connection failed: {err}"
+            raise GaroConnectionError(msg) from err
+        except aiohttp.ServerDisconnectedError as err:
+            msg = f"Server disconnected: {err}"
+            raise GaroConnectionError(msg) from err
+        except TimeoutError as err:
+            msg = "Request timed out"
+            raise GaroConnectionError(msg) from err
+        except aiohttp.ClientError as err:
+            msg = f"HTTP client error: {err}"
+            raise GaroConnectionError(msg) from err
+
+    @staticmethod
+    def _raise_for_status(status: int, body: str) -> None:
+        if status == 401:
+            detail = (body or "").strip()[:300]
+            msg = "Authentication failed (check username/password and that the account is enabled)"
+            if detail:
+                msg = f"{msg}. Server response: {detail}"
+            raise GaroAuthError(msg)
+        if status == 403:
+            detail = (body or "").strip()[:300]
+            msg = "Forbidden (wrong role or API disabled)"
+            if detail:
+                msg = f"{msg}. Server response: {detail}"
+            raise GaroAuthError(msg)
+        if 400 <= status < 600:
+            msg = f"HTTP {status}"
+            raise GaroHttpError(msg, status=status, body=body or None)

garo_entity_pro-0.1.0/src/garo_entity_pro/exceptions.py

@@ -0,0 +1,24 @@
+"""Exceptions raised by the Garo Entity Pro local API client."""
+
+from __future__ import annotations
+
+
+class GaroApiError(Exception):
+    """Base error for Garo API failures."""
+
+
+class GaroAuthError(GaroApiError):
+    """Invalid credentials or unsupported auth scheme."""
+
+
+class GaroConnectionError(GaroApiError):
+    """Network-level failure (timeout, refused, TLS, etc.)."""
+
+
+class GaroHttpError(GaroApiError):
+    """Non-success HTTP status from the device."""
+
+    def __init__(self, message: str, *, status: int, body: str | None = None) -> None:
+        super().__init__(message)
+        self.status = status
+        self.body = body

garo_entity_pro-0.1.0/src/garo_entity_pro/parsing.py

@@ -0,0 +1,386 @@
+"""Normalize common charger fields from heterogeneous Garo JSON responses."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+# /status/charging-state returns short codes; map to display labels (extend as needed).
+CHARGING_STATE_LABELS: dict[str, str] = {
+    "A1": "Available",
+}
+
+
+def _as_float(value: Any) -> float | None:
+    if value is None:
+        return None
+    if isinstance(value, bool):
+        return None
+    if isinstance(value, (int, float)):
+        return float(value)
+    try:
+        return float(str(value))
+    except (TypeError, ValueError):
+        return None
+
+
+def _list_is_ocpp_meter_values(lst: list[Any]) -> bool:
+    """True for OCPP MeterValue arrays (timestamp + sampledValue with measurand)."""
+    for item in lst:
+        if isinstance(item, dict) and isinstance(item.get("sampledValue"), list):
+            return True
+    return False
+
+
+def merge_layers(*layers: Mapping[str, Any]) -> dict[str, Any]:
+    """Later mappings override earlier keys.
+
+    If the API returns a JSON array it is wrapped as ``{"_list": [...]}``.
+    OCPP-style meter arrays (``sampledValue`` / ``measurand``) are **not** merged
+    per-element into the top level (that would overwrite ``sampledValue``); they
+    are left under ``_list`` for :func:`_enrich_from_ocpp_meter_list`.
+    Other list shapes are merged dict-by-dict as before.
+    """
+    merged: dict[str, Any] = {}
+    for m in layers:
+        merged.update(m)
+    lst = merged.get("_list")
+    if isinstance(lst, list) and not _list_is_ocpp_meter_values(lst):
+        for item in lst:
+            if isinstance(item, dict):
+                merged.update(item)
+    return merged
+
+
+def _location_matches(
+    sv: dict[str, Any],
+    location: str | None,
+    *,
+    location_must_be_absent: bool,
+) -> bool:
+    """When location_must_be_absent is True, only rows without a location field match."""
+    loc = sv.get("location")
+    if location_must_be_absent:
+        return loc is None or loc == ""
+    if location is not None:
+        return loc == location
+    return True
+
+
+def get_ocpp_sample_float(
+    *layers: Mapping[str, Any],
+    measurand: str,
+    phase: str | None = None,
+    location: str | None = None,
+    location_must_be_absent: bool = False,
+) -> float | None:
+    """Last matching sampledValue wins (metervalue-sample overrides energy-meter when merged later).
+
+    Use location_must_be_absent=True for plain L1/L2/L3/N currents without a ``location`` field.
+    """
+    merged = merge_layers(*layers)
+    val: float | None = None
+    for block in _iter_ocpp_blocks(merged):
+        sampled = block.get("sampledValue")
+        if not isinstance(sampled, list):
+            continue
+        for sv in sampled:
+            if not isinstance(sv, dict):
+                continue
+            if sv.get("measurand") != measurand:
+                continue
+            if phase is not None and sv.get("phase") != phase:
+                continue
+            if not _location_matches(sv, location, location_must_be_absent=location_must_be_absent):
+                continue
+            v = _as_float(sv.get("value"))
+            if v is not None:
+                val = v
+    return val
+
+
+def _iter_ocpp_blocks(merged: dict[str, Any]) -> list[dict[str, Any]]:
+    """Collect OCPP MeterValue blocks from a top-level array and/or a single sampledValue object."""
+    blocks: list[dict[str, Any]] = []
+    lst = merged.get("_list")
+    if isinstance(lst, list) and _list_is_ocpp_meter_values(lst):
+        blocks.extend(b for b in lst if isinstance(b, dict))
+    sv = merged.get("sampledValue")
+    if isinstance(sv, list) and sv and isinstance(sv[0], dict):
+        blocks.append({"sampledValue": sv, "timestamp": merged.get("timestamp")})
+    return blocks
+
+
+def _enrich_from_ocpp_meter_list(merged: dict[str, Any]) -> dict[str, Any]:
+    """Map OCPP MeterValue sampledValue entries to flat keys used by pick_first."""
+    blocks = _iter_ocpp_blocks(merged)
+    if not blocks:
+        return merged
+
+    updates: dict[str, Any] = {}
+    currents: dict[str, float] = {}
+
+    for block in blocks:
+        sampled = block.get("sampledValue")
+        if not isinstance(sampled, list):
+            continue
+        for sv in sampled:
+            if not isinstance(sv, dict):
+                continue
+            measurand = sv.get("measurand", "")
+            val_f = _as_float(sv.get("value"))
+            if val_f is None:
+                continue
+            if measurand == "Power.Active.Import":
+                updates["power"] = val_f
+                updates["activePower"] = val_f
+            elif measurand == "Energy.Active.Import.Register":
+                # Cumulative register in Wh (used by parse_energy_kwh)
+                updates["energy_wh"] = val_f
+                updates["energy"] = val_f
+                updates["totalEnergy"] = val_f
+            elif measurand == "Current.Import":
+                phase = sv.get("phase", "")
+                if phase in ("L1", "L2", "L3"):
+                    currents[phase] = val_f
+
+    if currents:
+        l123 = [currents[p] for p in ("L1", "L2", "L3") if p in currents]
+        if l123:
+            updates["current"] = max(l123)
+
+    out = dict(merged)
+    out.update(updates)
+    return out
+
+
+def _flatten_nested_leaves(d: Any) -> dict[str, Any]:
+    """Pull nested dict leaves into top-level keys so pick_first finds ``power`` inside ``meter: {power: …}``."""
+    flat: dict[str, Any] = {}
+    if not isinstance(d, dict):
+        return flat
+    for k, v in d.items():
+        if k.startswith("_"):
+            continue
+        if isinstance(v, dict):
+            flat.update(_flatten_nested_leaves(v))
+        elif isinstance(v, list):
+            for item in v:
+                if isinstance(item, dict):
+                    flat.update(_flatten_nested_leaves(item))
+        else:
+            flat[k] = v
+    return flat
+
+
+def merge_layers_for_parse(*layers: Mapping[str, Any]) -> dict[str, Any]:
+    """merge_layers, OCPP MeterValue extraction, then flatten nested dicts for key lookup."""
+    merged = merge_layers(*layers)
+    merged = _enrich_from_ocpp_meter_list(merged)
+    extra = _flatten_nested_leaves(merged)
+    out = dict(merged)
+    out.update(extra)
+    return out
+
+
+def pick_first(merged: Mapping[str, Any], keys: tuple[str, ...]) -> Any:
+    for key in keys:
+        if key in merged and merged[key] is not None:
+            return merged[key]
+    return None
+
+
+def parse_power_w(*layers: Mapping[str, Any]) -> float | None:
+    merged = merge_layers_for_parse(*layers)
+    raw = pick_first(
+        merged,
+        (
+            "power",
+            "activePower",
+            "ActivePower",
+            "active_power",
+            "powerW",
+            "power_w",
+            "totalPower",
+            "total_power",
+            "instantaneousPower",
+            "InstantaneousPower",
+            "chargePower",
+            "ChargePower",
+            "evsePower",
+            "EvsePower",
+            "measuredPower",
+            "MeasuredPower",
+            "P",
+            "p",
+            "W",
+            "w",
+            "value",
+            "Value",
+            "reading",
+            "Reading",
+        ),
+    )
+    val = _as_float(raw)
+    return val
+
+
+def parse_current_a(*layers: Mapping[str, Any]) -> float | None:
+    merged = merge_layers_for_parse(*layers)
+    raw = pick_first(
+        merged,
+        (
+            "current",
+            "Current",
+            "rmsCurrent",
+            "RmsCurrent",
+            "rms_current",
+            "currentL1",
+            "CurrentL1",
+            "current_l1",
+            "currentPhase1",
+            "I",
+            "i",
+            "measuredCurrent",
+            "MeasuredCurrent",
+            "phaseCurrent",
+            "L1",
+            "importCurrent",
+            "value",
+            "Value",
+            "reading",
+            "Reading",
+        ),
+    )
+    return _as_float(raw)
+
+
+def parse_energy_kwh(*layers: Mapping[str, Any]) -> float | None:
+    merged = merge_layers_for_parse(*layers)
+    if merged.get("energy_wh") is not None:
+        v = _as_float(merged["energy_wh"])
+        if v is not None:
+            return v / 1000.0
+    raw = pick_first(
+        merged,
+        (
+            "energy",
+            "Energy",
+            "sessionEnergy",
+            "SessionEnergy",
+            "session_energy",
+            "totalEnergy",
+            "TotalEnergy",
+            "total_energy",
+            "energyKwh",
+            "energy_kwh",
+            "meterEnergy",
+            "MeterEnergy",
+            "importedEnergy",
+            "ImportedEnergy",
+            "absoluteEnergy",
+            "AbsoluteEnergy",
+            "accumulatedEnergy",
+            "AccumulatedEnergy",
+            "total_import_energy",
+            "TotalImportEnergy",
+            "value",
+            "Value",
+            "reading",
+            "Reading",
+        ),
+    )
+    val = _as_float(raw)
+    if val is None:
+        return None
+    # Heuristic: large values are often Wh → kWh
+    if val > 10000:
+        return val / 1000.0
+    return val
+
+
+def parse_state_text(*layers: Mapping[str, Any]) -> str | None:
+    merged = merge_layers_for_parse(*layers)
+    raw = pick_first(
+        merged,
+        (
+            "state",
+            "State",
+            "chargingState",
+            "ChargingState",
+            "charging_state",
+            "status",
+            "Status",
+            "cpStatus",
+            "CpStatus",
+            "cp_status",
+            "chargerState",
+            "ChargerState",
+            "evseStatus",
+            "EvseStatus",
+            "operationalState",
+            "OperationalState",
+            "chargerStatus",
+            "ChargerStatus",
+        ),
+    )
+    if raw is not None:
+        if isinstance(raw, bool):
+            return "Charging" if raw else "Idle"
+        code = str(raw).strip()
+        return CHARGING_STATE_LABELS.get(code, code)
+    # OCPP meter payloads often omit a text state; infer from power/current
+    p = _as_float(merged.get("power"))
+    c = _as_float(merged.get("current"))
+    if p is not None and p > 1.0:
+        return "Charging"
+    if c is not None and c > 0.01:
+        return "Charging"
+    if p is not None or c is not None:
+        return "Idle"
+    return None
+
+
+def parse_cpu_temperature_c(temperatures: Mapping[str, Any]) -> float | None:
+    """CPU temperature from /status/temperatures (°C)."""
+    merged = merge_layers_for_parse(temperatures)
+    raw = pick_first(
+        merged,
+        (
+            "cpu",
+            "cpuTemperature",
+            "cpu_temperature",
+            "CPU",
+            "processor",
+            "ProcessorTemperature",
+        ),
+    )
+    return _as_float(raw)
+
+
+def parse_baseboard_temperature_c(temperatures: Mapping[str, Any]) -> float | None:
+    """Baseboard temperature from /status/temperatures (°C)."""
+    merged = merge_layers_for_parse(temperatures)
+    raw = pick_first(
+        merged,
+        (
+            "baseboard",
+            "baseboardTemperature",
+            "baseboard_temperature",
+            "BaseboardTemperature",
+            "board",
+            "Board",
+            "mb",
+            "MB",
+            "pcb",
+            "Pcb",
+            "PCB",
+            "motherboard",
+            "Motherboard",
+            "ambient",
+            "Ambient",
+            "base_board",
+            "BaseBoard",
+        ),
+    )
+    return _as_float(raw)

garo_entity_pro-0.1.0/src/garo_entity_pro.egg-info/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: garo-entity-pro
+Version: 0.1.0
+Summary: Async client for the Garo Entity Pro charger local HTTPS API (/status/...).
+License: MIT
+Keywords: garo,evcharger,ocpp,aiohttp,home-assistant
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Home Automation
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.9.0
+Requires-Dist: yarl>=1.9.0
+Provides-Extra: ha
+Requires-Dist: homeassistant>=2024.1.0; extra == "ha"
+Requires-Dist: voluptuous>=0.13; extra == "ha"
+Dynamic: license-file
+
+# garo-entity-pro
+
+Async Python client for the **Garo Entity Pro** wallbox local HTTPS API (`/status/energy-meter`, `/status/temperatures`, etc.).
+
+## Install
+
+```bash
+pip install garo-entity-pro
+```
+
+## Library usage
+
+```python
+from garo_entity_pro import GaroApiClient
+
+async def main():
+    async with GaroApiClient("https://192.168.1.10", "user", "pass", verify_ssl=False) as client:
+        data = await client.get_status()
+```
+
+Parsing helpers live under `garo_entity_pro.parsing` (OCPP-style meter payloads, state labels).
+
+## Home Assistant
+
+The custom integration in `custom_components/garo_entity_pro/` depends on this package (see `manifest.json`). Install the integration and ensure Home Assistant can install requirements, or run `pip install -e .` from this repository when developing.
+
+## Development
+
+```bash
+pip install -e ".[ha]"
+```
+
+Build a wheel:
+
+```bash
+pip install build && python -m build
+```

garo_entity_pro-0.1.0/src/garo_entity_pro.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+src/garo_entity_pro/__init__.py
+src/garo_entity_pro/client.py
+src/garo_entity_pro/exceptions.py
+src/garo_entity_pro/parsing.py
+src/garo_entity_pro/py.typed
+src/garo_entity_pro.egg-info/PKG-INFO
+src/garo_entity_pro.egg-info/SOURCES.txt
+src/garo_entity_pro.egg-info/dependency_links.txt
+src/garo_entity_pro.egg-info/requires.txt
+src/garo_entity_pro.egg-info/top_level.txt

garo_entity_pro-0.1.0/src/garo_entity_pro.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

garo_entity_pro-0.1.0/src/garo_entity_pro.egg-info/requires.txt

@@ -0,0 +1,6 @@
+aiohttp>=3.9.0
+yarl>=1.9.0
+
+[ha]
+homeassistant>=2024.1.0
+voluptuous>=0.13

garo_entity_pro-0.1.0/src/garo_entity_pro.egg-info/top_level.txt

@@ -0,0 +1 @@
+garo_entity_pro