2026.3.1 (#165001)

Signed-off-by: Daniel Hjelseth Høyer <github@dahoiv.net>

.core_files.yaml

@@ -34,7 +34,6 @@ base_platforms: &base_platforms
   - homeassistant/components/humidifier/**
   - homeassistant/components/image/**
   - homeassistant/components/image_processing/**
-  - homeassistant/components/infrared/**
   - homeassistant/components/lawn_mower/**
   - homeassistant/components/light/**
   - homeassistant/components/lock/**

.github/workflows/ci.yaml

@@ -40,7 +40,7 @@ env:
   CACHE_VERSION: 3
   UV_CACHE_VERSION: 1
   MYPY_CACHE_VERSION: 1
-  HA_SHORT_VERSION: "2026.4"
+  HA_SHORT_VERSION: "2026.3"
   DEFAULT_PYTHON: "3.14.2"
   ALL_PYTHON_VERSIONS: "['3.14.2']"
   # 10.3 is the oldest supported version

.github/workflows/wheels.yml

@@ -209,4 +209,4 @@ jobs:
           skip-binary: aiohttp;charset-normalizer;grpcio;multidict;SQLAlchemy;propcache;protobuf;pymicro-vad;yarl
           constraints: "homeassistant/package_constraints.txt"
           requirements-diff: "requirements_diff.txt"
-          requirements: "requirements_all.txt"
+          requirements: "requirements_all_wheels_${{ matrix.arch }}.txt"

.strict-typing

@@ -289,7 +289,6 @@ homeassistant.components.imgw_pib.*
 homeassistant.components.immich.*
 homeassistant.components.incomfort.*
 homeassistant.components.inels.*
-homeassistant.components.infrared.*
 homeassistant.components.input_button.*
 homeassistant.components.input_select.*
 homeassistant.components.input_text.*

CODEOWNERS

@@ -794,8 +794,6 @@ build.json @home-assistant/supervisor
 /tests/components/inels/ @epdevlab
 /homeassistant/components/influxdb/ @mdegat01 @Robbie1221
 /tests/components/influxdb/ @mdegat01 @Robbie1221
-/homeassistant/components/infrared/ @home-assistant/core
-/tests/components/infrared/ @home-assistant/core
 /homeassistant/components/inkbird/ @bdraco
 /tests/components/inkbird/ @bdraco
 /homeassistant/components/input_boolean/ @home-assistant/core

codecov.yml

@@ -10,7 +10,6 @@ coverage:
         target: auto
         threshold: 1
         paths:
-          - homeassistant/components/*/backup.py
           - homeassistant/components/*/config_flow.py
           - homeassistant/components/*/device_action.py
           - homeassistant/components/*/device_condition.py
@@ -29,7 +28,6 @@ coverage:
         target: 100
         threshold: 0
         paths:
-          - homeassistant/components/*/backup.py
           - homeassistant/components/*/config_flow.py
           - homeassistant/components/*/device_action.py
           - homeassistant/components/*/device_condition.py

homeassistant/bootstrap.py

@@ -70,7 +70,7 @@ from .const import (
     SIGNAL_BOOTSTRAP_INTEGRATIONS,
 )
 from .core_config import async_process_ha_core_config
-from .exceptions import HomeAssistantError
+from .exceptions import HomeAssistantError, UnsupportedStorageVersionError
 from .helpers import (
     area_registry,
     category_registry,
@@ -239,6 +239,8 @@ DEFAULT_INTEGRATIONS = {
 }
 DEFAULT_INTEGRATIONS_RECOVERY_MODE = {
     # These integrations are set up if recovery mode is activated.
+    "backup",
+    "cloud",
     "frontend",
 }
 DEFAULT_INTEGRATIONS_SUPERVISOR = {
@@ -433,32 +435,56 @@ def _init_blocking_io_modules_in_executor() -> None:
     is_docker_env()
 
 
-async def async_load_base_functionality(hass: core.HomeAssistant) -> None:
-    """Load the registries and modules that will do blocking I/O."""
+async def async_load_base_functionality(hass: core.HomeAssistant) -> bool:
+    """Load the registries and modules that will do blocking I/O.
+
+    Return whether loading succeeded.
+    """
     if DATA_REGISTRIES_LOADED in hass.data:
-        return
+        return True
+
     hass.data[DATA_REGISTRIES_LOADED] = None
     entity.async_setup(hass)
     frame.async_setup(hass)
     template.async_setup(hass)
     translation.async_setup(hass)
-    await asyncio.gather(
-        create_eager_task(get_internal_store_manager(hass).async_initialize()),
-        create_eager_task(area_registry.async_load(hass)),
-        create_eager_task(category_registry.async_load(hass)),
-        create_eager_task(device_registry.async_load(hass)),
-        create_eager_task(entity_registry.async_load(hass)),
-        create_eager_task(floor_registry.async_load(hass)),
-        create_eager_task(issue_registry.async_load(hass)),
-        create_eager_task(label_registry.async_load(hass)),
-        hass.async_add_executor_job(_init_blocking_io_modules_in_executor),
-        create_eager_task(template.async_load_custom_templates(hass)),
-        create_eager_task(restore_state.async_load(hass)),
-        create_eager_task(hass.config_entries.async_initialize()),
-        create_eager_task(async_get_system_info(hass)),
-        create_eager_task(condition.async_setup(hass)),
-        create_eager_task(trigger.async_setup(hass)),
-    )
+
+    recovery = hass.config.recovery_mode
+    try:
+        await asyncio.gather(
+            create_eager_task(get_internal_store_manager(hass).async_initialize()),
+            create_eager_task(area_registry.async_load(hass, load_empty=recovery)),
+            create_eager_task(category_registry.async_load(hass, load_empty=recovery)),
+            create_eager_task(device_registry.async_load(hass, load_empty=recovery)),
+            create_eager_task(entity_registry.async_load(hass, load_empty=recovery)),
+            create_eager_task(floor_registry.async_load(hass, load_empty=recovery)),
+            create_eager_task(issue_registry.async_load(hass, load_empty=recovery)),
+            create_eager_task(label_registry.async_load(hass, load_empty=recovery)),
+            hass.async_add_executor_job(_init_blocking_io_modules_in_executor),
+            create_eager_task(template.async_load_custom_templates(hass)),
+            create_eager_task(restore_state.async_load(hass, load_empty=recovery)),
+            create_eager_task(hass.config_entries.async_initialize()),
+            create_eager_task(async_get_system_info(hass)),
+            create_eager_task(condition.async_setup(hass)),
+            create_eager_task(trigger.async_setup(hass)),
+        )
+    except UnsupportedStorageVersionError as err:
+        # If we're already in recovery mode, we don't want to handle the exception
+        # and activate recovery mode again, as that would lead to an infinite loop.
+        if recovery:
+            raise
+
+        _LOGGER.error(
+            "Storage file %s was created by a newer version of Home Assistant"
+            " (storage version %s > %s); activating recovery mode; on-disk data"
+            " is preserved; upgrade Home Assistant or restore from a backup",
+            err.storage_key,
+            err.found_version,
+            err.max_supported_version,
+        )
+        return False
+
+    return True
 
 
 async def async_from_config_dict(
@@ -475,7 +501,9 @@ async def async_from_config_dict(
     # Prime custom component cache early so we know if registry entries are tied
     # to a custom integration
     await loader.async_get_custom_components(hass)
-    await async_load_base_functionality(hass)
+
+    if not await async_load_base_functionality(hass):
+        return None
 
     # Set up core.
     _LOGGER.debug("Setting up %s", CORE_INTEGRATIONS)

homeassistant/brands/ubisys.json

@@ -0,0 +1,5 @@
+{
+  "domain": "ubisys",
+  "name": "Ubisys",
+  "iot_standards": ["zigbee"]
+}

homeassistant/components/abode/services.py

@@ -12,6 +12,10 @@ from homeassistant.helpers.dispatcher import dispatcher_send
 
 from .const import DOMAIN, DOMAIN_DATA, LOGGER
 
+SERVICE_SETTINGS = "change_setting"
+SERVICE_CAPTURE_IMAGE = "capture_image"
+SERVICE_TRIGGER_AUTOMATION = "trigger_automation"
+
 ATTR_SETTING = "setting"
 ATTR_VALUE = "value"
 
@@ -71,13 +75,16 @@ def async_setup_services(hass: HomeAssistant) -> None:
     """Home Assistant services."""
 
     hass.services.async_register(
-        DOMAIN, "change_setting", _change_setting, schema=CHANGE_SETTING_SCHEMA
+        DOMAIN, SERVICE_SETTINGS, _change_setting, schema=CHANGE_SETTING_SCHEMA
     )
 
     hass.services.async_register(
-        DOMAIN, "capture_image", _capture_image, schema=CAPTURE_IMAGE_SCHEMA
+        DOMAIN, SERVICE_CAPTURE_IMAGE, _capture_image, schema=CAPTURE_IMAGE_SCHEMA
     )
 
     hass.services.async_register(
-        DOMAIN, "trigger_automation", _trigger_automation, schema=AUTOMATION_SCHEMA
+        DOMAIN,
+        SERVICE_TRIGGER_AUTOMATION,
+        _trigger_automation,
+        schema=AUTOMATION_SCHEMA,
     )

homeassistant/components/accuweather/weather.py

@@ -191,7 +191,7 @@ class AccuWeatherEntity(
             {
                 ATTR_FORECAST_TIME: utc_from_timestamp(item["EpochDate"]).isoformat(),
                 ATTR_FORECAST_CLOUD_COVERAGE: item["CloudCoverDay"],
-                ATTR_FORECAST_HUMIDITY: item["RelativeHumidityDay"]["Average"],
+                ATTR_FORECAST_HUMIDITY: item["RelativeHumidityDay"].get("Average"),
                 ATTR_FORECAST_NATIVE_TEMP: item["TemperatureMax"][ATTR_VALUE],
                 ATTR_FORECAST_NATIVE_TEMP_LOW: item["TemperatureMin"][ATTR_VALUE],
                 ATTR_FORECAST_NATIVE_APPARENT_TEMP: item["RealFeelTemperatureMax"][

homeassistant/components/advantage_air/services.py

@@ -10,6 +10,8 @@ from homeassistant.helpers import config_validation as cv, service
 
 from .const import DOMAIN
 
+ADVANTAGE_AIR_SERVICE_SET_TIME_TO = "set_time_to"
+
 
 @callback
 def async_setup_services(hass: HomeAssistant) -> None:
@@ -18,7 +20,7 @@ def async_setup_services(hass: HomeAssistant) -> None:
     service.async_register_platform_entity_service(
         hass,
         DOMAIN,
-        "set_time_to",
+        ADVANTAGE_AIR_SERVICE_SET_TIME_TO,
         entity_domain=SENSOR_DOMAIN,
         schema={vol.Required("minutes"): cv.positive_int},
         func="set_time_to",

homeassistant/components/agent_dvr/services.py

@@ -8,12 +8,18 @@ from homeassistant.helpers import service
 
 from .const import DOMAIN
 
+_DEV_EN_ALT = "enable_alerts"
+_DEV_DS_ALT = "disable_alerts"
+_DEV_EN_REC = "start_recording"
+_DEV_DS_REC = "stop_recording"
+_DEV_SNAP = "snapshot"
+
 CAMERA_SERVICES = {
-    "enable_alerts": "async_enable_alerts",
-    "disable_alerts": "async_disable_alerts",
-    "start_recording": "async_start_recording",
-    "stop_recording": "async_stop_recording",
-    "snapshot": "async_snapshot",
+    _DEV_EN_ALT: "async_enable_alerts",
+    _DEV_DS_ALT: "async_disable_alerts",
+    _DEV_EN_REC: "async_start_recording",
+    _DEV_DS_REC: "async_stop_recording",
+    _DEV_SNAP: "async_snapshot",
 }
 
 

homeassistant/components/airobot/number.py

@@ -93,7 +93,6 @@ class AirobotNumber(AirobotEntity, NumberEntity):
             raise ServiceValidationError(
                 translation_domain=DOMAIN,
                 translation_key="set_value_failed",
-                translation_placeholders={"error": str(err)},
             ) from err
         else:
             await self.coordinator.async_request_refresh()

homeassistant/components/airobot/strings.json

@@ -112,7 +112,7 @@
       "message": "Failed to set temperature to {temperature}."
     },
     "set_value_failed": {
-      "message": "Failed to set value: {error}"
+      "message": "Failed to set value."
     },
     "switch_turn_off_failed": {
       "message": "Failed to turn off {switch}."

homeassistant/components/aladdin_connect/diagnostics.py

@@ -1,32 +0,0 @@
-"""Diagnostics support for Aladdin Connect."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from homeassistant.components.diagnostics import async_redact_data
-from homeassistant.core import HomeAssistant
-
-from .coordinator import AladdinConnectConfigEntry
-
-TO_REDACT = {"access_token", "refresh_token"}
-
-
-async def async_get_config_entry_diagnostics(
-    hass: HomeAssistant, config_entry: AladdinConnectConfigEntry
-) -> dict[str, Any]:
-    """Return diagnostics for a config entry."""
-    return {
-        "config_entry": async_redact_data(config_entry.as_dict(), TO_REDACT),
-        "doors": {
-            uid: {
-                "device_id": coordinator.data.device_id,
-                "door_number": coordinator.data.door_number,
-                "name": coordinator.data.name,
-                "status": coordinator.data.status,
-                "link_status": coordinator.data.link_status,
-                "battery_level": coordinator.data.battery_level,
-            }
-            for uid, coordinator in config_entry.runtime_data.items()
-        },
-    }

homeassistant/components/aladdin_connect/quality_scale.yaml

@@ -45,7 +45,7 @@ rules:
 
   # Gold
   devices: done
-  diagnostics: done
+  diagnostics: todo
   discovery: done
   discovery-update-info:
     status: exempt

homeassistant/components/alarmdecoder/services.py

@@ -13,6 +13,9 @@ from homeassistant.helpers import config_validation as cv, service
 
 from .const import DOMAIN
 
+SERVICE_ALARM_TOGGLE_CHIME = "alarm_toggle_chime"
+
+SERVICE_ALARM_KEYPRESS = "alarm_keypress"
 ATTR_KEYPRESS = "keypress"
 
 
@@ -23,7 +26,7 @@ def async_setup_services(hass: HomeAssistant) -> None:
     service.async_register_platform_entity_service(
         hass,
         DOMAIN,
-        "alarm_toggle_chime",
+        SERVICE_ALARM_TOGGLE_CHIME,
         entity_domain=ALARM_CONTROL_PANEL_DOMAIN,
         schema={
             vol.Required(ATTR_CODE): cv.string,
@@ -34,7 +37,7 @@ def async_setup_services(hass: HomeAssistant) -> None:
     service.async_register_platform_entity_service(
         hass,
         DOMAIN,
-        "alarm_keypress",
+        SERVICE_ALARM_KEYPRESS,
         entity_domain=ALARM_CONTROL_PANEL_DOMAIN,
         schema={
             vol.Required(ATTR_KEYPRESS): cv.string,

homeassistant/components/alexa_devices/entity.py

@@ -1,6 +1,6 @@
 """Defines a base Alexa Devices entity."""
 
-from aioamazondevices.const.devices import SPEAKER_GROUP_MODEL
+from aioamazondevices.const.devices import SPEAKER_GROUP_DEVICE_TYPE
 from aioamazondevices.structures import AmazonDevice
 
 from homeassistant.helpers.device_registry import DeviceInfo
@@ -25,19 +25,20 @@ class AmazonEntity(CoordinatorEntity[AmazonDevicesCoordinator]):
         """Initialize the entity."""
         super().__init__(coordinator)
         self._serial_num = serial_num
-        model_details = coordinator.api.get_model_details(self.device) or {}
-        model = model_details.get("model")
+        model = self.device.model
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, serial_num)},
             name=self.device.account_name,
             model=model,
             model_id=self.device.device_type,
-            manufacturer=model_details.get("manufacturer", "Amazon"),
-            hw_version=model_details.get("hw_version"),
+            manufacturer=self.device.manufacturer or "Amazon",
+            hw_version=self.device.hardware_version,
             sw_version=(
-                self.device.software_version if model != SPEAKER_GROUP_MODEL else None
+                self.device.software_version
+                if model != SPEAKER_GROUP_DEVICE_TYPE
+                else None
             ),
-            serial_number=serial_num if model != SPEAKER_GROUP_MODEL else None,
+            serial_number=serial_num if model != SPEAKER_GROUP_DEVICE_TYPE else None,
         )
         self.entity_description = description
         self._attr_unique_id = f"{serial_num}-{description.key}"

homeassistant/components/alexa_devices/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["aioamazondevices"],
   "quality_scale": "platinum",
-  "requirements": ["aioamazondevices==12.0.0"]
+  "requirements": ["aioamazondevices==13.0.0"]
 }

homeassistant/components/alexa_devices/services.py

@@ -16,6 +16,9 @@ from .coordinator import AmazonConfigEntry
 ATTR_TEXT_COMMAND = "text_command"
 ATTR_SOUND = "sound"
 ATTR_INFO_SKILL = "info_skill"
+SERVICE_TEXT_COMMAND = "send_text_command"
+SERVICE_SOUND_NOTIFICATION = "send_sound"
+SERVICE_INFO_SKILL = "send_info_skill"
 
 SCHEMA_SOUND_SERVICE = vol.Schema(
     {
@@ -125,17 +128,17 @@ def async_setup_services(hass: HomeAssistant) -> None:
     """Set up the services for the Amazon Devices integration."""
     for service_name, method, schema in (
         (
-            "send_sound",
+            SERVICE_SOUND_NOTIFICATION,
             async_send_sound_notification,
             SCHEMA_SOUND_SERVICE,
         ),
         (
-            "send_text_command",
+            SERVICE_TEXT_COMMAND,
             async_send_text_command,
             SCHEMA_CUSTOM_COMMAND,
         ),
         (
-            "send_info_skill",
+            SERVICE_INFO_SKILL,
             async_send_info_skill,
             SCHEMA_INFO_SKILL,
         ),

homeassistant/components/amberelectric/const.py

@@ -16,6 +16,8 @@ ATTRIBUTION = "Data provided by Amber Electric"
 LOGGER = logging.getLogger(__package__)
 PLATFORMS = [Platform.BINARY_SENSOR, Platform.SENSOR]
 
+SERVICE_GET_FORECASTS = "get_forecasts"
+
 GENERAL_CHANNEL = "general"
 CONTROLLED_LOAD_CHANNEL = "controlled_load"
 FEED_IN_CHANNEL = "feed_in"

homeassistant/components/amberelectric/services.py

@@ -22,6 +22,7 @@ from .const import (
     DOMAIN,
     FEED_IN_CHANNEL,
     GENERAL_CHANNEL,
+    SERVICE_GET_FORECASTS,
 )
 from .coordinator import AmberConfigEntry
 from .helpers import format_cents_to_dollars, normalize_descriptor
@@ -100,7 +101,7 @@ def async_setup_services(hass: HomeAssistant) -> None:
 
     hass.services.async_register(
         DOMAIN,
-        "get_forecasts",
+        SERVICE_GET_FORECASTS,
         handle_get_forecasts,
         GET_FORECASTS_SCHEMA,
         supports_response=SupportsResponse.ONLY,

homeassistant/components/amcrest/camera.py

@@ -49,6 +49,18 @@ SCAN_INTERVAL = timedelta(seconds=15)
 
 STREAM_SOURCE_LIST = ["snapshot", "mjpeg", "rtsp"]
 
+_SRV_EN_REC = "enable_recording"
+_SRV_DS_REC = "disable_recording"
+_SRV_EN_AUD = "enable_audio"
+_SRV_DS_AUD = "disable_audio"
+_SRV_EN_MOT_REC = "enable_motion_recording"
+_SRV_DS_MOT_REC = "disable_motion_recording"
+_SRV_GOTO = "goto_preset"
+_SRV_CBW = "set_color_bw"
+_SRV_TOUR_ON = "start_tour"
+_SRV_TOUR_OFF = "stop_tour"
+
+_SRV_PTZ_CTRL = "ptz_control"
 _ATTR_PTZ_TT = "travel_time"
 _ATTR_PTZ_MOV = "movement"
 _MOV = [
@@ -91,17 +103,17 @@ _SRV_PTZ_SCHEMA = _SRV_SCHEMA.extend(
 )
 
 CAMERA_SERVICES = {
-    "enable_recording": (_SRV_SCHEMA, "async_enable_recording", ()),
-    "disable_recording": (_SRV_SCHEMA, "async_disable_recording", ()),
-    "enable_audio": (_SRV_SCHEMA, "async_enable_audio", ()),
-    "disable_audio": (_SRV_SCHEMA, "async_disable_audio", ()),
-    "enable_motion_recording": (_SRV_SCHEMA, "async_enable_motion_recording", ()),
-    "disable_motion_recording": (_SRV_SCHEMA, "async_disable_motion_recording", ()),
-    "goto_preset": (_SRV_GOTO_SCHEMA, "async_goto_preset", (_ATTR_PRESET,)),
-    "set_color_bw": (_SRV_CBW_SCHEMA, "async_set_color_bw", (_ATTR_COLOR_BW,)),
-    "start_tour": (_SRV_SCHEMA, "async_start_tour", ()),
-    "stop_tour": (_SRV_SCHEMA, "async_stop_tour", ()),
-    "ptz_control": (
+    _SRV_EN_REC: (_SRV_SCHEMA, "async_enable_recording", ()),
+    _SRV_DS_REC: (_SRV_SCHEMA, "async_disable_recording", ()),
+    _SRV_EN_AUD: (_SRV_SCHEMA, "async_enable_audio", ()),
+    _SRV_DS_AUD: (_SRV_SCHEMA, "async_disable_audio", ()),
+    _SRV_EN_MOT_REC: (_SRV_SCHEMA, "async_enable_motion_recording", ()),
+    _SRV_DS_MOT_REC: (_SRV_SCHEMA, "async_disable_motion_recording", ()),
+    _SRV_GOTO: (_SRV_GOTO_SCHEMA, "async_goto_preset", (_ATTR_PRESET,)),
+    _SRV_CBW: (_SRV_CBW_SCHEMA, "async_set_color_bw", (_ATTR_COLOR_BW,)),
+    _SRV_TOUR_ON: (_SRV_SCHEMA, "async_start_tour", ()),
+    _SRV_TOUR_OFF: (_SRV_SCHEMA, "async_stop_tour", ()),
+    _SRV_PTZ_CTRL: (
         _SRV_PTZ_SCHEMA,
         "async_ptz_control",
         (_ATTR_PTZ_MOV, _ATTR_PTZ_TT),

homeassistant/components/androidtv/media_player.py

@@ -36,7 +36,7 @@ from .const import (
     SIGNAL_CONFIG_ENTITY,
 )
 from .entity import AndroidTVEntity, adb_decorator
-from .services import ATTR_ADB_RESPONSE, ATTR_HDMI_INPUT
+from .services import ATTR_ADB_RESPONSE, ATTR_HDMI_INPUT, SERVICE_LEARN_SENDEVENT
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -271,7 +271,7 @@ class ADBDevice(AndroidTVEntity, MediaPlayerEntity):
             self.async_write_ha_state()
 
             msg = (
-                f"Output from service 'learn_sendevent' from"
+                f"Output from service '{SERVICE_LEARN_SENDEVENT}' from"
                 f" {self.entity_id}: '{output}'"
             )
             persistent_notification.async_create(

homeassistant/components/androidtv/services.py

@@ -16,6 +16,11 @@ ATTR_DEVICE_PATH = "device_path"
 ATTR_HDMI_INPUT = "hdmi_input"
 ATTR_LOCAL_PATH = "local_path"
 
+SERVICE_ADB_COMMAND = "adb_command"
+SERVICE_DOWNLOAD = "download"
+SERVICE_LEARN_SENDEVENT = "learn_sendevent"
+SERVICE_UPLOAD = "upload"
+
 
 @callback
 def async_setup_services(hass: HomeAssistant) -> None:
@@ -24,7 +29,7 @@ def async_setup_services(hass: HomeAssistant) -> None:
     service.async_register_platform_entity_service(
         hass,
         DOMAIN,
-        "adb_command",
+        SERVICE_ADB_COMMAND,
         entity_domain=MEDIA_PLAYER_DOMAIN,
         schema={vol.Required(ATTR_COMMAND): cv.string},
         func="adb_command",
@@ -32,7 +37,7 @@ def async_setup_services(hass: HomeAssistant) -> None:
     service.async_register_platform_entity_service(
         hass,
         DOMAIN,
-        "learn_sendevent",
+        SERVICE_LEARN_SENDEVENT,
         entity_domain=MEDIA_PLAYER_DOMAIN,
         schema=None,
         func="learn_sendevent",
@@ -40,7 +45,7 @@ def async_setup_services(hass: HomeAssistant) -> None:
     service.async_register_platform_entity_service(
         hass,
         DOMAIN,
-        "download",
+        SERVICE_DOWNLOAD,
         entity_domain=MEDIA_PLAYER_DOMAIN,
         schema={
             vol.Required(ATTR_DEVICE_PATH): cv.string,
@@ -51,7 +56,7 @@ def async_setup_services(hass: HomeAssistant) -> None:
     service.async_register_platform_entity_service(
         hass,
         DOMAIN,
-        "upload",
+        SERVICE_UPLOAD,
         entity_domain=MEDIA_PLAYER_DOMAIN,
         schema={
             vol.Required(ATTR_DEVICE_PATH): cv.string,

homeassistant/components/august/manifest.json

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

homeassistant/components/aws_s3/backup.py

@@ -19,7 +19,7 @@ from homeassistant.components.backup import (
 from homeassistant.core import HomeAssistant, callback
 
 from . import S3ConfigEntry
-from .const import CONF_BUCKET, CONF_PREFIX, DATA_BACKUP_AGENT_LISTENERS, DOMAIN
+from .const import CONF_BUCKET, DATA_BACKUP_AGENT_LISTENERS, DOMAIN
 from .helpers import async_list_backups_from_s3
 
 _LOGGER = logging.getLogger(__name__)
@@ -100,13 +100,6 @@ class S3BackupAgent(BackupAgent):
         self.unique_id = entry.entry_id
         self._backup_cache: dict[str, AgentBackup] = {}
         self._cache_expiration = time()
-        self._prefix: str = entry.data.get(CONF_PREFIX, "")
-
-    def _with_prefix(self, key: str) -> str:
-        """Add prefix to a key if configured."""
-        if not self._prefix:
-            return key
-        return f"{self._prefix}/{key}"
 
     @handle_boto_errors
     async def async_download_backup(
@@ -122,9 +115,7 @@ class S3BackupAgent(BackupAgent):
         backup = await self._find_backup_by_id(backup_id)
         tar_filename, _ = suggested_filenames(backup)
 
-        response = await self._client.get_object(
-            Bucket=self._bucket, Key=self._with_prefix(tar_filename)
-        )
+        response = await self._client.get_object(Bucket=self._bucket, Key=tar_filename)
         return response["Body"].iter_chunks()
 
     async def async_upload_backup(
@@ -151,7 +142,7 @@ class S3BackupAgent(BackupAgent):
             metadata_content = json.dumps(backup.as_dict())
             await self._client.put_object(
                 Bucket=self._bucket,
-                Key=self._with_prefix(metadata_filename),
+                Key=metadata_filename,
                 Body=metadata_content,
             )
         except BotoCoreError as err:
@@ -178,7 +169,7 @@ class S3BackupAgent(BackupAgent):
 
         await self._client.put_object(
             Bucket=self._bucket,
-            Key=self._with_prefix(tar_filename),
+            Key=tar_filename,
             Body=bytes(file_data),
         )
 
@@ -195,7 +186,7 @@ class S3BackupAgent(BackupAgent):
         _LOGGER.debug("Starting multipart upload for %s", tar_filename)
         multipart_upload = await self._client.create_multipart_upload(
             Bucket=self._bucket,
-            Key=self._with_prefix(tar_filename),
+            Key=tar_filename,
         )
         upload_id = multipart_upload["UploadId"]
         try:
@@ -225,7 +216,7 @@ class S3BackupAgent(BackupAgent):
                         )
                         part = await cast(Any, self._client).upload_part(
                             Bucket=self._bucket,
-                            Key=self._with_prefix(tar_filename),
+                            Key=tar_filename,
                             PartNumber=part_number,
                             UploadId=upload_id,
                             Body=part_data.tobytes(),
@@ -253,7 +244,7 @@ class S3BackupAgent(BackupAgent):
                 )
                 part = await cast(Any, self._client).upload_part(
                     Bucket=self._bucket,
-                    Key=self._with_prefix(tar_filename),
+                    Key=tar_filename,
                     PartNumber=part_number,
                     UploadId=upload_id,
                     Body=remaining_data.tobytes(),
@@ -262,7 +253,7 @@ class S3BackupAgent(BackupAgent):
 
             await cast(Any, self._client).complete_multipart_upload(
                 Bucket=self._bucket,
-                Key=self._with_prefix(tar_filename),
+                Key=tar_filename,
                 UploadId=upload_id,
                 MultipartUpload={"Parts": parts},
             )
@@ -271,7 +262,7 @@ class S3BackupAgent(BackupAgent):
             try:
                 await self._client.abort_multipart_upload(
                     Bucket=self._bucket,
-                    Key=self._with_prefix(tar_filename),
+                    Key=tar_filename,
                     UploadId=upload_id,
                 )
             except BotoCoreError:
@@ -292,12 +283,8 @@ class S3BackupAgent(BackupAgent):
         tar_filename, metadata_filename = suggested_filenames(backup)
 
         # Delete both the backup file and its metadata file
-        await self._client.delete_object(
-            Bucket=self._bucket, Key=self._with_prefix(tar_filename)
-        )
-        await self._client.delete_object(
-            Bucket=self._bucket, Key=self._with_prefix(metadata_filename)
-        )
+        await self._client.delete_object(Bucket=self._bucket, Key=tar_filename)
+        await self._client.delete_object(Bucket=self._bucket, Key=metadata_filename)
 
         # Reset cache after successful deletion
         self._cache_expiration = time()
@@ -330,9 +317,7 @@ class S3BackupAgent(BackupAgent):
         if time() <= self._cache_expiration:
             return self._backup_cache
 
-        backups_list = await async_list_backups_from_s3(
-            self._client, self._bucket, self._prefix
-        )
+        backups_list = await async_list_backups_from_s3(self._client, self._bucket)
         self._backup_cache = {b.backup_id: b for b in backups_list}
         self._cache_expiration = time() + CACHE_TTL
 

homeassistant/components/aws_s3/config_flow.py

@@ -22,7 +22,6 @@ from .const import (
     CONF_ACCESS_KEY_ID,
     CONF_BUCKET,
     CONF_ENDPOINT_URL,
-    CONF_PREFIX,
     CONF_SECRET_ACCESS_KEY,
     DEFAULT_ENDPOINT_URL,
     DESCRIPTION_AWS_S3_DOCS_URL,
@@ -40,7 +39,6 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
         vol.Required(CONF_ENDPOINT_URL, default=DEFAULT_ENDPOINT_URL): TextSelector(
             config=TextSelectorConfig(type=TextSelectorType.URL)
         ),
-        vol.Optional(CONF_PREFIX, default=""): cv.string,
     }
 )
 
@@ -55,17 +53,12 @@ class S3ConfigFlow(ConfigFlow, domain=DOMAIN):
         errors: dict[str, str] = {}
 
         if user_input is not None:
-            normalized_prefix = user_input.get(CONF_PREFIX, "").strip("/")
-            # Check for existing entries, treating missing prefix as empty
-            for entry in self._async_current_entries(include_ignore=False):
-                entry_prefix = (entry.data.get(CONF_PREFIX) or "").strip("/")
-                if (
-                    entry.data.get(CONF_BUCKET) == user_input[CONF_BUCKET]
-                    and entry.data.get(CONF_ENDPOINT_URL)
-                    == user_input[CONF_ENDPOINT_URL]
-                    and entry_prefix == normalized_prefix
-                ):
-                    return self.async_abort(reason="already_configured")
+            self._async_abort_entries_match(
+                {
+                    CONF_BUCKET: user_input[CONF_BUCKET],
+                    CONF_ENDPOINT_URL: user_input[CONF_ENDPOINT_URL],
+                }
+            )
 
             hostname = urlparse(user_input[CONF_ENDPOINT_URL]).hostname
             if not hostname or not hostname.endswith(AWS_DOMAIN):
@@ -90,18 +83,9 @@ class S3ConfigFlow(ConfigFlow, domain=DOMAIN):
                 except ConnectionError:
                     errors[CONF_ENDPOINT_URL] = "cannot_connect"
                 else:
-                    data = dict(user_input)
-                    if not normalized_prefix:
-                        # Do not persist empty optional values
-                        data.pop(CONF_PREFIX, None)
-                    else:
-                        data[CONF_PREFIX] = normalized_prefix
-
-                    title = user_input[CONF_BUCKET]
-                    if normalized_prefix:
-                        title = f"{title} - {normalized_prefix}"
-
-                    return self.async_create_entry(title=title, data=data)
+                    return self.async_create_entry(
+                        title=user_input[CONF_BUCKET], data=user_input
+                    )
 
         return self.async_show_form(
             step_id="user",

homeassistant/components/aws_s3/const.py

@@ -11,7 +11,6 @@ CONF_ACCESS_KEY_ID = "access_key_id"
 CONF_SECRET_ACCESS_KEY = "secret_access_key"
 CONF_ENDPOINT_URL = "endpoint_url"
 CONF_BUCKET = "bucket"
-CONF_PREFIX = "prefix"
 
 AWS_DOMAIN = "amazonaws.com"
 DEFAULT_ENDPOINT_URL = f"https://s3.eu-central-1.{AWS_DOMAIN}/"

homeassistant/components/aws_s3/coordinator.py

@@ -13,7 +13,7 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
-from .const import CONF_BUCKET, CONF_PREFIX, DOMAIN
+from .const import CONF_BUCKET, DOMAIN
 from .helpers import async_list_backups_from_s3
 
 SCAN_INTERVAL = timedelta(hours=6)
@@ -53,14 +53,11 @@ class S3DataUpdateCoordinator(DataUpdateCoordinator[SensorData]):
         )
         self.client = client
         self._bucket: str = entry.data[CONF_BUCKET]
-        self._prefix: str = entry.data.get(CONF_PREFIX, "")
 
     async def _async_update_data(self) -> SensorData:
         """Fetch data from AWS S3."""
         try:
-            backups = await async_list_backups_from_s3(
-                self.client, self._bucket, self._prefix
-            )
+            backups = await async_list_backups_from_s3(self.client, self._bucket)
         except BotoCoreError as error:
             raise UpdateFailed(
                 translation_domain=DOMAIN,

homeassistant/components/aws_s3/diagnostics.py

@@ -1,55 +0,0 @@
-"""Diagnostics support for AWS S3."""
-
-from __future__ import annotations
-
-import dataclasses
-from typing import Any
-
-from homeassistant.components.backup import (
-    DATA_MANAGER as BACKUP_DATA_MANAGER,
-    BackupManager,
-)
-from homeassistant.components.diagnostics import async_redact_data
-from homeassistant.core import HomeAssistant
-
-from .const import (
-    CONF_ACCESS_KEY_ID,
-    CONF_BUCKET,
-    CONF_PREFIX,
-    CONF_SECRET_ACCESS_KEY,
-    DOMAIN,
-)
-from .coordinator import S3ConfigEntry
-from .helpers import async_list_backups_from_s3
-
-TO_REDACT = (CONF_ACCESS_KEY_ID, CONF_SECRET_ACCESS_KEY)
-
-
-async def async_get_config_entry_diagnostics(
-    hass: HomeAssistant,
-    entry: S3ConfigEntry,
-) -> dict[str, Any]:
-    """Return diagnostics for a config entry."""
-    coordinator = entry.runtime_data
-    backup_manager: BackupManager = hass.data[BACKUP_DATA_MANAGER]
-    backups = await async_list_backups_from_s3(
-        coordinator.client,
-        bucket=entry.data[CONF_BUCKET],
-        prefix=entry.data.get(CONF_PREFIX, ""),
-    )
-
-    data = {
-        "coordinator_data": dataclasses.asdict(coordinator.data),
-        "config": {
-            **entry.data,
-            **entry.options,
-        },
-        "backup_agents": [
-            {"name": agent.name}
-            for agent in backup_manager.backup_agents.values()
-            if agent.domain == DOMAIN
-        ],
-        "backup": [backup.as_dict() for backup in backups],
-    }
-
-    return async_redact_data(data, TO_REDACT)

homeassistant/components/aws_s3/helpers.py

@@ -17,17 +17,11 @@ _LOGGER = logging.getLogger(__name__)
 async def async_list_backups_from_s3(
     client: S3Client,
     bucket: str,
-    prefix: str,
 ) -> list[AgentBackup]:
     """List backups from an S3 bucket by reading metadata files."""
     paginator = client.get_paginator("list_objects_v2")
     metadata_files: list[dict[str, Any]] = []
-
-    list_kwargs: dict[str, Any] = {"Bucket": bucket}
-    if prefix:
-        list_kwargs["Prefix"] = prefix + "/"
-
-    async for page in paginator.paginate(**list_kwargs):
+    async for page in paginator.paginate(Bucket=bucket):
         metadata_files.extend(
             obj
             for obj in page.get("Contents", [])

homeassistant/components/aws_s3/quality_scale.yaml

@@ -23,9 +23,7 @@ rules:
   runtime-data: done
   test-before-configure: done
   test-before-setup: done
-  unique-config-entry:
-    status: exempt
-    comment: Hassfest does not recognize the duplicate prevention logic. Duplicate entries are prevented by checking bucket, endpoint URL, and prefix in the config flow.
+  unique-config-entry: done
 
   # Silver
   action-exceptions:
@@ -38,14 +36,14 @@ rules:
   docs-installation-parameters: done
   entity-unavailable: done
   integration-owner: done
-  log-when-unavailable: done
+  log-when-unavailable: todo
   parallel-updates: done
   reauthentication-flow: todo
   test-coverage: done
 
   # Gold
   devices: done
-  diagnostics: done
+  diagnostics: todo
   discovery-update-info:
     status: exempt
     comment: S3 is a cloud service that is not discovered on the network.

homeassistant/components/aws_s3/strings.json

@@ -15,14 +15,12 @@
           "access_key_id": "Access key ID",
           "bucket": "Bucket name",
           "endpoint_url": "Endpoint URL",
-          "prefix": "Prefix",
           "secret_access_key": "Secret access key"
         },
         "data_description": {
           "access_key_id": "Access key ID to connect to AWS S3 API",
           "bucket": "Bucket must already exist and be writable by the provided credentials.",
           "endpoint_url": "Endpoint URL provided to [Boto3 Session]({boto3_docs_url}). Region-specific [AWS S3 endpoints]({aws_s3_docs_url}) are available in their docs.",
-          "prefix": "Folder or prefix to store backups in, for example `backups`",
           "secret_access_key": "Secret access key to connect to AWS S3 API"
         },
         "title": "Add AWS S3 bucket"

homeassistant/components/backup/store.py

@@ -29,12 +29,17 @@ class StoredBackupData(TypedDict):
 class _BackupStore(Store[StoredBackupData]):
     """Class to help storing backup data."""
 
+    # Maximum version we support reading for forward compatibility.
+    # This allows reading data written by a newer HA version after downgrade.
+    _MAX_READABLE_VERSION = 2
+
     def __init__(self, hass: HomeAssistant) -> None:
         """Initialize storage class."""
         super().__init__(
             hass,
             STORAGE_VERSION,
             STORAGE_KEY,
+            max_readable_version=self._MAX_READABLE_VERSION,
             minor_version=STORAGE_VERSION_MINOR,
         )
 
@@ -86,8 +91,8 @@ class _BackupStore(Store[StoredBackupData]):
         # data["config"]["schedule"]["state"] will be removed. The bump to 2 is
         # planned to happen after a 6 month quiet period with no minor version
         # changes.
-        # Reject if major version is higher than 2.
-        if old_major_version > 2:
+        # Reject if major version is higher than _MAX_READABLE_VERSION.
+        if old_major_version > self._MAX_READABLE_VERSION:
             raise NotImplementedError
         return data
 

homeassistant/components/bsblan/manifest.json

@@ -8,7 +8,7 @@
   "iot_class": "local_polling",
   "loggers": ["bsblan"],
   "quality_scale": "silver",
-  "requirements": ["python-bsblan==5.1.0"],
+  "requirements": ["python-bsblan==5.1.2"],
   "zeroconf": [
     {
       "name": "bsb-lan*",

homeassistant/components/bsblan/sensor.py

@@ -64,6 +64,8 @@ SENSOR_TYPES: tuple[BSBLanSensorEntityDescription, ...] = (
         device_class=SensorDeviceClass.ENERGY,
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         state_class=SensorStateClass.TOTAL_INCREASING,
+        suggested_display_precision=0,
+        entity_registry_enabled_default=False,
         value_fn=lambda data: (
             data.sensor.total_energy.value
             if data.sensor.total_energy is not None

homeassistant/components/cast/media_player.py

@@ -804,9 +804,24 @@ class CastMediaPlayerEntity(CastDevice, MediaPlayerEntity):
     @property
     def state(self) -> MediaPlayerState | None:
         """Return the state of the player."""
-        # The lovelace app loops media to prevent timing out, don't show that
+        if (chromecast := self._chromecast) is None or (
+            cast_status := self.cast_status
+        ) is None:
+            # Not connected to any chromecast, or not yet got any status
+            return None
+
+        if (
+            chromecast.cast_type == pychromecast.const.CAST_TYPE_CHROMECAST
+            and not chromecast.ignore_cec
+            and cast_status.is_active_input is False
+        ):
+            # The display interface for the device has been turned off or switched away
+            return MediaPlayerState.OFF
+
         if self.app_id == CAST_APP_ID_HOMEASSISTANT_LOVELACE:
+            # The lovelace app loops media to prevent timing out, don't show that
             return MediaPlayerState.PLAYING
+
         if (media_status := self._media_status()[0]) is not None:
             if media_status.player_state == MEDIA_PLAYER_STATE_PLAYING:
                 return MediaPlayerState.PLAYING
@@ -817,20 +832,16 @@ class CastMediaPlayerEntity(CastDevice, MediaPlayerEntity):
             if media_status.player_is_idle:
                 return MediaPlayerState.IDLE
 
-        if self._chromecast is not None and self._chromecast.is_idle:
-            # If library consider us idle, that is our off state
-            # it takes HDMI status into account for cast devices.
-            return MediaPlayerState.OFF
-
         if self.app_id in APP_IDS_UNRELIABLE_MEDIA_INFO:
             # Some apps don't report media status, show the player as playing
             return MediaPlayerState.PLAYING
 
-        if self.app_id is not None:
-            # We have an active app
-            return MediaPlayerState.IDLE
+        if self.app_id in (pychromecast.IDLE_APP_ID, None):
+            # We have no active app or the home screen app. This is
+            # same app as APP_BACKDROP.
+            return MediaPlayerState.OFF
 
-        return None
+        return MediaPlayerState.IDLE
 
     @property
     def media_content_id(self) -> str | None:

homeassistant/components/compit/__init__.py

@@ -12,7 +12,6 @@ from .coordinator import CompitConfigEntry, CompitDataUpdateCoordinator
 PLATFORMS = [
     Platform.BINARY_SENSOR,
     Platform.CLIMATE,
-    Platform.FAN,
     Platform.NUMBER,
     Platform.SELECT,
     Platform.SENSOR,

homeassistant/components/compit/fan.py

@@ -1,172 +0,0 @@
-"""Fan platform for Compit integration."""
-
-from typing import Any
-
-from compit_inext_api import PARAM_VALUES
-from compit_inext_api.consts import CompitParameter
-
-from homeassistant.components.fan import (
-    FanEntity,
-    FanEntityDescription,
-    FanEntityFeature,
-)
-from homeassistant.const import STATE_OFF, STATE_ON
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
-from homeassistant.util.percentage import (
-    ordered_list_item_to_percentage,
-    percentage_to_ordered_list_item,
-)
-
-from .const import DOMAIN, MANUFACTURER_NAME
-from .coordinator import CompitConfigEntry, CompitDataUpdateCoordinator
-
-PARALLEL_UPDATES = 0
-
-COMPIT_GEAR_TO_HA = PARAM_VALUES[CompitParameter.VENTILATION_GEAR_TARGET]
-HA_STATE_TO_COMPIT = {value: key for key, value in COMPIT_GEAR_TO_HA.items()}
-
-
-DEVICE_DEFINITIONS: dict[int, FanEntityDescription] = {
-    223: FanEntityDescription(
-        key="Nano Color 2",
-        translation_key="ventilation",
-    ),
-    12: FanEntityDescription(
-        key="Nano Color",
-        translation_key="ventilation",
-    ),
-}
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: CompitConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Compit fan entities from a config entry."""
-    coordinator = entry.runtime_data
-    async_add_entities(
-        CompitFan(
-            coordinator,
-            device_id,
-            device_definition,
-        )
-        for device_id, device in coordinator.connector.all_devices.items()
-        if (device_definition := DEVICE_DEFINITIONS.get(device.definition.code))
-    )
-
-
-class CompitFan(CoordinatorEntity[CompitDataUpdateCoordinator], FanEntity):
-    """Representation of a Compit fan entity."""
-
-    _attr_speed_count = len(COMPIT_GEAR_TO_HA)
-    _attr_has_entity_name = True
-    _attr_name = None
-    _attr_supported_features = (
-        FanEntityFeature.TURN_ON
-        | FanEntityFeature.TURN_OFF
-        | FanEntityFeature.SET_SPEED
-    )
-
-    def __init__(
-        self,
-        coordinator: CompitDataUpdateCoordinator,
-        device_id: int,
-        entity_description: FanEntityDescription,
-    ) -> None:
-        """Initialize the fan entity."""
-        super().__init__(coordinator)
-        self.device_id = device_id
-        self.entity_description = entity_description
-        self._attr_unique_id = f"{device_id}_{entity_description.key}"
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, str(device_id))},
-            name=entity_description.key,
-            manufacturer=MANUFACTURER_NAME,
-            model=entity_description.key,
-        )
-
-    @property
-    def available(self) -> bool:
-        """Return if entity is available."""
-        return (
-            super().available
-            and self.coordinator.connector.get_device(self.device_id) is not None
-        )
-
-    @property
-    def is_on(self) -> bool | None:
-        """Return true if the fan is on."""
-        value = self.coordinator.connector.get_current_option(
-            self.device_id, CompitParameter.VENTILATION_ON_OFF
-        )
-
-        return True if value == STATE_ON else False if value == STATE_OFF else None
-
-    async def async_turn_on(
-        self,
-        percentage: int | None = None,
-        preset_mode: str | None = None,
-        **kwargs: Any,
-    ) -> None:
-        """Turn on the fan."""
-        await self.coordinator.connector.select_device_option(
-            self.device_id, CompitParameter.VENTILATION_ON_OFF, STATE_ON
-        )
-
-        if percentage is None:
-            self.async_write_ha_state()
-            return
-
-        await self.async_set_percentage(percentage)
-
-    async def async_turn_off(self, **kwargs: Any) -> None:
-        """Turn off the fan."""
-        await self.coordinator.connector.select_device_option(
-            self.device_id, CompitParameter.VENTILATION_ON_OFF, STATE_OFF
-        )
-        self.async_write_ha_state()
-
-    @property
-    def percentage(self) -> int | None:
-        """Return the current fan speed as a percentage."""
-        if self.is_on is False:
-            return 0
-        mode = self.coordinator.connector.get_current_option(
-            self.device_id, CompitParameter.VENTILATION_GEAR_TARGET
-        )
-        if mode is None:
-            return None
-        gear = COMPIT_GEAR_TO_HA.get(mode)
-        return (
-            None
-            if gear is None
-            else ordered_list_item_to_percentage(
-                list(COMPIT_GEAR_TO_HA.values()),
-                gear,
-            )
-        )
-
-    async def async_set_percentage(self, percentage: int) -> None:
-        """Set the fan speed."""
-        if percentage == 0:
-            await self.async_turn_off()
-            return
-
-        gear = int(
-            percentage_to_ordered_list_item(
-                list(COMPIT_GEAR_TO_HA.values()),
-                percentage,
-            )
-        )
-        mode = HA_STATE_TO_COMPIT.get(gear)
-        if mode is None:
-            return
-
-        await self.coordinator.connector.select_device_option(
-            self.device_id, CompitParameter.VENTILATION_GEAR_TARGET, mode
-        )
-        self.async_write_ha_state()

homeassistant/components/compit/icons.json

@@ -20,14 +20,6 @@
         "default": "mdi:alert"
       }
     },
-    "fan": {
-      "ventilation": {
-        "default": "mdi:fan",
-        "state": {
-          "off": "mdi:fan-off"
-        }
-      }
-    },
     "number": {
       "boiler_target_temperature": {
         "default": "mdi:water-boiler"

homeassistant/components/compit/strings.json

@@ -53,11 +53,6 @@
         "name": "Temperature alert"
       }
     },
-    "fan": {
-      "ventilation": {
-        "name": "[%key:component::fan::title%]"
-      }
-    },
     "number": {
       "boiler_target_temperature": {
         "name": "Boiler target temperature"

homeassistant/components/conversation/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/conversation",
   "integration_type": "entity",
   "quality_scale": "internal",
-  "requirements": ["hassil==3.5.0", "home-assistant-intents==2026.2.13"]
+  "requirements": ["hassil==3.5.0", "home-assistant-intents==2026.3.3"]
 }

homeassistant/components/dsmr/manifest.json

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

homeassistant/components/dunehd/media_player.py

@@ -33,6 +33,8 @@ DUNEHD_PLAYER_SUPPORT: Final[MediaPlayerEntityFeature] = (
     | MediaPlayerEntityFeature.PLAY
     | MediaPlayerEntityFeature.PLAY_MEDIA
     | MediaPlayerEntityFeature.BROWSE_MEDIA
+    | MediaPlayerEntityFeature.VOLUME_STEP
+    | MediaPlayerEntityFeature.VOLUME_MUTE
 )
 
 

homeassistant/components/esphome/assist_satellite.py

@@ -524,14 +524,10 @@ class EsphomeAssistSatellite(
         self._active_pipeline_index = 0
 
         maybe_pipeline_index = 0
-        while True:
-            if not (ww_entity_id := self.get_wake_word_entity(maybe_pipeline_index)):
-                break
-
-            if not (ww_state := self.hass.states.get(ww_entity_id)):
-                continue
-
-            if ww_state.state == wake_word_phrase:
+        while ww_entity_id := self.get_wake_word_entity(maybe_pipeline_index):
+            if (
+                ww_state := self.hass.states.get(ww_entity_id)
+            ) and ww_state.state == wake_word_phrase:
                 # First match
                 self._active_pipeline_index = maybe_pipeline_index
                 break

homeassistant/components/evohome/climate.py

@@ -36,12 +36,19 @@ from homeassistant.const import (
     UnitOfTemperature,
 )
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
+from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 from homeassistant.util import dt as dt_util
 
-from .const import ATTR_DURATION, ATTR_PERIOD, DOMAIN, EVOHOME_DATA, EvoService
+from .const import (
+    ATTR_DURATION,
+    ATTR_DURATION_UNTIL,
+    ATTR_PERIOD,
+    ATTR_SETPOINT,
+    EVOHOME_DATA,
+    EvoService,
+)
 from .coordinator import EvoDataUpdateCoordinator
 from .entity import EvoChild, EvoEntity
 
@@ -132,24 +139,6 @@ class EvoClimateEntity(EvoEntity, ClimateEntity):
     _attr_hvac_modes = [HVACMode.OFF, HVACMode.HEAT]
     _attr_temperature_unit = UnitOfTemperature.CELSIUS
 
-    async def async_clear_zone_override(self) -> None:
-        """Clear the zone override; only supported by zones."""
-        raise ServiceValidationError(
-            translation_domain=DOMAIN,
-            translation_key="zone_only_service",
-            translation_placeholders={"service": EvoService.CLEAR_ZONE_OVERRIDE},
-        )
-
-    async def async_set_zone_override(
-        self, setpoint: float, duration: timedelta | None = None
-    ) -> None:
-        """Set the zone override; only supported by zones."""
-        raise ServiceValidationError(
-            translation_domain=DOMAIN,
-            translation_key="zone_only_service",
-            translation_placeholders={"service": EvoService.SET_ZONE_OVERRIDE},
-        )
-
 
 class EvoZone(EvoChild, EvoClimateEntity):
     """Base for any evohome-compatible heating zone."""
@@ -188,22 +177,22 @@ class EvoZone(EvoChild, EvoClimateEntity):
             | ClimateEntityFeature.TURN_ON
         )
 
-    async def async_clear_zone_override(self) -> None:
-        """Clear the zone's override, if any."""
-        await self.coordinator.call_client_api(self._evo_device.reset())
+    async def async_zone_svc_request(self, service: str, data: dict[str, Any]) -> None:
+        """Process a service request (setpoint override) for a zone."""
+        if service == EvoService.RESET_ZONE_OVERRIDE:
+            await self.coordinator.call_client_api(self._evo_device.reset())
+            return
 
-    async def async_set_zone_override(
-        self, setpoint: float, duration: timedelta | None = None
-    ) -> None:
-        """Set the zone's override (mode/setpoint)."""
-        temperature = max(min(setpoint, self.max_temp), self.min_temp)
+        # otherwise it is EvoService.SET_ZONE_OVERRIDE
+        temperature = max(min(data[ATTR_SETPOINT], self.max_temp), self.min_temp)
 
-        if duration is not None:
+        if ATTR_DURATION_UNTIL in data:
+            duration: timedelta = data[ATTR_DURATION_UNTIL]
             if duration.total_seconds() == 0:
                 await self._update_schedule()
                 until = self.setpoints.get("next_sp_from")
             else:
-                until = dt_util.now() + duration
+                until = dt_util.now() + data[ATTR_DURATION_UNTIL]
         else:
             until = None  # indefinitely
 

homeassistant/components/evohome/const.py

@@ -28,6 +28,7 @@ ATTR_PERIOD: Final = "period"  # number of days
 ATTR_DURATION: Final = "duration"  # number of minutes, <24h
 
 ATTR_SETPOINT: Final = "setpoint"
+ATTR_DURATION_UNTIL: Final = "duration"
 
 
 @unique
@@ -38,4 +39,4 @@ class EvoService(StrEnum):
     SET_SYSTEM_MODE = "set_system_mode"
     RESET_SYSTEM = "reset_system"
     SET_ZONE_OVERRIDE = "set_zone_override"
-    CLEAR_ZONE_OVERRIDE = "clear_zone_override"
+    RESET_ZONE_OVERRIDE = "clear_zone_override"

homeassistant/components/evohome/entity.py

@@ -12,7 +12,7 @@ from homeassistant.core import callback
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from .const import DOMAIN
+from .const import DOMAIN, EvoService
 from .coordinator import EvoDataUpdateCoordinator
 
 _LOGGER = logging.getLogger(__name__)
@@ -47,12 +47,22 @@ class EvoEntity(CoordinatorEntity[EvoDataUpdateCoordinator]):
             raise NotImplementedError
         if payload["unique_id"] != self._attr_unique_id:
             return
+        if payload["service"] in (
+            EvoService.SET_ZONE_OVERRIDE,
+            EvoService.RESET_ZONE_OVERRIDE,
+        ):
+            await self.async_zone_svc_request(payload["service"], payload["data"])
+            return
         await self.async_tcs_svc_request(payload["service"], payload["data"])
 
     async def async_tcs_svc_request(self, service: str, data: dict[str, Any]) -> None:
         """Process a service request (system mode) for a controller."""
         raise NotImplementedError
 
+    async def async_zone_svc_request(self, service: str, data: dict[str, Any]) -> None:
+        """Process a service request (setpoint override) for a zone."""
+        raise NotImplementedError
+
     @property
     def extra_state_attributes(self) -> Mapping[str, Any]:
         """Return the evohome-specific state attributes."""

homeassistant/components/evohome/services.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from datetime import timedelta
-from typing import Any, Final
+from typing import Final
 
 from evohomeasync2.const import SZ_CAN_BE_TEMPORARY, SZ_SYSTEM_MODE, SZ_TIMING_MODE
 from evohomeasync2.schemas.const import (
@@ -13,51 +13,40 @@ from evohomeasync2.schemas.const import (
 )
 import voluptuous as vol
 
-from homeassistant.components.climate import DOMAIN as CLIMATE_DOMAIN
-from homeassistant.const import ATTR_MODE
+from homeassistant.const import ATTR_ENTITY_ID, ATTR_MODE
 from homeassistant.core import HomeAssistant, ServiceCall, callback
-from homeassistant.helpers import config_validation as cv, service
+from homeassistant.helpers import config_validation as cv, entity_registry as er
 from homeassistant.helpers.dispatcher import async_dispatcher_send
 from homeassistant.helpers.service import verify_domain_control
 
-from .const import ATTR_DURATION, ATTR_PERIOD, ATTR_SETPOINT, DOMAIN, EvoService
+from .const import (
+    ATTR_DURATION,
+    ATTR_DURATION_UNTIL,
+    ATTR_PERIOD,
+    ATTR_SETPOINT,
+    DOMAIN,
+    EvoService,
+)
 from .coordinator import EvoDataUpdateCoordinator
 
 # system mode schemas are built dynamically when the services are registered
 # because supported modes can vary for edge-case systems
 
-# Zone service schemas (registered as entity services)
-CLEAR_ZONE_OVERRIDE_SCHEMA: Final[dict[str | vol.Marker, Any]] = {}
-SET_ZONE_OVERRIDE_SCHEMA: Final[dict[str | vol.Marker, Any]] = {
-    vol.Required(ATTR_SETPOINT): vol.All(
-        vol.Coerce(float), vol.Range(min=4.0, max=35.0)
-    ),
-    vol.Optional(ATTR_DURATION): vol.All(
-        cv.time_period,
-        vol.Range(min=timedelta(days=0), max=timedelta(days=1)),
-    ),
-}
-
-
-def _register_zone_entity_services(hass: HomeAssistant) -> None:
-    """Register entity-level services for zones."""
-
-    service.async_register_platform_entity_service(
-        hass,
-        DOMAIN,
-        EvoService.CLEAR_ZONE_OVERRIDE,
-        entity_domain=CLIMATE_DOMAIN,
-        schema=CLEAR_ZONE_OVERRIDE_SCHEMA,
-        func="async_clear_zone_override",
-    )
-    service.async_register_platform_entity_service(
-        hass,
-        DOMAIN,
-        EvoService.SET_ZONE_OVERRIDE,
-        entity_domain=CLIMATE_DOMAIN,
-        schema=SET_ZONE_OVERRIDE_SCHEMA,
-        func="async_set_zone_override",
-    )
+RESET_ZONE_OVERRIDE_SCHEMA: Final = vol.Schema(
+    {vol.Required(ATTR_ENTITY_ID): cv.entity_id}
+)
+SET_ZONE_OVERRIDE_SCHEMA: Final = vol.Schema(
+    {
+        vol.Required(ATTR_ENTITY_ID): cv.entity_id,
+        vol.Required(ATTR_SETPOINT): vol.All(
+            vol.Coerce(float), vol.Range(min=4.0, max=35.0)
+        ),
+        vol.Optional(ATTR_DURATION_UNTIL): vol.All(
+            cv.time_period,
+            vol.Range(min=timedelta(days=0), max=timedelta(days=1)),
+        ),
+    }
+)
 
 
 @callback
@@ -69,6 +58,8 @@ def setup_service_functions(
     Not all Honeywell TCC-compatible systems support all operating modes. In addition,
     each mode will require any of four distinct service schemas. This has to be
     enumerated before registering the appropriate handlers.
+
+    It appears that all TCC-compatible systems support the same three zones modes.
     """
 
     @verify_domain_control(DOMAIN)
@@ -88,6 +79,28 @@ def setup_service_functions(
         }
         async_dispatcher_send(hass, DOMAIN, payload)
 
+    @verify_domain_control(DOMAIN)
+    async def set_zone_override(call: ServiceCall) -> None:
+        """Set the zone override (setpoint)."""
+        entity_id = call.data[ATTR_ENTITY_ID]
+
+        registry = er.async_get(hass)
+        registry_entry = registry.async_get(entity_id)
+
+        if registry_entry is None or registry_entry.platform != DOMAIN:
+            raise ValueError(f"'{entity_id}' is not a known {DOMAIN} entity")
+
+        if registry_entry.domain != "climate":
+            raise ValueError(f"'{entity_id}' is not an {DOMAIN} controller/zone")
+
+        payload = {
+            "unique_id": registry_entry.unique_id,
+            "service": call.service,
+            "data": call.data,
+        }
+
+        async_dispatcher_send(hass, DOMAIN, payload)
+
     assert coordinator.tcs is not None  # mypy
 
     hass.services.async_register(DOMAIN, EvoService.REFRESH_SYSTEM, force_refresh)
@@ -150,4 +163,16 @@ def setup_service_functions(
             schema=vol.Schema(vol.Any(*system_mode_schemas)),
         )
 
-    _register_zone_entity_services(hass)
+    # The zone modes are consistent across all systems and use the same schema
+    hass.services.async_register(
+        DOMAIN,
+        EvoService.RESET_ZONE_OVERRIDE,
+        set_zone_override,
+        schema=RESET_ZONE_OVERRIDE_SCHEMA,
+    )
+    hass.services.async_register(
+        DOMAIN,
+        EvoService.SET_ZONE_OVERRIDE,
+        set_zone_override,
+        schema=SET_ZONE_OVERRIDE_SCHEMA,
+    )

homeassistant/components/evohome/services.yaml

@@ -28,11 +28,14 @@ reset_system:
 refresh_system:
 
 set_zone_override:
-  target:
-    entity:
-      integration: evohome
-      domain: climate
   fields:
+    entity_id:
+      required: true
+      example: climate.bathroom
+      selector:
+        entity:
+          integration: evohome
+          domain: climate
     setpoint:
       required: true
       selector:
@@ -46,7 +49,10 @@ set_zone_override:
         object:
 
 clear_zone_override:
-  target:
-    entity:
-      integration: evohome
-      domain: climate
+  fields:
+    entity_id:
+      required: true
+      selector:
+        entity:
+          integration: evohome
+          domain: climate

homeassistant/components/evohome/strings.json

@@ -1,12 +1,13 @@
 {
-  "exceptions": {
-    "zone_only_service": {
-      "message": "Only zones support the `{service}` service"
-    }
-  },
   "services": {
     "clear_zone_override": {
       "description": "Sets a zone to follow its schedule.",
+      "fields": {
+        "entity_id": {
+          "description": "[%key:component::evohome::services::set_zone_override::fields::entity_id::description%]",
+          "name": "[%key:component::evohome::services::set_zone_override::fields::entity_id::name%]"
+        }
+      },
       "name": "Clear zone override"
     },
     "refresh_system": {
@@ -42,6 +43,10 @@
           "description": "The zone will revert to its schedule after this time. If 0 the change is until the next scheduled setpoint.",
           "name": "Duration"
         },
+        "entity_id": {
+          "description": "The entity ID of the Evohome zone.",
+          "name": "Entity"
+        },
         "setpoint": {
           "description": "The temperature to be used instead of the scheduled setpoint.",
           "name": "Setpoint"

homeassistant/components/fibaro/__init__.py

@@ -275,8 +275,11 @@ class FibaroController:
                 # otherwise add the first visible device in the group
                 # which is a hack, but solves a problem with FGT having
                 # hidden compatibility devices before the real device
-                if last_climate_parent != device.parent_fibaro_id or (
-                    device.has_endpoint_id and last_endpoint != device.endpoint_id
+                # Second hack is for quickapps which have parent id 0 and no children
+                if (
+                    last_climate_parent != device.parent_fibaro_id
+                    or (device.has_endpoint_id and last_endpoint != device.endpoint_id)
+                    or device.parent_fibaro_id == 0
                 ):
                     _LOGGER.debug("Handle separately")
                     self.fibaro_devices[platform].append(device)

homeassistant/components/frontend/manifest.json

@@ -21,5 +21,5 @@
   "integration_type": "system",
   "preview_features": { "winter_mode": {} },
   "quality_scale": "internal",
-  "requirements": ["home-assistant-frontend==20260226.0"]
+  "requirements": ["home-assistant-frontend==20260304.0"]
 }

homeassistant/components/ghost/config_flow.py

@@ -89,7 +89,7 @@ class GhostConfigFlow(ConfigFlow, domain=DOMAIN):
 
         site_title = site["title"]
 
-        await self.async_set_unique_id(site["uuid"])
+        await self.async_set_unique_id(site["site_uuid"])
         self._abort_if_unique_id_configured()
 
         return self.async_create_entry(

homeassistant/components/github/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["aiogithubapi"],
-  "requirements": ["aiogithubapi==24.6.0"]
+  "requirements": ["aiogithubapi==26.0.0"]
 }

homeassistant/components/hassio/__init__.py

@@ -21,7 +21,6 @@ from homeassistant.components.homeassistant import async_set_stop_handler
 from homeassistant.components.http import StaticPathConfig
 from homeassistant.config_entries import SOURCE_SYSTEM, ConfigEntry
 from homeassistant.const import (
-    ATTR_DEVICE_ID,
     ATTR_NAME,
     EVENT_CORE_CONFIG_UPDATE,
     HASSIO_USER_NAME,
@@ -35,13 +34,11 @@ from homeassistant.core import (
     async_get_hass_or_none,
     callback,
 )
-from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
 from homeassistant.helpers import (
     config_validation as cv,
     device_registry as dr,
     discovery_flow,
     issue_registry as ir,
-    selector,
 )
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.event import async_call_later
@@ -95,7 +92,6 @@ from .const import (
     DATA_SUPERVISOR_INFO,
     DOMAIN,
     HASSIO_UPDATE_INTERVAL,
-    SupervisorEntityModel,
 )
 from .coordinator import (
     HassioDataUpdateCoordinator,
@@ -151,7 +147,6 @@ SERVICE_BACKUP_FULL = "backup_full"
 SERVICE_BACKUP_PARTIAL = "backup_partial"
 SERVICE_RESTORE_FULL = "restore_full"
 SERVICE_RESTORE_PARTIAL = "restore_partial"
-SERVICE_MOUNT_RELOAD = "mount_reload"
 
 VALID_ADDON_SLUG = vol.Match(re.compile(r"^[-_.A-Za-z0-9]+$"))
 
@@ -234,19 +229,6 @@ SCHEMA_RESTORE_PARTIAL = SCHEMA_RESTORE_FULL.extend(
     }
 )
 
-SCHEMA_MOUNT_RELOAD = vol.Schema(
-    {
-        vol.Required(ATTR_DEVICE_ID): selector.DeviceSelector(
-            selector.DeviceSelectorConfig(
-                filter=selector.DeviceFilterSelectorConfig(
-                    integration=DOMAIN,
-                    model=SupervisorEntityModel.MOUNT,
-                )
-            )
-        )
-    }
-)
-
 
 def _is_32_bit() -> bool:
     size = struct.calcsize("P")
@@ -462,42 +444,6 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa:
             DOMAIN, service, async_service_handler, schema=settings.schema
         )
 
-    dev_reg = dr.async_get(hass)
-
-    async def async_mount_reload(service: ServiceCall) -> None:
-        """Handle service calls for Hass.io."""
-        coordinator: HassioDataUpdateCoordinator | None = None
-
-        if (device := dev_reg.async_get(service.data[ATTR_DEVICE_ID])) is None:
-            raise ServiceValidationError(
-                translation_domain=DOMAIN,
-                translation_key="mount_reload_unknown_device_id",
-            )
-
-        if (
-            device.name is None
-            or device.model != SupervisorEntityModel.MOUNT
-            or (coordinator := hass.data.get(ADDONS_COORDINATOR)) is None
-            or coordinator.entry_id not in device.config_entries
-        ):
-            raise ServiceValidationError(
-                translation_domain=DOMAIN,
-                translation_key="mount_reload_invalid_device",
-            )
-
-        try:
-            await supervisor_client.mounts.reload_mount(device.name)
-        except SupervisorError as error:
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="mount_reload_error",
-                translation_placeholders={"name": device.name, "error": str(error)},
-            ) from error
-
-    hass.services.async_register(
-        DOMAIN, SERVICE_MOUNT_RELOAD, async_mount_reload, SCHEMA_MOUNT_RELOAD
-    )
-
     async def update_info_data(_: datetime | None = None) -> None:
         """Update last available supervisor information."""
         supervisor_client = get_supervisor_client(hass)

homeassistant/components/hassio/icons.json

@@ -46,9 +46,6 @@
     "host_shutdown": {
       "service": "mdi:power"
     },
-    "mount_reload": {
-      "service": "mdi:reload"
-    },
     "restore_full": {
       "service": "mdi:backup-restore"
     },

homeassistant/components/hassio/services.yaml

@@ -165,13 +165,3 @@ restore_partial:
       example: "password"
       selector:
         text:
-
-mount_reload:
-  fields:
-    device_id:
-      required: true
-      selector:
-        device:
-          filter:
-            integration: hassio
-            model: Home Assistant Mount

homeassistant/components/hassio/strings.json

@@ -43,17 +43,6 @@
       }
     }
   },
-  "exceptions": {
-    "mount_reload_error": {
-      "message": "Failed to reload mount {name}: {error}"
-    },
-    "mount_reload_invalid_device": {
-      "message": "Device is not a supervisor mount point"
-    },
-    "mount_reload_unknown_device_id": {
-      "message": "Device ID not found"
-    }
-  },
   "issues": {
     "issue_addon_boot_fail": {
       "fix_flow": {
@@ -467,16 +456,6 @@
       "description": "Powers off the host system.",
       "name": "Power off the host system"
     },
-    "mount_reload": {
-      "description": "Reloads a network storage mount.",
-      "fields": {
-        "device_id": {
-          "description": "The device ID of the network storage mount to reload.",
-          "name": "Device ID"
-        }
-      },
-      "name": "Reload network storage mount"
-    },
     "restore_full": {
       "description": "Restores from full backup.",
       "fields": {

homeassistant/components/history_stats/__init__.py

@@ -16,14 +16,7 @@ from homeassistant.helpers.helper_integration import (
 )
 from homeassistant.helpers.template import Template
 
-from .const import (
-    CONF_DURATION,
-    CONF_END,
-    CONF_MIN_STATE_DURATION,
-    CONF_START,
-    PLATFORMS,
-    SECTION_ADVANCED_SETTINGS,
-)
+from .const import CONF_DURATION, CONF_END, CONF_START, PLATFORMS
 from .coordinator import HistoryStatsUpdateCoordinator
 from .data import HistoryStats
 
@@ -43,14 +36,8 @@ async def async_setup_entry(
     end: str | None = entry.options.get(CONF_END)
 
     duration: timedelta | None = None
-    min_state_duration: timedelta
     if duration_dict := entry.options.get(CONF_DURATION):
         duration = timedelta(**duration_dict)
-    advanced_settings = entry.options.get(SECTION_ADVANCED_SETTINGS, {})
-    if min_state_duration_dict := advanced_settings.get(CONF_MIN_STATE_DURATION):
-        min_state_duration = timedelta(**min_state_duration_dict)
-    else:
-        min_state_duration = timedelta(0)
 
     history_stats = HistoryStats(
         hass,
@@ -59,7 +46,6 @@ async def async_setup_entry(
         Template(start, hass) if start else None,
         Template(end, hass) if end else None,
         duration,
-        min_state_duration,
     )
     coordinator = HistoryStatsUpdateCoordinator(hass, history_stats, entry, entry.title)
     await coordinator.async_config_entry_first_refresh()

homeassistant/components/history_stats/config_flow.py

@@ -12,7 +12,6 @@ from homeassistant.components import websocket_api
 from homeassistant.components.sensor import CONF_STATE_CLASS, SensorStateClass
 from homeassistant.const import CONF_ENTITY_ID, CONF_NAME, CONF_STATE, CONF_TYPE
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.data_entry_flow import section
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.schema_config_entry_flow import (
     SchemaCommonFlowHandler,
@@ -38,7 +37,6 @@ from homeassistant.helpers.template import Template
 from .const import (
     CONF_DURATION,
     CONF_END,
-    CONF_MIN_STATE_DURATION,
     CONF_PERIOD_KEYS,
     CONF_START,
     CONF_TYPE_KEYS,
@@ -46,7 +44,6 @@ from .const import (
     CONF_TYPE_TIME,
     DEFAULT_NAME,
     DOMAIN,
-    SECTION_ADVANCED_SETTINGS,
 )
 from .coordinator import HistoryStatsUpdateCoordinator
 from .data import HistoryStats
@@ -142,7 +139,7 @@ def _get_options_schema_with_entity_id(entity_id: str, type: str) -> vol.Schema:
             vol.Optional(CONF_START): TemplateSelector(),
             vol.Optional(CONF_END): TemplateSelector(),
             vol.Optional(CONF_DURATION): DurationSelector(
-                DurationSelectorConfig(enable_day=True, allow_negative=False),
+                DurationSelectorConfig(enable_day=True, allow_negative=False)
             ),
             vol.Optional(CONF_STATE_CLASS): SelectSelector(
                 SelectSelectorConfig(
@@ -151,18 +148,6 @@ def _get_options_schema_with_entity_id(entity_id: str, type: str) -> vol.Schema:
                     mode=SelectSelectorMode.DROPDOWN,
                 ),
             ),
-            vol.Optional(SECTION_ADVANCED_SETTINGS): section(
-                vol.Schema(
-                    {
-                        vol.Optional(CONF_MIN_STATE_DURATION): DurationSelector(
-                            DurationSelectorConfig(
-                                enable_day=True, allow_negative=False
-                            )
-                        ),
-                    }
-                ),
-                {"collapsed": True},
-            ),
         }
     )
 
@@ -290,8 +275,6 @@ async def ws_start_preview(
     start = validated_data.get(CONF_START)
     end = validated_data.get(CONF_END)
     duration = validated_data.get(CONF_DURATION)
-    advanced_settings = validated_data.get(SECTION_ADVANCED_SETTINGS, {})
-    min_state_duration = advanced_settings.get(CONF_MIN_STATE_DURATION)
     state_class = validated_data.get(CONF_STATE_CLASS)
 
     history_stats = HistoryStats(
@@ -301,7 +284,6 @@ async def ws_start_preview(
         Template(start, hass) if start else None,
         Template(end, hass) if end else None,
         timedelta(**duration) if duration else None,
-        timedelta(**min_state_duration) if min_state_duration else timedelta(0),
         True,
     )
     coordinator = HistoryStatsUpdateCoordinator(hass, history_stats, None, name, True)

homeassistant/components/history_stats/const.py

@@ -8,7 +8,6 @@ PLATFORMS = [Platform.SENSOR]
 CONF_START = "start"
 CONF_END = "end"
 CONF_DURATION = "duration"
-CONF_MIN_STATE_DURATION = "min_state_duration"
 CONF_PERIOD_KEYS = [CONF_START, CONF_END, CONF_DURATION]
 
 CONF_TYPE_TIME = "time"
@@ -17,5 +16,3 @@ CONF_TYPE_COUNT = "count"
 CONF_TYPE_KEYS = [CONF_TYPE_TIME, CONF_TYPE_RATIO, CONF_TYPE_COUNT]
 
 DEFAULT_NAME = "unnamed statistics"
-
-SECTION_ADVANCED_SETTINGS = "advanced_settings"

homeassistant/components/history_stats/data.py

@@ -47,7 +47,6 @@ class HistoryStats:
         start: Template | None,
         end: Template | None,
         duration: datetime.timedelta | None,
-        min_state_duration: datetime.timedelta,
         preview: bool = False,
     ) -> None:
         """Init the history stats manager."""
@@ -59,7 +58,6 @@ class HistoryStats:
         self._has_recorder_data = False
         self._entity_states = set(entity_states)
         self._duration = duration
-        self._min_state_duration = min_state_duration.total_seconds()
         self._start = start
         self._end = end
         self._preview = preview
@@ -245,38 +243,18 @@ class HistoryStats:
                 )
                 break
 
-            if not previous_state_matches and current_state_matches:
-                # We are entering a matching state.
-                # This marks the start of a new candidate block that may later
-                # qualify if it lasts at least min_state_duration.
-                last_state_change_timestamp = max(
-                    start_timestamp, state_change_timestamp
-                )
-            elif previous_state_matches and not current_state_matches:
-                # We are leaving a matching state.
-                # This closes the current matching block and allows to
-                # evaluate its total duration.
-                block_duration = state_change_timestamp - last_state_change_timestamp
-                if block_duration >= self._min_state_duration:
-                    # The block lasted long enough so we increment match count
-                    # and accumulate its duration.
-                    elapsed += block_duration
-                    match_count += 1
+            if previous_state_matches:
+                elapsed += state_change_timestamp - last_state_change_timestamp
+            elif current_state_matches:
+                match_count += 1
 
             previous_state_matches = current_state_matches
+            last_state_change_timestamp = max(start_timestamp, state_change_timestamp)
 
         # Count time elapsed between last history state and end of measure
         if previous_state_matches:
-            # We are still inside a matching block at the end of the
-            # measurement window. This block has not been closed by a
-            # transition, so we evaluate it up to measure_end.
             measure_end = min(end_timestamp, now_timestamp)
-            last_state_duration = max(0, measure_end - last_state_change_timestamp)
-            if last_state_duration >= self._min_state_duration:
-                # The open block lasted long enough so we increment match count
-                # and accumulate its duration.
-                elapsed += last_state_duration
-                match_count += 1
+            elapsed += measure_end - last_state_change_timestamp
 
         # Save value in seconds
         seconds_matched = elapsed

homeassistant/components/history_stats/sensor.py

@@ -42,7 +42,6 @@ from . import HistoryStatsConfigEntry
 from .const import (
     CONF_DURATION,
     CONF_END,
-    CONF_MIN_STATE_DURATION,
     CONF_PERIOD_KEYS,
     CONF_START,
     CONF_TYPE_COUNT,
@@ -64,8 +63,6 @@ UNITS: dict[str, str] = {
 }
 ICON = "mdi:chart-line"
 
-DEFAULT_MIN_STATE_DURATION = datetime.timedelta(0)
-
 
 def exactly_two_period_keys[_T: dict[str, Any]](conf: _T) -> _T:
     """Ensure exactly 2 of CONF_PERIOD_KEYS are provided."""
@@ -94,9 +91,6 @@ PLATFORM_SCHEMA = vol.All(
             vol.Optional(CONF_START): cv.template,
             vol.Optional(CONF_END): cv.template,
             vol.Optional(CONF_DURATION): cv.time_period,
-            vol.Optional(
-                CONF_MIN_STATE_DURATION, default=DEFAULT_MIN_STATE_DURATION
-            ): cv.time_period,
             vol.Optional(CONF_TYPE, default=CONF_TYPE_TIME): vol.In(CONF_TYPE_KEYS),
             vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
             vol.Optional(CONF_UNIQUE_ID): cv.string,
@@ -126,7 +120,6 @@ async def async_setup_platform(
     start: Template | None = config.get(CONF_START)
     end: Template | None = config.get(CONF_END)
     duration: datetime.timedelta | None = config.get(CONF_DURATION)
-    min_state_duration: datetime.timedelta = config[CONF_MIN_STATE_DURATION]
     sensor_type: str = config[CONF_TYPE]
     name: str = config[CONF_NAME]
     unique_id: str | None = config.get(CONF_UNIQUE_ID)
@@ -134,9 +127,7 @@ async def async_setup_platform(
         CONF_STATE_CLASS, SensorStateClass.MEASUREMENT
     )
 
-    history_stats = HistoryStats(
-        hass, entity_id, entity_states, start, end, duration, min_state_duration
-    )
+    history_stats = HistoryStats(hass, entity_id, entity_states, start, end, duration)
     coordinator = HistoryStatsUpdateCoordinator(hass, history_stats, None, name)
     await coordinator.async_refresh()
     if not coordinator.last_update_success:

homeassistant/components/history_stats/strings.json

@@ -19,23 +19,14 @@
         },
         "data_description": {
           "duration": "Duration of the measure.",
-          "end": "When to stop the measure (timestamp or datetime). Can be a template.",
+          "end": "When to stop the measure (timestamp or datetime). Can be a template",
           "entity_id": "[%key:component::history_stats::config::step::user::data_description::entity_id%]",
           "start": "When to start the measure (timestamp or datetime). Can be a template.",
           "state": "[%key:component::history_stats::config::step::user::data_description::state%]",
           "state_class": "The state class for statistics calculation.",
           "type": "[%key:component::history_stats::config::step::user::data_description::type%]"
         },
-        "description": "Read the documentation for further details on how to configure the history stats sensor using these options.",
-        "sections": {
-          "advanced_settings": {
-            "data": { "min_state_duration": "Minimum state duration" },
-            "data_description": {
-              "min_state_duration": "The minimum state duration to account for the statistics. Default is 0 seconds."
-            },
-            "name": "Advanced settings"
-          }
-        }
+        "description": "Read the documentation for further details on how to configure the history stats sensor using these options."
       },
       "state": {
         "data": {
@@ -91,18 +82,7 @@
           "state_class": "The state class for statistics calculation. Changing the state class will require statistics to be reset.",
           "type": "[%key:component::history_stats::config::step::user::data_description::type%]"
         },
-        "description": "[%key:component::history_stats::config::step::options::description%]",
-        "sections": {
-          "advanced_settings": {
-            "data": {
-              "min_state_duration": "[%key:component::history_stats::config::step::options::sections::advanced_settings::data::min_state_duration%]"
-            },
-            "data_description": {
-              "min_state_duration": "[%key:component::history_stats::config::step::options::sections::advanced_settings::data_description::min_state_duration%]"
-            },
-            "name": "[%key:component::history_stats::config::step::options::sections::advanced_settings::name%]"
-          }
-        }
+        "description": "[%key:component::history_stats::config::step::options::description%]"
       }
     }
   },

homeassistant/components/hive/manifest.json

@@ -10,5 +10,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["apyhiveapi"],
-  "requirements": ["pyhive-integration==1.0.7"]
+  "requirements": ["pyhive-integration==1.0.8"]
 }

homeassistant/components/homematicip_cloud/climate.py

@@ -88,6 +88,17 @@ class HomematicipHeatingGroup(HomematicipGenericEntity, ClimateEntity):
         if device.actualTemperature is None:
             self._simple_heating = self._first_radiator_thermostat
 
+    @property
+    def available(self) -> bool:
+        """Heating group available.
+
+        A heating group must be available, and should not be affected by the
+        individual availability of group members.
+        This allows controlling the temperature even when individual group
+        members are not available.
+        """
+        return True
+
     @property
     def device_info(self) -> DeviceInfo:
         """Return device specific attributes."""

homeassistant/components/homematicip_cloud/cover.py

@@ -312,6 +312,17 @@ class HomematicipCoverShutterGroup(HomematicipGenericEntity, CoverEntity):
         device.modelType = f"HmIP-{post}"
         super().__init__(hap, device, post, is_multi_channel=False)
 
+    @property
+    def available(self) -> bool:
+        """Cover shutter group available.
+
+        A cover shutter group must be available, and should not be affected by
+        the individual availability of group members.
+        This allows controlling the shutters even when individual group
+        members are not available.
+        """
+        return True
+
     @property
     def current_cover_position(self) -> int | None:
         """Return current position of cover."""

homeassistant/components/homevolt/sensor.py

@@ -91,14 +91,14 @@ SENSORS: tuple[SensorEntityDescription, ...] = (
         translation_key="energy_exported",
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
+        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
     ),
     SensorEntityDescription(
         key="energy_imported",
         translation_key="energy_imported",
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
+        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
     ),
     SensorEntityDescription(
         key="frequency",

homeassistant/components/homewizard/sensor.py

@@ -610,6 +610,7 @@ SENSORS: Final[tuple[HomeWizardSensorEntityDescription, ...]] = (
         key="active_liter_lpm",
         translation_key="active_liter_lpm",
         native_unit_of_measurement=UnitOfVolumeFlowRate.LITERS_PER_MINUTE,
+        device_class=SensorDeviceClass.VOLUME_FLOW_RATE,
         state_class=SensorStateClass.MEASUREMENT,
         has_fn=lambda data: data.measurement.active_liter_lpm is not None,
         value_fn=lambda data: data.measurement.active_liter_lpm,

homeassistant/components/hunterdouglas_powerview/cover.py

@@ -901,7 +901,9 @@ class PowerViewShadeDualOverlappedRear(PowerViewShadeDualOverlappedBase):
         )
 
 
-class PowerViewShadeDualOverlappedCombinedTilt(PowerViewShadeDualOverlappedCombined):
+class PowerViewShadeDualOverlappedCombinedTilt(
+    PowerViewShadeDualOverlappedCombined, PowerViewShadeWithTiltBase
+):
     """Represent a shade that has a front sheer and rear opaque panel.
 
     This equates to two shades being controlled by one motor.
@@ -915,26 +917,6 @@ class PowerViewShadeDualOverlappedCombinedTilt(PowerViewShadeDualOverlappedCombi
     Type 10 - Duolite with 180° Tilt
     """
 
-    # type
-    def __init__(
-        self,
-        coordinator: PowerviewShadeUpdateCoordinator,
-        device_info: PowerviewDeviceInfo,
-        room_name: str,
-        shade: BaseShade,
-        name: str,
-    ) -> None:
-        """Initialize the shade."""
-        super().__init__(coordinator, device_info, room_name, shade, name)
-        self._attr_supported_features |= (
-            CoverEntityFeature.OPEN_TILT
-            | CoverEntityFeature.CLOSE_TILT
-            | CoverEntityFeature.SET_TILT_POSITION
-        )
-        if self._shade.is_supported(MOTION_STOP):
-            self._attr_supported_features |= CoverEntityFeature.STOP_TILT
-        self._max_tilt = self._shade.shade_limits.tilt_max
-
     @property
     def transition_steps(self) -> int:
         """Return the steps to make a move."""
@@ -949,26 +931,6 @@ class PowerViewShadeDualOverlappedCombinedTilt(PowerViewShadeDualOverlappedCombi
         tilt = self.positions.tilt
         return ceil(primary + secondary + tilt)
 
-    @callback
-    def _get_shade_tilt(self, target_hass_tilt_position: int) -> ShadePosition:
-        """Return a ShadePosition."""
-        return ShadePosition(
-            tilt=target_hass_tilt_position,
-            velocity=self.positions.velocity,
-        )
-
-    @property
-    def open_tilt_position(self) -> ShadePosition:
-        """Return the open tilt position and required additional positions."""
-        return replace(self._shade.open_position_tilt, velocity=self.positions.velocity)
-
-    @property
-    def close_tilt_position(self) -> ShadePosition:
-        """Return the open tilt position and required additional positions."""
-        return replace(
-            self._shade.close_position_tilt, velocity=self.positions.velocity
-        )
-
 
 TYPE_TO_CLASSES = {
     0: (PowerViewShade,),

homeassistant/components/indevolt/strings.json

@@ -57,8 +57,8 @@
       "battery_charge_discharge_state": {
         "name": "Battery charge/discharge state",
         "state": {
-          "charging": "Charging",
-          "discharging": "Discharging",
+          "charging": "[%key:common::state::charging%]",
+          "discharging": "[%key:common::state::discharging%]",
           "static": "Static"
         }
       },

homeassistant/components/influxdb/__init__.py

@@ -43,6 +43,7 @@ from homeassistant.const import (
     STATE_UNKNOWN,
 )
 from homeassistant.core import Event, HomeAssistant, State, callback
+from homeassistant.data_entry_flow import FlowResultType
 from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers import config_validation as cv, state as state_helper
 from homeassistant.helpers.entity_values import EntityValues
@@ -61,6 +62,7 @@ from .const import (
     CLIENT_ERROR_V2,
     CODE_INVALID_INPUTS,
     COMPONENT_CONFIG_SCHEMA_CONNECTION,
+    COMPONENT_CONFIG_SCHEMA_CONNECTION_VALIDATORS,
     CONF_API_VERSION,
     CONF_BUCKET,
     CONF_COMPONENT_CONFIG,
@@ -79,7 +81,6 @@ from .const import (
     CONF_TAGS_ATTRIBUTES,
     CONNECTION_ERROR,
     DEFAULT_API_VERSION,
-    DEFAULT_HOST,
     DEFAULT_HOST_V2,
     DEFAULT_MEASUREMENT_ATTR,
     DEFAULT_SSL_V2,
@@ -104,6 +105,7 @@ from .const import (
     WRITE_ERROR,
     WROTE_MESSAGE,
 )
+from .issue import async_create_deprecated_yaml_issue
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -137,7 +139,7 @@ def create_influx_url(conf: dict) -> dict:
 
 def validate_version_specific_config(conf: dict) -> dict:
     """Ensure correct config fields are provided based on API version used."""
-    if conf[CONF_API_VERSION] == API_VERSION_2:
+    if conf.get(CONF_API_VERSION, DEFAULT_API_VERSION) == API_VERSION_2:
         if CONF_TOKEN not in conf:
             raise vol.Invalid(
                 f"{CONF_TOKEN} and {CONF_BUCKET} are required when"
@@ -193,32 +195,13 @@ _INFLUX_BASE_SCHEMA = INCLUDE_EXCLUDE_BASE_FILTER_SCHEMA.extend(
     }
 )
 
-INFLUX_SCHEMA = vol.All(
-    _INFLUX_BASE_SCHEMA.extend(COMPONENT_CONFIG_SCHEMA_CONNECTION),
-    validate_version_specific_config,
-    create_influx_url,
+INFLUX_SCHEMA = _INFLUX_BASE_SCHEMA.extend(
+    COMPONENT_CONFIG_SCHEMA_CONNECTION_VALIDATORS
 )
 
 
 CONFIG_SCHEMA = vol.Schema(
-    {
-        DOMAIN: vol.All(
-            cv.deprecated(CONF_API_VERSION),
-            cv.deprecated(CONF_HOST),
-            cv.deprecated(CONF_PATH),
-            cv.deprecated(CONF_PORT),
-            cv.deprecated(CONF_SSL),
-            cv.deprecated(CONF_VERIFY_SSL),
-            cv.deprecated(CONF_SSL_CA_CERT),
-            cv.deprecated(CONF_USERNAME),
-            cv.deprecated(CONF_PASSWORD),
-            cv.deprecated(CONF_DB_NAME),
-            cv.deprecated(CONF_TOKEN),
-            cv.deprecated(CONF_ORG),
-            cv.deprecated(CONF_BUCKET),
-            INFLUX_SCHEMA,
-        )
-    },
+    {DOMAIN: vol.All(INFLUX_SCHEMA, validate_version_specific_config)},
     extra=vol.ALLOW_EXTRA,
 )
 
@@ -499,23 +482,35 @@ def get_influx_connection(  # noqa: C901
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the InfluxDB component."""
-    conf = config.get(DOMAIN)
+    if DOMAIN not in config:
+        return True
 
-    if conf is not None:
-        if CONF_HOST not in conf and conf[CONF_API_VERSION] == DEFAULT_API_VERSION:
-            conf[CONF_HOST] = DEFAULT_HOST
-
-        hass.async_create_task(
-            hass.config_entries.flow.async_init(
-                DOMAIN,
-                context={"source": SOURCE_IMPORT},
-                data=conf,
-            )
-        )
+    hass.async_create_task(_async_setup(hass, config[DOMAIN]))
 
     return True
 
 
+async def _async_setup(hass: HomeAssistant, config: dict[str, Any]) -> None:
+    """Import YAML configuration into a config entry."""
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN,
+        context={"source": SOURCE_IMPORT},
+        data=config,
+    )
+    if (
+        result.get("type") is FlowResultType.ABORT
+        and (reason := result["reason"]) != "single_instance_allowed"
+    ):
+        async_create_deprecated_yaml_issue(hass, error=reason)
+        return
+
+    # If we are here, the entry already exists (single instance allowed)
+    if config.keys() & (
+        {k.schema for k in COMPONENT_CONFIG_SCHEMA_CONNECTION} - {CONF_PRECISION}
+    ):
+        async_create_deprecated_yaml_issue(hass)
+
+
 async def async_setup_entry(hass: HomeAssistant, entry: InfluxDBConfigEntry) -> bool:
     """Set up InfluxDB from a config entry."""
     data = entry.data

homeassistant/components/influxdb/config_flow.py

@@ -31,7 +31,7 @@ from homeassistant.helpers.selector import (
 )
 from homeassistant.helpers.storage import STORAGE_DIR
 
-from . import DOMAIN, get_influx_connection
+from . import DOMAIN, create_influx_url, get_influx_connection
 from .const import (
     API_VERSION_2,
     CONF_API_VERSION,
@@ -40,8 +40,11 @@ from .const import (
     CONF_ORG,
     CONF_SSL_CA_CERT,
     DEFAULT_API_VERSION,
+    DEFAULT_BUCKET,
+    DEFAULT_DATABASE,
     DEFAULT_HOST,
     DEFAULT_PORT,
+    DEFAULT_VERIFY_SSL,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -240,14 +243,17 @@ class InfluxDBConfigFlow(ConfigFlow, domain=DOMAIN):
 
     async def async_step_import(self, import_data: dict[str, Any]) -> ConfigFlowResult:
         """Handle the initial step."""
-        host = import_data.get(CONF_HOST)
-        database = import_data.get(CONF_DB_NAME)
-        bucket = import_data.get(CONF_BUCKET)
+        import_data = {**import_data}
+        import_data.setdefault(CONF_API_VERSION, DEFAULT_API_VERSION)
+        import_data.setdefault(CONF_VERIFY_SSL, DEFAULT_VERIFY_SSL)
+        import_data.setdefault(CONF_DB_NAME, DEFAULT_DATABASE)
+        import_data.setdefault(CONF_BUCKET, DEFAULT_BUCKET)
 
-        api_version = import_data.get(CONF_API_VERSION)
-        ssl = import_data.get(CONF_SSL)
+        api_version = import_data[CONF_API_VERSION]
 
         if api_version == DEFAULT_API_VERSION:
+            host = import_data.get(CONF_HOST, DEFAULT_HOST)
+            database = import_data[CONF_DB_NAME]
             title = f"{database} ({host})"
             data = {
                 CONF_API_VERSION: api_version,
@@ -256,21 +262,23 @@ class InfluxDBConfigFlow(ConfigFlow, domain=DOMAIN):
                 CONF_USERNAME: import_data.get(CONF_USERNAME),
                 CONF_PASSWORD: import_data.get(CONF_PASSWORD),
                 CONF_DB_NAME: database,
-                CONF_SSL: ssl,
+                CONF_SSL: import_data.get(CONF_SSL),
                 CONF_PATH: import_data.get(CONF_PATH),
-                CONF_VERIFY_SSL: import_data.get(CONF_VERIFY_SSL),
+                CONF_VERIFY_SSL: import_data[CONF_VERIFY_SSL],
                 CONF_SSL_CA_CERT: import_data.get(CONF_SSL_CA_CERT),
             }
         else:
+            create_influx_url(import_data)  # Only modifies dict for api_version == 2
+            bucket = import_data[CONF_BUCKET]
             url = import_data.get(CONF_URL)
             title = f"{bucket} ({url})"
             data = {
                 CONF_API_VERSION: api_version,
-                CONF_URL: import_data.get(CONF_URL),
+                CONF_URL: url,
                 CONF_TOKEN: import_data.get(CONF_TOKEN),
                 CONF_ORG: import_data.get(CONF_ORG),
                 CONF_BUCKET: bucket,
-                CONF_VERIFY_SSL: import_data.get(CONF_VERIFY_SSL),
+                CONF_VERIFY_SSL: import_data[CONF_VERIFY_SSL],
                 CONF_SSL_CA_CERT: import_data.get(CONF_SSL_CA_CERT),
             }
 

homeassistant/components/influxdb/const.py

@@ -154,3 +154,14 @@ COMPONENT_CONFIG_SCHEMA_CONNECTION = {
     vol.Inclusive(CONF_ORG, "v2_authentication"): cv.string,
     vol.Optional(CONF_BUCKET, default=DEFAULT_BUCKET): cv.string,
 }
+
+# Same keys without defaults, used in CONFIG_SCHEMA to validate
+# without injecting default values (so we can detect explicit keys).
+COMPONENT_CONFIG_SCHEMA_CONNECTION_VALIDATORS = {
+    (
+        vol.Optional(k.schema)
+        if isinstance(k, vol.Optional) and k.default is not vol.UNDEFINED
+        else k
+    ): v
+    for k, v in COMPONENT_CONFIG_SCHEMA_CONNECTION.items()
+}

homeassistant/components/influxdb/issue.py

@@ -0,0 +1,34 @@
+"""Issues for InfluxDB integration."""
+
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
+
+from .const import DOMAIN
+
+
+@callback
+def async_create_deprecated_yaml_issue(
+    hass: HomeAssistant, *, error: str | None = None
+) -> None:
+    """Create a repair issue for deprecated YAML connection configuration."""
+    if error is None:
+        issue_id = "deprecated_yaml"
+        severity = IssueSeverity.WARNING
+    else:
+        issue_id = f"deprecated_yaml_import_issue_{error}"
+        severity = IssueSeverity.ERROR
+
+    async_create_issue(
+        hass,
+        DOMAIN,
+        issue_id,
+        is_fixable=False,
+        issue_domain=DOMAIN,
+        breaks_in_ha_version="2026.9.0",
+        severity=severity,
+        translation_key=issue_id,
+        translation_placeholders={
+            "domain": DOMAIN,
+            "url": f"/config/integrations/dashboard/add?domain={DOMAIN}",
+        },
+    )

homeassistant/components/influxdb/manifest.json

@@ -7,7 +7,6 @@
   "documentation": "https://www.home-assistant.io/integrations/influxdb",
   "iot_class": "local_push",
   "loggers": ["influxdb", "influxdb_client"],
-  "quality_scale": "legacy",
   "requirements": ["influxdb==5.3.1", "influxdb-client==1.50.0"],
   "single_config_entry": true
 }

homeassistant/components/influxdb/strings.json

@@ -54,5 +54,31 @@
         "title": "Choose InfluxDB version"
       }
     }
+  },
+  "issues": {
+    "deprecated_yaml": {
+      "description": "Configuring InfluxDB connection settings using YAML is being removed. Your existing YAML connection configuration has been imported into the UI automatically.\n\nRemove the `{domain}` connection and authentication keys from your `configuration.yaml` file and restart Home Assistant to fix this issue. Other options like `include`, `exclude`, and `tags` remain in YAML for now. \n\nThe following keys should be removed:\n- `api_version`\n- `host`\n- `port`\n- `ssl`\n- `verify_ssl`\n- `ssl_ca_cert`\n- `username`\n- `password`\n- `database`\n- `token`\n- `organization`\n- `bucket`\n- `path`",
+      "title": "The InfluxDB YAML configuration is being removed"
+    },
+    "deprecated_yaml_import_issue_cannot_connect": {
+      "description": "Configuring InfluxDB connection settings using YAML is being removed but the import failed because Home Assistant could not connect to the InfluxDB server.\n\nPlease correct your YAML configuration and restart Home Assistant.\n\nAlternatively you can remove the `{domain}` connection and authentication keys from your `configuration.yaml` file and continue to [set up the integration]({url}) manually. \n\nThe following keys should be removed:\n- `api_version`\n- `host`\n- `port`\n- `ssl`\n- `verify_ssl`\n- `ssl_ca_cert`\n- `username`\n- `password`\n- `database`\n- `token`\n- `organization`\n- `bucket`\n- `path`",
+      "title": "Failed to import InfluxDB YAML configuration"
+    },
+    "deprecated_yaml_import_issue_invalid_auth": {
+      "description": "Configuring InfluxDB connection settings using YAML is being removed but the import failed because the provided credentials are invalid.\n\nPlease correct your YAML configuration and restart Home Assistant.\n\nAlternatively you can remove the `{domain}` connection and authentication keys from your `configuration.yaml` file and continue to [set up the integration]({url}) manually. \n\nThe following keys should be removed:\n- `api_version`\n- `host`\n- `port`\n- `ssl`\n- `verify_ssl`\n- `ssl_ca_cert`\n- `username`\n- `password`\n- `database`\n- `token`\n- `organization`\n- `bucket`\n- `path`",
+      "title": "[%key:component::influxdb::issues::deprecated_yaml_import_issue_cannot_connect::title%]"
+    },
+    "deprecated_yaml_import_issue_invalid_database": {
+      "description": "Configuring InfluxDB connection settings using YAML is being removed but the import failed because the specified database was not found.\n\nPlease correct your YAML configuration and restart Home Assistant.\n\nAlternatively you can remove the `{domain}` connection and authentication keys from your `configuration.yaml` file and continue to [set up the integration]({url}) manually. \n\nThe following keys should be removed:\n- `api_version`\n- `host`\n- `port`\n- `ssl`\n- `verify_ssl`\n- `ssl_ca_cert`\n- `username`\n- `password`\n- `database`\n- `token`\n- `organization`\n- `bucket`\n- `path`",
+      "title": "[%key:component::influxdb::issues::deprecated_yaml_import_issue_cannot_connect::title%]"
+    },
+    "deprecated_yaml_import_issue_ssl_error": {
+      "description": "Configuring InfluxDB connection settings using YAML is being removed but the import failed due to an SSL certificate error.\n\nPlease correct your YAML configuration and restart Home Assistant.\n\nAlternatively you can remove the `{domain}` connection and authentication keys from your `configuration.yaml` file and continue to [set up the integration]({url}) manually. \n\nThe following keys should be removed:\n- `api_version`\n- `host`\n- `port`\n- `ssl`\n- `verify_ssl`\n- `ssl_ca_cert`\n- `username`\n- `password`\n- `database`\n- `token`\n- `organization`\n- `bucket`\n- `path`",
+      "title": "[%key:component::influxdb::issues::deprecated_yaml_import_issue_cannot_connect::title%]"
+    },
+    "deprecated_yaml_import_issue_unknown": {
+      "description": "Configuring InfluxDB connection settings using YAML is being removed but the import failed due to an unknown error.\n\nPlease correct your YAML configuration and restart Home Assistant.\n\nAlternatively you can remove the `{domain}` connection and authentication keys from your `configuration.yaml` file and continue to [set up the integration]({url}) manually. \n\nThe following keys should be removed:\n- `api_version`\n- `host`\n- `port`\n- `ssl`\n- `verify_ssl`\n- `ssl_ca_cert`\n- `username`\n- `password`\n- `database`\n- `token`\n- `organization`\n- `bucket`\n- `path`",
+      "title": "[%key:component::influxdb::issues::deprecated_yaml_import_issue_cannot_connect::title%]"
+    }
   }
 }

homeassistant/components/infrared/__init__.py

@@ -1,153 +0,0 @@
-"""Provides functionality to interact with infrared devices."""
-
-from __future__ import annotations
-
-from abc import abstractmethod
-from datetime import timedelta
-import logging
-from typing import final
-
-from infrared_protocols import Command as InfraredCommand
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import STATE_UNAVAILABLE
-from homeassistant.core import Context, HomeAssistant, callback
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import config_validation as cv, entity_registry as er
-from homeassistant.helpers.entity import EntityDescription
-from homeassistant.helpers.entity_component import EntityComponent
-from homeassistant.helpers.restore_state import RestoreEntity
-from homeassistant.helpers.typing import ConfigType
-from homeassistant.util import dt as dt_util
-from homeassistant.util.hass_dict import HassKey
-
-from .const import DOMAIN
-
-__all__ = [
-    "DOMAIN",
-    "InfraredEntity",
-    "InfraredEntityDescription",
-    "async_get_emitters",
-    "async_send_command",
-]
-
-_LOGGER = logging.getLogger(__name__)
-
-DATA_COMPONENT: HassKey[EntityComponent[InfraredEntity]] = HassKey(DOMAIN)
-ENTITY_ID_FORMAT = DOMAIN + ".{}"
-PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA
-PLATFORM_SCHEMA_BASE = cv.PLATFORM_SCHEMA_BASE
-SCAN_INTERVAL = timedelta(seconds=30)
-
-
-async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
-    """Set up the infrared domain."""
-    component = hass.data[DATA_COMPONENT] = EntityComponent[InfraredEntity](
-        _LOGGER, DOMAIN, hass, SCAN_INTERVAL
-    )
-    await component.async_setup(config)
-
-    return True
-
-
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
-    """Set up a config entry."""
-    return await hass.data[DATA_COMPONENT].async_setup_entry(entry)
-
-
-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
-    """Unload a config entry."""
-    return await hass.data[DATA_COMPONENT].async_unload_entry(entry)
-
-
-@callback
-def async_get_emitters(hass: HomeAssistant) -> list[InfraredEntity]:
-    """Get all infrared emitters."""
-    component = hass.data.get(DATA_COMPONENT)
-    if component is None:
-        return []
-
-    return list(component.entities)
-
-
-async def async_send_command(
-    hass: HomeAssistant,
-    entity_id_or_uuid: str,
-    command: InfraredCommand,
-    context: Context | None = None,
-) -> None:
-    """Send an IR command to the specified infrared entity.
-
-    Raises:
-        HomeAssistantError: If the infrared entity is not found.
-    """
-    component = hass.data.get(DATA_COMPONENT)
-    if component is None:
-        raise HomeAssistantError(
-            translation_domain=DOMAIN,
-            translation_key="component_not_loaded",
-        )
-
-    ent_reg = er.async_get(hass)
-    entity_id = er.async_validate_entity_id(ent_reg, entity_id_or_uuid)
-    entity = component.get_entity(entity_id)
-    if entity is None:
-        raise HomeAssistantError(
-            translation_domain=DOMAIN,
-            translation_key="entity_not_found",
-            translation_placeholders={"entity_id": entity_id},
-        )
-
-    if context is not None:
-        entity.async_set_context(context)
-
-    await entity.async_send_command_internal(command)
-
-
-class InfraredEntityDescription(EntityDescription, frozen_or_thawed=True):
-    """Describes infrared entities."""
-
-
-class InfraredEntity(RestoreEntity):
-    """Base class for infrared transmitter entities."""
-
-    entity_description: InfraredEntityDescription
-    _attr_should_poll = False
-    _attr_state: None = None
-
-    __last_command_sent: str | None = None
-
-    @property
-    @final
-    def state(self) -> str | None:
-        """Return the entity state."""
-        return self.__last_command_sent
-
-    @final
-    async def async_send_command_internal(self, command: InfraredCommand) -> None:
-        """Send an IR command and update state.
-
-        Should not be overridden, handles setting last sent timestamp.
-        """
-        await self.async_send_command(command)
-        self.__last_command_sent = dt_util.utcnow().isoformat(timespec="milliseconds")
-        self.async_write_ha_state()
-
-    @final
-    async def async_internal_added_to_hass(self) -> None:
-        """Call when the infrared entity is added to hass."""
-        await super().async_internal_added_to_hass()
-        state = await self.async_get_last_state()
-        if state is not None and state.state not in (STATE_UNAVAILABLE, None):
-            self.__last_command_sent = state.state
-
-    @abstractmethod
-    async def async_send_command(self, command: InfraredCommand) -> None:
-        """Send an IR command.
-
-        Args:
-            command: The IR command to send.
-
-        Raises:
-            HomeAssistantError: If transmission fails.
-        """

homeassistant/components/infrared/const.py

@@ -1,5 +0,0 @@
-"""Constants for the Infrared integration."""
-
-from typing import Final
-
-DOMAIN: Final = "infrared"

homeassistant/components/infrared/icons.json

@@ -1,7 +0,0 @@
-{
-  "entity_component": {
-    "_": {
-      "default": "mdi:led-on"
-    }
-  }
-}

homeassistant/components/infrared/manifest.json

@@ -1,9 +0,0 @@
-{
-  "domain": "infrared",
-  "name": "Infrared",
-  "codeowners": ["@home-assistant/core"],
-  "documentation": "https://www.home-assistant.io/integrations/infrared",
-  "integration_type": "entity",
-  "quality_scale": "internal",
-  "requirements": ["infrared-protocols==1.0.0"]
-}

homeassistant/components/infrared/strings.json

@@ -1,10 +0,0 @@
-{
-  "exceptions": {
-    "component_not_loaded": {
-      "message": "Infrared component not loaded"
-    },
-    "entity_not_found": {
-      "message": "Infrared entity `{entity_id}` not found"
-    }
-  }
-}

homeassistant/components/intesishome/climate.py

@@ -221,13 +221,13 @@ class IntesisAC(ClimateEntity):
     def extra_state_attributes(self) -> dict[str, Any]:
         """Return the device specific state attributes."""
         attrs = {}
-        if self._outdoor_temp:
+        if self._outdoor_temp is not None:
             attrs["outdoor_temp"] = self._outdoor_temp
-        if self._power_consumption_heat:
+        if self._power_consumption_heat is not None:
             attrs["power_consumption_heat_kw"] = round(
                 self._power_consumption_heat / 1000, 1
             )
-        if self._power_consumption_cool:
+        if self._power_consumption_cool is not None:
             attrs["power_consumption_cool_kw"] = round(
                 self._power_consumption_cool / 1000, 1
             )
@@ -244,7 +244,7 @@ class IntesisAC(ClimateEntity):
         if hvac_mode := kwargs.get(ATTR_HVAC_MODE):
             await self.async_set_hvac_mode(hvac_mode)
 
-        if temperature := kwargs.get(ATTR_TEMPERATURE):
+        if (temperature := kwargs.get(ATTR_TEMPERATURE)) is not None:
             _LOGGER.debug("Setting %s to %s degrees", self._device_type, temperature)
             await self._controller.set_temperature(self._device_id, temperature)
             self._attr_target_temperature = temperature
@@ -271,7 +271,7 @@ class IntesisAC(ClimateEntity):
         await self._controller.set_mode(self._device_id, MAP_HVAC_MODE_TO_IH[hvac_mode])
 
         # Send the temperature again in case changing modes has changed it
-        if self._attr_target_temperature:
+        if self._attr_target_temperature is not None:
             await self._controller.set_temperature(
                 self._device_id, self._attr_target_temperature
             )

homeassistant/components/iron_os/number.py

@@ -358,7 +358,7 @@ PINECIL_SETPOINT_NUMBER_DESCRIPTION = IronOSNumberEntityDescription(
     native_max_value=MAX_TEMP,
     native_min_value_f=MIN_TEMP_F,
     native_max_value_f=MAX_TEMP_F,
-    native_step=5,
+    native_step=1,
 )
 
 

homeassistant/components/keyboard_remote/manifest.json

@@ -7,5 +7,5 @@
   "iot_class": "local_push",
   "loggers": ["aionotify", "evdev"],
   "quality_scale": "legacy",
-  "requirements": ["evdev==1.6.1", "asyncinotify==4.2.0"]
+  "requirements": ["evdev==1.9.3", "asyncinotify==4.4.0"]
 }

homeassistant/components/kitchen_sink/__init__.py

@@ -56,9 +56,7 @@ from .const import DATA_BACKUP_AGENT_LISTENERS, DOMAIN
 
 COMPONENTS_WITH_DEMO_PLATFORM = [
     Platform.BUTTON,
-    Platform.FAN,
     Platform.IMAGE,
-    Platform.INFRARED,
     Platform.LAWN_MOWER,
     Platform.LOCK,
     Platform.NOTIFY,
@@ -133,9 +131,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     # Notify backup listeners
     hass.async_create_task(_notify_backup_listeners(hass), eager_start=False)
 
-    # Reload config entry when subentries are added/removed/updated
-    entry.async_on_unload(entry.add_update_listener(_async_update_listener))
-
     # Subscribe to labs feature updates for kitchen_sink preview repair
     entry.async_on_unload(
         async_subscribe_preview_feature(
@@ -152,11 +147,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     return True
 
 
-async def _async_update_listener(hass: HomeAssistant, entry: ConfigEntry) -> None:
-    """Reload config entry on update (e.g. subentry added/removed)."""
-    await hass.config_entries.async_reload(entry.entry_id)
-
-
 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload config entry."""
     # Notify backup listeners

homeassistant/components/kitchen_sink/config_flow.py

@@ -8,23 +8,18 @@ from typing import Any
 import voluptuous as vol
 
 from homeassistant import data_entry_flow
-from homeassistant.components.infrared import (
-    DOMAIN as INFRARED_DOMAIN,
-    async_get_emitters,
-)
 from homeassistant.config_entries import (
     ConfigEntry,
     ConfigFlow,
     ConfigFlowResult,
     ConfigSubentryFlow,
-    OptionsFlow,
+    OptionsFlowWithReload,
     SubentryFlowResult,
 )
 from homeassistant.core import callback
 from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.selector import EntitySelector, EntitySelectorConfig
 
-from .const import CONF_INFRARED_ENTITY_ID, DOMAIN
+from . import DOMAIN
 
 CONF_BOOLEAN = "bool"
 CONF_INT = "int"
@@ -49,10 +44,7 @@ class KitchenSinkConfigFlow(ConfigFlow, domain=DOMAIN):
         cls, config_entry: ConfigEntry
     ) -> dict[str, type[ConfigSubentryFlow]]:
         """Return subentries supported by this handler."""
-        return {
-            "entity": SubentryFlowHandler,
-            "infrared_fan": InfraredFanSubentryFlowHandler,
-        }
+        return {"entity": SubentryFlowHandler}
 
     async def async_step_import(self, import_data: dict[str, Any]) -> ConfigFlowResult:
         """Set the config entry up from yaml."""
@@ -73,7 +65,7 @@ class KitchenSinkConfigFlow(ConfigFlow, domain=DOMAIN):
         return self.async_abort(reason="reauth_successful")
 
 
-class OptionsFlowHandler(OptionsFlow):
+class OptionsFlowHandler(OptionsFlowWithReload):
     """Handle options."""
 
     async def async_step_init(
@@ -154,7 +146,7 @@ class SubentryFlowHandler(ConfigSubentryFlow):
         """Reconfigure a sensor."""
         if user_input is not None:
             title = user_input.pop("name")
-            return self.async_update_and_abort(
+            return self.async_update_reload_and_abort(
                 self._get_entry(),
                 self._get_reconfigure_subentry(),
                 data=user_input,
@@ -170,35 +162,3 @@ class SubentryFlowHandler(ConfigSubentryFlow):
                 }
             ),
         )
-
-
-class InfraredFanSubentryFlowHandler(ConfigSubentryFlow):
-    """Handle infrared fan subentry flow."""
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> SubentryFlowResult:
-        """User flow to add an infrared fan."""
-
-        entities = async_get_emitters(self.hass)
-        if not entities:
-            return self.async_abort(reason="no_emitters")
-
-        if user_input is not None:
-            title = user_input.pop("name")
-            return self.async_create_entry(data=user_input, title=title)
-
-        return self.async_show_form(
-            step_id="user",
-            data_schema=vol.Schema(
-                {
-                    vol.Required("name"): str,
-                    vol.Required(CONF_INFRARED_ENTITY_ID): EntitySelector(
-                        EntitySelectorConfig(
-                            domain=INFRARED_DOMAIN,
-                            include_entities=[entity.entity_id for entity in entities],
-                        )
-                    ),
-                }
-            ),
-        )

homeassistant/components/kitchen_sink/const.py

@@ -7,7 +7,6 @@ from collections.abc import Callable
 from homeassistant.util.hass_dict import HassKey
 
 DOMAIN = "kitchen_sink"
-CONF_INFRARED_ENTITY_ID = "infrared_entity_id"
 DATA_BACKUP_AGENT_LISTENERS: HassKey[list[Callable[[], None]]] = HassKey(
     f"{DOMAIN}.backup_agent_listeners"
 )

homeassistant/components/kitchen_sink/fan.py

@@ -1,150 +0,0 @@
-"""Demo platform that offers a fake infrared fan entity."""
-
-from __future__ import annotations
-
-from typing import Any
-
-import infrared_protocols
-
-from homeassistant.components.fan import FanEntity, FanEntityFeature
-from homeassistant.components.infrared import async_send_command
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import STATE_UNAVAILABLE
-from homeassistant.core import Event, EventStateChangedData, HomeAssistant, callback
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.event import async_track_state_change_event
-
-from .const import CONF_INFRARED_ENTITY_ID, DOMAIN
-
-PARALLEL_UPDATES = 0
-
-DUMMY_FAN_ADDRESS = 0x1234
-DUMMY_CMD_POWER_ON = 0x01
-DUMMY_CMD_POWER_OFF = 0x02
-DUMMY_CMD_SPEED_LOW = 0x03
-DUMMY_CMD_SPEED_MEDIUM = 0x04
-DUMMY_CMD_SPEED_HIGH = 0x05
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    config_entry: ConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up the demo infrared fan platform."""
-    for subentry_id, subentry in config_entry.subentries.items():
-        if subentry.subentry_type != "infrared_fan":
-            continue
-        async_add_entities(
-            [
-                DemoInfraredFan(
-                    subentry_id=subentry_id,
-                    device_name=subentry.title,
-                    infrared_entity_id=subentry.data[CONF_INFRARED_ENTITY_ID],
-                )
-            ],
-            config_subentry_id=subentry_id,
-        )
-
-
-class DemoInfraredFan(FanEntity):
-    """Representation of a demo infrared fan entity."""
-
-    _attr_has_entity_name = True
-    _attr_name = None
-    _attr_should_poll = False
-    _attr_assumed_state = True
-    _attr_speed_count = 3
-    _attr_supported_features = (
-        FanEntityFeature.SET_SPEED
-        | FanEntityFeature.TURN_OFF
-        | FanEntityFeature.TURN_ON
-    )
-
-    def __init__(
-        self,
-        subentry_id: str,
-        device_name: str,
-        infrared_entity_id: str,
-    ) -> None:
-        """Initialize the demo infrared fan entity."""
-        self._infrared_entity_id = infrared_entity_id
-        self._attr_unique_id = subentry_id
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, subentry_id)},
-            name=device_name,
-        )
-        self._attr_percentage = 0
-
-    async def async_added_to_hass(self) -> None:
-        """Subscribe to infrared entity state changes."""
-        await super().async_added_to_hass()
-
-        @callback
-        def _async_ir_state_changed(event: Event[EventStateChangedData]) -> None:
-            """Handle infrared entity state changes."""
-            new_state = event.data["new_state"]
-            self._attr_available = (
-                new_state is not None and new_state.state != STATE_UNAVAILABLE
-            )
-            self.async_write_ha_state()
-
-        self.async_on_remove(
-            async_track_state_change_event(
-                self.hass, [self._infrared_entity_id], _async_ir_state_changed
-            )
-        )
-
-        # Set initial availability based on current infrared entity state
-        ir_state = self.hass.states.get(self._infrared_entity_id)
-        self._attr_available = (
-            ir_state is not None and ir_state.state != STATE_UNAVAILABLE
-        )
-
-    async def _send_command(self, command_code: int) -> None:
-        """Send an IR command using the NEC protocol."""
-        command = infrared_protocols.NECCommand(
-            address=DUMMY_FAN_ADDRESS,
-            command=command_code,
-            modulation=38000,
-        )
-        await async_send_command(
-            self.hass, self._infrared_entity_id, command, context=self._context
-        )
-
-    async def async_turn_on(
-        self,
-        percentage: int | None = None,
-        preset_mode: str | None = None,
-        **kwargs: Any,
-    ) -> None:
-        """Turn on the fan."""
-        if percentage is not None:
-            await self.async_set_percentage(percentage)
-            return
-        await self._send_command(DUMMY_CMD_POWER_ON)
-        self._attr_percentage = 33
-        self.async_write_ha_state()
-
-    async def async_turn_off(self, **kwargs: Any) -> None:
-        """Turn off the fan."""
-        await self._send_command(DUMMY_CMD_POWER_OFF)
-        self._attr_percentage = 0
-        self.async_write_ha_state()
-
-    async def async_set_percentage(self, percentage: int) -> None:
-        """Set the speed percentage of the fan."""
-        if percentage == 0:
-            await self.async_turn_off()
-            return
-
-        if percentage <= 33:
-            await self._send_command(DUMMY_CMD_SPEED_LOW)
-        elif percentage <= 66:
-            await self._send_command(DUMMY_CMD_SPEED_MEDIUM)
-        else:
-            await self._send_command(DUMMY_CMD_SPEED_HIGH)
-
-        self._attr_percentage = percentage
-        self.async_write_ha_state()

homeassistant/components/kitchen_sink/infrared.py

@@ -1,65 +0,0 @@
-"""Demo platform that offers a fake infrared entity."""
-
-from __future__ import annotations
-
-import infrared_protocols
-
-from homeassistant.components import persistent_notification
-from homeassistant.components.infrared import InfraredEntity
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from . import DOMAIN
-
-PARALLEL_UPDATES = 0
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    config_entry: ConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up the demo infrared platform."""
-    async_add_entities(
-        [
-            DemoInfrared(
-                unique_id="ir_transmitter",
-                device_name="IR Blaster",
-                entity_name="Infrared Transmitter",
-            ),
-        ]
-    )
-
-
-class DemoInfrared(InfraredEntity):
-    """Representation of a demo infrared entity."""
-
-    _attr_has_entity_name = True
-    _attr_should_poll = False
-
-    def __init__(
-        self,
-        unique_id: str,
-        device_name: str,
-        entity_name: str,
-    ) -> None:
-        """Initialize the demo infrared entity."""
-        self._attr_unique_id = unique_id
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, unique_id)},
-            name=device_name,
-        )
-        self._attr_name = entity_name
-
-    async def async_send_command(self, command: infrared_protocols.Command) -> None:
-        """Send an IR command."""
-        timings = [
-            interval
-            for timing in command.get_raw_timings()
-            for interval in (timing.high_us, -timing.low_us)
-        ]
-        persistent_notification.async_create(
-            self.hass, str(timings), title="Infrared Command"
-        )

homeassistant/components/kitchen_sink/sensor.py

@@ -101,8 +101,6 @@ async def async_setup_entry(
     )
 
     for subentry_id, subentry in config_entry.subentries.items():
-        if subentry.subentry_type != "entity":
-            continue
         async_add_entities(
             [
                 DemoSensor(

homeassistant/components/kitchen_sink/strings.json

@@ -32,24 +32,6 @@
           "description": "Reconfigure the sensor"
         }
       }
-    },
-    "infrared_fan": {
-      "abort": {
-        "no_emitters": "No infrared transmitter entities found. Please set up an infrared device first."
-      },
-      "entry_type": "Infrared fan",
-      "initiate_flow": {
-        "user": "Add infrared fan"
-      },
-      "step": {
-        "user": {
-          "data": {
-            "infrared_entity_id": "Infrared transmitter",
-            "name": "[%key:common::config_flow::data::name%]"
-          },
-          "description": "Select an infrared transmitter to control the fan."
-        }
-      }
     }
   },
   "device": {

homeassistant/components/knx/dpt.py

@@ -8,6 +8,7 @@ from xknx.dpt import DPTBase, DPTComplex, DPTEnum, DPTNumeric
 from xknx.dpt.dpt_16 import DPTString
 
 from homeassistant.components.sensor import SensorDeviceClass, SensorStateClass
+from homeassistant.const import UnitOfReactiveEnergy
 
 HaDptClass = Literal["numeric", "enum", "complex", "string"]
 
@@ -36,7 +37,7 @@ def get_supported_dpts() -> Mapping[str, DPTInfo]:
             main=dpt_class.dpt_main_number,  # type: ignore[typeddict-item] # checked in xknx unit tests
             sub=dpt_class.dpt_sub_number,
             name=dpt_class.value_type,
-            unit=dpt_class.unit,
+            unit=_sensor_unit_overrides.get(dpt_number_str, dpt_class.unit),
             sensor_device_class=_sensor_device_classes.get(dpt_number_str),
             sensor_state_class=_get_sensor_state_class(ha_dpt_class, dpt_number_str),
         )
@@ -77,13 +78,13 @@ _sensor_device_classes: Mapping[str, SensorDeviceClass] = {
     "12.1200": SensorDeviceClass.VOLUME,
     "12.1201": SensorDeviceClass.VOLUME,
     "13.002": SensorDeviceClass.VOLUME_FLOW_RATE,
-    "13.010": SensorDeviceClass.ENERGY,
-    "13.012": SensorDeviceClass.REACTIVE_ENERGY,
-    "13.013": SensorDeviceClass.ENERGY,
-    "13.015": SensorDeviceClass.REACTIVE_ENERGY,
-    "13.016": SensorDeviceClass.ENERGY,
-    "13.1200": SensorDeviceClass.VOLUME,
-    "13.1201": SensorDeviceClass.VOLUME,
+    "13.010": SensorDeviceClass.ENERGY,  # DPTActiveEnergy
+    "13.012": SensorDeviceClass.REACTIVE_ENERGY,  # DPTReactiveEnergy
+    "13.013": SensorDeviceClass.ENERGY,  # DPTActiveEnergykWh
+    "13.015": SensorDeviceClass.REACTIVE_ENERGY,  # DPTReactiveEnergykVARh
+    "13.016": SensorDeviceClass.ENERGY,  # DPTActiveEnergyMWh
+    "13.1200": SensorDeviceClass.VOLUME,  # DPTDeltaVolumeLiquidLitre
+    "13.1201": SensorDeviceClass.VOLUME,  # DPTDeltaVolumeM3
     "14.010": SensorDeviceClass.AREA,
     "14.019": SensorDeviceClass.CURRENT,
     "14.027": SensorDeviceClass.VOLTAGE,
@@ -91,7 +92,7 @@ _sensor_device_classes: Mapping[str, SensorDeviceClass] = {
     "14.030": SensorDeviceClass.VOLTAGE,
     "14.031": SensorDeviceClass.ENERGY,
     "14.033": SensorDeviceClass.FREQUENCY,
-    "14.037": SensorDeviceClass.ENERGY_STORAGE,
+    "14.037": SensorDeviceClass.ENERGY_STORAGE,  # DPTHeatQuantity
     "14.039": SensorDeviceClass.DISTANCE,
     "14.051": SensorDeviceClass.WEIGHT,
     "14.056": SensorDeviceClass.POWER,
@@ -101,7 +102,7 @@ _sensor_device_classes: Mapping[str, SensorDeviceClass] = {
     "14.068": SensorDeviceClass.TEMPERATURE,
     "14.069": SensorDeviceClass.TEMPERATURE,
     "14.070": SensorDeviceClass.TEMPERATURE_DELTA,
-    "14.076": SensorDeviceClass.VOLUME,
+    "14.076": SensorDeviceClass.VOLUME,  # DPTVolume
     "14.077": SensorDeviceClass.VOLUME_FLOW_RATE,
     "14.080": SensorDeviceClass.APPARENT_POWER,
     "14.1200": SensorDeviceClass.VOLUME_FLOW_RATE,
@@ -121,17 +122,28 @@ _sensor_state_class_overrides: Mapping[str, SensorStateClass | None] = {
     "13.010": SensorStateClass.TOTAL,  # DPTActiveEnergy
     "13.011": SensorStateClass.TOTAL,  # DPTApparantEnergy
     "13.012": SensorStateClass.TOTAL,  # DPTReactiveEnergy
+    "13.013": SensorStateClass.TOTAL,  # DPTActiveEnergykWh
+    "13.015": SensorStateClass.TOTAL,  # DPTReactiveEnergykVARh
+    "13.016": SensorStateClass.TOTAL,  # DPTActiveEnergyMWh
+    "13.1200": SensorStateClass.TOTAL,  # DPTDeltaVolumeLiquidLitre
+    "13.1201": SensorStateClass.TOTAL,  # DPTDeltaVolumeM3
     "14.007": SensorStateClass.MEASUREMENT_ANGLE,  # DPTAngleDeg
-    "14.037": SensorStateClass.TOTAL,  # DPTHeatQuantity
     "14.051": SensorStateClass.TOTAL,  # DPTMass
     "14.055": SensorStateClass.MEASUREMENT_ANGLE,  # DPTPhaseAngleDeg
     "14.031": SensorStateClass.TOTAL_INCREASING,  # DPTEnergy
+    "14.076": SensorStateClass.TOTAL,  # DPTVolume
     "17.001": None,  # DPTSceneNumber
     "29.010": SensorStateClass.TOTAL,  # DPTActiveEnergy8Byte
     "29.011": SensorStateClass.TOTAL,  # DPTApparantEnergy8Byte
     "29.012": SensorStateClass.TOTAL,  # DPTReactiveEnergy8Byte
 }
 
+_sensor_unit_overrides: Mapping[str, str] = {
+    "13.012": UnitOfReactiveEnergy.VOLT_AMPERE_REACTIVE_HOUR,  # DPTReactiveEnergy (VARh in KNX)
+    "13.015": UnitOfReactiveEnergy.KILO_VOLT_AMPERE_REACTIVE_HOUR,  # DPTReactiveEnergykVARh (kVARh in KNX)
+    "29.012": UnitOfReactiveEnergy.VOLT_AMPERE_REACTIVE_HOUR,  # DPTReactiveEnergy8Byte (VARh in KNX)
+}
+
 
 def _get_sensor_state_class(
     ha_dpt_class: HaDptClass, dpt_number_str: str

homeassistant/components/knx/manifest.json

@@ -13,7 +13,7 @@
   "requirements": [
     "xknx==3.15.0",
     "xknxproject==3.8.2",
-    "knx-frontend==2026.2.25.165736"
+    "knx-frontend==2026.3.2.183756"
   ],
   "single_config_entry": true
 }

homeassistant/components/matter/vacuum.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from enum import IntEnum
+import logging
 from typing import TYPE_CHECKING, Any
 
 from chip.clusters import Objects as clusters
@@ -26,6 +27,8 @@ from .entity import MatterEntity, MatterEntityDescription
 from .helpers import get_matter
 from .models import MatterDiscoverySchema
 
+_LOGGER = logging.getLogger(__name__)
+
 
 class OperationalState(IntEnum):
     """Operational State of the vacuum cleaner.
@@ -168,8 +171,9 @@ class MatterVacuum(MatterEntity, StateVacuumEntity):
         segments: dict[str, Segment] = {}
         for area in supported_areas:
             area_name = None
-            if area.areaInfo and area.areaInfo.locationInfo:
-                area_name = area.areaInfo.locationInfo.locationName
+            location_info = area.areaInfo.locationInfo
+            if location_info not in (None, clusters.NullValue):
+                area_name = location_info.locationName
 
             if area_name:
                 segment_id = str(area.areaID)
@@ -253,9 +257,18 @@ class MatterVacuum(MatterEntity, StateVacuumEntity):
             VacuumEntityFeature.CLEAN_AREA in self.supported_features
             and self.registry_entry is not None
             and (last_seen_segments := self.last_seen_segments) is not None
-            and self._current_segments != {s.id: s for s in last_seen_segments}
+            # Ignore empty segments; some devices transiently
+            # report an empty list before sending the real one.
+            and (current_segments := self._current_segments)
         ):
-            self.async_create_segments_issue()
+            last_seen_by_id = {s.id: s for s in last_seen_segments}
+            if current_segments != last_seen_by_id:
+                _LOGGER.debug(
+                    "Vacuum segments changed: last_seen=%s, current=%s",
+                    last_seen_by_id,
+                    current_segments,
+                )
+                self.async_create_segments_issue()
 
     @callback
     def _calculate_features(self) -> None:

homeassistant/components/miele/const.py

@@ -617,11 +617,11 @@ class OvenProgramId(MieleEnum, missing_to_none=True):
     evaporate_water = 327
     shabbat_program = 335
     yom_tov = 336
-    drying = 357
+    drying = 357, 2028
     heat_crockery = 358
-    prove_dough = 359
+    prove_dough = 359, 2023
     low_temperature_cooking = 360
-    steam_cooking = 361
+    steam_cooking = 8, 361
     keeping_warm = 362
     apple_sponge = 364
     apple_pie = 365
@@ -668,9 +668,9 @@ class OvenProgramId(MieleEnum, missing_to_none=True):
     saddle_of_roebuck = 456
     salmon_fillet = 461
     potato_cheese_gratin = 464
-    trout = 486
-    carp = 491
-    salmon_trout = 492
+    trout = 486, 2224
+    carp = 491, 2233
+    salmon_trout = 492, 2241
     springform_tin_15cm = 496
     springform_tin_20cm = 497
     springform_tin_25cm = 498
@@ -736,137 +736,15 @@ class OvenProgramId(MieleEnum, missing_to_none=True):
     pork_belly = 701
     pikeperch_fillet_with_vegetables = 702
     steam_bake = 99001
-
-
-class DishWarmerProgramId(MieleEnum, missing_to_none=True):
-    """Program Id codes for dish warmers."""
-
-    no_program = 0, -1
-    warm_cups_glasses = 1
-    warm_dishes_plates = 2
-    keep_warm = 3
-    slow_roasting = 4
-
-
-class RobotVacuumCleanerProgramId(MieleEnum, missing_to_none=True):
-    """Program Id codes for robot vacuum cleaners."""
-
-    no_program = 0, -1
-    auto = 1
-    spot = 2
-    turbo = 3
-    silent = 4
-
-
-class CoffeeSystemProgramId(MieleEnum, missing_to_none=True):
-    """Program Id codes for coffee systems."""
-
-    no_program = 0, -1
-
-    check_appliance = 17004
-
-    # profile 1
-    ristretto = 24000, 24032, 24064, 24096, 24128
-    espresso = 24001, 24033, 24065, 24097, 24129
-    coffee = 24002, 24034, 24066, 24098, 24130
-    long_coffee = 24003, 24035, 24067, 24099, 24131
-    cappuccino = 24004, 24036, 24068, 24100, 24132
-    cappuccino_italiano = 24005, 24037, 24069, 24101, 24133
-    latte_macchiato = 24006, 24038, 24070, 24102, 24134
-    espresso_macchiato = 24007, 24039, 24071, 24135
-    cafe_au_lait = 24008, 24040, 24072, 24104, 24136
-    caffe_latte = 24009, 24041, 24073, 24105, 24137
-    flat_white = 24012, 24044, 24076, 24108, 24140
-    very_hot_water = 24013, 24045, 24077, 24109, 24141
-    hot_water = 24014, 24046, 24078, 24110, 24142
-    hot_milk = 24015, 24047, 24079, 24111, 24143
-    milk_foam = 24016, 24048, 24080, 24112, 24144
-    black_tea = 24017, 24049, 24081, 24113, 24145
-    herbal_tea = 24018, 24050, 24082, 24114, 24146
-    fruit_tea = 24019, 24051, 24083, 24115, 24147
-    green_tea = 24020, 24052, 24084, 24116, 24148
-    white_tea = 24021, 24053, 24085, 24117, 24149
-    japanese_tea = 24022, 29054, 24086, 24118, 24150
-    # special programs
-    coffee_pot = 24400
-    barista_assistant = 24407
-    # machine settings menu
-    appliance_settings = (
-        16016,  # display brightness
-        16018,  # volume
-        16019,  # buttons volume
-        16020,  # child lock
-        16021,  # water hardness
-        16027,  # welcome sound
-        16033,  # connection status
-        16035,  # remote control
-        16037,  # remote update
-        24500,  # total dispensed
-        24502,  # lights appliance on
-        24503,  # lights appliance off
-        24504,  # turn off lights after
-        24506,  # altitude
-        24513,  # performance mode
-        24516,  # turn off after
-        24537,  # advanced mode
-        24542,  # tea timer
-        24549,  # total coffee dispensed
-        24550,  # total tea dispensed
-        24551,  # total ristretto
-        24552,  # total cappuccino
-        24553,  # total espresso
-        24554,  # total coffee
-        24555,  # total long coffee
-        24556,  # total italian cappuccino
-        24557,  # total latte macchiato
-        24558,  # total caffe latte
-        24560,  # total espresso macchiato
-        24562,  # total flat white
-        24563,  # total coffee with milk
-        24564,  # total black tea
-        24565,  # total herbal tea
-        24566,  # total fruit tea
-        24567,  # total green tea
-        24568,  # total white tea
-        24569,  # total japanese tea
-        24571,  # total milk foam
-        24572,  # total hot milk
-        24573,  # total hot water
-        24574,  # total very hot water
-        24575,  # counter to descaling
-        24576,  # counter to brewing unit degreasing
-        24800,  # maintenance
-        24801,  # profiles settings menu
-        24813,  # add profile
-    )
-    appliance_rinse = 24750, 24759, 24773, 24787, 24788
-    intermediate_rinsing = 24758
-    automatic_maintenance = 24778
-    descaling = 24751
-    brewing_unit_degrease = 24753
-    milk_pipework_rinse = 24754
-    milk_pipework_clean = 24789
-
-
-class SteamOvenMicroProgramId(MieleEnum, missing_to_none=True):
-    """Program Id codes for steam oven micro combo."""
-
-    no_program = 0, -1
-    steam_cooking = 8
-    microwave = 19
-    popcorn = 53
-    quick_mw = 54
     sous_vide = 72
     eco_steam_cooking = 75
     rapid_steam_cooking = 77
-    descale = 326
     menu_cooking = 330
     reheating_with_steam = 2018
     defrosting_with_steam = 2019
     blanching = 2020
     bottling = 2021
     sterilize_crockery = 2022
-    prove_dough = 2023
     soak = 2027
     reheating_with_microwave = 2029
     defrosting_with_microwave = 2030
@@ -1020,18 +898,15 @@ class SteamOvenMicroProgramId(MieleEnum, missing_to_none=True):
     gilt_head_bream_fillet = 2220
     codfish_piece = 2221, 2232
     codfish_fillet = 2222, 2231
-    trout = 2224
     pike_fillet = 2225
     pike_piece = 2226
     halibut_fillet_2_cm = 2227
     halibut_fillet_3_cm = 2230
-    carp = 2233
     salmon_fillet_2_cm = 2234
     salmon_fillet_3_cm = 2235
     salmon_steak_2_cm = 2238
     salmon_steak_3_cm = 2239
     salmon_piece = 2240
-    salmon_trout = 2241
     iridescent_shark_fillet = 2244
     red_snapper_fillet_2_cm = 2245
     red_snapper_fillet_3_cm = 2248
@@ -1268,6 +1143,116 @@ class SteamOvenMicroProgramId(MieleEnum, missing_to_none=True):
     round_grain_rice_general_rapid_steam_cooking = 3411
 
 
+class DishWarmerProgramId(MieleEnum, missing_to_none=True):
+    """Program Id codes for dish warmers."""
+
+    no_program = 0, -1
+    warm_cups_glasses = 1
+    warm_dishes_plates = 2
+    keep_warm = 3
+    slow_roasting = 4
+
+
+class RobotVacuumCleanerProgramId(MieleEnum, missing_to_none=True):
+    """Program Id codes for robot vacuum cleaners."""
+
+    no_program = 0, -1
+    auto = 1
+    spot = 2
+    turbo = 3
+    silent = 4
+
+
+class CoffeeSystemProgramId(MieleEnum, missing_to_none=True):
+    """Program Id codes for coffee systems."""
+
+    no_program = 0, -1
+
+    check_appliance = 17004
+
+    # profile 1
+    ristretto = 24000, 24032, 24064, 24096, 24128
+    espresso = 24001, 24033, 24065, 24097, 24129
+    coffee = 24002, 24034, 24066, 24098, 24130
+    long_coffee = 24003, 24035, 24067, 24099, 24131
+    cappuccino = 24004, 24036, 24068, 24100, 24132
+    cappuccino_italiano = 24005, 24037, 24069, 24101, 24133
+    latte_macchiato = 24006, 24038, 24070, 24102, 24134
+    espresso_macchiato = 24007, 24039, 24071, 24135
+    cafe_au_lait = 24008, 24040, 24072, 24104, 24136
+    caffe_latte = 24009, 24041, 24073, 24105, 24137
+    flat_white = 24012, 24044, 24076, 24108, 24140
+    very_hot_water = 24013, 24045, 24077, 24109, 24141
+    hot_water = 24014, 24046, 24078, 24110, 24142
+    hot_milk = 24015, 24047, 24079, 24111, 24143
+    milk_foam = 24016, 24048, 24080, 24112, 24144
+    black_tea = 24017, 24049, 24081, 24113, 24145
+    herbal_tea = 24018, 24050, 24082, 24114, 24146
+    fruit_tea = 24019, 24051, 24083, 24115, 24147
+    green_tea = 24020, 24052, 24084, 24116, 24148
+    white_tea = 24021, 24053, 24085, 24117, 24149
+    japanese_tea = 24022, 29054, 24086, 24118, 24150
+    # special programs
+    coffee_pot = 24400
+    barista_assistant = 24407
+    # machine settings menu
+    appliance_settings = (
+        16016,  # display brightness
+        16018,  # volume
+        16019,  # buttons volume
+        16020,  # child lock
+        16021,  # water hardness
+        16027,  # welcome sound
+        16033,  # connection status
+        16035,  # remote control
+        16037,  # remote update
+        24500,  # total dispensed
+        24502,  # lights appliance on
+        24503,  # lights appliance off
+        24504,  # turn off lights after
+        24506,  # altitude
+        24513,  # performance mode
+        24516,  # turn off after
+        24537,  # advanced mode
+        24542,  # tea timer
+        24549,  # total coffee dispensed
+        24550,  # total tea dispensed
+        24551,  # total ristretto
+        24552,  # total cappuccino
+        24553,  # total espresso
+        24554,  # total coffee
+        24555,  # total long coffee
+        24556,  # total italian cappuccino
+        24557,  # total latte macchiato
+        24558,  # total caffe latte
+        24560,  # total espresso macchiato
+        24562,  # total flat white
+        24563,  # total coffee with milk
+        24564,  # total black tea
+        24565,  # total herbal tea
+        24566,  # total fruit tea
+        24567,  # total green tea
+        24568,  # total white tea
+        24569,  # total japanese tea
+        24571,  # total milk foam
+        24572,  # total hot milk
+        24573,  # total hot water
+        24574,  # total very hot water
+        24575,  # counter to descaling
+        24576,  # counter to brewing unit degreasing
+        24800,  # maintenance
+        24801,  # profiles settings menu
+        24813,  # add profile
+    )
+    appliance_rinse = 24750, 24759, 24773, 24787, 24788
+    intermediate_rinsing = 24758
+    automatic_maintenance = 24778
+    descaling = 24751
+    brewing_unit_degrease = 24753
+    milk_pipework_rinse = 24754
+    milk_pipework_clean = 24789
+
+
 PROGRAM_IDS: dict[int, type[MieleEnum]] = {
     MieleAppliance.WASHING_MACHINE: WashingMachineProgramId,
     MieleAppliance.TUMBLE_DRYER: TumbleDryerProgramId,
@@ -1278,7 +1263,7 @@ PROGRAM_IDS: dict[int, type[MieleEnum]] = {
     MieleAppliance.STEAM_OVEN_MK2: OvenProgramId,
     MieleAppliance.STEAM_OVEN: OvenProgramId,
     MieleAppliance.STEAM_OVEN_COMBI: OvenProgramId,
-    MieleAppliance.STEAM_OVEN_MICRO: SteamOvenMicroProgramId,
+    MieleAppliance.STEAM_OVEN_MICRO: OvenProgramId,
     MieleAppliance.WASHER_DRYER: WashingMachineProgramId,
     MieleAppliance.ROBOT_VACUUM_CLEANER: RobotVacuumCleanerProgramId,
     MieleAppliance.COFFEE_SYSTEM: CoffeeSystemProgramId,

homeassistant/components/miele/strings.json

@@ -474,6 +474,7 @@
           "drain_spin": "Drain/spin",
           "drop_cookies_1_tray": "Drop cookies (1 tray)",
           "drop_cookies_2_trays": "Drop cookies (2 trays)",
+          "drying": "Drying",
           "duck": "Duck",
           "dutch_hash": "Dutch hash",
           "easy_care": "Easy care",

homeassistant/components/mobile_app/notify.py

@@ -120,6 +120,7 @@ class MobileAppNotificationService(BaseNotificationService):
 
         local_push_channels = self.hass.data[DOMAIN][DATA_PUSH_CHANNEL]
 
+        failed_targets = []
         for target in targets:
             registration = self.hass.data[DOMAIN][DATA_CONFIG_ENTRIES][target].data
 
@@ -134,12 +135,16 @@ class MobileAppNotificationService(BaseNotificationService):
 
             # Test if local push only.
             if ATTR_PUSH_URL not in registration[ATTR_APP_DATA]:
-                raise HomeAssistantError(
-                    "Device not connected to local push notifications"
-                )
+                failed_targets.append(target)
+                continue
 
             await self._async_send_remote_message_target(target, registration, data)
 
+        if failed_targets:
+            raise HomeAssistantError(
+                f"Device(s) with webhook id(s) {', '.join(failed_targets)} not connected to local push notifications"
+            )
+
     async def _async_send_remote_message_target(self, target, registration, data):
         """Send a message to a target."""
         app_data = registration[ATTR_APP_DATA]