python-hilo 2026.3.1__tar.gz → 2026.3.2__tar.gz

{python_hilo-2026.3.1 → python_hilo-2026.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-hilo
-Version: 2026.3.1
+Version: 2026.3.2
 Summary: A Python3, async interface to the Hilo API
 License: MIT
 License-File: LICENSE
@@ -29,7 +29,7 @@ Requires-Dist: async-timeout (>=4.0.0)
 Requires-Dist: attrs (>=21.2.0)
 Requires-Dist: backoff (>=1.11.1)
 Requires-Dist: httpx-sse (>=0.4.0)
-Requires-Dist: httpx[http2] (>=0.20.0)
+Requires-Dist: httpx[http2] (>=0.27.0)
 Requires-Dist: python-dateutil (>=2.8.2)
 Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
 Requires-Dist: voluptuous (>=0.13.1)

{python_hilo-2026.3.1 → python_hilo-2026.3.2}/pyhilo/api.py

@@ -94,6 +94,9 @@ class API:
         self.ws_token: str = ""
         self.endpoint: str = ""
         self._urn: str | None = None
+        # Device cache from websocket DeviceListInitialValuesReceived
+        self._device_cache: list[dict[str, Any]] = []
+        self._device_cache_event: asyncio.Event = asyncio.Event()
 
     @classmethod
     async def async_create(
@@ -544,17 +547,86 @@ class API:
         req: list[dict[str, Any]] = await self.async_request("get", url)
         return (req[0]["id"], req[0]["locationHiloId"])
 
-    async def get_devices(self, location_id: int) -> list[dict[str, Any]]:
-        """Get list of all devices"""
-        url = self._get_url("Devices", location_id=location_id)
-        LOG.debug("Devices URL is %s", url)
-        devices: list[dict[str, Any]] = await self.async_request("get", url)
-        devices.append(await self.get_gateway(location_id))
-        # Now it's time to add devices coming from external sources like hass
-        # integration.
-        for callback in self._get_device_callbacks:
-            devices.append(callback())
-        return devices
+    def set_device_cache(self, devices: list[dict[str, Any]]) -> None:
+        """Store devices received from websocket DeviceListInitialValuesReceived.
+
+        This replaces the old REST API get_devices call. The websocket sends
+        device data with list-type attributes (supportedAttributesList, etc.)
+        which need to be converted to comma-separated strings to match the
+        format that HiloDevice.update() expects.
+        """
+        self._device_cache = [self._convert_ws_device(device) for device in devices]
+        LOG.debug(
+            "Device cache populated with %d devices from websocket",
+            len(self._device_cache),
+        )
+        self._device_cache_event.set()
+
+    @staticmethod
+    def _convert_ws_device(ws_device: dict[str, Any]) -> dict[str, Any]:
+        """Convert a websocket device dict to the format generate_device expects.
+
+        The REST API returned supportedAttributes/settableAttributes as
+        comma-separated strings. The websocket returns supportedAttributesList/
+        settableAttributesList/supportedParametersList as Python lists.
+        We convert to the old format so HiloDevice.update() works unchanged.
+        """
+        device = dict(ws_device)
+
+        # Convert list attributes to comma-separated strings
+        list_to_csv_mappings = {
+            "supportedAttributesList": "supportedAttributes",
+            "settableAttributesList": "settableAttributes",
+            "supportedParametersList": "supportedParameters",
+        }
+        for list_key, csv_key in list_to_csv_mappings.items():
+            if list_key in device:
+                items = device.pop(list_key)
+                if isinstance(items, list):
+                    device[csv_key] = ", ".join(str(i) for i in items)
+                else:
+                    device[csv_key] = str(items) if items else ""
+
+        return device
+
+    async def wait_for_device_cache(self, timeout: float = 30.0) -> None:
+        """Wait for the device cache to be populated from websocket.
+
+        :param timeout: Maximum time to wait in seconds
+        :raises TimeoutError: If the device cache is not populated in time
+        """
+        if self._device_cache_event.is_set():
+            return
+        LOG.debug("Waiting for device cache from websocket (timeout=%ss)", timeout)
+        try:
+            await asyncio.wait_for(self._device_cache_event.wait(), timeout=timeout)
+        except asyncio.TimeoutError:
+            LOG.error(
+                "Timed out waiting for device list from websocket after %ss",
+                timeout,
+            )
+            raise
+
+    def get_device_cache(self, location_id: int) -> list[dict[str, Any]]:
+        """Return cached devices from websocket.
+
+        :param location_id: Hilo location id (unused but kept for interface compat)
+        :return: List of device dicts ready for generate_device()
+        """
+        return list(self._device_cache)
+
+    def add_to_device_cache(self, devices: list[dict[str, Any]]) -> None:
+        """Append new devices to the existing cache (e.g. from DeviceAdded).
+
+        Converts websocket format and adds to the cache without replacing
+        existing entries. Skips devices already in cache (by id).
+        """
+        existing_ids = {d.get("id") for d in self._device_cache}
+        for device in devices:
+            converted = self._convert_ws_device(device)
+            if converted.get("id") not in existing_ids:
+                self._device_cache.append(converted)
+                LOG.debug("Added device %s to cache", converted.get("id"))
 
     async def _set_device_attribute(
         self,

{python_hilo-2026.3.1 → python_hilo-2026.3.2}/pyhilo/const.py

@@ -11,7 +11,7 @@ INSTANCE_ID: Final = str(uuid.uuid4())[24:]
 LOG: Final = logging.getLogger(__package__)
 DEFAULT_STATE_FILE: Final = "hilo_state.yaml"
 REQUEST_RETRY: Final = 9
-PYHILO_VERSION: Final = "2026.3.01"
+PYHILO_VERSION: Final = "2026.3.02"
 # TODO: Find a way to keep previous line in sync with pyproject.toml automatically
 
 CONTENT_TYPE_FORM: Final = "application/x-www-form-urlencoded"
@@ -201,6 +201,7 @@ HILO_DEVICE_TYPES: Final = {
     "Cee": "Switch",
     "Thermostat24V": "Climate",
     "Tracker": "Sensor",
+    "SinopeWaterHeater": "Switch",
 }
 
 HILO_UNIT_CONVERSION: Final = {

{python_hilo-2026.3.1 → python_hilo-2026.3.2}/pyhilo/devices.py

@@ -58,7 +58,13 @@ class Devices:
             device_identifier: Union[int, str] = reading.device_id
             if device_identifier == 0:
                 device_identifier = reading.hilo_id
-            if device := self.find_device(device_identifier):
+            device = self.find_device(device_identifier)
+            # If device_id was 0 and hilo_id lookup failed, this is likely
+            # a gateway reading that arrives before GatewayValuesReceived
+            # assigns the real ID. Fall back to the gateway device.
+            if device is None and reading.device_id == 0:
+                device = next((d for d in self.devices if d.type == "Gateway"), None)
+            if device:
                 device.update_readings(reading)
                 LOG.debug("%s Received %s", device, reading)
                 if device not in updated_devices:
@@ -93,27 +99,78 @@ class Devices:
         return dev
 
     async def update(self) -> None:
-        fresh_devices = await self._api.get_devices(self.location_id)
+        """Update device list from websocket cache + gateway from REST."""
+        # Get devices from websocket cache (already populated by DeviceListInitialValuesReceived)
+        cached_devices = self._api.get_device_cache(self.location_id)
         generated_devices = []
-        for raw_device in fresh_devices:
+        for raw_device in cached_devices:
             LOG.debug("Generating device %s", raw_device)
             dev = self.generate_device(raw_device)
             generated_devices.append(dev)
             if dev not in self.devices:
                 self.devices.append(dev)
+
+        # Append gateway from REST API (still available)
+        try:
+            gw = await self._api.get_gateway(self.location_id)
+            LOG.debug("Generating gateway device %s", gw)
+            gw_dev = self.generate_device(gw)
+            generated_devices.append(gw_dev)
+            if gw_dev not in self.devices:
+                self.devices.append(gw_dev)
+        except Exception as err:
+            LOG.error("Failed to get gateway: %s", err)
+
+        # Now add devices from external sources (e.g. unknown source tracker)
+        for callback in self._api._get_device_callbacks:
+            try:
+                cb_device = callback()
+                dev = self.generate_device(cb_device)
+                generated_devices.append(dev)
+                if dev not in self.devices:
+                    self.devices.append(dev)
+            except Exception as err:
+                LOG.error("Failed to generate callback device: %s", err)
+
         for device in self.devices:
             if device not in generated_devices:
                 LOG.debug("Device unpaired %s", device)
                 # Don't do anything with unpaired device for now.
-                # self.devices.remove(device)
 
     async def update_devicelist_from_signalr(
         self, values: list[dict[str, Any]]
     ) -> list[HiloDevice]:
-        # ic-dev21 not sure if this is dead code?
+        """Process device list received from SignalR websocket.
+
+        This is called when DeviceListInitialValuesReceived arrives.
+        It populates the API device cache and generates HiloDevice objects.
+        """
+        # Populate the API cache so future update() calls use this data
+        self._api.set_device_cache(values)
+
         new_devices = []
-        for raw_device in values:
-            LOG.debug("Generating device %s", raw_device)
+        for raw_device in self._api.get_device_cache(self.location_id):
+            LOG.debug("Generating device from SignalR %s", raw_device)
+            dev = self.generate_device(raw_device)
+            if dev not in self.devices:
+                self.devices.append(dev)
+                new_devices.append(dev)
+
+        return new_devices
+
+    async def add_device_from_signalr(
+        self, values: list[dict[str, Any]]
+    ) -> list[HiloDevice]:
+        """Process individual device additions from SignalR websocket.
+
+        This is called when DeviceAdded arrives. It appends to the existing
+        cache rather than replacing it.
+        """
+        self._api.add_to_device_cache(values)
+
+        new_devices = []
+        for raw_device in self._api.get_device_cache(self.location_id):
+            LOG.debug("Generating added device from SignalR %s", raw_device)
             dev = self.generate_device(raw_device)
             if dev not in self.devices:
                 self.devices.append(dev)
@@ -122,9 +179,16 @@ class Devices:
         return new_devices
 
     async def async_init(self) -> None:
-        """Initialize the Hilo "manager" class."""
-        LOG.info("Initialising after websocket is connected")
+        """Initialize the Hilo "manager" class.
+
+        Gets location IDs from REST API, then waits for the websocket
+        to deliver the device list via DeviceListInitialValuesReceived.
+        The gateway is appended from REST.
+        """
+        LOG.info("Initialising: getting location IDs")
         location_ids = await self._api.get_location_ids()
         self.location_id = location_ids[0]
         self.location_hilo_id = location_ids[1]
-        await self.update()
+        # Device list will be populated when DeviceListInitialValuesReceived
+        # arrives on the websocket. The hilo integration's async_init will
+        # call wait_for_device_cache() and then update() after subscribing.

{python_hilo-2026.3.1 → python_hilo-2026.3.2}/pyhilo/graphql.py

@@ -1,8 +1,10 @@
 import asyncio
 import hashlib
 import json
+import ssl
 from typing import Any, Callable, Dict, List, Optional
 
+import certifi
 import httpx
 from httpx_sse import aconnect_sse
 
@@ -24,6 +26,17 @@ class GraphQlHelper:
 
     async def async_init(self) -> None:
         """Initialize the Hilo "GraphQlHelper" class."""
+        loop = asyncio.get_running_loop()
+
+        def _create_ssl_context() -> ssl.SSLContext:
+            ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+            ctx.check_hostname = True
+            ctx.verify_mode = ssl.CERT_REQUIRED
+            ctx.load_verify_locations(certifi.where())
+            return ctx
+
+        self._ssl_context = await loop.run_in_executor(None, _create_ssl_context)
+
         await self.call_get_location_query(self._devices.location_hilo_id)
 
     QUERY_GET_LOCATION: str = """query getLocation($locationHiloId: String!) {
@@ -548,7 +561,7 @@ class GraphQlHelper:
             "variables": {"locationHiloId": location_hilo_id},
         }
 
-        async with httpx.AsyncClient(http2=True) as client:
+        async with httpx.AsyncClient(http2=True, verify=self._ssl_context) as client:
             try:
                 response = await client.post(url, json=payload, headers=headers)
                 response.raise_for_status()
@@ -634,7 +647,9 @@ class GraphQlHelper:
 
                 retry_with_full_query = False
 
-                async with httpx.AsyncClient(http2=True, timeout=None) as client:
+                async with httpx.AsyncClient(
+                    http2=True, timeout=None, verify=self._ssl_context
+                ) as client:
                     async with aconnect_sse(
                         client, "POST", url, json=payload, headers=headers
                     ) as event_source:

{python_hilo-2026.3.1 → python_hilo-2026.3.2}/pyproject.toml

@@ -40,7 +40,7 @@ exclude = ".venv/.*"
 
 [tool.poetry]
 name = "python-hilo"
-version = "2026.3.1"
+version = "2026.3.2"
 description = "A Python3, async interface to the Hilo API"
 readme = "README.md"
 authors = ["David Vallee Delisle <me@dvd.dev>"]
@@ -74,7 +74,7 @@ python-dateutil = ">=2.8.2"
 python = "^3.9.0"
 voluptuous = ">=0.13.1"
 pyyaml = "^6.0.2"
-httpx = {version = ">=0.20.0", extras = ["http2"]}
+httpx = {version = ">=0.27.0", extras = ["http2"]}
 httpx-sse = ">=0.4.0"
 
 [poetry.group.dev.dependencies]