fixes

Author: docteurzoidberg

custom_components/invicta/api.py

@@ -4,6 +4,7 @@
 from enum import Enum
 import time
 import aiohttp
+from aiohttp import ClientOSError
 
 from custom_components.invicta.winet.model import WinetGetRegisterResult
 from custom_components.invicta.winet.winet import WinetAPILocal
@@ -265,6 +266,7 @@ class InvictaApiClient:
     failed_poll_attempts = 0
     is_sending = False
     is_polling_in_background = False
+    stove_ip = ""
 
     def __init__(self, session: aiohttp.ClientSession, host: str) -> None:
         """init"""
@@ -275,6 +277,7 @@ def __init__(self, session: aiohttp.ClientSession, host: str) -> None:
         self._should_poll_in_background = False
         self._bg_task: Task | None = None
 
+        self.stove_ip = host
         self.is_polling_in_background = False
         self.is_sending = False
         self.failed_poll_attempts = 0

custom_components/invicta/binary_sensors.py renamed to custom_components/invicta/binary_sensor.py

@@ -69,7 +69,7 @@ def device_info(self) -> DeviceInfo:
             manufacturer="Invicta",
             model="Fontica 8",
             name=self.read_api.data.name,
-            identifiers={("Invicta", f"{self.read_api.data.productmodel}]")},
+            identifiers={("Invicta", f"{self.read_api.data.model}]")},
             sw_version="1.0",
             configuration_url=f"http://{self._api.stove_ip}/",
         )

custom_components/invicta/coordinator.py

@@ -24,8 +24,6 @@ def __init__(
         self._attr_name = f"Stove {description.name}"
 
         # no serial number. generate unique id ?
-        self._attr_unique_id = (
-            f"{description.key}_{coordinator.read_api.data.productmodel}"
-        )
+        self._attr_unique_id = f"{description.key}_{coordinator.read_api.data.model}"
         # Configure the Device Info
         self._attr_device_info = self.coordinator.device_info

custom_components/invicta/entity.py

@@ -1,6 +1,7 @@
 """Winet-Control API"""
 from __future__ import annotations
-import logging as _log
+import logging
+
 from json import JSONDecodeError
 
 import aiohttp
@@ -17,6 +18,8 @@
     WinetRegisterCategory,
 )
 
+LOGGER = logging.getLogger(__package__)
+
 
 class WinetAPILocal:
     """Bottom level API. handle http communication with the local winet module"""
@@ -51,35 +54,35 @@ async def get_registers(
                 "Origin": f"http://{self._stove_ip}",
                 "Referer": f"http://{self._stove_ip}/management.html",
             }
-            _log.warning(f"Querying {url} with data={data}")
+            LOGGER.debug(f"Querying {url} with data={data}")
             try:
                 async with session.post(url, data=data, headers=headers) as response:
                     try:
                         if response.status != 200:
-                            _log.warning(f"Error accessing {url} - {response.status}")
+                            LOGGER.warning(f"Error accessing {url} - {response.status}")
                             raise ConnectionError(
                                 f"Communication error - Response status {response.status}"
                             )
                         try:
                             json_data = await response.json(content_type=None)
-                            _log.warning("Received: %s", json_data)
+                            LOGGER.debug("Received: %s", json_data)
 
                             if "result" in json_data:
                                 # handle an action's result
                                 if json_data["result"] is False:
-                                    _log.warning("Api result is False")
+                                    LOGGER.warning("Api result is False")
                             else:
                                 try:
                                     return WinetGetRegisterResult(**json_data)
                                 except Exception:
-                                    _log.warning("Error parsing poll data")
-                                    _log.warning(f"Received: {json_data}")
+                                    LOGGER.warning("Error parsing poll data")
+                                    LOGGER.debug(f"Received: {json_data}")
                             # TODO: what about model check exceptions ?
                         except JSONDecodeError:
-                            _log.warning("Error decoding JSON: [%s]", response.text)
+                            LOGGER.warning("Error decoding JSON: [%s]", response.text)
 
                     except ConnectionError as exc:
-                        _log.warning(f"Connection Error accessing {url}")
+                        LOGGER.warning(f"Connection Error accessing {url}")
                         raise ConnectionError(
                             "ConnectionError - host not found"
                         ) from exc
@@ -92,7 +95,7 @@ async def get_registers(
             ):
                 raise ConnectionError()
             except Exception as unknown_error:
-                _log.error("Unhandled Exception %s", type(unknown_error))
+                LOGGER.error("Unhandled Exception %s", type(unknown_error))
 
     async def set_register(
         self, registerid: WinetRegister, value: int, key="002", memory=1
@@ -118,27 +121,27 @@ async def set_register(
                 "Origin": f"http://{self._stove_ip}",
                 "Referer": f"http://{self._stove_ip}/management.html",
             }
-            _log.debug(f"Posting to {url}, data={data}")
+            LOGGER.debug(f"Posting to {url}, data={data}")
             try:
                 async with session.post(url, data=data, headers=headers) as response:
                     try:
                         # TODO: log others error responses codes
                         if response.status != 200:
                             # Valid address - but poll endpoint not found
-                            _log.warning(f"Error accessing {url} - {response.status}")
+                            LOGGER.warning(f"Error accessing {url} - {response.status}")
                             raise ConnectionError(
                                 f"Error accessing {url} - {response.status}"
                             )
                         try:
                             # returns {'result': False} if failed (or True if success)
                             json_data = await response.json(content_type=None)
                             if json_data["result"] is not True:
-                                _log.warning("Received: %s", json_data)
+                                LOGGER.debug("Received: %s", json_data)
 
                         except JSONDecodeError:
-                            _log.warning("Error decoding JSON: [%s]", response.text)
+                            LOGGER.warning("Error decoding JSON: [%s]", response.text)
                     except ConnectionError as exc:
-                        _log.warning(f"Connection Error accessing {url}")
+                        LOGGER.warning(f"Connection Error accessing {url}")
                         raise ConnectionError(
                             "ConnectionError - host not found"
                         ) from exc
@@ -152,4 +155,4 @@ async def set_register(
             ) as exc:
                 raise ConnectionError() from exc
             except Exception as unknown_error:
-                _log.error("Unhandled Exception %s", type(unknown_error))
+                LOGGER.error("Unhandled Exception %s", type(unknown_error))