Add config flow for Rain Bird

homeassistant/components/rainbird/__init__.py

@@ -4,32 +4,27 @@
 import asyncio
 import logging
 
-from pyrainbird.async_client import (
-    AsyncRainbirdClient,
-    AsyncRainbirdController,
-    RainbirdApiException,
-)
+from pyrainbird.async_client import AsyncRainbirdClient, AsyncRainbirdController
 import voluptuous as vol
 
+from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry, ConfigEntryState
 from homeassistant.const import (
+    ATTR_DEVICE_ID,
     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 HomeAssistantError
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
+from homeassistant.helpers.service import async_extract_config_entry_ids
 from homeassistant.helpers.typing import ConfigType
 
-from .const import (
-    CONF_ZONES,
-    RAINBIRD_CONTROLLER,
-    SENSOR_TYPE_RAINDELAY,
-    SENSOR_TYPE_RAINSENSOR,
-)
+from .const import ATTR_DURATION, CONF_SERIAL_NUMBER, CONF_ZONES
 from .coordinator import RainbirdUpdateCoordinator
 
 PLATFORMS = [Platform.SWITCH, Platform.SENSOR, Platform.BINARY_SENSOR]
@@ -61,47 +56,104 @@
     extra=vol.ALLOW_EXTRA,
 )
 
+SERVICE_SET_RAIN_DELAY = "set_rain_delay"
+SERVICE_SCHEMA_RAIN_DELAY = vol.All(
+    vol.Schema(
+        {
+            **cv.TARGET_SERVICE_FIELDS,
+            vol.Required(ATTR_DURATION): cv.positive_float,
+        }
+    ),
+    cv.has_at_least_one_key(ATTR_DEVICE_ID),
+)
+
 
 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.4.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."""
 
-    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,
+    hass.data.setdefault(DOMAIN, {})
+
+    controller = AsyncRainbirdController(
+        AsyncRainbirdClient(
+            async_get_clientsession(hass),
+            entry.data[CONF_HOST],
+            entry.data[CONF_PASSWORD],
+        )
+    )
+    coordinator = RainbirdUpdateCoordinator(
+        hass,
+        name=entry.title,
+        controller=controller,
+        serial_number=entry.data[CONF_SERIAL_NUMBER],
+    )
+    await coordinator.async_config_entry_first_refresh()
+
+    hass.data[DOMAIN][entry.entry_id] = coordinator
+
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
+    async def set_rain_delay(call: ServiceCall) -> None:
+        """Service call to delay automatic irrigigation."""
+        duration = call.data[ATTR_DURATION]
+        entry_ids = await async_extract_config_entry_ids(hass, call)
+        if not entry_ids:
+            raise HomeAssistantError("Device id did not match any devices")
+        await asyncio.gather(
+            *(
+                hass.data[DOMAIN][entry_id].controller.set_rain_delay(duration)
+                for entry_id in entry_ids
             )
         )
+
+    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)
+
+    loaded_entries = [
+        entry
+        for entry in hass.config_entries.async_entries(DOMAIN)
+        if entry.state == ConfigEntryState.LOADED
+    ]
+    if len(loaded_entries) == 1:
+        hass.services.async_remove(DOMAIN, SERVICE_SET_RAIN_DELAY)
+
+    return unload_ok

homeassistant/components/rainbird/binary_sensor.py

@@ -2,71 +2,54 @@
 from __future__ import annotations
 
 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_platform import AddEntitiesCallback
-from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from .const import SENSOR_TYPE_RAINDELAY, SENSOR_TYPE_RAINSENSOR
+from .const import DOMAIN
 from .coordinator import RainbirdUpdateCoordinator
 
 _LOGGER = logging.getLogger(__name__)
 
 
-BINARY_SENSOR_TYPES: tuple[BinarySensorEntityDescription, ...] = (
-    BinarySensorEntityDescription(
-        key=SENSOR_TYPE_RAINSENSOR,
-        name="Rainsensor",
-        icon="mdi:water",
-    ),
-    BinarySensorEntityDescription(
-        key=SENSOR_TYPE_RAINDELAY,
-        name="Raindelay",
-        icon="mdi:water-off",
-    ),
+RAIN_SENSOR_ENTITY_DESCRIPTION = BinarySensorEntityDescription(
+    key="rainsensor",
+    name="Rainsensor",
+    icon="mdi:water",
 )
 
 
-async def async_setup_platform(
+async def async_setup_entry(
     hass: HomeAssistant,
-    config: ConfigType,
+    config_entry: ConfigEntry,
     async_add_entities: AddEntitiesCallback,
-    discovery_info: DiscoveryInfoType | None = None,
 ) -> None:
-    """Set up a Rain Bird sensor."""
-    if discovery_info is None:
-        return
+    """Set up entry for a Rain Bird binary_sensor."""
+    coordinator = hass.data[DOMAIN][config_entry.entry_id]
+    async_add_entities([RainBirdSensor(coordinator, RAIN_SENSOR_ENTITY_DESCRIPTION)])
 
-    async_add_entities(
-        [
-            RainBirdSensor(discovery_info[description.key], description)
-            for description in BINARY_SENSOR_TYPES
-        ],
-        True,
-    )
 
-
-class RainBirdSensor(
-    CoordinatorEntity[RainbirdUpdateCoordinator[Union[int, bool]]], BinarySensorEntity
-):
+class RainBirdSensor(CoordinatorEntity[RainbirdUpdateCoordinator], BinarySensorEntity):
     """A sensor implementation for Rain Bird device."""
 
     def __init__(
         self,
-        coordinator: RainbirdUpdateCoordinator[int | bool],
+        coordinator: RainbirdUpdateCoordinator,
         description: BinarySensorEntityDescription,
     ) -> None:
         """Initialize the Rain Bird sensor."""
         super().__init__(coordinator)
         self.entity_description = description
+        self._attr_unique_id = f"{coordinator.serial_number}-{description.key}"
+        self._attr_device_info = coordinator.device_info
 
     @property
     def is_on(self) -> bool | None:
         """Return True if entity is on."""
-        return None if self.coordinator.data is None else bool(self.coordinator.data)
+        return self.coordinator.data.rain