Merge pull request #134 from explosivo22/dev

Enhance Rinnai integration with reauthentication handling and configuration improvements

Author: explosivo22

.github/workflows/test-with-homeassistant.yaml

@@ -6,11 +6,12 @@
 from aiorinnai.errors import RequestError
 
 from homeassistant.config_entries import ConfigEntry
+from homeassistant.helpers import issue_registry as ir
 from homeassistant.const import CONF_EMAIL, CONF_PASSWORD
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady, ConfigEntryAuthFailed
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.components.water_heater import DOMAIN as WATER_HEATER_DOMAIN
+from homeassistant.components.water_heater.const import DOMAIN as WATER_HEATER_DOMAIN
 from homeassistant.helpers.device_registry import DeviceEntry
 
 from .const import (
@@ -40,6 +41,16 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         _LOGGER.debug("User info retrieved: %s", user_info)
     except Unauthenticated as err:
         _LOGGER.error("Authentication error: %s", err)
+        # Create actionable repair issue for user notification
+        ir.async_create_issue(
+            hass,
+            DOMAIN,
+            "reauth_required",
+            is_fixable=True,
+            is_persistent=True,
+            severity=ir.IssueSeverity.ERROR,
+            translation_key="reauth_required",
+        )
         raise ConfigEntryAuthFailed from err
     except RequestError as err:
         _LOGGER.error("Request error: %s", err)
@@ -50,8 +61,10 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         _LOGGER.error("No devices found in user info")
         raise ConfigEntryNotReady("No devices found")
 
+    # Convert MappingProxyType to dict for options
+    options = dict(entry.options) if not isinstance(entry.options, dict) else entry.options
     hass.data[DOMAIN][entry.entry_id]["devices"] = [
-        RinnaiDeviceDataUpdateCoordinator(hass, client, device["id"], entry.options)
+        RinnaiDeviceDataUpdateCoordinator(hass, client, device["id"], options)
         for device in devices
     ]
 

custom_components/rinnaicontrolr-ha/__init__.py

@@ -21,6 +21,7 @@
     CONF_REFRESH_TOKEN,
 )
 
+# The above class is a Python ConfigFlow class for a specific domain.
 class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Rinnai."""
     VERSION = 2
@@ -164,12 +165,11 @@ async def async_step_reauth(self, user_input=None):
     @callback
     def async_get_options_flow(config_entry):
         """Get the options flow for this handler."""
-        return OptionsFlow(config_entry)
+        return OptionsFlow()
+
 
 class OptionsFlow(config_entries.OptionsFlow):
-    def __init__(self, config_entry: config_entries.ConfigEntry):
-        """Initialize options flow."""
-        self.config_entry = config_entry
+    # No __init__ needed; base class handles config_entry
 
     async def async_step_init(self, user_input=None):
         if user_input is not None:

custom_components/rinnaicontrolr-ha/config_flow.py

@@ -41,35 +41,50 @@ def __init__(
         self._manufacturer: str = "Rinnai"
         self._device_information: Optional[Dict[str, Any]] = None
         self.options = options
-        self._listeners = []
         super().__init__(
             hass,
             LOGGER,
             name=f"{RINNAI_DOMAIN}-{device_id}",
             update_interval=timedelta(seconds=60),
         )
 
-    async def _async_update_data(self) -> None:
-        """Update data via library"""
+    async def _async_update_data(self) -> dict[str, Any]:
+        """Fetch data from device via API and return the fetched device information as a dict[str, Any]."""
         try:
             async with timeout(10):
-                await asyncio.gather(
-                    self._update_device()
-                )
+                device_info = await self.api_client.device.get_info(self._rinnai_device_id)
         except Unauthenticated as error:
             LOGGER.error("Authentication error: %s", error)
             raise ConfigEntryAuthFailed from error
         except RequestError as error:
             raise UpdateFailed(error) from error
 
+        # Optionally perform maintenance retrieval if enabled (outside try block)
+        if self.options.get(CONF_MAINT_INTERVAL_ENABLED, False):
+            try:
+                await self.async_do_maintenance_retrieval()
+            except Unauthenticated as error:
+                LOGGER.error("Authentication error during maintenance retrieval: %s", error)
+                raise ConfigEntryAuthFailed from error
+            except RequestError as error:
+                LOGGER.warning("Maintenance retrieval failed due to request error: %s", error)
+        else:
+            LOGGER.debug("Skipping Maintenance retrieval since disabled inside of configuration")
+
+        LOGGER.debug("Rinnai device data: %s", device_info)
+        self._device_information = device_info
+        return device_info
+
     @property
     def id(self) -> str:
         """Return Rinnai thing name"""
         return self._rinnai_device_id
 
     @property
-    def device_name(self) -> str:
+    def device_name(self) -> Optional[str]:
         """Return device name."""
+        if not self._device_information:
+            return None
         return self._device_information["data"]["getDevice"]["device_name"]
 
     @property
@@ -78,126 +93,171 @@ def manufacturer(self) -> str:
         return self._manufacturer
 
     @property
-    def model(self) -> str:
+    def model(self) -> Optional[str]:
         """Return model for device"""
+        if not self._device_information:
+            return None
         return self._device_information["data"]["getDevice"]["model"]
 
     @property
-    def firmware_version(self) -> str:
+    def firmware_version(self) -> Optional[str]:
         """Return the serial number for the device"""
+        if not self._device_information:
+            return None
         return self._device_information["data"]["getDevice"]["firmware"]
 
     @property
-    def thing_name(self) -> str:
+    def thing_name(self) -> Optional[str]:
         """Return model for device"""
+        if not self._device_information:
+            return None
         return self._device_information["data"]["getDevice"]["thing_name"]
 
     @property
-    def user_uuid(self) -> str:
+    def user_uuid(self) -> Optional[str]:
         """Return model for device"""
+        if not self._device_information:
+            return None
         return self._device_information["data"]["getDevice"]["user_uuid"]
 
     @property
-    def current_temperature(self) -> float:
+    def current_temperature(self) -> Optional[float]:
         """Return the current temperature in degrees F"""
+        if not self._device_information:
+            return None
         return float(self._device_information["data"]["getDevice"]["info"]["domestic_temperature"])
 
     @property
     def target_temperature(self) -> Optional[float]:
         """Return the current temperature in degrees F"""
+        if not self._device_information:
+            return None
         if self._device_information["data"]["getDevice"]["shadow"]["set_domestic_temperature"] is None:
             return None
         return float(self._device_information["data"]["getDevice"]["shadow"]["set_domestic_temperature"])
 
     @property
-    def serial_number(self) -> str:
+    def serial_number(self) -> Optional[str]:
         """Return the serial number for the device"""
+        if not self._device_information:
+            return None
         return self._device_information["data"]["getDevice"]["info"]["serial_id"]
 
     @property
-    def last_known_state(self) -> str:
+    def last_known_state(self) -> Optional[str]:
+        if not self._device_information:
+            return None
         return self._device_information["data"]["getDevice"]["activity"]["eventType"]
 
     @property
-    def is_heating(self) -> bool:
+    def is_heating(self) -> Optional[bool]:
+        if not self._device_information:
+            return None
         value = self._device_information["data"]["getDevice"]["info"]["domestic_combustion"]
         return _convert_to_bool(value)
 
     @property
-    def is_on(self) -> bool:
+    def is_on(self) -> Optional[bool]:
+        if not self._device_information:
+            return None
         value = self._device_information["data"]["getDevice"]["shadow"]["set_operation_enabled"]
         return _convert_to_bool(value)
 
     @property
-    def is_recirculating(self) -> bool:
+    def is_recirculating(self) -> Optional[bool]:
+        if not self._device_information:
+            return None
         value = self._device_information["data"]["getDevice"]["shadow"]["recirculation_enabled"]
         return _convert_to_bool(value)
 
     @property
     def vacation_mode_on(self) -> Optional[bool]:
+        if not self._device_information:
+            return None
         value = self._device_information["data"]["getDevice"]["shadow"]["schedule_holiday"]
         if value is None:
             return None
         return _convert_to_bool(value)
 
     @property
-    def outlet_temperature(self) -> float:
+    def outlet_temperature(self) -> Optional[float]:
+        if not self._device_information:
+            return None
         return float(self._device_information["data"]["getDevice"]["info"]["m02_outlet_temperature"])
 
     @property
-    def inlet_temperature(self) -> float:
+    def inlet_temperature(self) -> Optional[float]:
+        if not self._device_information:
+            return None
         return float(self._device_information["data"]["getDevice"]["info"]["m08_inlet_temperature"])
 
     @property
     def water_flow_rate(self) -> Optional[float]:
         """Return the current temperature in degrees F"""
+        if not self._device_information:
+            return None
         if self._device_information["data"]["getDevice"]["info"]["m01_water_flow_rate_raw"] is None:
             return None
         return float(self._device_information["data"]["getDevice"]["info"]["m01_water_flow_rate_raw"])
 
     @property
     def combustion_cycles(self) -> Optional[float]:
         """Return the current temperature in degrees F"""
+        if not self._device_information:
+            return None
         if self._device_information["data"]["getDevice"]["info"]["m04_combustion_cycles"] is None:
             return None
         return float(self._device_information["data"]["getDevice"]["info"]["m04_combustion_cycles"])
 
     @property
     def operation_hours(self) -> Optional[float]:
         """Return the operation hours."""
+        if not self._device_information:
+            return None
         if self._device_information["data"]["getDevice"]["info"]["operation_hours"] is None:
             return None
         return float(self._device_information["data"]["getDevice"]["info"]["operation_hours"])
 
     @property
     def pump_hours(self) -> Optional[float]:
         """Return the pump hours."""
+        if not self._device_information:
+            return None
         if self._device_information["data"]["getDevice"]["info"]["m19_pump_hours"] is None:
             return None
         return float(self._device_information["data"]["getDevice"]["info"]["m19_pump_hours"])
 
     @property
     def fan_current(self) -> Optional[float]:
         """Return the fan current."""
+        if not self._device_information:
+            return None
         if self._device_information["data"]["getDevice"]["info"]["m09_fan_current"] is None:
             return None
         return float(self._device_information["data"]["getDevice"]["info"]["m09_fan_current"])
 
     @property
     def fan_frequency(self) -> Optional[float]:
         """Return the fan frequency."""
+        if not self._device_information:
+            return None
         if self._device_information["data"]["getDevice"]["info"]["m05_fan_frequency"] is None:
             return None
         return float(self._device_information["data"]["getDevice"]["info"]["m05_fan_frequency"])
 
     @property
     def pump_cycles(self) -> Optional[float]:
         """Return the pump cycles."""
+        if not self._device_information:
+            return None
         if self._device_information["data"]["getDevice"]["info"]["m20_pump_cycles"] is None:
             return None
         return float(self._device_information["data"]["getDevice"]["info"]["m20_pump_cycles"])
 
     async def async_set_temperature(self, temperature: int) -> None:
+        if not self._device_information:
+            LOGGER.debug("Cannot set temperature: device information not yet loaded")
+            return
         try:
             await self.api_client.device.set_temperature(self._device_information["data"]["getDevice"], temperature)
         except Unauthenticated as error:
@@ -207,6 +267,9 @@ async def async_set_temperature(self, temperature: int) -> None:
             raise UpdateFailed(error) from error
 
     async def async_start_recirculation(self, duration: int) -> None:
+        if not self._device_information:
+            LOGGER.debug("Cannot start recirculation: device information not yet loaded")
+            return
         try:
             await self.api_client.device.start_recirculation(self._device_information["data"]["getDevice"], duration)
         except Unauthenticated as error:
@@ -216,6 +279,9 @@ async def async_start_recirculation(self, duration: int) -> None:
             raise UpdateFailed(error) from error
 
     async def async_stop_recirculation(self) -> None:
+        if not self._device_information:
+            LOGGER.debug("Cannot stop recirculation: device information not yet loaded")
+            return
         try:
             await self.api_client.device.stop_recirculation(self._device_information["data"]["getDevice"])
         except Unauthenticated as error:
@@ -225,6 +291,9 @@ async def async_stop_recirculation(self) -> None:
             raise UpdateFailed(error) from error
 
     async def async_enable_vacation_mode(self) -> None:
+        if not self._device_information:
+            LOGGER.debug("Cannot enable vacation mode: device information not yet loaded")
+            return
         try:
             await self.api_client.device.enable_vacation_mode(self._device_information["data"]["getDevice"])
         except Unauthenticated as error:
@@ -234,6 +303,9 @@ async def async_enable_vacation_mode(self) -> None:
             raise UpdateFailed(error) from error
 
     async def async_disable_vacation_mode(self) -> None:
+        if not self._device_information:
+            LOGGER.debug("Cannot disable vacation mode: device information not yet loaded")
+            return
         try:
             await self.api_client.device.disable_vacation_mode(self._device_information["data"]["getDevice"])
         except Unauthenticated as error:
@@ -243,6 +315,9 @@ async def async_disable_vacation_mode(self) -> None:
             raise UpdateFailed(error) from error
 
     async def async_turn_off(self) -> None:
+        if not self._device_information:
+            LOGGER.debug("Cannot turn off device: device information not yet loaded")
+            return
         try:
             await self.api_client.device.turn_off(self._device_information["data"]["getDevice"])
         except Unauthenticated as error:
@@ -252,6 +327,9 @@ async def async_turn_off(self) -> None:
             raise UpdateFailed(error) from error
 
     async def async_turn_on(self) -> None:
+        if not self._device_information:
+            LOGGER.debug("Cannot turn on device: device information not yet loaded")
+            return
         try:
             await self.api_client.device.turn_on(self._device_information["data"]["getDevice"])
         except Unauthenticated as error:
@@ -262,6 +340,9 @@ async def async_turn_on(self) -> None:
 
     @Throttle(MIN_TIME_BETWEEN_UPDATES)
     async def async_do_maintenance_retrieval(self) -> None:
+        if not self._device_information:
+            LOGGER.debug("Cannot perform maintenance retrieval: device information not yet loaded")
+            return
         try:
             await self.api_client.device.do_maintenance_retrieval(self._device_information["data"]["getDevice"])
             LOGGER.debug("Rinnai Maintenance Retrieval Started")
@@ -270,16 +351,3 @@ async def async_do_maintenance_retrieval(self) -> None:
             raise ConfigEntryAuthFailed from error
         except RequestError as error:
             raise UpdateFailed(error) from error
-
-    async def _update_device(self, *_) -> None:
-        """Update the device information from the API"""
-        self._device_information = await self.api_client.device.get_info(
-            self._rinnai_device_id
-        )
-
-        if self.options[CONF_MAINT_INTERVAL_ENABLED]:
-            await self.async_do_maintenance_retrieval()
-        else:
-            LOGGER.debug("Skipping Maintenance retrieval since disabled inside of configuration")
-        
-        LOGGER.debug("Rinnai device data: %s", self._device_information)