Add config flow for Rain Bird

homeassistant/components/rainbird/__init__.py

@@ -4,31 +4,40 @@
 import asyncio
 import logging
 
+import async_timeout
 from pyrainbird.async_client import (
     AsyncRainbirdClient,
     AsyncRainbirdController,
     RainbirdApiException,
 )
 import voluptuous as vol
 
+from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
 from homeassistant.const import (
     CONF_FRIENDLY_NAME,
     CONF_HOST,
     CONF_PASSWORD,
     CONF_TRIGGER_TIME,
     Platform,
 )
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers import discovery
+from homeassistant.core import HomeAssistant, ServiceCall
+from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers.entity import DeviceInfo
+from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
 from homeassistant.helpers.typing import ConfigType
 
 from .const import (
+    ATTR_DURATION,
     CONF_ZONES,
+    DEVICE_INFO,
+    MANUFACTURER,
     RAINBIRD_CONTROLLER,
     SENSOR_TYPE_RAINDELAY,
     SENSOR_TYPE_RAINSENSOR,
+    SERIAL_NUMBER,
+    TIMEOUT_SECONDS,
 )
 from .coordinator import RainbirdUpdateCoordinator
 
@@ -61,47 +70,101 @@
     extra=vol.ALLOW_EXTRA,
 )
 
+SERVICE_SET_RAIN_DELAY = "set_rain_delay"
+SERVICE_SCHEMA_RAIN_DELAY = vol.Schema(
+    {
+        vol.Required(ATTR_DURATION): cv.positive_float,
+    }
+)
+
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the Rain Bird component."""
-    return all(
-        await asyncio.gather(
-            *[
-                _setup_controller(hass, controller_config, config)
-                for controller_config in config[DOMAIN]
-            ]
+    if DOMAIN not in config:
+        return True
+
+    for controller_config in config[DOMAIN]:
+        hass.async_create_task(
+            hass.config_entries.flow.async_init(
+                DOMAIN,
+                context={"source": SOURCE_IMPORT},
+                data=controller_config,
+            )
         )
+
+    async_create_issue(
+        hass,
+        DOMAIN,
+        "deprecated_yaml",
+        breaks_in_ha_version="2023.3.0",
+        is_fixable=False,
+        severity=IssueSeverity.WARNING,
+        translation_key="deprecated_yaml",
     )
 
+    return True
 
-async def _setup_controller(hass, controller_config, config):
-    """Set up a controller."""
-    server = controller_config[CONF_HOST]
-    password = controller_config[CONF_PASSWORD]
-    client = AsyncRainbirdClient(async_get_clientsession(hass), server, password)
-    controller = AsyncRainbirdController(client)
-    try:
-        await controller.get_serial_number()
-    except RainbirdApiException as exc:
-        _LOGGER.error("Unable to setup controller: %s", exc)
-        return False
 
-    rain_coordinator = RainbirdUpdateCoordinator(hass, controller.get_rain_sensor_state)
-    delay_coordinator = RainbirdUpdateCoordinator(hass, controller.get_rain_delay)
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Set up the config entry for Rain Bird."""
+    hass.data.setdefault(DOMAIN, {})
 
-    for platform in PLATFORMS:
-        hass.async_create_task(
-            discovery.async_load_platform(
-                hass,
-                platform,
-                DOMAIN,
-                {
-                    RAINBIRD_CONTROLLER: controller,
-                    SENSOR_TYPE_RAINSENSOR: rain_coordinator,
-                    SENSOR_TYPE_RAINDELAY: delay_coordinator,
-                    **controller_config,
-                },
-                config,
-            )
+    controller = AsyncRainbirdController(
+        AsyncRainbirdClient(
+            async_get_clientsession(hass),
+            entry.data[CONF_HOST],
+            entry.data[CONF_PASSWORD],
         )
+    )
+
+    try:
+        async with async_timeout.timeout(TIMEOUT_SECONDS):
+            serial_number = await controller.get_serial_number()
+    except (RainbirdApiException, asyncio.TimeoutError) as err:
+        raise ConfigEntryNotReady(f"Error talking to controller: {str(err)}") from err
+
+    device_info = DeviceInfo(
+        default_name=MANUFACTURER,
+        identifiers={(DOMAIN, serial_number)},
+        manufacturer=MANUFACTURER,
+    )
+    rain_coordinator = RainbirdUpdateCoordinator(
+        hass, "Rain", controller.get_rain_sensor_state
+    )
+    delay_coordinator = RainbirdUpdateCoordinator(
+        hass, "Rain delay", controller.get_rain_delay
+    )
+
+    hass.data[DOMAIN][entry.entry_id] = {
+        SERIAL_NUMBER: serial_number,
+        DEVICE_INFO: device_info,
+        RAINBIRD_CONTROLLER: controller,
+        SENSOR_TYPE_RAINSENSOR: rain_coordinator,
+        SENSOR_TYPE_RAINDELAY: delay_coordinator,
+    }
+
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
+    async def set_rain_delay(service: ServiceCall) -> None:
+        await controller.set_rain_delay(service.data[ATTR_DURATION])
+
+    hass.services.async_register(
+        DOMAIN,
+        SERVICE_SET_RAIN_DELAY,
+        set_rain_delay,
+        schema=SERVICE_SCHEMA_RAIN_DELAY,
+    )
+
     return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Unload a config entry."""
+
+    if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
+        hass.data[DOMAIN].pop(entry.entry_id)
+
+    if unload_ok and not hass.data[DOMAIN]:
+        hass.services.async_remove(DOMAIN, SERVICE_SET_RAIN_DELAY)
+
+    return unload_ok

homeassistant/components/rainbird/binary_sensor.py

@@ -1,25 +1,35 @@
 """Support for Rain Bird Irrigation system LNK WiFi Module."""
 from __future__ import annotations
 
+import asyncio
 import logging
 from typing import Union
 
 from homeassistant.components.binary_sensor import (
     BinarySensorEntity,
     BinarySensorEntityDescription,
 )
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity import DeviceInfo
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
+from homeassistant.helpers.update_coordinator import CoordinatorEntity, DataUpdateCoordinator
 
-from .const import SENSOR_TYPE_RAINDELAY, SENSOR_TYPE_RAINSENSOR
+from .const import (
+    DEVICE_INFO,
+    DOMAIN,
+    SENSOR_TYPE_RAINDELAY,
+    SENSOR_TYPE_RAINSENSOR,
+    SERIAL_NUMBER,
+)
 from .coordinator import RainbirdUpdateCoordinator
 
+
 _LOGGER = logging.getLogger(__name__)
 
 
-BINARY_SENSOR_TYPES: tuple[BinarySensorEntityDescription, ...] = (
+SENSOR_TYPES: tuple[BinarySensorEntityDescription, ...] = (
     BinarySensorEntityDescription(
         key=SENSOR_TYPE_RAINSENSOR,
         name="Rainsensor",
@@ -33,22 +43,24 @@
 )
 
 
-async def async_setup_platform(
+async def async_setup_entry(
     hass: HomeAssistant,
-    config: ConfigType,
-    async_add_entities: AddEntitiesCallback,
-    discovery_info: DiscoveryInfoType | None = None,
+    config_entry: ConfigEntry,
+    async_add_devices: AddEntitiesCallback,
 ) -> None:
-    """Set up a Rain Bird sensor."""
-    if discovery_info is None:
-        return
-
-    async_add_entities(
-        [
-            RainBirdSensor(discovery_info[description.key], description)
-            for description in BINARY_SENSOR_TYPES
+    """Set up entry for a Rain Bird binary_sensor."""
+    data = hass.data[DOMAIN][config_entry.entry_id]
+    await asyncio.gather(
+        *[
+            data[description.key].async_config_entry_first_refresh()
+            for description in SENSOR_TYPES
         ],
-        True,
+    )
+    async_add_devices(
+        RainBirdSensor(
+            data[description.key], description, data[SERIAL_NUMBER], data[DEVICE_INFO]
+        )
+        for description in SENSOR_TYPES
     )
 
 
@@ -61,10 +73,14 @@ def __init__(
         self,
         coordinator: RainbirdUpdateCoordinator[int | bool],
         description: BinarySensorEntityDescription,
+        serial_number: str,
+        device_info: DeviceInfo,
     ) -> None:
         """Initialize the Rain Bird sensor."""
         super().__init__(coordinator)
         self.entity_description = description
+        self._attr_unique_id = f"{serial_number}-{description.key}"
+        self._attr_device_info = device_info
 
     @property
     def is_on(self) -> bool | None: