Split up coordinators in solarlog (home-assistant#161169)

Co-authored-by: Joost Lekkerkerker <joostlek@outlook.com>

Author: dontinelli

homeassistant/components/solarlog/__init__.py

@@ -1,13 +1,24 @@
 """Solar-Log integration."""
 
 import logging
+from urllib.parse import ParseResult, urlparse
 
-from homeassistant.const import Platform
+from aiohttp import CookieJar
+from solarlog_cli.solarlog_connector import SolarLogConnector
+
+from homeassistant.const import CONF_HOST, CONF_TIMEOUT, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er
+from homeassistant.helpers.aiohttp_client import async_create_clientsession
 
 from .const import CONF_HAS_PWD
-from .coordinator import SolarlogConfigEntry, SolarLogCoordinator
+from .coordinator import (
+    SolarLogBasicDataCoordinator,
+    SolarlogConfigEntry,
+    SolarLogDeviceDataCoordinator,
+    SolarLogLongtimeDataCoordinator,
+)
+from .models import SolarlogIntegrationData
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -16,10 +27,57 @@
 
 async def async_setup_entry(hass: HomeAssistant, entry: SolarlogConfigEntry) -> bool:
     """Set up a config entry for solarlog."""
-    coordinator = SolarLogCoordinator(hass, entry)
-    await coordinator.async_config_entry_first_refresh()
-    entry.runtime_data = coordinator
+
+    host_entry = entry.data[CONF_HOST]
+    password = entry.data.get("password", "")
+
+    url = urlparse(host_entry, "http")
+    netloc = url.netloc or url.path
+    path = url.path if url.netloc else ""
+    url = ParseResult("http", netloc, path, *url[3:])
+
+    solarlog = SolarLogConnector(
+        url.geturl(),
+        tz=hass.config.time_zone,
+        password=password,
+        session=async_create_clientsession(
+            hass, cookie_jar=CookieJar(quote_cookie=False)
+        ),
+    )
+
+    basic_coordinator = SolarLogBasicDataCoordinator(hass, entry, solarlog)
+
+    solarLogData = SolarlogIntegrationData(
+        api=solarlog,
+        basic_data_coordinator=basic_coordinator,
+    )
+
+    await basic_coordinator.async_config_entry_first_refresh()
+
+    entry.runtime_data = solarLogData
+
+    if basic_coordinator.solarlog.extended_data:
+        timeout = entry.data.get(CONF_TIMEOUT, 0)
+        if timeout <= 150:
+            # Increase timeout for next try, skip setup of LongtimeDataCoordinator,
+            # if timeout was not the issue (assumed when timeout > 150)
+            timeout = timeout + 30
+            new = {**entry.data}
+            new[CONF_TIMEOUT] = timeout
+            hass.config_entries.async_update_entry(entry, data=new)
+
+            entry.runtime_data.longtime_data_coordinator = (
+                SolarLogLongtimeDataCoordinator(hass, entry, solarlog, timeout)
+            )
+            await entry.runtime_data.longtime_data_coordinator.async_config_entry_first_refresh()
+
+        entry.runtime_data.device_data_coordinator = SolarLogDeviceDataCoordinator(
+            hass, entry, solarlog
+        )
+        await entry.runtime_data.device_data_coordinator.async_config_entry_first_refresh()
+
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
     return True
 
 

homeassistant/components/solarlog/coordinator.py

@@ -5,39 +5,41 @@
 from collections.abc import Callable
 from datetime import timedelta
 import logging
-from urllib.parse import ParseResult, urlparse
 
-from aiohttp import CookieJar
 from solarlog_cli.solarlog_connector import SolarLogConnector
 from solarlog_cli.solarlog_exceptions import (
     SolarLogAuthenticationError,
     SolarLogConnectionError,
     SolarLogUpdateError,
 )
-from solarlog_cli.solarlog_models import SolarlogData
+from solarlog_cli.solarlog_models import EnergyData, InverterData, SolarlogData
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_HOST
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import device_registry as dr
-from homeassistant.helpers.aiohttp_client import async_create_clientsession
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 from homeassistant.util import slugify
 
 from .const import DOMAIN
+from .models import SolarlogIntegrationData
 
 _LOGGER = logging.getLogger(__name__)
 
-type SolarlogConfigEntry = ConfigEntry[SolarLogCoordinator]
+type SolarlogConfigEntry = ConfigEntry[SolarlogIntegrationData]
 
 
-class SolarLogCoordinator(DataUpdateCoordinator[SolarlogData]):
-    """Get and update the latest data."""
+class SolarLogBasicDataCoordinator(DataUpdateCoordinator[SolarlogData]):
+    """Get and update the basic solarlog data."""
 
     config_entry: SolarlogConfigEntry
 
-    def __init__(self, hass: HomeAssistant, config_entry: SolarlogConfigEntry) -> None:
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        config_entry: SolarlogConfigEntry,
+        api: SolarLogConnector,
+    ) -> None:
         """Initialize the data object."""
         super().__init__(
             hass,
@@ -47,27 +49,8 @@ def __init__(self, hass: HomeAssistant, config_entry: SolarlogConfigEntry) -> No
             update_interval=timedelta(seconds=60),
         )
 
-        self.new_device_callbacks: list[Callable[[int], None]] = []
-        self._devices_last_update: set[tuple[int, str]] = set()
-
-        host_entry = config_entry.data[CONF_HOST]
-        password = config_entry.data.get("password", "")
-
-        url = urlparse(host_entry, "http")
-        netloc = url.netloc or url.path
-        path = url.path if url.netloc else ""
-        url = ParseResult("http", netloc, path, *url[3:])
         self.unique_id = config_entry.entry_id
-        self.host = url.geturl()
-
-        self.solarlog = SolarLogConnector(
-            self.host,
-            tz=hass.config.time_zone,
-            password=password,
-            session=async_create_clientsession(
-                hass, cookie_jar=CookieJar(quote_cookie=False)
-            ),
-        )
+        self.solarlog = api
 
     async def _async_setup(self) -> None:
         """Do initialization logic."""
@@ -82,13 +65,10 @@ async def _async_setup(self) -> None:
 
     async def _async_update_data(self) -> SolarlogData:
         """Update the data from the SolarLog device."""
-        _LOGGER.debug("Start data update")
+        _LOGGER.debug("Start basic data update")
 
         try:
-            data = await self.solarlog.update_data()
-            if self.solarlog.extended_data:
-                await self.solarlog.update_device_list()
-                data.inverter_data = await self.solarlog.update_inverter_data()
+            data = await self.solarlog.update_basic_data()
         except SolarLogConnectionError as ex:
             raise ConfigEntryNotReady(
                 translation_domain=DOMAIN,
@@ -112,26 +92,94 @@ async def _async_update_data(self) -> SolarlogData:
                 translation_key="update_failed",
             ) from ex
 
-        _LOGGER.debug("Data successfully updated")
-
-        if self.solarlog.extended_data:
-            self._async_add_remove_devices(data)
-            _LOGGER.debug("Add_remove_devices finished")
+        _LOGGER.debug("Basic data successfully updated")
 
         return data
 
-    def _async_add_remove_devices(self, data: SolarlogData) -> None:
+    async def renew_authentication(self) -> bool:
+        """Renew access token for SolarLog API."""
+        logged_in = False
+        try:
+            logged_in = await self.solarlog.login()
+        except SolarLogAuthenticationError as ex:
+            raise ConfigEntryAuthFailed(
+                translation_domain=DOMAIN,
+                translation_key="auth_failed",
+            ) from ex
+        except (SolarLogConnectionError, SolarLogUpdateError) as ex:
+            raise ConfigEntryNotReady(
+                translation_domain=DOMAIN,
+                translation_key="config_entry_not_ready",
+            ) from ex
+
+        _LOGGER.debug("Credentials successfully updated? %s", logged_in)
+
+        return logged_in
+
+
+class SolarLogDeviceDataCoordinator(DataUpdateCoordinator[dict[int, InverterData]]):
+    """Get and update the device data of solarlog."""
+
+    config_entry: SolarlogConfigEntry
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        config_entry: SolarlogConfigEntry,
+        api: SolarLogConnector,
+    ) -> None:
+        """Initialize the data object."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            config_entry=config_entry,
+            name="SolarLogDevices",
+            update_interval=timedelta(seconds=60),
+        )
+
+        self.new_device_callbacks: list[Callable[[int], None]] = []
+        self._devices_last_update: set[tuple[int, str]] = set()
+        self.solarlog = api
+
+    async def _async_update_data(self) -> dict[int, InverterData]:
+        """Update the data from the SolarLog device."""
+        _LOGGER.debug("Start device data update")
+
+        try:
+            await self.solarlog.update_device_list()
+            inverter_data = await self.solarlog.update_inverter_data()
+        except SolarLogAuthenticationError as ex:
+            raise ConfigEntryAuthFailed(
+                translation_domain=DOMAIN,
+                translation_key="auth_failed",
+            ) from ex
+        except (SolarLogConnectionError, SolarLogUpdateError) as ex:
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="update_failed",
+            ) from ex
+
+        _LOGGER.debug("Device data successfully updated")
+
+        self.data = inverter_data
+
+        self._async_add_remove_devices(inverter_data)
+
+        return inverter_data
+
+    def _async_add_remove_devices(self, inverter_data: dict[int, InverterData]) -> None:
         """Add new devices, remove non-existing devices."""
+
         if (
             current_devices := {
-                (k, self.solarlog.device_name(k)) for k in data.inverter_data
+                (k, self.solarlog.device_name(k)) for k in inverter_data
             }
         ) == self._devices_last_update:
             return
 
         # remove old devices
         if removed_devices := self._devices_last_update - current_devices:
-            _LOGGER.debug("Removed device(s): %s", ", ".join(map(str, removed_devices)))
+            _LOGGER.info("Removed device(s): %s", ", ".join(map(str, removed_devices)))
             device_registry = dr.async_get(self.hass)
 
             for removed_device in removed_devices:
@@ -144,41 +192,76 @@ def _async_add_remove_devices(self, data: SolarlogData) -> None:
                     identifiers={
                         (
                             DOMAIN,
-                            f"{self.unique_id}_{slugify(device_name)}",
+                            f"{self.config_entry.entry_id}_{slugify(device_name)}",
                         )
                     }
                 ):
                     device_registry.async_update_device(
                         device_id=device.id,
-                        remove_config_entry_id=self.unique_id,
+                        remove_config_entry_id=self.config_entry.entry_id,
                     )
-                    _LOGGER.debug("Device removed from device registry: %s", device.id)
+                    _LOGGER.info("Device removed from device registry: %s", device.id)
 
         # add new devices
         if new_devices := current_devices - self._devices_last_update:
-            _LOGGER.debug("New device(s) found: %s", ", ".join(map(str, new_devices)))
+            _LOGGER.info("New device(s) found: %s", ", ".join(map(str, new_devices)))
             for device_id in new_devices:
                 for callback in self.new_device_callbacks:
                     callback(device_id[0])
 
         self._devices_last_update = current_devices
 
-    async def renew_authentication(self) -> bool:
-        """Renew access token for SolarLog API."""
-        logged_in = False
+
+class SolarLogLongtimeDataCoordinator(DataUpdateCoordinator[EnergyData]):
+    """Get and update the solarlog longtime energy data."""
+
+    config_entry: SolarlogConfigEntry
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        config_entry: SolarlogConfigEntry,
+        api: SolarLogConnector,
+        timeout: float,
+    ) -> None:
+        """Initialize the data object."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            config_entry=config_entry,
+            name="SolarLogLongtimeEnergy",
+            update_interval=timedelta(seconds=timeout * 2),
+        )
+
+        self.solarlog = api
+        self.connection_timeout = timeout
+
+    async def _async_update_data(self) -> EnergyData:
+        """Update the energy data from the SolarLog device."""
+        _LOGGER.debug(
+            "Start energy data update with timeout=%s", self.connection_timeout
+        )
+
         try:
-            logged_in = await self.solarlog.login()
+            energy_data: EnergyData | None = await self.solarlog.update_energy_data(
+                timeout=self.connection_timeout
+            )
         except SolarLogAuthenticationError as ex:
             raise ConfigEntryAuthFailed(
                 translation_domain=DOMAIN,
                 translation_key="auth_failed",
             ) from ex
         except (SolarLogConnectionError, SolarLogUpdateError) as ex:
-            raise ConfigEntryNotReady(
+            raise UpdateFailed(
                 translation_domain=DOMAIN,
-                translation_key="config_entry_not_ready",
+                translation_key="update_failed",
             ) from ex
 
-        _LOGGER.debug("Credentials successfully updated? %s", logged_in)
+        if energy_data is None:
+            energy_data = EnergyData(None, None)
 
-        return logged_in
+        self.config_entry.runtime_data.basic_data_coordinator.data.self_consumption_year = energy_data.self_consumption
+
+        _LOGGER.debug("Energy data successfully updated")
+
+        return energy_data

homeassistant/components/solarlog/diagnostics.py

@@ -19,7 +19,7 @@ async def async_get_config_entry_diagnostics(
     hass: HomeAssistant, config_entry: SolarlogConfigEntry
 ) -> dict[str, Any]:
     """Return diagnostics for a config entry."""
-    data = config_entry.runtime_data.data
+    data = config_entry.runtime_data.basic_data_coordinator.data
 
     return {
         "config_entry": async_redact_data(config_entry.as_dict(), TO_REDACT),