Merge branch 'dev' into radio-frequency-consumer-entity

Co-authored-by: piitaya <5878303+piitaya@users.noreply.github.com>
2026-06-08 02:59:41 +00:00 · 2026-05-21 13:35:41 +00:00 · 2026-05-17 16:27:32 -04:00 · 2026-05-17 16:23:55 -04:00
338 changed files with 1690 additions and 6872 deletions
@@ -96,7 +96,6 @@ homeassistant.components.aprs.*
 homeassistant.components.apsystems.*
 homeassistant.components.aqualogic.*
 homeassistant.components.aquostv.*
-homeassistant.components.aqvify.*
 homeassistant.components.aranet.*
 homeassistant.components.arcam_fmj.*
 homeassistant.components.arris_tg2492lg.*
@@ -162,8 +162,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/apsystems/ @mawoka-myblock @SonnenladenGmbH
 /homeassistant/components/aquacell/ @Jordi1990
 /tests/components/aquacell/ @Jordi1990
-/homeassistant/components/aqvify/ @astrandb
-/tests/components/aqvify/ @astrandb
 /homeassistant/components/aranet/ @aschmitz @thecode @anrijs
 /tests/components/aranet/ @aschmitz @thecode @anrijs
 /homeassistant/components/arcam_fmj/ @elupus
@@ -576,8 +574,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/flo/ @dmulcahey
 /homeassistant/components/flume/ @ChrisMandich @bdraco @jeeftor
 /tests/components/flume/ @ChrisMandich @bdraco @jeeftor
-/homeassistant/components/fluss/ @fluss @Marcello17
-/tests/components/fluss/ @fluss @Marcello17
+/homeassistant/components/fluss/ @fluss
+/tests/components/fluss/ @fluss
 /homeassistant/components/flux_led/ @icemanch
 /tests/components/flux_led/ @icemanch
 /homeassistant/components/forecast_solar/ @klaasnicolaas @frenck
@@ -116,6 +116,10 @@ async def async_setup_entry(hass: HomeAssistant, entry: AirOSConfigEntry) -> boo
 async def async_migrate_entry(hass: HomeAssistant, entry: AirOSConfigEntry) -> bool:
    """Migrate old config entry."""

+    # This means the user has downgraded from a future version
+    if entry.version > 2:
+        return False
+
    # 1.1 Migrate config_entry to add advanced ssl settings
    if entry.version == 1 and entry.minor_version == 1:
        new_minor_version = 2
@@ -65,6 +65,10 @@ async def async_setup_entry(hass: HomeAssistant, entry: AmazonConfigEntry) -> bo
 async def async_migrate_entry(hass: HomeAssistant, entry: AmazonConfigEntry) -> bool:
    """Migrate old entry."""

+    if entry.version > 1:
+        # This means the user has downgraded from a future version
+        return False
+
    if entry.version == 1 and entry.minor_version < 3:
        if CONF_SITE in entry.data:
            # Site in data (wrong place), just move to login data
@@ -75,6 +75,10 @@ async def async_migrate_entry(hass: HomeAssistant, entry: AnovaConfigEntry) -> b
    """Migrate entry."""
    _LOGGER.debug("Migrating from version %s:%s", entry.version, entry.minor_version)

+    if entry.version > 1:
+        # This means the user has downgraded from a future version
+        return False
+
    if entry.version == 1 and entry.minor_version == 1:
        new_data = {**entry.data}
        if CONF_DEVICES in new_data:
@@ -178,6 +178,10 @@ async def async_migrate_entry(hass: HomeAssistant, entry: AnthropicConfigEntry)
    """Migrate entry."""
    LOGGER.debug("Migrating from version %s:%s", entry.version, entry.minor_version)

+    if entry.version > 2:
+        # This means the user has downgraded from a future version
+        return False
+
    if entry.version == 2 and entry.minor_version == 1:
        # Correct broken device migration in Home Assistant Core 2025.7.0b0-2025.7.0b1
        device_registry = dr.async_get(hass)
@@ -1,28 +0,0 @@
-"""The Aqvify integration."""
-
-import logging
-
-from homeassistant.const import Platform
-from homeassistant.core import HomeAssistant
-
-from .coordinator import AqvifyConfigEntry, AqvifyCoordinator
-
-_LOGGER = logging.getLogger(__name__)
-PLATFORMS: list[Platform] = [Platform.SENSOR]
-
-
-async def async_setup_entry(hass: HomeAssistant, entry: AqvifyConfigEntry) -> bool:
-    """Set up Aqvify from a config entry."""
-
-    coordinator = AqvifyCoordinator(hass, entry)
-    await coordinator.async_config_entry_first_refresh()
-    entry.runtime_data = coordinator
-
-    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
-
-    return True
-
-
-async def async_unload_entry(hass: HomeAssistant, entry: AqvifyConfigEntry) -> bool:
-    """Unload Aqvify config entry."""
-    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
@@ -1,61 +0,0 @@
-"""Config flow for the Aqvify integration."""
-
-import logging
-from typing import Any
-
-from aiohttp import ClientResponseError
-from pyaqvify import AqvifyAPI, AqvifyAuthException
-import voluptuous as vol
-
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_API_KEY
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-
-from .const import DOMAIN
-
-_LOGGER = logging.getLogger(__name__)
-
-STEP_USER_DATA_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_API_KEY): str,
-    }
-)
-
-
-class AqvifyConfigFlow(ConfigFlow, domain=DOMAIN):
-    """Handle a config flow for Aqvify."""
-
-    VERSION = 1
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the initial step."""
-        errors: dict[str, str] = {}
-        if user_input is not None:
-            hub = AqvifyAPI(
-                user_input[CONF_API_KEY],
-                websession=async_get_clientsession(self.hass),
-            )
-            try:
-                account_data = await hub.async_get_account_id()
-            except AqvifyAuthException:
-                errors["base"] = "invalid_auth"
-            except ClientResponseError:
-                errors["base"] = "cannot_connect"
-            except Exception:
-                _LOGGER.exception("Unexpected exception")
-                errors["base"] = "unknown"
-            else:
-                await self.async_set_unique_id(account_data.account_id)
-                self._abort_if_unique_id_configured()
-                return self.async_create_entry(title="Aqvify", data=user_input)
-
-        return self.async_show_form(
-            step_id="user",
-            data_schema=STEP_USER_DATA_SCHEMA,
-            errors=errors,
-            description_placeholders={
-                "aqvify_url": "https://app.aqvify.com/User",
-            },
-        )
@@ -1,3 +0,0 @@
-"""Constants for the Aqvify integration."""
-
-DOMAIN = "aqvify"
@@ -1,92 +0,0 @@
-"""Coordinator for Aqvify integration."""
-
-from dataclasses import dataclass
-from datetime import timedelta
-import logging
-
-from aiohttp import ClientResponseError
-from pyaqvify import AqvifyAPI, AqvifyAuthException, AqvifyDeviceData, AqvifyDevices
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_API_KEY
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
-
-from .const import DOMAIN
-
-_LOGGER = logging.getLogger(__name__)
-
-UPDATE_INTERVAL = timedelta(seconds=60)
-
-type AqvifyConfigEntry = ConfigEntry[AqvifyCoordinator]
-
-
-@dataclass
-class AqvifyCoordinatorData:
-    """Data class for storing coordinator data."""
-
-    devices: AqvifyDevices
-    device_data: dict[str, AqvifyDeviceData]
-
-
-class AqvifyCoordinator(DataUpdateCoordinator[AqvifyCoordinatorData]):
-    """Data update coordinator for Aqvify devices."""
-
-    config_entry: AqvifyConfigEntry
-
-    def __init__(self, hass: HomeAssistant, entry: AqvifyConfigEntry) -> None:
-        """Initialize the Aqvify data update coordinator."""
-        super().__init__(
-            hass,
-            logger=_LOGGER,
-            name=DOMAIN,
-            update_interval=UPDATE_INTERVAL,
-            config_entry=entry,
-        )
-
-        self.api_client = AqvifyAPI(
-            entry.data[CONF_API_KEY], websession=async_get_clientsession(hass)
-        )
-
-    async def _async_setup(self) -> None:
-        """Set up the coordinator."""
-        try:
-            await self.api_client.async_get_account_id()
-        except AqvifyAuthException as err:
-            raise ConfigEntryAuthFailed(f"Invalid Aqvify API key: {err}") from err
-        except (ClientResponseError, TimeoutError) as err:
-            raise ConfigEntryNotReady(
-                f"Failed to connect to Aqvify API: {err}"
-            ) from err
-
-    async def _async_update_data(self) -> AqvifyCoordinatorData:
-        """Fetch device state."""
-        try:
-            devices = await self.api_client.async_get_devices()
-        except ClientResponseError as err:
-            raise UpdateFailed(f"Error communicating with Aqvify API: {err}") from err
-        except TimeoutError as err:
-            raise UpdateFailed(f"Timeout communicating with Aqvify API: {err}") from err
-
-        device_data = {}
-        for device in devices.devices.values():
-            try:
-                device_key = str(device.device_key)
-                device_data[
-                    device_key
-                ] = await self.api_client.async_get_device_latest_data(device_key)
-            except ClientResponseError as err:
-                raise UpdateFailed(
-                    f"Error communicating with Aqvify API: {err}"
-                ) from err
-            except TimeoutError as err:
-                raise UpdateFailed(
-                    f"Timeout communicating with Aqvify API: {err}"
-                ) from err
-
-        return AqvifyCoordinatorData(
-            devices=devices,
-            device_data=device_data,
-        )
@@ -1,35 +0,0 @@
-"""Defines a base Aqvify entity."""
-
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.entity import EntityDescription
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
-
-from .const import DOMAIN
-from .coordinator import AqvifyCoordinator
-
-
-class AqvifyBaseEntity(CoordinatorEntity[AqvifyCoordinator]):
-    """Defines a base Aqvify entity."""
-
-    _attr_has_entity_name = True
-
-    def __init__(
-        self,
-        coordinator: AqvifyCoordinator,
-        description: EntityDescription,
-        device_key: str,
-    ) -> None:
-        """Initialize the Aqvify entity."""
-        super().__init__(coordinator)
-
-        account_id = self.coordinator.config_entry.unique_id
-        self.device_key = device_key
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, f"{account_id}_{device_key}")},
-            name=coordinator.data.devices.devices[device_key].name,
-            manufacturer="Aqvify",
-            configuration_url="https://app.aqvify.com",
-            serial_number=device_key,
-        )
-        self._attr_unique_id = f"{account_id}_{device_key}_{description.key}"
-        self.entity_description = description
@@ -1,12 +0,0 @@
-{
-  "entity": {
-    "sensor": {
-      "meter_value": {
-        "default": "mdi:waves-arrow-up"
-      },
-      "water_level": {
-        "default": "mdi:waves"
-      }
-    }
-  }
-}
@@ -1,12 +0,0 @@
-{
-  "domain": "aqvify",
-  "name": "Aqvify",
-  "codeowners": ["@astrandb"],
-  "config_flow": true,
-  "documentation": "https://www.home-assistant.io/integrations/aqvify",
-  "integration_type": "hub",
-  "iot_class": "cloud_polling",
-  "loggers": ["pyaqvify"],
-  "quality_scale": "bronze",
-  "requirements": ["pyaqvify==0.0.8"]
-}
@@ -1,69 +0,0 @@
-rules:
-  # Bronze
-  action-setup:
-    status: exempt
-    comment: |
-      No actions in this integration.
-  appropriate-polling: done
-  brands: done
-  common-modules: done
-  config-flow-test-coverage: done
-  config-flow: done
-  dependency-transparency: done
-  docs-actions:
-    status: exempt
-    comment: |
-      The integration does not provide any actions.
-  docs-high-level-description: done
-  docs-installation-instructions: done
-  docs-removal-instructions: done
-  entity-event-setup:
-    status: exempt
-    comment: |
-      Entities of this integration do not explicitly subscribe to events.
-  entity-unique-id: done
-  has-entity-name: done
-  runtime-data: done
-  test-before-configure: done
-  test-before-setup: done
-  unique-config-entry: done
-
-  # Silver
-  action-exceptions: todo
-  config-entry-unloading: done
-  docs-configuration-parameters: todo
-  docs-installation-parameters: todo
-  entity-unavailable: todo
-  integration-owner: todo
-  log-when-unavailable: todo
-  parallel-updates: done
-  reauthentication-flow: todo
-  test-coverage: todo
-
-  # Gold
-  devices: todo
-  diagnostics: todo
-  discovery-update-info: todo
-  discovery: todo
-  docs-data-update: todo
-  docs-examples: todo
-  docs-known-limitations: todo
-  docs-supported-devices: todo
-  docs-supported-functions: todo
-  docs-troubleshooting: todo
-  docs-use-cases: todo
-  dynamic-devices: todo
-  entity-category: todo
-  entity-device-class: todo
-  entity-disabled-by-default: todo
-  entity-translations: todo
-  exception-translations: todo
-  icon-translations: done
-  reconfiguration-flow: todo
-  repair-issues: todo
-  stale-devices: todo
-
-  # Platinum
-  async-dependency: todo
-  inject-websession: todo
-  strict-typing: todo
@@ -1,79 +0,0 @@
-"""Sensor platform for Aqvify integration."""
-
-from collections.abc import Callable
-from dataclasses import dataclass
-from datetime import datetime
-
-from pyaqvify import AqvifyDeviceData
-
-from homeassistant.components.sensor import (
-    SensorDeviceClass,
-    SensorEntity,
-    SensorEntityDescription,
-    SensorStateClass,
-    StateType,
-)
-from homeassistant.const import UnitOfLength
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .coordinator import AqvifyConfigEntry
-from .entity import AqvifyBaseEntity
-
-# Coordinator is used to centralize the data updates.
-PARALLEL_UPDATES = 0
-
-
-@dataclass(frozen=True, kw_only=True)
-class AqvifySensorEntityDescription(SensorEntityDescription):
-    """Description of an Aqvify sensor entity."""
-
-    value_fn: Callable[[AqvifyDeviceData], float | int | None]
-
-
-ENTITIES: tuple[AqvifySensorEntityDescription, ...] = (
-    AqvifySensorEntityDescription(
-        key="meter_value",
-        translation_key="meter_value",
-        native_unit_of_measurement=UnitOfLength.METERS,
-        state_class=SensorStateClass.MEASUREMENT,
-        device_class=SensorDeviceClass.DISTANCE,
-        suggested_display_precision=2,
-        value_fn=lambda value: value.meter_value,
-    ),
-    AqvifySensorEntityDescription(
-        key="water_level",
-        translation_key="water_level",
-        native_unit_of_measurement=UnitOfLength.METERS,
-        state_class=SensorStateClass.MEASUREMENT,
-        device_class=SensorDeviceClass.DISTANCE,
-        suggested_display_precision=2,
-        value_fn=lambda value: value.water_level,
-    ),
-)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: AqvifyConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Aqvify sensor entities from a config entry."""
-    async_add_entities(
-        AqvifySensor(entry.runtime_data, description, device_key)
-        for description in ENTITIES
-        for device_key in entry.runtime_data.data.devices.devices
-    )
-
-
-class AqvifySensor(AqvifyBaseEntity, SensorEntity):
-    """Representation of an Aqvify sensor entity."""
-
-    entity_description: AqvifySensorEntityDescription
-
-    @property
-    def native_value(self) -> StateType | datetime | None:
-        """Return the state of the sensor."""
-        return self.entity_description.value_fn(
-            self.coordinator.data.device_data[self.device_key]
-        )
@@ -1,33 +0,0 @@
-{
-  "config": {
-    "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
-    },
-    "error": {
-      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
-      "unknown": "[%key:common::config_flow::error::unknown%]"
-    },
-    "step": {
-      "user": {
-        "data": {
-          "api_key": "API key"
-        },
-        "data_description": {
-          "api_key": "Your Aqvify API key"
-        },
-        "description": "Navigate to your [Aqvify account]({aqvify_url}), copy your API key, and paste it below."
-      }
-    }
-  },
-  "entity": {
-    "sensor": {
-      "meter_value": {
-        "name": "Meter value"
-      },
-      "water_level": {
-        "name": "Water level"
-      }
-    }
-  }
-}
@@ -1816,11 +1816,6 @@ class PipelineInput:
                            await self.run.text_to_speech(tts_input)

        except PipelineError as err:
-            if self.run.tts_stream:
-                # Clean up TTS stream
-                self.run.tts_stream.delete()
-                self.run.tts_stream = None
-
            self.run.process_event(
                PipelineEvent(
                    PipelineEventType.ERROR,
@@ -1890,17 +1885,15 @@ class PipelineInput:
        ):
            prepare_tasks.append(self.run.prepare_recognize_intent(self.session))

-        if prepare_tasks:
-            await asyncio.gather(*prepare_tasks)
-
-        # Do TTS prepare separately so we don't create a ResultStream if the
-        # pipeline is invalid.
        if (
            start_stage_index
            <= PIPELINE_STAGE_ORDER.index(PipelineStage.TTS)
            <= end_stage_index
        ):
-            await self.run.prepare_text_to_speech()
+            prepare_tasks.append(self.run.prepare_text_to_speech())
+
+        if prepare_tasks:
+            await asyncio.gather(*prepare_tasks)


 class PipelinePreferred(CollectionError):
@@ -3,7 +3,6 @@
 from dataclasses import asdict
 import logging
 from pathlib import Path
-import re
 from typing import Any

 from hassil.parse_expression import parse_sentence
@@ -205,8 +204,6 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 def has_no_punctuation(value: list[str]) -> list[str]:
    """Validate result does not contain punctuation."""
    for sentence in value:
-        # Exclude {list_references} which may contain punctuation characters.
-        sentence = _remove_list_references(sentence)
        if (
            PUNCTUATION_START.search(sentence)
            or PUNCTUATION_END.search(sentence)
@@ -218,11 +215,6 @@ def has_no_punctuation(value: list[str]) -> list[str]:
    return value


-def _remove_list_references(sentence: str) -> str:
-    """Remove {list_references} from a sentence for linting."""
-    return re.sub(r"(?<!\\)\{[^{}]*\}", "", sentence)
-
-
 def is_valid_sentence(value: list[str]) -> list[str]:
    """Validate result can be parsed by hassil."""
    for sentence in value:
@@ -230,6 +222,7 @@ def is_valid_sentence(value: list[str]) -> list[str]:
            parse_sentence(sentence)
        except ParseError as err:
            raise vol.Invalid(f"invalid sentence: {err}") from err
+
    return value


@@ -18,9 +18,6 @@
      }
    },
    "sensor": {
-      "open_status": {
-        "default": "mdi:window-open"
-      },
      "power_consumption": {
        "default": "mdi:lightning-bolt"
      }
@@ -50,25 +50,21 @@ SENSOR_TYPES: tuple[BleBoxSensorEntityDescription, ...] = (
        key="pm1",
        device_class=SensorDeviceClass.PM1,
        native_unit_of_measurement=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
-        state_class=SensorStateClass.MEASUREMENT,
    ),
    BleBoxSensorEntityDescription(
        key="pm2_5",
        device_class=SensorDeviceClass.PM25,
        native_unit_of_measurement=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
-        state_class=SensorStateClass.MEASUREMENT,
    ),
    BleBoxSensorEntityDescription(
        key="pm10",
        device_class=SensorDeviceClass.PM10,
        native_unit_of_measurement=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
-        state_class=SensorStateClass.MEASUREMENT,
    ),
    BleBoxSensorEntityDescription(
        key="temperature",
        device_class=SensorDeviceClass.TEMPERATURE,
        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        state_class=SensorStateClass.MEASUREMENT,
    ),
    BleBoxSensorEntityDescription(
        key="powerConsumption",
@@ -80,72 +76,62 @@ SENSOR_TYPES: tuple[BleBoxSensorEntityDescription, ...] = (
        key="humidity",
        device_class=SensorDeviceClass.HUMIDITY,
        native_unit_of_measurement=PERCENTAGE,
-        state_class=SensorStateClass.MEASUREMENT,
    ),
    BleBoxSensorEntityDescription(
        key="wind",
        device_class=SensorDeviceClass.WIND_SPEED,
        native_unit_of_measurement=UnitOfSpeed.METERS_PER_SECOND,
-        state_class=SensorStateClass.MEASUREMENT,
    ),
    BleBoxSensorEntityDescription(
        key="illuminance",
        device_class=SensorDeviceClass.ILLUMINANCE,
        native_unit_of_measurement=LIGHT_LUX,
-        state_class=SensorStateClass.MEASUREMENT,
    ),
    BleBoxSensorEntityDescription(
        key="forwardActiveEnergy",
        device_class=SensorDeviceClass.ENERGY,
        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
-        state_class=SensorStateClass.TOTAL_INCREASING,
    ),
    BleBoxSensorEntityDescription(
        key="reverseActiveEnergy",
        device_class=SensorDeviceClass.ENERGY,
        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
-        state_class=SensorStateClass.TOTAL_INCREASING,
    ),
    BleBoxSensorEntityDescription(
        key="reactivePower",
        device_class=SensorDeviceClass.POWER,
        native_unit_of_measurement=UnitOfReactivePower.VOLT_AMPERE_REACTIVE,
-        state_class=SensorStateClass.MEASUREMENT,
    ),
    BleBoxSensorEntityDescription(
        key="activePower",
        device_class=SensorDeviceClass.POWER,
        native_unit_of_measurement=UnitOfPower.WATT,
-        state_class=SensorStateClass.MEASUREMENT,
    ),
    BleBoxSensorEntityDescription(
        key="apparentPower",
        device_class=SensorDeviceClass.APPARENT_POWER,
        native_unit_of_measurement=UnitOfApparentPower.VOLT_AMPERE,
-        state_class=SensorStateClass.MEASUREMENT,
    ),
    BleBoxSensorEntityDescription(
        key="voltage",
        device_class=SensorDeviceClass.VOLTAGE,
        native_unit_of_measurement=UnitOfElectricPotential.VOLT,
-        state_class=SensorStateClass.MEASUREMENT,
    ),
    BleBoxSensorEntityDescription(
        key="current",
        device_class=SensorDeviceClass.CURRENT,
        native_unit_of_measurement=UnitOfElectricCurrent.MILLIAMPERE,
-        state_class=SensorStateClass.MEASUREMENT,
    ),
    BleBoxSensorEntityDescription(
        key="frequency",
        device_class=SensorDeviceClass.FREQUENCY,
        native_unit_of_measurement=UnitOfFrequency.HERTZ,
-        state_class=SensorStateClass.MEASUREMENT,
    ),
    BleBoxSensorEntityDescription(
        key="openStatus",
        translation_key="open_status",
        device_class=SensorDeviceClass.ENUM,
+        icon="mdi:window-open",
        options=list(OPEN_STATUS.values()),
        value_fn=lambda v: OPEN_STATUS.get(int(v)) if v is not None else None,
    ),
@@ -230,6 +230,10 @@ async def async_migrate_entry(hass: HomeAssistant, entry: BSBLanConfigEntry) ->
        entry.minor_version,
    )

+    if entry.version > 1:
+        # Downgraded from a future version; cannot migrate.
+        return False
+
    # 1.1 -> 1.2: Add CONF_HEATING_CIRCUITS. Attempt to discover available
    # heating circuits from the device; fall back to [1] (pre-multi-circuit
    # default) if the device is unreachable or the endpoint is unsupported.
@@ -6,5 +6,5 @@
  "documentation": "https://www.home-assistant.io/integrations/chacon_dio",
  "iot_class": "cloud_push",
  "loggers": ["dio_chacon_api"],
-  "requirements": ["dio-chacon-wifi-api==1.3.0"]
+  "requirements": ["dio-chacon-wifi-api==1.2.2"]
 }
@@ -87,6 +87,10 @@ async def async_migrate_entry(
 ) -> bool:
    """Migrate old entry."""

+    if config_entry.version > 1:
+        # This means the user has downgraded from a future version
+        return False
+
    if config_entry.version == 1 and config_entry.minor_version == 1:
        device_registry = dr.async_get(hass)

@@ -1,7 +1,6 @@
 """Offer sentence based automation rules."""

 from collections.abc import Awaitable, Callable
-import re
 from typing import Any

 from hassil.parse_expression import parse_sentence
@@ -34,8 +33,6 @@ TRIGGER_CALLBACK_TYPE = Callable[
 def has_no_punctuation(value: list[str]) -> list[str]:
    """Validate result does not contain punctuation."""
    for sentence in value:
-        # Exclude {list_references} which may contain punctuation characters.
-        sentence = _remove_list_references(sentence)
        if (
            PUNCTUATION_START.search(sentence)
            or PUNCTUATION_END.search(sentence)
@@ -47,11 +44,6 @@ def has_no_punctuation(value: list[str]) -> list[str]:
    return value


-def _remove_list_references(sentence: str) -> str:
-    """Remove {list_references} from a sentence for linting."""
-    return re.sub(r"(?<!\\)\{[^{}]*\}", "", sentence)
-
-
 def is_valid_sentence(value: list[str]) -> list[str]:
    """Validate result can be parsed by hassil."""
    for sentence in value:
@@ -59,6 +51,7 @@ def is_valid_sentence(value: list[str]) -> list[str]:
            parse_sentence(sentence)
        except ParseError as err:
            raise vol.Invalid(f"invalid sentence: {err}") from err
+
    return value


@@ -7,6 +7,6 @@
  "integration_type": "device",
  "iot_class": "local_polling",
  "loggers": ["pydaikin"],
-  "requirements": ["pydaikin==2.18.1"],
+  "requirements": ["pydaikin==2.17.2"],
  "zeroconf": ["_dkapi._tcp.local."]
 }
@@ -5,7 +5,7 @@ import logging
 from typing import Any

 from aiohttp import ClientError, ClientResponseError
-from data_grand_lyon_ha import DataGrandLyonClient, TclStop, find_tcl_stop_by_id
+from data_grand_lyon_ha import DataGrandLyonClient
 import voluptuous as vol

 from homeassistant.config_entries import (
@@ -18,12 +18,6 @@ from homeassistant.config_entries import (
 from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
 from homeassistant.core import callback
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.selector import (
-    SelectOptionDict,
-    SelectSelector,
-    SelectSelectorConfig,
-    SelectSelectorMode,
-)

 from .const import (
    CONF_LINE,
@@ -49,6 +43,13 @@ STEP_RECONFIGURE_SCHEMA = vol.Schema(
    }
 )

+STEP_STOP_DATA_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_LINE): str,
+        vol.Required(CONF_STOP_ID): vol.Coerce(int),
+    }
+)
+
 STEP_VELOV_STATION_DATA_SCHEMA = vol.Schema(
    {
        vol.Required(CONF_STATION_ID): vol.Coerce(int),
@@ -178,126 +179,33 @@ class DataGrandLyonConfigFlow(ConfigFlow, domain=DOMAIN):
 class StopSubentryFlowHandler(ConfigSubentryFlow):
    """Handle a subentry flow for adding a Data Grand Lyon stop."""

-    def __init__(self) -> None:
-        """Initialize the flow."""
-        self._stops: list[TclStop] = []
-        self._selected_stop: TclStop | None = None
-        self._selected_stop_id: int | None = None
-
    async def async_step_user(
        self, user_input: dict[str, Any] | None = None
    ) -> SubentryFlowResult:
-        """Pick a stop from the list fetched from the API, or enter one manually."""
-        if not self._stops:
-            if error := await self._async_load_stops():
-                return self.async_abort(reason=error)
+        """Handle the user step to add a new stop."""
+        entry = self._get_entry()

-        errors: dict[str, str] = {}
        if user_input is not None:
-            try:
-                stop_id = int(user_input[CONF_STOP_ID])
-            except ValueError:
-                errors[CONF_STOP_ID] = "invalid_stop_id"
-            else:
-                self._selected_stop_id = stop_id
-                self._selected_stop = find_tcl_stop_by_id(self._stops, stop_id)
-                return await self.async_step_pick_line()
+            line = user_input[CONF_LINE]
+            stop_id = user_input[CONF_STOP_ID]
+            unique_id = f"{line}_{stop_id}"

-        options = [
-            SelectOptionDict(value=str(stop.id), label=_stop_label(stop))
-            for stop in sorted(
-                self._stops, key=lambda s: (s.nom, s.commune or "", s.id or 0)
+            for subentry in entry.subentries.values():
+                if subentry.unique_id == unique_id:
+                    return self.async_abort(reason="already_configured")
+
+            name = f"{line} - Stop {stop_id}"
+            return self.async_create_entry(
+                title=name,
+                data={CONF_LINE: line, CONF_STOP_ID: stop_id},
+                unique_id=unique_id,
            )
-        ]
-        schema = vol.Schema(
-            {
-                vol.Required(CONF_STOP_ID): SelectSelector(
-                    SelectSelectorConfig(
-                        options=options,
-                        mode=SelectSelectorMode.DROPDOWN,
-                        sort=False,
-                        custom_value=True,
-                    )
-                )
-            }
-        )
+
        return self.async_show_form(
            step_id="user",
-            data_schema=schema,
-            errors=errors,
+            data_schema=STEP_STOP_DATA_SCHEMA,
        )

-    async def async_step_pick_line(
-        self, user_input: dict[str, Any] | None = None
-    ) -> SubentryFlowResult:
-        """Pick a line from the selected stop's desserte, or enter one manually."""
-        assert self._selected_stop_id is not None
-        if user_input is not None:
-            return self._create_stop(
-                line=user_input[CONF_LINE], stop_id=self._selected_stop_id
-            )
-
-        options = self._selected_stop.desserte if self._selected_stop else []
-        schema = vol.Schema(
-            {
-                vol.Required(CONF_LINE): SelectSelector(
-                    SelectSelectorConfig(
-                        options=options,
-                        mode=SelectSelectorMode.DROPDOWN,
-                        custom_value=True,
-                    )
-                )
-            }
-        )
-        return self.async_show_form(step_id="pick_line", data_schema=schema)
-
-    async def _async_load_stops(self) -> str | None:
-        """Fetch TCL stops from the API, returning an error key on failure."""
-        entry = self._get_entry()
-        session = async_get_clientsession(self.hass)
-        client = DataGrandLyonClient(
-            session=session,
-            username=entry.data[CONF_USERNAME],
-            password=entry.data[CONF_PASSWORD],
-        )
-        try:
-            self._stops = await client.get_tcl_stops()
-        except ClientResponseError as err:
-            if err.status in (401, 403):
-                return "invalid_auth"
-            return "cannot_connect"
-        except ClientError, TimeoutError:
-            return "cannot_connect"
-        except Exception:
-            _LOGGER.exception("Unexpected error fetching Data Grand Lyon TCL stops")
-            return "unknown"
-        return None
-
-    def _create_stop(self, line: str, stop_id: int) -> SubentryFlowResult:
-        """Create the stop subentry, aborting on duplicate."""
-        entry = self._get_entry()
-        unique_id = f"{line}_{stop_id}"
-        for subentry in entry.subentries.values():
-            if subentry.unique_id == unique_id:
-                return self.async_abort(reason="already_configured")
-
-        return self.async_create_entry(
-            title=f"{line} - Stop {stop_id}",
-            data={CONF_LINE: line, CONF_STOP_ID: stop_id},
-            unique_id=unique_id,
-        )
-
-
-def _stop_label(stop: TclStop) -> str:
-    label = stop.nom
-    # variable extracted to please codespell.
-    address = stop.adresse  # codespell:ignore adresse
-    if address or stop.commune:
-        label += " (" + ", ".join(filter(None, [address, stop.commune])) + ")"
-    label += f" - {stop.id}"
-
-    return label
-

 class VelovStationSubentryFlowHandler(ConfigSubentryFlow):
    """Handle a subentry flow for adding a Vélo'v station."""
@@ -46,30 +46,17 @@
  "config_subentries": {
    "stop": {
      "abort": {
-        "already_configured": "[%key:common::config_flow::abort::already_configured_service%]",
-        "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-        "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
-        "unknown": "[%key:common::config_flow::error::unknown%]"
+        "already_configured": "[%key:common::config_flow::abort::already_configured_service%]"
      },
      "entry_type": "Transit stop",
-      "error": {
-        "invalid_stop_id": "Stop ID must be a number."
-      },
      "initiate_flow": {
        "user": "Add transit stop"
      },
      "step": {
-        "pick_line": {
-          "data": {
-            "line": "Line"
-          }
-        },
        "user": {
          "data": {
-            "stop_id": "Stop"
-          },
-          "data_description": {
-            "stop_id": "Search by stop name, address or city, or enter a stop ID directly."
+            "line": "Line",
+            "stop_id": "Stop ID"
          }
        }
      }
@@ -54,6 +54,10 @@ async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
        config_entry.minor_version,
    )

+    if config_entry.version > 1:
+        # This means the user has downgraded from a future version
+        return False
+
    if config_entry.version == 1:
        if config_entry.minor_version < 2:
            new_options = {**config_entry.options}
@@ -51,7 +51,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: DnsIPConfigEntry) -> boo
            tcp_port=entry.options[CONF_PORT],
            udp_port=entry.options[CONF_PORT],
        )
-        queries.append(resolver_ipv4.query_dns(hostname, "A"))
+        queries.append(resolver_ipv4.query(hostname, "A"))

    if entry.data[CONF_IPV6]:
        resolver_ipv6 = aiodns.DNSResolver(
@@ -59,7 +59,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: DnsIPConfigEntry) -> boo
            tcp_port=entry.options[CONF_PORT_IPV6],
            udp_port=entry.options[CONF_PORT_IPV6],
        )
-        queries.append(resolver_ipv6.query_dns(hostname, "AAAA"))
+        queries.append(resolver_ipv6.query(hostname, "AAAA"))

    async def _close_resolvers() -> None:
        if resolver_ipv4 is not None:
@@ -111,6 +111,10 @@ async def async_migrate_entry(
 ) -> bool:
    """Migrate old entry to a newer version."""

+    if config_entry.version > 1:
+        # This means the user has downgraded from a future version
+        return False
+
    if config_entry.version < 2 and config_entry.minor_version < 2:
        _LOGGER.debug(
            "Migrating configuration from version %s.%s",
@@ -72,7 +72,7 @@ async def async_validate_hostname(
            _resolver = aiodns.DNSResolver(
                nameservers=[resolver], udp_port=port, tcp_port=port
            )
-            result = bool(await _resolver.query_dns(hostname, qtype))
+            result = bool(await _resolver.query(hostname, qtype))

        return result

@@ -8,7 +8,6 @@ from typing import TYPE_CHECKING, Literal

 import aiodns
 from aiodns.error import DNSError
-import pycares

 from homeassistant.components.sensor import SensorEntity
 from homeassistant.const import CONF_NAME, CONF_PORT
@@ -149,7 +148,7 @@ class WanIpSensor(SensorEntity):
        response = None
        try:
            async with asyncio.timeout(10):
-                response = await self._resolver.query_dns(self.hostname, self.querytype)
+                response = await self._resolver.query(self.hostname, self.querytype)
        except TimeoutError as err:
            _LOGGER.debug("Timeout while resolving host: %s", err)
            await self._resolver.close()
@@ -158,19 +157,9 @@ class WanIpSensor(SensorEntity):
            await self._resolver.close()

        if response:
-            if TYPE_CHECKING:
-                assert all(
-                    isinstance(res.data, (pycares.ARecordData, pycares.AAAARecordData))
-                    for res in response.answer
-                )
-            _ips = []
-            for res in response.answer:
-                if TYPE_CHECKING:
-                    assert isinstance(
-                        res.data, (pycares.ARecordData, pycares.AAAARecordData)
-                    )
-                _ips.append(res.data.addr)
-            sorted_ips = sort_ips(_ips, querytype=self.querytype)
+            sorted_ips = sort_ips(
+                [res.host for res in response], querytype=self.querytype
+            )
            self._attr_native_value = sorted_ips[0]
            self._attr_extra_state_attributes["ip_addresses"] = sorted_ips
            self._attr_available = True
@@ -7,4 +7,3 @@ from homeassistant.const import Platform
 DOMAIN = "duco"
 PLATFORMS = [Platform.FAN, Platform.SENSOR]
 SCAN_INTERVAL = timedelta(seconds=10)
-BOX_NODE_ID = 1
@@ -24,7 +24,7 @@ from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util import dt as dt_util

-from .const import BOX_NODE_ID, DOMAIN
+from .const import DOMAIN
 from .coordinator import DucoConfigEntry, DucoCoordinator
 from .entity import DucoEntity

@@ -158,13 +158,7 @@ async def async_setup_entry(
        # The firmware removes deregistered RF/wired nodes automatically.
        # BSRH box sensors that are physically unplugged from the PCB are
        # not deregistered by the firmware and will never appear here as stale.
-        # The BOX node can transiently disappear from the API response, so keep
-        # node 1 to avoid removing the main controller device.
-        stale_node_ids = {
-            node_id
-            for node_id in known_nodes - coordinator.data.nodes.keys()
-            if node_id != BOX_NODE_ID
-        }
+        stale_node_ids = known_nodes - coordinator.data.nodes.keys()
        if stale_node_ids:
            device_reg = dr.async_get(hass)
            mac = entry.unique_id
@@ -98,6 +98,10 @@ async def async_migrate_entry(
        config_entry.minor_version,
    )

+    if config_entry.version > 1:
+        # This means the user has downgraded from a future version
+        return False
+
    if config_entry.version == 1:
        new_options = {**config_entry.options}

@@ -26,7 +26,6 @@ from homeassistant.helpers.event import (
    async_track_state_change_event,
    async_track_time_interval,
 )
-from homeassistant.util import dt as dt_util

 from .const import (
    CONF_DEVICE_NAME,
@@ -222,7 +221,8 @@ def update_listeners(hass: HomeAssistant, entry: EnergyIDConfigEntry) -> None:
            ):
                try:
                    value = float(current_state.state)
-                    timestamp = current_state.last_updated or dt_util.utcnow()
+                    # pylint: disable-next=home-assistant-enforce-utcnow
+                    timestamp = current_state.last_updated or dt.datetime.now(dt.UTC)
                    client.get_or_create_sensor(energyid_key).update(value, timestamp)
                except ValueError, TypeError:
                    _LOGGER.debug(
@@ -8,12 +8,9 @@ from env_canada import ECAirQuality, ECMap, ECWeather
 from homeassistant.const import CONF_LANGUAGE, CONF_LATITUDE, CONF_LONGITUDE, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.typing import ConfigType

-from .const import CONF_STATION, DOMAIN
+from .const import CONF_STATION
 from .coordinator import ECConfigEntry, ECDataUpdateCoordinator, ECRuntimeData
-from .services import async_setup_services

 DEFAULT_RADAR_UPDATE_INTERVAL = timedelta(minutes=5)
 DEFAULT_WEATHER_UPDATE_INTERVAL = timedelta(minutes=5)
@@ -22,14 +19,6 @@ PLATFORMS = [Platform.CAMERA, Platform.SENSOR, Platform.WEATHER]

 _LOGGER = logging.getLogger(__name__)

-CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
-
-
-async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
-    """Set up the Environment Canada services."""
-    async_setup_services(hass)
-    return True
-

 async def async_setup_entry(hass: HomeAssistant, config_entry: ECConfigEntry) -> bool:
    """Set up EC as config entry."""
@@ -19,9 +19,6 @@
    }
  },
  "services": {
-    "get_alerts": {
-      "service": "mdi:bell-alert"
-    },
    "get_forecasts": {
      "service": "mdi:weather-cloudy-clock"
    },
@@ -1,56 +0,0 @@
-"""Define services for the Environment Canada integration."""
-
-from typing import Any
-
-from env_canada import ECWeather
-import voluptuous as vol
-
-from homeassistant.const import ATTR_CONFIG_ENTRY_ID
-from homeassistant.core import HomeAssistant, ServiceCall, SupportsResponse, callback
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import config_validation as cv, service
-
-from .const import DOMAIN
-
-SERVICE_GET_ALERTS = "get_alerts"
-SERVICE_GET_ALERTS_SCHEMA = vol.Schema({vol.Required(ATTR_CONFIG_ENTRY_ID): cv.string})
-
-SNAKE_MAPPING = {
-    "alertColourLevel": "alert_colour_level",
-    "expiryTime": "expiry_time",
-}
-
-
-async def _async_get_alerts(call: ServiceCall) -> dict[str, Any]:
-    """Return the active alerts."""
-    entry = service.async_get_config_entry(
-        call.hass, DOMAIN, call.data[ATTR_CONFIG_ENTRY_ID]
-    )
-
-    ec: ECWeather | None = entry.runtime_data.weather_coordinator.ec_data
-    if ec is None:
-        raise HomeAssistantError(
-            translation_domain=DOMAIN,
-            translation_key="not_connected",
-        )
-
-    data: dict[str, Any] = ec.alerts
-    return {
-        k: [
-            {SNAKE_MAPPING.get(ik, ik): iv for ik, iv in item.items()}
-            for item in v["value"]
-        ]
-        for k, v in data.items()
-    }
-
-
-@callback
-def async_setup_services(hass: HomeAssistant) -> None:
-    """Set up the services for the Environment Canada integration."""
-    hass.services.async_register(
-        DOMAIN,
-        SERVICE_GET_ALERTS,
-        _async_get_alerts,
-        schema=SERVICE_GET_ALERTS_SCHEMA,
-        supports_response=SupportsResponse.ONLY,
-    )
@@ -1,11 +1,3 @@
-get_alerts:
-  fields:
-    config_entry_id:
-      required: true
-      selector:
-        config_entry:
-          integration: environment_canada
-
 get_forecasts:
  target:
    entity:
@@ -112,22 +112,7 @@
      }
    }
  },
-  "exceptions": {
-    "not_connected": {
-      "message": "Environment Canada is not connected"
-    }
-  },
  "services": {
-    "get_alerts": {
-      "description": "Retrieves the alerts from the selected weather service.",
-      "fields": {
-        "config_entry_id": {
-          "description": "The Environment Canada service to retrieve alerts from.",
-          "name": "Environment Canada service"
-        }
-      },
-      "name": "Get alerts"
-    },
    "get_forecasts": {
      "description": "Retrieves the forecast from selected weather services.",
      "name": "Get forecasts"
@@ -88,6 +88,10 @@ async def async_migrate_entry(
        config_entry.minor_version,
    )

+    if config_entry.version > 1 or config_entry.minor_version > 1:
+        # This means the user has downgraded from a future version
+        return False
+
    if config_entry.version == 1 and config_entry.minor_version == 1:
        new_data = {**config_entry.data}
        new_data[CONF_CONNECTION_TYPE] = HTTP
@@ -53,6 +53,9 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:

 async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> bool:
    """Migrate config entry."""
+    if config_entry.version > 2:
+        # Downgraded from future
+        return False

    if config_entry.version < 2:
        # Move optional fields from data to options in config entry
@@ -1,7 +1,7 @@
 {
  "domain": "fluss",
  "name": "Fluss+",
-  "codeowners": ["@fluss", "@Marcello17"],
+  "codeowners": ["@fluss"],
  "config_flow": true,
  "documentation": "https://www.home-assistant.io/integrations/fluss",
  "iot_class": "cloud_polling",
@@ -48,6 +48,8 @@ async def async_unload_entry(hass: HomeAssistant, entry: FGLairConfigEntry) -> b

 async def async_migrate_entry(hass: HomeAssistant, entry: FGLairConfigEntry) -> bool:
    """Migrate old entry."""
+    if entry.version > 1:
+        return False

    if entry.version == 1:
        new_data = {**entry.data}
@@ -65,6 +65,10 @@ async def async_migrate_entry(
    """Migrate old entry."""
    _LOGGER.debug("Migrating from version %s", config_entry.version)

+    if config_entry.version > 1:
+        # This means the user has downgraded from a future version
+        return False
+
    if config_entry.version == 1:
        if config_entry.minor_version < 2:
            new = {**config_entry.data}
@@ -14,7 +14,6 @@ from homeassistant.const import CONF_ADDRESS, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady

-from .const import CONF_PRODUCT_TYPE
 from .coordinator import (
    DeviceUnavailable,
    GardenaBluetoothConfigEntry,
@@ -37,8 +36,8 @@ PRODUCTS_SCAN_TIMEOUT = 10
 PRODUCT_TYPE_TIMEOUT = 30


-async def async_get_product(hass: HomeAssistant, address: str) -> ManufacturerData:
-    """Get manufacturer data for the given address via active scan."""
+async def async_get_product_type(hass: HomeAssistant, address: str) -> ProductType:
+    """Get a product type for the given address."""

    data = ManufacturerData()

@@ -60,7 +59,7 @@ async def async_get_product(hass: HomeAssistant, address: str) -> ManufacturerDa
            mode=bluetooth.BluetoothScanningMode.ACTIVE,
            timeout=PRODUCT_TYPE_TIMEOUT,
        )
-    return data
+    return data.product_type


 async def async_get_products(hass: HomeAssistant) -> dict[str, ManufacturerData]:
@@ -93,21 +92,6 @@ async def async_get_products(hass: HomeAssistant) -> dict[str, ManufacturerData]
    return products


-async def async_migrate_product_type(
-    hass: HomeAssistant, entry: GardenaBluetoothConfigEntry
-) -> GardenaBluetoothConfigEntry:
-    """Discover product type for old entries and upgrade them to minor version 2."""
-    mfg = await async_get_product(hass, entry.data[CONF_ADDRESS])
-    if mfg.product_type is ProductType.UNKNOWN:
-        raise ConfigEntryNotReady("Unable to find product type")
-    hass.config_entries.async_update_entry(
-        entry,
-        data={**entry.data, CONF_PRODUCT_TYPE: mfg.product_type.name},
-        minor_version=2,
-    )
-    return entry
-
-
 def get_connection(hass: HomeAssistant, address: str) -> CachedConnection:
    """Set up a cached client that keeps connection after last use."""

@@ -127,11 +111,11 @@ async def async_setup_entry(
 ) -> bool:
    """Set up Gardena Bluetooth from a config entry."""

-    if entry.minor_version < 2:
-        entry = await async_migrate_product_type(hass, entry)
-
    address = entry.data[CONF_ADDRESS]
-    product_type = ProductType[entry.data[CONF_PRODUCT_TYPE]]
+
+    product_type = await async_get_product_type(hass, address)
+    if product_type is ProductType.UNKNOWN:
+        raise ConfigEntryNotReady("Unable to find product type")

    client = Client(get_connection(hass, address), product_type)

@@ -6,7 +6,7 @@ from typing import Any
 from gardena_bluetooth.client import Client
 from gardena_bluetooth.const import PRODUCT_NAMES, DeviceInformation
 from gardena_bluetooth.exceptions import CharacteristicNotFound, CommunicationFailure
-from gardena_bluetooth.parse import ManufacturerData, ProductType
+from gardena_bluetooth.parse import ProductType
 import voluptuous as vol

 from homeassistant.components.bluetooth import BluetoothServiceInfo
@@ -14,8 +14,8 @@ from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
 from homeassistant.const import CONF_ADDRESS
 from homeassistant.data_entry_flow import AbortFlow

-from . import async_get_product, async_get_products, get_connection
-from .const import CONF_PRODUCT_TYPE, DOMAIN
+from . import async_get_product_type, async_get_products, get_connection
+from .const import DOMAIN

 _LOGGER = logging.getLogger(__name__)

@@ -33,12 +33,11 @@ class GardenaBluetoothConfigFlow(ConfigFlow, domain=DOMAIN):
    """Handle a config flow for Gardena Bluetooth."""

    VERSION = 1
-    MINOR_VERSION = 2

    def __init__(self) -> None:
        """Initialize the config flow."""
+        self.devices: dict[str, str] = {}
        self.address: str | None
-        self.devices: dict[str, ManufacturerData] = {}

    async def async_read_data(self):
        """Try to connect to device and extract information."""
@@ -54,23 +53,19 @@ class GardenaBluetoothConfigFlow(ConfigFlow, domain=DOMAIN):
        finally:
            await client.disconnect()

-        assert self.address in self.devices
-        return {
-            CONF_ADDRESS: self.address,
-            CONF_PRODUCT_TYPE: self.devices[self.address].product_type.name,
-        }
+        return {CONF_ADDRESS: self.address}

    async def async_step_bluetooth(
        self, discovery_info: BluetoothServiceInfo
    ) -> ConfigFlowResult:
        """Handle the bluetooth discovery step."""
        _LOGGER.debug("Discovered device: %s", discovery_info)
-        mfg = await async_get_product(self.hass, discovery_info.address)
-        self.devices[discovery_info.address] = mfg
-        if mfg.product_type not in _SUPPORTED_PRODUCT_TYPES:
+        product_type = await async_get_product_type(self.hass, discovery_info.address)
+        if product_type not in _SUPPORTED_PRODUCT_TYPES:
            return self.async_abort(reason="no_devices_found")

        self.address = discovery_info.address
+        self.devices = {discovery_info.address: PRODUCT_NAMES[product_type]}
        await self.async_set_unique_id(self.address)
        self._abort_if_unique_id_configured()
        return await self.async_step_confirm()
@@ -80,7 +75,7 @@ class GardenaBluetoothConfigFlow(ConfigFlow, domain=DOMAIN):
    ) -> ConfigFlowResult:
        """Confirm discovery."""
        assert self.address
-        title = PRODUCT_NAMES[self.devices[self.address].product_type]
+        title = self.devices[self.address]

        if user_input is not None:
            data = await self.async_read_data()
@@ -107,24 +102,24 @@ class GardenaBluetoothConfigFlow(ConfigFlow, domain=DOMAIN):
            return await self.async_step_confirm()

        current = self._async_current_ids(include_ignore=False)
-        self.devices = await async_get_products(self.hass)
+        devices = await async_get_products(self.hass)

        # Keep selection sorted by address to ensure stable tests
-        devices = {
+        self.devices = {
            address: PRODUCT_NAMES[data.product_type]
-            for address in sorted(self.devices)
+            for address in sorted(devices)
            if address not in current
-            and (data := self.devices[address]).product_type in _SUPPORTED_PRODUCT_TYPES
+            and (data := devices[address]).product_type in _SUPPORTED_PRODUCT_TYPES
        }

-        if not devices:
+        if not self.devices:
            return self.async_abort(reason="no_devices_found")

        return self.async_show_form(
            step_id="user",
            data_schema=vol.Schema(
                {
-                    vol.Required(CONF_ADDRESS): vol.In(devices),
+                    vol.Required(CONF_ADDRESS): vol.In(self.devices),
                },
            ),
        )
@@ -1,4 +1,3 @@
 """Constants for the Gardena Bluetooth integration."""

 DOMAIN = "gardena_bluetooth"
-CONF_PRODUCT_TYPE = "product_type"
@@ -59,6 +59,10 @@ async def async_migrate_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
    """Migrate entry."""
    _LOGGER.debug("Migrating from version %s:%s", entry.version, entry.minor_version)

+    if entry.version > 2:
+        # This means the user has downgraded from a future version
+        return False
+
    if entry.version == 1:
        # Migrate to advanced section
        new_options = {**entry.options}
@@ -148,6 +148,9 @@ async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
        "Migrating from version %s.%s", config_entry.version, config_entry.minor_version
    )

+    if config_entry.version > 1:
+        # This means the user has downgraded from a future version
+        return False
    if config_entry.version == 1:
        options = {**config_entry.options}
        if config_entry.minor_version < 2:
@@ -76,6 +76,9 @@ async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
        "Migrating from version %s.%s", config_entry.version, config_entry.minor_version
    )

+    if config_entry.version > 1:
+        # This means the user has downgraded from a future version
+        return False
    if config_entry.version == 1:
        options = {**config_entry.options}
        if config_entry.minor_version < 2:
@@ -98,6 +98,10 @@ async def async_migrate_entry(
 ) -> bool:
    """Migrate old config entries."""

+    if config_entry.version > 2:
+        # This means the user has downgraded from a future version
+        return False
+
    if config_entry.version == 1:
        # Update from version 1 to version 2 adding the PROTOCOL to the config entry
        host = config_entry.data[CONF_HOST]
@@ -226,6 +226,10 @@ async def async_migrate_entry(
    """Migrate entry."""
    LOGGER.debug("Migrating from version %s:%s", entry.version, entry.minor_version)

+    if entry.version > 2:
+        # This means the user has downgraded from a future version
+        return False
+
    if entry.version == 2 and entry.minor_version == 1:
        # Add TTS subentry which was missing in 2025.7.0b0
        if not any(
@@ -100,6 +100,9 @@ async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
        "Migrating from version %s.%s", config_entry.version, config_entry.minor_version
    )

+    if config_entry.version > 1:
+        # This means the user has downgraded from a future version
+        return False
    if config_entry.version == 1:
        options = {**config_entry.options}
        if config_entry.minor_version < 2:
@@ -108,6 +108,10 @@ async def async_migrate_entry(
        config_entry.minor_version,
    )

+    if config_entry.version > 1:
+        # This means the user has downgraded from a future version
+        return False
+
    if config_entry.version == 1:
        if config_entry.minor_version == 1:
            serial_number = config_entry.data[SERIAL_NUMBER]
@@ -131,24 +135,7 @@ async def async_migrate_entry(
            )

            if canonical.entry_id != config_entry.entry_id:
-                if canonical.minor_version < 2:
-                    # The canonical entry has not been migrated yet and its
-                    # migration will remove this duplicate.
-                    return False
-
-                # The canonical entry is already fully migrated and will not run
-                # a migration that removes this duplicate, so remove it here. The
-                # entry can't remove itself while its setup lock is held, so
-                # schedule the removal instead.
-                _LOGGER.debug(
-                    "Removing duplicate config entry %s for serial %s in favor of %s",
-                    config_entry.entry_id,
-                    serial_number,
-                    canonical.entry_id,
-                )
-                hass.async_create_task(
-                    hass.config_entries.async_remove(config_entry.entry_id)
-                )
+                # The canonical entry's migration will remove this duplicate.
                return False

            for duplicate in duplicates:
@@ -140,6 +140,10 @@ async def async_migrate_entry(
        "Migrating from version %s.%s", config_entry.version, config_entry.minor_version
    )

+    if config_entry.version > 1:
+        # This means the user has downgraded from a future version
+        return False
+
    if config_entry.version == 1:
        if config_entry.minor_version == 1:
            # Add-on startup with type service get started before
@@ -235,24 +239,7 @@ async def async_migrate_entry(
            )

            if canonical.entry_id != config_entry.entry_id:
-                if canonical.minor_version < 5:
-                    # The canonical entry has not been migrated yet and its
-                    # migration will remove this duplicate.
-                    return False
-
-                # The canonical entry is already fully migrated and will not run
-                # a migration that removes this duplicate, so remove it here. The
-                # entry can't remove itself while its setup lock is held, so
-                # schedule the removal instead.
-                _LOGGER.warning(
-                    "Removing duplicate config entry %s for serial %s in favor of %s",
-                    config_entry.entry_id,
-                    serial_number,
-                    canonical.entry_id,
-                )
-                hass.async_create_task(
-                    hass.config_entries.async_remove(config_entry.entry_id)
-                )
+                # The canonical entry's migration will remove this duplicate.
                return False

            for duplicate in duplicates:
@@ -126,6 +126,8 @@ async def async_migrate_entry(
    hass: HomeAssistant, config_entry: config_entries.ConfigEntry
 ) -> bool:
    """Migrate the config entry from version 1 to version 2."""
+    if config_entry.version > 2:
+        return False

    if config_entry.version == 1:
        _LOGGER.debug("Migrating HomematicIP Cloud config entry to version 2")
@@ -1,18 +1,10 @@
 """Common entity for Honeywell String Lights integration."""

-import logging
-
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import STATE_UNAVAILABLE
-from homeassistant.core import Event, EventStateChangedData, callback
-from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity import Entity
-from homeassistant.helpers.event import async_track_state_change_event

-from .const import CONF_TRANSMITTER, DOMAIN
-
-_LOGGER = logging.getLogger(__name__)
+from .const import DOMAIN


 class HoneywellStringLightsEntity(Entity):
@@ -22,53 +14,9 @@ class HoneywellStringLightsEntity(Entity):

    def __init__(self, entry: ConfigEntry) -> None:
        """Initialize the entity."""
-        self._transmitter = entry.data[CONF_TRANSMITTER]
        self._attr_unique_id = entry.entry_id
        self._attr_device_info = DeviceInfo(
            identifiers={(DOMAIN, entry.entry_id)},
            manufacturer="Honeywell",
            model="String Lights",
        )
-
-    async def async_added_to_hass(self) -> None:
-        """Subscribe to transmitter entity state changes."""
-        await super().async_added_to_hass()
-
-        transmitter_entity_id = er.async_validate_entity_id(
-            er.async_get(self.hass), self._transmitter
-        )
-
-        @callback
-        def _async_transmitter_state_changed(
-            event: Event[EventStateChangedData],
-        ) -> None:
-            """Handle transmitter entity state changes."""
-            new_state = event.data["new_state"]
-            transmitter_available = (
-                new_state is not None and new_state.state != STATE_UNAVAILABLE
-            )
-            if transmitter_available != self.available:
-                _LOGGER.info(
-                    "Transmitter %s used by %s is %s",
-                    transmitter_entity_id,
-                    self.entity_id,
-                    "available" if transmitter_available else "unavailable",
-                )
-
-                self._attr_available = transmitter_available
-                self.async_write_ha_state()
-
-        self.async_on_remove(
-            async_track_state_change_event(
-                self.hass,
-                [transmitter_entity_id],
-                _async_transmitter_state_changed,
-            )
-        )
-
-        # Set initial availability based on current transmitter entity state
-        transmitter_state = self.hass.states.get(transmitter_entity_id)
-        self._attr_available = (
-            transmitter_state is not None
-            and transmitter_state.state != STATE_UNAVAILABLE
-        )
@@ -5,13 +5,16 @@ from typing import Any
 from rf_protocols.codes.honeywell.string_lights import CODES

 from homeassistant.components.light import ColorMode, LightEntity
-from homeassistant.components.radio_frequency import async_send_command
+from homeassistant.components.radio_frequency import (
+    RadioFrequencyTransmitterConsumerEntity,
+)
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import STATE_ON
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.restore_state import RestoreEntity

+from .const import CONF_TRANSMITTER
 from .entity import HoneywellStringLightsEntity

 PARALLEL_UPDATES = 1
@@ -26,14 +29,23 @@ async def async_setup_entry(
    async_add_entities([HoneywellStringLight(config_entry)])


-class HoneywellStringLight(HoneywellStringLightsEntity, LightEntity, RestoreEntity):
+class HoneywellStringLight(
+    HoneywellStringLightsEntity,
+    RadioFrequencyTransmitterConsumerEntity,
+    LightEntity,
+    RestoreEntity,
+):
    """Representation of a Honeywell String Lights set controlled via RF."""

    _attr_assumed_state = True
    _attr_color_mode = ColorMode.ONOFF
    _attr_supported_color_modes = {ColorMode.ONOFF}
    _attr_name = None
-    _attr_should_poll = False
+
+    def __init__(self, entry: ConfigEntry) -> None:
+        """Initialize the entity."""
+        super().__init__(entry)
+        self._rf_transmitter_entity_id = entry.data[CONF_TRANSMITTER]

    async def async_added_to_hass(self) -> None:
        """Restore last known state."""
@@ -43,19 +55,17 @@ class HoneywellStringLight(HoneywellStringLightsEntity, LightEntity, RestoreEnti

    async def async_turn_on(self, **kwargs: Any) -> None:
        """Turn on the light."""
-        await self._async_send_command("turn_on")
+        await self._async_send_rf_command("turn_on")
        self._attr_is_on = True
        self.async_write_ha_state()

    async def async_turn_off(self, **kwargs: Any) -> None:
        """Turn off the light."""
-        await self._async_send_command("turn_off")
+        await self._async_send_rf_command("turn_off")
        self._attr_is_on = False
        self.async_write_ha_state()

-    async def _async_send_command(self, name: str) -> None:
+    async def _async_send_rf_command(self, name: str) -> None:
        """Load the named command and send it via the configured transmitter."""
        command = await CODES.async_load_command(name)
-        await async_send_command(
-            self.hass, self._transmitter, command, context=self._context
-        )
+        await self._send_command(command)
@@ -1,16 +1,9 @@
 """The coordinator for Hypontech Cloud integration."""

-import asyncio
 from dataclasses import dataclass
 from datetime import timedelta

-from hyponcloud import (
-    HyponCloud,
-    OverviewData,
-    PlantData,
-    PlantMonitorData,
-    RequestError,
-)
+from hyponcloud import HyponCloud, OverviewData, PlantData, RequestError

 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
@@ -19,20 +12,12 @@ from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, Upda
 from .const import DOMAIN, LOGGER


-@dataclass
-class HypontechPlant:
-    """Store a plant together with its real-time monitor data."""
-
-    info: PlantData
-    monitor: PlantMonitorData
-
-
@dataclass
 class HypontechCoordinatorData:
    """Store coordinator data."""

    overview: OverviewData
-    plants: dict[str, HypontechPlant]
+    plants: dict[str, PlantData]


 type HypontechConfigEntry = ConfigEntry[HypontechDataCoordinator]
@@ -65,17 +50,11 @@ class HypontechDataCoordinator(DataUpdateCoordinator[HypontechCoordinatorData]):
        try:
            overview = await self.api.get_overview()
            plants = await self.api.get_list()
-            monitors = await asyncio.gather(
-                *(self.api.get_monitor(plant.plant_id) for plant in plants)
-            )
        except RequestError as ex:
            raise UpdateFailed(
                translation_domain=DOMAIN, translation_key="connection_error"
            ) from ex
        return HypontechCoordinatorData(
            overview=overview,
-            plants={
-                plant.plant_id: HypontechPlant(info=plant, monitor=monitor)
-                for plant, monitor in zip(plants, monitors, strict=True)
-            },
+            plants={plant.plant_id: plant for plant in plants},
        )
@@ -1,10 +1,12 @@
 """Base entity for the Hypontech Cloud integration."""

+from hyponcloud import PlantData
+
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.update_coordinator import CoordinatorEntity

 from .const import DOMAIN
-from .coordinator import HypontechDataCoordinator, HypontechPlant
+from .coordinator import HypontechDataCoordinator


 class HypontechEntity(CoordinatorEntity[HypontechDataCoordinator]):
@@ -34,13 +36,12 @@ class HypontechPlantEntity(CoordinatorEntity[HypontechDataCoordinator]):
        plant = coordinator.data.plants[plant_id]
        self._attr_device_info = DeviceInfo(
            identifiers={(DOMAIN, plant_id)},
-            name=plant.info.plant_name,
+            name=plant.plant_name,
            manufacturer="Hypontech",
-            model=plant.info.plant_type,
        )

    @property
-    def plant(self) -> HypontechPlant:
+    def plant(self) -> PlantData:
        """Return the plant data."""
        return self.coordinator.data.plants[self.plant_id]

@@ -11,11 +11,11 @@ from homeassistant.components.sensor import (
    SensorEntityDescription,
    SensorStateClass,
 )
-from homeassistant.const import PERCENTAGE, UnitOfEnergy, UnitOfPower
+from homeassistant.const import UnitOfEnergy, UnitOfPower
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback

-from .coordinator import HypontechConfigEntry, HypontechDataCoordinator, HypontechPlant
+from .coordinator import HypontechConfigEntry, HypontechDataCoordinator
 from .entity import HypontechEntity, HypontechPlantEntity


@@ -36,8 +36,8 @@ class HypontechSensorDescription(SensorEntityDescription):
 class HypontechPlantSensorDescription(SensorEntityDescription):
    """Describes Hypontech plant sensor entity."""

-    value_fn: Callable[[HypontechPlant], float | None]
-    unit_fn: Callable[[HypontechPlant], str] | None = None
+    value_fn: Callable[[PlantData], float | None]
+    unit_fn: Callable[[PlantData], str] | None = None


 OVERVIEW_SENSORS: tuple[HypontechSensorDescription, ...] = (
@@ -67,24 +67,12 @@ OVERVIEW_SENSORS: tuple[HypontechSensorDescription, ...] = (
 )

 PLANT_SENSORS: tuple[HypontechPlantSensorDescription, ...] = (
-    # Historically keyed "pv_power" when total power was the only reading (no
-    # battery support). Now it carries the PV-only power from the monitor
-    # endpoint; the plant endpoint's total power is exposed as "total_power".
    HypontechPlantSensorDescription(
        key="pv_power",
-        translation_key="pv_power",
-        native_unit_of_measurement=UnitOfPower.WATT,
        device_class=SensorDeviceClass.POWER,
        state_class=SensorStateClass.MEASUREMENT,
-        value_fn=lambda c: c.monitor.power_pv,
-    ),
-    HypontechPlantSensorDescription(
-        key="total_power",
-        translation_key="total_power",
-        device_class=SensorDeviceClass.POWER,
-        state_class=SensorStateClass.MEASUREMENT,
-        value_fn=lambda c: c.info.power,
-        unit_fn=lambda c: _power_unit(c.info),
+        value_fn=lambda c: c.power,
+        unit_fn=_power_unit,
    ),
    HypontechPlantSensorDescription(
        key="lifetime_energy",
@@ -92,7 +80,7 @@ PLANT_SENSORS: tuple[HypontechPlantSensorDescription, ...] = (
        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
        device_class=SensorDeviceClass.ENERGY,
        state_class=SensorStateClass.TOTAL_INCREASING,
-        value_fn=lambda c: c.info.e_total,
+        value_fn=lambda c: c.e_total,
    ),
    HypontechPlantSensorDescription(
        key="today_energy",
@@ -100,44 +88,7 @@ PLANT_SENSORS: tuple[HypontechPlantSensorDescription, ...] = (
        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
        device_class=SensorDeviceClass.ENERGY,
        state_class=SensorStateClass.TOTAL_INCREASING,
-        value_fn=lambda c: c.info.e_today,
-    ),
-    HypontechPlantSensorDescription(
-        key="load_power",
-        translation_key="load_power",
-        native_unit_of_measurement=UnitOfPower.WATT,
-        device_class=SensorDeviceClass.POWER,
-        state_class=SensorStateClass.MEASUREMENT,
-        value_fn=lambda c: c.monitor.power_load,
-    ),
-    HypontechPlantSensorDescription(
-        key="grid_power",
-        translation_key="grid_power",
-        native_unit_of_measurement=UnitOfPower.WATT,
-        device_class=SensorDeviceClass.POWER,
-        state_class=SensorStateClass.MEASUREMENT,
-        value_fn=lambda c: c.monitor.meter_power,
-    ),
-)
-
-# Sensors only added for plants that have a battery (storage) system.
-BATTERY_SENSORS: tuple[HypontechPlantSensorDescription, ...] = (
-    HypontechPlantSensorDescription(
-        key="battery_power",
-        translation_key="battery_power",
-        native_unit_of_measurement=UnitOfPower.WATT,
-        device_class=SensorDeviceClass.POWER,
-        state_class=SensorStateClass.MEASUREMENT,
-        # Positive while the battery is discharging, negative while charging.
-        value_fn=lambda c: c.monitor.w_cha,
-    ),
-    HypontechPlantSensorDescription(
-        key="battery_state_of_charge",
-        translation_key="battery_state_of_charge",
-        native_unit_of_measurement=PERCENTAGE,
-        device_class=SensorDeviceClass.BATTERY,
-        state_class=SensorStateClass.MEASUREMENT,
-        value_fn=lambda c: c.monitor.soc,
+        value_fn=lambda c: c.e_today,
    ),
 )

@@ -154,15 +105,11 @@ async def async_setup_entry(
        HypontechOverviewSensor(coordinator, desc) for desc in OVERVIEW_SENSORS
    ]

-    for plant_id, plant in coordinator.data.plants.items():
-        entities.extend(
-            HypontechPlantSensor(coordinator, plant_id, desc) for desc in PLANT_SENSORS
-        )
-        if plant.info.plant_type.endswith("Storage"):
-            entities.extend(
-                HypontechPlantSensor(coordinator, plant_id, desc)
-                for desc in BATTERY_SENSORS
-            )
+    entities.extend(
+        HypontechPlantSensor(coordinator, plant_id, desc)
+        for plant_id in coordinator.data.plants
+        for desc in PLANT_SENSORS
+    )

    async_add_entities(entities)

@@ -36,29 +36,11 @@
  },
  "entity": {
    "sensor": {
-      "battery_power": {
-        "name": "Battery power"
-      },
-      "battery_state_of_charge": {
-        "name": "Battery state of charge"
-      },
-      "grid_power": {
-        "name": "Grid power"
-      },
      "lifetime_energy": {
        "name": "Lifetime energy"
      },
-      "load_power": {
-        "name": "Load power"
-      },
-      "pv_power": {
-        "name": "PV power"
-      },
      "today_energy": {
        "name": "Today energy"
-      },
-      "total_power": {
-        "name": "Total power"
      }
    }
  },
@@ -49,6 +49,9 @@ async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
        "Migrating from version %s.%s", config_entry.version, config_entry.minor_version
    )

+    if config_entry.version > 1:
+        # This means the user has downgraded from a future version
+        return False
    if config_entry.version == 1:
        options = {**config_entry.options}
        if config_entry.minor_version < 2:
@@ -52,6 +52,9 @@ async def async_migrate_entry(
    """Migrate old entry."""
    _LOGGER.debug("Migrating from version %s", config_entry.version)

+    if config_entry.version > 1:
+        # This means the user has downgraded from a future version
+        return False
    if config_entry.version == 1:
        new = {**config_entry.data}
        if config_entry.minor_version < 2:
@@ -2,7 +2,6 @@

 from typing import Any

-from homeassistant.const import CONF_URL
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import config_validation as cv, device_registry as dr
@@ -66,15 +65,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: JellyfinConfigEntry) ->
    return True


-async def async_migrate_entry(hass: HomeAssistant, entry: JellyfinConfigEntry) -> bool:
-    """Migrate an old config entry."""
-    if entry.version == 1 and entry.minor_version < 2:
-        new_data = {**entry.data, CONF_URL: entry.data[CONF_URL].rstrip("/")}
-        hass.config_entries.async_update_entry(entry, data=new_data, minor_version=2)
-
-    return True
-
-
 async def async_unload_entry(hass: HomeAssistant, entry: JellyfinConfigEntry) -> bool:
    """Unload a config entry."""
    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
@@ -46,7 +46,6 @@ class JellyfinConfigFlow(ConfigFlow, domain=DOMAIN):
    """Handle a config flow for Jellyfin."""

    VERSION = 1
-    MINOR_VERSION = 2

    def __init__(self) -> None:
        """Initialize the Jellyfin config flow."""
@@ -59,8 +58,6 @@ class JellyfinConfigFlow(ConfigFlow, domain=DOMAIN):
        errors: dict[str, str] = {}

        if user_input is not None:
-            user_input[CONF_URL] = user_input[CONF_URL].rstrip("/")
-
            if self.client_device_id is None:
                self.client_device_id = _generate_client_device_id()

@@ -131,6 +131,10 @@ async def async_migrate_entry(
            return {"new_unique_id": new_unique_id}
        return None

+    if config_entry.version > 2:
+        # This means the user has downgraded from a future version
+        return False
+
    if config_entry.version == 1:
        await er.async_migrate_entries(hass, config_entry.entry_id, update_unique_id)
        hass.config_entries.async_update_entry(config_entry, version=2)
@@ -2,14 +2,8 @@

 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.typing import ConfigType

-from .const import DOMAIN
 from .coordinator import KioskerConfigEntry, KioskerDataUpdateCoordinator
-from .services import async_setup_services
-
-CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)

 _PLATFORMS: list[Platform] = [
    Platform.BINARY_SENSOR,
@@ -19,12 +13,6 @@ _PLATFORMS: list[Platform] = [
 ]


-async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
-    """Set up the Kiosker integration."""
-    async_setup_services(hass)
-    return True
-
-
 async def async_setup_entry(hass: HomeAssistant, entry: KioskerConfigEntry) -> bool:
    """Set up Kiosker from a config entry."""

@@ -8,16 +8,3 @@ POLL_INTERVAL = 15
 DEFAULT_SSL = False
 DEFAULT_SSL_VERIFY = False
 REFRESH_DELAY = 0.5
-
-# Service attribute keys
-ATTR_URL = "url"
-ATTR_VISIBLE = "visible"
-ATTR_TEXT = "text"
-ATTR_BACKGROUND = "background"
-ATTR_FOREGROUND = "foreground"
-ATTR_EXPIRE = "expire"
-ATTR_DISMISSIBLE = "dismissible"
-ATTR_BUTTON_BACKGROUND = "button_background"
-ATTR_BUTTON_FOREGROUND = "button_foreground"
-ATTR_BUTTON_TEXT = "button_text"
-ATTR_SOUND = "sound"
@@ -65,13 +65,5 @@
        "default": "mdi:power-sleep"
      }
    }
-  },
-  "services": {
-    "navigate_url": {
-      "service": "mdi:web"
-    },
-    "set_blackout": {
-      "service": "mdi:monitor-off"
-    }
  }
 }
@@ -1,17 +1,23 @@
 rules:
  # Bronze
-  action-setup: done
+  action-setup:
+    status: exempt
+    comment: Integration does not register custom actions
  appropriate-polling: done
  brands: done
  common-modules: done
  config-flow-test-coverage: done
  config-flow: done
  dependency-transparency: done
-  docs-actions: done
+  docs-actions:
+    status: exempt
+    comment: Integration does not provide custom actions to document
  docs-high-level-description: done
  docs-installation-instructions: done
  docs-removal-instructions: done
-  entity-event-setup: done
+  entity-event-setup:
+    status: exempt
+    comment: Integration is polling-only and does not subscribe to external events
  entity-unique-id: done
  has-entity-name: done
  runtime-data: done
@@ -20,7 +26,9 @@ rules:
  unique-config-entry: done

  # Silver
-  action-exceptions: done
+  action-exceptions:
+    status: exempt
+    comment: Integration does not provide custom actions
  config-entry-unloading: done
  docs-configuration-parameters: done
  docs-installation-parameters: done
@@ -1,168 +0,0 @@
-"""Services for the Kiosker integration."""
-
-from collections.abc import Awaitable, Callable, Coroutine
-import functools
-from typing import Any
-
-from kiosker import (
-    AuthenticationError,
-    BadRequestError,
-    Blackout,
-    ConnectionError,
-    IPAuthenticationError,
-    TLSVerificationError,
-)
-import voluptuous as vol
-
-from homeassistant.config_entries import ConfigEntryState
-from homeassistant.const import ATTR_DEVICE_ID, ATTR_ICON
-from homeassistant.core import HomeAssistant, ServiceCall, ServiceResponse, callback
-from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
-from homeassistant.helpers import (
-    config_validation as cv,
-    device_registry as dr,
-    selector,
-)
-
-from .const import (
-    ATTR_BACKGROUND,
-    ATTR_BUTTON_BACKGROUND,
-    ATTR_BUTTON_FOREGROUND,
-    ATTR_BUTTON_TEXT,
-    ATTR_DISMISSIBLE,
-    ATTR_EXPIRE,
-    ATTR_FOREGROUND,
-    ATTR_SOUND,
-    ATTR_TEXT,
-    ATTR_URL,
-    ATTR_VISIBLE,
-    DOMAIN,
-)
-from .coordinator import KioskerDataUpdateCoordinator
-
-NAVIGATE_URL_SCHEMA = vol.Schema(
-    {
-        vol.Required(ATTR_DEVICE_ID): str,
-        vol.Required(ATTR_URL): str,
-    }
-)
-
-SET_BLACKOUT_SCHEMA = vol.Schema(
-    {
-        vol.Required(ATTR_DEVICE_ID): str,
-        vol.Optional(ATTR_VISIBLE, default=True): cv.boolean,
-        vol.Optional(ATTR_TEXT): str,
-        vol.Optional(ATTR_BACKGROUND, default=[0, 0, 0]): selector.ColorRGBSelector(),
-        vol.Optional(
-            ATTR_FOREGROUND, default=[255, 255, 255]
-        ): selector.ColorRGBSelector(),
-        vol.Optional(ATTR_ICON): str,
-        vol.Optional(ATTR_EXPIRE, default=60): vol.All(
-            vol.Coerce(int), vol.Range(min=0, max=100000)
-        ),
-        vol.Optional(ATTR_DISMISSIBLE, default=False): cv.boolean,
-        vol.Optional(
-            ATTR_BUTTON_BACKGROUND, default=[255, 255, 255]
-        ): selector.ColorRGBSelector(),
-        vol.Optional(
-            ATTR_BUTTON_FOREGROUND, default=[0, 0, 0]
-        ): selector.ColorRGBSelector(),
-        vol.Optional(ATTR_BUTTON_TEXT): str,
-        vol.Optional(ATTR_SOUND): str,
-    }
-)
-
-
-def handle_kiosker_api_errors(
-    func: Callable[[ServiceCall], Awaitable[None]],
-) -> Callable[[ServiceCall], Coroutine[Any, Any, ServiceResponse]]:
-    """Decorator to handle Kiosker API errors consistently across all service calls."""
-
-    @functools.wraps(func)
-    async def wrapper(call: ServiceCall) -> ServiceResponse:
-        try:
-            await func(call)
-        except ConnectionError as ex:
-            raise HomeAssistantError(f"Unable to connect to Kiosker: {ex}") from ex
-        except AuthenticationError as ex:
-            raise ServiceValidationError(
-                "Authentication failed. Check your API token."
-            ) from ex
-        except IPAuthenticationError as ex:
-            raise ServiceValidationError(
-                "IP authentication failed. Check your IP whitelist."
-            ) from ex
-        except TLSVerificationError as ex:
-            raise ServiceValidationError(f"TLS verification failed: {ex}") from ex
-        except BadRequestError as ex:
-            raise ServiceValidationError(f"Bad request: {ex}") from ex
-        else:
-            return None
-
-    return wrapper
-
-
-async def _get_coordinator(
-    call: ServiceCall,
-) -> KioskerDataUpdateCoordinator:
-    """Get the coordinator for the targeted device."""
-    registry = dr.async_get(call.hass)
-    device_id: str = call.data[ATTR_DEVICE_ID]
-    device = registry.async_get(device_id)
-
-    if device:
-        for entry_id in device.config_entries:
-            entry = call.hass.config_entries.async_get_entry(entry_id)
-            if entry and entry.domain == DOMAIN:
-                if entry.state != ConfigEntryState.LOADED:
-                    raise HomeAssistantError(f"{entry.title} is not loaded")
-                return entry.runtime_data
-
-    raise ServiceValidationError(f"No {DOMAIN} devices found in targeted selection")
-
-
-def _rgb_to_hex(rgb: list[int]) -> str:
-    """Convert an [r, g, b] list to a hex color string."""
-    return f"#{rgb[0]:02x}{rgb[1]:02x}{rgb[2]:02x}"
-
-
-@handle_kiosker_api_errors
-async def navigate_url(call: ServiceCall) -> None:
-    """Navigate to a URL on the Kiosker device."""
-    coordinator = await _get_coordinator(call)
-    await call.hass.async_add_executor_job(
-        coordinator.api.navigate_url, call.data[ATTR_URL]
-    )
-
-
-@handle_kiosker_api_errors
-async def set_blackout(call: ServiceCall) -> None:
-    """Set blackout mode on the Kiosker device."""
-    blackout = Blackout(
-        visible=call.data[ATTR_VISIBLE],
-        text=call.data.get(ATTR_TEXT),
-        background=_rgb_to_hex(call.data[ATTR_BACKGROUND]),
-        foreground=_rgb_to_hex(call.data[ATTR_FOREGROUND]),
-        icon=call.data.get(ATTR_ICON),
-        expire=call.data[ATTR_EXPIRE],
-        dismissible=call.data[ATTR_DISMISSIBLE],
-        buttonBackground=_rgb_to_hex(call.data[ATTR_BUTTON_BACKGROUND]),
-        buttonForeground=_rgb_to_hex(call.data[ATTR_BUTTON_FOREGROUND]),
-        buttonText=call.data.get(ATTR_BUTTON_TEXT),
-        sound=call.data.get(ATTR_SOUND),
-    )
-
-    coordinator = await _get_coordinator(call)
-    await call.hass.async_add_executor_job(coordinator.api.blackout_set, blackout)
-    await coordinator.async_request_refresh()
-
-
-@callback
-def async_setup_services(hass: HomeAssistant) -> None:
-    """Set up the services for the Kiosker integration."""
-    hass.services.async_register(
-        DOMAIN, "navigate_url", navigate_url, schema=NAVIGATE_URL_SCHEMA
-    )
-    hass.services.async_register(
-        DOMAIN, "set_blackout", set_blackout, schema=SET_BLACKOUT_SCHEMA
-    )
@@ -1,62 +0,0 @@
-navigate_url:
-  fields:
-    device_id:
-      required: true
-      selector:
-        device:
-          integration: kiosker
-    url:
-      required: true
-      selector:
-        text:
-
-set_blackout:
-  fields:
-    device_id:
-      required: true
-      selector:
-        device:
-          integration: kiosker
-    visible:
-      default: true
-      selector:
-        boolean:
-    text:
-      selector:
-        text:
-    background:
-      default: [0, 0, 0]
-      selector:
-        color_rgb:
-    foreground:
-      default: [255, 255, 255]
-      selector:
-        color_rgb:
-    icon:
-      selector:
-        text:
-    expire:
-      default: 60
-      selector:
-        number:
-          min: 0
-          max: 3600
-          unit_of_measurement: seconds
-    dismissible:
-      default: false
-      selector:
-        boolean:
-    button_background:
-      default: [255, 255, 255]
-      selector:
-        color_rgb:
-    button_foreground:
-      default: [0, 0, 0]
-      selector:
-        color_rgb:
-    button_text:
-      selector:
-        text:
-    sound:
-      selector:
-        text:
@@ -104,75 +104,5 @@
        "name": "Disable screensaver"
      }
    }
-  },
-  "services": {
-    "navigate_url": {
-      "description": "Navigate to a specific URL",
-      "fields": {
-        "device_id": {
-          "description": "The Kiosker device to control",
-          "name": "Device"
-        },
-        "url": {
-          "description": "The URL to navigate to",
-          "name": "URL"
-        }
-      },
-      "name": "Navigate to URL"
-    },
-    "set_blackout": {
-      "description": "Set blackout screen with custom message",
-      "fields": {
-        "background": {
-          "description": "Background color in rgb format",
-          "name": "Background color"
-        },
-        "button_background": {
-          "description": "Background color of the dismiss button in rgb format",
-          "name": "Button background color"
-        },
-        "button_foreground": {
-          "description": "Text color of the dismiss button in rgb format",
-          "name": "Button foreground color"
-        },
-        "button_text": {
-          "description": "Text to display on the dismiss button",
-          "name": "Button text"
-        },
-        "device_id": {
-          "description": "The Kiosker device to control",
-          "name": "Device"
-        },
-        "dismissible": {
-          "description": "Whether the blackout can be dismissed by user interaction",
-          "name": "Dismissible"
-        },
-        "expire": {
-          "description": "Time in seconds before the blackout expires",
-          "name": "Expire time"
-        },
-        "foreground": {
-          "description": "Text color in rgb format",
-          "name": "Foreground color"
-        },
-        "icon": {
-          "description": "Icon to display (SF Symbols name)",
-          "name": "Icon"
-        },
-        "sound": {
-          "description": "Sound to play when blackout is displayed (SystemSoundID, e.g., 1007)",
-          "name": "Sound"
-        },
-        "text": {
-          "description": "Text to display on blackout screen",
-          "name": "Text"
-        },
-        "visible": {
-          "description": "Whether the blackout is visible",
-          "name": "Visible"
-        }
-      },
-      "name": "Set blackout"
-    }
  }
 }
@@ -217,6 +217,9 @@ async def async_migrate_entry(
    hass: HomeAssistant, entry: LaMarzoccoConfigEntry
 ) -> bool:
    """Migrate config entry."""
+    if entry.version > 4:
+        # guard against downgrade from a future version
+        return False

    if entry.version in (1, 2):
        _LOGGER.error(
@@ -48,6 +48,9 @@ async def async_migrate_entry(
        entry.minor_version,
    )

+    if entry.version > 1:
+        return False
+
    if entry.minor_version < 2:
        account = Account(websession=async_get_clientsession(hass))
        try:
@@ -88,10 +88,13 @@ class LutronCasetaLight(LutronCasetaUpdatableEntity, LightEntity):
    """

    _attr_supported_features = LightEntityFeature.TRANSITION
-    _prev_brightness: int | None = None

    def __init__(self, light: dict[str, Any], data: LutronCasetaData) -> None:
-        """Initialize the light and set the supported color modes."""
+        """Initialize the light and set the supported color modes.
+
+        :param light: The lutron light device to initialize.
+        :param data: The integration data
+        """
        super().__init__(light, data)

        self._attr_min_color_temp_kelvin = self._get_min_color_temp_kelvin(light)
@@ -112,23 +115,28 @@ class LutronCasetaLight(LutronCasetaUpdatableEntity, LightEntity):
            DEVICE_TYPE_COLOR_TUNE,
        )

-        # Capture the initial brightness so _prev_brightness is correct on startup
-        self._sync_prev_brightness_from_device()
-
    def _get_min_color_temp_kelvin(self, light: dict[str, Any]) -> int:
-        """Return minimum supported color temperature."""
+        """Return minimum supported color temperature.
+
+        :param light: The light to get the minimum color temperature for.
+        """
        white_tune_range = light.get("white_tuning_range")
        # Default to 1.4k if not found
        if white_tune_range is None or "Min" not in white_tune_range:
            return 1400
+
        return white_tune_range.get("Min")

    def _get_max_color_temp_kelvin(self, light: dict[str, Any]) -> int:
-        """Return maximum supported color temperature."""
+        """Return maximum supported color temperature.
+
+        :param light: The light to get the maximum color temperature for.
+        """
        white_tune_range = light.get("white_tuning_range")
        # Default to 10k if not found
        if white_tune_range is None or "Max" not in white_tune_range:
            return 10000
+
        return white_tune_range.get("Max")

    @property
@@ -136,42 +144,20 @@ class LutronCasetaLight(LutronCasetaUpdatableEntity, LightEntity):
        """Return the brightness of the light."""
        return to_hass_level(self._device["current_state"])

-    def _sync_prev_brightness_from_device(self) -> None:
-        """Keep previous brightness in sync with device state."""
-        current_level = self._device.get("current_state")
-        if current_level is None:
-            return
-
-        hass_brightness = to_hass_level(current_level)
-        if hass_brightness > 0:
-            # Any non-zero brightness (HA or physical) becomes the new last level
-            self._prev_brightness = hass_brightness
-
-    async def async_update(self) -> None:
-        """Update when forcing a refresh of the device."""
-        await super().async_update()
-        self._sync_prev_brightness_from_device()
-
-    def _handle_bridge_update(self) -> None:
-        """Handle updated data from the bridge."""
-        self._sync_prev_brightness_from_device()
-        super()._handle_bridge_update()
-
    async def _async_set_brightness(
        self, brightness: int | None, color_value: LutronColorMode | None, **kwargs: Any
    ) -> None:
-        args: dict[str, Any] = {}
+        args = {}
        if ATTR_TRANSITION in kwargs:
            args["fade_time"] = timedelta(seconds=kwargs[ATTR_TRANSITION])

        if brightness is not None:
            brightness = to_lutron_level(brightness)
-
        await self._smartbridge.set_value(
            self.device_id, value=brightness, color_value=color_value, **args
        )

-    async def _async_set_warm_dim(self, brightness: int | None, **kwargs: Any) -> None:
+    async def _async_set_warm_dim(self, brightness: int | None, **kwargs: Any):
        """Set the light to warm dim mode."""
        set_warm_dim_kwargs: dict[str, Any] = {}
        if ATTR_TRANSITION in kwargs:
@@ -190,13 +176,10 @@ class LutronCasetaLight(LutronCasetaUpdatableEntity, LightEntity):
        """Turn the light on."""
        # first check for "white mode" (WarmDim)
        if (white_color := kwargs.get(ATTR_WHITE)) is not None:
-            # Only remember non-zero levels (see brightness handling below)
-            if white_color:
-                self._prev_brightness = white_color
            await self._async_set_warm_dim(white_color)
            return

-        # Parse the color first, so a color-only call can leave brightness alone
+        brightness = kwargs.pop(ATTR_BRIGHTNESS, None)
        color: LutronColorMode | None = None
        hs_color: tuple[float, float] | None = kwargs.pop(ATTR_HS_COLOR, None)
        kelvin_color: int | None = kwargs.pop(ATTR_COLOR_TEMP_KELVIN, None)
@@ -206,33 +189,20 @@ class LutronCasetaLight(LutronCasetaUpdatableEntity, LightEntity):
        elif kelvin_color is not None:
            color = WarmCoolColorValue(kelvin_color)

-        brightness: int | None
-        if ATTR_BRIGHTNESS in kwargs:
-            brightness = kwargs.pop(ATTR_BRIGHTNESS)
-            # Only remember non-zero levels, so a later turn-on without an
-            # explicit brightness never restores the light to "off"
-            if brightness:
-                self._prev_brightness = brightness
-        elif color is not None:
-            # Color-only change: pass None so the device keeps its brightness
-            brightness = None
-        elif self._prev_brightness is None:
-            # No history at all: default to full brightness
+        # if user is pressing on button nothing is set, so set brightness to 255
+        if color is None and brightness is None:
            brightness = 255
-        else:
-            # Restore the last known non-zero brightness
-            brightness = self._prev_brightness

        await self._async_set_brightness(brightness, color, **kwargs)

    async def async_turn_off(self, **kwargs: Any) -> None:
        """Turn the light off."""
-        # Do not touch _prev_brightness here; we want the last non-zero level to survive.
        await self._async_set_brightness(0, None, **kwargs)

    @property
    def color_mode(self) -> ColorMode:
        """Return the current color mode of the light."""
+
        currently_warm_dim = self._device.get("warm_dim", False)
        if self.supports_warm_dim and currently_warm_dim:
            return ColorMode.WHITE
@@ -99,6 +99,10 @@ async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
        config_entry.minor_version,
    )

+    if config_entry.version > 1:
+        # This means the user has downgraded from a future version
+        return False
+
    if config_entry.version == 1:
        if config_entry.minor_version < 2:
            # Remove the mold indicator config entry from the source device
@@ -467,6 +467,10 @@ async def async_migrate_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
    _LOGGER.debug("Migrating from version %s.%s", entry.version, entry.minor_version)
    data: dict[str, Any] = dict(entry.data)
    options: dict[str, Any] = dict(entry.options)
+    if entry.version > 2 or (entry.version == 2 and entry.minor_version > 1):
+        # This means the user has downgraded from a future version
+        # We allow read support for version 2.1
+        return False

    if entry.version == 1 and entry.minor_version < 2:
        # Can be removed when the config entry is bumped to version 2.1
@@ -44,6 +44,9 @@ async def async_migrate_entry(hass: HomeAssistant, entry: NinaConfigEntry) -> bo
    minor_version = entry.minor_version

    _LOGGER.debug("Migrating from version %s.%s", version, minor_version)
+    if entry.version > 1:
+        # This means the user has downgraded from a future version
+        return False

    new_data: dict[str, Any] = {**entry.data, CONF_FILTERS: {}}

@@ -116,6 +116,10 @@ async def async_migrate_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
        "Migrating configuration from version %s.%s", entry.version, entry.minor_version
    )

+    if entry.version > 1:
+        # This means the user has downgraded from a future version
+        return False
+
    if entry.version == 1:
        new_options = {**entry.options}
        if entry.minor_version < 2:
@@ -1,18 +1,10 @@
 """Common entity for the Novy Cooker Hood integration."""

-import logging
-
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import STATE_UNAVAILABLE
-from homeassistant.core import Event, EventStateChangedData, callback
-from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity import Entity
-from homeassistant.helpers.event import async_track_state_change_event

-from .const import CONF_TRANSMITTER, DOMAIN
-
-_LOGGER = logging.getLogger(__name__)
+from .const import DOMAIN


 class NovyCookerHoodEntity(Entity):
@@ -20,55 +12,11 @@ class NovyCookerHoodEntity(Entity):

    _attr_assumed_state = True
    _attr_has_entity_name = True
-    _attr_should_poll = False

    def __init__(self, entry: ConfigEntry) -> None:
        """Initialize the entity."""
-        self._transmitter = entry.data[CONF_TRANSMITTER]
        self._attr_device_info = DeviceInfo(
            identifiers={(DOMAIN, entry.entry_id)},
            manufacturer="Novy",
            model="Cooker Hood",
        )
-
-    async def async_added_to_hass(self) -> None:
-        """Subscribe to transmitter entity state changes."""
-        await super().async_added_to_hass()
-
-        transmitter_entity_id = er.async_validate_entity_id(
-            er.async_get(self.hass), self._transmitter
-        )
-
-        @callback
-        def _async_transmitter_state_changed(
-            event: Event[EventStateChangedData],
-        ) -> None:
-            """Handle transmitter entity state changes."""
-            new_state = event.data["new_state"]
-            transmitter_available = (
-                new_state is not None and new_state.state != STATE_UNAVAILABLE
-            )
-            if transmitter_available != self.available:
-                _LOGGER.info(
-                    "Transmitter %s used by %s is %s",
-                    transmitter_entity_id,
-                    self.entity_id,
-                    "available" if transmitter_available else "unavailable",
-                )
-
-                self._attr_available = transmitter_available
-                self.async_write_ha_state()
-
-        self.async_on_remove(
-            async_track_state_change_event(
-                self.hass,
-                [transmitter_entity_id],
-                _async_transmitter_state_changed,
-            )
-        )
-
-        transmitter_state = self.hass.states.get(transmitter_entity_id)
-        self._attr_available = (
-            transmitter_state is not None
-            and transmitter_state.state != STATE_UNAVAILABLE
-        )
@@ -4,10 +4,11 @@ import math
 from typing import Any

 from rf_protocols.codes.novy.cooker_hood import NovyCookerHoodButton
-from rf_protocols.commands.novy import NovyCookerHoodCommand

 from homeassistant.components.fan import ATTR_PERCENTAGE, FanEntity, FanEntityFeature
-from homeassistant.components.radio_frequency import async_send_command
+from homeassistant.components.radio_frequency import (
+    RadioFrequencyTransmitterConsumerEntity,
+)
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_CODE
 from homeassistant.core import HomeAssistant
@@ -18,7 +19,7 @@ from homeassistant.util.percentage import (
    ranged_value_to_percentage,
 )

-from .const import SPEED_COUNT
+from .const import CONF_TRANSMITTER, SPEED_COUNT
 from .entity import NovyCookerHoodEntity

 PARALLEL_UPDATES = 1
@@ -35,7 +36,12 @@ async def async_setup_entry(
    async_add_entities([NovyCookerHoodFan(config_entry)])


-class NovyCookerHoodFan(NovyCookerHoodEntity, FanEntity, RestoreEntity):
+class NovyCookerHoodFan(
+    NovyCookerHoodEntity,
+    RadioFrequencyTransmitterConsumerEntity,
+    FanEntity,
+    RestoreEntity,
+):
    """Calibration-based fan: each change resets to off then climbs to target."""

    _attr_name = None
@@ -49,6 +55,7 @@ class NovyCookerHoodFan(NovyCookerHoodEntity, FanEntity, RestoreEntity):
    def __init__(self, entry: ConfigEntry) -> None:
        """Initialize the fan."""
        super().__init__(entry)
+        self._rf_transmitter_entity_id = entry.data[CONF_TRANSMITTER]
        self._code: int = entry.data[CONF_CODE]
        self._level = 0
        self._attr_unique_id = entry.entry_id
@@ -105,7 +112,7 @@ class NovyCookerHoodFan(NovyCookerHoodEntity, FanEntity, RestoreEntity):
        steps = self._steps_from_percentage(percentage_step)
        plus = NovyCookerHoodButton.PLUS.to_command(channel=self._code)
        for _ in range(steps):
-            await self._async_send(plus)
+            await self._send_command(plus)
        self._level = min(SPEED_COUNT, self._level + steps)
        self.async_write_ha_state()

@@ -114,7 +121,7 @@ class NovyCookerHoodFan(NovyCookerHoodEntity, FanEntity, RestoreEntity):
        steps = self._steps_from_percentage(percentage_step)
        minus = NovyCookerHoodButton.MINUS.to_command(channel=self._code)
        for _ in range(steps):
-            await self._async_send(minus)
+            await self._send_command(minus)
        self._level = max(0, self._level - steps)
        self.async_write_ha_state()

@@ -129,16 +136,10 @@ class NovyCookerHoodFan(NovyCookerHoodEntity, FanEntity, RestoreEntity):
        """Reset to off with `SPEED_COUNT` minus presses, then climb to level."""
        minus = NovyCookerHoodButton.MINUS.to_command(channel=self._code)
        for _ in range(SPEED_COUNT):
-            await self._async_send(minus)
+            await self._send_command(minus)
        if level > 0:
            plus = NovyCookerHoodButton.PLUS.to_command(channel=self._code)
            for _ in range(level):
-                await self._async_send(plus)
+                await self._send_command(plus)
        self._level = level
        self.async_write_ha_state()
-
-    async def _async_send(self, command: NovyCookerHoodCommand) -> None:
-        """Send a single RF command via the configured transmitter."""
-        await async_send_command(
-            self.hass, self._transmitter, command, context=self._context
-        )
@@ -5,13 +5,16 @@ from typing import Any
 from rf_protocols.codes.novy.cooker_hood import NovyCookerHoodButton

 from homeassistant.components.light import ColorMode, LightEntity
-from homeassistant.components.radio_frequency import async_send_command
+from homeassistant.components.radio_frequency import (
+    RadioFrequencyTransmitterConsumerEntity,
+)
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_CODE, STATE_ON
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.restore_state import RestoreEntity

+from .const import CONF_TRANSMITTER
 from .entity import NovyCookerHoodEntity

 PARALLEL_UPDATES = 1
@@ -26,7 +29,12 @@ async def async_setup_entry(
    async_add_entities([NovyCookerHoodLight(config_entry)])


-class NovyCookerHoodLight(NovyCookerHoodEntity, LightEntity, RestoreEntity):
+class NovyCookerHoodLight(
+    NovyCookerHoodEntity,
+    RadioFrequencyTransmitterConsumerEntity,
+    LightEntity,
+    RestoreEntity,
+):
    """Novy cooker hood light toggled via a single RF press."""

    _attr_color_mode = ColorMode.ONOFF
@@ -36,6 +44,7 @@ class NovyCookerHoodLight(NovyCookerHoodEntity, LightEntity, RestoreEntity):
    def __init__(self, entry: ConfigEntry) -> None:
        """Initialize the light."""
        super().__init__(entry)
+        self._rf_transmitter_entity_id = entry.data[CONF_TRANSMITTER]
        self._code = entry.data[CONF_CODE]
        self._attr_unique_id = entry.entry_id

@@ -60,6 +69,4 @@ class NovyCookerHoodLight(NovyCookerHoodEntity, LightEntity, RestoreEntity):
    async def _async_send_light(self) -> None:
        """Send the light toggle command via the configured transmitter."""
        command = NovyCookerHoodButton.LIGHT.to_command(channel=self._code)
-        await async_send_command(
-            self.hass, self._transmitter, command, context=self._context
-        )
+        await self._send_command(command)
@@ -236,6 +236,10 @@ async def async_migrate_entry(hass: HomeAssistant, entry: OllamaConfigEntry) ->
    """Migrate entry."""
    _LOGGER.debug("Migrating from version %s:%s", entry.version, entry.minor_version)

+    if entry.version > 3:
+        # This means the user has downgraded from a future version
+        return False
+
    if entry.version == 2 and entry.minor_version == 1:
        # Correct broken device migration in Home Assistant Core 2025.7.0b0-2025.7.0b1
        device_registry = dr.async_get(hass)
@@ -133,6 +133,9 @@ async def _migrate_backup_files(client: OneDriveClient, backup_folder_id: str) -

 async def async_migrate_entry(hass: HomeAssistant, entry: OneDriveConfigEntry) -> bool:
    """Migrate old entry."""
+    if entry.version > 1:
+        # This means the user has downgraded from a future version
+        return False

    if (version := entry.version) == 1 and (minor_version := entry.minor_version) == 1:
        _LOGGER.debug(
@@ -63,6 +63,9 @@ async def async_migrate_entry(
    """Migrate config entry."""
    LOGGER.debug("Migrating from version %s.%s", entry.version, entry.minor_version)

+    if entry.version > 1 or (entry.version == 1 and entry.minor_version > 2):
+        return False
+
    if entry.version == 1 and entry.minor_version < 2:
        for subentry in entry.subentries.values():
            if CONF_WEB_SEARCH in subentry.data:
@@ -428,6 +428,10 @@ async def async_migrate_entry(hass: HomeAssistant, entry: OpenAIConfigEntry) ->
    """Migrate entry."""
    LOGGER.debug("Migrating from version %s:%s", entry.version, entry.minor_version)

+    if entry.version > 2:
+        # This means the user has downgraded from a future version
+        return False
+
    if entry.version == 2 and entry.minor_version == 1:
        # Correct broken device migration in Home Assistant Core 2025.7.0b0-2025.7.0b1
        device_registry = dr.async_get(hass)
@@ -40,7 +40,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: OpenEVSEConfigEntry) ->
    await coordinator.async_config_entry_first_refresh()

    # Start websocket listener for push updates
-    await coordinator.async_start_websocket()
+    coordinator.start_websocket()

    entry.runtime_data = coordinator

@@ -48,9 +48,9 @@ class OpenEVSEDataUpdateCoordinator(DataUpdateCoordinator[None]):
        """Handle websocket data update."""
        self.async_set_updated_data(None)

-    async def async_start_websocket(self) -> None:
+    def start_websocket(self) -> None:
        """Start the websocket listener."""
-        await self.charger.ws_start()
+        self.charger.ws_start()

    async def async_stop_websocket(self) -> None:
        """Stop the websocket listener."""
@@ -9,6 +9,6 @@
  "iot_class": "local_push",
  "loggers": ["openevsehttp"],
  "quality_scale": "bronze",
-  "requirements": ["python-openevse-http==1.0.1"],
+  "requirements": ["python-openevse-http==0.3.4"],
  "zeroconf": ["_openevse._tcp.local."]
 }
@@ -43,10 +43,10 @@ NUMBER_TYPES: tuple[OpenEVSENumberDescription, ...] = (
    OpenEVSENumberDescription(
        key="charge_rate",
        translation_key="charge_rate",
-        value_fn=lambda ev: ev.max_current_soft or 0,
-        min_value_fn=lambda ev: ev.min_amps or 0,
-        max_value_fn=lambda ev: ev.max_amps or 0,
-        set_value_fn=lambda ev, value: ev.set_current(int(value)),
+        value_fn=lambda ev: ev.max_current_soft,
+        min_value_fn=lambda ev: ev.min_amps,
+        max_value_fn=lambda ev: ev.max_amps,
+        set_value_fn=lambda ev, value: ev.set_current(value),
        native_step=1.0,
        entity_category=EntityCategory.CONFIG,
        native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
@@ -75,7 +75,7 @@ SENSOR_TYPES: tuple[OpenEVSESensorDescription, ...] = (
            "1": "level_1",
            "2": "level_2",
            "a": "automatic",
-        }.get(str(ev.service_level).lower()),
+        }.get(ev.service_level.lower()),
        entity_category=EntityCategory.DIAGNOSTIC,
        entity_registry_enabled_default=False,
    ),
@@ -201,6 +201,8 @@ async def async_migrate_entry(
    hass: HomeAssistant, entry: OverkizDataConfigEntry
 ) -> bool:
    """Migrate old entry."""
+    if entry.version > 1:
+        return False

    if entry.version == 1 and entry.minor_version < 2:
        await _async_migrate_strenum_unique_ids(hass, entry)
@@ -113,36 +113,6 @@ class OVHcloudAIEndpointsConfigFlow(ConfigFlow, domain=DOMAIN):
            errors=errors,
        )

-    async def async_step_reconfigure(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Reconfigure the API key on an existing entry."""
-        errors: dict[str, str] = {}
-        entry = self._get_reconfigure_entry()
-        if user_input is not None:
-            self._async_abort_entries_match(user_input)
-            client = _create_client(self.hass, user_input[CONF_API_KEY])
-            try:
-                await _validate_api_key(client)
-            except AuthenticationError, PermissionDeniedError:
-                errors["base"] = "invalid_auth"
-            except OpenAIError:
-                errors["base"] = "cannot_connect"
-            except Exception:
-                _LOGGER.exception("Unexpected exception")
-                errors["base"] = "unknown"
-            else:
-                return self.async_update_reload_and_abort(
-                    entry, data_updates=user_input
-                )
-        return self.async_show_form(
-            step_id="reconfigure",
-            data_schema=self.add_suggested_values_to_schema(
-                STEP_REAUTH_DATA_SCHEMA, user_input or entry.data
-            ),
-            errors=errors,
-        )
-

 class ConversationFlowHandler(ConfigSubentryFlow):
    """Handle conversation subentry flow."""
@@ -166,51 +136,6 @@ class ConversationFlowHandler(ConfigSubentryFlow):
        self.options = RECOMMENDED_CONVERSATION_OPTIONS.copy()
        return await self.async_step_init(user_input)

-    async def async_step_reconfigure(
-        self, user_input: dict[str, Any] | None = None
-    ) -> SubentryFlowResult:
-        """Reconfigure a conversation agent (prompt + LLM APIs; model is fixed)."""
-        subentry = self._get_reconfigure_subentry()
-        existing = subentry.data
-
-        if user_input is not None:
-            if not user_input.get(CONF_LLM_HASS_API):
-                user_input.pop(CONF_LLM_HASS_API, None)
-            user_input[CONF_MODEL] = existing[CONF_MODEL]
-            return self.async_update_and_abort(
-                self._get_entry(), subentry, data=user_input
-            )
-
-        hass_apis: list[SelectOptionDict] = [
-            SelectOptionDict(label=api.name, value=api.id)
-            for api in llm.async_get_apis(self.hass)
-        ]
-        return self.async_show_form(
-            step_id="reconfigure",
-            data_schema=vol.Schema(
-                {
-                    vol.Optional(
-                        CONF_PROMPT,
-                        description={
-                            "suggested_value": existing.get(
-                                CONF_PROMPT,
-                                RECOMMENDED_CONVERSATION_OPTIONS[CONF_PROMPT],
-                            )
-                        },
-                    ): TemplateSelector(),
-                    vol.Optional(
-                        CONF_LLM_HASS_API,
-                        default=existing.get(
-                            CONF_LLM_HASS_API,
-                            RECOMMENDED_CONVERSATION_OPTIONS[CONF_LLM_HASS_API],
-                        ),
-                    ): SelectSelector(
-                        SelectSelectorConfig(options=hass_apis, multiple=True)
-                    ),
-                }
-            ),
-        )
-
    async def async_step_init(
        self, user_input: dict[str, Any] | None = None
    ) -> SubentryFlowResult:
@@ -82,7 +82,7 @@ rules:
    comment: conversation entity name comes from subentry title
  exception-translations: todo
  icon-translations: todo
-  reconfiguration-flow: done
+  reconfiguration-flow: todo
  repair-issues:
    status: exempt
    comment: the integration has no repairs
@@ -2,8 +2,7 @@
  "config": {
    "abort": {
      "already_configured": "[%key:common::config_flow::abort::already_configured_service%]",
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
-      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]"
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
    },
    "error": {
      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
@@ -20,15 +19,6 @@
        },
        "description": "The OVHcloud AI Endpoints API key is no longer valid. Please enter a new one."
      },
-      "reconfigure": {
-        "data": {
-          "api_key": "[%key:common::config_flow::data::api_key%]"
-        },
-        "data_description": {
-          "api_key": "[%key:component::ovhcloud_ai_endpoints::config::step::user::data_description::api_key%]"
-        },
-        "description": "Update the API key used to authenticate with OVHcloud AI Endpoints."
-      },
      "user": {
        "data": {
          "api_key": "[%key:common::config_flow::data::api_key%]"
@@ -44,7 +34,6 @@
      "abort": {
        "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
        "entry_not_loaded": "The main integration entry is not loaded. Please ensure the integration is loaded before configuring.",
-        "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",
        "unknown": "[%key:common::config_flow::error::unknown%]"
      },
      "entry_type": "Conversation agent",
@@ -64,17 +53,6 @@
            "prompt": "Instruct how the LLM should respond. This can be a template."
          },
          "description": "Configure the conversation agent"
-        },
-        "reconfigure": {
-          "data": {
-            "llm_hass_api": "[%key:common::config_flow::data::llm_hass_api%]",
-            "prompt": "[%key:common::config_flow::data::prompt%]"
-          },
-          "data_description": {
-            "llm_hass_api": "[%key:component::ovhcloud_ai_endpoints::config_subentries::conversation::step::init::data_description::llm_hass_api%]",
-            "prompt": "[%key:component::ovhcloud_ai_endpoints::config_subentries::conversation::step::init::data_description::prompt%]"
-          },
-          "description": "Update the prompt and Home Assistant LLM APIs for this conversation agent. Create a new conversation agent to use a different model."
        }
      }
    }
@@ -6,22 +6,24 @@ import logging
 from rf_protocols import ModulationType, RadioFrequencyCommand

 from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import Context, HomeAssistant, callback
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import config_validation as cv, entity_registry as er
+from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.typing import ConfigType
-from homeassistant.util.hass_dict import HassKey

-from .const import DOMAIN
+from .const import DATA_COMPONENT, DOMAIN
 from .entity import (
    RadioFrequencyTransmitterEntity,
    RadioFrequencyTransmitterEntityDescription,
 )
+from .helpers import RadioFrequencyTransmitterConsumerEntity, async_send_command

 __all__ = [
    "DOMAIN",
    "ModulationType",
+    "RadioFrequencyCommand",
+    "RadioFrequencyTransmitterConsumerEntity",
    "RadioFrequencyTransmitterEntity",
    "RadioFrequencyTransmitterEntityDescription",
    "async_get_transmitters",
@@ -30,9 +32,6 @@ __all__ = [

 _LOGGER = logging.getLogger(__name__)

-DATA_COMPONENT: HassKey[EntityComponent[RadioFrequencyTransmitterEntity]] = HassKey(
-    DOMAIN
-)
 ENTITY_ID_FORMAT = DOMAIN + ".{}"
 PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA
 PLATFORM_SCHEMA_BASE = cv.PLATFORM_SCHEMA_BASE
@@ -95,60 +94,3 @@ def async_get_transmitters(
        if entity.supports_modulation(modulation)
        and entity.supports_frequency(frequency)
    ]
-
-
-async def async_send_command(
-    hass: HomeAssistant,
-    entity_id_or_uuid: str,
-    command: RadioFrequencyCommand,
-    context: Context | None = None,
-) -> None:
-    """Send an RF command to the specified radio_frequency entity.
-
-    Raises:
-        vol.Invalid: If `entity_id_or_uuid` is not a valid entity ID or known entity
-            registry UUID.
-        HomeAssistantError: If the radio_frequency component is not loaded or the
-            resolved entity is not found.
-    """
-    component = hass.data.get(DATA_COMPONENT)
-    if component is None:
-        raise HomeAssistantError(
-            translation_domain=DOMAIN,
-            translation_key="component_not_loaded",
-        )
-
-    ent_reg = er.async_get(hass)
-    entity_id = er.async_validate_entity_id(ent_reg, entity_id_or_uuid)
-    entity = component.get_entity(entity_id)
-    if entity is None:
-        raise HomeAssistantError(
-            translation_domain=DOMAIN,
-            translation_key="entity_not_found",
-            translation_placeholders={"entity_id": entity_id},
-        )
-
-    if not entity.supports_frequency(command.frequency):
-        raise HomeAssistantError(
-            translation_domain=DOMAIN,
-            translation_key="unsupported_frequency",
-            translation_placeholders={
-                "entity_id": entity_id,
-                "frequency": str(command.frequency),
-            },
-        )
-
-    if not entity.supports_modulation(command.modulation):
-        raise HomeAssistantError(
-            translation_domain=DOMAIN,
-            translation_key="unsupported_modulation",
-            translation_placeholders={
-                "entity_id": entity_id,
-                "modulation": command.modulation,
-            },
-        )
-
-    if context is not None:
-        entity.async_set_context(context)
-
-    await entity.async_send_command_internal(command)
@@ -2,4 +2,12 @@

 from typing import Final

+from homeassistant.helpers.entity_component import EntityComponent
+from homeassistant.util.hass_dict import HassKey
+
+from .entity import RadioFrequencyTransmitterEntity
+
 DOMAIN: Final = "radio_frequency"
+DATA_COMPONENT: HassKey[EntityComponent[RadioFrequencyTransmitterEntity]] = HassKey(
+    DOMAIN
+)
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
copilot-swe-agent[bot]	987f126351	Merge branch 'dev' into radio-frequency-consumer-entity	2026-06-08 02:59:41 +00:00
copilot-swe-agent[bot]	e08ba030a0	Merge branch 'dev' into radio-frequency-consumer-entity Co-authored-by: piitaya <5878303+piitaya@users.noreply.github.com>	2026-05-21 13:35:41 +00:00
Paulus Schoutsen	ba9504a70d	Migrate honeywell_string_lights and novy_cooker_hood to use RadioFrequencyTransmitterConsumerEntity Replace hand-rolled availability tracking in both integrations with the new RadioFrequencyTransmitterConsumerEntity base class. The base entity classes now only provide device info. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-05-17 16:27:32 -04:00
Paulus Schoutsen	5c5d9828f8	Add helper consumer entity for radio_frequency Move DATA_COMPONENT to const.py, move async_send_command to a new helpers.py, and add RadioFrequencyTransmitterConsumerEntity base class that tracks the availability of the underlying RF transmitter entity. Mirrors the refactoring done for the infrared integration in #170854. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-05-17 16:23:55 -04:00