Update stookwijzer api to atlas leefomgeving and add extra sensors

homeassistant/components/stookwijzer/__init__.py

@@ -1,23 +1,68 @@
 """The Stookwijzer integration."""
 from __future__ import annotations
 
+import logging
+
 from stookwijzer import Stookwijzer
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_LATITUDE, CONF_LOCATION, CONF_LONGITUDE, Platform
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
 from .const import DOMAIN
+from .coordinator import StookwijzerCoordinator, StookwijzerData
+
+PLATFORMS = [Platform.BINARY_SENSOR, Platform.SENSOR]
+
+_LOGGER = logging.getLogger(__name__)
+
+
+async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> bool:
+    """Migrate old entry."""
+    _LOGGER.debug("Migrating from version %s", config_entry.version)
+
+    if config_entry.version == 1:
+        session = async_get_clientsession(hass)
+        x, y = await Stookwijzer.async_transform_coordinates(
+            session,
+            config_entry.data[CONF_LOCATION][CONF_LATITUDE],
+            config_entry.data[CONF_LOCATION][CONF_LONGITUDE],
+        )
+
+        if not x or not y:
+            _LOGGER.error(
+                "Migration to version %s not successful", config_entry.version
+            )
+            return False
 
-PLATFORMS = [Platform.SENSOR]
+        config_entry.version = 2
+        hass.config_entries.async_update_entry(
+            config_entry, data={CONF_LATITUDE: x, CONF_LONGITUDE: y}
+        )
+
+        _LOGGER.debug("Migration to version %s successful", config_entry.version)
+
+    return True
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up Stookwijzer from a config entry."""
     hass.data.setdefault(DOMAIN, {})[entry.entry_id] = Stookwijzer(
-        entry.data[CONF_LOCATION][CONF_LATITUDE],
-        entry.data[CONF_LOCATION][CONF_LONGITUDE],
+        async_get_clientsession(hass),
+        entry.data[CONF_LATITUDE],
+        entry.data[CONF_LONGITUDE],
     )
+    client = Stookwijzer(
+        async_get_clientsession(hass),
+        entry.data[CONF_LATITUDE],
+        entry.data[CONF_LONGITUDE],
+    )
+    coordinator = StookwijzerCoordinator(hass, client)
+    await coordinator.async_config_entry_first_refresh()
+
+    hass.data[DOMAIN][entry.entry_id] = StookwijzerData(coordinator=coordinator)
+
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
     return True
 

homeassistant/components/stookwijzer/binary_sensor.py

@@ -0,0 +1,88 @@
+"""Support for Stookwijzer Binary Sensors."""
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import cast
+
+from homeassistant.components.binary_sensor import (
+    BinarySensorDeviceClass,
+    BinarySensorEntity,
+    BinarySensorEntityDescription,
+)
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN
+from .coordinator import StookwijzerCoordinator, StookwijzerData
+from .entity import StookwijzerEntity
+
+
+@dataclass
+class StookwijzerSensorDescriptionMixin:
+    """Required values for Stookwijzer binary sensors."""
+
+    value_fn: Callable[[StookwijzerCoordinator], bool | None]
+    attr_fn: Callable[[StookwijzerCoordinator], list | None]
+
+
+@dataclass
+class StookwijzerBinarySensorDescription(
+    BinarySensorEntityDescription,
+    StookwijzerSensorDescriptionMixin,
+):
+    """Class describing Stookwijzer binary sensor entities."""
+
+
+STOOKWIJZER_BINARY_SENSORS = (
+    StookwijzerBinarySensorDescription(
+        key="stookalert",
+        device_class=BinarySensorDeviceClass.SAFETY,
+        value_fn=lambda StookwijzerCoordinator: cast(
+            bool | None, StookwijzerCoordinator.client.alert
+        ),
+        attr_fn=lambda StookwijzerCoordinator: cast(
+            list | None, StookwijzerCoordinator.client.forecast_alert
+        ),
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: ConfigEntry,
+    async_add_entities: AddEntitiesCallback,
+) -> None:
+    """Set up Stookwijzer binary sensor from a config entry."""
+    data: StookwijzerData = hass.data[DOMAIN][entry.entry_id]
+    coordinator = data.coordinator
+
+    assert coordinator is not None
+    async_add_entities(
+        StookwijzerBinarySensor(description, coordinator, entry)
+        for description in STOOKWIJZER_BINARY_SENSORS
+    )
+
+
+class StookwijzerBinarySensor(
+    StookwijzerEntity, CoordinatorEntity[StookwijzerCoordinator], BinarySensorEntity
+):
+    """Defines a Stookwijzer binary sensor."""
+
+    entity_description: StookwijzerBinarySensorDescription
+
+    def __init__(
+        self,
+        description: StookwijzerBinarySensorDescription,
+        coordinator: StookwijzerCoordinator,
+        entry: ConfigEntry,
+    ) -> None:
+        """Initialize the entity."""
+        super().__init__(description, coordinator, entry)
+
+    @property
+    def is_on(self) -> bool | None:
+        """Return the state of the device."""
+        return self.entity_description.value_fn(self._coordinator)

homeassistant/components/stookwijzer/config_flow.py

@@ -3,11 +3,13 @@
 
 from typing import Any
 
+from stookwijzer import Stookwijzer
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow
 from homeassistant.const import CONF_LATITUDE, CONF_LOCATION, CONF_LONGITUDE
 from homeassistant.data_entry_flow import FlowResult
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.selector import LocationSelector
 
 from .const import DOMAIN
@@ -16,19 +18,27 @@
 class StookwijzerFlowHandler(ConfigFlow, domain=DOMAIN):
     """Config flow for Stookwijzer."""
 
-    VERSION = 1
+    VERSION = 2
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
     ) -> FlowResult:
         """Handle a flow initialized by the user."""
 
         if user_input is not None:
-            return self.async_create_entry(
-                title="Stookwijzer",
-                data=user_input,
+            session = async_get_clientsession(self.hass)
+            x, y = await Stookwijzer.async_transform_coordinates(
+                session,
+                user_input[CONF_LOCATION][CONF_LATITUDE],
+                user_input[CONF_LOCATION][CONF_LONGITUDE],
             )
 
+            if x and y:
+                return self.async_create_entry(
+                    title="Stookwijzer",
+                    data={CONF_LATITUDE: x, CONF_LONGITUDE: y},
+                )
+
         return self.async_show_form(
             step_id="user",
             data_schema=vol.Schema(

homeassistant/components/stookwijzer/const.py

@@ -10,6 +10,6 @@
 class StookwijzerState(StrEnum):
     """Stookwijzer states for sensor entity."""
 
-    BLUE = "blauw"
-    ORANGE = "oranje"
-    RED = "rood"
+    CODE_YELLOW = "code_yellow"
+    CODE_ORANGE = "code_orange"
+    CODE_RED = "code_red"

homeassistant/components/stookwijzer/coordinator.py

@@ -0,0 +1,40 @@
+"""Class representing a Stookwijzer update coordinator."""
+from dataclasses import dataclass
+from datetime import timedelta
+import logging
+
+from stookwijzer import Stookwijzer
+
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+SCAN_INTERVAL = timedelta(minutes=60)
+
+
+class StookwijzerCoordinator(DataUpdateCoordinator[None]):
+    """Devialet update coordinator."""
+
+    def __init__(self, hass: HomeAssistant, client: Stookwijzer) -> None:
+        """Initialize the coordinator."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            name=DOMAIN,
+            update_interval=SCAN_INTERVAL,
+        )
+        self.client = client
+
+    async def _async_update_data(self) -> None:
+        """Fetch data from API endpoint."""
+        await self.client.async_update()
+
+
+@dataclass
+class StookwijzerData:
+    """Config Entry global data."""
+
+    coordinator: StookwijzerCoordinator | None

homeassistant/components/stookwijzer/diagnostics.py

@@ -24,8 +24,10 @@ async def async_get_config_entry_diagnostics(
     return {
         "state": client.state,
         "last_updated": last_updated,
-        "lqi": client.lqi,
-        "windspeed": client.windspeed,
-        "weather": client.weather,
-        "concentrations": client.concentrations,
+        "alert": client.alert,
+        "air_quality_index": client.lki,
+        "windspeed_bft": client.windspeed_bft,
+        "windspeed_ms": client.windspeed_ms,
+        "forecast_advice": client.forecast_advice,
+        "forecast_alert": client.forecast_alert,
     }

homeassistant/components/stookwijzer/entity.py

@@ -0,0 +1,59 @@
+"""The Stookwijzer integration entities."""
+from __future__ import annotations
+
+from typing import Any
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import callback
+from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
+from homeassistant.helpers.entity import Entity, EntityDescription
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN
+from .coordinator import StookwijzerCoordinator
+
+
+class StookwijzerEntity(CoordinatorEntity, Entity):
+    """Base class for Stookwijzer entities."""
+
+    _attr_attribution = "Data provided by atlasleefomgeving.nl"
+    _attr_should_poll = False
+
+    def __init__(
+        self,
+        description: EntityDescription,
+        coordinator: StookwijzerCoordinator,
+        entry: ConfigEntry,
+    ) -> None:
+        """Initialize a Stookwijzer device."""
+
+        self.entity_description = description
+        super().__init__(coordinator)
+
+        self._coordinator = coordinator
+        self._attr_unique_id = DOMAIN + description.key
+        self._attr_name = description.key.title()
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, entry.entry_id)},
+            name=description.key,
+            manufacturer="Atlas Leefomgeving",
+            entry_type=DeviceEntryType.SERVICE,
+            configuration_url="https://www.atlasleefomgeving.nl/stookwijzer",
+        )
+
+    @callback
+    def _handle_coordinator_update(self) -> None:
+        self.async_write_ha_state()
+
+    @property
+    def available(self) -> bool:
+        """Return if entity is available."""
+        return self._coordinator.client.advice is not None
+
+    @property
+    def extra_state_attributes(self) -> dict[str, Any] | None:
+        """Return the state attributes."""
+        if not self.entity_description.attr_fn:  # type: ignore[attr-defined]
+            return None
+
+        return {"forecast": self.entity_description.attr_fn(self._coordinator)}  # type: ignore[attr-defined]

homeassistant/components/stookwijzer/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/stookwijzer",
   "integration_type": "service",
   "iot_class": "cloud_polling",
-  "requirements": ["stookwijzer==1.3.0"]
+  "requirements": ["stookwijzer==1.4.9"]
 }