Add missing humidity feature flag to Whirlpool climate

Both the service action and attribute were implemented already.

.github/workflows/ci.yaml

@@ -653,7 +653,7 @@ jobs:
       - name: Check out code from GitHub
         uses: actions/checkout@v4.2.2
       - name: Dependency review
-        uses: actions/dependency-review-action@v4.5.0
+        uses: actions/dependency-review-action@v4.6.0
         with:
           license-check: false # We use our own license audit checks
 

.github/workflows/codeql.yml

@@ -24,11 +24,11 @@ jobs:
         uses: actions/checkout@v4.2.2
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3.28.13
+        uses: github/codeql-action/init@v3.28.15
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v3.28.13
+        uses: github/codeql-action/analyze@v3.28.15
         with:
           category: "/language:python"

.strict-typing

@@ -364,6 +364,7 @@ homeassistant.components.notify.*
 homeassistant.components.notion.*
 homeassistant.components.number.*
 homeassistant.components.nut.*
+homeassistant.components.ohme.*
 homeassistant.components.onboarding.*
 homeassistant.components.oncue.*
 homeassistant.components.onedrive.*

CODEOWNERS

@@ -704,6 +704,8 @@ build.json @home-assistant/supervisor
 /tests/components/image_upload/ @home-assistant/core
 /homeassistant/components/imap/ @jbouwh
 /tests/components/imap/ @jbouwh
+/homeassistant/components/imeon_inverter/ @Imeon-Energy
+/tests/components/imeon_inverter/ @Imeon-Energy
 /homeassistant/components/imgw_pib/ @bieniu
 /tests/components/imgw_pib/ @bieniu
 /homeassistant/components/improv_ble/ @emontnemery

homeassistant/bootstrap.py

@@ -859,8 +859,14 @@ async def _async_set_up_integrations(
     integrations, all_integrations = await _async_resolve_domains_and_preload(
         hass, config
     )
-    all_domains = set(all_integrations)
-    domains = set(integrations)
+    # Detect all cycles
+    integrations_after_dependencies = (
+        await loader.resolve_integrations_after_dependencies(
+            hass, all_integrations.values(), set(all_integrations)
+        )
+    )
+    all_domains = set(integrations_after_dependencies)
+    domains = set(integrations) & all_domains
 
     _LOGGER.info(
         "Domains to be set up: %s | %s",
@@ -868,6 +874,8 @@ async def _async_set_up_integrations(
         all_domains - domains,
     )
 
+    async_set_domains_to_be_loaded(hass, all_domains)
+
     # Initialize recorder
     if "recorder" in all_domains:
         recorder.async_initialize_recorder(hass)
@@ -900,24 +908,12 @@ async def _async_set_up_integrations(
         stage_dep_domains_unfiltered = {
             dep
             for domain in stage_domains
-            for dep in all_integrations[domain].all_dependencies
+            for dep in integrations_after_dependencies[domain]
             if dep not in stage_domains
         }
         stage_dep_domains = stage_dep_domains_unfiltered - hass.config.components
 
         stage_all_domains = stage_domains | stage_dep_domains
-        stage_all_integrations = {
-            domain: all_integrations[domain] for domain in stage_all_domains
-        }
-        # Detect all cycles
-        stage_integrations_after_dependencies = (
-            await loader.resolve_integrations_after_dependencies(
-                hass, stage_all_integrations.values(), stage_all_domains
-            )
-        )
-        stage_all_domains = set(stage_integrations_after_dependencies)
-        stage_domains &= stage_all_domains
-        stage_dep_domains &= stage_all_domains
 
         _LOGGER.info(
             "Setting up stage %s: %s | %s\nDependencies: %s | %s",
@@ -928,8 +924,6 @@ async def _async_set_up_integrations(
             stage_dep_domains_unfiltered - stage_dep_domains,
         )
 
-        async_set_domains_to_be_loaded(hass, stage_all_domains)
-
         if timeout is None:
             await _async_setup_multi_components(hass, stage_all_domains, config)
             continue

homeassistant/brands/eve.json

@@ -0,0 +1,5 @@
+{
+  "domain": "eve",
+  "name": "Eve",
+  "iot_standards": ["matter"]
+}

homeassistant/components/accuweather/strings.json

@@ -72,10 +72,10 @@
           "level": {
             "name": "Level",
             "state": {
-              "high": "High",
-              "low": "Low",
+              "high": "[%key:common::state::high%]",
+              "low": "[%key:common::state::low%]",
               "moderate": "Moderate",
-              "very_high": "Very high"
+              "very_high": "[%key:common::state::very_high%]"
             }
           }
         }
@@ -89,10 +89,10 @@
           "level": {
             "name": "[%key:component::accuweather::entity::sensor::grass_pollen::state_attributes::level::name%]",
             "state": {
-              "high": "[%key:component::accuweather::entity::sensor::grass_pollen::state_attributes::level::state::high%]",
-              "low": "[%key:component::accuweather::entity::sensor::grass_pollen::state_attributes::level::state::low%]",
+              "high": "[%key:common::state::high%]",
+              "low": "[%key:common::state::low%]",
               "moderate": "[%key:component::accuweather::entity::sensor::grass_pollen::state_attributes::level::state::moderate%]",
-              "very_high": "[%key:component::accuweather::entity::sensor::grass_pollen::state_attributes::level::state::very_high%]"
+              "very_high": "[%key:common::state::very_high%]"
             }
           }
         }
@@ -123,10 +123,10 @@
           "level": {
             "name": "[%key:component::accuweather::entity::sensor::grass_pollen::state_attributes::level::name%]",
             "state": {
-              "high": "[%key:component::accuweather::entity::sensor::grass_pollen::state_attributes::level::state::high%]",
-              "low": "[%key:component::accuweather::entity::sensor::grass_pollen::state_attributes::level::state::low%]",
+              "high": "[%key:common::state::high%]",
+              "low": "[%key:common::state::low%]",
               "moderate": "[%key:component::accuweather::entity::sensor::grass_pollen::state_attributes::level::state::moderate%]",
-              "very_high": "[%key:component::accuweather::entity::sensor::grass_pollen::state_attributes::level::state::very_high%]"
+              "very_high": "[%key:common::state::very_high%]"
             }
           }
         }
@@ -167,10 +167,10 @@
           "level": {
             "name": "[%key:component::accuweather::entity::sensor::grass_pollen::state_attributes::level::name%]",
             "state": {
-              "high": "[%key:component::accuweather::entity::sensor::grass_pollen::state_attributes::level::state::high%]",
-              "low": "[%key:component::accuweather::entity::sensor::grass_pollen::state_attributes::level::state::low%]",
+              "high": "[%key:common::state::high%]",
+              "low": "[%key:common::state::low%]",
               "moderate": "[%key:component::accuweather::entity::sensor::grass_pollen::state_attributes::level::state::moderate%]",
-              "very_high": "[%key:component::accuweather::entity::sensor::grass_pollen::state_attributes::level::state::very_high%]"
+              "very_high": "[%key:common::state::very_high%]"
             }
           }
         }
@@ -181,10 +181,10 @@
           "level": {
             "name": "[%key:component::accuweather::entity::sensor::grass_pollen::state_attributes::level::name%]",
             "state": {
-              "high": "[%key:component::accuweather::entity::sensor::grass_pollen::state_attributes::level::state::high%]",
-              "low": "[%key:component::accuweather::entity::sensor::grass_pollen::state_attributes::level::state::low%]",
+              "high": "[%key:common::state::high%]",
+              "low": "[%key:common::state::low%]",
               "moderate": "[%key:component::accuweather::entity::sensor::grass_pollen::state_attributes::level::state::moderate%]",
-              "very_high": "[%key:component::accuweather::entity::sensor::grass_pollen::state_attributes::level::state::very_high%]"
+              "very_high": "[%key:common::state::very_high%]"
             }
           }
         }
@@ -195,10 +195,10 @@
           "level": {
             "name": "[%key:component::accuweather::entity::sensor::grass_pollen::state_attributes::level::name%]",
             "state": {
-              "high": "[%key:component::accuweather::entity::sensor::grass_pollen::state_attributes::level::state::high%]",
-              "low": "[%key:component::accuweather::entity::sensor::grass_pollen::state_attributes::level::state::low%]",
+              "high": "[%key:common::state::high%]",
+              "low": "[%key:common::state::low%]",
               "moderate": "[%key:component::accuweather::entity::sensor::grass_pollen::state_attributes::level::state::moderate%]",
-              "very_high": "[%key:component::accuweather::entity::sensor::grass_pollen::state_attributes::level::state::very_high%]"
+              "very_high": "[%key:common::state::very_high%]"
             }
           }
         }

homeassistant/components/airvisual/strings.json

@@ -16,8 +16,8 @@
         "data": {
           "api_key": "[%key:common::config_flow::data::api_key%]",
           "city": "City",
-          "country": "Country",
-          "state": "State"
+          "state": "State",
+          "country": "[%key:common::config_flow::data::country%]"
         }
       },
       "reauth_confirm": {
@@ -56,12 +56,12 @@
     "sensor": {
       "pollutant_label": {
         "state": {
-          "co": "Carbon monoxide",
-          "n2": "Nitrogen dioxide",
-          "o3": "Ozone",
-          "p1": "PM10",
-          "p2": "PM2.5",
-          "s2": "Sulfur dioxide"
+          "co": "[%key:component::sensor::entity_component::carbon_monoxide::name%]",
+          "n2": "[%key:component::sensor::entity_component::nitrogen_dioxide::name%]",
+          "o3": "[%key:component::sensor::entity_component::ozone::name%]",
+          "p1": "[%key:component::sensor::entity_component::pm10::name%]",
+          "p2": "[%key:component::sensor::entity_component::pm25::name%]",
+          "s2": "[%key:component::sensor::entity_component::sulphur_dioxide::name%]"
         }
       },
       "pollutant_level": {

homeassistant/components/airzone/manifest.json

@@ -11,5 +11,5 @@
   "documentation": "https://www.home-assistant.io/integrations/airzone",
   "iot_class": "local_polling",
   "loggers": ["aioairzone"],
-  "requirements": ["aioairzone==0.9.9"]
+  "requirements": ["aioairzone==1.0.0"]
 }

homeassistant/components/airzone/sensor.py

@@ -9,6 +9,8 @@ from aioairzone.const import (
     AZD_HUMIDITY,
     AZD_TEMP,
     AZD_TEMP_UNIT,
+    AZD_THERMOSTAT_BATTERY,
+    AZD_THERMOSTAT_SIGNAL,
     AZD_WEBSERVER,
     AZD_WIFI_RSSI,
     AZD_ZONES,
@@ -73,6 +75,20 @@ ZONE_SENSOR_TYPES: Final[tuple[SensorEntityDescription, ...]] = (
         native_unit_of_measurement=PERCENTAGE,
         state_class=SensorStateClass.MEASUREMENT,
     ),
+    SensorEntityDescription(
+        device_class=SensorDeviceClass.BATTERY,
+        key=AZD_THERMOSTAT_BATTERY,
+        native_unit_of_measurement=PERCENTAGE,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    SensorEntityDescription(
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
+        key=AZD_THERMOSTAT_SIGNAL,
+        native_unit_of_measurement=PERCENTAGE,
+        state_class=SensorStateClass.MEASUREMENT,
+        translation_key="thermostat_signal",
+    ),
 )
 
 

homeassistant/components/airzone/strings.json

@@ -76,6 +76,9 @@
     "sensor": {
       "rssi": {
         "name": "RSSI"
+      },
+      "thermostat_signal": {
+        "name": "Signal strength"
       }
     }
   }

homeassistant/components/androidtv_remote/entity.py

@@ -73,7 +73,7 @@ class AndroidTVRemoteBaseEntity(Entity):
             self._api.send_key_command(key_code, direction)
         except ConnectionClosed as exc:
             raise HomeAssistantError(
-                "Connection to Android TV device is closed"
+                translation_domain=DOMAIN, translation_key="connection_closed"
             ) from exc
 
     def _send_launch_app_command(self, app_link: str) -> None:
@@ -85,5 +85,5 @@ class AndroidTVRemoteBaseEntity(Entity):
             self._api.send_launch_app_command(app_link)
         except ConnectionClosed as exc:
             raise HomeAssistantError(
-                "Connection to Android TV device is closed"
+                translation_domain=DOMAIN, translation_key="connection_closed"
             ) from exc

homeassistant/components/androidtv_remote/media_player.py

@@ -21,7 +21,7 @@ from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import AndroidTVRemoteConfigEntry
-from .const import CONF_APP_ICON, CONF_APP_NAME
+from .const import CONF_APP_ICON, CONF_APP_NAME, DOMAIN
 from .entity import AndroidTVRemoteBaseEntity
 
 PARALLEL_UPDATES = 0
@@ -233,5 +233,5 @@ class AndroidTVRemoteMediaPlayerEntity(AndroidTVRemoteBaseEntity, MediaPlayerEnt
                 await asyncio.sleep(delay_secs)
         except ConnectionClosed as exc:
             raise HomeAssistantError(
-                "Connection to Android TV device is closed"
+                translation_domain=DOMAIN, translation_key="connection_closed"
             ) from exc

homeassistant/components/androidtv_remote/strings.json

@@ -54,5 +54,10 @@
         }
       }
     }
+  },
+  "exceptions": {
+    "connection_closed": {
+      "message": "Connection to the Android TV device is closed"
+    }
   }
 }

homeassistant/components/apcupsd/binary_sensor.py

@@ -53,10 +53,8 @@ class OnlineStatus(CoordinatorEntity[APCUPSdCoordinator], BinarySensorEntity):
         """Initialize the APCUPSd binary device."""
         super().__init__(coordinator, context=description.key.upper())
 
-        # Set up unique id and device info if serial number is available.
-        if (serial_no := coordinator.data.serial_no) is not None:
-            self._attr_unique_id = f"{serial_no}_{description.key}"
         self.entity_description = description
+        self._attr_unique_id = f"{coordinator.unique_device_id}_{description.key}"
         self._attr_device_info = coordinator.device_info
 
     @property

homeassistant/components/apcupsd/coordinator.py

@@ -85,11 +85,16 @@ class APCUPSdCoordinator(DataUpdateCoordinator[APCUPSdData]):
         self._host = host
         self._port = port
 
+    @property
+    def unique_device_id(self) -> str:
+        """Return a unique ID of the device, which is the serial number (if available) or the config entry ID."""
+        return self.data.serial_no or self.config_entry.entry_id
+
     @property
     def device_info(self) -> DeviceInfo:
         """Return the DeviceInfo of this APC UPS, if serial number is available."""
         return DeviceInfo(
-            identifiers={(DOMAIN, self.data.serial_no or self.config_entry.entry_id)},
+            identifiers={(DOMAIN, self.unique_device_id)},
             model=self.data.model,
             manufacturer="APC",
             name=self.data.name or "APC UPS",

homeassistant/components/apcupsd/sensor.py

@@ -458,11 +458,8 @@ class APCUPSdSensor(CoordinatorEntity[APCUPSdCoordinator], SensorEntity):
         """Initialize the sensor."""
         super().__init__(coordinator=coordinator, context=description.key.upper())
 
-        # Set up unique id and device info if serial number is available.
-        if (serial_no := coordinator.data.serial_no) is not None:
-            self._attr_unique_id = f"{serial_no}_{description.key}"
-
         self.entity_description = description
+        self._attr_unique_id = f"{coordinator.unique_device_id}_{description.key}"
         self._attr_device_info = coordinator.device_info
 
         # Initial update of attributes.

homeassistant/components/apple_tv/config_flow.py

@@ -20,6 +20,7 @@ import voluptuous as vol
 from homeassistant.components import zeroconf
 from homeassistant.config_entries import (
     SOURCE_IGNORE,
+    SOURCE_REAUTH,
     SOURCE_ZEROCONF,
     ConfigEntry,
     ConfigFlow,
@@ -381,7 +382,9 @@ class AppleTVConfigFlow(ConfigFlow, domain=DOMAIN):
                         CONF_IDENTIFIERS: list(combined_identifiers),
                     },
                 )
-                if entry.source != SOURCE_IGNORE:
+                # Don't reload ignored entries or in the middle of reauth,
+                # e.g. if the user is entering a new PIN
+                if entry.source != SOURCE_IGNORE and self.source != SOURCE_REAUTH:
                     self.hass.config_entries.async_schedule_reload(entry.entry_id)
             if not allow_exist:
                 raise DeviceAlreadyConfigured

homeassistant/components/aquacell/strings.json

@@ -36,9 +36,9 @@
       "wi_fi_strength": {
         "name": "Wi-Fi strength",
         "state": {
-          "low": "Low",
-          "medium": "Medium",
-          "high": "High"
+          "low": "[%key:common::state::low%]",
+          "medium": "[%key:common::state::medium%]",
+          "high": "[%key:common::state::high%]"
         }
       }
     }

homeassistant/components/assist_satellite/__init__.py

@@ -60,7 +60,8 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
                 {
                     vol.Optional("message"): str,
                     vol.Optional("media_id"): str,
-                    vol.Optional("preannounce_media_id"): vol.Any(str, None),
+                    vol.Optional("preannounce"): bool,
+                    vol.Optional("preannounce_media_id"): str,
                 }
             ),
             cv.has_at_least_one_key("message", "media_id"),
@@ -75,7 +76,8 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
                 {
                     vol.Optional("start_message"): str,
                     vol.Optional("start_media_id"): str,
-                    vol.Optional("preannounce_media_id"): vol.Any(str, None),
+                    vol.Optional("preannounce"): bool,
+                    vol.Optional("preannounce_media_id"): str,
                     vol.Optional("extra_system_prompt"): str,
                 }
             ),

homeassistant/components/assist_satellite/entity.py

@@ -180,7 +180,8 @@ class AssistSatelliteEntity(entity.Entity):
         self,
         message: str | None = None,
         media_id: str | None = None,
-        preannounce_media_id: str | None = PREANNOUNCE_URL,
+        preannounce: bool = True,
+        preannounce_media_id: str = PREANNOUNCE_URL,
     ) -> None:
         """Play and show an announcement on the satellite.
 
@@ -190,8 +191,8 @@ class AssistSatelliteEntity(entity.Entity):
         If media_id is provided, it is played directly. It is possible
         to omit the message and the satellite will not show any text.
 
+        If preannounce is True, a sound is played before the announcement.
         If preannounce_media_id is provided, it overrides the default sound.
-        If preannounce_media_id is None, no sound is played.
 
         Calls async_announce with message and media id.
         """
@@ -201,7 +202,9 @@ class AssistSatelliteEntity(entity.Entity):
             message = ""
 
         announcement = await self._resolve_announcement_media_id(
-            message, media_id, preannounce_media_id
+            message,
+            media_id,
+            preannounce_media_id=preannounce_media_id if preannounce else None,
         )
 
         if self._is_announcing:
@@ -229,7 +232,8 @@ class AssistSatelliteEntity(entity.Entity):
         start_message: str | None = None,
         start_media_id: str | None = None,
         extra_system_prompt: str | None = None,
-        preannounce_media_id: str | None = PREANNOUNCE_URL,
+        preannounce: bool = True,
+        preannounce_media_id: str = PREANNOUNCE_URL,
     ) -> None:
         """Start a conversation from the satellite.
 
@@ -239,8 +243,8 @@ class AssistSatelliteEntity(entity.Entity):
         If start_media_id is provided, it is played directly. It is possible
         to omit the message and the satellite will not show any text.
 
-        If preannounce_media_id is provided, it is played before the announcement.
-        If preannounce_media_id is None, no sound is played.
+        If preannounce is True, a sound is played before the start message or media.
+        If preannounce_media_id is provided, it overrides the default sound.
 
         Calls async_start_conversation.
         """
@@ -257,7 +261,9 @@ class AssistSatelliteEntity(entity.Entity):
             start_message = ""
 
         announcement = await self._resolve_announcement_media_id(
-            start_message, start_media_id, preannounce_media_id
+            start_message,
+            start_media_id,
+            preannounce_media_id=preannounce_media_id if preannounce else None,
         )
 
         if self._is_announcing:

homeassistant/components/assist_satellite/services.yaml

@@ -15,6 +15,11 @@ announce:
       required: false
       selector:
         text:
+    preannounce:
+      required: false
+      default: true
+      selector:
+        boolean:
     preannounce_media_id:
       required: false
       selector:
@@ -40,6 +45,11 @@ start_conversation:
       required: false
       selector:
         text:
+    preannounce:
+      required: false
+      default: true
+      selector:
+        boolean:
     preannounce_media_id:
       required: false
       selector:

homeassistant/components/assist_satellite/strings.json

@@ -24,9 +24,13 @@
           "name": "Media ID",
           "description": "The media ID to announce instead of using text-to-speech."
         },
+        "preannounce": {
+          "name": "Preannounce",
+          "description": "Play a sound before the announcement."
+        },
         "preannounce_media_id": {
-          "name": "Preannounce Media ID",
-          "description": "The media ID to play before the announcement."
+          "name": "Preannounce media ID",
+          "description": "Custom media ID to play before the announcement."
         }
       }
     },
@@ -46,9 +50,13 @@
           "name": "Extra system prompt",
           "description": "Provide background information to the AI about the request."
         },
+        "preannounce": {
+          "name": "Preannounce",
+          "description": "Play a sound before the start message or media."
+        },
         "preannounce_media_id": {
-          "name": "Preannounce Media ID",
-          "description": "The media ID to play before the start message or media."
+          "name": "Preannounce media ID",
+          "description": "Custom media ID to play before the start message or media."
         }
       }
     }

homeassistant/components/assist_satellite/websocket_api.py

@@ -199,7 +199,7 @@ async def websocket_test_connection(
     hass.async_create_background_task(
         satellite.async_internal_announce(
             media_id=f"{CONNECTION_TEST_URL_BASE}/{connection_id}",
-            preannounce_media_id=None,
+            preannounce=False,
         ),
         f"assist_satellite_connection_test_{msg['entity_id']}",
     )

homeassistant/components/azure_storage/backup.py

@@ -175,7 +175,8 @@ class AzureStorageBackupAgent(BackupAgent):
         """Find a blob by backup id."""
         async for blob in self._client.list_blobs(include="metadata"):
             if (
-                backup_id == blob.metadata.get("backup_id", "")
+                blob.metadata is not None
+                and backup_id == blob.metadata.get("backup_id", "")
                 and blob.metadata.get("metadata_version") == METADATA_VERSION
             ):
                 return blob

homeassistant/components/balboa/strings.json

@@ -103,8 +103,8 @@
       "temperature_range": {
         "name": "Temperature range",
         "state": {
-          "low": "Low",
-          "high": "High"
+          "low": "[%key:common::state::low%]",
+          "high": "[%key:common::state::high%]"
         }
       }
     },

homeassistant/components/binary_sensor/strings.json

@@ -124,8 +124,8 @@
     "battery": {
       "name": "Battery",
       "state": {
-        "off": "Normal",
-        "on": "Low"
+        "off": "[%key:common::state::normal%]",
+        "on": "[%key:common::state::low%]"
       }
     },
     "battery_charging": {
@@ -145,7 +145,7 @@
     "cold": {
       "name": "Cold",
       "state": {
-        "off": "[%key:component::binary_sensor::entity_component::battery::state::off%]",
+        "off": "[%key:common::state::normal%]",
         "on": "Cold"
       }
     },
@@ -180,7 +180,7 @@
     "heat": {
       "name": "Heat",
       "state": {
-        "off": "[%key:component::binary_sensor::entity_component::battery::state::off%]",
+        "off": "[%key:common::state::normal%]",
         "on": "Hot"
       }
     },

homeassistant/components/bluesound/media_player.py

@@ -501,18 +501,16 @@ class BluesoundPlayer(CoordinatorEntity[BluesoundCoordinator], MediaPlayerEntity
             return
 
         # presets and inputs might have the same name; presets have priority
-        url: str | None = None
         for input_ in self._inputs:
             if input_.text == source:
-                url = input_.url
+                await self._player.play_url(input_.url)
+                return
         for preset in self._presets:
             if preset.name == source:
-                url = preset.url
+                await self._player.load_preset(preset.id)
+                return
 
-        if url is None:
-            raise ServiceValidationError(f"Source {source} not found")
-
-        await self._player.play_url(url)
+        raise ServiceValidationError(f"Source {source} not found")
 
     async def async_clear_playlist(self) -> None:
         """Clear players playlist."""

homeassistant/components/bluetooth/manifest.json

@@ -19,7 +19,7 @@
     "bleak-retry-connector==3.9.0",
     "bluetooth-adapters==0.21.4",
     "bluetooth-auto-recovery==1.4.5",
-    "bluetooth-data-tools==1.26.1",
+    "bluetooth-data-tools==1.27.0",
     "dbus-fast==2.43.0",
     "habluetooth==3.37.0"
   ]

homeassistant/components/bond/config_flow.py

@@ -16,6 +16,7 @@ from homeassistant.const import CONF_ACCESS_TOKEN, CONF_HOST, CONF_NAME
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.service_info.dhcp import DhcpServiceInfo
 from homeassistant.helpers.service_info.zeroconf import ZeroconfServiceInfo
 
 from .const import DOMAIN
@@ -91,11 +92,22 @@ class BondConfigFlow(ConfigFlow, domain=DOMAIN):
 
         self._discovered[CONF_ACCESS_TOKEN] = token
         try:
-            _, hub_name = await _validate_input(self.hass, self._discovered)
+            bond_id, hub_name = await _validate_input(self.hass, self._discovered)
         except InputValidationError:
             return
+        await self.async_set_unique_id(bond_id)
+        self._abort_if_unique_id_configured(updates={CONF_HOST: host})
         self._discovered[CONF_NAME] = hub_name
 
+    async def async_step_dhcp(
+        self, discovery_info: DhcpServiceInfo
+    ) -> ConfigFlowResult:
+        """Handle a flow initialized by dhcp discovery."""
+        host = discovery_info.ip
+        bond_id = discovery_info.hostname.partition("-")[2].upper()
+        await self.async_set_unique_id(bond_id)
+        return await self.async_step_any_discovery(bond_id, host)
+
     async def async_step_zeroconf(
         self, discovery_info: ZeroconfServiceInfo
     ) -> ConfigFlowResult:
@@ -104,11 +116,17 @@ class BondConfigFlow(ConfigFlow, domain=DOMAIN):
         host: str = discovery_info.host
         bond_id = name.partition(".")[0]
         await self.async_set_unique_id(bond_id)
+        return await self.async_step_any_discovery(bond_id, host)
+
+    async def async_step_any_discovery(
+        self, bond_id: str, host: str
+    ) -> ConfigFlowResult:
+        """Handle a flow initialized by discovery."""
         for entry in self._async_current_entries():
             if entry.unique_id != bond_id:
                 continue
             updates = {CONF_HOST: host}
-            if entry.state == ConfigEntryState.SETUP_ERROR and (
+            if entry.state is ConfigEntryState.SETUP_ERROR and (
                 token := await async_get_token(self.hass, host)
             ):
                 updates[CONF_ACCESS_TOKEN] = token
@@ -153,10 +171,14 @@ class BondConfigFlow(ConfigFlow, domain=DOMAIN):
                 CONF_HOST: self._discovered[CONF_HOST],
             }
             try:
-                _, hub_name = await _validate_input(self.hass, data)
+                bond_id, hub_name = await _validate_input(self.hass, data)
             except InputValidationError as error:
                 errors["base"] = error.base
             else:
+                await self.async_set_unique_id(bond_id)
+                self._abort_if_unique_id_configured(
+                    updates={CONF_HOST: self._discovered[CONF_HOST]}
+                )
                 return self.async_create_entry(
                     title=hub_name,
                     data=data,
@@ -185,8 +207,10 @@ class BondConfigFlow(ConfigFlow, domain=DOMAIN):
             except InputValidationError as error:
                 errors["base"] = error.base
             else:
-                await self.async_set_unique_id(bond_id)
-                self._abort_if_unique_id_configured()
+                await self.async_set_unique_id(bond_id, raise_on_progress=False)
+                self._abort_if_unique_id_configured(
+                    updates={CONF_HOST: user_input[CONF_HOST]}
+                )
                 return self.async_create_entry(title=hub_name, data=user_input)
 
         return self.async_show_form(

homeassistant/components/bond/manifest.json

@@ -3,6 +3,16 @@
   "name": "Bond",
   "codeowners": ["@bdraco", "@prystupa", "@joshs85", "@marciogranzotto"],
   "config_flow": true,
+  "dhcp": [
+    {
+      "hostname": "bond-*",
+      "macaddress": "3C6A2C1*"
+    },
+    {
+      "hostname": "bond-*",
+      "macaddress": "F44E38*"
+    }
+  ],
   "documentation": "https://www.home-assistant.io/integrations/bond",
   "iot_class": "local_push",
   "loggers": ["bond_async"],

homeassistant/components/bosch_alarm/__init__.py

@@ -9,12 +9,12 @@ from bosch_alarm_mode2 import Panel
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_PORT, Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryNotReady
+from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import device_registry as dr
 
 from .const import CONF_INSTALLER_CODE, CONF_USER_CODE, DOMAIN
 
-PLATFORMS: list[Platform] = [Platform.ALARM_CONTROL_PANEL]
+PLATFORMS: list[Platform] = [Platform.ALARM_CONTROL_PANEL, Platform.SENSOR]
 
 type BoschAlarmConfigEntry = ConfigEntry[Panel]
 
@@ -34,10 +34,15 @@ async def async_setup_entry(hass: HomeAssistant, entry: BoschAlarmConfigEntry) -
         await panel.connect()
     except (PermissionError, ValueError) as err:
         await panel.disconnect()
-        raise ConfigEntryNotReady from err
+        raise ConfigEntryAuthFailed(
+            translation_domain=DOMAIN, translation_key="authentication_failed"
+        ) from err
     except (TimeoutError, OSError, ConnectionRefusedError, SSLError) as err:
         await panel.disconnect()
-        raise ConfigEntryNotReady("Connection failed") from err
+        raise ConfigEntryNotReady(
+            translation_domain=DOMAIN,
+            translation_key="cannot_connect",
+        ) from err
 
     entry.runtime_data = panel
 

homeassistant/components/bosch_alarm/alarm_control_panel.py

@@ -10,11 +10,10 @@ from homeassistant.components.alarm_control_panel import (
     AlarmControlPanelState,
 )
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import BoschAlarmConfigEntry
-from .const import DOMAIN
+from .entity import BoschAlarmAreaEntity
 
 
 async def async_setup_entry(
@@ -35,7 +34,7 @@ async def async_setup_entry(
     )
 
 
-class AreaAlarmControlPanel(AlarmControlPanelEntity):
+class AreaAlarmControlPanel(BoschAlarmAreaEntity, AlarmControlPanelEntity):
     """An alarm control panel entity for a bosch alarm panel."""
 
     _attr_has_entity_name = True
@@ -48,19 +47,8 @@ class AreaAlarmControlPanel(AlarmControlPanelEntity):
 
     def __init__(self, panel: Panel, area_id: int, unique_id: str) -> None:
         """Initialise a Bosch Alarm control panel entity."""
-        self.panel = panel
-        self._area = panel.areas[area_id]
-        self._area_id = area_id
-        self._attr_unique_id = f"{unique_id}_area_{area_id}"
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, self._attr_unique_id)},
-            name=self._area.name,
-            manufacturer="Bosch Security Systems",
-            via_device=(
-                DOMAIN,
-                unique_id,
-            ),
-        )
+        super().__init__(panel, area_id, unique_id, False, False, True)
+        self._attr_unique_id = self._area_unique_id
 
     @property
     def alarm_state(self) -> AlarmControlPanelState | None:
@@ -90,20 +78,3 @@ class AreaAlarmControlPanel(AlarmControlPanelEntity):
     async def async_alarm_arm_away(self, code: str | None = None) -> None:
         """Send arm away command."""
         await self.panel.area_arm_all(self._area_id)
-
-    @property
-    def available(self) -> bool:
-        """Return True if entity is available."""
-        return self.panel.connection_status()
-
-    async def async_added_to_hass(self) -> None:
-        """Run when entity attached to hass."""
-        await super().async_added_to_hass()
-        self._area.status_observer.attach(self.schedule_update_ha_state)
-        self.panel.connection_status_observer.attach(self.schedule_update_ha_state)
-
-    async def async_will_remove_from_hass(self) -> None:
-        """Run when entity removed from hass."""
-        await super().async_will_remove_from_hass()
-        self._area.status_observer.detach(self.schedule_update_ha_state)
-        self.panel.connection_status_observer.detach(self.schedule_update_ha_state)

homeassistant/components/bosch_alarm/config_flow.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+from collections.abc import Mapping
 import logging
 import ssl
 from typing import Any
@@ -10,7 +11,12 @@ from typing import Any
 from bosch_alarm_mode2 import Panel
 import voluptuous as vol
 
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.config_entries import (
+    SOURCE_RECONFIGURE,
+    SOURCE_USER,
+    ConfigFlow,
+    ConfigFlowResult,
+)
 from homeassistant.const import (
     CONF_CODE,
     CONF_HOST,
@@ -107,6 +113,13 @@ class BoschAlarmConfigFlow(ConfigFlow, domain=DOMAIN):
             else:
                 self._data = user_input
                 self._data[CONF_MODEL] = model
+
+                if self.source == SOURCE_RECONFIGURE:
+                    if (
+                        self._get_reconfigure_entry().data[CONF_MODEL]
+                        != self._data[CONF_MODEL]
+                    ):
+                        return self.async_abort(reason="device_mismatch")
                 return await self.async_step_auth()
         return self.async_show_form(
             step_id="user",
@@ -116,6 +129,12 @@ class BoschAlarmConfigFlow(ConfigFlow, domain=DOMAIN):
             errors=errors,
         )
 
+    async def async_step_reconfigure(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the reconfigure step."""
+        return await self.async_step_user()
+
     async def async_step_auth(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
@@ -153,13 +172,77 @@ class BoschAlarmConfigFlow(ConfigFlow, domain=DOMAIN):
             else:
                 if serial_number:
                     await self.async_set_unique_id(str(serial_number))
-                    self._abort_if_unique_id_configured()
-                else:
-                    self._async_abort_entries_match({CONF_HOST: self._data[CONF_HOST]})
-                return self.async_create_entry(title=f"Bosch {model}", data=self._data)
+                if self.source == SOURCE_USER:
+                    if serial_number:
+                        self._abort_if_unique_id_configured()
+                    else:
+                        self._async_abort_entries_match(
+                            {CONF_HOST: self._data[CONF_HOST]}
+                        )
+                    return self.async_create_entry(
+                        title=f"Bosch {model}", data=self._data
+                    )
+                if serial_number:
+                    self._abort_if_unique_id_mismatch(reason="device_mismatch")
+                return self.async_update_reload_and_abort(
+                    self._get_reconfigure_entry(),
+                    data=self._data,
+                )
 
         return self.async_show_form(
             step_id="auth",
             data_schema=self.add_suggested_values_to_schema(schema, user_input),
             errors=errors,
         )
+
+    async def async_step_reauth(
+        self, entry_data: Mapping[str, Any]
+    ) -> ConfigFlowResult:
+        """Perform reauth upon an authentication error."""
+        self._data = dict(entry_data)
+        return await self.async_step_reauth_confirm()
+
+    async def async_step_reauth_confirm(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the reauth step."""
+        errors: dict[str, str] = {}
+
+        # Each model variant requires a different authentication flow
+        if "Solution" in self._data[CONF_MODEL]:
+            schema = STEP_AUTH_DATA_SCHEMA_SOLUTION
+        elif "AMAX" in self._data[CONF_MODEL]:
+            schema = STEP_AUTH_DATA_SCHEMA_AMAX
+        else:
+            schema = STEP_AUTH_DATA_SCHEMA_BG
+
+        if user_input is not None:
+            reauth_entry = self._get_reauth_entry()
+            self._data.update(user_input)
+            try:
+                (_, _) = await try_connect(self._data, Panel.LOAD_EXTENDED_INFO)
+            except (PermissionError, ValueError) as e:
+                errors["base"] = "invalid_auth"
+                _LOGGER.error("Authentication Error: %s", e)
+            except (
+                OSError,
+                ConnectionRefusedError,
+                ssl.SSLError,
+                TimeoutError,
+            ) as e:
+                _LOGGER.error("Connection Error: %s", e)
+                errors["base"] = "cannot_connect"
+            except Exception:
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
+            else:
+                return self.async_update_reload_and_abort(
+                    reauth_entry,
+                    data_updates=user_input,
+                )
+
+        return self.async_show_form(
+            step_id="reauth_confirm",
+            data_schema=self.add_suggested_values_to_schema(schema, user_input),
+            errors=errors,
+        )

homeassistant/components/bosch_alarm/diagnostics.py

@@ -0,0 +1,73 @@
+"""Diagnostics for bosch alarm."""
+
+from typing import Any
+
+from homeassistant.components.diagnostics import async_redact_data
+from homeassistant.const import CONF_PASSWORD
+from homeassistant.core import HomeAssistant
+
+from . import BoschAlarmConfigEntry
+from .const import CONF_INSTALLER_CODE, CONF_USER_CODE
+
+TO_REDACT = [CONF_INSTALLER_CODE, CONF_USER_CODE, CONF_PASSWORD]
+
+
+async def async_get_config_entry_diagnostics(
+    hass: HomeAssistant, entry: BoschAlarmConfigEntry
+) -> dict[str, Any]:
+    """Return diagnostics for a config entry."""
+
+    return {
+        "entry_data": async_redact_data(entry.data, TO_REDACT),
+        "data": {
+            "model": entry.runtime_data.model,
+            "serial_number": entry.runtime_data.serial_number,
+            "protocol_version": entry.runtime_data.protocol_version,
+            "firmware_version": entry.runtime_data.firmware_version,
+            "areas": [
+                {
+                    "id": area_id,
+                    "name": area.name,
+                    "all_ready": area.all_ready,
+                    "part_ready": area.part_ready,
+                    "faults": area.faults,
+                    "alarms": area.alarms,
+                    "disarmed": area.is_disarmed(),
+                    "arming": area.is_arming(),
+                    "pending": area.is_pending(),
+                    "part_armed": area.is_part_armed(),
+                    "all_armed": area.is_all_armed(),
+                    "armed": area.is_armed(),
+                    "triggered": area.is_triggered(),
+                }
+                for area_id, area in entry.runtime_data.areas.items()
+            ],
+            "points": [
+                {
+                    "id": point_id,
+                    "name": point.name,
+                    "open": point.is_open(),
+                    "normal": point.is_normal(),
+                }
+                for point_id, point in entry.runtime_data.points.items()
+            ],
+            "doors": [
+                {
+                    "id": door_id,
+                    "name": door.name,
+                    "open": door.is_open(),
+                    "locked": door.is_locked(),
+                }
+                for door_id, door in entry.runtime_data.doors.items()
+            ],
+            "outputs": [
+                {
+                    "id": output_id,
+                    "name": output.name,
+                    "active": output.is_active(),
+                }
+                for output_id, output in entry.runtime_data.outputs.items()
+            ],
+            "history_events": entry.runtime_data.events,
+        },
+    }

homeassistant/components/bosch_alarm/entity.py

@@ -0,0 +1,88 @@
+"""Support for Bosch Alarm Panel History as a sensor."""
+
+from __future__ import annotations
+
+from bosch_alarm_mode2 import Panel
+
+from homeassistant.components.sensor import Entity
+from homeassistant.helpers.device_registry import DeviceInfo
+
+from .const import DOMAIN
+
+PARALLEL_UPDATES = 0
+
+
+class BoschAlarmEntity(Entity):
+    """A base entity for a bosch alarm panel."""
+
+    _attr_has_entity_name = True
+
+    def __init__(self, panel: Panel, unique_id: str) -> None:
+        """Set up a entity for a bosch alarm panel."""
+        self.panel = panel
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, unique_id)},
+            name=f"Bosch {panel.model}",
+            manufacturer="Bosch Security Systems",
+        )
+
+    @property
+    def available(self) -> bool:
+        """Return True if entity is available."""
+        return self.panel.connection_status()
+
+    async def async_added_to_hass(self) -> None:
+        """Observe state changes."""
+        self.panel.connection_status_observer.attach(self.schedule_update_ha_state)
+
+    async def async_will_remove_from_hass(self) -> None:
+        """Stop observing state changes."""
+        self.panel.connection_status_observer.detach(self.schedule_update_ha_state)
+
+
+class BoschAlarmAreaEntity(BoschAlarmEntity):
+    """A base entity for area related entities within a bosch alarm panel."""
+
+    def __init__(
+        self,
+        panel: Panel,
+        area_id: int,
+        unique_id: str,
+        observe_alarms: bool,
+        observe_ready: bool,
+        observe_status: bool,
+    ) -> None:
+        """Set up a area related entity for a bosch alarm panel."""
+        super().__init__(panel, unique_id)
+        self._area_id = area_id
+        self._area_unique_id = f"{unique_id}_area_{area_id}"
+        self._observe_alarms = observe_alarms
+        self._observe_ready = observe_ready
+        self._observe_status = observe_status
+        self._area = panel.areas[area_id]
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, self._area_unique_id)},
+            name=self._area.name,
+            manufacturer="Bosch Security Systems",
+            via_device=(DOMAIN, unique_id),
+        )
+
+    async def async_added_to_hass(self) -> None:
+        """Observe state changes."""
+        await super().async_added_to_hass()
+        if self._observe_alarms:
+            self._area.alarm_observer.attach(self.schedule_update_ha_state)
+        if self._observe_ready:
+            self._area.ready_observer.attach(self.schedule_update_ha_state)
+        if self._observe_status:
+            self._area.status_observer.attach(self.schedule_update_ha_state)
+
+    async def async_will_remove_from_hass(self) -> None:
+        """Stop observing state changes."""
+        await super().async_added_to_hass()
+        if self._observe_alarms:
+            self._area.alarm_observer.detach(self.schedule_update_ha_state)
+        if self._observe_ready:
+            self._area.ready_observer.detach(self.schedule_update_ha_state)
+        if self._observe_status:
+            self._area.status_observer.detach(self.schedule_update_ha_state)

homeassistant/components/bosch_alarm/icons.json

@@ -0,0 +1,9 @@
+{
+  "entity": {
+    "sensor": {
+      "faulting_points": {
+        "default": "mdi:alert-circle-outline"
+      }
+    }
+  }
+}

homeassistant/components/bosch_alarm/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "quality_scale": "bronze",
-  "requirements": ["bosch-alarm-mode2==0.4.3"]
+  "requirements": ["bosch-alarm-mode2==0.4.6"]
 }

homeassistant/components/bosch_alarm/quality_scale.yaml

@@ -40,7 +40,7 @@ rules:
   integration-owner: done
   log-when-unavailable: todo
   parallel-updates: todo
-  reauthentication-flow: todo
+  reauthentication-flow: done
   test-coverage: done
 
   # Gold
@@ -62,9 +62,9 @@ rules:
   entity-category: todo
   entity-device-class: todo
   entity-disabled-by-default: todo
-  entity-translations: todo
+  entity-translations: done
   exception-translations: todo
-  icon-translations: todo
+  icon-translations: done
   reconfiguration-flow: todo
   repair-issues:
     status: exempt

homeassistant/components/bosch_alarm/sensor.py

@@ -0,0 +1,86 @@
+"""Support for Bosch Alarm Panel History as a sensor."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from bosch_alarm_mode2 import Panel
+from bosch_alarm_mode2.panel import Area
+
+from homeassistant.components.sensor import SensorEntity, SensorEntityDescription
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import BoschAlarmConfigEntry
+from .entity import BoschAlarmAreaEntity
+
+
+@dataclass(kw_only=True, frozen=True)
+class BoschAlarmSensorEntityDescription(SensorEntityDescription):
+    """Describes Bosch Alarm sensor entity."""
+
+    value_fn: Callable[[Area], int]
+    observe_alarms: bool = False
+    observe_ready: bool = False
+    observe_status: bool = False
+
+
+SENSOR_TYPES: list[BoschAlarmSensorEntityDescription] = [
+    BoschAlarmSensorEntityDescription(
+        key="faulting_points",
+        translation_key="faulting_points",
+        value_fn=lambda area: area.faults,
+        observe_ready=True,
+    ),
+]
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: BoschAlarmConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up bosch alarm sensors."""
+
+    panel = config_entry.runtime_data
+    unique_id = config_entry.unique_id or config_entry.entry_id
+
+    async_add_entities(
+        BoschAreaSensor(panel, area_id, unique_id, template)
+        for area_id in panel.areas
+        for template in SENSOR_TYPES
+    )
+
+
+PARALLEL_UPDATES = 0
+
+
+class BoschAreaSensor(BoschAlarmAreaEntity, SensorEntity):
+    """An area sensor entity for a bosch alarm panel."""
+
+    entity_description: BoschAlarmSensorEntityDescription
+
+    def __init__(
+        self,
+        panel: Panel,
+        area_id: int,
+        unique_id: str,
+        entity_description: BoschAlarmSensorEntityDescription,
+    ) -> None:
+        """Set up an area sensor entity for a bosch alarm panel."""
+        super().__init__(
+            panel,
+            area_id,
+            unique_id,
+            entity_description.observe_alarms,
+            entity_description.observe_ready,
+            entity_description.observe_status,
+        )
+        self.entity_description = entity_description
+        self._attr_unique_id = f"{self._area_unique_id}_{entity_description.key}"
+
+    @property
+    def native_value(self) -> int:
+        """Return the state of the sensor."""
+        return self.entity_description.value_fn(self._area)

homeassistant/components/bosch_alarm/strings.json

@@ -22,6 +22,18 @@
           "installer_code": "The installer code from your panel",
           "user_code": "The user code from your panel"
         }
+      },
+      "reauth_confirm": {
+        "data": {
+          "password": "[%key:common::config_flow::data::password%]",
+          "installer_code": "[%key:component::bosch_alarm::config::step::auth::data::installer_code%]",
+          "user_code": "[%key:component::bosch_alarm::config::step::auth::data::user_code%]"
+        },
+        "data_description": {
+          "password": "[%key:component::bosch_alarm::config::step::auth::data_description::password%]",
+          "installer_code": "[%key:component::bosch_alarm::config::step::auth::data_description::installer_code%]",
+          "user_code": "[%key:component::bosch_alarm::config::step::auth::data_description::user_code%]"
+        }
       }
     },
     "error": {
@@ -30,7 +42,26 @@
       "unknown": "[%key:common::config_flow::error::unknown%]"
     },
     "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
+      "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%]",
+      "device_mismatch": "Please ensure you reconfigure against the same device."
+    }
+  },
+  "exceptions": {
+    "cannot_connect": {
+      "message": "Could not connect to panel."
+    },
+    "authentication_failed": {
+      "message": "Incorrect credentials for panel."
+    }
+  },
+  "entity": {
+    "sensor": {
+      "faulting_points": {
+        "name": "Faulting points",
+        "unit_of_measurement": "points"
+      }
     }
   }
 }

homeassistant/components/bring/strings.json

@@ -13,7 +13,7 @@
         },
         "data_description": {
           "email": "The email address associated with your Bring! account.",
-          "password": "The password to login to your Bring! account."
+          "password": "The password to log in to your Bring! account."
         }
       },
       "reauth_confirm": {

homeassistant/components/calendar/strings.json

@@ -74,7 +74,7 @@
     },
     "get_events": {
       "name": "Get events",
-      "description": "Get events on a calendar within a time range.",
+      "description": "Retrieves events on a calendar within a time range.",
       "fields": {
         "start_date_time": {
           "name": "Start time",

homeassistant/components/camera/img_util.py

@@ -2,17 +2,10 @@
 
 from __future__ import annotations
 
-from contextlib import suppress
 import logging
 from typing import TYPE_CHECKING, Literal, cast
 
-with suppress(Exception):
-    # TurboJPEG imports numpy which may or may not work so
-    # we have to guard the import here. We still want
-    # to import it at top level so it gets loaded
-    # in the import executor and not in the event loop.
-    from turbojpeg import TurboJPEG
-
+from turbojpeg import TurboJPEG
 
 if TYPE_CHECKING:
     from . import Image

homeassistant/components/climate/strings.json

@@ -98,13 +98,13 @@
           "name": "Preset",
           "state": {
             "none": "None",
-            "eco": "Eco",
-            "away": "Away",
+            "home": "[%key:common::state::home%]",
+            "away": "[%key:common::state::not_home%]",
+            "activity": "Activity",
             "boost": "Boost",
             "comfort": "Comfort",
-            "home": "[%key:common::state::home%]",
-            "sleep": "Sleep",
-            "activity": "Activity"
+            "eco": "Eco",
+            "sleep": "Sleep"
           }
         },
         "preset_modes": {
@@ -257,7 +257,7 @@
   "selector": {
     "hvac_mode": {
       "options": {
-        "off": "Off",
+        "off": "[%key:common::state::off%]",
         "auto": "Auto",
         "cool": "Cool",
         "dry": "Dry",

homeassistant/components/cloud/account_link.py

@@ -127,7 +127,11 @@ class CloudOAuth2Implementation(config_entry_oauth2_flow.AbstractOAuth2Implement
                     flow_id=flow_id, user_input=tokens
                 )
 
-        self.hass.async_create_task(await_tokens())
+        # It's a background task because it should be cancelled on shutdown and there's nothing else
+        # we can do in such case. There's also no need to wait for this during setup.
+        self.hass.async_create_background_task(
+            await_tokens(), name="Awaiting OAuth tokens"
+        )
 
         return authorize_url
 

homeassistant/components/comelit/humidifier.py

@@ -162,7 +162,7 @@ class ComelitHumidifierEntity(CoordinatorEntity[ComelitSerialBridge], Humidifier
 
     async def async_set_humidity(self, humidity: int) -> None:
         """Set new target humidity."""
-        if self.mode == HumidifierComelitMode.OFF:
+        if not self._attr_is_on:
             raise ServiceValidationError(
                 translation_domain=DOMAIN,
                 translation_key="humidity_while_off",
@@ -190,9 +190,13 @@ class ComelitHumidifierEntity(CoordinatorEntity[ComelitSerialBridge], Humidifier
         await self.coordinator.api.set_humidity_status(
             self._device.index, self._set_command
         )
+        self._attr_is_on = True
+        self.async_write_ha_state()
 
     async def async_turn_off(self, **kwargs: Any) -> None:
         """Turn off."""
         await self.coordinator.api.set_humidity_status(
             self._device.index, HumidifierComelitCommand.OFF
         )
+        self._attr_is_on = False
+        self.async_write_ha_state()

homeassistant/components/comelit/strings.json

@@ -42,9 +42,9 @@
     "sensor": {
       "zone_status": {
         "state": {
+          "open": "[%key:common::state::open%]",
           "alarm": "Alarm",
           "armed": "Armed",
-          "open": "Open",
           "excluded": "Excluded",
           "faulty": "Faulty",
           "inhibited": "Inhibited",
@@ -52,7 +52,9 @@
           "rest": "Rest",
           "sabotated": "Sabotated"
         }
-      },
+      }
+    },
+    "humidifier": {
       "humidifier": {
         "name": "Humidifier"
       },

homeassistant/components/config/config_entries.py

@@ -58,7 +58,8 @@ def async_setup(hass: HomeAssistant) -> bool:
     websocket_api.async_register_command(hass, config_entry_get_single)
     websocket_api.async_register_command(hass, config_entry_update)
     websocket_api.async_register_command(hass, config_entries_subscribe)
-    websocket_api.async_register_command(hass, config_entries_progress)
+    websocket_api.async_register_command(hass, config_entries_flow_progress)
+    websocket_api.async_register_command(hass, config_entries_flow_subscribe)
     websocket_api.async_register_command(hass, ignore_config_flow)
 
     websocket_api.async_register_command(hass, config_subentry_delete)
@@ -357,7 +358,7 @@ class SubentryManagerFlowResourceView(
 
 @websocket_api.require_admin
 @websocket_api.websocket_command({"type": "config_entries/flow/progress"})
-def config_entries_progress(
+def config_entries_flow_progress(
     hass: HomeAssistant,
     connection: websocket_api.ActiveConnection,
     msg: dict[str, Any],
@@ -378,6 +379,66 @@ def config_entries_progress(
     )
 
 
+@websocket_api.require_admin
+@websocket_api.websocket_command({"type": "config_entries/flow/subscribe"})
+def config_entries_flow_subscribe(
+    hass: HomeAssistant,
+    connection: websocket_api.ActiveConnection,
+    msg: dict[str, Any],
+) -> None:
+    """Subscribe to non user created flows being initiated or removed.
+
+    When initiating the subscription, the current flows are sent to the client.
+
+    Example of a non-user initiated flow is a discovered Hue hub that
+    requires user interaction to finish setup.
+    """
+
+    @callback
+    def async_on_flow_init_remove(change_type: str, flow_id: str) -> None:
+        """Forward config entry state events to websocket."""
+        if change_type == "removed":
+            connection.send_message(
+                websocket_api.event_message(
+                    msg["id"],
+                    [{"type": change_type, "flow_id": flow_id}],
+                )
+            )
+            return
+        # change_type == "added"
+        connection.send_message(
+            websocket_api.event_message(
+                msg["id"],
+                [
+                    {
+                        "type": change_type,
+                        "flow_id": flow_id,
+                        "flow": hass.config_entries.flow.async_get(flow_id),
+                    }
+                ],
+            )
+        )
+
+    connection.subscriptions[msg["id"]] = hass.config_entries.flow.async_subscribe_flow(
+        async_on_flow_init_remove
+    )
+    connection.send_message(
+        websocket_api.event_message(
+            msg["id"],
+            [
+                {"type": None, "flow_id": flw["flow_id"], "flow": flw}
+                for flw in hass.config_entries.flow.async_progress()
+                if flw["context"]["source"]
+                not in (
+                    config_entries.SOURCE_RECONFIGURE,
+                    config_entries.SOURCE_USER,
+                )
+            ],
+        )
+    )
+    connection.send_result(msg["id"])
+
+
 def send_entry_not_found(
     connection: websocket_api.ActiveConnection, msg_id: int
 ) -> None:

homeassistant/components/conversation/chat_log.py

@@ -354,6 +354,35 @@ class ChatLog:
                 if self.delta_listener:
                     self.delta_listener(self, asdict(tool_result))
 
+    async def _async_expand_prompt_template(
+        self,
+        llm_context: llm.LLMContext,
+        prompt: str,
+        language: str,
+        user_name: str | None = None,
+    ) -> str:
+        try:
+            return template.Template(prompt, self.hass).async_render(
+                {
+                    "ha_name": self.hass.config.location_name,
+                    "user_name": user_name,
+                    "llm_context": llm_context,
+                },
+                parse_result=False,
+            )
+        except TemplateError as err:
+            LOGGER.error("Error rendering prompt: %s", err)
+            intent_response = intent.IntentResponse(language=language)
+            intent_response.async_set_error(
+                intent.IntentResponseErrorCode.UNKNOWN,
+                "Sorry, I had a problem with my template",
+            )
+            raise ConverseError(
+                "Error rendering prompt",
+                conversation_id=self.conversation_id,
+                response=intent_response,
+            ) from err
+
     async def async_update_llm_data(
         self,
         conversing_domain: str,
@@ -409,38 +438,28 @@ class ChatLog:
         ):
             user_name = user.name
 
-        try:
-            prompt_parts = [
-                template.Template(
-                    llm.BASE_PROMPT
-                    + (user_llm_prompt or llm.DEFAULT_INSTRUCTIONS_PROMPT),
-                    self.hass,
-                ).async_render(
-                    {
-                        "ha_name": self.hass.config.location_name,
-                        "user_name": user_name,
-                        "llm_context": llm_context,
-                    },
-                    parse_result=False,
-                )
-            ]
-
-        except TemplateError as err:
-            LOGGER.error("Error rendering prompt: %s", err)
-            intent_response = intent.IntentResponse(language=user_input.language)
-            intent_response.async_set_error(
-                intent.IntentResponseErrorCode.UNKNOWN,
-                "Sorry, I had a problem with my template",
+        prompt_parts = []
+        prompt_parts.append(
+            await self._async_expand_prompt_template(
+                llm_context,
+                (user_llm_prompt or llm.DEFAULT_INSTRUCTIONS_PROMPT),
+                user_input.language,
+                user_name,
             )
-            raise ConverseError(
-                "Error rendering prompt",
-                conversation_id=self.conversation_id,
-                response=intent_response,
-            ) from err
+        )
 
         if llm_api:
             prompt_parts.append(llm_api.api_prompt)
 
+        prompt_parts.append(
+            await self._async_expand_prompt_template(
+                llm_context,
+                llm.BASE_PROMPT,
+                user_input.language,
+                user_name,
+            )
+        )
+
         if extra_system_prompt := (
             # Take new system prompt if one was given
             user_input.extra_system_prompt or self.extra_system_prompt

homeassistant/components/daikin/__init__.py

@@ -21,6 +21,7 @@ from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers import device_registry as dr, entity_registry as er
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC
+from homeassistant.util.ssl import client_context_no_verify
 
 from .const import KEY_MAC, TIMEOUT
 from .coordinator import DaikinConfigEntry, DaikinCoordinator
@@ -48,6 +49,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: DaikinConfigEntry) -> bo
                 key=entry.data.get(CONF_API_KEY),
                 uuid=entry.data.get(CONF_UUID),
                 password=entry.data.get(CONF_PASSWORD),
+                ssl_context=client_context_no_verify(),
             )
         _LOGGER.debug("Connection to %s successful", host)
     except TimeoutError as err:

homeassistant/components/daikin/config_flow.py

@@ -18,6 +18,7 @@ from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
 from homeassistant.const import CONF_API_KEY, CONF_HOST, CONF_PASSWORD, CONF_UUID
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.service_info.zeroconf import ZeroconfServiceInfo
+from homeassistant.util.ssl import client_context_no_verify
 
 from .const import DOMAIN, KEY_MAC, TIMEOUT
 
@@ -90,6 +91,7 @@ class FlowHandler(ConfigFlow, domain=DOMAIN):
                     key=key,
                     uuid=uuid,
                     password=password,
+                    ssl_context=client_context_no_verify(),
                 )
         except (TimeoutError, ClientError):
             self.host = None

homeassistant/components/daikin/manifest.json

@@ -6,6 +6,6 @@
   "documentation": "https://www.home-assistant.io/integrations/daikin",
   "iot_class": "local_polling",
   "loggers": ["pydaikin"],
-  "requirements": ["pydaikin==2.14.1"],
+  "requirements": ["pydaikin==2.15.0"],
   "zeroconf": ["_dkapi._tcp.local."]
 }

homeassistant/components/deluge/strings.json

@@ -2,7 +2,7 @@
   "config": {
     "step": {
       "user": {
-        "description": "To be able to use this integration, you have to enable the following option in deluge settings: Daemon > Allow remote controls",
+        "description": "To be able to use this integration, you have to enable the following option in Deluge settings: Daemon > Allow remote controls",
         "data": {
           "host": "[%key:common::config_flow::data::host%]",
           "username": "[%key:common::config_flow::data::username%]",

homeassistant/components/dlna_dmr/manifest.json

@@ -8,7 +8,7 @@
   "documentation": "https://www.home-assistant.io/integrations/dlna_dmr",
   "iot_class": "local_push",
   "loggers": ["async_upnp_client"],
-  "requirements": ["async-upnp-client==0.43.0", "getmac==0.9.5"],
+  "requirements": ["async-upnp-client==0.44.0", "getmac==0.9.5"],
   "ssdp": [
     {
       "deviceType": "urn:schemas-upnp-org:device:MediaRenderer:1",

homeassistant/components/dlna_dms/manifest.json

@@ -7,7 +7,7 @@
   "dependencies": ["ssdp"],
   "documentation": "https://www.home-assistant.io/integrations/dlna_dms",
   "iot_class": "local_polling",
-  "requirements": ["async-upnp-client==0.43.0"],
+  "requirements": ["async-upnp-client==0.44.0"],
   "ssdp": [
     {
       "deviceType": "urn:schemas-upnp-org:device:MediaServer:1",

homeassistant/components/drop_connect/strings.json

@@ -38,8 +38,8 @@
       "protect_mode": {
         "name": "Protect mode",
         "state": {
-          "away": "Away",
-          "home": "Home",
+          "away": "[%key:common::state::not_home%]",
+          "home": "[%key:common::state::home%]",
           "schedule": "Schedule"
         }
       }

homeassistant/components/dsmr/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "local_push",
   "loggers": ["dsmr_parser"],
-  "requirements": ["dsmr-parser==1.4.2"]
+  "requirements": ["dsmr-parser==1.4.3"]
 }

homeassistant/components/dsmr/strings.json

@@ -51,8 +51,8 @@
       "electricity_active_tariff": {
         "name": "Active tariff",
         "state": {
-          "low": "Low",
-          "normal": "Normal"
+          "low": "[%key:common::state::low%]",
+          "normal": "[%key:common::state::normal%]"
         }
       },
       "electricity_delivered_tariff_1": {

homeassistant/components/dsmr_reader/strings.json

@@ -140,8 +140,8 @@
       "electricity_tariff": {
         "name": "Electricity tariff",
         "state": {
-          "low": "Low",
-          "high": "High"
+          "low": "[%key:common::state::low%]",
+          "high": "[%key:common::state::high%]"
         }
       },
       "power_failure_count": {

homeassistant/components/ecobee/strings.json

@@ -55,7 +55,7 @@
       "fields": {
         "entity_id": {
           "name": "Entity",
-          "description": "Ecobee thermostat on which to create the vacation."
+          "description": "ecobee thermostat on which to create the vacation."
         },
         "vacation_name": {
           "name": "Vacation name",
@@ -101,7 +101,7 @@
       "fields": {
         "entity_id": {
           "name": "Entity",
-          "description": "Ecobee thermostat on which to delete the vacation."
+          "description": "ecobee thermostat on which to delete the vacation."
         },
         "vacation_name": {
           "name": "[%key:component::ecobee::services::create_vacation::fields::vacation_name::name%]",
@@ -149,7 +149,7 @@
     },
     "set_mic_mode": {
       "name": "Set mic mode",
-      "description": "Enables/disables Alexa microphone (only for Ecobee 4).",
+      "description": "Enables/disables Alexa microphone (only for ecobee 4).",
       "fields": {
         "mic_enabled": {
           "name": "Mic enabled",
@@ -177,7 +177,7 @@
       "fields": {
         "entity_id": {
           "name": "Entity",
-          "description": "Ecobee thermostat on which to set active sensors."
+          "description": "ecobee thermostat on which to set active sensors."
         },
         "preset_mode": {
           "name": "Climate Name",
@@ -203,12 +203,12 @@
   },
   "issues": {
     "migrate_aux_heat": {
-      "title": "Migration of Ecobee set_aux_heat action",
+      "title": "Migration of ecobee set_aux_heat action",
       "fix_flow": {
         "step": {
           "confirm": {
-            "description": "The Ecobee `set_aux_heat` action has been migrated. A new `aux_heat_only` switch entity is available for each thermostat that supports a Heat Pump.\n\nUpdate any automations to use the new `aux_heat_only` switch entity. When this is done, fix this issue and restart Home Assistant.",
-            "title": "Disable legacy Ecobee set_aux_heat action"
+            "description": "The ecobee `set_aux_heat` action has been migrated. A new `aux_heat_only` switch entity is available for each thermostat that supports a Heat Pump.\n\nUpdate any automations to use the new `aux_heat_only` switch entity. When this is done, fix this issue and restart Home Assistant.",
+            "title": "Disable legacy ecobee set_aux_heat action"
           }
         }
       }

homeassistant/components/econet/climate.py

@@ -23,10 +23,8 @@ from homeassistant.components.climate import (
 from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.issue_registry import IssueSeverity, create_issue
 
 from . import EconetConfigEntry
-from .const import DOMAIN
 from .entity import EcoNetEntity
 
 ECONET_STATE_TO_HA = {
@@ -212,34 +210,6 @@ class EcoNetThermostat(EcoNetEntity[Thermostat], ClimateEntity):
         """Set the fan mode."""
         self._econet.set_fan_mode(HA_FAN_STATE_TO_ECONET[fan_mode])
 
-    def turn_aux_heat_on(self) -> None:
-        """Turn auxiliary heater on."""
-        create_issue(
-            self.hass,
-            DOMAIN,
-            "migrate_aux_heat",
-            breaks_in_ha_version="2025.4.0",
-            is_fixable=True,
-            is_persistent=True,
-            translation_key="migrate_aux_heat",
-            severity=IssueSeverity.WARNING,
-        )
-        self._econet.set_mode(ThermostatOperationMode.EMERGENCY_HEAT)
-
-    def turn_aux_heat_off(self) -> None:
-        """Turn auxiliary heater off."""
-        create_issue(
-            self.hass,
-            DOMAIN,
-            "migrate_aux_heat",
-            breaks_in_ha_version="2025.4.0",
-            is_fixable=True,
-            is_persistent=True,
-            translation_key="migrate_aux_heat",
-            severity=IssueSeverity.WARNING,
-        )
-        self._econet.set_mode(ThermostatOperationMode.HEATING)
-
     @property
     def min_temp(self):
         """Return the minimum temperature."""

homeassistant/components/econet/water_heater.py

@@ -91,15 +91,15 @@ class EcoNetWaterHeater(EcoNetEntity[WaterHeater], WaterHeaterEntity):
     def operation_list(self) -> list[str]:
         """List of available operation modes."""
         econet_modes = self.water_heater.modes
-        op_list = []
+        operation_modes = set()
         for mode in econet_modes:
             if (
                 mode is not WaterHeaterOperationMode.UNKNOWN
                 and mode is not WaterHeaterOperationMode.VACATION
             ):
                 ha_mode = ECONET_STATE_TO_HA[mode]
-                op_list.append(ha_mode)
-        return op_list
+                operation_modes.add(ha_mode)
+        return list(operation_modes)
 
     @property
     def supported_features(self) -> WaterHeaterEntityFeature:

homeassistant/components/ecovacs/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/ecovacs",
   "iot_class": "cloud_push",
   "loggers": ["sleekxmppfs", "sucks", "deebot_client"],
-  "requirements": ["py-sucks==0.9.10", "deebot-client==12.4.0"]
+  "requirements": ["py-sucks==0.9.10", "deebot-client==12.5.0"]
 }

homeassistant/components/ecovacs/strings.json

@@ -176,9 +176,9 @@
       "water_amount": {
         "name": "Water flow level",
         "state": {
-          "high": "High",
-          "low": "Low",
-          "medium": "Medium",
+          "high": "[%key:common::state::high%]",
+          "low": "[%key:common::state::low%]",
+          "medium": "[%key:common::state::medium%]",
           "ultrahigh": "Ultrahigh"
         }
       },
@@ -229,9 +229,9 @@
         "state_attributes": {
           "fan_speed": {
             "state": {
+              "normal": "[%key:common::state::normal%]",
               "max": "Max",
               "max_plus": "Max+",
-              "normal": "Normal",
               "quiet": "Quiet"
             }
           },

homeassistant/components/eheimdigital/__init__.py

@@ -9,7 +9,7 @@ from homeassistant.helpers.device_registry import DeviceEntry
 from .const import DOMAIN
 from .coordinator import EheimDigitalConfigEntry, EheimDigitalUpdateCoordinator
 
-PLATFORMS = [Platform.CLIMATE, Platform.LIGHT]
+PLATFORMS = [Platform.CLIMATE, Platform.LIGHT, Platform.SENSOR]
 
 
 async def async_setup_entry(

homeassistant/components/eheimdigital/icons.json

@@ -0,0 +1,18 @@
+{
+  "entity": {
+    "sensor": {
+      "current_speed": {
+        "default": "mdi:pump"
+      },
+      "service_hours": {
+        "default": "mdi:wrench-clock"
+      },
+      "error_code": {
+        "default": "mdi:alert-octagon",
+        "state": {
+          "no_error": "mdi:check-circle"
+        }
+      }
+    }
+  }
+}

homeassistant/components/eheimdigital/sensor.py

@@ -0,0 +1,114 @@
+"""EHEIM Digital sensors."""
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Generic, TypeVar, override
+
+from eheimdigital.classic_vario import EheimDigitalClassicVario
+from eheimdigital.device import EheimDigitalDevice
+from eheimdigital.types import FilterErrorCode
+
+from homeassistant.components.sensor import SensorEntity, SensorEntityDescription
+from homeassistant.components.sensor.const import SensorDeviceClass
+from homeassistant.const import PERCENTAGE, EntityCategory, UnitOfTime
+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
+
+_DeviceT_co = TypeVar("_DeviceT_co", bound=EheimDigitalDevice, covariant=True)
+
+
+@dataclass(frozen=True, kw_only=True)
+class EheimDigitalSensorDescription(SensorEntityDescription, Generic[_DeviceT_co]):
+    """Class describing EHEIM Digital sensor entities."""
+
+    value_fn: Callable[[_DeviceT_co], float | str | None]
+
+
+CLASSICVARIO_DESCRIPTIONS: tuple[
+    EheimDigitalSensorDescription[EheimDigitalClassicVario], ...
+] = (
+    EheimDigitalSensorDescription[EheimDigitalClassicVario](
+        key="current_speed",
+        translation_key="current_speed",
+        value_fn=lambda device: device.current_speed,
+        native_unit_of_measurement=PERCENTAGE,
+    ),
+    EheimDigitalSensorDescription[EheimDigitalClassicVario](
+        key="service_hours",
+        translation_key="service_hours",
+        value_fn=lambda device: device.service_hours,
+        device_class=SensorDeviceClass.DURATION,
+        native_unit_of_measurement=UnitOfTime.HOURS,
+        suggested_unit_of_measurement=UnitOfTime.DAYS,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+    EheimDigitalSensorDescription[EheimDigitalClassicVario](
+        key="error_code",
+        translation_key="error_code",
+        value_fn=(
+            lambda device: device.error_code.name.lower()
+            if device.error_code is not None
+            else None
+        ),
+        device_class=SensorDeviceClass.ENUM,
+        options=[name.lower() for name in FilterErrorCode._member_names_],
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: EheimDigitalConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up the callbacks for the coordinator so lights 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 light entities for one or multiple devices."""
+        entities: list[EheimDigitalSensor[EheimDigitalDevice]] = []
+        for device in device_address.values():
+            if isinstance(device, EheimDigitalClassicVario):
+                entities += [
+                    EheimDigitalSensor[EheimDigitalClassicVario](
+                        coordinator, device, description
+                    )
+                    for description in CLASSICVARIO_DESCRIPTIONS
+                ]
+
+        async_add_entities(entities)
+
+    coordinator.add_platform_callback(async_setup_device_entities)
+    async_setup_device_entities(coordinator.hub.devices)
+
+
+class EheimDigitalSensor(
+    EheimDigitalEntity[_DeviceT_co], SensorEntity, Generic[_DeviceT_co]
+):
+    """Represent a EHEIM Digital sensor entity."""
+
+    entity_description: EheimDigitalSensorDescription[_DeviceT_co]
+
+    def __init__(
+        self,
+        coordinator: EheimDigitalUpdateCoordinator,
+        device: _DeviceT_co,
+        description: EheimDigitalSensorDescription[_DeviceT_co],
+    ) -> None:
+        """Initialize an EHEIM Digital number entity."""
+        super().__init__(coordinator, device)
+        self.entity_description = description
+        self._attr_unique_id = f"{self._device_address}_{description.key}"
+
+    @override
+    def _async_update_attrs(self) -> None:
+        self._attr_native_value = self.entity_description.value_fn(self._device)

homeassistant/components/eheimdigital/strings.json

@@ -46,6 +46,22 @@
           }
         }
       }
+    },
+    "sensor": {
+      "current_speed": {
+        "name": "Current speed"
+      },
+      "service_hours": {
+        "name": "Remaining hours until service"
+      },
+      "error_code": {
+        "name": "Error code",
+        "state": {
+          "no_error": "No error",
+          "rotor_stuck": "Rotor stuck",
+          "air_in_filter": "Air in filter"
+        }
+      }
     }
   }
 }

homeassistant/components/elkm1/entity.py

@@ -100,7 +100,11 @@ class ElkEntity(Entity):
         return {"index": self._element.index + 1}
 
     def _element_changed(self, element: Element, changeset: dict[str, Any]) -> None:
-        pass
+        """Handle changes to the element.
+
+        This method is called when the element changes. It should be
+        overridden by subclasses to handle the changes.
+        """
 
     @callback
     def _element_callback(self, element: Element, changeset: dict[str, Any]) -> None:
@@ -111,7 +115,7 @@ class ElkEntity(Entity):
     async def async_added_to_hass(self) -> None:
         """Register callback for ElkM1 changes and update entity state."""
         self._element.add_callback(self._element_callback)
-        self._element_callback(self._element, {})
+        self._element_changed(self._element, {})
 
     @property
     def device_info(self) -> DeviceInfo:

homeassistant/components/elmax/strings.json

@@ -4,12 +4,12 @@
       "choose_mode": {
         "description": "Please choose the connection mode to Elmax panels.",
         "menu_options": {
-          "cloud": "Connect to Elmax Panel via Elmax Cloud APIs",
-          "direct": "Connect to Elmax Panel via local/direct IP"
+          "cloud": "Connect to Elmax panel via Elmax Cloud APIs",
+          "direct": "Connect to Elmax panel via local/direct IP"
         }
       },
       "cloud": {
-        "description": "Please login to the Elmax cloud using your credentials",
+        "description": "Please log in to the Elmax cloud using your credentials",
         "data": {
           "password": "[%key:common::config_flow::data::password%]",
           "username": "[%key:common::config_flow::data::username%]"
@@ -28,7 +28,7 @@
       "direct": {
         "description": "Specify the Elmax panel connection parameters below.",
         "data": {
-          "panel_api_host": "Panel API Hostname or IP",
+          "panel_api_host": "Panel API hostname or IP",
           "panel_api_port": "Panel API port",
           "use_ssl": "Use SSL",
           "panel_pin": "Panel PIN code"
@@ -40,7 +40,7 @@
       "panels": {
         "description": "Select which panel you would like to control with this integration. Please note that the panel must be ON in order to be configured.",
         "data": {
-          "panel_name": "Panel Name",
+          "panel_name": "Panel name",
           "panel_id": "Panel ID",
           "panel_pin": "[%key:common::config_flow::data::pin%]"
         }

homeassistant/components/energy/sensor.py

@@ -25,6 +25,7 @@ from homeassistant.core import (
     split_entity_id,
     valid_entity_id,
 )
+from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.event import async_track_state_change_event
@@ -122,6 +123,10 @@ SOURCE_ADAPTERS: Final = (
 )
 
 
+class EntityNotFoundError(HomeAssistantError):
+    """When a referenced entity was not found."""
+
+
 class SensorManager:
     """Class to handle creation/removal of sensor data."""
 
@@ -311,43 +316,25 @@ class EnergyCostSensor(SensorEntity):
         except ValueError:
             return
 
-        # Determine energy price
-        if self._config["entity_energy_price"] is not None:
-            energy_price_state = self.hass.states.get(
-                self._config["entity_energy_price"]
+        try:
+            energy_price, energy_price_unit = self._get_energy_price(
+                valid_units, default_price_unit
             )
-
-            if energy_price_state is None:
-                return
-
-            try:
-                energy_price = float(energy_price_state.state)
-            except ValueError:
-                if self._last_energy_sensor_state is None:
-                    # Initialize as it's the first time all required entities except
-                    # price are in place. This means that the cost will update the first
-                    # time the energy is updated after the price entity is in place.
-                    self._reset(energy_state)
-                return
-
-            energy_price_unit: str | None = energy_price_state.attributes.get(
-                ATTR_UNIT_OF_MEASUREMENT, ""
-            ).partition("/")[2]
-
-            # For backwards compatibility we don't validate the unit of the price
-            # If it is not valid, we assume it's our default price unit.
-            if energy_price_unit not in valid_units:
-                energy_price_unit = default_price_unit
-
-        else:
-            energy_price = cast(float, self._config["number_energy_price"])
-            energy_price_unit = default_price_unit
+        except EntityNotFoundError:
+            return
+        except ValueError:
+            energy_price = None
 
         if self._last_energy_sensor_state is None:
-            # Initialize as it's the first time all required entities are in place.
+            # Initialize as it's the first time all required entities are in place or
+            # only the price is missing. In the later case, cost will update the first
+            # time the energy is updated after the price entity is in place.
             self._reset(energy_state)
             return
 
+        if energy_price is None:
+            return
+
         energy_unit: str | None = energy_state.attributes.get(ATTR_UNIT_OF_MEASUREMENT)
 
         if energy_unit is None or energy_unit not in valid_units:
@@ -383,20 +370,9 @@ class EnergyCostSensor(SensorEntity):
         old_energy_value = float(self._last_energy_sensor_state.state)
         cur_value = cast(float, self._attr_native_value)
 
-        if energy_price_unit is None:
-            converted_energy_price = energy_price
-        else:
-            converter: Callable[[float, str, str], float]
-            if energy_unit in VALID_ENERGY_UNITS:
-                converter = unit_conversion.EnergyConverter.convert
-            else:
-                converter = unit_conversion.VolumeConverter.convert
-
-            converted_energy_price = converter(
-                energy_price,
-                energy_unit,
-                energy_price_unit,
-            )
+        converted_energy_price = self._convert_energy_price(
+            energy_price, energy_price_unit, energy_unit
+        )
 
         self._attr_native_value = (
             cur_value + (energy - old_energy_value) * converted_energy_price
@@ -404,6 +380,52 @@ class EnergyCostSensor(SensorEntity):
 
         self._last_energy_sensor_state = energy_state
 
+    def _get_energy_price(
+        self, valid_units: set[str], default_unit: str | None
+    ) -> tuple[float, str | None]:
+        """Get the energy price.
+
+        Raises:
+            EntityNotFoundError: When the energy price entity is not found.
+            ValueError: When the entity state is not a valid float.
+
+        """
+
+        if self._config["entity_energy_price"] is None:
+            return cast(float, self._config["number_energy_price"]), default_unit
+
+        energy_price_state = self.hass.states.get(self._config["entity_energy_price"])
+        if energy_price_state is None:
+            raise EntityNotFoundError
+
+        energy_price = float(energy_price_state.state)
+
+        energy_price_unit: str | None = energy_price_state.attributes.get(
+            ATTR_UNIT_OF_MEASUREMENT, ""
+        ).partition("/")[2]
+
+        # For backwards compatibility we don't validate the unit of the price
+        # If it is not valid, we assume it's our default price unit.
+        if energy_price_unit not in valid_units:
+            energy_price_unit = default_unit
+
+        return energy_price, energy_price_unit
+
+    def _convert_energy_price(
+        self, energy_price: float, energy_price_unit: str | None, energy_unit: str
+    ) -> float:
+        """Convert the energy price to the correct unit."""
+        if energy_price_unit is None:
+            return energy_price
+
+        converter: Callable[[float, str, str], float]
+        if energy_unit in VALID_ENERGY_UNITS:
+            converter = unit_conversion.EnergyConverter.convert
+        else:
+            converter = unit_conversion.VolumeConverter.convert
+
+        return converter(energy_price, energy_unit, energy_price_unit)
+
     async def async_added_to_hass(self) -> None:
         """Register callbacks."""
         energy_state = self.hass.states.get(self._config[self._adapter.stat_energy_key])

homeassistant/components/enphase_envoy/config_flow.py

@@ -16,7 +16,13 @@ from homeassistant.config_entries import (
     ConfigFlowResult,
     OptionsFlow,
 )
-from homeassistant.const import CONF_HOST, CONF_NAME, CONF_PASSWORD, CONF_USERNAME
+from homeassistant.const import (
+    CONF_HOST,
+    CONF_NAME,
+    CONF_PASSWORD,
+    CONF_TOKEN,
+    CONF_USERNAME,
+)
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.httpx_client import get_async_client
 from homeassistant.helpers.service_info.zeroconf import ZeroconfServiceInfo
@@ -40,6 +46,13 @@ CONF_SERIAL = "serial"
 
 INSTALLER_AUTH_USERNAME = "installer"
 
+AVOID_REFLECT_KEYS = {CONF_PASSWORD, CONF_TOKEN}
+
+
+def without_avoid_reflect_keys(dictionary: Mapping[str, Any]) -> dict[str, Any]:
+    """Return a dictionary without AVOID_REFLECT_KEYS."""
+    return {k: v for k, v in dictionary.items() if k not in AVOID_REFLECT_KEYS}
+
 
 async def validate_input(
     hass: HomeAssistant,
@@ -205,7 +218,10 @@ class EnphaseConfigFlow(ConfigFlow, domain=DOMAIN):
         description_placeholders["serial"] = serial
         return self.async_show_form(
             step_id="reauth_confirm",
-            data_schema=self._async_generate_schema(),
+            data_schema=self.add_suggested_values_to_schema(
+                self._async_generate_schema(),
+                without_avoid_reflect_keys(user_input or reauth_entry.data),
+            ),
             description_placeholders=description_placeholders,
             errors=errors,
         )
@@ -259,10 +275,12 @@ class EnphaseConfigFlow(ConfigFlow, domain=DOMAIN):
                 CONF_SERIAL: self.unique_id,
                 CONF_HOST: host,
             }
-
         return self.async_show_form(
             step_id="user",
-            data_schema=self._async_generate_schema(),
+            data_schema=self.add_suggested_values_to_schema(
+                self._async_generate_schema(),
+                without_avoid_reflect_keys(user_input or {}),
+            ),
             description_placeholders=description_placeholders,
             errors=errors,
         )
@@ -306,11 +324,11 @@ class EnphaseConfigFlow(ConfigFlow, domain=DOMAIN):
         }
         description_placeholders["serial"] = serial
 
-        suggested_values: Mapping[str, Any] = user_input or reconfigure_entry.data
         return self.async_show_form(
             step_id="reconfigure",
             data_schema=self.add_suggested_values_to_schema(
-                self._async_generate_schema(), suggested_values
+                self._async_generate_schema(),
+                without_avoid_reflect_keys(user_input or reconfigure_entry.data),
             ),
             description_placeholders=description_placeholders,
             errors=errors,

homeassistant/components/enphase_envoy/diagnostics.py

@@ -66,16 +66,19 @@ async def _get_fixture_collection(envoy: Envoy, serial: str) -> dict[str, Any]:
     ]
 
     for end_point in end_points:
-        response = await envoy.request(end_point)
-        fixture_data[end_point] = response.text.replace("\n", "").replace(
-            serial, CLEAN_TEXT
-        )
-        fixture_data[f"{end_point}_log"] = json_dumps(
-            {
-                "headers": dict(response.headers.items()),
-                "code": response.status_code,
-            }
-        )
+        try:
+            response = await envoy.request(end_point)
+            fixture_data[end_point] = response.text.replace("\n", "").replace(
+                serial, CLEAN_TEXT
+            )
+            fixture_data[f"{end_point}_log"] = json_dumps(
+                {
+                    "headers": dict(response.headers.items()),
+                    "code": response.status_code,
+                }
+            )
+        except EnvoyError as err:
+            fixture_data[f"{end_point}_log"] = {"Error": repr(err)}
     return fixture_data
 
 
@@ -160,10 +163,7 @@ async def async_get_config_entry_diagnostics(
 
     fixture_data: dict[str, Any] = {}
     if entry.options.get(OPTION_DIAGNOSTICS_INCLUDE_FIXTURES, False):
-        try:
-            fixture_data = await _get_fixture_collection(envoy=envoy, serial=old_serial)
-        except EnvoyError as err:
-            fixture_data["Error"] = repr(err)
+        fixture_data = await _get_fixture_collection(envoy=envoy, serial=old_serial)
 
     diagnostic_data: dict[str, Any] = {
         "config_entry": async_redact_data(entry.as_dict(), TO_REDACT),

homeassistant/components/enphase_envoy/manifest.json

@@ -6,7 +6,7 @@
   "documentation": "https://www.home-assistant.io/integrations/enphase_envoy",
   "iot_class": "local_polling",
   "loggers": ["pyenphase"],
-  "requirements": ["pyenphase==1.25.1"],
+  "requirements": ["pyenphase==1.25.5"],
   "zeroconf": [
     {
       "type": "_enphase-envoy._tcp.local."

homeassistant/components/eq3btsmart/manifest.json

@@ -22,5 +22,5 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["eq3btsmart"],
-  "requirements": ["eq3btsmart==1.4.1", "bleak-esphome==2.12.0"]
+  "requirements": ["eq3btsmart==1.4.1", "bleak-esphome==2.13.1"]
 }

homeassistant/components/esphome/config_flow.py

@@ -128,8 +128,23 @@ class EsphomeFlowHandler(ConfigFlow, domain=DOMAIN):
             self._password = ""
             return await self._async_authenticate_or_add()
 
+        if error is None and entry_data.get(CONF_NOISE_PSK):
+            return await self.async_step_reauth_encryption_removed_confirm()
         return await self.async_step_reauth_confirm()
 
+    async def async_step_reauth_encryption_removed_confirm(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle reauthorization flow when encryption was removed."""
+        if user_input is not None:
+            self._noise_psk = None
+            return self._async_get_entry()
+
+        return self.async_show_form(
+            step_id="reauth_encryption_removed_confirm",
+            description_placeholders={"name": self._name},
+        )
+
     async def async_step_reauth_confirm(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:

homeassistant/components/esphome/manager.py

@@ -13,6 +13,7 @@ from aioesphomeapi import (
     APIConnectionError,
     APIVersion,
     DeviceInfo as EsphomeDeviceInfo,
+    EncryptionPlaintextAPIError,
     EntityInfo,
     HomeassistantServiceCall,
     InvalidAuthAPIError,
@@ -570,6 +571,7 @@ class ESPHomeManager:
         if isinstance(
             err,
             (
+                EncryptionPlaintextAPIError,
                 RequiresEncryptionAPIError,
                 InvalidEncryptionKeyAPIError,
                 InvalidAuthAPIError,

homeassistant/components/esphome/manifest.json

@@ -16,9 +16,9 @@
   "loggers": ["aioesphomeapi", "noiseprotocol", "bleak_esphome"],
   "mqtt": ["esphome/discover/#"],
   "requirements": [
-    "aioesphomeapi==29.7.0",
+    "aioesphomeapi==29.9.0",
     "esphome-dashboard-api==1.2.3",
-    "bleak-esphome==2.12.0"
+    "bleak-esphome==2.13.1"
   ],
   "zeroconf": ["_esphomelib._tcp.local."]
 }

homeassistant/components/esphome/strings.json

@@ -43,6 +43,9 @@
         },
         "description": "The ESPHome device {name} enabled transport encryption or changed the encryption key. Please enter the updated key. You can find it in the ESPHome Dashboard or in your device configuration."
       },
+      "reauth_encryption_removed_confirm": {
+        "description": "The ESPHome device {name} disabled transport encryption. Please confirm that you want to remove the encryption key and allow unencrypted connections."
+      },
       "discovery_confirm": {
         "description": "Do you want to add the ESPHome node `{name}` to Home Assistant?",
         "title": "Discovered ESPHome node"

homeassistant/components/evohome/climate.py

@@ -152,7 +152,7 @@ class EvoZone(EvoChild, EvoClimateEntity):
         super().__init__(coordinator, evo_device)
         self._evo_id = evo_device.id
 
-        if evo_device.model.startswith("VisionProWifi"):
+        if evo_device.id == evo_device.tcs.id:
             # this system does not have a distinct ID for the zone
             self._attr_unique_id = f"{evo_device.id}z"
         else:

homeassistant/components/evohome/manifest.json

@@ -6,5 +6,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["evohome", "evohomeasync", "evohomeasync2"],
   "quality_scale": "legacy",
-  "requirements": ["evohome-async==1.0.4"]
+  "requirements": ["evohome-async==1.0.5"]
 }

homeassistant/components/fibaro/__init__.py

@@ -14,9 +14,10 @@ from pyfibaro.fibaro_client import (
 )
 from pyfibaro.fibaro_data_helper import read_rooms
 from pyfibaro.fibaro_device import DeviceModel
+from pyfibaro.fibaro_device_manager import FibaroDeviceManager
 from pyfibaro.fibaro_info import InfoModel
 from pyfibaro.fibaro_scene import SceneModel
-from pyfibaro.fibaro_state_resolver import FibaroEvent, FibaroStateResolver
+from pyfibaro.fibaro_state_resolver import FibaroEvent
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_PASSWORD, CONF_URL, CONF_USERNAME, Platform
@@ -81,8 +82,8 @@ class FibaroController:
         self._client = fibaro_client
         self._fibaro_info = info
 
-        # Whether to import devices from plugins
-        self._import_plugins = import_plugins
+        # The fibaro device manager exposes higher level API to access fibaro devices
+        self._fibaro_device_manager = FibaroDeviceManager(fibaro_client, import_plugins)
         # Mapping roomId to room object
         self._room_map = read_rooms(fibaro_client)
         self._device_map: dict[int, DeviceModel]  # Mapping deviceId to device object
@@ -91,79 +92,30 @@ class FibaroController:
         )  # List of devices by entity platform
         # All scenes
         self._scenes = self._client.read_scenes()
-        self._callbacks: dict[int, list[Any]] = {}  # Update value callbacks by deviceId
-        # Event callbacks by device id
-        self._event_callbacks: dict[int, list[Callable[[FibaroEvent], None]]] = {}
         # Unique serial number of the hub
         self.hub_serial = info.serial_number
         # Device infos by fibaro device id
         self._device_infos: dict[int, DeviceInfo] = {}
         self._read_devices()
 
-    def enable_state_handler(self) -> None:
-        """Start StateHandler thread for monitoring updates."""
-        self._client.register_update_handler(self._on_state_change)
+    def disconnect(self) -> None:
+        """Close push channel."""
+        self._fibaro_device_manager.close()
 
-    def disable_state_handler(self) -> None:
-        """Stop StateHandler thread used for monitoring updates."""
-        self._client.unregister_update_handler()
-
-    def _on_state_change(self, state: Any) -> None:
-        """Handle change report received from the HomeCenter."""
-        callback_set = set()
-        for change in state.get("changes", []):
-            try:
-                dev_id = change.pop("id")
-                if dev_id not in self._device_map:
-                    continue
-                device = self._device_map[dev_id]
-                for property_name, value in change.items():
-                    if property_name == "log":
-                        if value and value != "transfer OK":
-                            _LOGGER.debug("LOG %s: %s", device.friendly_name, value)
-                        continue
-                    if property_name == "logTemp":
-                        continue
-                    if property_name in device.properties:
-                        device.properties[property_name] = value
-                        _LOGGER.debug(
-                            "<- %s.%s = %s", device.ha_id, property_name, str(value)
-                        )
-                    else:
-                        _LOGGER.warning("%s.%s not found", device.ha_id, property_name)
-                    if dev_id in self._callbacks:
-                        callback_set.add(dev_id)
-            except (ValueError, KeyError):
-                pass
-        for item in callback_set:
-            for callback in self._callbacks[item]:
-                callback()
-
-        resolver = FibaroStateResolver(state)
-        for event in resolver.get_events():
-            # event does not always have a fibaro id, therefore it is
-            # essential that we first check for relevant event type
-            if (
-                event.event_type.lower() == "centralsceneevent"
-                and event.fibaro_id in self._event_callbacks
-            ):
-                for callback in self._event_callbacks[event.fibaro_id]:
-                    callback(event)
-
-    def register(self, device_id: int, callback: Any) -> None:
+    def register(
+        self, device_id: int, callback: Callable[[DeviceModel], None]
+    ) -> Callable[[], None]:
         """Register device with a callback for updates."""
-        device_callbacks = self._callbacks.setdefault(device_id, [])
-        device_callbacks.append(callback)
+        return self._fibaro_device_manager.add_change_listener(device_id, callback)
 
     def register_event(
         self, device_id: int, callback: Callable[[FibaroEvent], None]
-    ) -> None:
+    ) -> Callable[[], None]:
         """Register device with a callback for central scene events.
 
         The callback receives one parameter with the event.
         """
-        device_callbacks = self._event_callbacks.setdefault(device_id, [])
-        device_callbacks.append(callback)
+        return self._fibaro_device_manager.add_event_listener(device_id, callback)
 
     def get_children(self, device_id: int) -> list[DeviceModel]:
         """Get a list of child devices."""
@@ -286,7 +238,7 @@ class FibaroController:
 
     def _read_devices(self) -> None:
         """Read and process the device list."""
-        devices = self._client.read_devices()
+        devices = self._fibaro_device_manager.get_devices()
         self._device_map = {}
         last_climate_parent = None
         last_endpoint = None
@@ -301,8 +253,8 @@ class FibaroController:
                 device.ha_id = (
                     f"{slugify(room_name)}_{slugify(device.name)}_{device.fibaro_id}"
                 )
-                if device.enabled and (not device.is_plugin or self._import_plugins):
-                    platform = self._map_device_to_platform(device)
+
+                platform = self._map_device_to_platform(device)
                 if platform is None:
                     continue
                 device.unique_id_str = f"{slugify(self.hub_serial)}.{device.fibaro_id}"
@@ -392,8 +344,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: FibaroConfigEntry) -> bo
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
-    controller.enable_state_handler()
-
     return True
 
 
@@ -402,8 +352,7 @@ async def async_unload_entry(hass: HomeAssistant, entry: FibaroConfigEntry) -> b
     _LOGGER.debug("Shutting down Fibaro connection")
     unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
 
-    entry.runtime_data.disable_state_handler()
-
+    entry.runtime_data.disconnect()
     return unload_ok
 
 

homeassistant/components/fibaro/entity.py

@@ -36,9 +36,13 @@ class FibaroEntity(Entity):
 
     async def async_added_to_hass(self) -> None:
         """Call when entity is added to hass."""
-        self.controller.register(self.fibaro_device.fibaro_id, self._update_callback)
+        self.async_on_remove(
+            self.controller.register(
+                self.fibaro_device.fibaro_id, self._update_callback
+            )
+        )
 
-    def _update_callback(self) -> None:
+    def _update_callback(self, fibaro_device: DeviceModel) -> None:
         """Update the state."""
         self.schedule_update_ha_state(True)
 

homeassistant/components/fibaro/event.py

@@ -60,11 +60,16 @@ class FibaroEventEntity(FibaroEntity, EventEntity):
         await super().async_added_to_hass()
 
         # Register event callback
-        self.controller.register_event(
-            self.fibaro_device.fibaro_id, self._event_callback
+        self.async_on_remove(
+            self.controller.register_event(
+                self.fibaro_device.fibaro_id, self._event_callback
+            )
         )
 
     def _event_callback(self, event: FibaroEvent) -> None:
-        if event.key_id == self._button:
+        if (
+            event.event_type.lower() == "centralsceneevent"
+            and event.key_id == self._button
+        ):
             self._trigger_event(event.key_event_type)
             self.schedule_update_ha_state()

homeassistant/components/fireservicerota/strings.json

@@ -9,7 +9,7 @@
         }
       },
       "reauth_confirm": {
-        "description": "Authentication tokens became invalid, login to recreate them.",
+        "description": "Authentication tokens became invalid, log in to recreate them.",
         "data": {
           "password": "[%key:common::config_flow::data::password%]"
         }

homeassistant/components/flipr/__init__.py

@@ -1,6 +1,5 @@
 """The Flipr integration."""
 
-from collections import Counter
 import logging
 
 from flipr_api import FliprAPIRestClient
@@ -8,10 +7,7 @@ from flipr_api import FliprAPIRestClient
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_EMAIL, CONF_PASSWORD, Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryError
-from homeassistant.helpers import issue_registry as ir
 
-from .const import DOMAIN
 from .coordinator import (
     FliprConfigEntry,
     FliprData,
@@ -27,9 +23,6 @@ _LOGGER = logging.getLogger(__name__)
 async def async_setup_entry(hass: HomeAssistant, entry: FliprConfigEntry) -> bool:
     """Set up flipr from a config entry."""
 
-    # Detect invalid old config entry and raise error if found
-    detect_invalid_old_configuration(hass, entry)
-
     config = entry.data
 
     username = config[CONF_EMAIL]
@@ -64,47 +57,3 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a config entry."""
 
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
-
-
-def detect_invalid_old_configuration(hass: HomeAssistant, entry: ConfigEntry):
-    """Detect invalid old configuration and raise error if found."""
-
-    def find_duplicate_entries(entries):
-        values = [e.data["email"] for e in entries]
-        _LOGGER.debug("Detecting duplicates in values : %s", values)
-        return any(count > 1 for count in Counter(values).values())
-
-    entries = hass.config_entries.async_entries(DOMAIN)
-
-    if find_duplicate_entries(entries):
-        ir.async_create_issue(
-            hass,
-            DOMAIN,
-            "duplicate_config",
-            breaks_in_ha_version="2025.4.0",
-            is_fixable=False,
-            severity=ir.IssueSeverity.ERROR,
-            translation_key="duplicate_config",
-        )
-
-        raise ConfigEntryError(
-            "Duplicate entries found for flipr with the same user email. Please remove one of it manually. Multiple fliprs will be automatically detected after restart."
-        )
-
-
-async def async_migrate_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
-    """Migrate config entry."""
-    _LOGGER.debug("Migration of flipr config from version %s", entry.version)
-
-    if entry.version == 1:
-        # In version 1, we have flipr device as config entry unique id
-        # and one device per config entry.
-        # We need to migrate to a new config entry that may contain multiple devices.
-        # So we change the entry data to match config_flow evolution.
-        login = entry.data[CONF_EMAIL]
-
-        hass.config_entries.async_update_entry(entry, version=2, unique_id=login)
-
-        _LOGGER.debug("Migration of flipr config to version 2 successful")
-
-    return True

homeassistant/components/flipr/strings.json

@@ -50,11 +50,5 @@
         }
       }
     }
-  },
-  "issues": {
-    "duplicate_config": {
-      "title": "Multiple flipr configurations with the same account",
-      "description": "The Flipr integration has been updated to work account based rather than device based. This means that if you have 2 devices, you only need one configuration. For every account you have, please delete all but one configuration and restart Home Assistant for it to set up the devices linked to your account."
-    }
   }
 }

homeassistant/components/flux_led/manifest.json

@@ -53,5 +53,5 @@
   "documentation": "https://www.home-assistant.io/integrations/flux_led",
   "iot_class": "local_push",
   "loggers": ["flux_led"],
-  "requirements": ["flux-led==1.1.3"]
+  "requirements": ["flux-led==1.2.0"]
 }

homeassistant/components/forecast_solar/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/forecast_solar",
   "integration_type": "service",
   "iot_class": "cloud_polling",
-  "requirements": ["forecast-solar==4.0.0"]
+  "requirements": ["forecast-solar==4.1.0"]
 }

homeassistant/components/fritz/binary_sensor.py

@@ -20,6 +20,9 @@ from .entity import FritzBoxBaseCoordinatorEntity, FritzEntityDescription
 
 _LOGGER = logging.getLogger(__name__)
 
+# Coordinator is used to centralize the data updates
+PARALLEL_UPDATES = 0
+
 
 @dataclass(frozen=True, kw_only=True)
 class FritzBinarySensorEntityDescription(

homeassistant/components/fritz/button.py

@@ -31,6 +31,9 @@ from .entity import FritzDeviceBase
 
 _LOGGER = logging.getLogger(__name__)
 
+# Set a sane value to avoid too many updates
+PARALLEL_UPDATES = 5
+
 
 @dataclass(frozen=True, kw_only=True)
 class FritzButtonDescription(ButtonEntityDescription):

homeassistant/components/fritz/device_tracker.py

@@ -22,6 +22,9 @@ from .entity import FritzDeviceBase
 
 _LOGGER = logging.getLogger(__name__)
 
+# Coordinator is used to centralize the data updates
+PARALLEL_UPDATES = 0
+
 
 async def async_setup_entry(
     hass: HomeAssistant,

homeassistant/components/fritz/image.py

@@ -18,6 +18,9 @@ from .entity import FritzBoxBaseEntity
 
 _LOGGER = logging.getLogger(__name__)
 
+# Coordinator is used to centralize the data updates
+PARALLEL_UPDATES = 0
+
 
 async def async_setup_entry(
     hass: HomeAssistant,

homeassistant/components/fritz/quality_scale.yaml

@@ -4,19 +4,13 @@ rules:
   appropriate-polling: done
   brands: done
   common-modules: done
-  config-flow-test-coverage:
-    status: todo
-    comment: one coverage miss in line 110
-  config-flow:
-    status: todo
-    comment: data_description are missing
+  config-flow-test-coverage: done
+  config-flow: done
   dependency-transparency: done
   docs-actions: done
   docs-high-level-description: done
   docs-installation-instructions: done
-  docs-removal-instructions:
-    status: todo
-    comment: include the proper docs snippet
+  docs-removal-instructions: done
   entity-event-setup: done
   entity-unique-id: done
   has-entity-name:
@@ -31,15 +25,11 @@ rules:
   action-exceptions: done
   config-entry-unloading: done
   docs-configuration-parameters: done
-  docs-installation-parameters:
-    status: todo
-    comment: add the proper configuration_basic block
+  docs-installation-parameters: done
   entity-unavailable: done
   integration-owner: done
   log-when-unavailable: done
-  parallel-updates:
-    status: todo
-    comment: not set at the moment, we use a coordinator
+  parallel-updates: done
   reauthentication-flow: done
   test-coverage:
     status: todo
@@ -50,7 +40,7 @@ rules:
   diagnostics: done
   discovery-update-info: todo
   discovery: done
-  docs-data-update: todo
+  docs-data-update: done
   docs-examples: done
   docs-known-limitations:
     status: exempt

homeassistant/components/fritz/sensor.py

@@ -32,6 +32,9 @@ from .entity import FritzBoxBaseCoordinatorEntity, FritzEntityDescription
 
 _LOGGER = logging.getLogger(__name__)
 
+# Coordinator is used to centralize the data updates
+PARALLEL_UPDATES = 0
+
 
 def _uptime_calculation(seconds_uptime: float, last_value: datetime | None) -> datetime:
     """Calculate uptime with deviation."""
@@ -238,6 +241,8 @@ SENSOR_TYPES: tuple[FritzSensorEntityDescription, ...] = (
         key="link_noise_margin_sent",
         translation_key="link_noise_margin_sent",
         native_unit_of_measurement=SIGNAL_STRENGTH_DECIBELS,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
         value_fn=_retrieve_link_noise_margin_sent_state,
         is_suitable=lambda info: info.wan_enabled and info.connection == DSL_CONNECTION,
     ),
@@ -245,6 +250,8 @@ SENSOR_TYPES: tuple[FritzSensorEntityDescription, ...] = (
         key="link_noise_margin_received",
         translation_key="link_noise_margin_received",
         native_unit_of_measurement=SIGNAL_STRENGTH_DECIBELS,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
         value_fn=_retrieve_link_noise_margin_received_state,
         is_suitable=lambda info: info.wan_enabled and info.connection == DSL_CONNECTION,
     ),
@@ -252,6 +259,8 @@ SENSOR_TYPES: tuple[FritzSensorEntityDescription, ...] = (
         key="link_attenuation_sent",
         translation_key="link_attenuation_sent",
         native_unit_of_measurement=SIGNAL_STRENGTH_DECIBELS,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
         value_fn=_retrieve_link_attenuation_sent_state,
         is_suitable=lambda info: info.wan_enabled and info.connection == DSL_CONNECTION,
     ),
@@ -259,6 +268,8 @@ SENSOR_TYPES: tuple[FritzSensorEntityDescription, ...] = (
         key="link_attenuation_received",
         translation_key="link_attenuation_received",
         native_unit_of_measurement=SIGNAL_STRENGTH_DECIBELS,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
         value_fn=_retrieve_link_attenuation_received_state,
         is_suitable=lambda info: info.wan_enabled and info.connection == DSL_CONNECTION,
     ),

homeassistant/components/fritz/strings.json

@@ -1,4 +1,11 @@
 {
+  "common": {
+    "data_description_host": "The hostname or IP address of your FRITZ!Box router.",
+    "data_description_port": "Leave empty to use the default port.",
+    "data_description_username": "Username for the FRITZ!Box.",
+    "data_description_password": "Password for the FRITZ!Box.",
+    "data_description_ssl": "Use SSL to connect to the FRITZ!Box."
+  },
   "config": {
     "flow_title": "{name}",
     "step": {
@@ -9,6 +16,11 @@
           "username": "[%key:common::config_flow::data::username%]",
           "password": "[%key:common::config_flow::data::password%]",
           "ssl": "[%key:common::config_flow::data::ssl%]"
+        },
+        "data_description": {
+          "username": "[%key:component::fritz::common::data_description_username%]",
+          "password": "[%key:component::fritz::common::data_description_password%]",
+          "ssl": "[%key:component::fritz::common::data_description_ssl%]"
         }
       },
       "reauth_confirm": {
@@ -17,6 +29,10 @@
         "data": {
           "username": "[%key:common::config_flow::data::username%]",
           "password": "[%key:common::config_flow::data::password%]"
+        },
+        "data_description": {
+          "username": "[%key:component::fritz::common::data_description_username%]",
+          "password": "[%key:component::fritz::common::data_description_password%]"
         }
       },
       "reconfigure": {
@@ -28,8 +44,9 @@
           "ssl": "[%key:common::config_flow::data::ssl%]"
         },
         "data_description": {
-          "host": "The hostname or IP address of your FRITZ!Box router.",
-          "port": "Leave it empty to use the default port."
+          "host": "[%key:component::fritz::common::data_description_host%]",
+          "port": "[%key:component::fritz::common::data_description_port%]",
+          "ssl": "[%key:component::fritz::common::data_description_ssl%]"
         }
       },
       "user": {
@@ -43,8 +60,11 @@
           "ssl": "[%key:common::config_flow::data::ssl%]"
         },
         "data_description": {
-          "host": "The hostname or IP address of your FRITZ!Box router.",
-          "port": "Leave it empty to use the default port."
+          "host": "[%key:component::fritz::common::data_description_host%]",
+          "port": "[%key:component::fritz::common::data_description_port%]",
+          "username": "[%key:component::fritz::common::data_description_username%]",
+          "password": "[%key:component::fritz::common::data_description_password%]",
+          "ssl": "[%key:component::fritz::common::data_description_ssl%]"
         }
       }
     },
@@ -70,6 +90,10 @@
         "data": {
           "consider_home": "Seconds to consider a device at 'home'",
           "old_discovery": "Enable old discovery method"
+        },
+        "data_description": {
+          "consider_home": "Time in seconds to consider a device at home. Default is 180 seconds.",
+          "old_discovery": "Enable old discovery method. This is needed for some scenarios."
         }
       }
     }
@@ -169,8 +193,12 @@
     "config_entry_not_found": {
       "message": "Failed to perform action \"{service}\". Config entry for target not found"
     },
-    "service_parameter_unknown": { "message": "Action or parameter unknown" },
-    "service_not_supported": { "message": "Action not supported" },
+    "service_parameter_unknown": {
+      "message": "Action or parameter unknown"
+    },
+    "service_not_supported": {
+      "message": "Action not supported"
+    },
     "error_refresh_hosts_info": {
       "message": "Error refreshing hosts info"
     },

homeassistant/components/fritz/switch.py

@@ -38,6 +38,9 @@ from .entity import FritzBoxBaseEntity, FritzDeviceBase
 
 _LOGGER = logging.getLogger(__name__)
 
+# Set a sane value to avoid too many updates
+PARALLEL_UPDATES = 5
+
 
 async def _async_deflection_entities_list(
     avm_wrapper: AvmWrapper, device_friendly_name: str

homeassistant/components/fritz/update.py

@@ -20,6 +20,9 @@ from .entity import FritzBoxBaseCoordinatorEntity, FritzEntityDescription
 
 _LOGGER = logging.getLogger(__name__)
 
+# Set a sane value to avoid too many updates
+PARALLEL_UPDATES = 5
+
 
 @dataclass(frozen=True, kw_only=True)
 class FritzUpdateEntityDescription(UpdateEntityDescription, FritzEntityDescription):

homeassistant/components/fritzbox/sensor.py

@@ -137,6 +137,7 @@ SENSOR_TYPES: Final[tuple[FritzSensorEntityDescription, ...]] = (
         key="battery",
         native_unit_of_measurement=PERCENTAGE,
         device_class=SensorDeviceClass.BATTERY,
+        state_class=SensorStateClass.MEASUREMENT,
         entity_category=EntityCategory.DIAGNOSTIC,
         suitable=lambda device: device.battery_level is not None,
         native_value=lambda device: device.battery_level,