Merge branch 'dev' into number/add-crossed_threshold-trigger

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.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@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.0
+        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.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@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.0
+        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.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@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.0
+        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.0
+        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.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@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.0
+        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.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@2031cfc080254a8a887f58cffee85186f0e49e48 # v4.9.0
+        uses: actions/dependency-review-action@05fe4576374b728f0c523d6a13d64c25081e0803 # v4.8.3
         with:
           license-check: false # We use our own license audit checks
 

.strict-typing

@@ -212,7 +212,6 @@ homeassistant.components.flexit_bacnet.*
 homeassistant.components.flux_led.*
 homeassistant.components.folder_watcher.*
 homeassistant.components.forecast_solar.*
-homeassistant.components.freshr.*
 homeassistant.components.fritz.*
 homeassistant.components.fritzbox.*
 homeassistant.components.fritzbox_callmonitor.*
@@ -342,7 +341,6 @@ 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

@@ -551,8 +551,6 @@ build.json @home-assistant/supervisor
 /tests/components/freebox/ @hacf-fr @Quentame
 /homeassistant/components/freedompro/ @stefano055415
 /tests/components/freedompro/ @stefano055415
-/homeassistant/components/freshr/ @SierraNL
-/tests/components/freshr/ @SierraNL
 /homeassistant/components/fressnapf_tracker/ @eifinger
 /tests/components/fressnapf_tracker/ @eifinger
 /homeassistant/components/fritz/ @AaronDavidSchneider @chemelli74 @mib1185
@@ -571,14 +569,10 @@ build.json @home-assistant/supervisor
 /tests/components/fully_kiosk/ @cgarwood
 /homeassistant/components/fyta/ @dontinelli
 /tests/components/fyta/ @dontinelli
-/homeassistant/components/garage_door/ @home-assistant/core
-/tests/components/garage_door/ @home-assistant/core
 /homeassistant/components/garages_amsterdam/ @klaasnicolaas
 /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
@@ -745,8 +739,6 @@ 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
@@ -796,8 +788,8 @@ build.json @home-assistant/supervisor
 /tests/components/improv_ble/ @emontnemery
 /homeassistant/components/incomfort/ @jbouwh
 /tests/components/incomfort/ @jbouwh
-/homeassistant/components/indevolt/ @xirt
-/tests/components/indevolt/ @xirt
+/homeassistant/components/indevolt/ @xirtnl
+/tests/components/indevolt/ @xirtnl
 /homeassistant/components/inels/ @epdevlab
 /tests/components/inels/ @epdevlab
 /homeassistant/components/influxdb/ @mdegat01 @Robbie1221

homeassistant/bootstrap.py

@@ -242,9 +242,6 @@ 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,57 +168,29 @@ 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
-        if self._attr_hvac_mode == HVACMode.HEAT:
-            await self._adax_data_handler.set_target_temperature(temperature)
+        await self._adax_data_handler.set_target_temperature(temperature)
 
-        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.
-        """
+    @callback
+    def _handle_coordinator_update(self) -> None:
+        """Handle updated data from the coordinator."""
         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 self._attr_target_temperature is None:
+                if target_temp == 0:
                     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,10 +101,7 @@ class AmazonSwitchEntity(AmazonEntity, SwitchEntity):
             assert method is not None
 
         await method(self.device, state)
-        self.coordinator.data[self.device.serial_number].sensors[
-            self.entity_description.key
-        ].value = state
-        self.async_write_ha_state()
+        await self.coordinator.async_request_refresh()
 
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Turn the switch on."""

homeassistant/components/androidtv_remote/helpers.py

@@ -27,4 +27,4 @@ def create_api(hass: HomeAssistant, host: str, enable_ime: bool) -> AndroidTVRem
 
 def get_enable_ime(entry: AndroidTVRemoteConfigEntry) -> bool:
     """Get value of enable_ime option or its default value."""
-    return bool(entry.options.get(CONF_ENABLE_IME, CONF_ENABLE_IME_DEFAULT_VALUE))
+    return entry.options.get(CONF_ENABLE_IME, CONF_ENABLE_IME_DEFAULT_VALUE)  # type: ignore[no-any-return]

homeassistant/components/anglian_water/sensor.py

@@ -4,7 +4,6 @@ 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
@@ -33,14 +32,13 @@ 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 | datetime | None]
+    value_fn: Callable[[SmartMeter], float]
 
 
 ENTITY_DESCRIPTIONS: tuple[AnglianWaterSensorEntityDescription, ...] = (
@@ -78,13 +76,6 @@ 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,
-    ),
 )
 
 
@@ -121,6 +112,6 @@ class AnglianWaterSensorEntity(AnglianWaterEntity, SensorEntity):
         self.entity_description = description
 
     @property
-    def native_value(self) -> float | datetime | None:
+    def native_value(self) -> float | None:
         """Return the state of the sensor."""
         return self.entity_description.value_fn(self.smart_meter)

homeassistant/components/anglian_water/strings.json

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

homeassistant/components/arcam_fmj/__init__.py

@@ -8,11 +8,19 @@ 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
-from .coordinator import ArcamFmjConfigEntry, ArcamFmjCoordinator, ArcamFmjRuntimeData
+from .const import (
+    DEFAULT_SCAN_INTERVAL,
+    SIGNAL_CLIENT_DATA,
+    SIGNAL_CLIENT_STARTED,
+    SIGNAL_CLIENT_STOPPED,
+)
+
+type ArcamFmjConfigEntry = ConfigEntry[Client]
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -22,41 +30,24 @@ PLATFORMS = [Platform.MEDIA_PLAYER]
 
 async def async_setup_entry(hass: HomeAssistant, entry: ArcamFmjConfigEntry) -> bool:
     """Set up config entry."""
-    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.runtime_data = Client(entry.data[CONF_HOST], entry.data[CONF_PORT])
 
     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: ArcamFmjConfigEntry) -> bool:
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Cleanup before removing config entry."""
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
 
 
-async def _run_client(
-    hass: HomeAssistant,
-    runtime_data: ArcamFmjRuntimeData,
-    interval: float,
-) -> None:
-    client = runtime_data.client
-    coordinators = runtime_data.coordinators
-
+async def _run_client(hass: HomeAssistant, client: Client, interval: float) -> None:
     def _listen(_: Any) -> None:
-        for coordinator in coordinators.values():
-            coordinator.async_notify_data_updated()
+        async_dispatcher_send(hass, SIGNAL_CLIENT_DATA, client.host)
 
     while True:
         try:
@@ -64,21 +55,16 @@ async def _run_client(
                 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)
-                for coordinator in coordinators.values():
-                    coordinator.async_notify_disconnected()
+                async_dispatcher_send(hass, SIGNAL_CLIENT_STOPPED, client.host)
 
         except ConnectionFailed:
             await asyncio.sleep(interval)

homeassistant/components/arcam_fmj/const.py

@@ -2,6 +2,10 @@
 
 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

@@ -1,96 +0,0 @@
-"""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,6 +8,7 @@ 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,
@@ -19,13 +20,20 @@ from homeassistant.components.media_player import (
     MediaType,
 )
 from homeassistant.const import ATTR_ENTITY_ID
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
 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 .const import EVENT_TURN_ON
-from .coordinator import ArcamFmjConfigEntry, ArcamFmjCoordinator
+from . import ArcamFmjConfigEntry
+from .const import (
+    DOMAIN,
+    EVENT_TURN_ON,
+    SIGNAL_CLIENT_DATA,
+    SIGNAL_CLIENT_STARTED,
+    SIGNAL_CLIENT_STOPPED,
+)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -36,17 +44,19 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the configuration entry."""
-    coordinators = config_entry.runtime_data.coordinators
+
+    client = config_entry.runtime_data
 
     async_add_entities(
         [
             ArcamFmj(
                 config_entry.title,
-                coordinators[zone],
+                State(client, zone),
                 config_entry.unique_id or config_entry.entry_id,
             )
             for zone in (1, 2)
         ],
+        True,
     )
 
 
@@ -67,21 +77,21 @@ def convert_exception[**_P, _R](
     return _convert_exception
 
 
-class ArcamFmj(CoordinatorEntity[ArcamFmjCoordinator], MediaPlayerEntity):
+class ArcamFmj(MediaPlayerEntity):
     """Representation of a media device."""
 
+    _attr_should_poll = False
     _attr_has_entity_name = True
 
     def __init__(
         self,
         device_name: str,
-        coordinator: ArcamFmjCoordinator,
+        state: State,
         uuid: str,
     ) -> None:
         """Initialize device."""
-        super().__init__(coordinator)
-        self._state = coordinator.state
-        self._attr_name = f"Zone {self._state.zn}"
+        self._state = state
+        self._attr_name = f"Zone {state.zn}"
         self._attr_supported_features = (
             MediaPlayerEntityFeature.SELECT_SOURCE
             | MediaPlayerEntityFeature.PLAY_MEDIA
@@ -92,11 +102,18 @@ class ArcamFmj(CoordinatorEntity[ArcamFmjCoordinator], MediaPlayerEntity):
             | MediaPlayerEntityFeature.TURN_OFF
             | MediaPlayerEntityFeature.TURN_ON
         )
-        if self._state.zn == 1:
+        if state.zn == 1:
             self._attr_supported_features |= MediaPlayerEntityFeature.SELECT_SOUND_MODE
-        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
+        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,
+        )
 
     @property
     def state(self) -> MediaPlayerState:
@@ -105,6 +122,49 @@ class ArcamFmj(CoordinatorEntity[ArcamFmjCoordinator], 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/august/manifest.json

@@ -30,5 +30,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_push",
   "loggers": ["pubnub", "yalexs"],
-  "requirements": ["yalexs==9.2.0", "yalexs-ble==3.3.0"]
+  "requirements": ["yalexs==9.2.0", "yalexs-ble==3.2.7"]
 }

homeassistant/components/automation/__init__.py

@@ -137,21 +137,19 @@ _EXPERIMENTAL_CONDITION_PLATFORMS = {
 _EXPERIMENTAL_TRIGGER_PLATFORMS = {
     "alarm_control_panel",
     "assist_satellite",
+    "binary_sensor",
     "button",
     "climate",
     "cover",
     "device_tracker",
     "door",
     "fan",
-    "garage_door",
-    "gate",
     "humidifier",
-    "humidity",
-    "input_boolean",
     "lawn_mower",
     "light",
     "lock",
     "media_player",
+    "number",
     "person",
     "remote",
     "scene",

homeassistant/components/aws_s3/backup.py

@@ -14,7 +14,6 @@ from homeassistant.components.backup import (
     BackupAgent,
     BackupAgentError,
     BackupNotFound,
-    OnProgressCallback,
     suggested_filename,
 )
 from homeassistant.core import HomeAssistant, callback
@@ -133,7 +132,6 @@ class S3BackupAgent(BackupAgent):
         *,
         open_stream: Callable[[], Coroutine[Any, Any, AsyncIterator[bytes]]],
         backup: AgentBackup,
-        on_progress: OnProgressCallback,
         **kwargs: Any,
     ) -> None:
         """Upload a backup.

homeassistant/components/azure_storage/backup.py

@@ -16,7 +16,6 @@ from homeassistant.components.backup import (
     BackupAgent,
     BackupAgentError,
     BackupNotFound,
-    OnProgressCallback,
     suggested_filename,
 )
 from homeassistant.core import HomeAssistant, callback
@@ -130,7 +129,6 @@ class AzureStorageBackupAgent(BackupAgent):
         *,
         open_stream: Callable[[], Coroutine[Any, Any, AsyncIterator[bytes]]],
         backup: AgentBackup,
-        on_progress: OnProgressCallback,
         **kwargs: Any,
     ) -> None:
         """Upload a backup."""

homeassistant/components/backblaze_b2/backup.py

@@ -17,7 +17,6 @@ from homeassistant.components.backup import (
     BackupAgent,
     BackupAgentError,
     BackupNotFound,
-    OnProgressCallback,
     suggested_filename,
 )
 from homeassistant.core import HomeAssistant, callback
@@ -231,7 +230,6 @@ class BackblazeBackupAgent(BackupAgent):
         *,
         open_stream: Callable[[], Coroutine[Any, Any, AsyncIterator[bytes]]],
         backup: AgentBackup,
-        on_progress: OnProgressCallback,
         **kwargs: Any,
     ) -> None:
         """Upload a backup to Backblaze B2.

homeassistant/components/backup/__init__.py

@@ -17,7 +17,6 @@ from .agent import (
     BackupAgentError,
     BackupAgentPlatformProtocol,
     LocalBackupAgent,
-    OnProgressCallback,
 )
 from .config import BackupConfig, CreateBackupParametersDict
 from .const import DATA_MANAGER, DOMAIN
@@ -42,7 +41,6 @@ from .manager import (
     RestoreBackupEvent,
     RestoreBackupStage,
     RestoreBackupState,
-    UploadBackupEvent,
     WrittenBackup,
 )
 from .models import AddonInfo, AgentBackup, BackupNotFound, Folder
@@ -74,11 +72,9 @@ __all__ = [
     "LocalBackupAgent",
     "ManagerBackup",
     "NewBackup",
-    "OnProgressCallback",
     "RestoreBackupEvent",
     "RestoreBackupStage",
     "RestoreBackupState",
-    "UploadBackupEvent",
     "WrittenBackup",
     "async_get_manager",
     "suggested_filename",

homeassistant/components/backup/agent.py

@@ -14,13 +14,6 @@ from homeassistant.core import HomeAssistant, callback
 from .models import AgentBackup, BackupAgentError
 
 
-class OnProgressCallback(Protocol):
-    """Protocol for on_progress callback."""
-
-    def __call__(self, *, bytes_uploaded: int, **kwargs: Any) -> None:
-        """Report upload progress."""
-
-
 class BackupAgentUnreachableError(BackupAgentError):
     """Raised when the agent can't reach its API."""
 
@@ -60,14 +53,12 @@ class BackupAgent(abc.ABC):
         *,
         open_stream: Callable[[], Coroutine[Any, Any, AsyncIterator[bytes]]],
         backup: AgentBackup,
-        on_progress: OnProgressCallback,
         **kwargs: Any,
     ) -> None:
         """Upload a backup.
 
         :param open_stream: A function returning an async iterator that yields bytes.
         :param backup: Metadata about the backup that should be uploaded.
-        :param on_progress: A callback to report the number of uploaded bytes.
         """
 
     @abc.abstractmethod

homeassistant/components/backup/backup.py

@@ -11,7 +11,7 @@ from typing import Any
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.hassio import is_hassio
 
-from .agent import BackupAgent, LocalBackupAgent, OnProgressCallback
+from .agent import BackupAgent, LocalBackupAgent
 from .const import DOMAIN, LOGGER
 from .models import AgentBackup, BackupNotFound
 from .util import read_backup, suggested_filename
@@ -73,7 +73,6 @@ class CoreLocalBackupAgent(LocalBackupAgent):
         *,
         open_stream: Callable[[], Coroutine[Any, Any, AsyncIterator[bytes]]],
         backup: AgentBackup,
-        on_progress: OnProgressCallback,
         **kwargs: Any,
     ) -> None:
         """Upload a backup."""

homeassistant/components/backup/manager.py

@@ -32,7 +32,6 @@ 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
@@ -79,8 +78,6 @@ from .util import (
     validate_password_stream,
 )
 
-UPLOAD_PROGRESS_DEBOUNCE_SECONDS = 1
-
 
 @dataclass(frozen=True, kw_only=True, slots=True)
 class NewBackup:
@@ -255,15 +252,6 @@ class BlockedEvent(ManagerStateEvent):
     manager_state: BackupManagerState = BackupManagerState.BLOCKED
 
 
-@dataclass(frozen=True, kw_only=True, slots=True)
-class UploadBackupEvent(ManagerStateEvent):
-    """Backup agent upload progress event."""
-
-    agent_id: str
-    uploaded_bytes: int
-    total_bytes: int
-
-
 class BackupPlatformProtocol(Protocol):
     """Define the format that backup platforms can have."""
 
@@ -591,50 +579,9 @@ class BackupManager:
                 _backup = replace(
                     backup, protected=should_encrypt, size=streamer.size()
                 )
-            agent = self.backup_agents[agent_id]
-
-            latest_uploaded_bytes = 0
-
-            @callback
-            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=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(
+            await self.backup_agents[agent_id].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()
@@ -1427,10 +1374,9 @@ class BackupManager:
         """Forward event to subscribers."""
         if (current_state := self.state) != (new_state := event.manager_state):
             LOGGER.debug("Backup state: %s -> %s", current_state, new_state)
-        if not isinstance(event, UploadBackupEvent):
-            self.last_event = event
-            if not isinstance(event, (BlockedEvent, IdleEvent)):
-                self.last_action_event = event
+        self.last_event = event
+        if not isinstance(event, (BlockedEvent, IdleEvent)):
+            self.last_action_event = event
         for subscription in self._backup_event_subscriptions:
             subscription(event)
 

homeassistant/components/binary_sensor/icons.json

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

homeassistant/components/binary_sensor/strings.json

@@ -1,4 +1,8 @@
 {
+  "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",
@@ -317,5 +321,36 @@
       }
     }
   },
-  "title": "Binary sensor"
+  "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"
+    }
+  }
 }

homeassistant/components/binary_sensor/trigger.py

@@ -0,0 +1,67 @@
+"""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/binary_sensor/triggers.yaml

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

homeassistant/components/bluetooth/manifest.json

@@ -16,11 +16,11 @@
   "quality_scale": "internal",
   "requirements": [
     "bleak==2.1.1",
-    "bleak-retry-connector==4.6.0",
+    "bleak-retry-connector==4.4.3",
     "bluetooth-adapters==2.1.0",
     "bluetooth-auto-recovery==1.5.3",
     "bluetooth-data-tools==1.28.4",
     "dbus-fast==3.1.2",
-    "habluetooth==5.9.1"
+    "habluetooth==5.8.0"
   ]
 }

homeassistant/components/bond/strings.json

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

homeassistant/components/climate/icons.json

@@ -115,6 +115,18 @@
     }
   },
   "triggers": {
+    "current_humidity_changed": {
+      "trigger": "mdi:water-percent"
+    },
+    "current_humidity_crossed_threshold": {
+      "trigger": "mdi:water-percent"
+    },
+    "current_temperature_changed": {
+      "trigger": "mdi:thermometer"
+    },
+    "current_temperature_crossed_threshold": {
+      "trigger": "mdi:thermometer"
+    },
     "hvac_mode_changed": {
       "trigger": "mdi:thermostat"
     },

homeassistant/components/climate/strings.json

@@ -372,6 +372,78 @@
   },
   "title": "Climate",
   "triggers": {
+    "current_humidity_changed": {
+      "description": "Triggers after the humidity measured by one or more climate-control devices changes.",
+      "fields": {
+        "above": {
+          "description": "Trigger when the humidity is above this value.",
+          "name": "Above"
+        },
+        "below": {
+          "description": "Trigger when the humidity is below this value.",
+          "name": "Below"
+        }
+      },
+      "name": "Climate-control device current humidity changed"
+    },
+    "current_humidity_crossed_threshold": {
+      "description": "Triggers after the humidity measured by one or more climate-control devices crosses a threshold.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::climate::common::trigger_behavior_description%]",
+          "name": "[%key:component::climate::common::trigger_behavior_name%]"
+        },
+        "lower_limit": {
+          "description": "Lower threshold limit.",
+          "name": "Lower threshold"
+        },
+        "threshold_type": {
+          "description": "Type of threshold crossing to trigger on.",
+          "name": "Threshold type"
+        },
+        "upper_limit": {
+          "description": "Upper threshold limit.",
+          "name": "Upper threshold"
+        }
+      },
+      "name": "Climate-control device current humidity crossed threshold"
+    },
+    "current_temperature_changed": {
+      "description": "Triggers after the temperature measured by one or more climate-control devices changes.",
+      "fields": {
+        "above": {
+          "description": "Trigger when the temperature is above this value.",
+          "name": "Above"
+        },
+        "below": {
+          "description": "Trigger when the temperature is below this value.",
+          "name": "Below"
+        }
+      },
+      "name": "Climate-control device current temperature changed"
+    },
+    "current_temperature_crossed_threshold": {
+      "description": "Triggers after the temperature measured by one or more climate-control devices crosses a threshold.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::climate::common::trigger_behavior_description%]",
+          "name": "[%key:component::climate::common::trigger_behavior_name%]"
+        },
+        "lower_limit": {
+          "description": "Lower threshold limit.",
+          "name": "Lower threshold"
+        },
+        "threshold_type": {
+          "description": "Type of threshold crossing to trigger on.",
+          "name": "Threshold type"
+        },
+        "upper_limit": {
+          "description": "Upper threshold limit.",
+          "name": "Upper threshold"
+        }
+      },
+      "name": "Climate-control device current temperature crossed threshold"
+    },
     "hvac_mode_changed": {
       "description": "Triggers after the mode of one or more climate-control devices changes.",
       "fields": {

homeassistant/components/climate/trigger.py

@@ -17,7 +17,15 @@ from homeassistant.helpers.trigger import (
     make_entity_transition_trigger,
 )
 
-from .const import ATTR_HUMIDITY, ATTR_HVAC_ACTION, DOMAIN, HVACAction, HVACMode
+from .const import (
+    ATTR_CURRENT_HUMIDITY,
+    ATTR_CURRENT_TEMPERATURE,
+    ATTR_HUMIDITY,
+    ATTR_HVAC_ACTION,
+    DOMAIN,
+    HVACAction,
+    HVACMode,
+)
 
 CONF_HVAC_MODE = "hvac_mode"
 
@@ -45,6 +53,18 @@ class HVACModeChangedTrigger(EntityTargetStateTriggerBase):
 
 
 TRIGGERS: dict[str, type[Trigger]] = {
+    "current_humidity_changed": make_entity_numerical_state_attribute_changed_trigger(
+        DOMAIN, ATTR_CURRENT_HUMIDITY
+    ),
+    "current_humidity_crossed_threshold": make_entity_numerical_state_attribute_crossed_threshold_trigger(
+        DOMAIN, ATTR_CURRENT_HUMIDITY
+    ),
+    "current_temperature_changed": make_entity_numerical_state_attribute_changed_trigger(
+        DOMAIN, ATTR_CURRENT_TEMPERATURE
+    ),
+    "current_temperature_crossed_threshold": make_entity_numerical_state_attribute_crossed_threshold_trigger(
+        DOMAIN, ATTR_CURRENT_TEMPERATURE
+    ),
     "hvac_mode_changed": HVACModeChangedTrigger,
     "started_cooling": make_entity_target_state_attribute_trigger(
         DOMAIN, ATTR_HVAC_ACTION, HVACAction.COOLING
@@ -53,16 +73,16 @@ TRIGGERS: dict[str, type[Trigger]] = {
         DOMAIN, ATTR_HVAC_ACTION, HVACAction.DRYING
     ),
     "target_humidity_changed": make_entity_numerical_state_attribute_changed_trigger(
-        {DOMAIN}, {DOMAIN: ATTR_HUMIDITY}
+        DOMAIN, ATTR_HUMIDITY
     ),
     "target_humidity_crossed_threshold": make_entity_numerical_state_attribute_crossed_threshold_trigger(
-        {DOMAIN}, {DOMAIN: ATTR_HUMIDITY}
+        DOMAIN, ATTR_HUMIDITY
     ),
     "target_temperature_changed": make_entity_numerical_state_attribute_changed_trigger(
-        {DOMAIN}, {DOMAIN: ATTR_TEMPERATURE}
+        DOMAIN, ATTR_TEMPERATURE
     ),
     "target_temperature_crossed_threshold": make_entity_numerical_state_attribute_crossed_threshold_trigger(
-        {DOMAIN}, {DOMAIN: ATTR_TEMPERATURE}
+        DOMAIN, ATTR_TEMPERATURE
     ),
     "turned_off": make_entity_target_state_trigger(DOMAIN, HVACMode.OFF),
     "turned_on": make_entity_transition_trigger(

homeassistant/components/climate/triggers.yaml

@@ -66,6 +66,20 @@ hvac_mode_changed:
             - unknown
           multiple: true
 
+current_humidity_changed:
+  target: *trigger_climate_target
+  fields:
+    above: *number_or_entity
+    below: *number_or_entity
+
+current_humidity_crossed_threshold:
+  target: *trigger_climate_target
+  fields:
+    behavior: *trigger_behavior
+    threshold_type: *trigger_threshold_type
+    lower_limit: *number_or_entity
+    upper_limit: *number_or_entity
+
 target_humidity_changed:
   target: *trigger_climate_target
   fields:
@@ -80,6 +94,20 @@ target_humidity_crossed_threshold:
     lower_limit: *number_or_entity
     upper_limit: *number_or_entity
 
+current_temperature_changed:
+  target: *trigger_climate_target
+  fields:
+    above: *number_or_entity
+    below: *number_or_entity
+
+current_temperature_crossed_threshold:
+  target: *trigger_climate_target
+  fields:
+    behavior: *trigger_behavior
+    threshold_type: *trigger_threshold_type
+    lower_limit: *number_or_entity
+    upper_limit: *number_or_entity
+
 target_temperature_changed:
   target: *trigger_climate_target
   fields:

homeassistant/components/cloud/backup.py

@@ -18,7 +18,6 @@ from homeassistant.components.backup import (
     BackupAgent,
     BackupAgentError,
     BackupNotFound,
-    OnProgressCallback,
 )
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.aiohttp_client import ChunkAsyncStreamIterator
@@ -107,7 +106,6 @@ class CloudBackupAgent(BackupAgent):
         *,
         open_stream: Callable[[], Coroutine[Any, Any, AsyncIterator[bytes]]],
         backup: AgentBackup,
-        on_progress: OnProgressCallback,
         **kwargs: Any,
     ) -> None:
         """Upload a backup.

homeassistant/components/cloudflare_r2/backup.py

@@ -14,7 +14,6 @@ from homeassistant.components.backup import (
     BackupAgent,
     BackupAgentError,
     BackupNotFound,
-    OnProgressCallback,
     suggested_filename,
 )
 from homeassistant.core import HomeAssistant, callback
@@ -130,7 +129,6 @@ class R2BackupAgent(BackupAgent):
         *,
         open_stream: Callable[[], Coroutine[Any, Any, AsyncIterator[bytes]]],
         backup: AgentBackup,
-        on_progress: OnProgressCallback,
         **kwargs: Any,
     ) -> None:
         """Upload a backup.

homeassistant/components/cover/__init__.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from collections.abc import Callable
 from datetime import timedelta
+from enum import IntFlag, StrEnum
 import functools as ft
 import logging
 from typing import Any, final
@@ -32,20 +33,7 @@ from homeassistant.helpers.typing import ConfigType
 from homeassistant.loader import bind_hass
 from homeassistant.util.hass_dict import HassKey
 
-from .const import (
-    ATTR_CURRENT_POSITION,
-    ATTR_CURRENT_TILT_POSITION,
-    ATTR_IS_CLOSED,
-    ATTR_POSITION,
-    ATTR_TILT_POSITION,
-    DOMAIN,
-    INTENT_CLOSE_COVER,
-    INTENT_OPEN_COVER,
-    CoverDeviceClass,
-    CoverEntityFeature,
-    CoverState,
-)
-from .trigger import make_cover_closed_trigger, make_cover_opened_trigger
+from .const import DOMAIN, INTENT_CLOSE_COVER, INTENT_OPEN_COVER  # noqa: F401
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -55,33 +43,57 @@ PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA
 PLATFORM_SCHEMA_BASE = cv.PLATFORM_SCHEMA_BASE
 SCAN_INTERVAL = timedelta(seconds=15)
 
+
+class CoverState(StrEnum):
+    """State of Cover entities."""
+
+    CLOSED = "closed"
+    CLOSING = "closing"
+    OPEN = "open"
+    OPENING = "opening"
+
+
+class CoverDeviceClass(StrEnum):
+    """Device class for cover."""
+
+    # Refer to the cover dev docs for device class descriptions
+    AWNING = "awning"
+    BLIND = "blind"
+    CURTAIN = "curtain"
+    DAMPER = "damper"
+    DOOR = "door"
+    GARAGE = "garage"
+    GATE = "gate"
+    SHADE = "shade"
+    SHUTTER = "shutter"
+    WINDOW = "window"
+
+
 DEVICE_CLASSES_SCHEMA = vol.All(vol.Lower, vol.Coerce(CoverDeviceClass))
 DEVICE_CLASSES = [cls.value for cls in CoverDeviceClass]
 
+
 # mypy: disallow-any-generics
 
 
-__all__ = [
-    "ATTR_CURRENT_POSITION",
-    "ATTR_CURRENT_TILT_POSITION",
-    "ATTR_IS_CLOSED",
-    "ATTR_POSITION",
-    "ATTR_TILT_POSITION",
-    "DEVICE_CLASSES",
-    "DEVICE_CLASSES_SCHEMA",
-    "DOMAIN",
-    "INTENT_CLOSE_COVER",
-    "INTENT_OPEN_COVER",
-    "PLATFORM_SCHEMA",
-    "PLATFORM_SCHEMA_BASE",
-    "CoverDeviceClass",
-    "CoverEntity",
-    "CoverEntityDescription",
-    "CoverEntityFeature",
-    "CoverState",
-    "make_cover_closed_trigger",
-    "make_cover_opened_trigger",
-]
+class CoverEntityFeature(IntFlag):
+    """Supported features of the cover entity."""
+
+    OPEN = 1
+    CLOSE = 2
+    SET_POSITION = 4
+    STOP = 8
+    OPEN_TILT = 16
+    CLOSE_TILT = 32
+    STOP_TILT = 64
+    SET_TILT_POSITION = 128
+
+
+ATTR_CURRENT_POSITION = "current_position"
+ATTR_CURRENT_TILT_POSITION = "current_tilt_position"
+ATTR_IS_CLOSED = "is_closed"
+ATTR_POSITION = "position"
+ATTR_TILT_POSITION = "tilt_position"
 
 
 @bind_hass

homeassistant/components/cover/const.py

@@ -1,52 +1,6 @@
 """Constants for cover entity platform."""
 
-from enum import IntFlag, StrEnum
-
 DOMAIN = "cover"
 
-ATTR_CURRENT_POSITION = "current_position"
-ATTR_CURRENT_TILT_POSITION = "current_tilt_position"
-ATTR_IS_CLOSED = "is_closed"
-ATTR_POSITION = "position"
-ATTR_TILT_POSITION = "tilt_position"
-
 INTENT_OPEN_COVER = "HassOpenCover"
 INTENT_CLOSE_COVER = "HassCloseCover"
-
-
-class CoverEntityFeature(IntFlag):
-    """Supported features of the cover entity."""
-
-    OPEN = 1
-    CLOSE = 2
-    SET_POSITION = 4
-    STOP = 8
-    OPEN_TILT = 16
-    CLOSE_TILT = 32
-    STOP_TILT = 64
-    SET_TILT_POSITION = 128
-
-
-class CoverState(StrEnum):
-    """State of Cover entities."""
-
-    CLOSED = "closed"
-    CLOSING = "closing"
-    OPEN = "open"
-    OPENING = "opening"
-
-
-class CoverDeviceClass(StrEnum):
-    """Device class for cover."""
-
-    # Refer to the cover dev docs for device class descriptions
-    AWNING = "awning"
-    BLIND = "blind"
-    CURTAIN = "curtain"
-    DAMPER = "damper"
-    DOOR = "door"
-    GARAGE = "garage"
-    GATE = "gate"
-    SHADE = "shade"
-    SHUTTER = "shutter"
-    WINDOW = "window"

homeassistant/components/cover/icons.json

@@ -108,37 +108,5 @@
     "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,8 +1,4 @@
 {
-  "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}",
@@ -86,15 +82,6 @@
       "name": "Window"
     }
   },
-  "selector": {
-    "trigger_behavior": {
-      "options": {
-        "any": "Any",
-        "first": "First",
-        "last": "Last"
-      }
-    }
-  },
   "services": {
     "close_cover": {
       "description": "Closes a cover.",
@@ -149,107 +136,5 @@
       "name": "Toggle tilt"
     }
   },
-  "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"
-    }
-  }
+  "title": "Cover"
 }

homeassistant/components/cover/trigger.py

@@ -1,107 +0,0 @@
-"""Provides triggers for covers."""
-
-from homeassistant.const import STATE_OFF, STATE_ON, STATE_UNAVAILABLE, STATE_UNKNOWN
-from homeassistant.core import HomeAssistant, State, split_entity_id
-from homeassistant.helpers.trigger import (
-    EntityTriggerBase,
-    Trigger,
-    get_device_class_or_undefined,
-)
-
-from .const import ATTR_IS_CLOSED, DOMAIN, CoverDeviceClass
-
-
-class CoverTriggerBase(EntityTriggerBase):
-    """Base trigger for cover state changes."""
-
-    _binary_sensor_target_state: str
-    _cover_is_closed_target_value: bool
-    _device_classes: dict[str, str]
-
-    def entity_filter(self, entities: set[str]) -> set[str]:
-        """Filter entities by cover device class."""
-        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_classes[split_entity_id(entity_id)[0]]
-        }
-
-    def is_valid_state(self, state: State) -> bool:
-        """Check if the state matches the target cover state."""
-        if split_entity_id(state.entity_id)[0] == DOMAIN:
-            return (
-                state.attributes.get(ATTR_IS_CLOSED)
-                == self._cover_is_closed_target_value
-            )
-        return state.state == self._binary_sensor_target_state
-
-    def is_valid_transition(self, from_state: State, to_state: State) -> bool:
-        """Check if the transition is valid for a cover state change."""
-        if from_state.state in (STATE_UNAVAILABLE, STATE_UNKNOWN):
-            return False
-        if split_entity_id(from_state.entity_id)[0] == DOMAIN:
-            if (from_is_closed := from_state.attributes.get(ATTR_IS_CLOSED)) is None:
-                return False
-            return from_is_closed != to_state.attributes.get(ATTR_IS_CLOSED)  # type: ignore[no-any-return]
-        return from_state.state != to_state.state
-
-
-def make_cover_opened_trigger(
-    *, device_classes: dict[str, str], domains: set[str] | None = None
-) -> type[CoverTriggerBase]:
-    """Create a trigger cover_opened."""
-
-    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
-
-
-def make_cover_closed_trigger(
-    *, device_classes: dict[str, str], domains: set[str] | None = None
-) -> type[CoverTriggerBase]:
-    """Create a trigger cover_closed."""
-
-    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

@@ -1,81 +0,0 @@
-.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

@@ -1,33 +1,80 @@
 """Provides triggers for doors."""
 
-from homeassistant.components.binary_sensor import (
-    DOMAIN as BINARY_SENSOR_DOMAIN,
-    BinarySensorDeviceClass,
-)
-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
+from homeassistant.components.binary_sensor import DOMAIN as BINARY_SENSOR_DOMAIN
+from homeassistant.components.cover import ATTR_IS_CLOSED, DOMAIN as COVER_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, Trigger
+from homeassistant.helpers.typing import UNDEFINED, UndefinedType
 
-DEVICE_CLASSES_DOOR: dict[str, str] = {
-    BINARY_SENSOR_DOMAIN: BinarySensorDeviceClass.DOOR,
-    COVER_DOMAIN: CoverDeviceClass.DOOR,
-}
+DEVICE_CLASS_DOOR = "door"
+
+
+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 DoorTriggerBase(EntityTriggerBase):
+    """Base trigger for door state changes."""
+
+    _domains = {BINARY_SENSOR_DOMAIN, COVER_DOMAIN}
+    _binary_sensor_target_state: str
+    _cover_is_closed_target_value: bool
+
+    def entity_filter(self, entities: set[str]) -> set[str]:
+        """Filter entities by door device class."""
+        entities = super().entity_filter(entities)
+        return {
+            entity_id
+            for entity_id in entities
+            if get_device_class_or_undefined(self._hass, entity_id) == DEVICE_CLASS_DOOR
+        }
+
+    def is_valid_state(self, state: State) -> bool:
+        """Check if the state matches the target door state."""
+        if split_entity_id(state.entity_id)[0] == COVER_DOMAIN:
+            return (
+                state.attributes.get(ATTR_IS_CLOSED)
+                == self._cover_is_closed_target_value
+            )
+        return state.state == self._binary_sensor_target_state
+
+    def is_valid_transition(self, from_state: State, to_state: State) -> bool:
+        """Check if the transition is valid for a door state change."""
+        if from_state.state in (STATE_UNAVAILABLE, STATE_UNKNOWN):
+            return False
+        if split_entity_id(from_state.entity_id)[0] == COVER_DOMAIN:
+            if (from_is_closed := from_state.attributes.get(ATTR_IS_CLOSED)) is None:
+                return False
+            return from_is_closed != to_state.attributes.get(ATTR_IS_CLOSED)
+        return from_state.state != to_state.state
+
+
+class DoorOpenedTrigger(DoorTriggerBase):
+    """Trigger for door opened state changes."""
+
+    _binary_sensor_target_state = STATE_ON
+    _cover_is_closed_target_value = False
+
+
+class DoorClosedTrigger(DoorTriggerBase):
+    """Trigger for door closed state changes."""
+
+    _binary_sensor_target_state = STATE_OFF
+    _cover_is_closed_target_value = True
 
 
 TRIGGERS: dict[str, type[Trigger]] = {
-    "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},
-    ),
+    "opened": DoorOpenedTrigger,
+    "closed": DoorClosedTrigger,
 }
 
 

homeassistant/components/ecobee/climate.py

@@ -490,14 +490,14 @@ class Thermostat(ClimateEntity):
         return None
 
     @property
-    def fan(self) -> str:
+    def fan(self):
         """Return the current fan status."""
         if "fan" in self.thermostat["equipmentStatus"]:
             return STATE_ON
         return STATE_OFF
 
     @property
-    def fan_mode(self) -> str:
+    def fan_mode(self):
         """Return the fan setting."""
         return self.thermostat["runtime"]["desiredFanMode"]
 
@@ -535,7 +535,7 @@ class Thermostat(ClimateEntity):
         return None
 
     @property
-    def hvac_mode(self) -> HVACMode:
+    def hvac_mode(self):
         """Return current operation."""
         return ECOBEE_HVAC_TO_HASS[self.settings["hvacMode"]]
 
@@ -548,7 +548,7 @@ class Thermostat(ClimateEntity):
             return None
 
     @property
-    def hvac_action(self) -> HVACAction:
+    def hvac_action(self):
         """Return current HVAC action.
 
         Ecobee returns a CSV string with different equipment that is active.

homeassistant/components/eheimdigital/__init__.py

@@ -10,7 +10,6 @@ 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

@@ -1,101 +0,0 @@
-"""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,19 +1,5 @@
 {
   "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,17 +33,6 @@
     }
   },
   "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,12 +363,10 @@ class EvoController(EvoClimateEntity):
 
         Data validation is not required, it will have been done upstream.
         """
-
-        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 service == EvoService.SET_SYSTEM_MODE:
+            mode = data[ATTR_MODE]
+        else:  # otherwise it is EvoService.RESET_SYSTEM
+            mode = EvoSystemMode.AUTO_WITH_RESET
 
         if ATTR_PERIOD in data:
             until = dt_util.start_of_local_day()

homeassistant/components/evohome/services.py

@@ -27,6 +27,7 @@ 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)
@@ -46,7 +47,7 @@ def _register_zone_entity_services(hass: HomeAssistant) -> None:
         DOMAIN,
         EvoService.CLEAR_ZONE_OVERRIDE,
         entity_domain=CLIMATE_DOMAIN,
-        schema=None,
+        schema=CLEAR_ZONE_OVERRIDE_SCHEMA,
         func="async_clear_zone_override",
     )
     service.async_register_platform_entity_service(
@@ -78,6 +79,7 @@ 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,
@@ -89,11 +91,18 @@ 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, "s2-pro"),
+                default=options.get(CONF_BACKEND, "s1"),
             ): SelectSelector(
                 SelectSelectorConfig(
                     options=[

homeassistant/components/fish_audio/const.py

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

homeassistant/components/freshr/__init__.py

@@ -1,47 +0,0 @@
-"""The Fresh-r integration."""
-
-import asyncio
-
-from homeassistant.const import Platform
-from homeassistant.core import HomeAssistant
-
-from .coordinator import (
-    FreshrConfigEntry,
-    FreshrData,
-    FreshrDevicesCoordinator,
-    FreshrReadingsCoordinator,
-)
-
-_PLATFORMS: list[Platform] = [Platform.SENSOR]
-
-
-async def async_setup_entry(hass: HomeAssistant, entry: FreshrConfigEntry) -> bool:
-    """Set up Fresh-r from a config entry."""
-    devices_coordinator = FreshrDevicesCoordinator(hass, entry)
-    await devices_coordinator.async_config_entry_first_refresh()
-
-    readings: dict[str, FreshrReadingsCoordinator] = {
-        device.id: FreshrReadingsCoordinator(
-            hass, entry, device, devices_coordinator.client
-        )
-        for device in devices_coordinator.data
-    }
-    await asyncio.gather(
-        *(
-            coordinator.async_config_entry_first_refresh()
-            for coordinator in readings.values()
-        )
-    )
-
-    entry.runtime_data = FreshrData(
-        devices=devices_coordinator,
-        readings=readings,
-    )
-
-    await hass.config_entries.async_forward_entry_setups(entry, _PLATFORMS)
-    return True
-
-
-async def async_unload_entry(hass: HomeAssistant, entry: FreshrConfigEntry) -> bool:
-    """Unload a config entry."""
-    return await hass.config_entries.async_unload_platforms(entry, _PLATFORMS)

homeassistant/components/freshr/config_flow.py

@@ -1,58 +0,0 @@
-"""Config flow for the Fresh-r integration."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from aiohttp import ClientError
-from pyfreshr import FreshrClient
-from pyfreshr.exceptions import LoginError
-import voluptuous as vol
-
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-
-from .const import DOMAIN, LOGGER
-
-STEP_USER_DATA_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_USERNAME): str,
-        vol.Required(CONF_PASSWORD): str,
-    }
-)
-
-
-class FreshrFlowHandler(ConfigFlow, domain=DOMAIN):
-    """Handle a config flow for Fresh-r."""
-
-    VERSION = 1
-    MINOR_VERSION = 1
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the initial step."""
-        errors: dict[str, str] = {}
-        if user_input is not None:
-            client = FreshrClient(session=async_get_clientsession(self.hass))
-            try:
-                await client.login(user_input[CONF_USERNAME], user_input[CONF_PASSWORD])
-            except LoginError:
-                errors["base"] = "invalid_auth"
-            except ClientError:
-                errors["base"] = "cannot_connect"
-            except Exception:  # noqa: BLE001
-                LOGGER.exception("Unexpected exception")
-                errors["base"] = "unknown"
-            else:
-                await self.async_set_unique_id(user_input[CONF_USERNAME].lower())
-                self._abort_if_unique_id_configured()
-                return self.async_create_entry(
-                    title=f"Fresh-r ({user_input[CONF_USERNAME]})",
-                    data=user_input,
-                )
-
-        return self.async_show_form(
-            step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
-        )

homeassistant/components/freshr/const.py

@@ -1,7 +0,0 @@
-"""Constants for the Fresh-r integration."""
-
-import logging
-from typing import Final
-
-DOMAIN: Final = "freshr"
-LOGGER = logging.getLogger(__package__)

homeassistant/components/freshr/coordinator.py

@@ -1,116 +0,0 @@
-"""Coordinator for Fresh-r integration."""
-
-from dataclasses import dataclass
-from datetime import timedelta
-
-from aiohttp import ClientError
-from pyfreshr import FreshrClient
-from pyfreshr.exceptions import ApiResponseError, LoginError
-from pyfreshr.models import DeviceReadings, DeviceSummary
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed
-from homeassistant.helpers.aiohttp_client import async_create_clientsession
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
-
-from .const import DOMAIN, LOGGER
-
-DEVICES_SCAN_INTERVAL = timedelta(hours=1)
-READINGS_SCAN_INTERVAL = timedelta(minutes=10)
-
-
-@dataclass
-class FreshrData:
-    """Runtime data stored on the config entry."""
-
-    devices: FreshrDevicesCoordinator
-    readings: dict[str, FreshrReadingsCoordinator]
-
-
-type FreshrConfigEntry = ConfigEntry[FreshrData]
-
-
-class FreshrDevicesCoordinator(DataUpdateCoordinator[list[DeviceSummary]]):
-    """Coordinator that refreshes the device list once an hour."""
-
-    config_entry: FreshrConfigEntry
-
-    def __init__(self, hass: HomeAssistant, config_entry: FreshrConfigEntry) -> None:
-        """Initialize the device list coordinator."""
-        super().__init__(
-            hass,
-            LOGGER,
-            config_entry=config_entry,
-            name=f"{DOMAIN}_devices",
-            update_interval=DEVICES_SCAN_INTERVAL,
-        )
-        self.client = FreshrClient(session=async_create_clientsession(hass))
-
-    async def _async_update_data(self) -> list[DeviceSummary]:
-        """Fetch the list of devices from the Fresh-r API."""
-        username = self.config_entry.data[CONF_USERNAME]
-        password = self.config_entry.data[CONF_PASSWORD]
-
-        try:
-            if not self.client.logged_in:
-                await self.client.login(username, password)
-
-            devices = await self.client.fetch_devices()
-        except LoginError as err:
-            raise ConfigEntryAuthFailed(
-                translation_domain=DOMAIN,
-                translation_key="auth_failed",
-            ) from err
-        except (ApiResponseError, ClientError) as err:
-            raise UpdateFailed(
-                translation_domain=DOMAIN,
-                translation_key="cannot_connect",
-            ) from err
-        else:
-            return devices
-
-
-class FreshrReadingsCoordinator(DataUpdateCoordinator[DeviceReadings]):
-    """Coordinator that refreshes readings for a single device every 10 minutes."""
-
-    config_entry: FreshrConfigEntry
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        config_entry: FreshrConfigEntry,
-        device: DeviceSummary,
-        client: FreshrClient,
-    ) -> None:
-        """Initialize the readings coordinator for a single device."""
-        super().__init__(
-            hass,
-            LOGGER,
-            config_entry=config_entry,
-            name=f"{DOMAIN}_readings_{device.id}",
-            update_interval=READINGS_SCAN_INTERVAL,
-        )
-        self._device = device
-        self._client = client
-
-    @property
-    def device_id(self) -> str:
-        """Return the device ID."""
-        return self._device.id
-
-    async def _async_update_data(self) -> DeviceReadings:
-        """Fetch current readings for this device from the Fresh-r API."""
-        try:
-            return await self._client.fetch_device_current(self._device)
-        except LoginError as err:
-            raise ConfigEntryAuthFailed(
-                translation_domain=DOMAIN,
-                translation_key="auth_failed",
-            ) from err
-        except (ApiResponseError, ClientError) as err:
-            raise UpdateFailed(
-                translation_domain=DOMAIN,
-                translation_key="cannot_connect",
-            ) from err

homeassistant/components/freshr/icons.json

@@ -1,18 +0,0 @@
-{
-  "entity": {
-    "sensor": {
-      "dew_point": {
-        "default": "mdi:thermometer-water"
-      },
-      "flow": {
-        "default": "mdi:fan"
-      },
-      "inside_temperature": {
-        "default": "mdi:home-thermometer"
-      },
-      "outside_temperature": {
-        "default": "mdi:thermometer"
-      }
-    }
-  }
-}

homeassistant/components/freshr/manifest.json

@@ -1,11 +0,0 @@
-{
-  "domain": "freshr",
-  "name": "Fresh-r",
-  "codeowners": ["@SierraNL"],
-  "config_flow": true,
-  "documentation": "https://www.home-assistant.io/integrations/freshr",
-  "integration_type": "hub",
-  "iot_class": "cloud_polling",
-  "quality_scale": "bronze",
-  "requirements": ["pyfreshr==1.2.0"]
-}

homeassistant/components/freshr/quality_scale.yaml

@@ -1,72 +0,0 @@
-rules:
-  # Bronze
-  action-setup:
-    status: exempt
-    comment: Integration does not register custom actions.
-  appropriate-polling: done
-  brands: done
-  common-modules: done
-  config-flow: done
-  config-flow-test-coverage: done
-  dependency-transparency: done
-  docs-actions:
-    status: exempt
-    comment: Integration does not register custom actions.
-  docs-high-level-description: done
-  docs-installation-instructions: done
-  docs-removal-instructions: done
-  entity-event-setup:
-    status: exempt
-    comment: Integration uses a polling coordinator, not event-driven updates.
-  entity-unique-id: done
-  has-entity-name: done
-  runtime-data: done
-  test-before-configure: done
-  test-before-setup: done
-  unique-config-entry: done
-
-  # Silver
-  action-exceptions:
-    status: exempt
-    comment: Integration does not register custom actions.
-  config-entry-unloading: done
-  docs-configuration-parameters: done
-  docs-installation-parameters: done
-  entity-unavailable: done
-  integration-owner: done
-  log-when-unavailable: done
-  parallel-updates: done
-  reauthentication-flow: todo
-  test-coverage: done
-
-  # Gold
-  devices: done
-  diagnostics: todo
-  discovery-update-info:
-    status: exempt
-    comment: Integration connects to a cloud service; no local network discovery is possible.
-  discovery: todo
-  docs-data-update: done
-  docs-examples: done
-  docs-known-limitations: done
-  docs-supported-devices: done
-  docs-supported-functions: done
-  docs-troubleshooting: done
-  docs-use-cases: done
-  dynamic-devices: todo
-  entity-category: done
-  entity-device-class: done
-  entity-disabled-by-default: done
-  entity-translations: done
-  exception-translations: done
-  icon-translations: done
-  reconfiguration-flow: todo
-  repair-issues:
-    status: exempt
-    comment: No actionable repair scenarios exist; authentication failures are handled via the reauthentication flow.
-  stale-devices: todo
-
-  # Platinum
-  async-dependency: done
-  inject-websession: done
-  strict-typing: done

homeassistant/components/freshr/sensor.py

@@ -1,158 +0,0 @@
-"""Sensor platform for the Fresh-r integration."""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from dataclasses import dataclass
-
-from pyfreshr.models import DeviceReadings, DeviceType
-
-from homeassistant.components.sensor import (
-    SensorDeviceClass,
-    SensorEntity,
-    SensorEntityDescription,
-    SensorStateClass,
-    StateType,
-)
-from homeassistant.const import (
-    CONCENTRATION_PARTS_PER_MILLION,
-    PERCENTAGE,
-    UnitOfTemperature,
-    UnitOfVolumeFlowRate,
-)
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
-
-from .const import DOMAIN
-from .coordinator import FreshrConfigEntry, FreshrReadingsCoordinator
-
-PARALLEL_UPDATES = 0
-
-
-@dataclass(frozen=True, kw_only=True)
-class FreshrSensorEntityDescription(SensorEntityDescription):
-    """Describes a Fresh-r sensor."""
-
-    value_fn: Callable[[DeviceReadings], StateType]
-
-
-_T1 = FreshrSensorEntityDescription(
-    key="t1",
-    translation_key="inside_temperature",
-    device_class=SensorDeviceClass.TEMPERATURE,
-    native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-    state_class=SensorStateClass.MEASUREMENT,
-    value_fn=lambda r: r.t1,
-)
-_T2 = FreshrSensorEntityDescription(
-    key="t2",
-    translation_key="outside_temperature",
-    device_class=SensorDeviceClass.TEMPERATURE,
-    native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-    state_class=SensorStateClass.MEASUREMENT,
-    value_fn=lambda r: r.t2,
-)
-_CO2 = FreshrSensorEntityDescription(
-    key="co2",
-    device_class=SensorDeviceClass.CO2,
-    native_unit_of_measurement=CONCENTRATION_PARTS_PER_MILLION,
-    state_class=SensorStateClass.MEASUREMENT,
-    value_fn=lambda r: r.co2,
-)
-_HUM = FreshrSensorEntityDescription(
-    key="hum",
-    device_class=SensorDeviceClass.HUMIDITY,
-    native_unit_of_measurement=PERCENTAGE,
-    state_class=SensorStateClass.MEASUREMENT,
-    value_fn=lambda r: r.hum,
-)
-_FLOW = FreshrSensorEntityDescription(
-    key="flow",
-    translation_key="flow",
-    device_class=SensorDeviceClass.VOLUME_FLOW_RATE,
-    native_unit_of_measurement=UnitOfVolumeFlowRate.CUBIC_METERS_PER_HOUR,
-    state_class=SensorStateClass.MEASUREMENT,
-    value_fn=lambda r: r.flow,
-)
-_DP = FreshrSensorEntityDescription(
-    key="dp",
-    translation_key="dew_point",
-    device_class=SensorDeviceClass.TEMPERATURE,
-    native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-    state_class=SensorStateClass.MEASUREMENT,
-    entity_registry_enabled_default=False,
-    value_fn=lambda r: r.dp,
-)
-_TEMP = FreshrSensorEntityDescription(
-    key="temp",
-    device_class=SensorDeviceClass.TEMPERATURE,
-    native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-    state_class=SensorStateClass.MEASUREMENT,
-    value_fn=lambda r: r.temp,
-)
-
-_DEVICE_TYPE_NAMES: dict[DeviceType, str] = {
-    DeviceType.FRESH_R: "Fresh-r",
-    DeviceType.FORWARD: "Fresh-r Forward",
-    DeviceType.MONITOR: "Fresh-r Monitor",
-}
-
-SENSOR_TYPES: dict[DeviceType, tuple[FreshrSensorEntityDescription, ...]] = {
-    DeviceType.FRESH_R: (_T1, _T2, _CO2, _HUM, _FLOW, _DP),
-    DeviceType.FORWARD: (_T1, _T2, _CO2, _HUM, _FLOW, _DP, _TEMP),
-    DeviceType.MONITOR: (_CO2, _HUM, _DP, _TEMP),
-}
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    config_entry: FreshrConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Fresh-r sensors from a config entry."""
-    entities: list[FreshrSensor] = []
-    for device in config_entry.runtime_data.devices.data:
-        descriptions = SENSOR_TYPES.get(
-            device.device_type, SENSOR_TYPES[DeviceType.FRESH_R]
-        )
-        device_info = DeviceInfo(
-            identifiers={(DOMAIN, device.id)},
-            name=_DEVICE_TYPE_NAMES.get(device.device_type, "Fresh-r"),
-            serial_number=device.id,
-            manufacturer="Fresh-r",
-        )
-        entities.extend(
-            FreshrSensor(
-                config_entry.runtime_data.readings[device.id],
-                description,
-                device_info,
-            )
-            for description in descriptions
-        )
-    async_add_entities(entities)
-
-
-class FreshrSensor(CoordinatorEntity[FreshrReadingsCoordinator], SensorEntity):
-    """Representation of a Fresh-r sensor."""
-
-    _attr_has_entity_name = True
-    entity_description: FreshrSensorEntityDescription
-
-    def __init__(
-        self,
-        coordinator: FreshrReadingsCoordinator,
-        description: FreshrSensorEntityDescription,
-        device_info: DeviceInfo,
-    ) -> None:
-        """Initialize the sensor."""
-        super().__init__(coordinator)
-        self.entity_description = description
-        self._attr_device_info = device_info
-        self._attr_unique_id = f"{coordinator.device_id}_{description.key}"
-
-    @property
-    def native_value(self) -> StateType:
-        """Return the value from coordinator data."""
-        return self.entity_description.value_fn(self.coordinator.data)

homeassistant/components/freshr/strings.json

@@ -1,51 +0,0 @@
-{
-  "config": {
-    "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
-      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",
-      "wrong_account": "Cannot change the account username."
-    },
-    "error": {
-      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
-      "unknown": "[%key:common::config_flow::error::unknown%]"
-    },
-    "step": {
-      "user": {
-        "data": {
-          "password": "[%key:common::config_flow::data::password%]",
-          "username": "[%key:common::config_flow::data::username%]"
-        },
-        "data_description": {
-          "password": "Your Fresh-r account password.",
-          "username": "Your Fresh-r account username (email address)."
-        }
-      }
-    }
-  },
-  "entity": {
-    "sensor": {
-      "dew_point": {
-        "name": "Dew point"
-      },
-      "flow": {
-        "name": "Air flow rate"
-      },
-      "inside_temperature": {
-        "name": "Inside temperature"
-      },
-      "outside_temperature": {
-        "name": "Outside temperature"
-      }
-    }
-  },
-  "exceptions": {
-    "auth_failed": {
-      "message": "Authentication failed. Check your Fresh-r username and password."
-    },
-    "cannot_connect": {
-      "message": "Could not connect to the Fresh-r service."
-    }
-  }
-}

homeassistant/components/garage_door/__init__.py

@@ -1,15 +0,0 @@
-"""Integration for garage door 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 = "garage_door"
-CONFIG_SCHEMA = cv.empty_config_schema(DOMAIN)
-
-
-async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
-    """Set up the component."""
-    return True

homeassistant/components/garage_door/icons.json

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

homeassistant/components/garage_door/manifest.json

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

homeassistant/components/garage_door/strings.json

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

homeassistant/components/garage_door/trigger.py

@@ -1,36 +0,0 @@
-"""Provides triggers for garage doors."""
-
-from homeassistant.components.binary_sensor import (
-    DOMAIN as BINARY_SENSOR_DOMAIN,
-    BinarySensorDeviceClass,
-)
-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_GARAGE_DOOR: dict[str, str] = {
-    BINARY_SENSOR_DOMAIN: BinarySensorDeviceClass.GARAGE_DOOR,
-    COVER_DOMAIN: CoverDeviceClass.GARAGE,
-}
-
-
-TRIGGERS: dict[str, type[Trigger]] = {
-    "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},
-    ),
-}
-
-
-async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
-    """Return the triggers for garage doors."""
-    return TRIGGERS

homeassistant/components/garage_door/triggers.yaml

@@ -1,29 +0,0 @@
-.trigger_common_fields: &trigger_common_fields
-  behavior:
-    required: true
-    default: any
-    selector:
-      select:
-        translation_key: trigger_behavior
-        options:
-          - first
-          - last
-          - any
-
-closed:
-  fields: *trigger_common_fields
-  target:
-    entity:
-      - domain: binary_sensor
-        device_class: garage_door
-      - domain: cover
-        device_class: garage
-
-opened:
-  fields: *trigger_common_fields
-  target:
-    entity:
-      - domain: binary_sensor
-        device_class: garage_door
-      - domain: cover
-        device_class: garage

homeassistant/components/gardena_bluetooth/__init__.py

@@ -2,18 +2,12 @@
 
 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 (
-    CharacteristicNoAccess,
-    CharacteristicNotFound,
-    CommunicationFailure,
-)
-from gardena_bluetooth.parse import CharacteristicTime
+from gardena_bluetooth.exceptions import CommunicationFailure
 
 from homeassistant.components import bluetooth
 from homeassistant.const import CONF_ADDRESS, Platform
@@ -29,7 +23,6 @@ from .coordinator import (
     GardenaBluetoothConfigEntry,
     GardenaBluetoothCoordinator,
 )
-from .util import async_get_product_type
 
 PLATFORMS: list[Platform] = [
     Platform.BINARY_SENSOR,
@@ -58,41 +51,22 @@ 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 = entry.title
-        name = await client.read_char(DeviceConfiguration.custom_device_name, name)
-
-        await _update_timestamp(client, DeviceConfiguration.unix_timestamp)
-
+        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())
     except (TimeoutError, CommunicationFailure, DeviceUnavailable) as exception:
         await client.disconnect()
         raise ConfigEntryNotReady(
@@ -109,7 +83,7 @@ async def async_setup_entry(
     )
 
     coordinator = GardenaBluetoothCoordinator(
-        hass, entry, LOGGER, client, set(chars.keys()), device, address
+        hass, entry, LOGGER, client, uuids, 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.unique_id,
+        key=Valve.connected_state.uuid,
         translation_key="valve_connected_state",
         device_class=BinarySensorDeviceClass.CONNECTIVITY,
         entity_category=EntityCategory.DIAGNOSTIC,
         char=Valve.connected_state,
     ),
     GardenaBluetoothBinarySensorEntityDescription(
-        key=Sensor.connected_state.unique_id,
+        key=Sensor.connected_state.uuid,
         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.char.unique_id in coordinator.characteristics
+        if description.key 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.unique_id,
+        key=Reset.factory_reset.uuid,
         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.char.unique_id in coordinator.characteristics
+        if description.key 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==2.1.0"]
+  "requirements": ["gardena-bluetooth==1.6.0"]
 }

homeassistant/components/gardena_bluetooth/number.py

@@ -46,7 +46,7 @@ class GardenaBluetoothNumberEntityDescription(NumberEntityDescription):
 
 DESCRIPTIONS = (
     GardenaBluetoothNumberEntityDescription(
-        key=Valve.manual_watering_time.unique_id,
+        key=Valve.manual_watering_time.uuid,
         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.unique_id,
+        key=Valve.remaining_open_time.uuid,
         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.unique_id,
+        key=DeviceConfiguration.rain_pause.uuid,
         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.unique_id,
+        key=DeviceConfiguration.seasonal_adjust.uuid,
         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.unique_id,
+        key=Sensor.threshold.uuid,
         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.char.unique_id in coordinator.characteristics
+        if description.key in coordinator.characteristics
     ]
-    if Valve.remaining_open_time.unique_id in coordinator.characteristics:
+    if Valve.remaining_open_time.uuid 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.unique_id,
+        key=Valve.activation_reason.uuid,
         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.unique_id,
+        key=Battery.battery_level.uuid,
         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.unique_id,
+        key=Sensor.battery_level.uuid,
         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.unique_id,
+        key=Sensor.value.uuid,
         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.unique_id,
+        key=Sensor.type.uuid,
         translation_key="sensor_type",
         entity_category=EntityCategory.DIAGNOSTIC,
         char=Sensor.type,
         connected_state=Sensor.connected_state,
     ),
     GardenaBluetoothSensorEntityDescription(
-        key=Sensor.measurement_timestamp.unique_id,
+        key=Sensor.measurement_timestamp.uuid,
         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.char.unique_id in coordinator.characteristics
+        if description.key in coordinator.characteristics
     ]
-    if Valve.remaining_open_time.unique_id in coordinator.characteristics:
+    if Valve.remaining_open_time.uuid 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.unique_id,
-        Valve.manual_watering_time.unique_id,
-        Valve.remaining_open_time.unique_id,
+        Valve.state.uuid,
+        Valve.manual_watering_time.uuid,
+        Valve.remaining_open_time.uuid,
     }
 
     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.unique_id}"
+        self._attr_unique_id = f"{coordinator.address}-{Valve.state.uuid}"
         self._attr_translation_key = "state"
         self._attr_is_on = None
         self._attr_entity_registry_enabled_default = False

homeassistant/components/gardena_bluetooth/util.py

@@ -1,51 +0,0 @@
-"""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.unique_id,
-        Valve.manual_watering_time.unique_id,
-        Valve.remaining_open_time.unique_id,
+        Valve.state.uuid,
+        Valve.manual_watering_time.uuid,
+        Valve.remaining_open_time.uuid,
     }
 
     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.unique_id}"
+        self._attr_unique_id = f"{coordinator.address}-{Valve.state.uuid}"
 
     def _handle_coordinator_update(self) -> None:
         self._attr_is_closed = not self.coordinator.get_cached(Valve.state)

homeassistant/components/gate/__init__.py

@@ -1,17 +0,0 @@
-"""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

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

homeassistant/components/gate/manifest.json

@@ -1,8 +0,0 @@
-{
-  "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

@@ -1,38 +0,0 @@
-{
-  "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

@@ -1,25 +0,0 @@
-"""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/ghost/config_flow.py

@@ -108,50 +108,6 @@ class GhostConfigFlow(ConfigFlow, domain=DOMAIN):
             description_placeholders={"setup_url": GHOST_INTEGRATION_SETUP_URL},
         )
 
-    async def async_step_reconfigure(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle reconfiguration."""
-        reconfigure_entry = self._get_reconfigure_entry()
-        errors: dict[str, str] = {}
-
-        if user_input is not None:
-            api_url = user_input[CONF_API_URL].rstrip("/")
-            admin_api_key = user_input[CONF_ADMIN_API_KEY]
-
-            if ":" not in admin_api_key:
-                errors["base"] = "invalid_api_key"
-            else:
-                try:
-                    site = await self._validate_credentials(api_url, admin_api_key)
-                except GhostAuthError:
-                    errors["base"] = "invalid_auth"
-                except GhostError:
-                    errors["base"] = "cannot_connect"
-                except Exception:
-                    _LOGGER.exception("Unexpected error during Ghost reconfigure")
-                    errors["base"] = "unknown"
-                else:
-                    await self.async_set_unique_id(site["site_uuid"])
-                    self._abort_if_unique_id_mismatch()
-                    return self.async_update_reload_and_abort(
-                        reconfigure_entry,
-                        data_updates={
-                            CONF_API_URL: api_url,
-                            CONF_ADMIN_API_KEY: admin_api_key,
-                        },
-                    )
-
-        return self.async_show_form(
-            step_id="reconfigure",
-            data_schema=self.add_suggested_values_to_schema(
-                data_schema=STEP_USER_DATA_SCHEMA,
-                suggested_values=user_input or reconfigure_entry.data,
-            ),
-            errors=errors,
-            description_placeholders={"setup_url": GHOST_INTEGRATION_SETUP_URL},
-        )
-
     async def _validate_credentials(
         self, api_url: str, admin_api_key: str
     ) -> dict[str, Any]:

homeassistant/components/ghost/manifest.json

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

homeassistant/components/ghost/quality_scale.yaml

@@ -68,11 +68,13 @@ rules:
   entity-translations: done
   exception-translations: done
   icon-translations: done
-  reconfiguration-flow: done
+  reconfiguration-flow: todo
   repair-issues:
     status: exempt
     comment: No repair scenarios identified for this integration.
-  stale-devices: done
+  stale-devices:
+    status: todo
+    comment: Remove newsletter entities when newsletter is removed
 
   # Platinum
   async-dependency: done

homeassistant/components/ghost/sensor.py

@@ -12,9 +12,7 @@ from homeassistant.components.sensor import (
     SensorEntityDescription,
     SensorStateClass,
 )
-from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
@@ -212,67 +210,36 @@ async def async_setup_entry(
 
     async_add_entities(entities)
 
-    # Remove stale newsletter entities left over from previous runs.
-    entity_registry = er.async_get(hass)
-    prefix = f"{entry.unique_id}_newsletter_"
-    active_newsletters = {
-        newsletter_id
-        for newsletter_id, newsletter in coordinator.data.newsletters.items()
-        if newsletter.get("status") == "active"
-    }
-    for entity_entry in er.async_entries_for_config_entry(
-        entity_registry, entry.entry_id
-    ):
-        if (
-            entity_entry.unique_id.startswith(prefix)
-            and entity_entry.unique_id[len(prefix) :] not in active_newsletters
-        ):
-            entity_registry.async_remove(entity_entry.entity_id)
-
     newsletter_added: set[str] = set()
 
     @callback
-    def _async_update_newsletter_entities() -> None:
-        """Add new and remove stale newsletter entities."""
+    def _async_add_newsletter_entities() -> None:
+        """Add newsletter entities when new newsletters appear."""
         nonlocal newsletter_added
 
-        active_newsletters = {
+        new_newsletters = {
             newsletter_id
             for newsletter_id, newsletter in coordinator.data.newsletters.items()
             if newsletter.get("status") == "active"
-        }
+        } - newsletter_added
 
-        new_newsletters = active_newsletters - newsletter_added
+        if not new_newsletters:
+            return
 
-        if new_newsletters:
-            async_add_entities(
-                GhostNewsletterSensorEntity(
-                    coordinator,
-                    entry,
-                    newsletter_id,
-                    coordinator.data.newsletters[newsletter_id].get(
-                        "name", "Newsletter"
-                    ),
-                )
-                for newsletter_id in new_newsletters
+        async_add_entities(
+            GhostNewsletterSensorEntity(
+                coordinator,
+                entry,
+                newsletter_id,
+                coordinator.data.newsletters[newsletter_id].get("name", "Newsletter"),
             )
-            newsletter_added.update(new_newsletters)
+            for newsletter_id in new_newsletters
+        )
+        newsletter_added |= new_newsletters
 
-        removed_newsletters = newsletter_added - active_newsletters
-        if removed_newsletters:
-            entity_registry = er.async_get(hass)
-            for newsletter_id in removed_newsletters:
-                unique_id = f"{entry.unique_id}_newsletter_{newsletter_id}"
-                entity_id = entity_registry.async_get_entity_id(
-                    Platform.SENSOR, DOMAIN, unique_id
-                )
-                if entity_id:
-                    entity_registry.async_remove(entity_id)
-            newsletter_added -= removed_newsletters
-
-    _async_update_newsletter_entities()
+    _async_add_newsletter_entities()
     entry.async_on_unload(
-        coordinator.async_add_listener(_async_update_newsletter_entities)
+        coordinator.async_add_listener(_async_add_newsletter_entities)
     )
 
 
@@ -343,10 +310,9 @@ class GhostNewsletterSensorEntity(
     @property
     def available(self) -> bool:
         """Return True if the entity is available."""
-        return (
-            super().available
-            and self._newsletter_id in self.coordinator.data.newsletters
-        )
+        if not super().available or self.coordinator.data is None:
+            return False
+        return self._newsletter_id in self.coordinator.data.newsletters
 
     @property
     def native_value(self) -> int | None:

homeassistant/components/ghost/strings.json

@@ -2,9 +2,7 @@
   "config": {
     "abort": {
       "already_configured": "This Ghost site is already configured.",
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
-      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",
-      "unique_id_mismatch": "The provided credentials belong to a different Ghost site."
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
     },
     "error": {
       "cannot_connect": "Failed to connect to Ghost. Please check your URL.",
@@ -23,17 +21,6 @@
         "description": "Your API key for {title} is invalid. [Create a new integration key]({setup_url}) to reauthenticate.",
         "title": "[%key:common::config_flow::title::reauth%]"
       },
-      "reconfigure": {
-        "data": {
-          "admin_api_key": "[%key:component::ghost::config::step::user::data::admin_api_key%]",
-          "api_url": "[%key:component::ghost::config::step::user::data::api_url%]"
-        },
-        "data_description": {
-          "admin_api_key": "[%key:component::ghost::config::step::user::data_description::admin_api_key%]",
-          "api_url": "[%key:component::ghost::config::step::user::data_description::api_url%]"
-        },
-        "description": "Update the configuration for your Ghost integration. [Create a custom integration]({setup_url}) to get your API URL and Admin API key."
-      },
       "user": {
         "data": {
           "admin_api_key": "Admin API key",

homeassistant/components/google_drive/backup.py

@@ -13,7 +13,6 @@ from homeassistant.components.backup import (
     BackupAgent,
     BackupAgentError,
     BackupNotFound,
-    OnProgressCallback,
 )
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
@@ -76,7 +75,6 @@ class GoogleDriveBackupAgent(BackupAgent):
         *,
         open_stream: Callable[[], Coroutine[Any, Any, AsyncIterator[bytes]]],
         backup: AgentBackup,
-        on_progress: OnProgressCallback,
         **kwargs: Any,
     ) -> None:
         """Upload a backup.

homeassistant/components/group/entity.py

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

homeassistant/components/group/lock.py

@@ -20,6 +20,9 @@ from homeassistant.const import (
     CONF_ENTITIES,
     CONF_NAME,
     CONF_UNIQUE_ID,
+    SERVICE_LOCK,
+    SERVICE_OPEN,
+    SERVICE_UNLOCK,
     STATE_UNAVAILABLE,
     STATE_UNKNOWN,
 )
@@ -29,7 +32,6 @@ 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
@@ -115,13 +117,47 @@ 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,28 +1,4 @@
-"""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)
-"""
+"""The Growatt server PV inverter sensor integration."""
 
 from collections.abc import Mapping
 from json import JSONDecodeError
@@ -49,7 +25,6 @@ from .const import (
     DOMAIN,
     LOGIN_INVALID_AUTH_CODE,
     PLATFORMS,
-    V1_API_ERROR_NO_PRIVILEGE,
 )
 from .coordinator import GrowattConfigEntry, GrowattCoordinator
 from .models import GrowattRuntimeData
@@ -252,12 +227,8 @@ 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.error_msg or str(e)} (Code: {e.error_code})"
+            f"API error during device list: {e} (Code: {getattr(e, 'error_code', None)}, Message: {getattr(e, 'error_msg', None)})"
         ) from e
     devices = devices_dict.get("devices", [])
     # Only MIN device (type = 7) support implemented in current V1 API
@@ -301,7 +272,6 @@ 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,6 +1,5 @@
 """Config flow for growatt server integration."""
 
-from collections.abc import Mapping
 import logging
 from typing import Any
 
@@ -32,11 +31,8 @@ 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__)
 
 
@@ -64,137 +60,6 @@ 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:
@@ -264,11 +129,9 @@ class GrowattServerConfigFlow(ConfigFlow, domain=DOMAIN):
             _LOGGER.error(
                 "Growatt V1 API error: %s (Code: %s)",
                 e.error_msg or str(e),
-                e.error_code,
+                getattr(e, "error_code", None),
             )
-            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})
+            return self._async_show_token_form({"base": ERROR_INVALID_AUTH})
         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,17 +40,8 @@ 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,11 +13,7 @@ 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 (
-    ConfigEntryAuthFailed,
-    HomeAssistantError,
-    ServiceValidationError,
-)
+from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 from homeassistant.util import dt as dt_util
 
@@ -27,8 +23,6 @@ from .const import (
     BATT_MODE_LOAD_FIRST,
     DEFAULT_URL,
     DOMAIN,
-    LOGIN_INVALID_AUTH_CODE,
-    V1_API_ERROR_NO_PRIVILEGE,
 )
 from .models import GrowattRuntimeData
 
@@ -69,7 +63,6 @@ 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]
@@ -95,14 +88,7 @@ class GrowattCoordinator(DataUpdateCoordinator[dict[str, Any]]):
 
         # login only required for classic API
         if self.api_version == "classic":
-            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}")
+            self.api.login(self.username, self.password)
 
         if self.device_type == "total":
             if self.api_version == "v1":
@@ -114,16 +100,7 @@ class GrowattCoordinator(DataUpdateCoordinator[dict[str, Any]]):
                 # todayEnergy -> today_energy
                 # totalEnergy -> total_energy
                 # invTodayPpv -> current_power
-                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 = self.api.plant_energy_overview(self.plant_id)
                 total_info["todayEnergy"] = total_info["today_energy"]
                 total_info["totalEnergy"] = total_info["total_energy"]
                 total_info["invTodayPpv"] = total_info["current_power"]
@@ -145,10 +122,6 @@ 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: done
+  reauthentication-flow: todo
   test-coverage: done
 
   # Gold

homeassistant/components/growatt_server/strings.json

@@ -3,8 +3,7 @@
     "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",
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
+      "no_plants": "No plants have been found on this account"
     },
     "error": {
       "cannot_connect": "Cannot connect to Growatt servers. Please check your internet connection and try again.",
@@ -14,7 +13,7 @@
       "password_auth": {
         "data": {
           "password": "[%key:common::config_flow::data::password%]",
-          "region": "Server region",
+          "url": "Server region",
           "username": "[%key:common::config_flow::data::username%]"
         },
         "title": "Enter your Growatt login credentials"
@@ -25,20 +24,10 @@
         },
         "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": {
-          "region": "[%key:component::growatt_server::config::step::password_auth::data::region%]",
-          "token": "API Token"
+          "token": "API Token",
+          "url": "Server region"
         },
         "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/backup.py

@@ -44,7 +44,6 @@ from homeassistant.components.backup import (
     IncorrectPasswordError,
     ManagerBackup,
     NewBackup,
-    OnProgressCallback,
     RestoreBackupEvent,
     RestoreBackupStage,
     RestoreBackupState,
@@ -184,7 +183,6 @@ class SupervisorBackupAgent(BackupAgent):
         *,
         open_stream: Callable[[], Coroutine[Any, Any, AsyncIterator[bytes]]],
         backup: AgentBackup,
-        on_progress: OnProgressCallback,
         **kwargs: Any,
     ) -> None:
         """Upload a backup.

homeassistant/components/home_connect/__init__.py

@@ -38,7 +38,6 @@ 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
+from .entity import HomeConnectEntity, HomeConnectOptionEntity
 
 
 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[HomeConnectEntity],
+        list[HomeConnectOptionEntity],
     ],
     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[HomeConnectEntity],
+        list[HomeConnectOptionEntity],
     ]
     | 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[HomeConnectEntity],
+        list[HomeConnectOptionEntity],
     ]
     | None = None,
 ) -> None:

homeassistant/components/home_connect/fan.py

@@ -1,235 +0,0 @@
-"""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[HomeConnectEntity]:
+) -> list[HomeConnectOptionEntity]:
     """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[HomeConnectEntity]:
+) -> list[HomeConnectOptionEntity]:
     """Get a list of entities."""
     return [
         HomeConnectSelectOptionEntity(appliance_coordinator, desc)