Merge pull request #825 from dvd-dev/split_CH_Flex

Séparation Crédit Hivernal et Flex D avec leur messages websocket associés. Ajout fonction debug websocket.

Author: ic-dev21

custom_components/hilo/__init__.py

@@ -47,7 +47,7 @@
 )
 from pyhilo.graphql import GraphQlHelper
 from pyhilo.util import from_utc_timestamp, time_diff
-from pyhilo.websocket import WebsocketEvent
+from pyhilo.websocket import WebsocketEvent, websocket_event_from_payload
 
 from .config_flow import STEP_OPTION_SCHEMA, HiloFlowHandler
 from .const import (
@@ -180,6 +180,20 @@ async def async_setup_entry(  # noqa: C901
         hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
     )
 
+    async def handle_debug_event(event: Event):
+        """Handle an event."""
+        LOG.debug("HILO_DEBUG: Event received: %s", event)
+        log_traces = current_options.get(CONF_LOG_TRACES)
+        LOG.debug("HILO_DEBUG: log_traces is %s", log_traces)
+        websocket_event = websocket_event_from_payload(event.data)
+        LOG.debug("HILO_DEBUG: Websocket event parsed: %s", websocket_event)
+        await hilo.on_websocket_event(websocket_event)
+
+    log_traces = current_options.get(CONF_LOG_TRACES)
+    if log_traces:
+        LOG.debug("HILO_DEBUG: log_traces is %s", log_traces)
+        hass.bus.async_listen("hilo_debug", handle_debug_event)
+
     async def async_reload_entry(_: HomeAssistant, updated_entry: ConfigEntry) -> None:
         """Handle an options update.
         This method will get called in two scenarios:
@@ -317,36 +331,48 @@ def register_websocket_listener(self, listener):
     async def _handle_websocket_message(self, event):
         """Process websocket messages and notify listeners."""
 
+        # TODO: ic-dev21: This needs to be cleaned up and optimized
         LOG.debug("Received websocket message type: %s", event)
         target = event.target
         LOG.debug("handle_websocket_message_target %s", target)
         msg_data = event
         LOG.debug("handle_websocket_message_ msg_data %s", msg_data)
 
-        if target == "ChallengeListInitialValuesReceived":
+        if target in [
+            "ChallengeListInitialValuesReceived",
+            "EventListInitialValuesReceived",
+        ]:
             msg_type = "challenge_list_initial"
-        elif target == "ChallengeAdded":
+        elif target in ["ChallengeAdded", "EventAdded"]:
             msg_type = "challenge_added"
         elif target == "ChallengeDetailsUpdated":
             msg_type = "challenge_details_update"
         elif target == "ChallengeConsumptionUpdatedValuesReceived":
             msg_type = "challenge_details_update"
-        elif target == "ChallengeDetailsUpdatedValuesReceived":
+        elif target in [
+            "ChallengeDetailsUpdatedValuesReceived",
+            "EventCHDetailsUpdatedValuesReceived",
+            "EventFlexDetailsUpdatedValuesReceived",
+        ]:
             msg_type = "challenge_details_update"
-        elif target == "ChallengeDetailsInitialValuesReceived":
+        elif target in [
+            "ChallengeDetailsInitialValuesReceived",
+            "EventCHDetailsInitialValuesReceived",
+            "EventFlexDetailsInitialValuesReceived",
+        ]:
             msg_type = "challenge_details_update"
-        elif target == "ChallengeListUpdatedValuesReceived":
+        elif target in [
+            "ChallengeListUpdatedValuesReceived",
+            "EventListUpdatedValuesReceived",
+        ]:
             msg_type = "challenge_details_update"
-        elif target == "EventCHConsumptionUpdatedValuesReceived":
+        elif target in [
+            "EventCHConsumptionUpdatedValuesReceived",
+            "EventFlexConsumptionUpdatedValuesReceived",
+        ]:
             LOG.debug("%s message received", target)
             LOG.debug("%s data: %s", target, msg_data)
             return
-        elif target == "EventCHDetailsUpdatedValuesReceived":
-            msg_type = "challenge_details_update"
-        elif target == "EventFlexDetailsUpdatedValuesReceived":
-            msg_type = "challenge_details_update"
-        elif target == "EventListUpdatedValuesReceived":
-            msg_type = "challenge_details_update"
 
         # ic-dev21 Notify listeners
         for listener in self._websocket_listeners:
@@ -478,13 +504,11 @@ async def on_websocket_event(self, event: WebsocketEvent) -> None:
         elif event.target == "Heartbeat":
             self.validate_heartbeat(event)
 
-        elif "Challenge" in event.target:
+        elif "Challenge" in event.target or "Event" in event.target:
+            LOG.debug("HILO_DEBUG: Handling challenge/event websocket event: %s", event)
             await self._handle_challenge_events(event)
             await self._handle_websocket_message(event)
 
-        elif "Event" in event.target:
-            await self._handle_websocket_message(event)
-
         elif "Device" in event.target or event.target == "GatewayValuesReceived":
             await self._handle_device_events(event)
 
@@ -504,36 +528,72 @@ async def subscribe_to_challenge(self, inv_id: int, event_id: int = 0) -> None:
         """Sends the json payload to receive updates from the challenge."""
         LOG.debug("Subscribing to challenge : %s or %s", event_id, self.challenge_id)
         event_id = event_id or self.challenge_id
-
-        LOG.debug(
-            "Subscribing to challenge %s at location %s",
-            event_id,
-            self.devices.location_id,
-        )
+        LOG.debug("API URN is %s", self._api.urn)
+        # Get plan name to connect to the correct challenge hub list
+        tarif_config = self.hq_plan_name
+        LOG.debug("Event list needed is %s", tarif_config)
+
+        # TODO: This is a fallback but will eventually need to be removed, I expect it to create
+        # websocket disconnects once the split is complete.
+        LOG.warning("Not using plan name %s, falling back to default", tarif_config)
         await self._api.websocket_challenges.async_invoke(
             [{"locationId": self.devices.location_id, "eventId": event_id}],
             "SubscribeToChallenge",
             inv_id,
         )
 
+        # Subscribe to the correct challenge hub
+        if tarif_config == "rate d":
+            await self._api.websocket_challenges.async_invoke(
+                [{"locationHiloId": self._api.urn, "eventId": event_id}],
+                "SubscribeToEventCH",
+                inv_id,
+            )
+
+        elif tarif_config == "flex d":
+            await self._api.websocket_challenges.async_invoke(
+                [{"locationHiloId": self._api.urn, "eventId": event_id}],
+                "SubscribeToEventFlex",
+                inv_id,
+            )
+        else:
+            LOG.warning("Unknown plan name %s, falling back to default", tarif_config)
+            await self._api.websocket_challenges.async_invoke(
+                [{"locationId": self.devices.location_id, "eventId": event_id}],
+                "SubscribeToChallenge",
+                inv_id,
+            )
+
     @callback
     async def subscribe_to_challengelist(self, inv_id: int) -> None:
         """Sends the json payload to receive updates from the challenge list."""
+        # TODO : Rename challegenge functions to Event, fallback on challenge for now
         LOG.debug(
             "Subscribing to challenge list at location %s", self.devices.location_id
         )
+        LOG.debug("API URN is %s", self._api.urn)
+
         await self._api.websocket_challenges.async_invoke(
             [{"locationId": self.devices.location_id}],
             "SubscribeToChallengeList",
             inv_id,
         )
 
+        LOG.debug("Subscribing to event list at location %s", self.devices.location_id)
+        await self._api.websocket_challenges.async_invoke(
+            [{"locationHiloId": self._api.urn}],
+            "SubscribeToEventList",
+            inv_id,
+        )
+
     @callback
     async def request_challenge_consumption_update(
         self, inv_id: int, event_id: int = 0
     ) -> None:
         """Sends the json payload to receive energy consumption updates from the challenge."""
         event_id = event_id or self.challenge_id
+
+        # TODO: Remove fallback once split is complete
         LOG.debug(
             "Requesting challenge %s consumption update at location %s",
             event_id,
@@ -545,6 +605,41 @@ async def request_challenge_consumption_update(
             inv_id,
         )
 
+        # Get plan name to request the correct consumption update
+        tarif_config = self.hq_plan_name
+        LOG.debug("API URN is %s", self._api.urn)
+        if tarif_config == "rate d":
+            LOG.debug(
+                "Requesting event CH consumption update at location %s",
+                self.devices.location_id,
+            )
+            await self._api.websocket_challenges.async_invoke(
+                [{"locationHiloId": self._api.urn, "eventId": event_id}],
+                "RequestEventCHConsumptionUpdate",
+                inv_id,
+            )
+        elif tarif_config == "flex d":
+            LOG.debug(
+                "Requesting event Flex consumption update at location %s",
+                self.devices.location_id,
+            )
+            await self._api.websocket_challenges.async_invoke(
+                [{"locationHiloId": self._api.urn, "eventId": event_id}],
+                "RequestEventFlexConsumptionUpdate",
+                inv_id,
+            )
+        else:
+            LOG.debug(
+                "Requesting challenge %s consumption update at location %s",
+                event_id,
+                self.devices.location_id,
+            )
+            await self._api.websocket_challenges.async_invoke(
+                [{"locationId": self.devices.location_id, "eventId": event_id}],
+                "RequestChallengeConsumptionUpdate",
+                inv_id,
+            )
+
     @callback
     async def request_status_update(self) -> None:
         await self._api.websocket_devices.send_status()

custom_components/hilo/manifest.json

@@ -11,6 +11,6 @@
   "documentation": "https://github.com/dvd-dev/hilo",
   "iot_class": "cloud_push",
   "issue_tracker": "https://github.com/dvd-dev/hilo/issues",
-  "requirements": ["python-hilo>=2025.12.3"],
-  "version": "2025.12.4"
+  "requirements": ["python-hilo>=2025.12.5"],
+  "version": "2025.12.5"
 }

custom_components/hilo/sensor.py

@@ -92,11 +92,8 @@ def process_wifi(strength: int) -> str:
 
 
 def validate_tariff_list(tariff_config):
-    tariff_list = TARIFF_LIST
-    for tariff in TARIFF_LIST:
-        if not tariff_config.get(tariff, 0):
-            tariff_list.remove(tariff)
-    return tariff_list
+    """Validate the tariff list from the configuration."""
+    return TARIFF_LIST
 
 
 def generate_entities_from_device(device, hilo, scan_interval):
@@ -717,6 +714,17 @@ async def handle_challenge_details_update(self, challenge):
     async def _async_update(self):
         seasons = await self._hilo._api.get_seasons(self._hilo.devices.location_id)
         self._events_to_poll = dict()
+        seasons = sorted(seasons, key=lambda x: x["season"], reverse=True)
+
+        # Re-add the totalReward that was present in the legacy API
+        for season_data in seasons:
+            total = sum(
+                event["reward"]
+                for event in season_data["events"]
+                if not event.get("isPreseasonEvent")
+            )
+            season_data["totalReward"] = total
+
         if seasons:
             current_history = await self._load_history()
             new_history = []
@@ -950,6 +958,8 @@ async def handle_challenge_details_update(self, challenge):
             elif used_wH is not None and used_wH > 0:
                 current_event = self._events[event_id]
                 current_event.update_wh(used_wH)
+                if baselinewH > 0:
+                    current_event.update_allowed_wh(baselinewH)
             # For non consumption updates, we need an event id
             elif event_has_id:
                 current_event = self._events[event_id]
@@ -1005,7 +1015,7 @@ def icon(self):
     @property
     def should_poll(self):
         """No need to poll with websockets. Polling to update allowed_wh in pre_heat phrase and consumption in reduction phase"""
-        return self.state in ["reduction", "pre_heat"]
+        return self.state in ["recovery", "reduction", "pre_heat"]
 
     @property
     def extra_state_attributes(self):
@@ -1022,7 +1032,7 @@ async def _async_update(self):
             if event.should_check_for_allowed_wh():
                 LOG.debug("ASYNC UPDATE SUB: EVENT: %s", event_id)
                 await self._hilo.subscribe_to_challenge(1, event_id)
-                await self._hilo.request_challenge_details_update(1, event_id)
+                await self._hilo.request_challenge_consumption_update(1, event_id)
             elif self.state == "reduction":
                 LOG.debug("ASYNC UPDATE: EVENT: %s", event_id)
                 await self._hilo.request_challenge_consumption_update(1, event_id)