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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-hilo
-Version: 2026.1.2
+Version: 2026.3.2
 Summary: A Python3, async interface to the Hilo API
 License: MIT
 License-File: LICENSE
@@ -28,11 +28,11 @@ Requires-Dist: aiosignal (>=1.2.0)
 Requires-Dist: async-timeout (>=4.0.0)
 Requires-Dist: attrs (>=21.2.0)
 Requires-Dist: backoff (>=1.11.1)
-Requires-Dist: gql (>=3.5.2,<5.0.0)
+Requires-Dist: httpx-sse (>=0.4.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)
-Requires-Dist: websockets (>=8.1,<16.0)
 Project-URL: Repository, https://github.com/dvd-dev/python-hilo
 Description-Content-Type: text/markdown
 

{python_hilo-2026.1.2 → python_hilo-2026.3.2}/pyhilo/__init__.py

@@ -1,4 +1,5 @@
 """Define the hilo package."""
+
 from pyhilo.api import API
 from pyhilo.const import UNMONITORED_DEVICES
 from pyhilo.device import HiloDevice

{python_hilo-2026.1.2 → 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(
@@ -193,9 +196,11 @@ class API:
                 for x in self.device_attributes
                 if x.hilo_attribute == attribute or x.attr == attribute
             ),
-            DeviceAttribute(attribute, HILO_READING_TYPES.get(value_type, "null"))
-            if value_type
-            else attribute,
+            (
+                DeviceAttribute(attribute, HILO_READING_TYPES.get(value_type, "null"))
+                if value_type
+                else attribute
+            ),
         )
 
     async def _get_fid_state(self) -> bool:
@@ -289,7 +294,7 @@ class API:
                 try:
                     data = await resp.json(content_type=None)
                 except json.decoder.JSONDecodeError:
-                    LOG.warning(f"JSON Decode error: {resp.__dict__}")
+                    LOG.warning("JSON Decode error: %s", resp.__dict__)
                     message = await resp.text()
                     data = {"error": message}
             else:
@@ -351,7 +356,7 @@ class API:
         err: ClientResponseError = err_info[1].with_traceback(err_info[2])  # type: ignore
 
         if err.status in (401, 403):
-            LOG.warning(f"Refreshing websocket token {err.request_info.url}")
+            LOG.warning("Refreshing websocket token %s", err.request_info.url)
             if (
                 "client/negotiate" in str(err.request_info.url)
                 and err.request_info.method == "POST"
@@ -359,7 +364,7 @@ class API:
                 LOG.info(
                     "401 detected on websocket, refreshing websocket token. Old url: {self.ws_url} Old Token: {self.ws_token}"
                 )
-                LOG.info(f"401 detected on {err.request_info.url}")
+                LOG.info("401 detected on %s", err.request_info.url)
                 async with self._backoff_refresh_lock_ws:
                     await self.refresh_ws_token()
                     await self.get_websocket_params()
@@ -478,7 +483,7 @@ class API:
                 json=body,
             )
         except ClientResponseError as err:
-            LOG.error(f"ClientResponseError: {err}")
+            LOG.error("ClientResponseError: %s", err)
             if err.status in (401, 403):
                 raise InvalidCredentialsError("Invalid credentials") from err
             raise RequestError(err) from err
@@ -516,14 +521,14 @@ class API:
                 data=parsed_body,
             )
         except ClientResponseError as err:
-            LOG.error(f"ClientResponseError: {err}")
+            LOG.error("ClientResponseError: %s", err)
             if err.status in (401, 403):
                 raise InvalidCredentialsError("Invalid credentials") from err
             raise RequestError(err) from err
         LOG.debug("Android client register: %s", resp)
         msg: str = resp.get("message", "")
         if msg.startswith("Error="):
-            LOG.error(f"Android registration error: {msg}")
+            LOG.error("Android registration error: %s", msg)
             raise RequestError
         token = msg.split("=")[-1]
         LOG.debug("Calling set_state android_register")
@@ -542,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.1.2 → python_hilo-2026.3.2}/pyhilo/const.py

@@ -1,7 +1,7 @@
 import logging
 import platform
-import uuid
 from typing import Final
+import uuid
 
 import aiohttp
 
@@ -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.1.02"
+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"
@@ -24,7 +24,9 @@ AUTH_AUTHORIZE: Final = f"https://{AUTH_HOSTNAME}{AUTH_ENDPOINT}authorize"
 AUTH_TOKEN: Final = f"https://{AUTH_HOSTNAME}{AUTH_ENDPOINT}token"
 AUTH_CHALLENGE_METHOD: Final = "S256"
 AUTH_CLIENT_ID: Final = "1ca9f585-4a55-4085-8e30-9746a65fa561"
-AUTH_SCOPE: Final = "openid https://HiloDirectoryB2C.onmicrosoft.com/hiloapis/user_impersonation offline_access"
+AUTH_SCOPE: Final = (
+    "openid https://HiloDirectoryB2C.onmicrosoft.com/hiloapis/user_impersonation offline_access"
+)
 SUBSCRIPTION_KEY: Final = "20eeaedcb86945afa3fe792cea89b8bf"
 
 # API constants
@@ -50,7 +52,9 @@ AUTOMATION_CHALLENGE_ENDPOINT: Final = "/ChallengeHub"
 
 
 # Request constants
-DEFAULT_USER_AGENT: Final = f"PyHilo/{PYHILO_VERSION}-{INSTANCE_ID} aiohttp/{aiohttp.__version__} Python/{platform.python_version()}"
+DEFAULT_USER_AGENT: Final = (
+    f"PyHilo/{PYHILO_VERSION}-{INSTANCE_ID} aiohttp/{aiohttp.__version__} Python/{platform.python_version()}"
+)
 
 
 # NOTE(dvd): Not sure how to get new ones so I'm using the ones from my emulator
@@ -197,6 +201,7 @@ HILO_DEVICE_TYPES: Final = {
     "Cee": "Switch",
     "Thermostat24V": "Climate",
     "Tracker": "Sensor",
+    "SinopeWaterHeater": "Switch",
 }
 
 HILO_UNIT_CONVERSION: Final = {

{python_hilo-2026.1.2 → python_hilo-2026.3.2}/pyhilo/device/__init__.py

@@ -51,7 +51,7 @@ class HiloDevice:
     def update(self, **kwargs: Dict[str, Union[str, int, Dict]]) -> None:
         # TODO(dvd): This has to be re-written, this is not dynamic at all.
         if self._api.log_traces:
-            LOG.debug(f"[TRACE] Adding device {kwargs}")
+            LOG.debug("[TRACE] Adding device %s", kwargs)
         for orig_att, val in kwargs.items():
             att = camel_to_snake(orig_att)
             if reading_att := HILO_READING_TYPES.get(orig_att):
@@ -70,7 +70,7 @@ class HiloDevice:
                 self.update_readings(DeviceReading(**reading))  # type: ignore
 
             if att not in HILO_DEVICE_ATTRIBUTES:
-                LOG.warning(f"Unknown device attribute {att}: {val}")
+                LOG.warning("Unknown device attribute %s: %s", att, val)
                 continue
             elif att in HILO_LIST_ATTRIBUTES:
                 # This is where we generated the supported_attributes and settable_attributes
@@ -108,7 +108,7 @@ class HiloDevice:
 
     async def set_attribute(self, attribute: str, value: Union[str, int, None]) -> None:
         if dev_attribute := cast(DeviceAttribute, self._api.dev_atts(attribute)):
-            LOG.debug(f"{self._tag} Setting {dev_attribute} to {value}")
+            LOG.debug("%s Setting %s to %s", self._tag, dev_attribute, value)
             await self._set_attribute(dev_attribute, value)
             return
         LOG.warning(
@@ -134,7 +134,7 @@ class HiloDevice:
                 )
             )
         else:
-            LOG.warning(f"{self._tag} Invalid attribute {attribute} for device")
+            LOG.warning("%s Invalid attribute %s for device", self._tag, attribute)
 
     def get_attribute(self, attribute: str) -> Union[DeviceReading, None]:
         if dev_attribute := cast(DeviceAttribute, self._api.dev_atts(attribute)):
@@ -245,7 +245,7 @@ class DeviceReading:
             else ""
         )
         if not self.device_attribute:
-            LOG.warning(f"Received invalid reading for {self.device_id}: {kwargs}")
+            LOG.warning("Received invalid reading for %s: %s", self.device_id, kwargs)
 
     def __repr__(self) -> str:
         return f"<Reading {self.device_attribute.attr} {self.value}{self.unit_of_measurement}>"

{python_hilo-2026.1.2 → python_hilo-2026.3.2}/pyhilo/device/climate.py

@@ -1,4 +1,5 @@
 """Climate object."""
+
 from __future__ import annotations
 
 from typing import Any, cast

{python_hilo-2026.1.2 → python_hilo-2026.3.2}/pyhilo/device/graphql_value_mapper.py

@@ -11,7 +11,7 @@ class GraphqlValueMapper:
 
     OnState = "on"
 
-    def map_query_values(self, values: Dict[str, Any]) -> list[Dict[str, Any]]:
+    def map_query_values(self, values: list[Dict[str, Any]]) -> list[Dict[str, Any]]:
         readings: list[Dict[str, Any]] = []
         for device in values:
             if device.get("deviceType") is not None:
@@ -20,7 +20,7 @@ class GraphqlValueMapper:
         return readings
 
     def map_device_subscription_values(
-        self, device: list[Dict[str, Any]]
+        self, device: Dict[str, Any]
     ) -> list[Dict[str, Any]]:
         readings: list[Dict[str, Any]] = []
         if device.get("deviceType") is not None:
@@ -32,7 +32,7 @@ class GraphqlValueMapper:
         self, values: Dict[str, Any]
     ) -> list[Dict[str, Any]]:
         readings: list[Dict[str, Any]] = []
-        for device in values:
+        for device in values.get("devices", []):
             if device.get("deviceType") is not None:
                 reading = self._map_devices_values(device)
                 readings.extend(reading)
@@ -425,7 +425,8 @@ class GraphqlValueMapper:
                     device["hiloId"], "Intensity", device["level"] / 100
                 )
             )
-        if device.get("lightType").lower() == "color":
+        light_type = device.get("lightType")
+        if light_type and light_type.lower() == "color":
             attributes.append(
                 self.build_attribute(device["hiloId"], "Hue", device.get("hue") or 0)
             )

{python_hilo-2026.1.2 → 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:
@@ -87,33 +93,84 @@ class Devices:
         try:
             device_type = HILO_DEVICE_TYPES[dev.type]
         except KeyError:
-            LOG.warning(f"Unknown device type {dev.type}, adding as Sensor")
+            LOG.warning("Unknown device type %s, adding as Sensor", dev.type)
             device_type = "Sensor"
         dev.__class__ = globals()[device_type]
         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.1.2 → python_hilo-2026.3.2}/pyhilo/event.py

@@ -27,7 +27,7 @@ class Event:
 
     def __init__(self, **event: dict[str, Any]):
         """Initialize."""
-        self._convert_phases(cast(dict[str, Any], event.get("phases", {})))
+        self._convert_phases(event.get("phases", {}))
         params: dict[str, Any] = event.get("parameters") or {}
         devices: list[dict[str, Any]] = params.get("devices", [])
         consumption: dict[str, Any] = event.get("consumption", {})
@@ -118,7 +118,7 @@ class Event:
             except TypeError:
                 setattr(self, phase, value)
             self.phases_list.append(phase)
-        for phase in self.__annotations__:
+        for phase in type(self).__annotations__:
             if phase not in self.phases_list:
                 # On t'aime Carl
                 setattr(self, phase, datetime(2099, 12, 31, tzinfo=timezone.utc))

{python_hilo-2026.1.2 → python_hilo-2026.3.2}/pyhilo/exceptions.py

@@ -1,4 +1,5 @@
 """Define package errors."""
+
 from __future__ import annotations
 
 

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

@@ -1,11 +1,12 @@
 import asyncio
-import logging
+import hashlib
+import json
 import ssl
-from typing import Any, Dict, List, Optional
+from typing import Any, Callable, Dict, List, Optional
 
-from gql import Client, gql
-from gql.transport.aiohttp import AIOHTTPTransport
-from gql.transport.websockets import WebsocketsTransport
+import certifi
+import httpx
+from httpx_sse import aconnect_sse
 
 from pyhilo import API
 from pyhilo.const import LOG, PLATFORM_HOST
@@ -25,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!) {
@@ -533,91 +545,164 @@ class GraphQlHelper:
     async def call_get_location_query(self, location_hilo_id: str) -> None:
         """This functions calls the digital-twin and requests location id"""
         access_token = await self._get_access_token()
-        transport = AIOHTTPTransport(
-            url=f"https://{PLATFORM_HOST}/api/digital-twin/v3/graphql",
-            headers={"Authorization": f"Bearer {access_token}"},
-        )
-        client = Client(transport=transport, fetch_schema_from_transport=True)
-        query = gql(self.QUERY_GET_LOCATION)
+        url = f"https://{PLATFORM_HOST}/api/digital-twin/v3/graphql"
+        headers = {"Authorization": f"Bearer {access_token}"}
 
-        async with client as session:
-            result = await session.execute(
-                query, variable_values={"locationHiloId": location_hilo_id}
-            )
-        self._handle_query_result(result)
+        query = self.QUERY_GET_LOCATION
+        query_hash = hashlib.sha256(query.encode("utf-8")).hexdigest()
+
+        payload = {
+            "extensions": {
+                "persistedQuery": {
+                    "version": 1,
+                    "sha256Hash": query_hash,
+                }
+            },
+            "variables": {"locationHiloId": location_hilo_id},
+        }
+
+        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()
+                response_json = response.json()
+            except Exception as e:
+                LOG.error("Error parsing response: %s", e)
+                return
+
+            if "errors" in response_json:
+                for error in response_json["errors"]:
+                    if error.get("message") == "PersistedQueryNotFound":
+                        payload["query"] = query
+                        try:
+                            response = await client.post(
+                                url, json=payload, headers=headers
+                            )
+                            response.raise_for_status()
+                            response_json = response.json()
+                        except Exception as e:
+                            LOG.error("Error parsing response on retry: %s", e)
+                            return
+                        break
+
+            if "errors" in response_json:
+                LOG.error("GraphQL errors: %s", response_json["errors"])
+                return
+
+            if "data" in response_json:
+                self._handle_query_result(response_json["data"])
 
     async def subscribe_to_device_updated(
-        self, location_hilo_id: str, callback: callable = None
+        self,
+        location_hilo_id: str,
+        callback: Optional[Callable[[str], None]] = None,
     ) -> None:
         LOG.debug("subscribe_to_device_updated called")
+        await self._listen_to_sse(
+            self.SUBSCRIPTION_DEVICE_UPDATED,
+            {"locationHiloId": location_hilo_id},
+            self._handle_device_subscription_result,
+            callback,
+            location_hilo_id,
+        )
+
+    async def subscribe_to_location_updated(
+        self,
+        location_hilo_id: str,
+        callback: Optional[Callable[[str], None]] = None,
+    ) -> None:
+        LOG.debug("subscribe_to_location_updated called")
+        await self._listen_to_sse(
+            self.SUBSCRIPTION_LOCATION_UPDATED,
+            {"locationHiloId": location_hilo_id},
+            self._handle_location_subscription_result,
+            callback,
+            location_hilo_id,
+        )
+
+    async def _listen_to_sse(
+        self,
+        query: str,
+        variables: Dict[str, Any],
+        handler: Callable[[Dict[str, Any]], str],
+        callback: Optional[Callable[[str], None]] = None,
+        location_hilo_id: Optional[str] = None,
+    ) -> None:
+        query_hash = hashlib.sha256(query.encode("utf-8")).hexdigest()
+        payload: Dict[str, Any] = {
+            "extensions": {
+                "persistedQuery": {
+                    "version": 1,
+                    "sha256Hash": query_hash,
+                }
+            },
+            "variables": variables,
+        }
 
-        # Setting log level to suppress keepalive messages on gql transport
-        logging.getLogger("gql.transport.websockets").setLevel(logging.WARNING)
-
-        #
-        loop = asyncio.get_event_loop()
-        ssl_context = await loop.run_in_executor(None, ssl.create_default_context)
-
-        while True:  # Loop to reconnect if the connection is lost
-            LOG.debug("subscribe_to_device_updated while true")
-            access_token = await self._get_access_token()
-            transport = WebsocketsTransport(
-                url=f"wss://{PLATFORM_HOST}/api/digital-twin/v3/graphql?access_token={access_token}",
-                ssl=ssl_context,
-            )
-            client = Client(transport=transport, fetch_schema_from_transport=True)
-            query = gql(self.SUBSCRIPTION_DEVICE_UPDATED)
+        while True:
             try:
-                async with client as session:
-                    async for result in session.subscribe(
-                        query, variable_values={"locationHiloId": location_hilo_id}
-                    ):
-                        LOG.debug(
-                            "subscribe_to_device_updated: Received subscription result %s",
-                            result,
-                        )
-                        device_hilo_id = self._handle_device_subscription_result(result)
-                        if callback:
-                            callback(device_hilo_id)
+                access_token = await self._get_access_token()
+                url = f"https://{PLATFORM_HOST}/api/digital-twin/v3/graphql"
+                headers = {"Authorization": f"Bearer {access_token}"}
+
+                retry_with_full_query = False
+
+                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:
+                        async for sse in event_source.aiter_sse():
+                            if not sse.data:
+                                continue
+                            try:
+                                data = json.loads(sse.data)
+                            except json.JSONDecodeError:
+                                continue
+
+                            if "errors" in data:
+                                if any(
+                                    e.get("message") == "PersistedQueryNotFound"
+                                    for e in data["errors"]
+                                ):
+                                    retry_with_full_query = True
+                                    break
+                                LOG.error(
+                                    "GraphQL Subscription Errors: %s", data["errors"]
+                                )
+                                continue
+
+                            if "data" in data:
+                                LOG.debug(
+                                    "Received subscription result %s", data["data"]
+                                )
+                                handler_result = handler(data["data"])
+                                if callback:
+                                    callback(handler_result)
+
+                if retry_with_full_query:
+                    payload["query"] = query
+                    continue
+
             except Exception as e:
                 LOG.debug(
-                    "subscribe_to_device_updated: Connection lost: %s. Reconnecting in 5 seconds...",
-                    e,
+                    "Subscription connection lost: %s. Reconnecting in 5 seconds...", e
                 )
                 await asyncio.sleep(5)
-                try:
-                    await self.call_get_location_query(location_hilo_id)
-                    LOG.debug(
-                        "subscribe_to_device_updated, call_get_location_query success"
-                    )
-
-                except Exception as e2:
-                    LOG.error(
-                        "subscribe_to_device_updated, exception while reconnecting, retrying: %s",
-                        e2,
-                    )
+                # Reset payload to APQ only on reconnect
+                if "query" in payload:
+                    del payload["query"]
 
-    async def subscribe_to_location_updated(
-        self, location_hilo_id: str, callback: callable = None
-    ) -> None:
-        access_token = await self._get_access_token()
-        transport = WebsocketsTransport(
-            url=f"wss://{PLATFORM_HOST}/api/digital-twin/v3/graphql?access_token={access_token}"
-        )
-        client = Client(transport=transport, fetch_schema_from_transport=True)
-        query = gql(self.SUBSCRIPTION_LOCATION_UPDATED)
-        try:
-            async with client as session:
-                async for result in session.subscribe(
-                    query, variable_values={"locationHiloId": location_hilo_id}
-                ):
-                    LOG.debug("Received subscription result %s", result)
-                    device_hilo_id = self._handle_location_subscription_result(result)
-                    callback(device_hilo_id)
-        except asyncio.CancelledError:
-            LOG.debug("Subscription cancelled.")
-            asyncio.sleep(1)
-            await self.subscribe_to_location_updated(location_hilo_id)
+                if location_hilo_id:
+                    try:
+                        await self.call_get_location_query(location_hilo_id)
+                        LOG.debug("call_get_location_query success after reconnect")
+                    except Exception as e2:
+                        LOG.error(
+                            "exception while RE-connecting, retrying: %s",
+                            e2,
+                        )
 
     async def _get_access_token(self) -> str:
         """Get the access token."""
@@ -625,22 +710,22 @@ class GraphQlHelper:
 
     def _handle_query_result(self, result: Dict[str, Any]) -> None:
         """This receives query results and maps them to the proper device."""
-        devices_values: list[any] = result["getLocation"]["devices"]
+        devices_values: List[Dict[str, Any]] = result["getLocation"]["devices"]
         attributes = self.mapper.map_query_values(devices_values)
         self._devices.parse_values_received(attributes)
 
     def _handle_device_subscription_result(self, result: Dict[str, Any]) -> str:
-        devices_values: list[any] = result["onAnyDeviceUpdated"]["device"]
-        attributes = self.mapper.map_device_subscription_values(devices_values)
+        device_value: Dict[str, Any] = result["onAnyDeviceUpdated"]["device"]
+        attributes = self.mapper.map_device_subscription_values(device_value)
         updated_device = self._devices.parse_values_received(attributes)
         # callback to update the device in the UI
         LOG.debug("Device updated: %s", updated_device)
-        return devices_values.get("hiloId")
+        return str(device_value.get("hiloId"))
 
     def _handle_location_subscription_result(self, result: Dict[str, Any]) -> str:
-        devices_values: list[any] = result["onAnyLocationUpdated"]["location"]
-        attributes = self.mapper.map_location_subscription_values(devices_values)
+        location_value: Dict[str, Any] = result["onAnyLocationUpdated"]["location"]
+        attributes = self.mapper.map_location_subscription_values(location_value)
         updated_device = self._devices.parse_values_received(attributes)
         # callback to update the device in the UI
         LOG.debug("Device updated: %s", updated_device)
-        return devices_values.get("hiloId")
+        return str(location_value.get("hiloId"))

{python_hilo-2026.1.2 → python_hilo-2026.3.2}/pyhilo/util/__init__.py

@@ -1,4 +1,5 @@
 """Define utility modules."""
+
 import asyncio
 from datetime import datetime, timedelta
 import re

{python_hilo-2026.1.2 → python_hilo-2026.3.2}/pyhilo/util/state.py

@@ -4,7 +4,9 @@ from __future__ import annotations
 
 import asyncio
 from datetime import datetime
+import os
 from os.path import isfile
+import tempfile
 from typing import Any, ForwardRef, TypedDict, TypeVar, get_type_hints
 
 import aiofiles
@@ -77,7 +79,7 @@ class StateDict(TypedDict, total=False):
 T = TypeVar("T", bound="StateDict")
 
 
-def _get_defaults(cls: type[T]) -> dict[str, Any]:
+def _get_defaults(cls: type[T]) -> T:
     """Generate a default dict based on typed dict
 
     This function recursively creates a nested dictionary structure that mirrors
@@ -117,34 +119,82 @@ def _get_defaults(cls: type[T]) -> dict[str, Any]:
     return new_dict  # type: ignore[return-value]
 
 
-async def get_state(state_yaml: str) -> StateDict:
+def _write_state(state_yaml: str, state: dict[str, Any] | StateDict) -> None:
+    "Write state atomically to a temp file, this prevents reading a file being written to"
+
+    dir_name = os.path.dirname(os.path.abspath(state_yaml))
+    content = yaml.dump(state)
+    with tempfile.NamedTemporaryFile(
+        mode="w", dir=dir_name, delete=False, suffix=".tmp"
+    ) as tmp:
+        tmp.write(content)
+        tmp_path = tmp.name
+    os.chmod(tmp_path, 0o644)
+    os.replace(tmp_path, state_yaml)
+
+
+async def get_state(state_yaml: str, _already_locked: bool = False) -> StateDict:
     """Read in state yaml.
 
     :param state_yaml: filename where to read the state
     :type state_yaml: ``str``
+    :param _already_locked: Whether the lock is already held by the caller (e.g. set_state).
+                            Prevents deadlock when corruption recovery needs to write defaults.
+    :type _already_locked: ``bool``
     :rtype: ``StateDict``
     """
     if not isfile(
         state_yaml
     ):  # noqa: PTH113 - isfile is fine and simpler in this case.
-        return _get_defaults(StateDict)  # type: ignore
-    async with aiofiles.open(state_yaml, mode="r") as yaml_file:
-        LOG.debug("Loading state from yaml")
-        content = await yaml_file.read()
-        state_yaml_payload: StateDict = yaml.safe_load(content)
-    return state_yaml_payload
+        return _get_defaults(StateDict)
+
+    try:
+        async with aiofiles.open(state_yaml, mode="r") as yaml_file:
+            LOG.debug("Loading state from yaml")
+            content = await yaml_file.read()
+
+        state_yaml_payload: StateDict | None = yaml.safe_load(content)
+
+        # Handle corrupted/empty YAML files
+        if state_yaml_payload is None or not isinstance(state_yaml_payload, dict):
+            LOG.warning(
+                "State file %s is corrupted or empty, reinitializing with defaults",
+                state_yaml,
+            )
+            defaults = _get_defaults(StateDict)
+            if _already_locked:
+                _write_state(state_yaml, defaults)
+            else:
+                async with lock:
+                    _write_state(state_yaml, defaults)
+            return defaults
+
+        return state_yaml_payload
+
+    except yaml.YAMLError as e:
+        LOG.error(
+            "Failed to parse state file %s: %s. Reinitializing with defaults.",
+            state_yaml,
+            e,
+        )
+        defaults = _get_defaults(StateDict)
+        if _already_locked:
+            _write_state(state_yaml, defaults)
+        else:
+            async with lock:
+                _write_state(state_yaml, defaults)
+        return defaults
 
 
 async def set_state(
     state_yaml: str,
     key: str,
-    state: TokenDict
-    | RegistrationDict
-    | FirebaseDict
-    | AndroidDeviceDict
-    | WebsocketDict,
+    state: (
+        TokenDict | RegistrationDict | FirebaseDict | AndroidDeviceDict | WebsocketDict
+    ),
 ) -> None:
     """Save state yaml.
+
     :param state_yaml: filename where to read the state
     :type state_yaml: ``str``
     :param key: Key name
@@ -154,14 +204,11 @@ async def set_state(
     :rtype: ``StateDict``
     """
     async with lock:  # note ic-dev21: on lock le fichier pour être sûr de finir la job
-        current_state = await get_state(state_yaml) or {}
+        current_state = await get_state(state_yaml, _already_locked=True) or {}
         merged_state: dict[str, Any] = {key: {**current_state.get(key, {}), **state}}  # type: ignore[dict-item]
         new_state: dict[str, Any] = {**current_state, **merged_state}
-        async with aiofiles.open(state_yaml, mode="w") as yaml_file:
-            LOG.debug("Saving state to yaml file")
-            # TODO: Use asyncio.get_running_loop() and run_in_executor to write
-            # to the file in a non blocking manner. Currently, the file writes
-            # are properly async but the yaml dump is done synchronously on the
-            # main event loop.
-            content = yaml.dump(new_state)
-            await yaml_file.write(content)
+        LOG.debug("Saving state to yaml file")
+        # TODO: Use asyncio.get_running_loop() and run_in_executor to write
+        # to the file in a non blocking manner. Currently, yaml.dump is
+        # synchronous on the main event loop.
+        _write_state(state_yaml, new_state)

{python_hilo-2026.1.2 → python_hilo-2026.3.2}/pyhilo/websocket.py

@@ -1,4 +1,5 @@
 """Define a connection to the Hilo websocket."""
+
 from __future__ import annotations
 
 import asyncio
@@ -172,7 +173,9 @@ class WebsocketClient:
         response = await self._client.receive(300)
 
         if response.type in (WSMsgType.CLOSE, WSMsgType.CLOSED, WSMsgType.CLOSING):
-            LOG.error(f"Websocket: Received event to close connection: {response.type}")
+            LOG.error(
+                "Websocket: Received event to close connection: %s", response.type
+            )
             raise ConnectionClosedError("Connection was closed.")
 
         if response.type == WSMsgType.ERROR:
@@ -182,7 +185,7 @@ class WebsocketClient:
             raise ConnectionFailedError
 
         if response.type != WSMsgType.TEXT:
-            LOG.error(f"Websocket: Received invalid message: {response}")
+            LOG.error("Websocket: Received invalid message: %s", response)
             raise InvalidMessageError(f"Received non-text message: {response.type}")
 
         messages: list[Dict[str, Any]] = []
@@ -195,7 +198,7 @@ class WebsocketClient:
         except ValueError as v_exc:
             raise InvalidMessageError("Received invalid JSON") from v_exc
         except json.decoder.JSONDecodeError as j_exc:
-            LOG.error(f"Received invalid JSON: {msg}")
+            LOG.error("Received invalid JSON: %s", msg)
             LOG.exception(j_exc)
             data = {}
 
@@ -306,14 +309,14 @@ class WebsocketClient:
                 **proxy_env,
             )
         except (ClientError, ServerDisconnectedError, WSServerHandshakeError) as err:
-            LOG.error(f"Unable to connect to WS server {err}")
+            LOG.error("Unable to connect to WS server %s", err)
             if hasattr(err, "status") and err.status in (401, 403, 404, 409):
                 raise InvalidCredentialsError("Invalid credentials") from err
         except Exception as err:
-            LOG.error(f"Unable to connect to WS server {err}")
+            LOG.error("Unable to connect to WS server %s", err)
             raise CannotConnectError(err) from err
 
-        LOG.info(f"Connected to websocket server {self._api.endpoint}")
+        LOG.info("Connected to websocket server %s", self._api.endpoint)
 
         # Quick pause to prevent race condition
         await asyncio.sleep(0.05)
@@ -352,11 +355,11 @@ class WebsocketClient:
             LOG.info("Websocket: Listen cancelled.")
             raise
         except ConnectionClosedError as err:
-            LOG.error(f"Websocket: Closed while listening: {err}")
+            LOG.error("Websocket: Closed while listening: %s", err)
             LOG.exception(err)
             pass
         except InvalidMessageError as err:
-            LOG.warning(f"Websocket: Received invalid json : {err}")
+            LOG.warning("Websocket: Received invalid json : %s", err)
             pass
         finally:
             LOG.info("Websocket: Listen completed; cleaning up")

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

@@ -40,7 +40,7 @@ exclude = ".venv/.*"
 
 [tool.poetry]
 name = "python-hilo"
-version = "2026.1.2"
+version = "2026.3.2"
 description = "A Python3, async interface to the Hilo API"
 readme = "README.md"
 authors = ["David Vallee Delisle <me@dvd.dev>"]
@@ -73,9 +73,9 @@ backoff = ">=1.11.1"
 python-dateutil = ">=2.8.2"
 python = "^3.9.0"
 voluptuous = ">=0.13.1"
-websockets = ">=8.1,<16.0"
-gql = ">=3.5.2,<5.0.0"
 pyyaml = "^6.0.2"
+httpx = {version = ">=0.27.0", extras = ["http2"]}
+httpx-sse = ">=0.4.0"
 
 [poetry.group.dev.dependencies]
 Sphinx = "^7.1.2"