Remove unused check availability method and fix tests

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: Erik Montnemery <erik@montnemery.com>

.github/workflows/builder.yml

@@ -196,7 +196,7 @@ jobs:
           echo "${GITHUB_SHA};${GITHUB_REF};${GITHUB_EVENT_NAME};${GITHUB_ACTOR}" > rootfs/OFFICIAL_IMAGE
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
+        uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.0
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
@@ -328,7 +328,7 @@ jobs:
           fi
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
+        uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.0
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
@@ -406,13 +406,13 @@ jobs:
 
       - name: Login to DockerHub
         if: matrix.registry == 'docker.io/homeassistant'
-        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
+        uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.0
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
+        uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.0
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
@@ -585,7 +585,7 @@ jobs:
           persist-credentials: false
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
+        uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.0
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}

.github/workflows/ci.yaml

@@ -609,7 +609,7 @@ jobs:
         with:
           persist-credentials: false
       - name: Dependency review
-        uses: actions/dependency-review-action@05fe4576374b728f0c523d6a13d64c25081e0803 # v4.8.3
+        uses: actions/dependency-review-action@2031cfc080254a8a887f58cffee85186f0e49e48 # v4.9.0
         with:
           license-check: false # We use our own license audit checks
 

.strict-typing

@@ -342,6 +342,7 @@ homeassistant.components.lookin.*
 homeassistant.components.lovelace.*
 homeassistant.components.luftdaten.*
 homeassistant.components.lunatone.*
+homeassistant.components.lutron.*
 homeassistant.components.madvr.*
 homeassistant.components.manual.*
 homeassistant.components.mastodon.*

CODEOWNERS

@@ -577,6 +577,8 @@ build.json @home-assistant/supervisor
 /tests/components/garages_amsterdam/ @klaasnicolaas
 /homeassistant/components/gardena_bluetooth/ @elupus
 /tests/components/gardena_bluetooth/ @elupus
+/homeassistant/components/gate/ @home-assistant/core
+/tests/components/gate/ @home-assistant/core
 /homeassistant/components/gdacs/ @exxamalte
 /tests/components/gdacs/ @exxamalte
 /homeassistant/components/generic/ @davet2001
@@ -743,6 +745,8 @@ build.json @home-assistant/supervisor
 /tests/components/huisbaasje/ @dennisschroer
 /homeassistant/components/humidifier/ @home-assistant/core @Shulyaka
 /tests/components/humidifier/ @home-assistant/core @Shulyaka
+/homeassistant/components/humidity/ @home-assistant/core
+/tests/components/humidity/ @home-assistant/core
 /homeassistant/components/hunterdouglas_powerview/ @bdraco @kingy444 @trullock
 /tests/components/hunterdouglas_powerview/ @bdraco @kingy444 @trullock
 /homeassistant/components/husqvarna_automower/ @Thomas55555

homeassistant/bootstrap.py

@@ -243,6 +243,8 @@ DEFAULT_INTEGRATIONS = {
     # Integrations providing triggers and conditions for base platforms:
     "door",
     "garage_door",
+    "gate",
+    "humidity",
 }
 DEFAULT_INTEGRATIONS_RECOVERY_MODE = {
     # These integrations are set up if recovery mode is activated.

homeassistant/components/adax/climate.py

@@ -168,29 +168,57 @@ class LocalAdaxDevice(CoordinatorEntity[AdaxLocalCoordinator], ClimateEntity):
         if hvac_mode == HVACMode.HEAT:
             temperature = self._attr_target_temperature or self._attr_min_temp
             await self._adax_data_handler.set_target_temperature(temperature)
+            self._attr_target_temperature = temperature
+            self._attr_icon = "mdi:radiator"
         elif hvac_mode == HVACMode.OFF:
             await self._adax_data_handler.set_target_temperature(0)
+            self._attr_icon = "mdi:radiator-off"
+        else:
+            # Ignore unsupported HVAC modes to avoid desynchronizing entity state
+            # from the physical device.
+            return
+
+        self._attr_hvac_mode = hvac_mode
+        self.async_write_ha_state()
 
     async def async_set_temperature(self, **kwargs: Any) -> None:
         """Set new target temperature."""
         if (temperature := kwargs.get(ATTR_TEMPERATURE)) is None:
             return
-        await self._adax_data_handler.set_target_temperature(temperature)
+        if self._attr_hvac_mode == HVACMode.HEAT:
+            await self._adax_data_handler.set_target_temperature(temperature)
 
-    @callback
-    def _handle_coordinator_update(self) -> None:
-        """Handle updated data from the coordinator."""
+        self._attr_target_temperature = temperature
+        self.async_write_ha_state()
+
+    def _update_hvac_attributes(self) -> None:
+        """Update hvac mode and temperatures from coordinator data.
+
+        The coordinator reports a target temperature of 0 when the heater is
+        turned off. In that case, only the hvac mode and icon are updated and
+        the previous non-zero target temperature is preserved. When the
+        reported target temperature is non-zero, the stored target temperature
+        is updated to match the coordinator value.
+        """
         if data := self.coordinator.data:
             self._attr_current_temperature = data["current_temperature"]
-            self._attr_available = self._attr_current_temperature is not None
             if (target_temp := data["target_temperature"]) == 0:
                 self._attr_hvac_mode = HVACMode.OFF
                 self._attr_icon = "mdi:radiator-off"
-                if target_temp == 0:
+                if self._attr_target_temperature is None:
                     self._attr_target_temperature = self._attr_min_temp
             else:
                 self._attr_hvac_mode = HVACMode.HEAT
                 self._attr_icon = "mdi:radiator"
                 self._attr_target_temperature = target_temp
 
+    @callback
+    def _handle_coordinator_update(self) -> None:
+        """Handle updated data from the coordinator."""
+        self._update_hvac_attributes()
         super()._handle_coordinator_update()
+
+    async def async_added_to_hass(self) -> None:
+        """When entity is added to hass."""
+        await super().async_added_to_hass()
+        self._update_hvac_attributes()

homeassistant/components/alexa_devices/switch.py

@@ -101,7 +101,10 @@ class AmazonSwitchEntity(AmazonEntity, SwitchEntity):
             assert method is not None
 
         await method(self.device, state)
-        await self.coordinator.async_request_refresh()
+        self.coordinator.data[self.device.serial_number].sensors[
+            self.entity_description.key
+        ].value = state
+        self.async_write_ha_state()
 
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Turn the switch on."""

homeassistant/components/anglian_water/sensor.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from collections.abc import Callable
 from dataclasses import dataclass
+from datetime import datetime
 from enum import StrEnum
 
 from pyanglianwater.meter import SmartMeter
@@ -32,13 +33,14 @@ class AnglianWaterSensor(StrEnum):
     YESTERDAY_WATER_COST = "yesterday_water_cost"
     YESTERDAY_SEWERAGE_COST = "yesterday_sewerage_cost"
     LATEST_READING = "latest_reading"
+    LAST_UPDATED = "last_updated"
 
 
 @dataclass(frozen=True, kw_only=True)
 class AnglianWaterSensorEntityDescription(SensorEntityDescription):
     """Describes AnglianWater sensor entity."""
 
-    value_fn: Callable[[SmartMeter], float]
+    value_fn: Callable[[SmartMeter], float | datetime | None]
 
 
 ENTITY_DESCRIPTIONS: tuple[AnglianWaterSensorEntityDescription, ...] = (
@@ -76,6 +78,13 @@ ENTITY_DESCRIPTIONS: tuple[AnglianWaterSensorEntityDescription, ...] = (
         translation_key=AnglianWaterSensor.YESTERDAY_SEWERAGE_COST,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
+    AnglianWaterSensorEntityDescription(
+        key=AnglianWaterSensor.LAST_UPDATED,
+        device_class=SensorDeviceClass.TIMESTAMP,
+        value_fn=lambda entity: entity.last_updated,
+        translation_key=AnglianWaterSensor.LAST_UPDATED,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
 )
 
 
@@ -112,6 +121,6 @@ class AnglianWaterSensorEntity(AnglianWaterEntity, SensorEntity):
         self.entity_description = description
 
     @property
-    def native_value(self) -> float | None:
+    def native_value(self) -> float | datetime | None:
         """Return the state of the sensor."""
         return self.entity_description.value_fn(self.smart_meter)

homeassistant/components/anglian_water/strings.json

@@ -34,6 +34,9 @@
   },
   "entity": {
     "sensor": {
+      "last_updated": {
+        "name": "Last meter reading processed"
+      },
       "latest_reading": {
         "name": "Latest reading"
       },

homeassistant/components/arcam_fmj/__init__.py

@@ -8,19 +8,11 @@ from typing import Any
 from arcam.fmj import ConnectionFailed
 from arcam.fmj.client import Client
 
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_HOST, CONF_PORT, Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers.dispatcher import async_dispatcher_send
 
-from .const import (
-    DEFAULT_SCAN_INTERVAL,
-    SIGNAL_CLIENT_DATA,
-    SIGNAL_CLIENT_STARTED,
-    SIGNAL_CLIENT_STOPPED,
-)
-
-type ArcamFmjConfigEntry = ConfigEntry[Client]
+from .const import DEFAULT_SCAN_INTERVAL
+from .coordinator import ArcamFmjConfigEntry, ArcamFmjCoordinator, ArcamFmjRuntimeData
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -30,24 +22,41 @@ PLATFORMS = [Platform.MEDIA_PLAYER]
 
 async def async_setup_entry(hass: HomeAssistant, entry: ArcamFmjConfigEntry) -> bool:
     """Set up config entry."""
-    entry.runtime_data = Client(entry.data[CONF_HOST], entry.data[CONF_PORT])
+    client = Client(entry.data[CONF_HOST], entry.data[CONF_PORT])
+
+    coordinators: dict[int, ArcamFmjCoordinator] = {}
+    for zone in (1, 2):
+        coordinator = ArcamFmjCoordinator(hass, entry, client, zone)
+        coordinators[zone] = coordinator
+
+    entry.runtime_data = ArcamFmjRuntimeData(client, coordinators)
 
     entry.async_create_background_task(
-        hass, _run_client(hass, entry.runtime_data, DEFAULT_SCAN_INTERVAL), "arcam_fmj"
+        hass,
+        _run_client(hass, entry.runtime_data, DEFAULT_SCAN_INTERVAL),
+        "arcam_fmj",
     )
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_unload_entry(hass: HomeAssistant, entry: ArcamFmjConfigEntry) -> bool:
     """Cleanup before removing config entry."""
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
 
 
-async def _run_client(hass: HomeAssistant, client: Client, interval: float) -> None:
+async def _run_client(
+    hass: HomeAssistant,
+    runtime_data: ArcamFmjRuntimeData,
+    interval: float,
+) -> None:
+    client = runtime_data.client
+    coordinators = runtime_data.coordinators
+
     def _listen(_: Any) -> None:
-        async_dispatcher_send(hass, SIGNAL_CLIENT_DATA, client.host)
+        for coordinator in coordinators.values():
+            coordinator.async_notify_data_updated()
 
     while True:
         try:
@@ -55,16 +64,21 @@ async def _run_client(hass: HomeAssistant, client: Client, interval: float) -> N
                 await client.start()
 
             _LOGGER.debug("Client connected %s", client.host)
-            async_dispatcher_send(hass, SIGNAL_CLIENT_STARTED, client.host)
 
             try:
+                for coordinator in coordinators.values():
+                    await coordinator.state.start()
+
                 with client.listen(_listen):
+                    for coordinator in coordinators.values():
+                        coordinator.async_notify_connected()
                     await client.process()
             finally:
                 await client.stop()
 
                 _LOGGER.debug("Client disconnected %s", client.host)
-                async_dispatcher_send(hass, SIGNAL_CLIENT_STOPPED, client.host)
+                for coordinator in coordinators.values():
+                    coordinator.async_notify_disconnected()
 
         except ConnectionFailed:
             await asyncio.sleep(interval)

homeassistant/components/arcam_fmj/const.py

@@ -2,10 +2,6 @@
 
 DOMAIN = "arcam_fmj"
 
-SIGNAL_CLIENT_STARTED = "arcam.client_started"
-SIGNAL_CLIENT_STOPPED = "arcam.client_stopped"
-SIGNAL_CLIENT_DATA = "arcam.client_data"
-
 EVENT_TURN_ON = "arcam_fmj.turn_on"
 
 DEFAULT_PORT = 50000

homeassistant/components/arcam_fmj/coordinator.py

@@ -0,0 +1,96 @@
+"""Coordinator for Arcam FMJ integration."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import logging
+
+from arcam.fmj import ConnectionFailed
+from arcam.fmj.client import Client
+from arcam.fmj.state import State
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+
+@dataclass
+class ArcamFmjRuntimeData:
+    """Runtime data for Arcam FMJ integration."""
+
+    client: Client
+    coordinators: dict[int, ArcamFmjCoordinator]
+
+
+type ArcamFmjConfigEntry = ConfigEntry[ArcamFmjRuntimeData]
+
+
+class ArcamFmjCoordinator(DataUpdateCoordinator[None]):
+    """Coordinator for a single Arcam FMJ zone."""
+
+    config_entry: ArcamFmjConfigEntry
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        config_entry: ArcamFmjConfigEntry,
+        client: Client,
+        zone: int,
+    ) -> None:
+        """Initialize the coordinator."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            config_entry=config_entry,
+            name=f"Arcam FMJ zone {zone}",
+        )
+        self.client = client
+        self.state = State(client, zone)
+        self.last_update_success = False
+
+        name = config_entry.title
+        unique_id = config_entry.unique_id or config_entry.entry_id
+        unique_id_device = unique_id
+        if zone != 1:
+            unique_id_device += f"-{zone}"
+            name += f" Zone {zone}"
+
+        self.device_info = DeviceInfo(
+            identifiers={(DOMAIN, unique_id_device)},
+            manufacturer="Arcam",
+            model="Arcam FMJ AVR",
+            name=name,
+        )
+
+        if zone != 1:
+            self.device_info["via_device"] = (DOMAIN, unique_id)
+
+    async def _async_update_data(self) -> None:
+        """Fetch data for manual refresh."""
+        try:
+            await self.state.update()
+        except ConnectionFailed as err:
+            raise UpdateFailed(
+                f"Connection failed during update for zone {self.state.zn}"
+            ) from err
+
+    @callback
+    def async_notify_data_updated(self) -> None:
+        """Notify that new data has been received from the device."""
+        self.async_set_updated_data(None)
+
+    @callback
+    def async_notify_connected(self) -> None:
+        """Handle client connected."""
+        self.hass.async_create_task(self.async_refresh())
+
+    @callback
+    def async_notify_disconnected(self) -> None:
+        """Handle client disconnected."""
+        self.last_update_success = False
+        self.async_update_listeners()

homeassistant/components/arcam_fmj/media_player.py

@@ -8,7 +8,6 @@ import logging
 from typing import Any
 
 from arcam.fmj import ConnectionFailed, SourceCodes
-from arcam.fmj.state import State
 
 from homeassistant.components.media_player import (
     BrowseError,
@@ -20,20 +19,13 @@ from homeassistant.components.media_player import (
     MediaType,
 )
 from homeassistant.const import ATTR_ENTITY_ID
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from . import ArcamFmjConfigEntry
-from .const import (
-    DOMAIN,
-    EVENT_TURN_ON,
-    SIGNAL_CLIENT_DATA,
-    SIGNAL_CLIENT_STARTED,
-    SIGNAL_CLIENT_STOPPED,
-)
+from .const import EVENT_TURN_ON
+from .coordinator import ArcamFmjConfigEntry, ArcamFmjCoordinator
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -44,19 +36,17 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the configuration entry."""
-
-    client = config_entry.runtime_data
+    coordinators = config_entry.runtime_data.coordinators
 
     async_add_entities(
         [
             ArcamFmj(
                 config_entry.title,
-                State(client, zone),
+                coordinators[zone],
                 config_entry.unique_id or config_entry.entry_id,
             )
             for zone in (1, 2)
         ],
-        True,
     )
 
 
@@ -77,21 +67,21 @@ def convert_exception[**_P, _R](
     return _convert_exception
 
 
-class ArcamFmj(MediaPlayerEntity):
+class ArcamFmj(CoordinatorEntity[ArcamFmjCoordinator], MediaPlayerEntity):
     """Representation of a media device."""
 
-    _attr_should_poll = False
     _attr_has_entity_name = True
 
     def __init__(
         self,
         device_name: str,
-        state: State,
+        coordinator: ArcamFmjCoordinator,
         uuid: str,
     ) -> None:
         """Initialize device."""
-        self._state = state
-        self._attr_name = f"Zone {state.zn}"
+        super().__init__(coordinator)
+        self._state = coordinator.state
+        self._attr_name = f"Zone {self._state.zn}"
         self._attr_supported_features = (
             MediaPlayerEntityFeature.SELECT_SOURCE
             | MediaPlayerEntityFeature.PLAY_MEDIA
@@ -102,18 +92,11 @@ class ArcamFmj(MediaPlayerEntity):
             | MediaPlayerEntityFeature.TURN_OFF
             | MediaPlayerEntityFeature.TURN_ON
         )
-        if state.zn == 1:
+        if self._state.zn == 1:
             self._attr_supported_features |= MediaPlayerEntityFeature.SELECT_SOUND_MODE
-        self._attr_unique_id = f"{uuid}-{state.zn}"
-        self._attr_entity_registry_enabled_default = state.zn == 1
-        self._attr_device_info = DeviceInfo(
-            identifiers={
-                (DOMAIN, uuid),
-            },
-            manufacturer="Arcam",
-            model="Arcam FMJ AVR",
-            name=device_name,
-        )
+        self._attr_unique_id = f"{uuid}-{self._state.zn}"
+        self._attr_entity_registry_enabled_default = self._state.zn == 1
+        self._attr_device_info = coordinator.device_info
 
     @property
     def state(self) -> MediaPlayerState:
@@ -122,49 +105,6 @@ class ArcamFmj(MediaPlayerEntity):
             return MediaPlayerState.ON
         return MediaPlayerState.OFF
 
-    async def async_added_to_hass(self) -> None:
-        """Once registered, add listener for events."""
-        await self._state.start()
-        try:
-            await self._state.update()
-        except ConnectionFailed as connection:
-            _LOGGER.debug("Connection lost during addition: %s", connection)
-
-        @callback
-        def _data(host: str) -> None:
-            if host == self._state.client.host:
-                self.async_write_ha_state()
-
-        @callback
-        def _started(host: str) -> None:
-            if host == self._state.client.host:
-                self.async_schedule_update_ha_state(force_refresh=True)
-
-        @callback
-        def _stopped(host: str) -> None:
-            if host == self._state.client.host:
-                self.async_schedule_update_ha_state(force_refresh=True)
-
-        self.async_on_remove(
-            async_dispatcher_connect(self.hass, SIGNAL_CLIENT_DATA, _data)
-        )
-
-        self.async_on_remove(
-            async_dispatcher_connect(self.hass, SIGNAL_CLIENT_STARTED, _started)
-        )
-
-        self.async_on_remove(
-            async_dispatcher_connect(self.hass, SIGNAL_CLIENT_STOPPED, _stopped)
-        )
-
-    async def async_update(self) -> None:
-        """Force update of state."""
-        _LOGGER.debug("Update state %s", self.name)
-        try:
-            await self._state.update()
-        except ConnectionFailed as connection:
-            _LOGGER.debug("Connection lost during update: %s", connection)
-
     @convert_exception
     async def async_mute_volume(self, mute: bool) -> None:
         """Send mute command."""

homeassistant/components/automation/__init__.py

@@ -137,7 +137,6 @@ _EXPERIMENTAL_CONDITION_PLATFORMS = {
 _EXPERIMENTAL_TRIGGER_PLATFORMS = {
     "alarm_control_panel",
     "assist_satellite",
-    "binary_sensor",
     "button",
     "climate",
     "cover",
@@ -145,7 +144,10 @@ _EXPERIMENTAL_TRIGGER_PLATFORMS = {
     "door",
     "fan",
     "garage_door",
+    "gate",
     "humidifier",
+    "humidity",
+    "input_boolean",
     "lawn_mower",
     "light",
     "lock",

homeassistant/components/backup/manager.py

@@ -32,6 +32,7 @@ from homeassistant.helpers import (
     issue_registry as ir,
     start,
 )
+from homeassistant.helpers.debounce import Debouncer
 from homeassistant.helpers.json import json_bytes
 from homeassistant.util import dt as dt_util, json as json_util
 from homeassistant.util.async_iterator import AsyncIteratorReader
@@ -78,6 +79,8 @@ from .util import (
     validate_password_stream,
 )
 
+UPLOAD_PROGRESS_DEBOUNCE_SECONDS = 1
+
 
 @dataclass(frozen=True, kw_only=True, slots=True)
 class NewBackup:
@@ -590,23 +593,49 @@ class BackupManager:
                 )
             agent = self.backup_agents[agent_id]
 
+            latest_uploaded_bytes = 0
+
             @callback
-            def on_upload_progress(*, bytes_uploaded: int, **kwargs: Any) -> None:
-                """Handle upload progress."""
+            def _emit_upload_progress() -> None:
+                """Emit the latest upload progress event."""
                 self.async_on_backup_event(
                     UploadBackupEvent(
                         manager_state=self.state,
                         agent_id=agent_id,
-                        uploaded_bytes=bytes_uploaded,
+                        uploaded_bytes=latest_uploaded_bytes,
                         total_bytes=_backup.size,
                     )
                 )
 
+            upload_progress_debouncer: Debouncer[None] = Debouncer(
+                self.hass,
+                LOGGER,
+                cooldown=UPLOAD_PROGRESS_DEBOUNCE_SECONDS,
+                immediate=True,
+                function=_emit_upload_progress,
+            )
+
+            @callback
+            def on_upload_progress(*, bytes_uploaded: int, **kwargs: Any) -> None:
+                """Handle upload progress."""
+                nonlocal latest_uploaded_bytes
+                latest_uploaded_bytes = bytes_uploaded
+                upload_progress_debouncer.async_schedule_call()
+
             await agent.async_upload_backup(
                 open_stream=open_stream_func,
                 backup=_backup,
                 on_progress=on_upload_progress,
             )
+            upload_progress_debouncer.async_cancel()
+            self.async_on_backup_event(
+                UploadBackupEvent(
+                    manager_state=self.state,
+                    agent_id=agent_id,
+                    uploaded_bytes=_backup.size,
+                    total_bytes=_backup.size,
+                )
+            )
             if streamer:
                 await streamer.wait()
 

homeassistant/components/binary_sensor/icons.json

@@ -174,13 +174,5 @@
         "on": "mdi:window-open"
       }
     }
-  },
-  "triggers": {
-    "occupancy_cleared": {
-      "trigger": "mdi:home-outline"
-    },
-    "occupancy_detected": {
-      "trigger": "mdi:home"
-    }
   }
 }

homeassistant/components/binary_sensor/strings.json

@@ -1,8 +1,4 @@
 {
-  "common": {
-    "trigger_behavior_description_occupancy": "The behavior of the targeted occupancy sensors to trigger on.",
-    "trigger_behavior_name": "Behavior"
-  },
   "device_automation": {
     "condition_type": {
       "is_bat_low": "{entity_name} battery is low",
@@ -321,36 +317,5 @@
       }
     }
   },
-  "selector": {
-    "trigger_behavior": {
-      "options": {
-        "any": "Any",
-        "first": "First",
-        "last": "Last"
-      }
-    }
-  },
-  "title": "Binary sensor",
-  "triggers": {
-    "occupancy_cleared": {
-      "description": "Triggers after one or more occupancy sensors stop detecting occupancy.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::binary_sensor::common::trigger_behavior_description_occupancy%]",
-          "name": "[%key:component::binary_sensor::common::trigger_behavior_name%]"
-        }
-      },
-      "name": "Occupancy cleared"
-    },
-    "occupancy_detected": {
-      "description": "Triggers after one or more occupancy sensors start detecting occupancy.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::binary_sensor::common::trigger_behavior_description_occupancy%]",
-          "name": "[%key:component::binary_sensor::common::trigger_behavior_name%]"
-        }
-      },
-      "name": "Occupancy detected"
-    }
-  }
+  "title": "Binary sensor"
 }

homeassistant/components/binary_sensor/trigger.py

@@ -1,67 +0,0 @@
-"""Provides triggers for binary sensors."""
-
-from homeassistant.const import STATE_OFF, STATE_ON
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.entity import get_device_class
-from homeassistant.helpers.trigger import EntityTargetStateTriggerBase, Trigger
-from homeassistant.helpers.typing import UNDEFINED, UndefinedType
-
-from . import DOMAIN, BinarySensorDeviceClass
-
-
-def get_device_class_or_undefined(
-    hass: HomeAssistant, entity_id: str
-) -> str | None | UndefinedType:
-    """Get the device class of an entity or UNDEFINED if not found."""
-    try:
-        return get_device_class(hass, entity_id)
-    except HomeAssistantError:
-        return UNDEFINED
-
-
-class BinarySensorOnOffTrigger(EntityTargetStateTriggerBase):
-    """Class for binary sensor on/off triggers."""
-
-    _device_class: BinarySensorDeviceClass | None
-    _domains = {DOMAIN}
-
-    def entity_filter(self, entities: set[str]) -> set[str]:
-        """Filter entities of this domain."""
-        entities = super().entity_filter(entities)
-        return {
-            entity_id
-            for entity_id in entities
-            if get_device_class_or_undefined(self._hass, entity_id)
-            == self._device_class
-        }
-
-
-def make_binary_sensor_trigger(
-    device_class: BinarySensorDeviceClass | None,
-    to_state: str,
-) -> type[BinarySensorOnOffTrigger]:
-    """Create an entity state trigger class."""
-
-    class CustomTrigger(BinarySensorOnOffTrigger):
-        """Trigger for entity state changes."""
-
-        _device_class = device_class
-        _to_states = {to_state}
-
-    return CustomTrigger
-
-
-TRIGGERS: dict[str, type[Trigger]] = {
-    "occupancy_detected": make_binary_sensor_trigger(
-        BinarySensorDeviceClass.OCCUPANCY, STATE_ON
-    ),
-    "occupancy_cleared": make_binary_sensor_trigger(
-        BinarySensorDeviceClass.OCCUPANCY, STATE_OFF
-    ),
-}
-
-
-async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
-    """Return the triggers for binary sensors."""
-    return TRIGGERS

homeassistant/components/bond/strings.json

@@ -37,8 +37,8 @@
           "name": "Entity"
         },
         "speed": {
-          "description": "Fan Speed as %.",
-          "name": "Fan Speed"
+          "description": "The fan speed as a percentage.",
+          "name": "Fan speed"
         }
       },
       "name": "Set fan speed tracked state"
@@ -47,7 +47,7 @@
       "description": "Sets the tracked brightness state of a Bond light.",
       "fields": {
         "brightness": {
-          "description": "Brightness.",
+          "description": "The tracked brightness of the light.",
           "name": "Brightness"
         },
         "entity_id": {
@@ -79,22 +79,22 @@
           "name": "Entity"
         },
         "power_state": {
-          "description": "Power state.",
+          "description": "The tracked power state.",
           "name": "Power state"
         }
       },
       "name": "Set switch power tracked state"
     },
     "start_decreasing_brightness": {
-      "description": "Starts decreasing the brightness of the light (deprecated).",
+      "description": "Starts decreasing the brightness of a light (deprecated).",
       "name": "Start decreasing brightness"
     },
     "start_increasing_brightness": {
-      "description": "Starts increasing the brightness of the light (deprecated).",
+      "description": "Starts increasing the brightness of a light (deprecated).",
       "name": "Start increasing brightness"
     },
     "stop": {
-      "description": "Stops any in-progress action and empty the queue (deprecated).",
+      "description": "Stops any in-progress action and empties the queue (deprecated).",
       "name": "[%key:common::action::stop%]"
     }
   }

homeassistant/components/climate/trigger.py

@@ -53,16 +53,16 @@ TRIGGERS: dict[str, type[Trigger]] = {
         DOMAIN, ATTR_HVAC_ACTION, HVACAction.DRYING
     ),
     "target_humidity_changed": make_entity_numerical_state_attribute_changed_trigger(
-        DOMAIN, ATTR_HUMIDITY
+        {DOMAIN}, {DOMAIN: ATTR_HUMIDITY}
     ),
     "target_humidity_crossed_threshold": make_entity_numerical_state_attribute_crossed_threshold_trigger(
-        DOMAIN, ATTR_HUMIDITY
+        {DOMAIN}, {DOMAIN: ATTR_HUMIDITY}
     ),
     "target_temperature_changed": make_entity_numerical_state_attribute_changed_trigger(
-        DOMAIN, ATTR_TEMPERATURE
+        {DOMAIN}, {DOMAIN: ATTR_TEMPERATURE}
     ),
     "target_temperature_crossed_threshold": make_entity_numerical_state_attribute_crossed_threshold_trigger(
-        DOMAIN, ATTR_TEMPERATURE
+        {DOMAIN}, {DOMAIN: ATTR_TEMPERATURE}
     ),
     "turned_off": make_entity_target_state_trigger(DOMAIN, HVACMode.OFF),
     "turned_on": make_entity_transition_trigger(

homeassistant/components/cloud/manifest.json

@@ -13,6 +13,6 @@
   "integration_type": "system",
   "iot_class": "cloud_push",
   "loggers": ["acme", "hass_nabucasa", "snitun"],
-  "requirements": ["hass-nabucasa==1.15.0", "openai==2.21.0"],
+  "requirements": ["hass-nabucasa==2.0.0", "openai==2.21.0"],
   "single_config_entry": true
 }

homeassistant/components/cover/__init__.py

@@ -45,7 +45,7 @@ from .const import (
     CoverEntityFeature,
     CoverState,
 )
-from .trigger import CoverClosedTriggerBase, CoverOpenedTriggerBase
+from .trigger import make_cover_closed_trigger, make_cover_opened_trigger
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -74,13 +74,13 @@ __all__ = [
     "INTENT_OPEN_COVER",
     "PLATFORM_SCHEMA",
     "PLATFORM_SCHEMA_BASE",
-    "CoverClosedTriggerBase",
     "CoverDeviceClass",
     "CoverEntity",
     "CoverEntityDescription",
     "CoverEntityFeature",
-    "CoverOpenedTriggerBase",
     "CoverState",
+    "make_cover_closed_trigger",
+    "make_cover_opened_trigger",
 ]
 
 

homeassistant/components/cover/icons.json

@@ -108,5 +108,37 @@
     "toggle_cover_tilt": {
       "service": "mdi:arrow-top-right-bottom-left"
     }
+  },
+  "triggers": {
+    "awning_closed": {
+      "trigger": "mdi:storefront-outline"
+    },
+    "awning_opened": {
+      "trigger": "mdi:storefront-outline"
+    },
+    "blind_closed": {
+      "trigger": "mdi:blinds-horizontal-closed"
+    },
+    "blind_opened": {
+      "trigger": "mdi:blinds-horizontal"
+    },
+    "curtain_closed": {
+      "trigger": "mdi:curtains-closed"
+    },
+    "curtain_opened": {
+      "trigger": "mdi:curtains"
+    },
+    "shade_closed": {
+      "trigger": "mdi:roller-shade-closed"
+    },
+    "shade_opened": {
+      "trigger": "mdi:roller-shade"
+    },
+    "shutter_closed": {
+      "trigger": "mdi:window-shutter"
+    },
+    "shutter_opened": {
+      "trigger": "mdi:window-shutter-open"
+    }
   }
 }

homeassistant/components/cover/strings.json

@@ -1,4 +1,8 @@
 {
+  "common": {
+    "trigger_behavior_description": "The behavior of the targeted covers to trigger on.",
+    "trigger_behavior_name": "Behavior"
+  },
   "device_automation": {
     "action_type": {
       "close": "Close {entity_name}",
@@ -82,6 +86,15 @@
       "name": "Window"
     }
   },
+  "selector": {
+    "trigger_behavior": {
+      "options": {
+        "any": "Any",
+        "first": "First",
+        "last": "Last"
+      }
+    }
+  },
   "services": {
     "close_cover": {
       "description": "Closes a cover.",
@@ -136,5 +149,107 @@
       "name": "Toggle tilt"
     }
   },
-  "title": "Cover"
+  "title": "Cover",
+  "triggers": {
+    "awning_closed": {
+      "description": "Triggers after one or more awnings close.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::cover::common::trigger_behavior_description%]",
+          "name": "[%key:component::cover::common::trigger_behavior_name%]"
+        }
+      },
+      "name": "Awning closed"
+    },
+    "awning_opened": {
+      "description": "Triggers after one or more awnings open.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::cover::common::trigger_behavior_description%]",
+          "name": "[%key:component::cover::common::trigger_behavior_name%]"
+        }
+      },
+      "name": "Awning opened"
+    },
+    "blind_closed": {
+      "description": "Triggers after one or more blinds close.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::cover::common::trigger_behavior_description%]",
+          "name": "[%key:component::cover::common::trigger_behavior_name%]"
+        }
+      },
+      "name": "Blind closed"
+    },
+    "blind_opened": {
+      "description": "Triggers after one or more blinds open.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::cover::common::trigger_behavior_description%]",
+          "name": "[%key:component::cover::common::trigger_behavior_name%]"
+        }
+      },
+      "name": "Blind opened"
+    },
+    "curtain_closed": {
+      "description": "Triggers after one or more curtains close.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::cover::common::trigger_behavior_description%]",
+          "name": "[%key:component::cover::common::trigger_behavior_name%]"
+        }
+      },
+      "name": "Curtain closed"
+    },
+    "curtain_opened": {
+      "description": "Triggers after one or more curtains open.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::cover::common::trigger_behavior_description%]",
+          "name": "[%key:component::cover::common::trigger_behavior_name%]"
+        }
+      },
+      "name": "Curtain opened"
+    },
+    "shade_closed": {
+      "description": "Triggers after one or more shades close.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::cover::common::trigger_behavior_description%]",
+          "name": "[%key:component::cover::common::trigger_behavior_name%]"
+        }
+      },
+      "name": "Shade closed"
+    },
+    "shade_opened": {
+      "description": "Triggers after one or more shades open.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::cover::common::trigger_behavior_description%]",
+          "name": "[%key:component::cover::common::trigger_behavior_name%]"
+        }
+      },
+      "name": "Shade opened"
+    },
+    "shutter_closed": {
+      "description": "Triggers after one or more shutters close.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::cover::common::trigger_behavior_description%]",
+          "name": "[%key:component::cover::common::trigger_behavior_name%]"
+        }
+      },
+      "name": "Shutter closed"
+    },
+    "shutter_opened": {
+      "description": "Triggers after one or more shutters open.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::cover::common::trigger_behavior_description%]",
+          "name": "[%key:component::cover::common::trigger_behavior_name%]"
+        }
+      },
+      "name": "Shutter opened"
+    }
+  }
 }

homeassistant/components/cover/trigger.py

@@ -1,30 +1,19 @@
 """Provides triggers for covers."""
 
-from homeassistant.components.binary_sensor import DOMAIN as BINARY_SENSOR_DOMAIN
 from homeassistant.const import STATE_OFF, STATE_ON, STATE_UNAVAILABLE, STATE_UNKNOWN
 from homeassistant.core import HomeAssistant, State, split_entity_id
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.entity import get_device_class
-from homeassistant.helpers.trigger import EntityTriggerBase
-from homeassistant.helpers.typing import UNDEFINED, UndefinedType
+from homeassistant.helpers.trigger import (
+    EntityTriggerBase,
+    Trigger,
+    get_device_class_or_undefined,
+)
 
-from .const import ATTR_IS_CLOSED, DOMAIN
-
-
-def get_device_class_or_undefined(
-    hass: HomeAssistant, entity_id: str
-) -> str | None | UndefinedType:
-    """Get the device class of an entity or UNDEFINED if not found."""
-    try:
-        return get_device_class(hass, entity_id)
-    except HomeAssistantError:
-        return UNDEFINED
+from .const import ATTR_IS_CLOSED, DOMAIN, CoverDeviceClass
 
 
 class CoverTriggerBase(EntityTriggerBase):
     """Base trigger for cover state changes."""
 
-    _domains = {BINARY_SENSOR_DOMAIN, DOMAIN}
     _binary_sensor_target_state: str
     _cover_is_closed_target_value: bool
     _device_classes: dict[str, str]
@@ -59,15 +48,60 @@ class CoverTriggerBase(EntityTriggerBase):
         return from_state.state != to_state.state
 
 
-class CoverOpenedTriggerBase(CoverTriggerBase):
-    """Base trigger for cover opened state changes."""
+def make_cover_opened_trigger(
+    *, device_classes: dict[str, str], domains: set[str] | None = None
+) -> type[CoverTriggerBase]:
+    """Create a trigger cover_opened."""
 
-    _binary_sensor_target_state = STATE_ON
-    _cover_is_closed_target_value = False
+    class CoverOpenedTrigger(CoverTriggerBase):
+        """Trigger for cover opened state changes."""
+
+        _binary_sensor_target_state = STATE_ON
+        _cover_is_closed_target_value = False
+        _domains = domains or {DOMAIN}
+        _device_classes = device_classes
+
+    return CoverOpenedTrigger
 
 
-class CoverClosedTriggerBase(CoverTriggerBase):
-    """Base trigger for cover closed state changes."""
+def make_cover_closed_trigger(
+    *, device_classes: dict[str, str], domains: set[str] | None = None
+) -> type[CoverTriggerBase]:
+    """Create a trigger cover_closed."""
 
-    _binary_sensor_target_state = STATE_OFF
-    _cover_is_closed_target_value = True
+    class CoverClosedTrigger(CoverTriggerBase):
+        """Trigger for cover closed state changes."""
+
+        _binary_sensor_target_state = STATE_OFF
+        _cover_is_closed_target_value = True
+        _domains = domains or {DOMAIN}
+        _device_classes = device_classes
+
+    return CoverClosedTrigger
+
+
+# Concrete triggers for cover device classes (cover-only, no binary sensor)
+
+DEVICE_CLASSES_AWNING: dict[str, str] = {DOMAIN: CoverDeviceClass.AWNING}
+DEVICE_CLASSES_BLIND: dict[str, str] = {DOMAIN: CoverDeviceClass.BLIND}
+DEVICE_CLASSES_CURTAIN: dict[str, str] = {DOMAIN: CoverDeviceClass.CURTAIN}
+DEVICE_CLASSES_SHADE: dict[str, str] = {DOMAIN: CoverDeviceClass.SHADE}
+DEVICE_CLASSES_SHUTTER: dict[str, str] = {DOMAIN: CoverDeviceClass.SHUTTER}
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "awning_opened": make_cover_opened_trigger(device_classes=DEVICE_CLASSES_AWNING),
+    "awning_closed": make_cover_closed_trigger(device_classes=DEVICE_CLASSES_AWNING),
+    "blind_opened": make_cover_opened_trigger(device_classes=DEVICE_CLASSES_BLIND),
+    "blind_closed": make_cover_closed_trigger(device_classes=DEVICE_CLASSES_BLIND),
+    "curtain_opened": make_cover_opened_trigger(device_classes=DEVICE_CLASSES_CURTAIN),
+    "curtain_closed": make_cover_closed_trigger(device_classes=DEVICE_CLASSES_CURTAIN),
+    "shade_opened": make_cover_opened_trigger(device_classes=DEVICE_CLASSES_SHADE),
+    "shade_closed": make_cover_closed_trigger(device_classes=DEVICE_CLASSES_SHADE),
+    "shutter_opened": make_cover_opened_trigger(device_classes=DEVICE_CLASSES_SHUTTER),
+    "shutter_closed": make_cover_closed_trigger(device_classes=DEVICE_CLASSES_SHUTTER),
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for covers."""
+    return TRIGGERS

homeassistant/components/cover/triggers.yaml

@@ -0,0 +1,81 @@
+.trigger_common_fields: &trigger_common_fields
+  behavior:
+    required: true
+    default: any
+    selector:
+      select:
+        translation_key: trigger_behavior
+        options:
+          - first
+          - last
+          - any
+
+awning_closed:
+  fields: *trigger_common_fields
+  target:
+    entity:
+      - domain: cover
+        device_class: awning
+
+awning_opened:
+  fields: *trigger_common_fields
+  target:
+    entity:
+      - domain: cover
+        device_class: awning
+
+blind_closed:
+  fields: *trigger_common_fields
+  target:
+    entity:
+      - domain: cover
+        device_class: blind
+
+blind_opened:
+  fields: *trigger_common_fields
+  target:
+    entity:
+      - domain: cover
+        device_class: blind
+
+curtain_closed:
+  fields: *trigger_common_fields
+  target:
+    entity:
+      - domain: cover
+        device_class: curtain
+
+curtain_opened:
+  fields: *trigger_common_fields
+  target:
+    entity:
+      - domain: cover
+        device_class: curtain
+
+shade_closed:
+  fields: *trigger_common_fields
+  target:
+    entity:
+      - domain: cover
+        device_class: shade
+
+shade_opened:
+  fields: *trigger_common_fields
+  target:
+    entity:
+      - domain: cover
+        device_class: shade
+
+shutter_closed:
+  fields: *trigger_common_fields
+  target:
+    entity:
+      - domain: cover
+        device_class: shutter
+
+shutter_opened:
+  fields: *trigger_common_fields
+  target:
+    entity:
+      - domain: cover
+        device_class: shutter

homeassistant/components/door/trigger.py

@@ -6,9 +6,9 @@ from homeassistant.components.binary_sensor import (
 )
 from homeassistant.components.cover import (
     DOMAIN as COVER_DOMAIN,
-    CoverClosedTriggerBase,
     CoverDeviceClass,
-    CoverOpenedTriggerBase,
+    make_cover_closed_trigger,
+    make_cover_opened_trigger,
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.trigger import Trigger
@@ -19,21 +19,15 @@ DEVICE_CLASSES_DOOR: dict[str, str] = {
 }
 
 
-class DoorOpenedTrigger(CoverOpenedTriggerBase):
-    """Trigger for door opened state changes."""
-
-    _device_classes = DEVICE_CLASSES_DOOR
-
-
-class DoorClosedTrigger(CoverClosedTriggerBase):
-    """Trigger for door closed state changes."""
-
-    _device_classes = DEVICE_CLASSES_DOOR
-
-
 TRIGGERS: dict[str, type[Trigger]] = {
-    "opened": DoorOpenedTrigger,
-    "closed": DoorClosedTrigger,
+    "opened": make_cover_opened_trigger(
+        device_classes=DEVICE_CLASSES_DOOR,
+        domains={BINARY_SENSOR_DOMAIN, COVER_DOMAIN},
+    ),
+    "closed": make_cover_closed_trigger(
+        device_classes=DEVICE_CLASSES_DOOR,
+        domains={BINARY_SENSOR_DOMAIN, COVER_DOMAIN},
+    ),
 }
 
 

homeassistant/components/eheimdigital/__init__.py

@@ -10,6 +10,7 @@ from .const import DOMAIN
 from .coordinator import EheimDigitalConfigEntry, EheimDigitalUpdateCoordinator
 
 PLATFORMS = [
+    Platform.BINARY_SENSOR,
     Platform.CLIMATE,
     Platform.LIGHT,
     Platform.NUMBER,

homeassistant/components/eheimdigital/binary_sensor.py

@@ -0,0 +1,101 @@
+"""EHEIM Digital binary sensors."""
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+from eheimdigital.device import EheimDigitalDevice
+from eheimdigital.reeflex import EheimDigitalReeflexUV
+
+from homeassistant.components.binary_sensor import (
+    BinarySensorDeviceClass,
+    BinarySensorEntity,
+    BinarySensorEntityDescription,
+)
+from homeassistant.const import EntityCategory
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .coordinator import EheimDigitalConfigEntry, EheimDigitalUpdateCoordinator
+from .entity import EheimDigitalEntity
+
+# Coordinator is used to centralize the data updates
+PARALLEL_UPDATES = 0
+
+
+@dataclass(frozen=True, kw_only=True)
+class EheimDigitalBinarySensorDescription[_DeviceT: EheimDigitalDevice](
+    BinarySensorEntityDescription
+):
+    """Class describing EHEIM Digital binary sensor entities."""
+
+    value_fn: Callable[[_DeviceT], bool | None]
+
+
+REEFLEX_DESCRIPTIONS: tuple[
+    EheimDigitalBinarySensorDescription[EheimDigitalReeflexUV], ...
+] = (
+    EheimDigitalBinarySensorDescription[EheimDigitalReeflexUV](
+        key="is_lighting",
+        translation_key="is_lighting",
+        value_fn=lambda device: device.is_lighting,
+        device_class=BinarySensorDeviceClass.LIGHT,
+    ),
+    EheimDigitalBinarySensorDescription[EheimDigitalReeflexUV](
+        key="is_uvc_connected",
+        translation_key="is_uvc_connected",
+        entity_category=EntityCategory.DIAGNOSTIC,
+        value_fn=lambda device: device.is_uvc_connected,
+        device_class=BinarySensorDeviceClass.CONNECTIVITY,
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: EheimDigitalConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up the callbacks for the coordinator so binary sensors can be added as devices are found."""
+    coordinator = entry.runtime_data
+
+    def async_setup_device_entities(
+        device_address: dict[str, EheimDigitalDevice],
+    ) -> None:
+        """Set up the binary sensor entities for one or multiple devices."""
+        entities: list[EheimDigitalBinarySensor[Any]] = []
+        for device in device_address.values():
+            if isinstance(device, EheimDigitalReeflexUV):
+                entities += [
+                    EheimDigitalBinarySensor[EheimDigitalReeflexUV](
+                        coordinator, device, description
+                    )
+                    for description in REEFLEX_DESCRIPTIONS
+                ]
+
+        async_add_entities(entities)
+
+    coordinator.add_platform_callback(async_setup_device_entities)
+    async_setup_device_entities(coordinator.hub.devices)
+
+
+class EheimDigitalBinarySensor[_DeviceT: EheimDigitalDevice](
+    EheimDigitalEntity[_DeviceT], BinarySensorEntity
+):
+    """Represent an EHEIM Digital binary sensor entity."""
+
+    entity_description: EheimDigitalBinarySensorDescription[_DeviceT]
+
+    def __init__(
+        self,
+        coordinator: EheimDigitalUpdateCoordinator,
+        device: _DeviceT,
+        description: EheimDigitalBinarySensorDescription[_DeviceT],
+    ) -> None:
+        """Initialize an EHEIM Digital binary sensor entity."""
+        super().__init__(coordinator, device)
+        self.entity_description = description
+        self._attr_unique_id = f"{self._device_address}_{description.key}"
+
+    def _async_update_attrs(self) -> None:
+        self._attr_is_on = self.entity_description.value_fn(self._device)

homeassistant/components/eheimdigital/icons.json

@@ -1,5 +1,19 @@
 {
   "entity": {
+    "binary_sensor": {
+      "is_lighting": {
+        "default": "mdi:lightbulb-outline",
+        "state": {
+          "on": "mdi:lightbulb-on"
+        }
+      },
+      "is_uvc_connected": {
+        "default": "mdi:lightbulb-off",
+        "state": {
+          "on": "mdi:lightbulb-outline"
+        }
+      }
+    },
     "number": {
       "day_speed": {
         "default": "mdi:weather-sunny"

homeassistant/components/eheimdigital/strings.json

@@ -33,6 +33,17 @@
     }
   },
   "entity": {
+    "binary_sensor": {
+      "is_lighting": {
+        "state": {
+          "off": "[%key:common::state::off%]",
+          "on": "[%key:common::state::on%]"
+        }
+      },
+      "is_uvc_connected": {
+        "name": "UVC lamp connected"
+      }
+    },
     "climate": {
       "heater": {
         "state_attributes": {

homeassistant/components/evohome/climate.py

@@ -363,10 +363,12 @@ class EvoController(EvoClimateEntity):
 
         Data validation is not required, it will have been done upstream.
         """
-        if service == EvoService.SET_SYSTEM_MODE:
-            mode = data[ATTR_MODE]
-        else:  # otherwise it is EvoService.RESET_SYSTEM
-            mode = EvoSystemMode.AUTO_WITH_RESET
+
+        if service == EvoService.RESET_SYSTEM:
+            await self.coordinator.call_client_api(self._evo_device.reset())
+            return
+
+        mode = data[ATTR_MODE]  # otherwise it is EvoService.SET_SYSTEM_MODE
 
         if ATTR_PERIOD in data:
             until = dt_util.start_of_local_day()

homeassistant/components/evohome/services.py

@@ -27,7 +27,6 @@ from .coordinator import EvoDataUpdateCoordinator
 # because supported modes can vary for edge-case systems
 
 # Zone service schemas (registered as entity services)
-CLEAR_ZONE_OVERRIDE_SCHEMA: Final[dict[str | vol.Marker, Any]] = {}
 SET_ZONE_OVERRIDE_SCHEMA: Final[dict[str | vol.Marker, Any]] = {
     vol.Required(ATTR_SETPOINT): vol.All(
         vol.Coerce(float), vol.Range(min=4.0, max=35.0)
@@ -47,7 +46,7 @@ def _register_zone_entity_services(hass: HomeAssistant) -> None:
         DOMAIN,
         EvoService.CLEAR_ZONE_OVERRIDE,
         entity_domain=CLIMATE_DOMAIN,
-        schema=CLEAR_ZONE_OVERRIDE_SCHEMA,
+        schema=None,
         func="async_clear_zone_override",
     )
     service.async_register_platform_entity_service(
@@ -79,7 +78,6 @@ def setup_service_functions(
     @verify_domain_control(DOMAIN)
     async def set_system_mode(call: ServiceCall) -> None:
         """Set the system mode."""
-        assert coordinator.tcs is not None  # mypy
 
         payload = {
             "unique_id": coordinator.tcs.id,
@@ -91,18 +89,11 @@ def setup_service_functions(
     assert coordinator.tcs is not None  # mypy
 
     hass.services.async_register(DOMAIN, EvoService.REFRESH_SYSTEM, force_refresh)
+    hass.services.async_register(DOMAIN, EvoService.RESET_SYSTEM, set_system_mode)
 
     # Enumerate which operating modes are supported by this system
     modes = list(coordinator.tcs.allowed_system_modes)
 
-    # Not all systems support "AutoWithReset": register this handler only if required
-    if any(
-        m[SZ_SYSTEM_MODE]
-        for m in modes
-        if m[SZ_SYSTEM_MODE] == EvoSystemMode.AUTO_WITH_RESET
-    ):
-        hass.services.async_register(DOMAIN, EvoService.RESET_SYSTEM, set_system_mode)
-
     system_mode_schemas = []
     modes = [m for m in modes if m[SZ_SYSTEM_MODE] != EvoSystemMode.AUTO_WITH_RESET]
 

homeassistant/components/fish_audio/config_flow.py

@@ -111,7 +111,7 @@ def get_model_selection_schema(
             ),
             vol.Required(
                 CONF_BACKEND,
-                default=options.get(CONF_BACKEND, "s1"),
+                default=options.get(CONF_BACKEND, "s2-pro"),
             ): SelectSelector(
                 SelectSelectorConfig(
                     options=[

homeassistant/components/fish_audio/const.py

@@ -31,7 +31,7 @@ TTS_SUPPORTED_LANGUAGES = [
 ]
 
 
-BACKEND_MODELS = ["s1", "speech-1.5", "speech-1.6"]
+BACKEND_MODELS = ["s2-pro", "s1", "speech-1.5", "speech-1.6"]
 SORT_BY_OPTIONS = ["task_count", "score", "created_at"]
 LATENCY_OPTIONS = ["normal", "balanced"]
 

homeassistant/components/fritzbox/climate.py

@@ -179,7 +179,9 @@ class FritzboxThermostat(FritzBoxDeviceEntity, ClimateEntity):
             return PRESET_HOLIDAY
         if self.data.summer_active:
             return PRESET_SUMMER
-        if self.data.target_temperature == ON_API_TEMPERATURE:
+        if self.data.target_temperature == ON_API_TEMPERATURE or getattr(
+            self.data, "boost_active", False
+        ):
             return PRESET_BOOST
         if self.data.target_temperature == self.data.comfort_temperature:
             return PRESET_COMFORT

homeassistant/components/garage_door/trigger.py

@@ -6,9 +6,9 @@ from homeassistant.components.binary_sensor import (
 )
 from homeassistant.components.cover import (
     DOMAIN as COVER_DOMAIN,
-    CoverClosedTriggerBase,
     CoverDeviceClass,
-    CoverOpenedTriggerBase,
+    make_cover_closed_trigger,
+    make_cover_opened_trigger,
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.trigger import Trigger
@@ -19,21 +19,15 @@ DEVICE_CLASSES_GARAGE_DOOR: dict[str, str] = {
 }
 
 
-class GarageDoorOpenedTrigger(CoverOpenedTriggerBase):
-    """Trigger for garage door opened state changes."""
-
-    _device_classes = DEVICE_CLASSES_GARAGE_DOOR
-
-
-class GarageDoorClosedTrigger(CoverClosedTriggerBase):
-    """Trigger for garage door closed state changes."""
-
-    _device_classes = DEVICE_CLASSES_GARAGE_DOOR
-
-
 TRIGGERS: dict[str, type[Trigger]] = {
-    "opened": GarageDoorOpenedTrigger,
-    "closed": GarageDoorClosedTrigger,
+    "opened": make_cover_opened_trigger(
+        device_classes=DEVICE_CLASSES_GARAGE_DOOR,
+        domains={BINARY_SENSOR_DOMAIN, COVER_DOMAIN},
+    ),
+    "closed": make_cover_closed_trigger(
+        device_classes=DEVICE_CLASSES_GARAGE_DOOR,
+        domains={BINARY_SENSOR_DOMAIN, COVER_DOMAIN},
+    ),
 }
 
 

homeassistant/components/gardena_bluetooth/__init__.py

@@ -2,12 +2,18 @@
 
 from __future__ import annotations
 
+import asyncio
 import logging
 
 from bleak.backends.device import BLEDevice
 from gardena_bluetooth.client import CachedConnection, Client
 from gardena_bluetooth.const import DeviceConfiguration, DeviceInformation
-from gardena_bluetooth.exceptions import CommunicationFailure
+from gardena_bluetooth.exceptions import (
+    CharacteristicNoAccess,
+    CharacteristicNotFound,
+    CommunicationFailure,
+)
+from gardena_bluetooth.parse import CharacteristicTime
 
 from homeassistant.components import bluetooth
 from homeassistant.const import CONF_ADDRESS, Platform
@@ -23,6 +29,7 @@ from .coordinator import (
     GardenaBluetoothConfigEntry,
     GardenaBluetoothCoordinator,
 )
+from .util import async_get_product_type
 
 PLATFORMS: list[Platform] = [
     Platform.BINARY_SENSOR,
@@ -51,22 +58,41 @@ def get_connection(hass: HomeAssistant, address: str) -> CachedConnection:
     return CachedConnection(DISCONNECT_DELAY, _device_lookup)
 
 
+async def _update_timestamp(client: Client, characteristics: CharacteristicTime):
+    try:
+        await client.update_timestamp(characteristics, dt_util.now())
+    except CharacteristicNotFound:
+        pass
+    except CharacteristicNoAccess:
+        LOGGER.debug("No access to update internal time")
+
+
 async def async_setup_entry(
     hass: HomeAssistant, entry: GardenaBluetoothConfigEntry
 ) -> bool:
     """Set up Gardena Bluetooth from a config entry."""
 
     address = entry.data[CONF_ADDRESS]
-    client = Client(get_connection(hass, address))
+
     try:
+        async with asyncio.timeout(TIMEOUT):
+            product_type = await async_get_product_type(hass, address)
+    except TimeoutError as exception:
+        raise ConfigEntryNotReady("Unable to find product type") from exception
+
+    client = Client(get_connection(hass, address), product_type)
+    try:
+        chars = await client.get_all_characteristics()
+
         sw_version = await client.read_char(DeviceInformation.firmware_version, None)
         manufacturer = await client.read_char(DeviceInformation.manufacturer_name, None)
         model = await client.read_char(DeviceInformation.model_number, None)
-        name = await client.read_char(
-            DeviceConfiguration.custom_device_name, entry.title
-        )
-        uuids = await client.get_all_characteristics_uuid()
-        await client.update_timestamp(dt_util.now())
+
+        name = entry.title
+        name = await client.read_char(DeviceConfiguration.custom_device_name, name)
+
+        await _update_timestamp(client, DeviceConfiguration.unix_timestamp)
+
     except (TimeoutError, CommunicationFailure, DeviceUnavailable) as exception:
         await client.disconnect()
         raise ConfigEntryNotReady(
@@ -83,7 +109,7 @@ async def async_setup_entry(
     )
 
     coordinator = GardenaBluetoothCoordinator(
-        hass, entry, LOGGER, client, uuids, device, address
+        hass, entry, LOGGER, client, set(chars.keys()), device, address
     )
 
     entry.runtime_data = coordinator

homeassistant/components/gardena_bluetooth/binary_sensor.py

@@ -34,14 +34,14 @@ class GardenaBluetoothBinarySensorEntityDescription(BinarySensorEntityDescriptio
 
 DESCRIPTIONS = (
     GardenaBluetoothBinarySensorEntityDescription(
-        key=Valve.connected_state.uuid,
+        key=Valve.connected_state.unique_id,
         translation_key="valve_connected_state",
         device_class=BinarySensorDeviceClass.CONNECTIVITY,
         entity_category=EntityCategory.DIAGNOSTIC,
         char=Valve.connected_state,
     ),
     GardenaBluetoothBinarySensorEntityDescription(
-        key=Sensor.connected_state.uuid,
+        key=Sensor.connected_state.unique_id,
         translation_key="sensor_connected_state",
         device_class=BinarySensorDeviceClass.CONNECTIVITY,
         entity_category=EntityCategory.DIAGNOSTIC,
@@ -60,7 +60,7 @@ async def async_setup_entry(
     entities = [
         GardenaBluetoothBinarySensor(coordinator, description, description.context)
         for description in DESCRIPTIONS
-        if description.key in coordinator.characteristics
+        if description.char.unique_id in coordinator.characteristics
     ]
     async_add_entities(entities)
 

homeassistant/components/gardena_bluetooth/button.py

@@ -30,7 +30,7 @@ class GardenaBluetoothButtonEntityDescription(ButtonEntityDescription):
 
 DESCRIPTIONS = (
     GardenaBluetoothButtonEntityDescription(
-        key=Reset.factory_reset.uuid,
+        key=Reset.factory_reset.unique_id,
         translation_key="factory_reset",
         entity_category=EntityCategory.DIAGNOSTIC,
         entity_registry_enabled_default=False,
@@ -49,7 +49,7 @@ async def async_setup_entry(
     entities = [
         GardenaBluetoothButton(coordinator, description, description.context)
         for description in DESCRIPTIONS
-        if description.key in coordinator.characteristics
+        if description.char.unique_id in coordinator.characteristics
     ]
     async_add_entities(entities)
 

homeassistant/components/gardena_bluetooth/manifest.json

@@ -15,5 +15,5 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["bleak", "bleak_esphome", "gardena_bluetooth"],
-  "requirements": ["gardena-bluetooth==1.6.0"]
+  "requirements": ["gardena-bluetooth==2.1.0"]
 }

homeassistant/components/gardena_bluetooth/number.py

@@ -46,7 +46,7 @@ class GardenaBluetoothNumberEntityDescription(NumberEntityDescription):
 
 DESCRIPTIONS = (
     GardenaBluetoothNumberEntityDescription(
-        key=Valve.manual_watering_time.uuid,
+        key=Valve.manual_watering_time.unique_id,
         translation_key="manual_watering_time",
         native_unit_of_measurement=UnitOfTime.SECONDS,
         mode=NumberMode.BOX,
@@ -58,7 +58,7 @@ DESCRIPTIONS = (
         device_class=NumberDeviceClass.DURATION,
     ),
     GardenaBluetoothNumberEntityDescription(
-        key=Valve.remaining_open_time.uuid,
+        key=Valve.remaining_open_time.unique_id,
         translation_key="remaining_open_time",
         native_unit_of_measurement=UnitOfTime.SECONDS,
         native_min_value=0.0,
@@ -69,7 +69,7 @@ DESCRIPTIONS = (
         device_class=NumberDeviceClass.DURATION,
     ),
     GardenaBluetoothNumberEntityDescription(
-        key=DeviceConfiguration.rain_pause.uuid,
+        key=DeviceConfiguration.rain_pause.unique_id,
         translation_key="rain_pause",
         native_unit_of_measurement=UnitOfTime.MINUTES,
         mode=NumberMode.BOX,
@@ -81,7 +81,7 @@ DESCRIPTIONS = (
         device_class=NumberDeviceClass.DURATION,
     ),
     GardenaBluetoothNumberEntityDescription(
-        key=DeviceConfiguration.seasonal_adjust.uuid,
+        key=DeviceConfiguration.seasonal_adjust.unique_id,
         translation_key="seasonal_adjust",
         native_unit_of_measurement=UnitOfTime.DAYS,
         mode=NumberMode.BOX,
@@ -93,7 +93,7 @@ DESCRIPTIONS = (
         device_class=NumberDeviceClass.DURATION,
     ),
     GardenaBluetoothNumberEntityDescription(
-        key=Sensor.threshold.uuid,
+        key=Sensor.threshold.unique_id,
         translation_key="sensor_threshold",
         native_unit_of_measurement=PERCENTAGE,
         mode=NumberMode.BOX,
@@ -117,9 +117,9 @@ async def async_setup_entry(
     entities: list[NumberEntity] = [
         GardenaBluetoothNumber(coordinator, description, description.context)
         for description in DESCRIPTIONS
-        if description.key in coordinator.characteristics
+        if description.char.unique_id in coordinator.characteristics
     ]
-    if Valve.remaining_open_time.uuid in coordinator.characteristics:
+    if Valve.remaining_open_time.unique_id in coordinator.characteristics:
         entities.append(GardenaBluetoothRemainingOpenSetNumber(coordinator))
     async_add_entities(entities)
 

homeassistant/components/gardena_bluetooth/sensor.py

@@ -41,7 +41,7 @@ class GardenaBluetoothSensorEntityDescription(SensorEntityDescription):
 
 DESCRIPTIONS = (
     GardenaBluetoothSensorEntityDescription(
-        key=Valve.activation_reason.uuid,
+        key=Valve.activation_reason.unique_id,
         translation_key="activation_reason",
         state_class=SensorStateClass.MEASUREMENT,
         entity_category=EntityCategory.DIAGNOSTIC,
@@ -49,7 +49,7 @@ DESCRIPTIONS = (
         char=Valve.activation_reason,
     ),
     GardenaBluetoothSensorEntityDescription(
-        key=Battery.battery_level.uuid,
+        key=Battery.battery_level.unique_id,
         state_class=SensorStateClass.MEASUREMENT,
         device_class=SensorDeviceClass.BATTERY,
         entity_category=EntityCategory.DIAGNOSTIC,
@@ -57,7 +57,7 @@ DESCRIPTIONS = (
         char=Battery.battery_level,
     ),
     GardenaBluetoothSensorEntityDescription(
-        key=Sensor.battery_level.uuid,
+        key=Sensor.battery_level.unique_id,
         translation_key="sensor_battery_level",
         state_class=SensorStateClass.MEASUREMENT,
         device_class=SensorDeviceClass.BATTERY,
@@ -67,7 +67,7 @@ DESCRIPTIONS = (
         connected_state=Sensor.connected_state,
     ),
     GardenaBluetoothSensorEntityDescription(
-        key=Sensor.value.uuid,
+        key=Sensor.value.unique_id,
         state_class=SensorStateClass.MEASUREMENT,
         device_class=SensorDeviceClass.MOISTURE,
         native_unit_of_measurement=PERCENTAGE,
@@ -75,14 +75,14 @@ DESCRIPTIONS = (
         connected_state=Sensor.connected_state,
     ),
     GardenaBluetoothSensorEntityDescription(
-        key=Sensor.type.uuid,
+        key=Sensor.type.unique_id,
         translation_key="sensor_type",
         entity_category=EntityCategory.DIAGNOSTIC,
         char=Sensor.type,
         connected_state=Sensor.connected_state,
     ),
     GardenaBluetoothSensorEntityDescription(
-        key=Sensor.measurement_timestamp.uuid,
+        key=Sensor.measurement_timestamp.unique_id,
         translation_key="sensor_measurement_timestamp",
         device_class=SensorDeviceClass.TIMESTAMP,
         entity_category=EntityCategory.DIAGNOSTIC,
@@ -102,9 +102,9 @@ async def async_setup_entry(
     entities: list[GardenaBluetoothEntity] = [
         GardenaBluetoothSensor(coordinator, description, description.context)
         for description in DESCRIPTIONS
-        if description.key in coordinator.characteristics
+        if description.char.unique_id in coordinator.characteristics
     ]
-    if Valve.remaining_open_time.uuid in coordinator.characteristics:
+    if Valve.remaining_open_time.unique_id in coordinator.characteristics:
         entities.append(GardenaBluetoothRemainSensor(coordinator))
     async_add_entities(entities)
 

homeassistant/components/gardena_bluetooth/switch.py

@@ -35,9 +35,9 @@ class GardenaBluetoothValveSwitch(GardenaBluetoothEntity, SwitchEntity):
     """Representation of a valve switch."""
 
     characteristics = {
-        Valve.state.uuid,
-        Valve.manual_watering_time.uuid,
-        Valve.remaining_open_time.uuid,
+        Valve.state.unique_id,
+        Valve.manual_watering_time.unique_id,
+        Valve.remaining_open_time.unique_id,
     }
 
     def __init__(
@@ -48,7 +48,7 @@ class GardenaBluetoothValveSwitch(GardenaBluetoothEntity, SwitchEntity):
         super().__init__(
             coordinator, {Valve.state.uuid, Valve.manual_watering_time.uuid}
         )
-        self._attr_unique_id = f"{coordinator.address}-{Valve.state.uuid}"
+        self._attr_unique_id = f"{coordinator.address}-{Valve.state.unique_id}"
         self._attr_translation_key = "state"
         self._attr_is_on = None
         self._attr_entity_registry_enabled_default = False

homeassistant/components/gardena_bluetooth/util.py

@@ -0,0 +1,51 @@
+"""Utility functions for Gardena Bluetooth integration."""
+
+import asyncio
+from collections.abc import AsyncIterator
+
+from gardena_bluetooth.parse import ManufacturerData, ProductType
+
+from homeassistant.components import bluetooth
+
+
+async def _async_service_info(
+    hass, address
+) -> AsyncIterator[bluetooth.BluetoothServiceInfoBleak]:
+    queue = asyncio.Queue[bluetooth.BluetoothServiceInfoBleak]()
+
+    def _callback(
+        service_info: bluetooth.BluetoothServiceInfoBleak,
+        change: bluetooth.BluetoothChange,
+    ) -> None:
+        if change != bluetooth.BluetoothChange.ADVERTISEMENT:
+            return
+
+        queue.put_nowait(service_info)
+
+    service_info = bluetooth.async_last_service_info(hass, address, True)
+    if service_info:
+        yield service_info
+
+    cancel = bluetooth.async_register_callback(
+        hass,
+        _callback,
+        {bluetooth.match.ADDRESS: address},
+        bluetooth.BluetoothScanningMode.ACTIVE,
+    )
+    try:
+        while True:
+            yield await queue.get()
+    finally:
+        cancel()
+
+
+async def async_get_product_type(hass, address: str) -> ProductType:
+    """Wait for enough packets of manufacturer data to get the product type."""
+    data = ManufacturerData()
+
+    async for service_info in _async_service_info(hass, address):
+        data.update(service_info.manufacturer_data.get(ManufacturerData.company, b""))
+        product_type = ProductType.from_manufacturer_data(data)
+        if product_type is not ProductType.UNKNOWN:
+            return product_type
+    raise AssertionError("Iterator should have been infinite")

homeassistant/components/gardena_bluetooth/valve.py

@@ -44,9 +44,9 @@ class GardenaBluetoothValve(GardenaBluetoothEntity, ValveEntity):
     _attr_device_class = ValveDeviceClass.WATER
 
     characteristics = {
-        Valve.state.uuid,
-        Valve.manual_watering_time.uuid,
-        Valve.remaining_open_time.uuid,
+        Valve.state.unique_id,
+        Valve.manual_watering_time.unique_id,
+        Valve.remaining_open_time.unique_id,
     }
 
     def __init__(
@@ -57,7 +57,7 @@ class GardenaBluetoothValve(GardenaBluetoothEntity, ValveEntity):
         super().__init__(
             coordinator, {Valve.state.uuid, Valve.manual_watering_time.uuid}
         )
-        self._attr_unique_id = f"{coordinator.address}-{Valve.state.uuid}"
+        self._attr_unique_id = f"{coordinator.address}-{Valve.state.unique_id}"
 
     def _handle_coordinator_update(self) -> None:
         self._attr_is_closed = not self.coordinator.get_cached(Valve.state)

homeassistant/components/gate/__init__.py

@@ -0,0 +1,17 @@
+"""Integration for gate triggers."""
+
+from __future__ import annotations
+
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.typing import ConfigType
+
+DOMAIN = "gate"
+CONFIG_SCHEMA = cv.empty_config_schema(DOMAIN)
+
+__all__ = []
+
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the component."""
+    return True

homeassistant/components/gate/icons.json

@@ -0,0 +1,10 @@
+{
+  "triggers": {
+    "closed": {
+      "trigger": "mdi:gate"
+    },
+    "opened": {
+      "trigger": "mdi:gate-open"
+    }
+  }
+}

homeassistant/components/gate/manifest.json

@@ -0,0 +1,8 @@
+{
+  "domain": "gate",
+  "name": "Gate",
+  "codeowners": ["@home-assistant/core"],
+  "documentation": "https://www.home-assistant.io/integrations/gate",
+  "integration_type": "system",
+  "quality_scale": "internal"
+}

homeassistant/components/gate/strings.json

@@ -0,0 +1,38 @@
+{
+  "common": {
+    "trigger_behavior_description": "The behavior of the targeted gates to trigger on.",
+    "trigger_behavior_name": "Behavior"
+  },
+  "selector": {
+    "trigger_behavior": {
+      "options": {
+        "any": "Any",
+        "first": "First",
+        "last": "Last"
+      }
+    }
+  },
+  "title": "Gate",
+  "triggers": {
+    "closed": {
+      "description": "Triggers after one or more gates close.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::gate::common::trigger_behavior_description%]",
+          "name": "[%key:component::gate::common::trigger_behavior_name%]"
+        }
+      },
+      "name": "Gate closed"
+    },
+    "opened": {
+      "description": "Triggers after one or more gates open.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::gate::common::trigger_behavior_description%]",
+          "name": "[%key:component::gate::common::trigger_behavior_name%]"
+        }
+      },
+      "name": "Gate opened"
+    }
+  }
+}

homeassistant/components/gate/trigger.py

@@ -0,0 +1,25 @@
+"""Provides triggers for gates."""
+
+from homeassistant.components.cover import (
+    DOMAIN as COVER_DOMAIN,
+    CoverDeviceClass,
+    make_cover_closed_trigger,
+    make_cover_opened_trigger,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.trigger import Trigger
+
+DEVICE_CLASSES_GATE: dict[str, str] = {
+    COVER_DOMAIN: CoverDeviceClass.GATE,
+}
+
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "opened": make_cover_opened_trigger(device_classes=DEVICE_CLASSES_GATE),
+    "closed": make_cover_closed_trigger(device_classes=DEVICE_CLASSES_GATE),
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for gates."""
+    return TRIGGERS

homeassistant/components/gate/triggers.yaml

@@ -10,16 +10,16 @@
           - last
           - any
 
-occupancy_cleared:
+closed:
   fields: *trigger_common_fields
   target:
     entity:
-      domain: binary_sensor
-      device_class: occupancy
+      - domain: cover
+        device_class: gate
 
-occupancy_detected:
+opened:
   fields: *trigger_common_fields
   target:
     entity:
-      domain: binary_sensor
-      device_class: occupancy
+      - domain: cover
+        device_class: gate

homeassistant/components/ghost/manifest.json

@@ -7,6 +7,6 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["aioghost"],
-  "quality_scale": "silver",
+  "quality_scale": "gold",
   "requirements": ["aioghost==0.4.0"]
 }

homeassistant/components/google_sheets/__init__.py

@@ -7,7 +7,12 @@ import aiohttp
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_TOKEN
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
+from homeassistant.exceptions import (
+    ConfigEntryAuthFailed,
+    ConfigEntryNotReady,
+    OAuth2TokenRequestError,
+    OAuth2TokenRequestReauthError,
+)
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.config_entry_oauth2_flow import (
     OAuth2Session,
@@ -39,11 +44,11 @@ async def async_setup_entry(
     session = OAuth2Session(hass, entry, implementation)
     try:
         await session.async_ensure_token_valid()
-    except aiohttp.ClientResponseError as err:
-        if 400 <= err.status < 500:
-            raise ConfigEntryAuthFailed(
-                "OAuth session is not valid, reauth required"
-            ) from err
+    except OAuth2TokenRequestReauthError as err:
+        raise ConfigEntryAuthFailed(
+            "OAuth session is not valid, reauth required"
+        ) from err
+    except OAuth2TokenRequestError as err:
         raise ConfigEntryNotReady from err
     except aiohttp.ClientError as err:
         raise ConfigEntryNotReady from err

homeassistant/components/group/entity.py

@@ -7,7 +7,13 @@ from collections.abc import Callable, Collection, Mapping
 import logging
 from typing import Any
 
-from homeassistant.const import ATTR_ASSUMED_STATE, ATTR_ENTITY_ID, STATE_OFF, STATE_ON
+from homeassistant.const import (
+    ATTR_ASSUMED_STATE,
+    ATTR_ENTITY_ID,
+    ATTR_GROUP_ENTITIES,
+    STATE_OFF,
+    STATE_ON,
+)
 from homeassistant.core import (
     CALLBACK_TYPE,
     Event,
@@ -35,7 +41,7 @@ _LOGGER = logging.getLogger(__name__)
 class GroupEntity(Entity):
     """Representation of a Group of entities."""
 
-    _unrecorded_attributes = frozenset({ATTR_ENTITY_ID})
+    _unrecorded_attributes = frozenset({ATTR_ENTITY_ID, ATTR_GROUP_ENTITIES})
 
     _attr_should_poll = False
     _entity_ids: list[str]

homeassistant/components/group/lock.py

@@ -20,9 +20,6 @@ from homeassistant.const import (
     CONF_ENTITIES,
     CONF_NAME,
     CONF_UNIQUE_ID,
-    SERVICE_LOCK,
-    SERVICE_OPEN,
-    SERVICE_UNLOCK,
     STATE_UNAVAILABLE,
     STATE_UNKNOWN,
 )
@@ -32,6 +29,7 @@ from homeassistant.helpers.entity_platform import (
     AddConfigEntryEntitiesCallback,
     AddEntitiesCallback,
 )
+from homeassistant.helpers.group import GenericGroup
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
 from .entity import GroupEntity
@@ -117,47 +115,13 @@ class LockGroup(GroupEntity, LockEntity):
     ) -> None:
         """Initialize a lock group."""
         self._entity_ids = entity_ids
+        self.group = GenericGroup(self, entity_ids)
         self._attr_supported_features = LockEntityFeature.OPEN
 
         self._attr_name = name
         self._attr_extra_state_attributes = {ATTR_ENTITY_ID: entity_ids}
         self._attr_unique_id = unique_id
 
-    async def async_lock(self, **kwargs: Any) -> None:
-        """Forward the lock command to all locks in the group."""
-        data = {ATTR_ENTITY_ID: self._entity_ids}
-        _LOGGER.debug("Forwarded lock command: %s", data)
-
-        await self.hass.services.async_call(
-            LOCK_DOMAIN,
-            SERVICE_LOCK,
-            data,
-            blocking=True,
-            context=self._context,
-        )
-
-    async def async_unlock(self, **kwargs: Any) -> None:
-        """Forward the unlock command to all locks in the group."""
-        data = {ATTR_ENTITY_ID: self._entity_ids}
-        await self.hass.services.async_call(
-            LOCK_DOMAIN,
-            SERVICE_UNLOCK,
-            data,
-            blocking=True,
-            context=self._context,
-        )
-
-    async def async_open(self, **kwargs: Any) -> None:
-        """Forward the open command to all locks in the group."""
-        data = {ATTR_ENTITY_ID: self._entity_ids}
-        await self.hass.services.async_call(
-            LOCK_DOMAIN,
-            SERVICE_OPEN,
-            data,
-            blocking=True,
-            context=self._context,
-        )
-
     @callback
     def async_update_group_state(self) -> None:
         """Query all members and determine the lock group state."""

homeassistant/components/growatt_server/__init__.py

@@ -1,4 +1,28 @@
-"""The Growatt server PV inverter sensor integration."""
+"""The Growatt server PV inverter sensor integration.
+
+This integration supports two distinct Growatt APIs with different auth models:
+
+Classic API (username/password):
+- Authenticates via api.login(), which returns a dict with a "success" key.
+- Auth failure is signalled by success=False and msg="502" (LOGIN_INVALID_AUTH_CODE).
+- A failed login does NOT raise an exception — the return value must be checked.
+- The coordinator calls api.login() on every update cycle to maintain the session.
+
+Open API V1 (API token):
+- Stateless — no login call, token is sent as a Bearer header on every request.
+- Auth failure is signalled by raising GrowattV1ApiError with error_code=10011
+  (V1_API_ERROR_NO_PRIVILEGE). The library NEVER returns a failure silently;
+  any non-zero error_code raises an exception via _process_response().
+- Because the library always raises on error, return-value validation after a
+  successful V1 API call is unnecessary — if it returned, the token was valid.
+
+Error handling pattern for reauth:
+- Classic API: check NOT login_response["success"] and msg == LOGIN_INVALID_AUTH_CODE
+  → raise ConfigEntryAuthFailed
+- V1 API: catch GrowattV1ApiError with error_code == V1_API_ERROR_NO_PRIVILEGE
+  → raise ConfigEntryAuthFailed
+- All other errors → ConfigEntryError (setup) or UpdateFailed (coordinator)
+"""
 
 from collections.abc import Mapping
 from json import JSONDecodeError
@@ -25,6 +49,7 @@ from .const import (
     DOMAIN,
     LOGIN_INVALID_AUTH_CODE,
     PLATFORMS,
+    V1_API_ERROR_NO_PRIVILEGE,
 )
 from .coordinator import GrowattConfigEntry, GrowattCoordinator
 from .models import GrowattRuntimeData
@@ -227,8 +252,12 @@ def get_device_list_v1(
     try:
         devices_dict = api.device_list(plant_id)
     except growattServer.GrowattV1ApiError as e:
+        if e.error_code == V1_API_ERROR_NO_PRIVILEGE:
+            raise ConfigEntryAuthFailed(
+                f"Authentication failed for Growatt API: {e.error_msg or str(e)}"
+            ) from e
         raise ConfigEntryError(
-            f"API error during device list: {e} (Code: {getattr(e, 'error_code', None)}, Message: {getattr(e, 'error_msg', None)})"
+            f"API error during device list: {e.error_msg or str(e)} (Code: {e.error_code})"
         ) from e
     devices = devices_dict.get("devices", [])
     # Only MIN device (type = 7) support implemented in current V1 API
@@ -272,6 +301,7 @@ async def async_setup_entry(
         # V1 API (token-based, no login needed)
         token = config[CONF_TOKEN]
         api = growattServer.OpenApiV1(token=token)
+        api.server_url = url
         devices, plant_id = await hass.async_add_executor_job(
             get_device_list_v1, api, config
         )

homeassistant/components/growatt_server/config_flow.py

@@ -1,5 +1,6 @@
 """Config flow for growatt server integration."""
 
+from collections.abc import Mapping
 import logging
 from typing import Any
 
@@ -31,8 +32,11 @@ from .const import (
     ERROR_INVALID_AUTH,
     LOGIN_INVALID_AUTH_CODE,
     SERVER_URLS_NAMES,
+    V1_API_ERROR_NO_PRIVILEGE,
 )
 
+_URL_TO_REGION = {v: k for k, v in SERVER_URLS_NAMES.items()}
+
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -60,6 +64,137 @@ class GrowattServerConfigFlow(ConfigFlow, domain=DOMAIN):
             menu_options=["password_auth", "token_auth"],
         )
 
+    async def async_step_reauth(self, _: Mapping[str, Any]) -> ConfigFlowResult:
+        """Handle reauth."""
+        return await self.async_step_reauth_confirm()
+
+    async def async_step_reauth_confirm(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle reauth confirmation."""
+        errors: dict[str, str] = {}
+        reauth_entry = self._get_reauth_entry()
+
+        if user_input is not None:
+            auth_type = reauth_entry.data.get(CONF_AUTH_TYPE)
+
+            if auth_type == AUTH_PASSWORD:
+                server_url = SERVER_URLS_NAMES[user_input[CONF_REGION]]
+                api = growattServer.GrowattApi(
+                    add_random_user_id=True,
+                    agent_identifier=user_input[CONF_USERNAME],
+                )
+                api.server_url = server_url
+
+                try:
+                    login_response = await self.hass.async_add_executor_job(
+                        api.login, user_input[CONF_USERNAME], user_input[CONF_PASSWORD]
+                    )
+                except requests.exceptions.RequestException as ex:
+                    _LOGGER.debug("Network error during reauth login: %s", ex)
+                    errors["base"] = ERROR_CANNOT_CONNECT
+                except (ValueError, KeyError, TypeError, AttributeError) as ex:
+                    _LOGGER.debug("Invalid response format during reauth login: %s", ex)
+                    errors["base"] = ERROR_CANNOT_CONNECT
+                else:
+                    if not isinstance(login_response, dict):
+                        errors["base"] = ERROR_CANNOT_CONNECT
+                    elif login_response.get("success"):
+                        return self.async_update_reload_and_abort(
+                            reauth_entry,
+                            data_updates={
+                                CONF_USERNAME: user_input[CONF_USERNAME],
+                                CONF_PASSWORD: user_input[CONF_PASSWORD],
+                                CONF_URL: server_url,
+                            },
+                        )
+                    elif login_response.get("msg") == LOGIN_INVALID_AUTH_CODE:
+                        errors["base"] = ERROR_INVALID_AUTH
+                    else:
+                        errors["base"] = ERROR_CANNOT_CONNECT
+
+            elif auth_type == AUTH_API_TOKEN:
+                server_url = SERVER_URLS_NAMES[user_input[CONF_REGION]]
+                api = growattServer.OpenApiV1(token=user_input[CONF_TOKEN])
+                api.server_url = server_url
+
+                try:
+                    await self.hass.async_add_executor_job(api.plant_list)
+                except requests.exceptions.RequestException as ex:
+                    _LOGGER.debug(
+                        "Network error during reauth token validation: %s", ex
+                    )
+                    errors["base"] = ERROR_CANNOT_CONNECT
+                except growattServer.GrowattV1ApiError as err:
+                    if err.error_code == V1_API_ERROR_NO_PRIVILEGE:
+                        errors["base"] = ERROR_INVALID_AUTH
+                    else:
+                        _LOGGER.debug(
+                            "Growatt V1 API error during reauth: %s (Code: %s)",
+                            err.error_msg or str(err),
+                            err.error_code,
+                        )
+                        errors["base"] = ERROR_CANNOT_CONNECT
+                except (ValueError, KeyError, TypeError, AttributeError) as ex:
+                    _LOGGER.debug(
+                        "Invalid response format during reauth token validation: %s", ex
+                    )
+                    errors["base"] = ERROR_CANNOT_CONNECT
+                else:
+                    return self.async_update_reload_and_abort(
+                        reauth_entry,
+                        data_updates={
+                            CONF_TOKEN: user_input[CONF_TOKEN],
+                            CONF_URL: server_url,
+                        },
+                    )
+
+        # Determine the current region key from the stored config value.
+        # Legacy entries may store the region key directly; newer entries store the URL.
+        stored_url = reauth_entry.data.get(CONF_URL, "")
+        if stored_url in SERVER_URLS_NAMES:
+            current_region = stored_url
+        else:
+            current_region = _URL_TO_REGION.get(stored_url, DEFAULT_URL)
+
+        auth_type = reauth_entry.data.get(CONF_AUTH_TYPE)
+        if auth_type == AUTH_PASSWORD:
+            data_schema = vol.Schema(
+                {
+                    vol.Required(
+                        CONF_USERNAME,
+                        default=reauth_entry.data.get(CONF_USERNAME),
+                    ): str,
+                    vol.Required(CONF_PASSWORD): str,
+                    vol.Required(CONF_REGION, default=current_region): SelectSelector(
+                        SelectSelectorConfig(
+                            options=list(SERVER_URLS_NAMES.keys()),
+                            translation_key="region",
+                        )
+                    ),
+                }
+            )
+        elif auth_type == AUTH_API_TOKEN:
+            data_schema = vol.Schema(
+                {
+                    vol.Required(CONF_TOKEN): str,
+                    vol.Required(CONF_REGION, default=current_region): SelectSelector(
+                        SelectSelectorConfig(
+                            options=list(SERVER_URLS_NAMES.keys()),
+                            translation_key="region",
+                        )
+                    ),
+                }
+            )
+        else:
+            return self.async_abort(reason=ERROR_CANNOT_CONNECT)
+
+        return self.async_show_form(
+            step_id="reauth_confirm",
+            data_schema=data_schema,
+            errors=errors,
+        )
+
     async def async_step_password_auth(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
@@ -129,9 +264,11 @@ class GrowattServerConfigFlow(ConfigFlow, domain=DOMAIN):
             _LOGGER.error(
                 "Growatt V1 API error: %s (Code: %s)",
                 e.error_msg or str(e),
-                getattr(e, "error_code", None),
+                e.error_code,
             )
-            return self._async_show_token_form({"base": ERROR_INVALID_AUTH})
+            if e.error_code == V1_API_ERROR_NO_PRIVILEGE:
+                return self._async_show_token_form({"base": ERROR_INVALID_AUTH})
+            return self._async_show_token_form({"base": ERROR_CANNOT_CONNECT})
         except (ValueError, KeyError, TypeError, AttributeError) as ex:
             _LOGGER.error(
                 "Invalid response format during Growatt V1 API plant list: %s", ex

homeassistant/components/growatt_server/const.py

@@ -40,8 +40,17 @@ DOMAIN = "growatt_server"
 
 PLATFORMS = [Platform.NUMBER, Platform.SENSOR, Platform.SWITCH]
 
+# Growatt Classic API error codes
 LOGIN_INVALID_AUTH_CODE = "502"
 
+# Growatt Open API V1 error codes
+# Reference: https://www.showdoc.com.cn/262556420217021/1494055648380019
+V1_API_ERROR_WRONG_DOMAIN = -1  # Use correct regional domain
+V1_API_ERROR_NO_PRIVILEGE = 10011  # No privilege access — invalid or expired token
+V1_API_ERROR_RATE_LIMITED = 10012  # Access frequency limit (5 minutes per call)
+V1_API_ERROR_PAGE_SIZE = 10013  # Page size cannot exceed 100
+V1_API_ERROR_PAGE_COUNT = 10014  # Page count cannot exceed 250
+
 # Config flow error types (also used as abort reasons)
 ERROR_CANNOT_CONNECT = "cannot_connect"  # Used for both form errors and aborts
 ERROR_INVALID_AUTH = "invalid_auth"

homeassistant/components/growatt_server/coordinator.py

@@ -13,7 +13,11 @@ from homeassistant.components.sensor import SensorStateClass
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_PASSWORD, CONF_URL, CONF_USERNAME
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
+from homeassistant.exceptions import (
+    ConfigEntryAuthFailed,
+    HomeAssistantError,
+    ServiceValidationError,
+)
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 from homeassistant.util import dt as dt_util
 
@@ -23,6 +27,8 @@ from .const import (
     BATT_MODE_LOAD_FIRST,
     DEFAULT_URL,
     DOMAIN,
+    LOGIN_INVALID_AUTH_CODE,
+    V1_API_ERROR_NO_PRIVILEGE,
 )
 from .models import GrowattRuntimeData
 
@@ -63,6 +69,7 @@ class GrowattCoordinator(DataUpdateCoordinator[dict[str, Any]]):
             self.url = config_entry.data.get(CONF_URL, DEFAULT_URL)
             self.token = config_entry.data["token"]
             self.api = growattServer.OpenApiV1(token=self.token)
+            self.api.server_url = self.url
         elif self.api_version == "classic":
             self.username = config_entry.data.get(CONF_USERNAME)
             self.password = config_entry.data[CONF_PASSWORD]
@@ -88,7 +95,14 @@ class GrowattCoordinator(DataUpdateCoordinator[dict[str, Any]]):
 
         # login only required for classic API
         if self.api_version == "classic":
-            self.api.login(self.username, self.password)
+            login_response = self.api.login(self.username, self.password)
+            if not login_response.get("success"):
+                msg = login_response.get("msg", "Unknown error")
+                if msg == LOGIN_INVALID_AUTH_CODE:
+                    raise ConfigEntryAuthFailed(
+                        "Username, password, or URL may be incorrect"
+                    )
+                raise UpdateFailed(f"Growatt login failed: {msg}")
 
         if self.device_type == "total":
             if self.api_version == "v1":
@@ -100,7 +114,16 @@ class GrowattCoordinator(DataUpdateCoordinator[dict[str, Any]]):
                 # todayEnergy -> today_energy
                 # totalEnergy -> total_energy
                 # invTodayPpv -> current_power
-                total_info = self.api.plant_energy_overview(self.plant_id)
+                try:
+                    total_info = self.api.plant_energy_overview(self.plant_id)
+                except growattServer.GrowattV1ApiError as err:
+                    if err.error_code == V1_API_ERROR_NO_PRIVILEGE:
+                        raise ConfigEntryAuthFailed(
+                            f"Authentication failed for Growatt API: {err.error_msg or str(err)}"
+                        ) from err
+                    raise UpdateFailed(
+                        f"Error fetching plant energy overview: {err}"
+                    ) from err
                 total_info["todayEnergy"] = total_info["today_energy"]
                 total_info["totalEnergy"] = total_info["total_energy"]
                 total_info["invTodayPpv"] = total_info["current_power"]
@@ -122,6 +145,10 @@ class GrowattCoordinator(DataUpdateCoordinator[dict[str, Any]]):
                 min_settings = self.api.min_settings(self.device_id)
                 min_energy = self.api.min_energy(self.device_id)
             except growattServer.GrowattV1ApiError as err:
+                if err.error_code == V1_API_ERROR_NO_PRIVILEGE:
+                    raise ConfigEntryAuthFailed(
+                        f"Authentication failed for Growatt API: {err.error_msg or str(err)}"
+                    ) from err
                 raise UpdateFailed(f"Error fetching min device data: {err}") from err
 
             min_info = {**min_details, **min_settings, **min_energy}

homeassistant/components/growatt_server/quality_scale.yaml

@@ -30,7 +30,7 @@ rules:
   integration-owner: done
   log-when-unavailable: done
   parallel-updates: done
-  reauthentication-flow: todo
+  reauthentication-flow: done
   test-coverage: done
 
   # Gold

homeassistant/components/growatt_server/strings.json

@@ -3,7 +3,8 @@
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "no_plants": "No plants have been found on this account"
+      "no_plants": "No plants have been found on this account",
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
     },
     "error": {
       "cannot_connect": "Cannot connect to Growatt servers. Please check your internet connection and try again.",
@@ -13,7 +14,7 @@
       "password_auth": {
         "data": {
           "password": "[%key:common::config_flow::data::password%]",
-          "url": "Server region",
+          "region": "Server region",
           "username": "[%key:common::config_flow::data::username%]"
         },
         "title": "Enter your Growatt login credentials"
@@ -24,10 +25,20 @@
         },
         "title": "Select your plant"
       },
+      "reauth_confirm": {
+        "data": {
+          "password": "[%key:common::config_flow::data::password%]",
+          "region": "[%key:component::growatt_server::config::step::password_auth::data::region%]",
+          "token": "[%key:component::growatt_server::config::step::token_auth::data::token%]",
+          "username": "[%key:common::config_flow::data::username%]"
+        },
+        "description": "Re-enter your credentials to continue using this integration.",
+        "title": "Re-authenticate with Growatt"
+      },
       "token_auth": {
         "data": {
-          "token": "API Token",
-          "url": "Server region"
+          "region": "[%key:component::growatt_server::config::step::password_auth::data::region%]",
+          "token": "API Token"
         },
         "description": "Token authentication is only supported for MIN/TLX devices. For other device types, please use username/password authentication.",
         "title": "Enter your API token"

homeassistant/components/hassio/addon_manager.py

@@ -10,7 +10,11 @@ from functools import partial, wraps
 import logging
 from typing import Any, Concatenate
 
-from aiohasupervisor import SupervisorError
+from aiohasupervisor import (
+    AddonNotSupportedError,
+    SupervisorError,
+    SupervisorNotFoundError,
+)
 from aiohasupervisor.models import (
     AddonsOptions,
     AddonState as SupervisorAddonState,
@@ -165,15 +169,7 @@ class AddonManager:
             )
 
         addon_info = await self._supervisor_client.addons.addon_info(self.addon_slug)
-        addon_state = self.async_get_addon_state(addon_info)
-        return AddonInfo(
-            available=addon_info.available,
-            hostname=addon_info.hostname,
-            options=addon_info.options,
-            state=addon_state,
-            update_available=addon_info.update_available,
-            version=addon_info.version,
-        )
+        return self.async_convert_installed_app_info(addon_info)
 
     @callback
     def async_get_addon_state(self, addon_info: InstalledAddonComplete) -> AddonState:
@@ -189,6 +185,20 @@ class AddonManager:
 
         return addon_state
 
+    @callback
+    def async_convert_installed_app_info(
+        self, app_info: InstalledAddonComplete
+    ) -> AddonInfo:
+        """Convert InstalledAddonComplete model to AddonInfo model."""
+        return AddonInfo(
+            available=app_info.available,
+            hostname=app_info.hostname,
+            options=app_info.options,
+            state=self.async_get_addon_state(app_info),
+            update_available=app_info.update_available,
+            version=app_info.version,
+        )
+
     @api_error(
         "Failed to set the {addon_name} app options",
         expected_error_type=SupervisorError,
@@ -199,21 +209,17 @@ class AddonManager:
             self.addon_slug, AddonsOptions(config=config)
         )
 
-    def _check_addon_available(self, addon_info: AddonInfo) -> None:
-        """Check if the managed add-on is available."""
-        if not addon_info.available:
-            raise AddonError(f"{self.addon_name} app is not available")
-
     @api_error(
         "Failed to install the {addon_name} app", expected_error_type=SupervisorError
     )
     async def async_install_addon(self) -> None:
         """Install the managed add-on."""
-        addon_info = await self.async_get_addon_info()
-
-        self._check_addon_available(addon_info)
-
-        await self._supervisor_client.store.install_addon(self.addon_slug)
+        try:
+            await self._supervisor_client.store.install_addon(self.addon_slug)
+        except AddonNotSupportedError as err:
+            raise AddonError(
+                f"{self.addon_name} app is not available: {err!s}"
+            ) from None
 
     @api_error(
         "Failed to uninstall the {addon_name} app",
@@ -226,17 +232,24 @@ class AddonManager:
     @api_error("Failed to update the {addon_name} app")
     async def async_update_addon(self) -> None:
         """Update the managed add-on if needed."""
-        addon_info = await self.async_get_addon_info()
+        try:
+            app_info = await self._supervisor_client.addons.addon_info(self.addon_slug)
+        except SupervisorNotFoundError:
+            raise AddonError(f"{self.addon_name} app is not installed") from None
 
-        self._check_addon_available(addon_info)
-
-        if addon_info.state is AddonState.NOT_INSTALLED:
-            raise AddonError(f"{self.addon_name} app is not installed")
-
-        if not addon_info.update_available:
+        if not app_info.update_available:
             return
 
-        await self.async_create_backup()
+        try:
+            await self._supervisor_client.store.addon_availability(self.addon_slug)
+        except AddonNotSupportedError as err:
+            raise AddonError(
+                f"{self.addon_name} app is not available: {err!s}"
+            ) from None
+
+        await self.async_create_backup(
+            app_info=self.async_convert_installed_app_info(app_info)
+        )
         await self._supervisor_client.store.update_addon(
             self.addon_slug, StoreAddonUpdate(backup=False)
         )
@@ -266,10 +279,14 @@ class AddonManager:
         "Failed to create a backup of the {addon_name} app",
         expected_error_type=SupervisorError,
     )
-    async def async_create_backup(self) -> None:
+    async def async_create_backup(self, *, app_info: AddonInfo | None = None) -> None:
         """Create a partial backup of the managed add-on."""
-        addon_info = await self.async_get_addon_info()
-        name = f"addon_{self.addon_slug}_{addon_info.version}"
+        if app_info:
+            app_version = app_info.version
+        else:
+            app_version = (await self.async_get_addon_info()).version
+
+        name = f"addon_{self.addon_slug}_{app_version}"
 
         self._logger.debug("Creating backup: %s", name)
         await self._supervisor_client.backups.partial_backup(

homeassistant/components/home_connect/__init__.py

@@ -38,6 +38,7 @@ CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 PLATFORMS = [
     Platform.BINARY_SENSOR,
     Platform.BUTTON,
+    Platform.FAN,
     Platform.LIGHT,
     Platform.NUMBER,
     Platform.SELECT,

homeassistant/components/home_connect/common.py

@@ -19,7 +19,7 @@ from .coordinator import (
     HomeConnectApplianceData,
     HomeConnectConfigEntry,
 )
-from .entity import HomeConnectEntity, HomeConnectOptionEntity
+from .entity import HomeConnectEntity
 
 
 def should_add_option_entity(
@@ -48,7 +48,7 @@ def _create_option_entities(
     known_entity_unique_ids: dict[str, str],
     get_option_entities_for_appliance: Callable[
         [HomeConnectApplianceCoordinator, er.EntityRegistry],
-        list[HomeConnectOptionEntity],
+        list[HomeConnectEntity],
     ],
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
@@ -78,7 +78,7 @@ def _handle_paired_or_connected_appliance(
     ],
     get_option_entities_for_appliance: Callable[
         [HomeConnectApplianceCoordinator, er.EntityRegistry],
-        list[HomeConnectOptionEntity],
+        list[HomeConnectEntity],
     ]
     | None,
     changed_options_listener_remove_callbacks: dict[str, list[Callable[[], None]]],
@@ -161,7 +161,7 @@ def setup_home_connect_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
     get_option_entities_for_appliance: Callable[
         [HomeConnectApplianceCoordinator, er.EntityRegistry],
-        list[HomeConnectOptionEntity],
+        list[HomeConnectEntity],
     ]
     | None = None,
 ) -> None:

homeassistant/components/home_connect/fan.py

@@ -0,0 +1,235 @@
+"""Provides fan entities for Home Connect."""
+
+import contextlib
+import logging
+from typing import cast
+
+from aiohomeconnect.model import EventKey, OptionKey
+from aiohomeconnect.model.error import ActiveProgramNotSetError, HomeConnectError
+
+from homeassistant.components.fan import (
+    FanEntity,
+    FanEntityDescription,
+    FanEntityFeature,
+)
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .common import setup_home_connect_entry
+from .const import DOMAIN
+from .coordinator import HomeConnectApplianceCoordinator, HomeConnectConfigEntry
+from .entity import HomeConnectEntity
+from .utils import get_dict_from_home_connect_error
+
+_LOGGER = logging.getLogger(__name__)
+
+PARALLEL_UPDATES = 1
+
+FAN_SPEED_MODE_OPTIONS = {
+    "auto": "HeatingVentilationAirConditioning.AirConditioner.EnumType.FanSpeedMode.Automatic",
+    "manual": "HeatingVentilationAirConditioning.AirConditioner.EnumType.FanSpeedMode.Manual",
+}
+FAN_SPEED_MODE_OPTIONS_INVERTED = {v: k for k, v in FAN_SPEED_MODE_OPTIONS.items()}
+
+
+AIR_CONDITIONER_ENTITY_DESCRIPTION = FanEntityDescription(
+    key="air_conditioner",
+    translation_key="air_conditioner",
+    name=None,
+)
+
+
+def _get_entities_for_appliance(
+    appliance_coordinator: HomeConnectApplianceCoordinator,
+) -> list[HomeConnectEntity]:
+    """Get a list of entities."""
+    return (
+        [HomeConnectAirConditioningFanEntity(appliance_coordinator)]
+        if appliance_coordinator.data.options
+        and any(
+            option in appliance_coordinator.data.options
+            for option in (
+                OptionKey.HEATING_VENTILATION_AIR_CONDITIONING_AIR_CONDITIONER_FAN_SPEED_MODE,
+                OptionKey.HEATING_VENTILATION_AIR_CONDITIONING_AIR_CONDITIONER_FAN_SPEED_PERCENTAGE,
+            )
+        )
+        else []
+    )
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: HomeConnectConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up the Home Connect fan entities."""
+    setup_home_connect_entry(
+        hass,
+        entry,
+        _get_entities_for_appliance,
+        async_add_entities,
+        lambda appliance_coordinator, _: _get_entities_for_appliance(
+            appliance_coordinator
+        ),
+    )
+
+
+class HomeConnectAirConditioningFanEntity(HomeConnectEntity, FanEntity):
+    """Representation of a Home Connect fan entity."""
+
+    def __init__(
+        self,
+        coordinator: HomeConnectApplianceCoordinator,
+    ) -> None:
+        """Initialize the entity."""
+        self._attr_preset_modes = list(FAN_SPEED_MODE_OPTIONS.keys())
+        self._original_speed_modes_keys = set(FAN_SPEED_MODE_OPTIONS_INVERTED)
+        super().__init__(
+            coordinator,
+            AIR_CONDITIONER_ENTITY_DESCRIPTION,
+            context_override=(
+                EventKey.HEATING_VENTILATION_AIR_CONDITIONING_AIR_CONDITIONER_FAN_SPEED_PERCENTAGE
+            ),
+        )
+        self.update_preset_mode()
+
+    @callback
+    def _handle_coordinator_update_preset_mode(self) -> None:
+        """Handle updated data from the coordinator."""
+        self.update_preset_mode()
+        self.async_write_ha_state()
+        _LOGGER.debug(
+            "Updated %s (fan mode), new state: %s", self.entity_id, self.preset_mode
+        )
+
+    async def async_added_to_hass(self) -> None:
+        """When entity is added to hass."""
+        await super().async_added_to_hass()
+        self.async_on_remove(
+            self.coordinator.async_add_listener(
+                self._handle_coordinator_update_preset_mode,
+                EventKey.HEATING_VENTILATION_AIR_CONDITIONING_AIR_CONDITIONER_FAN_SPEED_MODE,
+            )
+        )
+
+    def update_native_value(self) -> None:
+        """Set the speed percentage and speed mode values."""
+        option_value = None
+        option_key = OptionKey.HEATING_VENTILATION_AIR_CONDITIONING_AIR_CONDITIONER_FAN_SPEED_PERCENTAGE
+        if event := self.appliance.events.get(EventKey(option_key)):
+            option_value = event.value
+        self._attr_percentage = (
+            cast(int, option_value) if option_value is not None else None
+        )
+
+    @property
+    def supported_features(self) -> FanEntityFeature:
+        """Return the supported features for this fan entity."""
+        features = FanEntityFeature(0)
+        if (
+            OptionKey.HEATING_VENTILATION_AIR_CONDITIONING_AIR_CONDITIONER_FAN_SPEED_PERCENTAGE
+            in self.appliance.options
+        ):
+            features |= FanEntityFeature.SET_SPEED
+        if (
+            OptionKey.HEATING_VENTILATION_AIR_CONDITIONING_AIR_CONDITIONER_FAN_SPEED_MODE
+            in self.appliance.options
+        ):
+            features |= FanEntityFeature.PRESET_MODE
+        return features
+
+    def update_preset_mode(self) -> None:
+        """Set the preset mode value."""
+        option_value = None
+        option_key = OptionKey.HEATING_VENTILATION_AIR_CONDITIONING_AIR_CONDITIONER_FAN_SPEED_MODE
+        if event := self.appliance.events.get(EventKey(option_key)):
+            option_value = event.value
+        self._attr_preset_mode = (
+            FAN_SPEED_MODE_OPTIONS_INVERTED.get(cast(str, option_value))
+            if option_value is not None
+            else None
+        )
+        if (
+            (
+                option_definition := self.appliance.options.get(
+                    OptionKey.HEATING_VENTILATION_AIR_CONDITIONING_AIR_CONDITIONER_FAN_SPEED_MODE
+                )
+            )
+            and (option_constraints := option_definition.constraints)
+            and option_constraints.allowed_values
+            and (
+                allowed_values_without_none := {
+                    value
+                    for value in option_constraints.allowed_values
+                    if value is not None
+                }
+            )
+            and self._original_speed_modes_keys != allowed_values_without_none
+        ):
+            self._original_speed_modes_keys = allowed_values_without_none
+            self._attr_preset_modes = [
+                key
+                for key, value in FAN_SPEED_MODE_OPTIONS.items()
+                if value in self._original_speed_modes_keys
+            ]
+
+    async def async_set_percentage(self, percentage: int) -> None:
+        """Set the speed of the fan, as a percentage."""
+        await self._async_set_option(
+            OptionKey.HEATING_VENTILATION_AIR_CONDITIONING_AIR_CONDITIONER_FAN_SPEED_PERCENTAGE,
+            percentage,
+        )
+        _LOGGER.debug(
+            "Updated %s's speed percentage option, new state: %s",
+            self.entity_id,
+            percentage,
+        )
+
+    async def async_set_preset_mode(self, preset_mode: str) -> None:
+        """Set new target fan mode."""
+        await self._async_set_option(
+            OptionKey.HEATING_VENTILATION_AIR_CONDITIONING_AIR_CONDITIONER_FAN_SPEED_MODE,
+            FAN_SPEED_MODE_OPTIONS[preset_mode],
+        )
+        _LOGGER.debug(
+            "Updated %s's speed mode option, new state: %s",
+            self.entity_id,
+            self.state,
+        )
+
+    async def _async_set_option(self, key: OptionKey, value: str | int) -> None:
+        """Set an option for the entity."""
+        try:
+            # We try to set the active program option first,
+            # if it fails we try to set the selected program option
+            with contextlib.suppress(ActiveProgramNotSetError):
+                await self.coordinator.client.set_active_program_option(
+                    self.appliance.info.ha_id,
+                    option_key=key,
+                    value=value,
+                )
+                return
+
+            await self.coordinator.client.set_selected_program_option(
+                self.appliance.info.ha_id,
+                option_key=key,
+                value=value,
+            )
+        except HomeConnectError as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="set_option",
+                translation_placeholders=get_dict_from_home_connect_error(err),
+            ) from err
+
+    @property
+    def available(self) -> bool:
+        """Return True if entity is available."""
+        return super().available and any(
+            option in self.appliance.options
+            for option in (
+                OptionKey.HEATING_VENTILATION_AIR_CONDITIONING_AIR_CONDITIONER_FAN_SPEED_MODE,
+                OptionKey.HEATING_VENTILATION_AIR_CONDITIONING_AIR_CONDITIONER_FAN_SPEED_PERCENTAGE,
+            )
+        )

homeassistant/components/home_connect/number.py

@@ -136,7 +136,7 @@ def _get_entities_for_appliance(
 def _get_option_entities_for_appliance(
     appliance_coordinator: HomeConnectApplianceCoordinator,
     entity_registry: er.EntityRegistry,
-) -> list[HomeConnectOptionEntity]:
+) -> list[HomeConnectEntity]:
     """Get a list of currently available option entities."""
     return [
         HomeConnectOptionNumberEntity(appliance_coordinator, description)

homeassistant/components/home_connect/select.py

@@ -355,7 +355,7 @@ def _get_entities_for_appliance(
 def _get_option_entities_for_appliance(
     appliance_coordinator: HomeConnectApplianceCoordinator,
     entity_registry: er.EntityRegistry,
-) -> list[HomeConnectOptionEntity]:
+) -> list[HomeConnectEntity]:
     """Get a list of entities."""
     return [
         HomeConnectSelectOptionEntity(appliance_coordinator, desc)

homeassistant/components/home_connect/strings.json

@@ -119,6 +119,18 @@
         "name": "Stop program"
       }
     },
+    "fan": {
+      "air_conditioner": {
+        "state_attributes": {
+          "preset_mode": {
+            "state": {
+              "auto": "[%key:common::state::auto%]",
+              "manual": "[%key:common::state::manual%]"
+            }
+          }
+        }
+      }
+    },
     "light": {
       "ambient_light": {
         "name": "Ambient light"

homeassistant/components/home_connect/switch.py

@@ -189,7 +189,7 @@ def _get_entities_for_appliance(
 def _get_option_entities_for_appliance(
     appliance_coordinator: HomeConnectApplianceCoordinator,
     entity_registry: er.EntityRegistry,
-) -> list[HomeConnectOptionEntity]:
+) -> list[HomeConnectEntity]:
     """Get a list of currently available option entities."""
     return [
         HomeConnectSwitchOptionEntity(appliance_coordinator, description)

homeassistant/components/humidity/__init__.py

@@ -0,0 +1,17 @@
+"""Integration for humidity triggers."""
+
+from __future__ import annotations
+
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.typing import ConfigType
+
+DOMAIN = "humidity"
+CONFIG_SCHEMA = cv.empty_config_schema(DOMAIN)
+
+__all__ = []
+
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the component."""
+    return True

homeassistant/components/humidity/icons.json

@@ -0,0 +1,10 @@
+{
+  "triggers": {
+    "changed": {
+      "trigger": "mdi:water-percent"
+    },
+    "crossed_threshold": {
+      "trigger": "mdi:water-percent"
+    }
+  }
+}

homeassistant/components/humidity/manifest.json

@@ -0,0 +1,8 @@
+{
+  "domain": "humidity",
+  "name": "Humidity",
+  "codeowners": ["@home-assistant/core"],
+  "documentation": "https://www.home-assistant.io/integrations/humidity",
+  "integration_type": "system",
+  "quality_scale": "internal"
+}

homeassistant/components/humidity/strings.json

@@ -0,0 +1,68 @@
+{
+  "common": {
+    "trigger_behavior_description": "The behavior of the targeted entities to trigger on.",
+    "trigger_behavior_name": "Behavior"
+  },
+  "selector": {
+    "number_or_entity": {
+      "choices": {
+        "entity": "Entity",
+        "number": "Number"
+      }
+    },
+    "trigger_behavior": {
+      "options": {
+        "any": "Any",
+        "first": "First",
+        "last": "Last"
+      }
+    },
+    "trigger_threshold_type": {
+      "options": {
+        "above": "Above",
+        "below": "Below",
+        "between": "Between",
+        "outside": "Outside"
+      }
+    }
+  },
+  "title": "Humidity",
+  "triggers": {
+    "changed": {
+      "description": "Triggers when the relative humidity changes.",
+      "fields": {
+        "above": {
+          "description": "Only trigger when relative humidity is above this value.",
+          "name": "Above"
+        },
+        "below": {
+          "description": "Only trigger when relative humidity is below this value.",
+          "name": "Below"
+        }
+      },
+      "name": "Relative humidity changed"
+    },
+    "crossed_threshold": {
+      "description": "Triggers when the relative humidity crosses a threshold.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::humidity::common::trigger_behavior_description%]",
+          "name": "[%key:component::humidity::common::trigger_behavior_name%]"
+        },
+        "lower_limit": {
+          "description": "The lower limit of the threshold.",
+          "name": "Lower limit"
+        },
+        "threshold_type": {
+          "description": "The type of threshold to use.",
+          "name": "Threshold type"
+        },
+        "upper_limit": {
+          "description": "The upper limit of the threshold.",
+          "name": "Upper limit"
+        }
+      },
+      "name": "Relative humidity crossed threshold"
+    }
+  }
+}

homeassistant/components/humidity/trigger.py

@@ -0,0 +1,71 @@
+"""Provides triggers for humidity."""
+
+from __future__ import annotations
+
+from homeassistant.components.climate import (
+    ATTR_CURRENT_HUMIDITY as CLIMATE_ATTR_CURRENT_HUMIDITY,
+    DOMAIN as CLIMATE_DOMAIN,
+)
+from homeassistant.components.humidifier import (
+    ATTR_CURRENT_HUMIDITY as HUMIDIFIER_ATTR_CURRENT_HUMIDITY,
+    DOMAIN as HUMIDIFIER_DOMAIN,
+)
+from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN, SensorDeviceClass
+from homeassistant.components.weather import (
+    ATTR_WEATHER_HUMIDITY,
+    DOMAIN as WEATHER_DOMAIN,
+)
+from homeassistant.core import HomeAssistant, split_entity_id
+from homeassistant.helpers.trigger import (
+    EntityNumericalStateAttributeChangedTriggerBase,
+    EntityNumericalStateAttributeCrossedThresholdTriggerBase,
+    EntityTriggerBase,
+    Trigger,
+    get_device_class_or_undefined,
+)
+
+
+class _HumidityTriggerMixin(EntityTriggerBase):
+    """Mixin for humidity triggers providing entity filtering and value extraction."""
+
+    _attributes = {
+        CLIMATE_DOMAIN: CLIMATE_ATTR_CURRENT_HUMIDITY,
+        HUMIDIFIER_DOMAIN: HUMIDIFIER_ATTR_CURRENT_HUMIDITY,
+        SENSOR_DOMAIN: None,  # Use state.state
+        WEATHER_DOMAIN: ATTR_WEATHER_HUMIDITY,
+    }
+    _domains = {SENSOR_DOMAIN, CLIMATE_DOMAIN, HUMIDIFIER_DOMAIN, WEATHER_DOMAIN}
+
+    def entity_filter(self, entities: set[str]) -> set[str]:
+        """Filter entities: all climate/humidifier/weather, sensor only with device_class humidity."""
+        entities = super().entity_filter(entities)
+        return {
+            entity_id
+            for entity_id in entities
+            if split_entity_id(entity_id)[0] != SENSOR_DOMAIN
+            or get_device_class_or_undefined(self._hass, entity_id)
+            == SensorDeviceClass.HUMIDITY
+        }
+
+
+class HumidityChangedTrigger(
+    _HumidityTriggerMixin, EntityNumericalStateAttributeChangedTriggerBase
+):
+    """Trigger for humidity value changes across multiple domains."""
+
+
+class HumidityCrossedThresholdTrigger(
+    _HumidityTriggerMixin, EntityNumericalStateAttributeCrossedThresholdTriggerBase
+):
+    """Trigger for humidity value crossing a threshold across multiple domains."""
+
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "changed": HumidityChangedTrigger,
+    "crossed_threshold": HumidityCrossedThresholdTrigger,
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for humidity."""
+    return TRIGGERS

homeassistant/components/humidity/triggers.yaml

@@ -0,0 +1,65 @@
+.trigger_common_fields:
+  behavior: &trigger_behavior
+    required: true
+    default: any
+    selector:
+      select:
+        translation_key: trigger_behavior
+        options:
+          - first
+          - last
+          - any
+
+.number_or_entity: &number_or_entity
+  required: false
+  selector:
+    choose:
+      choices:
+        number:
+          selector:
+            number:
+              mode: box
+              unit_of_measurement: "%"
+        entity:
+          selector:
+            entity:
+              filter:
+                domain:
+                  - input_number
+                  - number
+                  - sensor
+      translation_key: number_or_entity
+
+.trigger_threshold_type: &trigger_threshold_type
+  required: true
+  default: above
+  selector:
+    select:
+      options:
+        - above
+        - below
+        - between
+        - outside
+      translation_key: trigger_threshold_type
+
+.trigger_target: &trigger_target
+  entity:
+    - domain: sensor
+      device_class: humidity
+    - domain: climate
+    - domain: humidifier
+    - domain: weather
+
+changed:
+  target: *trigger_target
+  fields:
+    above: *number_or_entity
+    below: *number_or_entity
+
+crossed_threshold:
+  target: *trigger_target
+  fields:
+    behavior: *trigger_behavior
+    threshold_type: *trigger_threshold_type
+    lower_limit: *number_or_entity
+    upper_limit: *number_or_entity

homeassistant/components/husqvarna_automower_ble/config_flow.py

@@ -58,7 +58,7 @@ def _is_supported(discovery_info: BluetoothServiceInfo):
 
     # Some mowers only expose the serial number in the manufacturer data
     # and not the product type, so we allow None here as well.
-    if product_type not in (ProductType.MOWER, None):
+    if product_type not in (ProductType.MOWER, ProductType.UNKNOWN):
         LOGGER.debug("Unsupported device: %s (%s)", manufacturer_data, discovery_info)
         return False
 

homeassistant/components/husqvarna_automower_ble/manifest.json

@@ -13,5 +13,5 @@
   "documentation": "https://www.home-assistant.io/integrations/husqvarna_automower_ble",
   "integration_type": "device",
   "iot_class": "local_polling",
-  "requirements": ["automower-ble==0.2.8", "gardena-bluetooth==1.6.0"]
+  "requirements": ["automower-ble==0.2.8", "gardena-bluetooth==2.1.0"]
 }

homeassistant/components/indevolt/config_flow.py

@@ -51,6 +51,38 @@ class IndevoltConfigFlow(ConfigFlow, domain=DOMAIN):
             errors=errors,
         )
 
+    async def async_step_reconfigure(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle reconfiguration of the Indevolt device host."""
+        errors: dict[str, str] = {}
+        reconfigure_entry = self._get_reconfigure_entry()
+
+        # Attempt to setup from user input
+        if user_input is not None:
+            errors, device_data = await self._async_validate_input(user_input)
+
+            if not errors and device_data:
+                await self.async_set_unique_id(device_data[CONF_SERIAL_NUMBER])
+                self._abort_if_unique_id_mismatch(reason="different_device")
+                return self.async_update_reload_and_abort(
+                    reconfigure_entry,
+                    data_updates={
+                        CONF_HOST: user_input[CONF_HOST],
+                        **device_data,
+                    },
+                )
+
+        # Retrieve user input (prefilled form)
+        return self.async_show_form(
+            step_id="reconfigure",
+            data_schema=self.add_suggested_values_to_schema(
+                vol.Schema({vol.Required(CONF_HOST): str}),
+                reconfigure_entry.data,
+            ),
+            errors=errors,
+        )
+
     async def _async_validate_input(
         self, user_input: dict[str, Any]
     ) -> tuple[dict[str, str], dict[str, Any] | None]:

homeassistant/components/indevolt/quality_scale.yaml

@@ -77,8 +77,7 @@ rules:
     status: todo
   icon-translations:
     status: todo
-  reconfiguration-flow:
-    status: todo
+  reconfiguration-flow: done
   repair-issues:
     status: exempt
     comment: No repair issues needed for current functionality

homeassistant/components/indevolt/strings.json

@@ -2,7 +2,9 @@
   "config": {
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
-      "cannot_connect": "Failed to connect (aborted)"
+      "cannot_connect": "Failed to connect (aborted)",
+      "different_device": "The device at the new host has a different serial number. Please ensure the new host is the same device.",
+      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]"
     },
     "error": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
@@ -10,6 +12,16 @@
       "unknown": "[%key:common::config_flow::error::unknown%]"
     },
     "step": {
+      "reconfigure": {
+        "data": {
+          "host": "[%key:common::config_flow::data::host%]"
+        },
+        "data_description": {
+          "host": "[%key:component::indevolt::config::step::user::data_description::host%]"
+        },
+        "description": "Update the connection details for your Indevolt device.",
+        "title": "Reconfigure Indevolt device"
+      },
       "user": {
         "data": {
           "host": "[%key:common::config_flow::data::host%]"

homeassistant/components/influxdb/config_flow.py

@@ -241,6 +241,104 @@ class InfluxDBConfigFlow(ConfigFlow, domain=DOMAIN):
             errors=errors,
         )
 
+    async def async_step_reconfigure(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle reconfiguration."""
+        entry = self._get_reconfigure_entry()
+        if entry.data[CONF_API_VERSION] == API_VERSION_2:
+            return await self.async_step_reconfigure_v2(user_input)
+        return await self.async_step_reconfigure_v1(user_input)
+
+    async def async_step_reconfigure_v1(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle reconfiguration of InfluxDB v1."""
+        errors: dict[str, str] = {}
+        entry = self._get_reconfigure_entry()
+
+        if user_input is not None:
+            url = URL(user_input[CONF_URL])
+            data = {
+                CONF_API_VERSION: DEFAULT_API_VERSION,
+                CONF_HOST: url.host,
+                CONF_PORT: url.port,
+                CONF_USERNAME: user_input.get(CONF_USERNAME),
+                CONF_PASSWORD: user_input.get(CONF_PASSWORD),
+                CONF_DB_NAME: user_input[CONF_DB_NAME],
+                CONF_SSL: url.scheme == "https",
+                CONF_PATH: url.path,
+                CONF_VERIFY_SSL: user_input[CONF_VERIFY_SSL],
+            }
+            if (cert := user_input.get(CONF_SSL_CA_CERT)) is not None:
+                path = await _save_uploaded_cert_file(self.hass, cert)
+                data[CONF_SSL_CA_CERT] = str(path)
+            elif CONF_SSL_CA_CERT in entry.data:
+                data[CONF_SSL_CA_CERT] = entry.data[CONF_SSL_CA_CERT]
+            errors = await _validate_influxdb_connection(self.hass, data)
+
+            if not errors:
+                title = f"{data[CONF_DB_NAME]} ({data[CONF_HOST]})"
+                return self.async_update_reload_and_abort(
+                    entry, title=title, data_updates=data
+                )
+
+        suggested_values = dict(entry.data) | (user_input or {})
+        if user_input is None:
+            suggested_values[CONF_URL] = str(
+                URL.build(
+                    scheme="https" if entry.data.get(CONF_SSL) else "http",
+                    host=entry.data.get(CONF_HOST, ""),
+                    port=entry.data.get(CONF_PORT),
+                    path=entry.data.get(CONF_PATH, ""),
+                )
+            )
+
+        return self.async_show_form(
+            step_id="reconfigure_v1",
+            data_schema=self.add_suggested_values_to_schema(
+                INFLUXDB_V1_SCHEMA, suggested_values
+            ),
+            errors=errors,
+        )
+
+    async def async_step_reconfigure_v2(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle reconfiguration of InfluxDB v2."""
+        errors: dict[str, str] = {}
+        entry = self._get_reconfigure_entry()
+
+        if user_input is not None:
+            data = {
+                CONF_API_VERSION: API_VERSION_2,
+                CONF_URL: user_input[CONF_URL],
+                CONF_TOKEN: user_input[CONF_TOKEN],
+                CONF_ORG: user_input[CONF_ORG],
+                CONF_BUCKET: user_input[CONF_BUCKET],
+                CONF_VERIFY_SSL: user_input[CONF_VERIFY_SSL],
+            }
+            if (cert := user_input.get(CONF_SSL_CA_CERT)) is not None:
+                path = await _save_uploaded_cert_file(self.hass, cert)
+                data[CONF_SSL_CA_CERT] = str(path)
+            elif CONF_SSL_CA_CERT in entry.data:
+                data[CONF_SSL_CA_CERT] = entry.data[CONF_SSL_CA_CERT]
+            errors = await _validate_influxdb_connection(self.hass, data)
+
+            if not errors:
+                title = f"{data[CONF_BUCKET]} ({data[CONF_URL]})"
+                return self.async_update_reload_and_abort(
+                    entry, title=title, data_updates=data
+                )
+
+        return self.async_show_form(
+            step_id="reconfigure_v2",
+            data_schema=self.add_suggested_values_to_schema(
+                INFLUXDB_V2_SCHEMA, entry.data | (user_input or {})
+            ),
+            errors=errors,
+        )
+
     async def async_step_import(self, import_data: dict[str, Any]) -> ConfigFlowResult:
         """Handle the initial step."""
         import_data = {**import_data}

homeassistant/components/influxdb/strings.json

@@ -3,6 +3,9 @@
     "ssl_ca_cert": "SSL CA certificate (Optional)"
   },
   "config": {
+    "abort": {
+      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]"
+    },
     "error": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
       "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
@@ -46,6 +49,39 @@
       "import": {
         "title": "Import configuration"
       },
+      "reconfigure_v1": {
+        "data": {
+          "database": "[%key:component::influxdb::config::step::configure_v1::data::database%]",
+          "password": "[%key:common::config_flow::data::password%]",
+          "ssl_ca_cert": "[%key:component::influxdb::common::ssl_ca_cert%]",
+          "url": "[%key:common::config_flow::data::url%]",
+          "username": "[%key:common::config_flow::data::username%]",
+          "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
+        },
+        "data_description": {
+          "database": "[%key:component::influxdb::config::step::configure_v1::data_description::database%]",
+          "ssl_ca_cert": "[%key:component::influxdb::config::step::configure_v1::data_description::ssl_ca_cert%]"
+        },
+        "description": "Update the connection settings for your InfluxDB v1.x server.",
+        "title": "[%key:component::influxdb::config::step::configure_v1::title%]"
+      },
+      "reconfigure_v2": {
+        "data": {
+          "bucket": "[%key:component::influxdb::config::step::configure_v2::data::bucket%]",
+          "organization": "[%key:component::influxdb::config::step::configure_v2::data::organization%]",
+          "ssl_ca_cert": "[%key:component::influxdb::common::ssl_ca_cert%]",
+          "token": "[%key:common::config_flow::data::api_token%]",
+          "url": "[%key:common::config_flow::data::url%]",
+          "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
+        },
+        "data_description": {
+          "bucket": "[%key:component::influxdb::config::step::configure_v2::data_description::bucket%]",
+          "organization": "[%key:component::influxdb::config::step::configure_v2::data_description::organization%]",
+          "ssl_ca_cert": "[%key:component::influxdb::config::step::configure_v2::data_description::ssl_ca_cert%]"
+        },
+        "description": "Update the connection settings for your InfluxDB v2.x / v3 server.",
+        "title": "[%key:component::influxdb::config::step::configure_v2::title%]"
+      },
       "user": {
         "menu_options": {
           "configure_v1": "InfluxDB v1.x",

homeassistant/components/input_boolean/icons.json

@@ -20,5 +20,13 @@
     "turn_on": {
       "service": "mdi:toggle-switch"
     }
+  },
+  "triggers": {
+    "turned_off": {
+      "trigger": "mdi:toggle-switch-off"
+    },
+    "turned_on": {
+      "trigger": "mdi:toggle-switch"
+    }
   }
 }

homeassistant/components/input_boolean/strings.json

@@ -1,4 +1,8 @@
 {
+  "common": {
+    "trigger_behavior_description": "The behavior of the targeted toggles to trigger on.",
+    "trigger_behavior_name": "Behavior"
+  },
   "entity_component": {
     "_": {
       "name": "[%key:component::input_boolean::title%]",
@@ -17,6 +21,15 @@
       }
     }
   },
+  "selector": {
+    "trigger_behavior": {
+      "options": {
+        "any": "Any",
+        "first": "First",
+        "last": "Last"
+      }
+    }
+  },
   "services": {
     "reload": {
       "description": "Reloads helpers from the YAML-configuration.",
@@ -35,5 +48,27 @@
       "name": "[%key:common::action::turn_on%]"
     }
   },
-  "title": "Input boolean"
+  "title": "Input boolean",
+  "triggers": {
+    "turned_off": {
+      "description": "Triggers after one or more toggles turn off.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::input_boolean::common::trigger_behavior_description%]",
+          "name": "[%key:component::input_boolean::common::trigger_behavior_name%]"
+        }
+      },
+      "name": "Toggle turned off"
+    },
+    "turned_on": {
+      "description": "Triggers after one or more toggles turn on.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::input_boolean::common::trigger_behavior_description%]",
+          "name": "[%key:component::input_boolean::common::trigger_behavior_name%]"
+        }
+      },
+      "name": "Toggle turned on"
+    }
+  }
 }

homeassistant/components/input_boolean/trigger.py

@@ -0,0 +1,17 @@
+"""Provides triggers for input booleans."""
+
+from homeassistant.const import STATE_OFF, STATE_ON
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.trigger import Trigger, make_entity_target_state_trigger
+
+from . import DOMAIN
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "turned_on": make_entity_target_state_trigger(DOMAIN, STATE_ON),
+    "turned_off": make_entity_target_state_trigger(DOMAIN, STATE_OFF),
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for input booleans."""
+    return TRIGGERS

homeassistant/components/input_boolean/triggers.yaml

@@ -0,0 +1,18 @@
+.trigger_common: &trigger_common
+  target:
+    entity:
+      domain: input_boolean
+  fields:
+    behavior:
+      required: true
+      default: any
+      selector:
+        select:
+          options:
+            - first
+            - last
+            - any
+          translation_key: trigger_behavior
+
+turned_off: *trigger_common
+turned_on: *trigger_common

homeassistant/components/intellifire/__init__.py

@@ -6,6 +6,7 @@ import asyncio
 
 from intellifire4py import UnifiedFireplace
 from intellifire4py.cloud_interface import IntelliFireCloudInterface
+from intellifire4py.const import IntelliFireApiMode
 from intellifire4py.model import IntelliFireCommonFireplaceData
 
 from homeassistant.const import (
@@ -20,6 +21,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 
 from .const import (
+    API_MODE_LOCAL,
     CONF_AUTH_COOKIE,
     CONF_CONTROL_MODE,
     CONF_READ_MODE,
@@ -55,8 +57,10 @@ def _construct_common_data(
         serial=entry.data[CONF_SERIAL],
         api_key=entry.data[CONF_API_KEY],
         ip_address=entry.data[CONF_IP_ADDRESS],
-        read_mode=entry.options[CONF_READ_MODE],
-        control_mode=entry.options[CONF_CONTROL_MODE],
+        read_mode=IntelliFireApiMode(entry.options.get(CONF_READ_MODE, API_MODE_LOCAL)),
+        control_mode=IntelliFireApiMode(
+            entry.options.get(CONF_CONTROL_MODE, API_MODE_LOCAL)
+        ),
     )
 
 
@@ -97,12 +101,34 @@ async def async_migrate_entry(
             hass.config_entries.async_update_entry(
                 config_entry,
                 data=new,
-                options={CONF_READ_MODE: "local", CONF_CONTROL_MODE: "local"},
+                options={
+                    CONF_READ_MODE: API_MODE_LOCAL,
+                    CONF_CONTROL_MODE: API_MODE_LOCAL,
+                },
                 unique_id=new[CONF_SERIAL],
                 version=1,
-                minor_version=2,
+                minor_version=3,
             )
-            LOGGER.debug("Pseudo Migration %s successful", config_entry.version)
+            LOGGER.debug("Migration to 1.3 successful")
+
+        if config_entry.minor_version < 3:
+            # Migrate old option keys (cloud_read, cloud_control) to new keys
+            old_options = config_entry.options
+            new_options = {
+                CONF_READ_MODE: old_options.get(
+                    "cloud_read", old_options.get(CONF_READ_MODE, API_MODE_LOCAL)
+                ),
+                CONF_CONTROL_MODE: old_options.get(
+                    "cloud_control", old_options.get(CONF_CONTROL_MODE, API_MODE_LOCAL)
+                ),
+            }
+            hass.config_entries.async_update_entry(
+                config_entry,
+                options=new_options,
+                version=1,
+                minor_version=3,
+            )
+            LOGGER.debug("Migration to 1.3 successful (options keys renamed)")
 
     return True
 
@@ -139,9 +165,43 @@ async def async_setup_entry(hass: HomeAssistant, entry: IntellifireConfigEntry)
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
+    entry.async_on_unload(entry.add_update_listener(async_update_options))
+
     return True
 
 
+async def async_update_options(
+    hass: HomeAssistant, entry: IntellifireConfigEntry
+) -> None:
+    """Handle options update."""
+    coordinator: IntellifireDataUpdateCoordinator = entry.runtime_data
+
+    new_read_mode = IntelliFireApiMode(
+        entry.options.get(CONF_READ_MODE, API_MODE_LOCAL)
+    )
+    new_control_mode = IntelliFireApiMode(
+        entry.options.get(CONF_CONTROL_MODE, API_MODE_LOCAL)
+    )
+
+    fireplace = coordinator.fireplace
+    current_read_mode = fireplace.read_mode
+    current_control_mode = fireplace.control_mode
+
+    # Only update modes that actually changed
+    if new_read_mode != current_read_mode:
+        LOGGER.debug("Updating read mode: %s -> %s", current_read_mode, new_read_mode)
+        await fireplace.set_read_mode(new_read_mode)
+
+    if new_control_mode != current_control_mode:
+        LOGGER.debug(
+            "Updating control mode: %s -> %s", current_control_mode, new_control_mode
+        )
+        await fireplace.set_control_mode(new_control_mode)
+
+    # Refresh data with new mode settings
+    await coordinator.async_request_refresh()
+
+
 async def _async_wait_for_initialization(
     fireplace: UnifiedFireplace, timeout=STARTUP_TIMEOUT
 ):

homeassistant/components/intellifire/config_flow.py

@@ -13,7 +13,12 @@ from intellifire4py.local_api import IntelliFireAPILocal
 from intellifire4py.model import IntelliFireCommonFireplaceData
 import voluptuous as vol
 
-from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlow, ConfigFlowResult
+from homeassistant.config_entries import (
+    SOURCE_REAUTH,
+    ConfigFlow,
+    ConfigFlowResult,
+    OptionsFlow,
+)
 from homeassistant.const import (
     CONF_API_KEY,
     CONF_HOST,
@@ -21,9 +26,12 @@ from homeassistant.const import (
     CONF_PASSWORD,
     CONF_USERNAME,
 )
+from homeassistant.core import callback
+from homeassistant.helpers import selector
 from homeassistant.helpers.service_info.dhcp import DhcpServiceInfo
 
 from .const import (
+    API_MODE_CLOUD,
     API_MODE_LOCAL,
     CONF_AUTH_COOKIE,
     CONF_CONTROL_MODE,
@@ -34,6 +42,7 @@ from .const import (
     DOMAIN,
     LOGGER,
 )
+from .coordinator import IntellifireConfigEntry
 
 STEP_USER_DATA_SCHEMA = vol.Schema({vol.Required(CONF_HOST): str})
 
@@ -70,7 +79,7 @@ class IntelliFireConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for IntelliFire."""
 
     VERSION = 1
-    MINOR_VERSION = 2
+    MINOR_VERSION = 3
 
     def __init__(self) -> None:
         """Initialize the Config Flow Handler."""
@@ -260,3 +269,85 @@ class IntelliFireConfigFlow(ConfigFlow, domain=DOMAIN):
             return self.async_abort(reason="not_intellifire_device")
 
         return await self.async_step_cloud_api()
+
+    @staticmethod
+    @callback
+    def async_get_options_flow(config_entry: IntellifireConfigEntry) -> OptionsFlow:
+        """Create the options flow."""
+        return IntelliFireOptionsFlowHandler()
+
+
+class IntelliFireOptionsFlowHandler(OptionsFlow):
+    """Options flow for IntelliFire component."""
+
+    config_entry: IntellifireConfigEntry
+
+    async def async_step_init(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Manage the options."""
+        errors: dict[str, str] = {}
+
+        if user_input is not None:
+            # Validate connectivity for requested modes if runtime data is available
+            coordinator = self.config_entry.runtime_data
+            if coordinator is not None:
+                fireplace = coordinator.fireplace
+
+                # Refresh connectivity status before validating
+                await fireplace.async_validate_connectivity()
+
+                if (
+                    user_input[CONF_READ_MODE] == API_MODE_LOCAL
+                    and not fireplace.local_connectivity
+                ):
+                    errors[CONF_READ_MODE] = "local_unavailable"
+                if (
+                    user_input[CONF_READ_MODE] == API_MODE_CLOUD
+                    and not fireplace.cloud_connectivity
+                ):
+                    errors[CONF_READ_MODE] = "cloud_unavailable"
+                if (
+                    user_input[CONF_CONTROL_MODE] == API_MODE_LOCAL
+                    and not fireplace.local_connectivity
+                ):
+                    errors[CONF_CONTROL_MODE] = "local_unavailable"
+                if (
+                    user_input[CONF_CONTROL_MODE] == API_MODE_CLOUD
+                    and not fireplace.cloud_connectivity
+                ):
+                    errors[CONF_CONTROL_MODE] = "cloud_unavailable"
+
+            if not errors:
+                return self.async_create_entry(title="", data=user_input)
+
+        existing_read = self.config_entry.options.get(CONF_READ_MODE, API_MODE_LOCAL)
+        existing_control = self.config_entry.options.get(
+            CONF_CONTROL_MODE, API_MODE_LOCAL
+        )
+
+        cloud_local_options = selector.SelectSelectorConfig(
+            options=[API_MODE_LOCAL, API_MODE_CLOUD],
+            translation_key="api_mode",
+        )
+
+        return self.async_show_form(
+            step_id="init",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(
+                        CONF_READ_MODE,
+                        default=user_input.get(CONF_READ_MODE, existing_read)
+                        if user_input
+                        else existing_read,
+                    ): selector.SelectSelector(cloud_local_options),
+                    vol.Required(
+                        CONF_CONTROL_MODE,
+                        default=user_input.get(CONF_CONTROL_MODE, existing_control)
+                        if user_input
+                        else existing_control,
+                    ): selector.SelectSelector(cloud_local_options),
+                }
+            ),
+            errors=errors,
+        )

homeassistant/components/intellifire/const.py

@@ -13,8 +13,8 @@ CONF_WEB_CLIENT_ID = "web_client_id"  # part of the cloud cookie
 CONF_AUTH_COOKIE = "auth_cookie"  # part of the cloud cookie
 
 CONF_SERIAL = "serial"
-CONF_READ_MODE = "cloud_read"
-CONF_CONTROL_MODE = "cloud_control"
+CONF_READ_MODE = "read_mode"
+CONF_CONTROL_MODE = "control_mode"
 
 
 API_MODE_LOCAL = "local"

homeassistant/components/intellifire/sensor.py

@@ -17,6 +17,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util.dt import utcnow
 
+from .const import API_MODE_CLOUD, API_MODE_LOCAL
 from .coordinator import IntellifireConfigEntry, IntellifireDataUpdateCoordinator
 from .entity import IntellifireEntity
 
@@ -66,6 +67,22 @@ def _uptime_to_timestamp(
 
 
 INTELLIFIRE_SENSORS: tuple[IntellifireSensorEntityDescription, ...] = (
+    IntellifireSensorEntityDescription(
+        key="read_mode",
+        translation_key="read_mode",
+        device_class=SensorDeviceClass.ENUM,
+        options=[API_MODE_LOCAL, API_MODE_CLOUD],
+        entity_category=EntityCategory.DIAGNOSTIC,
+        value_fn=lambda coordinator: coordinator.fireplace.read_mode.value,
+    ),
+    IntellifireSensorEntityDescription(
+        key="control_mode",
+        translation_key="control_mode",
+        device_class=SensorDeviceClass.ENUM,
+        options=[API_MODE_LOCAL, API_MODE_CLOUD],
+        entity_category=EntityCategory.DIAGNOSTIC,
+        value_fn=lambda coordinator: coordinator.fireplace.control_mode.value,
+    ),
     IntellifireSensorEntityDescription(
         key="flame_height",
         translation_key="flame_height",

homeassistant/components/intellifire/strings.json

@@ -100,6 +100,13 @@
       "connection_quality": {
         "name": "Connection quality"
       },
+      "control_mode": {
+        "name": "Control mode",
+        "state": {
+          "cloud": "Cloud",
+          "local": "Local"
+        }
+      },
       "downtime": {
         "name": "Downtime"
       },
@@ -115,6 +122,13 @@
       "ipv4_address": {
         "name": "IP address"
       },
+      "read_mode": {
+        "name": "Read mode",
+        "state": {
+          "cloud": "Cloud",
+          "local": "Local"
+        }
+      },
       "target_temp": {
         "name": "Target temperature"
       },
@@ -133,5 +147,29 @@
         "name": "Pilot light"
       }
     }
+  },
+  "options": {
+    "error": {
+      "cloud_unavailable": "Cloud connectivity is not available",
+      "local_unavailable": "Local connectivity is not available"
+    },
+    "step": {
+      "init": {
+        "data": {
+          "control_mode": "Send commands to",
+          "read_mode": "Read data from"
+        },
+        "description": "Some users find that their fireplace hardware prioritizes `Cloud` communication and may experience timeouts with `Local` control. If you encounter connectivity issues, try switching to `Cloud` for the affected endpoint.",
+        "title": "Endpoint selection"
+      }
+    }
+  },
+  "selector": {
+    "api_mode": {
+      "options": {
+        "cloud": "Cloud",
+        "local": "Local"
+      }
+    }
   }
 }

homeassistant/components/jvc_projector/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["jvcprojector"],
-  "requirements": ["pyjvcprojector==2.0.2"]
+  "requirements": ["pyjvcprojector==2.0.3"]
 }

homeassistant/components/knx/number.py

@@ -120,6 +120,19 @@ class KnxYamlNumber(_KnxNumber, KnxYamlEntity):
                 value_type=config[CONF_TYPE],
             ),
         )
+        dpt_string = self._device.sensor_value.dpt_class.dpt_number_str()
+        dpt_info = get_supported_dpts()[dpt_string]
+
+        self._attr_device_class = config.get(
+            CONF_DEVICE_CLASS,
+            try_parse_enum(
+                # sensor device classes should, with some exceptions ("enum" etc.), align with number device classes
+                NumberDeviceClass,
+                dpt_info["sensor_device_class"],
+            ),
+        )
+        self._attr_entity_category = config.get(CONF_ENTITY_CATEGORY)
+        self._attr_mode = config[CONF_MODE]
         self._attr_native_max_value = config.get(
             NumberConf.MAX,
             self._device.sensor_value.dpt_class.value_max,
@@ -128,14 +141,16 @@ class KnxYamlNumber(_KnxNumber, KnxYamlEntity):
             NumberConf.MIN,
             self._device.sensor_value.dpt_class.value_min,
         )
-        self._attr_mode = config[CONF_MODE]
         self._attr_native_step = config.get(
             NumberConf.STEP,
             self._device.sensor_value.dpt_class.resolution,
         )
-        self._attr_entity_category = config.get(CONF_ENTITY_CATEGORY)
+        self._attr_native_unit_of_measurement = config.get(
+            CONF_UNIT_OF_MEASUREMENT,
+            dpt_info["unit"],
+        )
         self._attr_unique_id = str(self._device.sensor_value.group_address)
-        self._attr_native_unit_of_measurement = self._device.unit_of_measurement()
+
         self._device.sensor_value.value = max(0, self._attr_native_min_value)
 
 

homeassistant/components/knx/schema.py

@@ -20,7 +20,10 @@ from homeassistant.components.climate import FAN_OFF, HVACMode
 from homeassistant.components.cover import (
     DEVICE_CLASSES_SCHEMA as COVER_DEVICE_CLASSES_SCHEMA,
 )
-from homeassistant.components.number import NumberMode
+from homeassistant.components.number import (
+    DEVICE_CLASSES_SCHEMA as NUMBER_DEVICE_CLASSES_SCHEMA,
+    NumberMode,
+)
 from homeassistant.components.sensor import (
     CONF_STATE_CLASS as CONF_SENSOR_STATE_CLASS,
     DEVICE_CLASSES_SCHEMA as SENSOR_DEVICE_CLASSES_SCHEMA,
@@ -39,6 +42,7 @@ from homeassistant.const import (
     CONF_NAME,
     CONF_PAYLOAD,
     CONF_TYPE,
+    CONF_UNIT_OF_MEASUREMENT,
     CONF_VALUE_TEMPLATE,
     Platform,
 )
@@ -787,6 +791,8 @@ class NumberSchema(KNXPlatformSchema):
                 vol.Optional(NumberConf.MAX): vol.Coerce(float),
                 vol.Optional(NumberConf.MIN): vol.Coerce(float),
                 vol.Optional(NumberConf.STEP): cv.positive_float,
+                vol.Optional(CONF_DEVICE_CLASS): NUMBER_DEVICE_CLASSES_SCHEMA,
+                vol.Optional(CONF_UNIT_OF_MEASUREMENT): cv.string,
                 vol.Optional(CONF_ENTITY_CATEGORY): ENTITY_CATEGORIES_SCHEMA,
             }
         ),
@@ -867,6 +873,7 @@ class SensorSchema(KNXPlatformSchema):
                 vol.Required(CONF_TYPE): sensor_type_validator,
                 vol.Required(CONF_STATE_ADDRESS): ga_list_validator,
                 vol.Optional(CONF_DEVICE_CLASS): SENSOR_DEVICE_CLASSES_SCHEMA,
+                vol.Optional(CONF_UNIT_OF_MEASUREMENT): cv.string,
                 vol.Optional(CONF_ENTITY_CATEGORY): ENTITY_CATEGORIES_SCHEMA,
             }
         ),

homeassistant/components/knx/sensor.py

@@ -216,20 +216,22 @@ class KnxYamlSensor(_KnxSensor, KnxYamlEntity):
         dpt_string = self._device.sensor_value.dpt_class.dpt_number_str()
         dpt_info = get_supported_dpts()[dpt_string]
 
-        if device_class := config.get(CONF_DEVICE_CLASS):
-            self._attr_device_class = device_class
-        else:
-            self._attr_device_class = dpt_info["sensor_device_class"]
-
-        self._attr_state_class = (
-            config.get(CONF_STATE_CLASS) or dpt_info["sensor_state_class"]
+        self._attr_device_class = config.get(
+            CONF_DEVICE_CLASS,
+            dpt_info["sensor_device_class"],
         )
-
-        self._attr_native_unit_of_measurement = dpt_info["unit"]
-        self._attr_force_update = config[SensorSchema.CONF_ALWAYS_CALLBACK]
         self._attr_entity_category = config.get(CONF_ENTITY_CATEGORY)
-        self._attr_unique_id = str(self._device.sensor_value.group_address_state)
         self._attr_extra_state_attributes = {}
+        self._attr_force_update = config[SensorSchema.CONF_ALWAYS_CALLBACK]
+        self._attr_native_unit_of_measurement = config.get(
+            CONF_UNIT_OF_MEASUREMENT,
+            dpt_info["unit"],
+        )
+        self._attr_state_class = config.get(
+            CONF_STATE_CLASS,
+            dpt_info["sensor_state_class"],
+        )
+        self._attr_unique_id = str(self._device.sensor_value.group_address_state)
 
 
 class KnxUiSensor(_KnxSensor, KnxUiEntity):

homeassistant/components/libre_hardware_monitor/coordinator.py

@@ -62,7 +62,9 @@ class LibreHardwareMonitorCoordinator(DataUpdateCoordinator[LibreHardwareMonitor
             registry=dr.async_get(self.hass), config_entry_id=self._entry_id
         )
         self._previous_devices: dict[DeviceId, DeviceName] = {
-            DeviceId(next(iter(device.identifiers))[1]): DeviceName(device.name)
+            DeviceId(
+                next(iter(device.identifiers))[1].removeprefix(f"{self._entry_id}_")
+            ): DeviceName(device.name)
             for device in device_entries
             if device.identifiers and device.name
         }
@@ -109,11 +111,6 @@ class LibreHardwareMonitorCoordinator(DataUpdateCoordinator[LibreHardwareMonitor
         self, detected_devices: dict[DeviceId, DeviceName]
     ) -> None:
         """Handle device changes by deleting devices from / adding devices to Home Assistant."""
-        detected_devices = {
-            DeviceId(f"{self.config_entry.entry_id}_{detected_id}"): device_name
-            for detected_id, device_name in detected_devices.items()
-        }
-
         previous_device_ids = set(self._previous_devices.keys())
         detected_device_ids = set(detected_devices.keys())
 
@@ -131,25 +128,14 @@ class LibreHardwareMonitorCoordinator(DataUpdateCoordinator[LibreHardwareMonitor
             device_registry = dr.async_get(self.hass)
             for device_id in orphaned_devices:
                 if device := device_registry.async_get_device(
-                    identifiers={(DOMAIN, device_id)}
+                    identifiers={(DOMAIN, f"{self._entry_id}_{device_id}")}
                 ):
                     _LOGGER.debug(
                         "Removing device: %s", self._previous_devices[device_id]
                     )
                     device_registry.async_update_device(
                         device_id=device.id,
-                        remove_config_entry_id=self.config_entry.entry_id,
+                        remove_config_entry_id=self._entry_id,
                     )
 
-        if self.data is None:
-            # initial update during integration startup
-            self._previous_devices = detected_devices  # type: ignore[unreachable]
-            return
-
-        if new_devices := detected_device_ids - previous_device_ids:
-            _LOGGER.warning(
-                "New Device(s) detected, reload integration to add them to Home Assistant: %s",
-                [detected_devices[DeviceId(device_id)] for device_id in new_devices],
-            )
-
         self._previous_devices = detected_devices

homeassistant/components/libre_hardware_monitor/sensor.py

@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
+import logging
 from typing import Any
 
-from librehardwaremonitor_api.model import LibreHardwareMonitorSensorData
+from librehardwaremonitor_api.model import DeviceId, LibreHardwareMonitorSensorData
 from librehardwaremonitor_api.sensor_type import SensorType
 
 from homeassistant.components.sensor import SensorEntity, SensorStateClass
@@ -16,6 +17,8 @@ from homeassistant.helpers.update_coordinator import CoordinatorEntity
 from . import LibreHardwareMonitorConfigEntry, LibreHardwareMonitorCoordinator
 from .const import DOMAIN
 
+_LOGGER = logging.getLogger(__name__)
+
 PARALLEL_UPDATES = 0
 
 STATE_MIN_VALUE = "min_value"
@@ -30,10 +33,28 @@ async def async_setup_entry(
     """Set up the LibreHardwareMonitor platform."""
     lhm_coordinator = config_entry.runtime_data
 
-    async_add_entities(
-        LibreHardwareMonitorSensor(lhm_coordinator, config_entry.entry_id, sensor_data)
-        for sensor_data in lhm_coordinator.data.sensor_data.values()
-    )
+    known_devices: set[DeviceId] = set()
+
+    def _check_device() -> None:
+        current_devices = set(lhm_coordinator.data.main_device_ids_and_names)
+        new_devices = current_devices - known_devices
+        if new_devices:
+            _LOGGER.debug("New Device(s) detected, adding: %s", new_devices)
+            known_devices.update(new_devices)
+            new_devices_sensor_data = [
+                sensor_data
+                for sensor_data in lhm_coordinator.data.sensor_data.values()
+                if sensor_data.device_id in new_devices
+            ]
+            async_add_entities(
+                LibreHardwareMonitorSensor(
+                    lhm_coordinator, config_entry.entry_id, sensor_data
+                )
+                for sensor_data in new_devices_sensor_data
+            )
+
+    _check_device()
+    config_entry.async_on_unload(lhm_coordinator.async_add_listener(_check_device))
 
 
 class LibreHardwareMonitorSensor(

homeassistant/components/light/__init__.py

@@ -7,7 +7,7 @@ import csv
 import dataclasses
 import logging
 import os
-from typing import TYPE_CHECKING, Any, Self, cast, final
+from typing import TYPE_CHECKING, Any, Self, cast, final, override
 
 from propcache.api import cached_property
 import voluptuous as vol
@@ -272,6 +272,18 @@ def filter_turn_off_params(
     return {k: v for k, v in params.items() if k in (ATTR_TRANSITION, ATTR_FLASH)}
 
 
+def process_turn_off_params(
+    hass: HomeAssistant, light: LightEntity, params: dict[str, Any]
+) -> dict[str, Any]:
+    """Process light turn off params."""
+    params = dict(params)
+
+    if ATTR_TRANSITION not in params:
+        hass.data[DATA_PROFILES].apply_default(light.entity_id, True, params)
+
+    return params
+
+
 def filter_turn_on_params(light: LightEntity, params: dict[str, Any]) -> dict[str, Any]:
     """Filter out params not supported by the light."""
     supported_features = light.supported_features
@@ -306,7 +318,171 @@ def filter_turn_on_params(light: LightEntity, params: dict[str, Any]) -> dict[st
     return params
 
 
-async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa: C901
+def process_turn_on_params(  # noqa: C901
+    hass: HomeAssistant, light: LightEntity, params: dict[str, Any]
+) -> dict[str, Any]:
+    """Process light turn on params."""
+    params = dict(params)
+
+    # Only process params once we processed brightness step
+    if params and (
+        ATTR_BRIGHTNESS_STEP in params or ATTR_BRIGHTNESS_STEP_PCT in params
+    ):
+        brightness = light.brightness if light.is_on and light.brightness else 0
+
+        if ATTR_BRIGHTNESS_STEP in params:
+            brightness += params.pop(ATTR_BRIGHTNESS_STEP)
+
+        else:
+            brightness_pct = round(brightness / 255 * 100)
+            brightness = round(
+                (brightness_pct + params.pop(ATTR_BRIGHTNESS_STEP_PCT)) / 100 * 255
+            )
+
+        params[ATTR_BRIGHTNESS] = max(0, min(255, brightness))
+
+        preprocess_turn_on_alternatives(hass, params)
+
+    if (not params or not light.is_on) or (params and ATTR_TRANSITION not in params):
+        hass.data[DATA_PROFILES].apply_default(light.entity_id, light.is_on, params)
+
+    supported_color_modes = light._light_internal_supported_color_modes  # noqa: SLF001
+
+    # If a color temperature is specified, emulate it if not supported by the light
+    if ATTR_COLOR_TEMP_KELVIN in params:
+        if (
+            ColorMode.COLOR_TEMP not in supported_color_modes
+            and ColorMode.RGBWW in supported_color_modes
+        ):
+            color_temp = params.pop(ATTR_COLOR_TEMP_KELVIN)
+            brightness = cast(int, params.get(ATTR_BRIGHTNESS, light.brightness))
+            params[ATTR_RGBWW_COLOR] = color_util.color_temperature_to_rgbww(
+                color_temp,
+                brightness,
+                light.min_color_temp_kelvin,
+                light.max_color_temp_kelvin,
+            )
+        elif ColorMode.COLOR_TEMP not in supported_color_modes:
+            color_temp = params.pop(ATTR_COLOR_TEMP_KELVIN)
+            if color_supported(supported_color_modes):
+                params[ATTR_HS_COLOR] = color_util.color_temperature_to_hs(color_temp)
+
+    # If a color is specified, convert to the color space supported by the light
+    rgb_color: tuple[int, int, int] | None
+    rgbww_color: tuple[int, int, int, int, int] | None
+    if ATTR_HS_COLOR in params and ColorMode.HS not in supported_color_modes:
+        hs_color = params.pop(ATTR_HS_COLOR)
+        if ColorMode.RGB in supported_color_modes:
+            params[ATTR_RGB_COLOR] = color_util.color_hs_to_RGB(*hs_color)
+        elif ColorMode.RGBW in supported_color_modes:
+            rgb_color = color_util.color_hs_to_RGB(*hs_color)
+            params[ATTR_RGBW_COLOR] = color_util.color_rgb_to_rgbw(*rgb_color)
+        elif ColorMode.RGBWW in supported_color_modes:
+            rgb_color = color_util.color_hs_to_RGB(*hs_color)
+            params[ATTR_RGBWW_COLOR] = color_util.color_rgb_to_rgbww(
+                *rgb_color, light.min_color_temp_kelvin, light.max_color_temp_kelvin
+            )
+        elif ColorMode.XY in supported_color_modes:
+            params[ATTR_XY_COLOR] = color_util.color_hs_to_xy(*hs_color)
+        elif ColorMode.COLOR_TEMP in supported_color_modes:
+            xy_color = color_util.color_hs_to_xy(*hs_color)
+            params[ATTR_COLOR_TEMP_KELVIN] = color_util.color_xy_to_temperature(
+                *xy_color
+            )
+    elif ATTR_RGB_COLOR in params and ColorMode.RGB not in supported_color_modes:
+        rgb_color = params.pop(ATTR_RGB_COLOR)
+        assert rgb_color is not None
+        if TYPE_CHECKING:
+            rgb_color = cast(tuple[int, int, int], rgb_color)
+        if ColorMode.RGBW in supported_color_modes:
+            params[ATTR_RGBW_COLOR] = color_util.color_rgb_to_rgbw(*rgb_color)
+        elif ColorMode.RGBWW in supported_color_modes:
+            params[ATTR_RGBWW_COLOR] = color_util.color_rgb_to_rgbww(
+                *rgb_color,
+                light.min_color_temp_kelvin,
+                light.max_color_temp_kelvin,
+            )
+        elif ColorMode.HS in supported_color_modes:
+            params[ATTR_HS_COLOR] = color_util.color_RGB_to_hs(*rgb_color)
+        elif ColorMode.XY in supported_color_modes:
+            params[ATTR_XY_COLOR] = color_util.color_RGB_to_xy(*rgb_color)
+        elif ColorMode.COLOR_TEMP in supported_color_modes:
+            xy_color = color_util.color_RGB_to_xy(*rgb_color)
+            params[ATTR_COLOR_TEMP_KELVIN] = color_util.color_xy_to_temperature(
+                *xy_color
+            )
+    elif ATTR_XY_COLOR in params and ColorMode.XY not in supported_color_modes:
+        xy_color = params.pop(ATTR_XY_COLOR)
+        if ColorMode.HS in supported_color_modes:
+            params[ATTR_HS_COLOR] = color_util.color_xy_to_hs(*xy_color)
+        elif ColorMode.RGB in supported_color_modes:
+            params[ATTR_RGB_COLOR] = color_util.color_xy_to_RGB(*xy_color)
+        elif ColorMode.RGBW in supported_color_modes:
+            rgb_color = color_util.color_xy_to_RGB(*xy_color)
+            params[ATTR_RGBW_COLOR] = color_util.color_rgb_to_rgbw(*rgb_color)
+        elif ColorMode.RGBWW in supported_color_modes:
+            rgb_color = color_util.color_xy_to_RGB(*xy_color)
+            params[ATTR_RGBWW_COLOR] = color_util.color_rgb_to_rgbww(
+                *rgb_color, light.min_color_temp_kelvin, light.max_color_temp_kelvin
+            )
+        elif ColorMode.COLOR_TEMP in supported_color_modes:
+            params[ATTR_COLOR_TEMP_KELVIN] = color_util.color_xy_to_temperature(
+                *xy_color
+            )
+    elif ATTR_RGBW_COLOR in params and ColorMode.RGBW not in supported_color_modes:
+        rgbw_color = params.pop(ATTR_RGBW_COLOR)
+        rgb_color = color_util.color_rgbw_to_rgb(*rgbw_color)
+        if ColorMode.RGB in supported_color_modes:
+            params[ATTR_RGB_COLOR] = rgb_color
+        elif ColorMode.RGBWW in supported_color_modes:
+            params[ATTR_RGBWW_COLOR] = color_util.color_rgb_to_rgbww(
+                *rgb_color, light.min_color_temp_kelvin, light.max_color_temp_kelvin
+            )
+        elif ColorMode.HS in supported_color_modes:
+            params[ATTR_HS_COLOR] = color_util.color_RGB_to_hs(*rgb_color)
+        elif ColorMode.XY in supported_color_modes:
+            params[ATTR_XY_COLOR] = color_util.color_RGB_to_xy(*rgb_color)
+        elif ColorMode.COLOR_TEMP in supported_color_modes:
+            xy_color = color_util.color_RGB_to_xy(*rgb_color)
+            params[ATTR_COLOR_TEMP_KELVIN] = color_util.color_xy_to_temperature(
+                *xy_color
+            )
+    elif ATTR_RGBWW_COLOR in params and ColorMode.RGBWW not in supported_color_modes:
+        rgbww_color = params.pop(ATTR_RGBWW_COLOR)
+        assert rgbww_color is not None
+        if TYPE_CHECKING:
+            rgbww_color = cast(tuple[int, int, int, int, int], rgbww_color)
+        rgb_color = color_util.color_rgbww_to_rgb(
+            *rgbww_color, light.min_color_temp_kelvin, light.max_color_temp_kelvin
+        )
+        if ColorMode.RGB in supported_color_modes:
+            params[ATTR_RGB_COLOR] = rgb_color
+        elif ColorMode.RGBW in supported_color_modes:
+            params[ATTR_RGBW_COLOR] = color_util.color_rgb_to_rgbw(*rgb_color)
+        elif ColorMode.HS in supported_color_modes:
+            params[ATTR_HS_COLOR] = color_util.color_RGB_to_hs(*rgb_color)
+        elif ColorMode.XY in supported_color_modes:
+            params[ATTR_XY_COLOR] = color_util.color_RGB_to_xy(*rgb_color)
+        elif ColorMode.COLOR_TEMP in supported_color_modes:
+            xy_color = color_util.color_RGB_to_xy(*rgb_color)
+            params[ATTR_COLOR_TEMP_KELVIN] = color_util.color_xy_to_temperature(
+                *xy_color
+            )
+
+    # If white is set to True, set it to the light's brightness
+    # Add a warning in Home Assistant Core 2024.3 if the brightness is set to an
+    # integer.
+    if params.get(ATTR_WHITE) is True:
+        params[ATTR_WHITE] = light.brightness
+
+    # If both white and brightness are specified, override white
+    if ATTR_WHITE in params and ColorMode.WHITE in supported_color_modes:
+        params[ATTR_WHITE] = params.pop(ATTR_BRIGHTNESS, params[ATTR_WHITE])
+
+    return params
+
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Expose light control via state machine and services."""
     component = hass.data[DATA_COMPONENT] = EntityComponent[LightEntity](
         _LOGGER, DOMAIN, hass, SCAN_INTERVAL
@@ -330,177 +506,15 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa:
         base["params"] = data
         return base
 
-    async def async_handle_light_on_service(  # noqa: C901
+    async def async_handle_light_on_service(
         light: LightEntity, call: ServiceCall
     ) -> None:
         """Handle turning a light on.
 
         If brightness is set to 0, this service will turn the light off.
         """
-        params: dict[str, Any] = dict(call.data["params"])
+        params = process_turn_on_params(hass, light, call.data["params"])
 
-        # Only process params once we processed brightness step
-        if params and (
-            ATTR_BRIGHTNESS_STEP in params or ATTR_BRIGHTNESS_STEP_PCT in params
-        ):
-            brightness = light.brightness if light.is_on and light.brightness else 0
-
-            if ATTR_BRIGHTNESS_STEP in params:
-                brightness += params.pop(ATTR_BRIGHTNESS_STEP)
-
-            else:
-                brightness_pct = round(brightness / 255 * 100)
-                brightness = round(
-                    (brightness_pct + params.pop(ATTR_BRIGHTNESS_STEP_PCT)) / 100 * 255
-                )
-
-            params[ATTR_BRIGHTNESS] = max(0, min(255, brightness))
-
-            preprocess_turn_on_alternatives(hass, params)
-
-        if (not params or not light.is_on) or (
-            params and ATTR_TRANSITION not in params
-        ):
-            profiles.apply_default(light.entity_id, light.is_on, params)
-
-        supported_color_modes = light._light_internal_supported_color_modes  # noqa: SLF001
-
-        # If a color temperature is specified, emulate it if not supported by the light
-        if ATTR_COLOR_TEMP_KELVIN in params:
-            if (
-                ColorMode.COLOR_TEMP not in supported_color_modes
-                and ColorMode.RGBWW in supported_color_modes
-            ):
-                color_temp = params.pop(ATTR_COLOR_TEMP_KELVIN)
-                brightness = cast(int, params.get(ATTR_BRIGHTNESS, light.brightness))
-                params[ATTR_RGBWW_COLOR] = color_util.color_temperature_to_rgbww(
-                    color_temp,
-                    brightness,
-                    light.min_color_temp_kelvin,
-                    light.max_color_temp_kelvin,
-                )
-            elif ColorMode.COLOR_TEMP not in supported_color_modes:
-                color_temp = params.pop(ATTR_COLOR_TEMP_KELVIN)
-                if color_supported(supported_color_modes):
-                    params[ATTR_HS_COLOR] = color_util.color_temperature_to_hs(
-                        color_temp
-                    )
-
-        # If a color is specified, convert to the color space supported by the light
-        rgb_color: tuple[int, int, int] | None
-        rgbww_color: tuple[int, int, int, int, int] | None
-        if ATTR_HS_COLOR in params and ColorMode.HS not in supported_color_modes:
-            hs_color = params.pop(ATTR_HS_COLOR)
-            if ColorMode.RGB in supported_color_modes:
-                params[ATTR_RGB_COLOR] = color_util.color_hs_to_RGB(*hs_color)
-            elif ColorMode.RGBW in supported_color_modes:
-                rgb_color = color_util.color_hs_to_RGB(*hs_color)
-                params[ATTR_RGBW_COLOR] = color_util.color_rgb_to_rgbw(*rgb_color)
-            elif ColorMode.RGBWW in supported_color_modes:
-                rgb_color = color_util.color_hs_to_RGB(*hs_color)
-                params[ATTR_RGBWW_COLOR] = color_util.color_rgb_to_rgbww(
-                    *rgb_color, light.min_color_temp_kelvin, light.max_color_temp_kelvin
-                )
-            elif ColorMode.XY in supported_color_modes:
-                params[ATTR_XY_COLOR] = color_util.color_hs_to_xy(*hs_color)
-            elif ColorMode.COLOR_TEMP in supported_color_modes:
-                xy_color = color_util.color_hs_to_xy(*hs_color)
-                params[ATTR_COLOR_TEMP_KELVIN] = color_util.color_xy_to_temperature(
-                    *xy_color
-                )
-        elif ATTR_RGB_COLOR in params and ColorMode.RGB not in supported_color_modes:
-            rgb_color = params.pop(ATTR_RGB_COLOR)
-            assert rgb_color is not None
-            if TYPE_CHECKING:
-                rgb_color = cast(tuple[int, int, int], rgb_color)
-            if ColorMode.RGBW in supported_color_modes:
-                params[ATTR_RGBW_COLOR] = color_util.color_rgb_to_rgbw(*rgb_color)
-            elif ColorMode.RGBWW in supported_color_modes:
-                params[ATTR_RGBWW_COLOR] = color_util.color_rgb_to_rgbww(
-                    *rgb_color,
-                    light.min_color_temp_kelvin,
-                    light.max_color_temp_kelvin,
-                )
-            elif ColorMode.HS in supported_color_modes:
-                params[ATTR_HS_COLOR] = color_util.color_RGB_to_hs(*rgb_color)
-            elif ColorMode.XY in supported_color_modes:
-                params[ATTR_XY_COLOR] = color_util.color_RGB_to_xy(*rgb_color)
-            elif ColorMode.COLOR_TEMP in supported_color_modes:
-                xy_color = color_util.color_RGB_to_xy(*rgb_color)
-                params[ATTR_COLOR_TEMP_KELVIN] = color_util.color_xy_to_temperature(
-                    *xy_color
-                )
-        elif ATTR_XY_COLOR in params and ColorMode.XY not in supported_color_modes:
-            xy_color = params.pop(ATTR_XY_COLOR)
-            if ColorMode.HS in supported_color_modes:
-                params[ATTR_HS_COLOR] = color_util.color_xy_to_hs(*xy_color)
-            elif ColorMode.RGB in supported_color_modes:
-                params[ATTR_RGB_COLOR] = color_util.color_xy_to_RGB(*xy_color)
-            elif ColorMode.RGBW in supported_color_modes:
-                rgb_color = color_util.color_xy_to_RGB(*xy_color)
-                params[ATTR_RGBW_COLOR] = color_util.color_rgb_to_rgbw(*rgb_color)
-            elif ColorMode.RGBWW in supported_color_modes:
-                rgb_color = color_util.color_xy_to_RGB(*xy_color)
-                params[ATTR_RGBWW_COLOR] = color_util.color_rgb_to_rgbww(
-                    *rgb_color, light.min_color_temp_kelvin, light.max_color_temp_kelvin
-                )
-            elif ColorMode.COLOR_TEMP in supported_color_modes:
-                params[ATTR_COLOR_TEMP_KELVIN] = color_util.color_xy_to_temperature(
-                    *xy_color
-                )
-        elif ATTR_RGBW_COLOR in params and ColorMode.RGBW not in supported_color_modes:
-            rgbw_color = params.pop(ATTR_RGBW_COLOR)
-            rgb_color = color_util.color_rgbw_to_rgb(*rgbw_color)
-            if ColorMode.RGB in supported_color_modes:
-                params[ATTR_RGB_COLOR] = rgb_color
-            elif ColorMode.RGBWW in supported_color_modes:
-                params[ATTR_RGBWW_COLOR] = color_util.color_rgb_to_rgbww(
-                    *rgb_color, light.min_color_temp_kelvin, light.max_color_temp_kelvin
-                )
-            elif ColorMode.HS in supported_color_modes:
-                params[ATTR_HS_COLOR] = color_util.color_RGB_to_hs(*rgb_color)
-            elif ColorMode.XY in supported_color_modes:
-                params[ATTR_XY_COLOR] = color_util.color_RGB_to_xy(*rgb_color)
-            elif ColorMode.COLOR_TEMP in supported_color_modes:
-                xy_color = color_util.color_RGB_to_xy(*rgb_color)
-                params[ATTR_COLOR_TEMP_KELVIN] = color_util.color_xy_to_temperature(
-                    *xy_color
-                )
-        elif (
-            ATTR_RGBWW_COLOR in params and ColorMode.RGBWW not in supported_color_modes
-        ):
-            rgbww_color = params.pop(ATTR_RGBWW_COLOR)
-            assert rgbww_color is not None
-            if TYPE_CHECKING:
-                rgbww_color = cast(tuple[int, int, int, int, int], rgbww_color)
-            rgb_color = color_util.color_rgbww_to_rgb(
-                *rgbww_color, light.min_color_temp_kelvin, light.max_color_temp_kelvin
-            )
-            if ColorMode.RGB in supported_color_modes:
-                params[ATTR_RGB_COLOR] = rgb_color
-            elif ColorMode.RGBW in supported_color_modes:
-                params[ATTR_RGBW_COLOR] = color_util.color_rgb_to_rgbw(*rgb_color)
-            elif ColorMode.HS in supported_color_modes:
-                params[ATTR_HS_COLOR] = color_util.color_RGB_to_hs(*rgb_color)
-            elif ColorMode.XY in supported_color_modes:
-                params[ATTR_XY_COLOR] = color_util.color_RGB_to_xy(*rgb_color)
-            elif ColorMode.COLOR_TEMP in supported_color_modes:
-                xy_color = color_util.color_RGB_to_xy(*rgb_color)
-                params[ATTR_COLOR_TEMP_KELVIN] = color_util.color_xy_to_temperature(
-                    *xy_color
-                )
-
-        # If white is set to True, set it to the light's brightness
-        # Add a warning in Home Assistant Core 2024.3 if the brightness is set to an
-        # integer.
-        if params.get(ATTR_WHITE) is True:
-            params[ATTR_WHITE] = light.brightness
-
-        # If both white and brightness are specified, override white
-        if ATTR_WHITE in params and ColorMode.WHITE in supported_color_modes:
-            params[ATTR_WHITE] = params.pop(ATTR_BRIGHTNESS, params[ATTR_WHITE])
-
-        # Remove deprecated white value if the light supports color mode
         if params.get(ATTR_BRIGHTNESS) == 0 or params.get(ATTR_WHITE) == 0:
             await async_handle_light_off_service(light, call)
         else:
@@ -510,10 +524,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa:
         light: LightEntity, call: ServiceCall
     ) -> None:
         """Handle turning off a light."""
-        params = dict(call.data["params"])
-
-        if ATTR_TRANSITION not in params:
-            profiles.apply_default(light.entity_id, True, params)
+        params = process_turn_off_params(hass, light, call.data["params"])
 
         await light.async_turn_off(**filter_turn_off_params(light, params))
 
@@ -521,10 +532,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa:
         light: LightEntity, call: ServiceCall
     ) -> None:
         """Handle toggling a light."""
-        if light.is_on:
-            await async_handle_light_off_service(light, call)
-        else:
-            await async_handle_light_on_service(light, call)
+        await light.async_toggle(**call.data["params"])
 
     # Listen for light on and light off service calls.
 
@@ -1046,3 +1054,15 @@ class LightEntity(ToggleEntity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
     def supported_features(self) -> LightEntityFeature:
         """Flag supported features."""
         return self._attr_supported_features
+
+    @override
+    async def async_toggle(self, **kwargs: Any) -> None:
+        """Toggle the entity."""
+        if not self.is_on:
+            params = process_turn_on_params(self.hass, self, kwargs)
+            if params.get(ATTR_BRIGHTNESS) != 0 and params.get(ATTR_WHITE) != 0:
+                await self.async_turn_on(**filter_turn_on_params(self, params))
+                return
+
+        params = process_turn_off_params(self.hass, self, kwargs)
+        await self.async_turn_off(**filter_turn_off_params(self, params))

homeassistant/components/light/trigger.py

@@ -24,7 +24,7 @@ class BrightnessChangedTrigger(EntityNumericalStateAttributeChangedTriggerBase):
     """Trigger for brightness changed."""
 
     _domains = {DOMAIN}
-    _attribute = ATTR_BRIGHTNESS
+    _attributes = {DOMAIN: ATTR_BRIGHTNESS}
 
     _converter = staticmethod(_convert_uint8_to_percentage)
 
@@ -35,7 +35,7 @@ class BrightnessCrossedThresholdTrigger(
     """Trigger for brightness crossed threshold."""
 
     _domains = {DOMAIN}
-    _attribute = ATTR_BRIGHTNESS
+    _attributes = {DOMAIN: ATTR_BRIGHTNESS}
     _converter = staticmethod(_convert_uint8_to_percentage)