Add ability to select/change the configured device in ViCare integration

.coveragerc

@@ -1499,6 +1499,7 @@ omit =
     homeassistant/components/vicare/entity.py
     homeassistant/components/vicare/number.py
     homeassistant/components/vicare/sensor.py
+    homeassistant/components/vicare/types.py
     homeassistant/components/vicare/utils.py
     homeassistant/components/vicare/water_heater.py
     homeassistant/components/vilfo/__init__.py

homeassistant/components/vicare/__init__.py

@@ -1,54 +1,64 @@
 """The ViCare integration."""
 from __future__ import annotations
 
-from collections.abc import Callable, Mapping
 from contextlib import suppress
-from dataclasses import dataclass
 import logging
 import os
-from typing import Any
 
-from PyViCare.PyViCare import PyViCare
-from PyViCare.PyViCareDevice import Device
+from PyViCare.PyViCareDeviceConfig import PyViCareDeviceConfig
 from PyViCare.PyViCareUtils import (
     PyViCareInvalidConfigurationError,
     PyViCareInvalidCredentialsError,
 )
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_CLIENT_ID, CONF_PASSWORD, CONF_USERNAME
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers.storage import STORAGE_DIR
 
 from .const import (
+    CONF_ACTIVE_DEVICE,
     CONF_HEATING_TYPE,
-    DEFAULT_SCAN_INTERVAL,
     DOMAIN,
     HEATING_TYPE_TO_CREATOR_METHOD,
     PLATFORMS,
     VICARE_API,
     VICARE_DEVICE_CONFIG,
     VICARE_DEVICE_CONFIG_LIST,
+    VICARE_TOKEN_FILENAME,
     HeatingType,
 )
+from .utils import get_device_config_list, get_serial
 
 _LOGGER = logging.getLogger(__name__)
-_TOKEN_FILENAME = "vicare_token.save"
 
 
-@dataclass(frozen=True)
-class ViCareRequiredKeysMixin:
-    """Mixin for required keys."""
+def _get_active_device_for_migration(hass: HomeAssistant, entry: ConfigEntry) -> str:
+    """Return the serial of the first element of the device config list (migration helper)."""
+    device_list = get_device_config_list(hass, entry.data)
+    # Currently we only support a single device
+    return get_serial(device_list[0])
 
-    value_getter: Callable[[Device], Any]
 
+async def async_migrate_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Migrate old entry."""
 
-@dataclass(frozen=True)
-class ViCareRequiredKeysMixinWithSet(ViCareRequiredKeysMixin):
-    """Mixin for required keys with setter."""
+    if entry.version == 1:
+        _LOGGER.debug("Migrating from version %s", entry.version)
+        serial = await hass.async_add_executor_job(
+            _get_active_device_for_migration, hass, entry
+        )
+        entry.version = 2
+        hass.config_entries.async_update_entry(
+            entry,
+            data={
+                **entry.data,
+                CONF_ACTIVE_DEVICE: serial,
+            },
+        )
+        _LOGGER.debug("Migration to version %s successful", entry.version)
 
-    value_setter: Callable[[Device], bool]
+    return True
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
@@ -68,31 +78,16 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     return True
 
 
-def vicare_login(hass: HomeAssistant, entry_data: Mapping[str, Any]) -> PyViCare:
-    """Login via PyVicare API."""
-    vicare_api = PyViCare()
-    vicare_api.setCacheDuration(DEFAULT_SCAN_INTERVAL)
-    vicare_api.initWithCredentials(
-        entry_data[CONF_USERNAME],
-        entry_data[CONF_PASSWORD],
-        entry_data[CONF_CLIENT_ID],
-        hass.config.path(STORAGE_DIR, _TOKEN_FILENAME),
-    )
-    return vicare_api
+async def async_update_entry(hass: HomeAssistant, entry: ConfigEntry) -> None:
+    """Update a given config entry."""
+    await hass.config_entries.async_reload(entry.entry_id)
 
 
 def setup_vicare_api(hass: HomeAssistant, entry: ConfigEntry) -> None:
     """Set up PyVicare API."""
-    vicare_api = vicare_login(hass, entry.data)
-
-    for device in vicare_api.devices:
-        _LOGGER.info(
-            "Found device: %s (online: %s)", device.getModel(), str(device.isOnline())
-        )
-
+    device_list = get_device_config_list(hass, entry.data)
     # Currently we only support a single device
-    device_list = vicare_api.devices
-    device = device_list[0]
+    device = get_configured_device(device_list, entry)
     hass.data[DOMAIN][entry.entry_id][VICARE_DEVICE_CONFIG_LIST] = device_list
     hass.data[DOMAIN][entry.entry_id][VICARE_DEVICE_CONFIG] = device
     hass.data[DOMAIN][entry.entry_id][VICARE_API] = getattr(
@@ -109,7 +104,22 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
     with suppress(FileNotFoundError):
         await hass.async_add_executor_job(
-            os.remove, hass.config.path(STORAGE_DIR, _TOKEN_FILENAME)
+            os.remove, hass.config.path(STORAGE_DIR, VICARE_TOKEN_FILENAME)
         )
 
     return unload_ok
+
+
+def get_configured_device(
+    devices: list[PyViCareDeviceConfig],
+    entry: ConfigEntry,
+) -> PyViCareDeviceConfig:
+    """Return the configured device."""
+    active_device: str = entry.options.get(
+        CONF_ACTIVE_DEVICE, entry.data.get(CONF_ACTIVE_DEVICE)
+    )
+
+    for device_config in devices:
+        if get_serial(device_config) == active_device:
+            return device_config
+    return None

homeassistant/components/vicare/binary_sensor.py

@@ -27,9 +27,9 @@
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
-from . import ViCareRequiredKeysMixin
 from .const import DOMAIN, VICARE_API, VICARE_DEVICE_CONFIG
 from .entity import ViCareEntity
+from .types import ViCareRequiredKeysMixin
 from .utils import get_burners, get_circuits, get_compressors, is_supported
 
 _LOGGER = logging.getLogger(__name__)

homeassistant/components/vicare/button.py

@@ -20,9 +20,9 @@
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
-from . import ViCareRequiredKeysMixinWithSet
 from .const import DOMAIN, VICARE_API, VICARE_DEVICE_CONFIG
 from .entity import ViCareEntity
+from .types import ViCareRequiredKeysMixinWithSet
 from .utils import is_supported
 
 _LOGGER = logging.getLogger(__name__)

homeassistant/components/vicare/config_flow.py

@@ -14,18 +14,26 @@
 from homeassistant import config_entries
 from homeassistant.components import dhcp
 from homeassistant.const import CONF_CLIENT_ID, CONF_PASSWORD, CONF_USERNAME
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.data_entry_flow import FlowResult
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.device_registry import format_mac
+from homeassistant.helpers.selector import (
+    SelectOptionDict,
+    SelectSelector,
+    SelectSelectorConfig,
+    SelectSelectorMode,
+)
 
-from . import vicare_login
 from .const import (
+    CONF_ACTIVE_DEVICE,
     CONF_HEATING_TYPE,
     DEFAULT_HEATING_TYPE,
     DOMAIN,
     VICARE_NAME,
     HeatingType,
 )
+from .utils import get_device_config_list, get_device_serial_model_list, vicare_login
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -46,11 +54,22 @@
 )
 
 
+def _get_device_list(
+    hass: HomeAssistant, entry_data: dict[str, Any]
+) -> list[tuple[str, str]]:
+    #     device_list = hass.data[DOMAIN][entry.entry_id].get(
+    #         VICARE_DEVICE_CONFIG_LIST, get_device_config_list(hass, entry.data)
+    #     )
+    device_list = get_device_config_list(hass, entry_data)
+    return get_device_serial_model_list(hass, device_list)
+
+
 class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
     """Handle a config flow for ViCare."""
 
-    VERSION = 1
+    VERSION = 2
     entry: config_entries.ConfigEntry | None
+    available_devices: list[tuple[str, str]] = []
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
@@ -60,23 +79,66 @@
             return self.async_abort(reason="single_instance_allowed")
 
         errors: dict[str, str] = {}
-
         if user_input is not None:
             try:
-                await self.hass.async_add_executor_job(
-                    vicare_login, self.hass, user_input
+                self.available_devices = await self.hass.async_add_executor_job(
+                    _get_device_list,
+                    self.hass,
+                    user_input,
                 )
             except (PyViCareInvalidConfigurationError, PyViCareInvalidCredentialsError):
                 errors["base"] = "invalid_auth"
             else:
-                return self.async_create_entry(title=VICARE_NAME, data=user_input)
-
+                if len(self.available_devices) > 1:
+                    return await self.async_step_select()
+                if len(self.available_devices) == 1:
+                    return self.async_create_entry(
+                        title=VICARE_NAME,
+                        data={
+                            **user_input,
+                            CONF_ACTIVE_DEVICE: self.available_devices[0][0],
+                        },
+                    )
+                errors["base"] = "no_devices"
         return self.async_show_form(
             step_id="user",
             data_schema=USER_SCHEMA,
             errors=errors,
         )
 
+    async def async_step_select(
+        self, user_input: dict[str, Any] | None = None
+    ) -> FlowResult:
+        """Select which device to show."""
+        errors: dict[str, str] = {}
+        if user_input is not None:
+            return self.async_create_entry(title="", data=user_input)
+
+        schema = (
+            vol.Schema(
+                {
+                    vol.Required(CONF_ACTIVE_DEVICE): SelectSelector(
+                        SelectSelectorConfig(
+                            options=[
+                                SelectOptionDict(
+                                    value=serial, label=f"{serial} ({model})"
+                                )
+                                for serial, model in self.available_devices
+                            ],
+                            multiple=False,
+                            mode=SelectSelectorMode.LIST,
+                        ),
+                    ),
+                }
+            ),
+        )
+
+        return self.async_show_form(
+            step_id="select",
+            data_schema=schema,
+            errors=errors,
+        )
+
     async def async_step_reauth(self, entry_data: Mapping[str, Any]) -> FlowResult:
         """Handle re-authentication with ViCare."""
         self.entry = self.hass.config_entries.async_get_entry(self.context["entry_id"])
@@ -127,3 +189,62 @@
             return self.async_abort(reason="single_instance_allowed")
 
         return await self.async_step_user()
+
+    @staticmethod
+    @callback
+    def async_get_options_flow(
+        config_entry: config_entries.ConfigEntry,
+    ) -> config_entries.OptionsFlow:
+        """Create the options flow."""
+        return OptionsFlowHandler(config_entry)
+
+
+class OptionsFlowHandler(config_entries.OptionsFlow):
+    """Options flow handler."""
+
+    available_devices: list[tuple[str, str]] = []
+
+    def __init__(self, config_entry: config_entries.ConfigEntry) -> None:
+        """Initialize options flow."""
+        self.entry = config_entry
+
+    async def async_step_init(
+        self, user_input: dict[str, Any] | None = None
+    ) -> FlowResult:
+        """Manage the options."""
+        errors: dict[str, str] = {}
+        if user_input is not None:
+            return self.async_create_entry(data=user_input)
+
+        try:
+            self.available_devices = await self.hass.async_add_executor_job(
+                _get_device_list,
+                self.hass,
+                self.entry.data,
+            )
+        except (PyViCareInvalidConfigurationError, PyViCareInvalidCredentialsError):
+            errors["base"] = "invalid_auth"
+
+        return self.async_show_form(
+            step_id="init",
+            data_schema=self.add_suggested_values_to_schema(
+                vol.Schema(
+                    {
+                        vol.Required(CONF_ACTIVE_DEVICE): SelectSelector(
+                            SelectSelectorConfig(
+                                options=[
+                                    SelectOptionDict(
+                                        value=serial, label=f"{serial} ({model})"
+                                    )
+                                    for serial, model in self.available_devices
+                                ],
+                                multiple=False,
+                                mode=SelectSelectorMode.LIST,
+                            ),
+                        ),
+                    }
+                ),
+                user_input or dict(self.entry.data),
+            ),
+            errors=errors,
+        )

homeassistant/components/vicare/const.py

@@ -18,9 +18,11 @@
 VICARE_DEVICE_CONFIG_LIST = "device_config_list"
 VICARE_API = "api"
 VICARE_NAME = "ViCare"
+VICARE_TOKEN_FILENAME = "vicare_token.save"
 
 CONF_CIRCUIT = "circuit"
 CONF_HEATING_TYPE = "heating_type"
+CONF_ACTIVE_DEVICE = "active_devices"
 
 DEFAULT_SCAN_INTERVAL = 60
 

homeassistant/components/vicare/number.py

@@ -29,9 +29,9 @@
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
-from . import ViCareRequiredKeysMixin
 from .const import DOMAIN, VICARE_API, VICARE_DEVICE_CONFIG
 from .entity import ViCareEntity
+from .types import ViCareRequiredKeysMixin
 from .utils import get_circuits, is_supported
 
 _LOGGER = logging.getLogger(__name__)

homeassistant/components/vicare/sensor.py

@@ -38,7 +38,6 @@
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
-from . import ViCareRequiredKeysMixin
 from .const import (
     DOMAIN,
     VICARE_API,
@@ -48,6 +47,7 @@
     VICARE_UNIT_TO_UNIT_OF_MEASUREMENT,
 )
 from .entity import ViCareEntity
+from .types import ViCareRequiredKeysMixin
 from .utils import get_burners, get_circuits, get_compressors, is_supported
 
 _LOGGER = logging.getLogger(__name__)