Update action-exceptions status

https://github.com/home-assistant/core/pull/144200

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,5 +1,6 @@
 name: Report an issue with Home Assistant Core
 description: Report an issue with Home Assistant Core.
+type: Bug
 body:
   - type: markdown
     attributes:

.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
 
@@ -1317,7 +1317,7 @@ jobs:
           pattern: coverage-*
       - name: Upload coverage to Codecov
         if: needs.info.outputs.test_full_suite == 'true'
-        uses: codecov/codecov-action@v5.4.0
+        uses: codecov/codecov-action@v5.4.2
         with:
           fail_ci_if_error: true
           flags: full-suite
@@ -1459,7 +1459,7 @@ jobs:
           pattern: coverage-*
       - name: Upload coverage to Codecov
         if: needs.info.outputs.test_full_suite == 'false'
-        uses: codecov/codecov-action@v5.4.0
+        uses: codecov/codecov-action@v5.4.2
         with:
           fail_ci_if_error: true
           token: ${{ secrets.CODECOV_TOKEN }}

.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

@@ -291,6 +291,7 @@ homeassistant.components.kaleidescape.*
 homeassistant.components.knocki.*
 homeassistant.components.knx.*
 homeassistant.components.kraken.*
+homeassistant.components.kulersky.*
 homeassistant.components.lacrosse.*
 homeassistant.components.lacrosse_view.*
 homeassistant.components.lamarzocco.*
@@ -364,6 +365,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

@@ -432,7 +432,7 @@ build.json @home-assistant/supervisor
 /homeassistant/components/entur_public_transport/ @hfurubotten
 /homeassistant/components/environment_canada/ @gwww @michaeldavie
 /tests/components/environment_canada/ @gwww @michaeldavie
-/homeassistant/components/ephember/ @ttroy50
+/homeassistant/components/ephember/ @ttroy50 @roberty99
 /homeassistant/components/epic_games_store/ @hacf-fr @Quentame
 /tests/components/epic_games_store/ @hacf-fr @Quentame
 /homeassistant/components/epion/ @lhgravendeel
@@ -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
@@ -935,6 +937,8 @@ build.json @home-assistant/supervisor
 /tests/components/metoffice/ @MrHarcombe @avee87
 /homeassistant/components/microbees/ @microBeesTech
 /tests/components/microbees/ @microBeesTech
+/homeassistant/components/miele/ @astrandb
+/tests/components/miele/ @astrandb
 /homeassistant/components/mikrotik/ @engrbm87
 /tests/components/mikrotik/ @engrbm87
 /homeassistant/components/mill/ @danielhiversen
@@ -1387,7 +1391,6 @@ build.json @home-assistant/supervisor
 /homeassistant/components/siren/ @home-assistant/core @raman325
 /tests/components/siren/ @home-assistant/core @raman325
 /homeassistant/components/sisyphus/ @jkeljo
-/homeassistant/components/sky_hub/ @rogerselwyn
 /homeassistant/components/sky_remote/ @dunnmj @saty9
 /tests/components/sky_remote/ @dunnmj @saty9
 /homeassistant/components/skybell/ @tkdrob

homeassistant/bootstrap.py

@@ -53,6 +53,7 @@ from .components import (
     logbook as logbook_pre_import,  # noqa: F401
     lovelace as lovelace_pre_import,  # noqa: F401
     onboarding as onboarding_pre_import,  # noqa: F401
+    person as person_pre_import,  # noqa: F401
     recorder as recorder_import,  # noqa: F401 - not named pre_import since it has requirements
     repairs as repairs_pre_import,  # noqa: F401
     search as search_pre_import,  # noqa: F401
@@ -859,8 +860,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 +875,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 +909,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 +925,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/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/airzone_cloud/strings.json

@@ -34,7 +34,7 @@
         "state": {
           "off": "[%key:common::state::off%]",
           "on": "[%key:common::state::on%]",
-          "auto": "Auto"
+          "auto": "[%key:common::state::auto%]"
         }
       },
       "modes": {

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/anthropic/config_flow.py

@@ -52,7 +52,7 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
 
 RECOMMENDED_OPTIONS = {
     CONF_RECOMMENDED: True,
-    CONF_LLM_HASS_API: llm.LLM_API_ASSIST,
+    CONF_LLM_HASS_API: [llm.LLM_API_ASSIST],
     CONF_PROMPT: llm.DEFAULT_INSTRUCTIONS_PROMPT,
 }
 
@@ -134,9 +134,8 @@ class AnthropicOptionsFlow(OptionsFlow):
 
         if user_input is not None:
             if user_input[CONF_RECOMMENDED] == self.last_rendered_recommended:
-                if user_input[CONF_LLM_HASS_API] == "none":
-                    user_input.pop(CONF_LLM_HASS_API)
-
+                if not user_input.get(CONF_LLM_HASS_API):
+                    user_input.pop(CONF_LLM_HASS_API, None)
                 if user_input.get(
                     CONF_THINKING_BUDGET, RECOMMENDED_THINKING_BUDGET
                 ) >= user_input.get(CONF_MAX_TOKENS, RECOMMENDED_MAX_TOKENS):
@@ -151,12 +150,16 @@ class AnthropicOptionsFlow(OptionsFlow):
                 options = {
                     CONF_RECOMMENDED: user_input[CONF_RECOMMENDED],
                     CONF_PROMPT: user_input[CONF_PROMPT],
-                    CONF_LLM_HASS_API: user_input[CONF_LLM_HASS_API],
+                    CONF_LLM_HASS_API: user_input.get(CONF_LLM_HASS_API),
                 }
 
         suggested_values = options.copy()
         if not suggested_values.get(CONF_PROMPT):
             suggested_values[CONF_PROMPT] = llm.DEFAULT_INSTRUCTIONS_PROMPT
+        if (
+            suggested_llm_apis := suggested_values.get(CONF_LLM_HASS_API)
+        ) and isinstance(suggested_llm_apis, str):
+            suggested_values[CONF_LLM_HASS_API] = [suggested_llm_apis]
 
         schema = self.add_suggested_values_to_schema(
             vol.Schema(anthropic_config_option_schema(self.hass, options)),
@@ -176,24 +179,18 @@ def anthropic_config_option_schema(
 ) -> dict:
     """Return a schema for Anthropic completion options."""
     hass_apis: list[SelectOptionDict] = [
-        SelectOptionDict(
-            label="No control",
-            value="none",
-        )
-    ]
-    hass_apis.extend(
         SelectOptionDict(
             label=api.name,
             value=api.id,
         )
         for api in llm.async_get_apis(hass)
-    )
+    ]
 
     schema = {
         vol.Optional(CONF_PROMPT): TemplateSelector(),
-        vol.Optional(CONF_LLM_HASS_API, default="none"): SelectSelector(
-            SelectSelectorConfig(options=hass_apis)
-        ),
+        vol.Optional(
+            CONF_LLM_HASS_API,
+        ): SelectSelector(SelectSelectorConfig(options=hass_apis, multiple=True)),
         vol.Required(
             CONF_RECOMMENDED, default=options.get(CONF_RECOMMENDED, False)
         ): bool,

homeassistant/components/anthropic/conversation.py

@@ -266,7 +266,7 @@ async def _transform_stream(
                 raise ValueError("Unexpected stop event without a current block")
             if current_block["type"] == "tool_use":
                 tool_block = cast(ToolUseBlockParam, current_block)
-                tool_args = json.loads(current_tool_args)
+                tool_args = json.loads(current_tool_args) if current_tool_args else {}
                 tool_block["input"] = tool_args
                 yield {
                     "tool_calls": [

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/apple_tv/media_player.py

@@ -120,6 +120,7 @@ class AppleTvMediaPlayer(
         """Initialize the Apple TV media player."""
         super().__init__(name, identifier, manager)
         self._playing: Playing | None = None
+        self._playing_last_updated: datetime | None = None
         self._app_list: dict[str, str] = {}
 
     @callback
@@ -209,6 +210,7 @@ class AppleTvMediaPlayer(
         This is a callback function from pyatv.interface.PushListener.
         """
         self._playing = playstatus
+        self._playing_last_updated = dt_util.utcnow()
         self.async_write_ha_state()
 
     @callback
@@ -316,7 +318,7 @@ class AppleTvMediaPlayer(
     def media_position_updated_at(self) -> datetime | None:
         """Last valid time of media position."""
         if self.state in {MediaPlayerState.PLAYING, MediaPlayerState.PAUSED}:
-            return dt_util.utcnow()
+            return self._playing_last_updated
         return None
 
     async def async_play_media(

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/aranet/strings.json

@@ -26,7 +26,7 @@
     "sensor": {
       "threshold": {
         "state": {
-          "error": "Error",
+          "error": "[%key:common::state::error%]",
           "green": "Green",
           "yellow": "Yellow",
           "red": "Red"

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/backup/onboarding.py

@@ -0,0 +1,136 @@
+"""Backup onboarding views."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Coroutine
+from functools import wraps
+from http import HTTPStatus
+from typing import TYPE_CHECKING, Any, Concatenate
+
+from aiohttp import web
+from aiohttp.web_exceptions import HTTPUnauthorized
+import voluptuous as vol
+
+from homeassistant.components.http import KEY_HASS
+from homeassistant.components.http.data_validator import RequestDataValidator
+from homeassistant.components.onboarding import (
+    BaseOnboardingView,
+    NoAuthBaseOnboardingView,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.backup import async_get_manager as async_get_backup_manager
+
+from . import BackupManager, Folder, IncorrectPasswordError, http as backup_http
+
+if TYPE_CHECKING:
+    from homeassistant.components.onboarding import OnboardingStoreData
+
+
+async def async_setup_views(hass: HomeAssistant, data: OnboardingStoreData) -> None:
+    """Set up the backup views."""
+
+    hass.http.register_view(BackupInfoView(data))
+    hass.http.register_view(RestoreBackupView(data))
+    hass.http.register_view(UploadBackupView(data))
+
+
+def with_backup_manager[_ViewT: BaseOnboardingView, **_P](
+    func: Callable[
+        Concatenate[_ViewT, BackupManager, web.Request, _P],
+        Coroutine[Any, Any, web.Response],
+    ],
+) -> Callable[Concatenate[_ViewT, web.Request, _P], Coroutine[Any, Any, web.Response]]:
+    """Home Assistant API decorator to check onboarding and inject manager."""
+
+    @wraps(func)
+    async def with_backup(
+        self: _ViewT,
+        request: web.Request,
+        *args: _P.args,
+        **kwargs: _P.kwargs,
+    ) -> web.Response:
+        """Check admin and call function."""
+        if self._data["done"]:
+            raise HTTPUnauthorized
+
+        manager = await async_get_backup_manager(request.app[KEY_HASS])
+        return await func(self, manager, request, *args, **kwargs)
+
+    return with_backup
+
+
+class BackupInfoView(NoAuthBaseOnboardingView):
+    """Get backup info view."""
+
+    url = "/api/onboarding/backup/info"
+    name = "api:onboarding:backup:info"
+
+    @with_backup_manager
+    async def get(self, manager: BackupManager, request: web.Request) -> web.Response:
+        """Return backup info."""
+        backups, _ = await manager.async_get_backups()
+        return self.json(
+            {
+                "backups": list(backups.values()),
+                "state": manager.state,
+                "last_action_event": manager.last_action_event,
+            }
+        )
+
+
+class RestoreBackupView(NoAuthBaseOnboardingView):
+    """Restore backup view."""
+
+    url = "/api/onboarding/backup/restore"
+    name = "api:onboarding:backup:restore"
+
+    @RequestDataValidator(
+        vol.Schema(
+            {
+                vol.Required("backup_id"): str,
+                vol.Required("agent_id"): str,
+                vol.Optional("password"): str,
+                vol.Optional("restore_addons"): [str],
+                vol.Optional("restore_database", default=True): bool,
+                vol.Optional("restore_folders"): [vol.Coerce(Folder)],
+            }
+        )
+    )
+    @with_backup_manager
+    async def post(
+        self, manager: BackupManager, request: web.Request, data: dict[str, Any]
+    ) -> web.Response:
+        """Restore a backup."""
+        try:
+            await manager.async_restore_backup(
+                data["backup_id"],
+                agent_id=data["agent_id"],
+                password=data.get("password"),
+                restore_addons=data.get("restore_addons"),
+                restore_database=data["restore_database"],
+                restore_folders=data.get("restore_folders"),
+                restore_homeassistant=True,
+            )
+        except IncorrectPasswordError:
+            return self.json(
+                {"code": "incorrect_password"}, status_code=HTTPStatus.BAD_REQUEST
+            )
+        except HomeAssistantError as err:
+            return self.json(
+                {"code": "restore_failed", "message": str(err)},
+                status_code=HTTPStatus.BAD_REQUEST,
+            )
+        return web.Response(status=HTTPStatus.OK)
+
+
+class UploadBackupView(NoAuthBaseOnboardingView, backup_http.UploadBackupView):
+    """Upload backup view."""
+
+    url = "/api/onboarding/backup/upload"
+    name = "api:onboarding:backup:upload"
+
+    @with_backup_manager
+    async def post(self, manager: BackupManager, request: web.Request) -> web.Response:
+        """Upload a backup file."""
+        return await self._post(request)

homeassistant/components/baf/strings.json

@@ -31,7 +31,7 @@
         "state_attributes": {
           "preset_mode": {
             "state": {
-              "auto": "[%key:component::climate::entity_component::_::state_attributes::fan_mode::state::auto%]"
+              "auto": "[%key:common::state::auto%]"
             }
           }
         }

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/blue_current/strings.json

@@ -30,7 +30,7 @@
           "available": "Available",
           "charging": "[%key:common::state::charging%]",
           "unavailable": "Unavailable",
-          "error": "Error",
+          "error": "[%key:common::state::error%]",
           "offline": "Offline"
         }
       },
@@ -41,7 +41,7 @@
           "vehicle_detected": "Detected",
           "ready": "Ready",
           "no_power": "No power",
-          "vehicle_error": "Error"
+          "vehicle_error": "[%key:common::state::error%]"
         }
       },
       "actual_v1": {

homeassistant/components/bluesound/manifest.json

@@ -6,7 +6,7 @@
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/bluesound",
   "iot_class": "local_polling",
-  "requirements": ["pyblu==2.0.0"],
+  "requirements": ["pyblu==2.0.1"],
   "zeroconf": [
     {
       "type": "_musc._tcp.local."

homeassistant/components/bluesound/media_player.py

@@ -330,7 +330,12 @@ class BluesoundPlayer(CoordinatorEntity[BluesoundCoordinator], MediaPlayerEntity
 
         if self._status.input_id is not None:
             for input_ in self._inputs:
-                if input_.id == self._status.input_id:
+                # the input might not have an id => also try to match on the stream_url/url
+                # we have to use both because neither matches all the time
+                if (
+                    input_.id == self._status.input_id
+                    or input_.url == self._status.stream_url
+                ):
                     return input_.text
 
         for preset in self._presets:
@@ -501,18 +506,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,8 +19,8 @@
     "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"
+    "habluetooth==3.39.0"
   ]
 }

homeassistant/components/bluetooth/passive_update_processor.py

@@ -374,6 +374,27 @@ class PassiveBluetoothProcessorCoordinator[_DataT](BasePassiveBluetoothCoordinat
             self.logger.exception("Unexpected error updating %s data", self.name)
             return
 
+        self._process_update(update, was_available)
+
+    @callback
+    def async_set_updated_data(self, update: _DataT) -> None:
+        """Manually update the processor with new data.
+
+        If the data comes in via a different method, like a
+        notification, this method can be used to update the
+        processor with the new data.
+
+        This is useful for devices that retrieve
+        some of their data via notifications.
+        """
+        was_available = self._available
+        self._available = True
+        self._process_update(update, was_available)
+
+    def _process_update(
+        self, update: _DataT, was_available: bool | None = None
+    ) -> None:
+        """Process the update from the bluetooth device."""
         if not self.last_update_success:
             self.last_update_success = True
             self.logger.info("Coordinator %s recovered", self.name)

homeassistant/components/bmw_connected_drive/strings.json

@@ -139,7 +139,7 @@
         "state": {
           "default": "Default",
           "charging": "[%key:common::state::charging%]",
-          "error": "Error",
+          "error": "[%key:common::state::error%]",
           "complete": "Complete",
           "fully_charged": "Fully charged",
           "finished_fully_charged": "Finished, fully charged",

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/buienradar/util.py

@@ -12,6 +12,7 @@ from buienradar.constants import (
     CONDITION,
     CONTENT,
     DATA,
+    FEELTEMPERATURE,
     FORECAST,
     HUMIDITY,
     MESSAGE,
@@ -22,6 +23,7 @@ from buienradar.constants import (
     TEMPERATURE,
     VISIBILITY,
     WINDAZIMUTH,
+    WINDGUST,
     WINDSPEED,
 )
 from buienradar.urls import JSON_FEED_URL, json_precipitation_forecast_url
@@ -200,6 +202,14 @@ class BrData:
         except (ValueError, TypeError):
             return None
 
+    @property
+    def feeltemperature(self):
+        """Return the feeltemperature, or None."""
+        try:
+            return float(self.data.get(FEELTEMPERATURE))
+        except (ValueError, TypeError):
+            return None
+
     @property
     def pressure(self):
         """Return the pressure, or None."""
@@ -224,6 +234,14 @@ class BrData:
         except (ValueError, TypeError):
             return None
 
+    @property
+    def wind_gust(self):
+        """Return the windgust, or None."""
+        try:
+            return float(self.data.get(WINDGUST))
+        except (ValueError, TypeError):
+            return None
+
     @property
     def wind_speed(self):
         """Return the windspeed, or None."""

homeassistant/components/buienradar/weather.py

@@ -9,6 +9,7 @@ from buienradar.constants import (
     MAX_TEMP,
     MIN_TEMP,
     RAIN,
+    RAIN_CHANCE,
     WINDAZIMUTH,
     WINDSPEED,
 )
@@ -33,6 +34,7 @@ from homeassistant.components.weather import (
     ATTR_FORECAST_NATIVE_TEMP,
     ATTR_FORECAST_NATIVE_TEMP_LOW,
     ATTR_FORECAST_NATIVE_WIND_SPEED,
+    ATTR_FORECAST_PRECIPITATION_PROBABILITY,
     ATTR_FORECAST_TIME,
     ATTR_FORECAST_WIND_BEARING,
     Forecast,
@@ -153,7 +155,9 @@ class BrWeather(WeatherEntity):
         )
         self._attr_native_pressure = data.pressure
         self._attr_native_temperature = data.temperature
+        self._attr_native_apparent_temperature = data.feeltemperature
         self._attr_native_visibility = data.visibility
+        self._attr_native_wind_gust_speed = data.wind_gust
         self._attr_native_wind_speed = data.wind_speed
         self._attr_wind_bearing = data.wind_bearing
 
@@ -188,6 +192,7 @@ class BrWeather(WeatherEntity):
                 ATTR_FORECAST_NATIVE_TEMP_LOW: data_in.get(MIN_TEMP),
                 ATTR_FORECAST_NATIVE_TEMP: data_in.get(MAX_TEMP),
                 ATTR_FORECAST_NATIVE_PRECIPITATION: data_in.get(RAIN),
+                ATTR_FORECAST_PRECIPITATION_PROBABILITY: data_in.get(RAIN_CHANCE),
                 ATTR_FORECAST_WIND_BEARING: data_in.get(WINDAZIMUTH),
                 ATTR_FORECAST_NATIVE_WIND_SPEED: data_in.get(WINDSPEED),
             }

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

@@ -28,10 +28,10 @@
       "name": "Thermostat",
       "state": {
         "off": "[%key:common::state::off%]",
+        "auto": "[%key:common::state::auto%]",
         "heat": "Heat",
         "cool": "Cool",
         "heat_cool": "Heat/Cool",
-        "auto": "Auto",
         "dry": "Dry",
         "fan_only": "Fan only"
       },
@@ -50,10 +50,10 @@
           "state": {
             "off": "[%key:common::state::off%]",
             "on": "[%key:common::state::on%]",
-            "auto": "Auto",
-            "low": "Low",
-            "medium": "Medium",
-            "high": "High",
+            "auto": "[%key:common::state::auto%]",
+            "low": "[%key:common::state::low%]",
+            "medium": "[%key:common::state::medium%]",
+            "high": "[%key:common::state::high%]",
             "top": "Top",
             "middle": "Middle",
             "focus": "Focus",
@@ -69,13 +69,13 @@
         "hvac_action": {
           "name": "Current action",
           "state": {
+            "off": "[%key:common::state::off%]",
+            "idle": "[%key:common::state::idle%]",
             "cooling": "Cooling",
             "defrosting": "Defrosting",
             "drying": "Drying",
             "fan": "Fan",
             "heating": "Heating",
-            "idle": "[%key:common::state::idle%]",
-            "off": "[%key:common::state::off%]",
             "preheating": "Preheating"
           }
         },
@@ -258,7 +258,7 @@
     "hvac_mode": {
       "options": {
         "off": "[%key:common::state::off%]",
-        "auto": "Auto",
+        "auto": "[%key:common::state::auto%]",
         "cool": "Cool",
         "dry": "Dry",
         "fan_only": "Fan only",

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/cloud/onboarding.py

@@ -0,0 +1,110 @@
+"""Cloud onboarding views."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Coroutine
+from functools import wraps
+from typing import TYPE_CHECKING, Any, Concatenate
+
+from aiohttp import web
+from aiohttp.web_exceptions import HTTPUnauthorized
+
+from homeassistant.components.http import KEY_HASS
+from homeassistant.components.onboarding import (
+    BaseOnboardingView,
+    NoAuthBaseOnboardingView,
+)
+from homeassistant.core import HomeAssistant
+
+from . import http_api as cloud_http
+from .const import DATA_CLOUD
+
+if TYPE_CHECKING:
+    from homeassistant.components.onboarding import OnboardingStoreData
+
+
+async def async_setup_views(hass: HomeAssistant, data: OnboardingStoreData) -> None:
+    """Set up the cloud views."""
+
+    hass.http.register_view(CloudForgotPasswordView(data))
+    hass.http.register_view(CloudLoginView(data))
+    hass.http.register_view(CloudLogoutView(data))
+    hass.http.register_view(CloudStatusView(data))
+
+
+def ensure_not_done[_ViewT: BaseOnboardingView, **_P](
+    func: Callable[
+        Concatenate[_ViewT, web.Request, _P],
+        Coroutine[Any, Any, web.Response],
+    ],
+) -> Callable[Concatenate[_ViewT, web.Request, _P], Coroutine[Any, Any, web.Response]]:
+    """Home Assistant API decorator to check onboarding and cloud."""
+
+    @wraps(func)
+    async def _ensure_not_done(
+        self: _ViewT,
+        request: web.Request,
+        *args: _P.args,
+        **kwargs: _P.kwargs,
+    ) -> web.Response:
+        """Check onboarding status, cloud and call function."""
+        if self._data["done"]:
+            # If at least one onboarding step is done, we don't allow accessing
+            # the cloud onboarding views.
+            raise HTTPUnauthorized
+
+        return await func(self, request, *args, **kwargs)
+
+    return _ensure_not_done
+
+
+class CloudForgotPasswordView(
+    NoAuthBaseOnboardingView, cloud_http.CloudForgotPasswordView
+):
+    """View to start Forgot Password flow."""
+
+    url = "/api/onboarding/cloud/forgot_password"
+    name = "api:onboarding:cloud:forgot_password"
+
+    @ensure_not_done
+    async def post(self, request: web.Request) -> web.Response:
+        """Handle forgot password request."""
+        return await super()._post(request)
+
+
+class CloudLoginView(NoAuthBaseOnboardingView, cloud_http.CloudLoginView):
+    """Login to Home Assistant Cloud."""
+
+    url = "/api/onboarding/cloud/login"
+    name = "api:onboarding:cloud:login"
+
+    @ensure_not_done
+    async def post(self, request: web.Request) -> web.Response:
+        """Handle login request."""
+        return await super()._post(request)
+
+
+class CloudLogoutView(NoAuthBaseOnboardingView, cloud_http.CloudLogoutView):
+    """Log out of the Home Assistant cloud."""
+
+    url = "/api/onboarding/cloud/logout"
+    name = "api:onboarding:cloud:logout"
+
+    @ensure_not_done
+    async def post(self, request: web.Request) -> web.Response:
+        """Handle logout request."""
+        return await super()._post(request)
+
+
+class CloudStatusView(NoAuthBaseOnboardingView):
+    """Get cloud status view."""
+
+    url = "/api/onboarding/cloud/status"
+    name = "api:onboarding:cloud:status"
+
+    @ensure_not_done
+    async def get(self, request: web.Request) -> web.Response:
+        """Return cloud status."""
+        hass = request.app[KEY_HASS]
+        cloud = hass.data[DATA_CLOUD]
+        return self.json({"logged_in": cloud.is_logged_in})

homeassistant/components/comelit/alarm_control_panel.py

@@ -83,7 +83,6 @@ class ComelitAlarmEntity(CoordinatorEntity[ComelitVedoSystem], AlarmControlPanel
         config_entry_entry_id: str,
     ) -> None:
         """Initialize the alarm panel."""
-        self._api = coordinator.api
         self._area_index = area.index
         super().__init__(coordinator)
         # Use config_entry.entry_id as base for unique_id
@@ -137,30 +136,38 @@ class ComelitAlarmEntity(CoordinatorEntity[ComelitVedoSystem], AlarmControlPanel
 
     async def async_alarm_disarm(self, code: str | None = None) -> None:
         """Send disarm command."""
-        if code != str(self._api.device_pin):
+        if code != str(self.coordinator.api.device_pin):
             return
-        await self._api.set_zone_status(self._area.index, ALARM_ACTIONS[DISABLE])
+        await self.coordinator.api.set_zone_status(
+            self._area.index, ALARM_ACTIONS[DISABLE]
+        )
         await self._async_update_state(
             AlarmAreaState.DISARMED, ALARM_AREA_ARMED_STATUS[DISABLE]
         )
 
     async def async_alarm_arm_away(self, code: str | None = None) -> None:
         """Send arm away command."""
-        await self._api.set_zone_status(self._area.index, ALARM_ACTIONS[AWAY])
+        await self.coordinator.api.set_zone_status(
+            self._area.index, ALARM_ACTIONS[AWAY]
+        )
         await self._async_update_state(
             AlarmAreaState.ARMED, ALARM_AREA_ARMED_STATUS[AWAY]
         )
 
     async def async_alarm_arm_home(self, code: str | None = None) -> None:
         """Send arm home command."""
-        await self._api.set_zone_status(self._area.index, ALARM_ACTIONS[HOME])
+        await self.coordinator.api.set_zone_status(
+            self._area.index, ALARM_ACTIONS[HOME]
+        )
         await self._async_update_state(
             AlarmAreaState.ARMED, ALARM_AREA_ARMED_STATUS[HOME_P1]
         )
 
     async def async_alarm_arm_night(self, code: str | None = None) -> None:
         """Send arm night command."""
-        await self._api.set_zone_status(self._area.index, ALARM_ACTIONS[NIGHT])
+        await self.coordinator.api.set_zone_status(
+            self._area.index, ALARM_ACTIONS[NIGHT]
+        )
         await self._async_update_state(
             AlarmAreaState.ARMED, ALARM_AREA_ARMED_STATUS[NIGHT]
         )

homeassistant/components/comelit/binary_sensor.py

@@ -50,7 +50,6 @@ class ComelitVedoBinarySensorEntity(
         config_entry_entry_id: str,
     ) -> None:
         """Init sensor entity."""
-        self._api = coordinator.api
         self._zone_index = zone.index
         super().__init__(coordinator)
         # Use config_entry.entry_id as base for unique_id

homeassistant/components/comelit/climate.py

@@ -19,10 +19,10 @@ from homeassistant.const import ATTR_TEMPERATURE, PRECISION_TENTHS
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .const import DOMAIN
 from .coordinator import ComelitConfigEntry, ComelitSerialBridge
+from .entity import ComelitBridgeBaseEntity
 
 # Coordinator is used to centralize the data updates
 PARALLEL_UPDATES = 0
@@ -89,7 +89,7 @@ async def async_setup_entry(
     )
 
 
-class ComelitClimateEntity(CoordinatorEntity[ComelitSerialBridge], ClimateEntity):
+class ComelitClimateEntity(ComelitBridgeBaseEntity, ClimateEntity):
     """Climate device."""
 
     _attr_hvac_modes = [HVACMode.AUTO, HVACMode.COOL, HVACMode.HEAT, HVACMode.OFF]
@@ -102,7 +102,6 @@ class ComelitClimateEntity(CoordinatorEntity[ComelitSerialBridge], ClimateEntity
     )
     _attr_target_temperature_step = PRECISION_TENTHS
     _attr_temperature_unit = UnitOfTemperature.CELSIUS
-    _attr_has_entity_name = True
     _attr_name = None
 
     def __init__(
@@ -112,13 +111,7 @@ class ComelitClimateEntity(CoordinatorEntity[ComelitSerialBridge], ClimateEntity
         config_entry_entry_id: str,
     ) -> None:
         """Init light entity."""
-        self._api = coordinator.api
-        self._device = device
-        super().__init__(coordinator)
-        # Use config_entry.entry_id as base for unique_id
-        # because no serial number or mac is available
-        self._attr_unique_id = f"{config_entry_entry_id}-{device.index}"
-        self._attr_device_info = coordinator.platform_device_info(device, device.type)
+        super().__init__(coordinator, device, config_entry_entry_id)
         self._update_attributes()
 
     def _update_attributes(self) -> None:

homeassistant/components/comelit/config_flow.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from asyncio.exceptions import TimeoutError
 from collections.abc import Mapping
 from typing import Any
 
@@ -53,10 +54,18 @@ async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> dict[str,
 
     try:
         await api.login()
-    except aiocomelit_exceptions.CannotConnect as err:
-        raise CannotConnect from err
+    except (aiocomelit_exceptions.CannotConnect, TimeoutError) as err:
+        raise CannotConnect(
+            translation_domain=DOMAIN,
+            translation_key="cannot_connect",
+            translation_placeholders={"error": repr(err)},
+        ) from err
     except aiocomelit_exceptions.CannotAuthenticate as err:
-        raise InvalidAuth from err
+        raise InvalidAuth(
+            translation_domain=DOMAIN,
+            translation_key="cannot_authenticate",
+            translation_placeholders={"error": repr(err)},
+        ) from err
     finally:
         await api.logout()
         await api.close()

homeassistant/components/comelit/cover.py

@@ -11,9 +11,9 @@ from homeassistant.components.cover import CoverDeviceClass, CoverEntity, CoverS
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.restore_state import RestoreEntity
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .coordinator import ComelitConfigEntry, ComelitSerialBridge
+from .entity import ComelitBridgeBaseEntity
 
 # Coordinator is used to centralize the data updates
 PARALLEL_UPDATES = 0
@@ -34,13 +34,10 @@ async def async_setup_entry(
     )
 
 
-class ComelitCoverEntity(
-    CoordinatorEntity[ComelitSerialBridge], RestoreEntity, CoverEntity
-):
+class ComelitCoverEntity(ComelitBridgeBaseEntity, RestoreEntity, CoverEntity):
     """Cover device."""
 
     _attr_device_class = CoverDeviceClass.SHUTTER
-    _attr_has_entity_name = True
     _attr_name = None
 
     def __init__(
@@ -50,13 +47,7 @@ class ComelitCoverEntity(
         config_entry_entry_id: str,
     ) -> None:
         """Init cover entity."""
-        self._api = coordinator.api
-        self._device = device
-        super().__init__(coordinator)
-        # Use config_entry.entry_id as base for unique_id
-        # because no serial number or mac is available
-        self._attr_unique_id = f"{config_entry_entry_id}-{device.index}"
-        self._attr_device_info = coordinator.platform_device_info(device, device.type)
+        super().__init__(coordinator, device, config_entry_entry_id)
         # Device doesn't provide a status so we assume UNKNOWN at first startup
         self._last_action: int | None = None
         self._last_state: str | None = None
@@ -101,7 +92,7 @@ class ComelitCoverEntity(
     async def _cover_set_state(self, action: int, state: int) -> None:
         """Set desired cover state."""
         self._last_state = self.state
-        await self._api.set_device_status(COVER, self._device.index, action)
+        await self.coordinator.api.set_device_status(COVER, self._device.index, action)
         self.coordinator.data[COVER][self._device.index].status = state
         self.async_write_ha_state()
 

homeassistant/components/comelit/entity.py

@@ -0,0 +1,29 @@
+"""Base entity for Comelit."""
+
+from __future__ import annotations
+
+from aiocomelit import ComelitSerialBridgeObject
+
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .coordinator import ComelitSerialBridge
+
+
+class ComelitBridgeBaseEntity(CoordinatorEntity[ComelitSerialBridge]):
+    """Comelit Bridge base entity."""
+
+    _attr_has_entity_name = True
+
+    def __init__(
+        self,
+        coordinator: ComelitSerialBridge,
+        device: ComelitSerialBridgeObject,
+        config_entry_entry_id: str,
+    ) -> None:
+        """Init cover entity."""
+        self._device = device
+        super().__init__(coordinator)
+        # Use config_entry.entry_id as base for unique_id
+        # because no serial number or mac is available
+        self._attr_unique_id = f"{config_entry_entry_id}-{device.index}"
+        self._attr_device_info = coordinator.platform_device_info(device, device.type)

homeassistant/components/comelit/humidifier.py

@@ -19,10 +19,10 @@ from homeassistant.components.humidifier import (
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .const import DOMAIN
 from .coordinator import ComelitConfigEntry, ComelitSerialBridge
+from .entity import ComelitBridgeBaseEntity
 
 # Coordinator is used to centralize the data updates
 PARALLEL_UPDATES = 0
@@ -92,14 +92,13 @@ async def async_setup_entry(
     async_add_entities(entities)
 
 
-class ComelitHumidifierEntity(CoordinatorEntity[ComelitSerialBridge], HumidifierEntity):
+class ComelitHumidifierEntity(ComelitBridgeBaseEntity, HumidifierEntity):
     """Humidifier device."""
 
     _attr_supported_features = HumidifierEntityFeature.MODES
     _attr_available_modes = [MODE_NORMAL, MODE_AUTO]
     _attr_min_humidity = 10
     _attr_max_humidity = 90
-    _attr_has_entity_name = True
 
     def __init__(
         self,
@@ -112,13 +111,8 @@ class ComelitHumidifierEntity(CoordinatorEntity[ComelitSerialBridge], Humidifier
         device_class: HumidifierDeviceClass,
     ) -> None:
         """Init light entity."""
-        self._api = coordinator.api
-        self._device = device
-        super().__init__(coordinator)
-        # Use config_entry.entry_id as base for unique_id
-        # because no serial number or mac is available
+        super().__init__(coordinator, device, config_entry_entry_id)
         self._attr_unique_id = f"{config_entry_entry_id}-{device.index}-{device_class}"
-        self._attr_device_info = coordinator.platform_device_info(device, device_class)
         self._attr_device_class = device_class
         self._attr_translation_key = device_class.value
         self._active_mode = active_mode
@@ -162,7 +156,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 +184,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/light.py

@@ -4,15 +4,14 @@ from __future__ import annotations
 
 from typing import Any, cast
 
-from aiocomelit import ComelitSerialBridgeObject
 from aiocomelit.const import LIGHT, STATE_OFF, STATE_ON
 
 from homeassistant.components.light import ColorMode, LightEntity
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .coordinator import ComelitConfigEntry, ComelitSerialBridge
+from .entity import ComelitBridgeBaseEntity
 
 # Coordinator is used to centralize the data updates
 PARALLEL_UPDATES = 0
@@ -33,29 +32,13 @@ async def async_setup_entry(
     )
 
 
-class ComelitLightEntity(CoordinatorEntity[ComelitSerialBridge], LightEntity):
+class ComelitLightEntity(ComelitBridgeBaseEntity, LightEntity):
     """Light device."""
 
     _attr_color_mode = ColorMode.ONOFF
-    _attr_has_entity_name = True
     _attr_name = None
     _attr_supported_color_modes = {ColorMode.ONOFF}
 
-    def __init__(
-        self,
-        coordinator: ComelitSerialBridge,
-        device: ComelitSerialBridgeObject,
-        config_entry_entry_id: str,
-    ) -> None:
-        """Init light entity."""
-        self._api = coordinator.api
-        self._device = device
-        super().__init__(coordinator)
-        # Use config_entry.entry_id as base for unique_id
-        # because no serial number or mac is available
-        self._attr_unique_id = f"{config_entry_entry_id}-{device.index}"
-        self._attr_device_info = coordinator.platform_device_info(device, device.type)
-
     async def _light_set_state(self, state: int) -> None:
         """Set desired light state."""
         await self.coordinator.api.set_device_status(LIGHT, self._device.index, state)

homeassistant/components/comelit/manifest.json

@@ -7,5 +7,6 @@
   "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["aiocomelit"],
+  "quality_scale": "bronze",
   "requirements": ["aiocomelit==0.11.3"]
 }

homeassistant/components/comelit/quality_scale.yaml

@@ -0,0 +1,92 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: no actions
+  appropriate-polling: done
+  brands: done
+  common-modules: done
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: done
+  docs-actions:
+    status: exempt
+    comment: no actions
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup:
+    status: exempt
+    comment: no events
+  entity-unique-id: done
+  has-entity-name: done
+  runtime-data: done
+  test-before-configure: done
+  test-before-setup: done
+  unique-config-entry: done
+
+  # Silver
+  action-exceptions:
+    status: todo
+    comment: wrap api calls in try block
+  config-entry-unloading: done
+  docs-configuration-parameters:
+    status: exempt
+    comment: no configuration parameters
+  docs-installation-parameters: done
+  entity-unavailable: done
+  integration-owner: done
+  log-when-unavailable: done
+  parallel-updates: done
+  reauthentication-flow: done
+  test-coverage: done
+
+  # Gold
+  devices: done
+  diagnostics: done
+  discovery-update-info:
+    status: exempt
+    comment: device not discoverable
+  discovery:
+    status: exempt
+    comment: device not discoverable
+  docs-data-update: done
+  docs-examples: done
+  docs-known-limitations:
+    status: exempt
+    comment: no known limitations, yet
+  docs-supported-devices:
+    status: todo
+    comment: review and complete missing ones
+  docs-supported-functions: todo
+  docs-troubleshooting: done
+  docs-use-cases: done
+  dynamic-devices:
+    status: todo
+    comment: missing implementation
+  entity-category:
+    status: todo
+    comment: PR in progress
+  entity-device-class: done
+  entity-disabled-by-default: done
+  entity-translations: done
+  exception-translations:
+    status: todo
+    comment: PR in progress
+  icon-translations: done
+  reconfiguration-flow:
+    status: todo
+    comment: PR in progress
+  repair-issues:
+    status: exempt
+    comment: no known use cases for repair issues or flows, yet
+  stale-devices:
+    status: todo
+    comment: missing implementation
+
+  # Platinum
+  async-dependency: done
+  inject-websession:
+    status: todo
+    comment: implement aiohttp_client.async_create_clientsession
+  strict-typing: done

homeassistant/components/comelit/sensor.py

@@ -19,6 +19,7 @@ from homeassistant.helpers.typing import StateType
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .coordinator import ComelitConfigEntry, ComelitSerialBridge, ComelitVedoSystem
+from .entity import ComelitBridgeBaseEntity
 
 # Coordinator is used to centralize the data updates
 PARALLEL_UPDATES = 0
@@ -95,10 +96,9 @@ async def async_setup_vedo_entry(
     async_add_entities(entities)
 
 
-class ComelitBridgeSensorEntity(CoordinatorEntity[ComelitSerialBridge], SensorEntity):
+class ComelitBridgeSensorEntity(ComelitBridgeBaseEntity, SensorEntity):
     """Sensor device."""
 
-    _attr_has_entity_name = True
     _attr_name = None
 
     def __init__(
@@ -109,13 +109,7 @@ class ComelitBridgeSensorEntity(CoordinatorEntity[ComelitSerialBridge], SensorEn
         description: SensorEntityDescription,
     ) -> None:
         """Init sensor entity."""
-        self._api = coordinator.api
-        self._device = device
-        super().__init__(coordinator)
-        # Use config_entry.entry_id as base for unique_id
-        # because no serial number or mac is available
-        self._attr_unique_id = f"{config_entry_entry_id}-{device.index}"
-        self._attr_device_info = coordinator.platform_device_info(device, device.type)
+        super().__init__(coordinator, device, config_entry_entry_id)
 
         self.entity_description = description
 
@@ -144,7 +138,6 @@ class ComelitVedoSensorEntity(CoordinatorEntity[ComelitVedoSystem], SensorEntity
         description: SensorEntityDescription,
     ) -> None:
         """Init sensor entity."""
-        self._api = coordinator.api
         self._zone_index = zone.index
         super().__init__(coordinator)
         # Use config_entry.entry_id as base for unique_id

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"
       },
@@ -67,6 +69,12 @@
     },
     "invalid_clima_data": {
       "message": "Invalid 'clima' data"
+    },
+    "cannot_connect": {
+      "message": "Error connecting: {error}"
+    },
+    "cannot_authenticate": {
+      "message": "Error authenticating: {error}"
     }
   }
 }

homeassistant/components/comelit/switch.py

@@ -10,9 +10,9 @@ from aiocomelit.const import IRRIGATION, OTHER, STATE_OFF, STATE_ON
 from homeassistant.components.switch import SwitchDeviceClass, SwitchEntity
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .coordinator import ComelitConfigEntry, ComelitSerialBridge
+from .entity import ComelitBridgeBaseEntity
 
 # Coordinator is used to centralize the data updates
 PARALLEL_UPDATES = 0
@@ -39,10 +39,9 @@ async def async_setup_entry(
     async_add_entities(entities)
 
 
-class ComelitSwitchEntity(CoordinatorEntity[ComelitSerialBridge], SwitchEntity):
+class ComelitSwitchEntity(ComelitBridgeBaseEntity, SwitchEntity):
     """Switch device."""
 
-    _attr_has_entity_name = True
     _attr_name = None
 
     def __init__(
@@ -52,13 +51,8 @@ class ComelitSwitchEntity(CoordinatorEntity[ComelitSerialBridge], SwitchEntity):
         config_entry_entry_id: str,
     ) -> None:
         """Init switch entity."""
-        self._api = coordinator.api
-        self._device = device
-        super().__init__(coordinator)
-        # Use config_entry.entry_id as base for unique_id
-        # because no serial number or mac is available
+        super().__init__(coordinator, device, config_entry_entry_id)
         self._attr_unique_id = f"{config_entry_entry_id}-{device.type}-{device.index}"
-        self._attr_device_info = coordinator.platform_device_info(device, device.type)
         if device.type == OTHER:
             self._attr_device_class = SwitchDeviceClass.OUTLET
 
@@ -81,4 +75,7 @@ class ComelitSwitchEntity(CoordinatorEntity[ComelitSerialBridge], SwitchEntity):
     @property
     def is_on(self) -> bool:
         """Return True if switch is on."""
-        return self.coordinator.data[OTHER][self._device.index].status == STATE_ON
+        return (
+            self.coordinator.data[self._device.type][self._device.index].status
+            == STATE_ON
+        )

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

@@ -197,6 +197,7 @@ class ChatLog:
                 (
                     "?",
                     ";",  # Greek question mark
+                    "？",  # Chinese question mark
                 )
             )
         )
@@ -387,7 +388,7 @@ class ChatLog:
         self,
         conversing_domain: str,
         user_input: ConversationInput,
-        user_llm_hass_api: str | None = None,
+        user_llm_hass_api: str | list[str] | None = None,
         user_llm_prompt: str | None = None,
     ) -> None:
         """Set the LLM system prompt."""

homeassistant/components/cover/reproduce_state.py

@@ -73,14 +73,14 @@ async def _async_set_position(
     Returns True if the position was set, False if there is no
     supported method for setting the position.
     """
-    if target_position == FULL_CLOSE and CoverEntityFeature.CLOSE in features:
-        await service_call(SERVICE_CLOSE_COVER, service_data)
-    elif target_position == FULL_OPEN and CoverEntityFeature.OPEN in features:
-        await service_call(SERVICE_OPEN_COVER, service_data)
-    elif CoverEntityFeature.SET_POSITION in features:
+    if CoverEntityFeature.SET_POSITION in features:
         await service_call(
             SERVICE_SET_COVER_POSITION, service_data | {ATTR_POSITION: target_position}
         )
+    elif target_position == FULL_CLOSE and CoverEntityFeature.CLOSE in features:
+        await service_call(SERVICE_CLOSE_COVER, service_data)
+    elif target_position == FULL_OPEN and CoverEntityFeature.OPEN in features:
+        await service_call(SERVICE_OPEN_COVER, service_data)
     else:
         # Requested a position but the cover doesn't support it
         return False
@@ -98,15 +98,17 @@ async def _async_set_tilt_position(
     Returns True if the tilt position was set, False if there is no
     supported method for setting the tilt position.
     """
-    if target_tilt_position == FULL_CLOSE and CoverEntityFeature.CLOSE_TILT in features:
-        await service_call(SERVICE_CLOSE_COVER_TILT, service_data)
-    elif target_tilt_position == FULL_OPEN and CoverEntityFeature.OPEN_TILT in features:
-        await service_call(SERVICE_OPEN_COVER_TILT, service_data)
-    elif CoverEntityFeature.SET_TILT_POSITION in features:
+    if CoverEntityFeature.SET_TILT_POSITION in features:
         await service_call(
             SERVICE_SET_COVER_TILT_POSITION,
             service_data | {ATTR_TILT_POSITION: target_tilt_position},
         )
+    elif (
+        target_tilt_position == FULL_CLOSE and CoverEntityFeature.CLOSE_TILT in features
+    ):
+        await service_call(SERVICE_CLOSE_COVER_TILT, service_data)
+    elif target_tilt_position == FULL_OPEN and CoverEntityFeature.OPEN_TILT in features:
+        await service_call(SERVICE_OPEN_COVER_TILT, service_data)
     else:
         # Requested a tilt position but the cover doesn't support it
         return False
@@ -183,12 +185,12 @@ async def _async_reproduce_state(
     current_attrs = cur_state.attributes
     target_attrs = state.attributes
 
-    current_position = current_attrs.get(ATTR_CURRENT_POSITION)
-    target_position = target_attrs.get(ATTR_CURRENT_POSITION)
+    current_position: int | None = current_attrs.get(ATTR_CURRENT_POSITION)
+    target_position: int | None = target_attrs.get(ATTR_CURRENT_POSITION)
     position_matches = current_position == target_position
 
-    current_tilt_position = current_attrs.get(ATTR_CURRENT_TILT_POSITION)
-    target_tilt_position = target_attrs.get(ATTR_CURRENT_TILT_POSITION)
+    current_tilt_position: int | None = current_attrs.get(ATTR_CURRENT_TILT_POSITION)
+    target_tilt_position: int | None = target_attrs.get(ATTR_CURRENT_TILT_POSITION)
     tilt_position_matches = current_tilt_position == target_tilt_position
 
     state_matches = cur_state.state == target_state
@@ -214,19 +216,11 @@ async def _async_reproduce_state(
     )
     service_data = {ATTR_ENTITY_ID: entity_id}
 
-    set_position = (
-        not position_matches
-        and target_position is not None
-        and await _async_set_position(
-            service_call, service_data, features, target_position
-        )
+    set_position = target_position is not None and await _async_set_position(
+        service_call, service_data, features, target_position
     )
-    set_tilt = (
-        not tilt_position_matches
-        and target_tilt_position is not None
-        and await _async_set_tilt_position(
-            service_call, service_data, features, target_tilt_position
-        )
+    set_tilt = target_tilt_position is not None and await _async_set_tilt_position(
+        service_call, service_data, features, target_tilt_position
     )
 
     if target_state in CLOSING_STATES:

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/demo/icons.json

@@ -45,6 +45,17 @@
         }
       }
     },
+    "light": {
+      "bed_light": {
+        "state_attributes": {
+          "effect": {
+            "state": {
+              "rainbow": "mdi:looks"
+            }
+          }
+        }
+      }
+    },
     "number": {
       "volume": {
         "default": "mdi:volume-high"

homeassistant/components/demo/light.py

@@ -15,6 +15,7 @@ from homeassistant.components.light import (
     ATTR_WHITE,
     DEFAULT_MAX_KELVIN,
     DEFAULT_MIN_KELVIN,
+    EFFECT_OFF,
     ColorMode,
     LightEntity,
     LightEntityFeature,
@@ -28,7 +29,7 @@ from . import DOMAIN
 
 LIGHT_COLORS = [(56, 86), (345, 75)]
 
-LIGHT_EFFECT_LIST = ["rainbow", "none"]
+LIGHT_EFFECT_LIST = ["rainbow", EFFECT_OFF]
 
 LIGHT_TEMPS = [4166, 2631]
 
@@ -48,6 +49,7 @@ async def async_setup_entry(
                 available=True,
                 effect_list=LIGHT_EFFECT_LIST,
                 effect=LIGHT_EFFECT_LIST[0],
+                translation_key="bed_light",
                 device_name="Bed Light",
                 state=False,
                 unique_id="light_1",
@@ -119,8 +121,10 @@ class DemoLight(LightEntity):
         rgbw_color: tuple[int, int, int, int] | None = None,
         rgbww_color: tuple[int, int, int, int, int] | None = None,
         supported_color_modes: set[ColorMode] | None = None,
+        translation_key: str | None = None,
     ) -> None:
         """Initialize the light."""
+        self._attr_translation_key = translation_key
         self._available = True
         self._brightness = brightness
         self._ct = ct or random.choice(LIGHT_TEMPS)

homeassistant/components/demo/media_player.py

@@ -41,6 +41,7 @@ async def async_setup_entry(
             DemoTVShowPlayer(),
             DemoBrowsePlayer("Browse"),
             DemoGroupPlayer("Group"),
+            DemoSearchPlayer("Search"),
         ]
     )
 
@@ -95,6 +96,8 @@ NETFLIX_PLAYER_SUPPORT = (
 
 BROWSE_PLAYER_SUPPORT = MediaPlayerEntityFeature.BROWSE_MEDIA
 
+SEARCH_PLAYER_SUPPORT = MediaPlayerEntityFeature.SEARCH_MEDIA
+
 
 class AbstractDemoPlayer(MediaPlayerEntity):
     """A demo media players."""
@@ -398,3 +401,9 @@ class DemoGroupPlayer(AbstractDemoPlayer):
         | MediaPlayerEntityFeature.GROUPING
         | MediaPlayerEntityFeature.TURN_OFF
     )
+
+
+class DemoSearchPlayer(AbstractDemoPlayer):
+    """A Demo media player that supports searching."""
+
+    _attr_supported_features = SEARCH_PLAYER_SUPPORT

homeassistant/components/demo/strings.json

@@ -28,10 +28,10 @@
         "state_attributes": {
           "fan_mode": {
             "state": {
-              "auto_high": "Auto High",
-              "auto_low": "Auto Low",
-              "on_high": "On High",
-              "on_low": "On Low"
+              "auto_high": "Auto high",
+              "auto_low": "Auto low",
+              "on_high": "On high",
+              "on_low": "On low"
             }
           },
           "swing_mode": {
@@ -39,14 +39,14 @@
               "1": "1",
               "2": "2",
               "3": "3",
-              "auto": "Auto",
+              "auto": "[%key:common::state::auto%]",
               "off": "[%key:common::state::off%]"
             }
           },
           "swing_horizontal_mode": {
             "state": {
               "rangefull": "Full range",
-              "auto": "Auto",
+              "auto": "[%key:common::state::auto%]",
               "off": "[%key:common::state::off%]"
             }
           }
@@ -58,7 +58,7 @@
         "state_attributes": {
           "preset_mode": {
             "state": {
-              "auto": "[%key:component::climate::entity_component::_::state_attributes::fan_mode::state::auto%]",
+              "auto": "[%key:common::state::auto%]",
               "sleep": "[%key:component::climate::entity_component::_::state_attributes::preset_mode::state::sleep%]",
               "smart": "Smart",
               "on": "[%key:common::state::on%]"
@@ -78,12 +78,23 @@
         }
       }
     },
+    "light": {
+      "bed_light": {
+        "state_attributes": {
+          "effect": {
+            "state": {
+              "rainbow": "Rainbow"
+            }
+          }
+        }
+      }
+    },
     "select": {
       "speed": {
         "state": {
-          "light_speed": "Light Speed",
-          "ludicrous_speed": "Ludicrous Speed",
-          "ridiculous_speed": "Ridiculous Speed"
+          "light_speed": "Light speed",
+          "ludicrous_speed": "Ludicrous speed",
+          "ridiculous_speed": "Ridiculous speed"
         }
       }
     },
@@ -102,7 +113,7 @@
       "model_s": {
         "state_attributes": {
           "cleaned_area": {
-            "name": "Cleaned Area"
+            "name": "Cleaned area"
           }
         }
       }

homeassistant/components/devolo_home_network/device_tracker.py

@@ -88,6 +88,8 @@ class DevoloScannerEntity(  # pylint: disable=hass-enforce-class-module
 ):
     """Representation of a devolo device tracker."""
 
+    _attr_translation_key = "device_tracker"
+
     def __init__(
         self,
         coordinator: DevoloDataUpdateCoordinator[list[ConnectedStationInfo]],
@@ -123,13 +125,6 @@ class DevoloScannerEntity(  # pylint: disable=hass-enforce-class-module
             )
         return attrs
 
-    @property
-    def icon(self) -> str:
-        """Return device icon."""
-        if self.is_connected:
-            return "mdi:lan-connect"
-        return "mdi:lan-disconnect"
-
     @property
     def is_connected(self) -> bool:
         """Return true if the device is connected to the network."""

homeassistant/components/devolo_home_network/icons.json

@@ -13,6 +13,14 @@
         "default": "mdi:wifi-plus"
       }
     },
+    "device_tracker": {
+      "device_tracker": {
+        "default": "mdi:lan-disconnect",
+        "state": {
+          "home": "mdi:lan-connect"
+        }
+      }
+    },
     "sensor": {
       "connected_plc_devices": {
         "default": "mdi:lan"

homeassistant/components/devolo_home_network/manifest.json

@@ -8,7 +8,7 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["devolo_plc_api"],
-  "requirements": ["devolo-plc-api==1.4.1"],
+  "requirements": ["devolo-plc-api==1.5.1"],
   "zeroconf": [
     {
       "type": "_dvl-deviceapi._tcp.local.",

homeassistant/components/devolo_home_network/switch.py

@@ -114,9 +114,14 @@ class DevoloSwitchEntity[_DataT: _DataType](
                 translation_key="password_protected",
                 translation_placeholders={"title": self.entry.title},
             ) from ex
-        except DeviceUnavailable:
-            pass  # The coordinator will handle this
-        await self.coordinator.async_request_refresh()
+        except DeviceUnavailable as ex:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="no_response",
+                translation_placeholders={"title": self.entry.title},
+            ) from ex
+        finally:
+            await self.coordinator.async_request_refresh()
 
     async def async_turn_off(self, **kwargs: Any) -> None:
         """Turn the entity off."""
@@ -129,6 +134,11 @@ class DevoloSwitchEntity[_DataT: _DataType](
                 translation_key="password_protected",
                 translation_placeholders={"title": self.entry.title},
             ) from ex
-        except DeviceUnavailable:
-            pass  # The coordinator will handle this
-        await self.coordinator.async_request_refresh()
+        except DeviceUnavailable as ex:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="no_response",
+                translation_placeholders={"title": self.entry.title},
+            ) from ex
+        finally:
+            await self.coordinator.async_request_refresh()

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/doods/manifest.json

@@ -6,5 +6,5 @@
   "iot_class": "local_polling",
   "loggers": ["pydoods"],
   "quality_scale": "legacy",
-  "requirements": ["pydoods==1.0.2", "Pillow==11.1.0"]
+  "requirements": ["pydoods==1.0.2", "Pillow==11.2.1"]
 }

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/duke_energy/coordinator.py

@@ -179,22 +179,18 @@ class DukeEnergyCoordinator(DataUpdateCoordinator[None]):
         one = timedelta(days=1)
         if start_time is None:
             # Max 3 years of data
-            agreement_date = dt_util.parse_datetime(meter["agreementActiveDate"])
-            if agreement_date is None:
-                start = dt_util.now(tz) - timedelta(days=3 * 365)
-            else:
-                start = max(
-                    agreement_date.replace(tzinfo=tz),
-                    dt_util.now(tz) - timedelta(days=3 * 365),
-                )
+            start = dt_util.now(tz) - timedelta(days=3 * 365)
         else:
             start = datetime.fromtimestamp(start_time, tz=tz) - lookback
+        agreement_date = dt_util.parse_datetime(meter["agreementActiveDate"])
+        if agreement_date is not None:
+            start = max(agreement_date.replace(tzinfo=tz), start)
 
         start = start.replace(hour=0, minute=0, second=0, microsecond=0)
         end = dt_util.now(tz).replace(hour=0, minute=0, second=0, microsecond=0) - one
         _LOGGER.debug("Data lookup range: %s - %s", start, end)
 
-        start_step = end - lookback
+        start_step = max(end - lookback, start)
         end_step = end
         usage: dict[datetime, dict[str, float | int]] = {}
         while True:

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/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.NUMBER, Platform.SENSOR]
 
 
 async def async_setup_entry(