Remove unnecessary suppress in importlib helper (#164323)

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: J. Nick Koston <nick@home-assistant.io>
Co-authored-by: J. Nick Koston <nick@koston.org>

homeassistant/components/bitcoin/sensor.py

@@ -190,7 +190,7 @@ class BitcoinSensor(SensorEntity):
         elif sensor_type == "miners_revenue_usd":
             self._attr_native_value = f"{stats.miners_revenue_usd:.0f}"
         elif sensor_type == "btc_mined":
-            self._attr_native_value = str(stats.btc_mined * 0.00000001)
+            self._attr_native_value = str(stats.btc_mined * 1e-8)
         elif sensor_type == "trade_volume_usd":
             self._attr_native_value = f"{stats.trade_volume_usd:.1f}"
         elif sensor_type == "difficulty":
@@ -208,13 +208,13 @@ class BitcoinSensor(SensorEntity):
         elif sensor_type == "blocks_size":
             self._attr_native_value = f"{stats.blocks_size:.1f}"
         elif sensor_type == "total_fees_btc":
-            self._attr_native_value = f"{stats.total_fees_btc * 0.00000001:.2f}"
+            self._attr_native_value = f"{stats.total_fees_btc * 1e-8:.2f}"
         elif sensor_type == "total_btc_sent":
-            self._attr_native_value = f"{stats.total_btc_sent * 0.00000001:.2f}"
+            self._attr_native_value = f"{stats.total_btc_sent * 1e-8:.2f}"
         elif sensor_type == "estimated_btc_sent":
-            self._attr_native_value = f"{stats.estimated_btc_sent * 0.00000001:.2f}"
+            self._attr_native_value = f"{stats.estimated_btc_sent * 1e-8:.2f}"
         elif sensor_type == "total_btc":
-            self._attr_native_value = f"{stats.total_btc * 0.00000001:.2f}"
+            self._attr_native_value = f"{stats.total_btc * 1e-8:.2f}"
         elif sensor_type == "total_blocks":
             self._attr_native_value = f"{stats.total_blocks:.0f}"
         elif sensor_type == "next_retarget":
@@ -222,7 +222,7 @@ class BitcoinSensor(SensorEntity):
         elif sensor_type == "estimated_transaction_volume_usd":
             self._attr_native_value = f"{stats.estimated_transaction_volume_usd:.2f}"
         elif sensor_type == "miners_revenue_btc":
-            self._attr_native_value = f"{stats.miners_revenue_btc * 0.00000001:.1f}"
+            self._attr_native_value = f"{stats.miners_revenue_btc * 1e-8:.1f}"
         elif sensor_type == "market_price_usd":
             self._attr_native_value = f"{stats.market_price_usd:.2f}"
 

homeassistant/components/conversation/http.py

@@ -48,6 +48,8 @@ def async_setup(hass: HomeAssistant) -> None:
         vol.Optional("conversation_id"): vol.Any(str, None),
         vol.Optional("language"): str,
         vol.Optional("agent_id"): agent_id_validator,
+        vol.Optional("device_id"): vol.Any(str, None),
+        vol.Optional("satellite_id"): vol.Any(str, None),
     }
 )
 @websocket_api.async_response
@@ -64,6 +66,8 @@ async def websocket_process(
         context=connection.context(msg),
         language=msg.get("language"),
         agent_id=msg.get("agent_id"),
+        device_id=msg.get("device_id"),
+        satellite_id=msg.get("satellite_id"),
     )
     connection.send_result(msg["id"], result.as_dict())
 
@@ -248,6 +252,8 @@ class ConversationProcessView(http.HomeAssistantView):
                 vol.Optional("conversation_id"): str,
                 vol.Optional("language"): str,
                 vol.Optional("agent_id"): agent_id_validator,
+                vol.Optional("device_id"): vol.Any(str, None),
+                vol.Optional("satellite_id"): vol.Any(str, None),
             }
         )
     )
@@ -262,6 +268,8 @@ class ConversationProcessView(http.HomeAssistantView):
             context=self.context(request),
             language=data.get("language"),
             agent_id=data.get("agent_id"),
+            device_id=data.get("device_id"),
+            satellite_id=data.get("satellite_id"),
         )
 
         return self.json(result.as_dict())

homeassistant/components/daikin/climate.py

@@ -112,11 +112,12 @@ def _zone_is_configured(zone: DaikinZone) -> bool:
 
 def _zone_temperature_lists(device: Appliance) -> tuple[list[str], list[str]]:
     """Return the decoded zone temperature lists."""
-    try:
-        heating = device.represent(DAIKIN_ZONE_TEMP_HEAT)[1]
-        cooling = device.represent(DAIKIN_ZONE_TEMP_COOL)[1]
-    except AttributeError, KeyError:
+    values = device.values
+    if DAIKIN_ZONE_TEMP_HEAT not in values or DAIKIN_ZONE_TEMP_COOL not in values:
         return ([], [])
+
+    heating = device.represent(DAIKIN_ZONE_TEMP_HEAT)[1]
+    cooling = device.represent(DAIKIN_ZONE_TEMP_COOL)[1]
     return (list(heating or []), list(cooling or []))
 
 

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/esphome/entity.py

@@ -189,6 +189,7 @@ async def platform_async_setup_entry(
     info_type: type[_InfoT],
     entity_type: type[_EntityT],
     state_type: type[_StateT],
+    info_filter: Callable[[_InfoT], bool] | None = None,
 ) -> None:
     """Set up an esphome platform.
 
@@ -208,10 +209,22 @@ async def platform_async_setup_entry(
         entity_type,
         state_type,
     )
+
+    if info_filter is not None:
+
+        def on_filtered_update(infos: list[EntityInfo]) -> None:
+            on_static_info_update(
+                [info for info in infos if info_filter(cast(_InfoT, info))]
+            )
+
+        info_callback = on_filtered_update
+    else:
+        info_callback = on_static_info_update
+
     entry_data.cleanup_callbacks.append(
         entry_data.async_register_static_info_callback(
             info_type,
-            on_static_info_update,
+            info_callback,
         )
     )
 

homeassistant/components/esphome/entry_data.py

@@ -29,6 +29,7 @@ from aioesphomeapi import (
     Event,
     EventInfo,
     FanInfo,
+    InfraredInfo,
     LightInfo,
     LockInfo,
     MediaPlayerInfo,
@@ -85,6 +86,7 @@ INFO_TYPE_TO_PLATFORM: dict[type[EntityInfo], Platform] = {
     DateTimeInfo: Platform.DATETIME,
     EventInfo: Platform.EVENT,
     FanInfo: Platform.FAN,
+    InfraredInfo: Platform.INFRARED,
     LightInfo: Platform.LIGHT,
     LockInfo: Platform.LOCK,
     MediaPlayerInfo: Platform.MEDIA_PLAYER,

homeassistant/components/esphome/infrared.py

@@ -0,0 +1,59 @@
+"""Infrared platform for ESPHome."""
+
+from __future__ import annotations
+
+from functools import partial
+import logging
+
+from aioesphomeapi import EntityState, InfraredCapability, InfraredInfo
+
+from homeassistant.components.infrared import InfraredCommand, InfraredEntity
+from homeassistant.core import callback
+
+from .entity import (
+    EsphomeEntity,
+    convert_api_error_ha_error,
+    platform_async_setup_entry,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+PARALLEL_UPDATES = 0
+
+
+class EsphomeInfraredEntity(EsphomeEntity[InfraredInfo, EntityState], InfraredEntity):
+    """ESPHome infrared entity using native API."""
+
+    @callback
+    def _on_device_update(self) -> None:
+        """Call when device updates or entry data changes."""
+        super()._on_device_update()
+        if self._entry_data.available:
+            # Infrared entities should go available as soon as the device comes online
+            self.async_write_ha_state()
+
+    @convert_api_error_ha_error
+    async def async_send_command(self, command: InfraredCommand) -> None:
+        """Send an IR command."""
+        timings = [
+            interval
+            for timing in command.get_raw_timings()
+            for interval in (timing.high_us, -timing.low_us)
+        ]
+        _LOGGER.debug("Sending command: %s", timings)
+
+        self._client.infrared_rf_transmit_raw_timings(
+            self._static_info.key,
+            carrier_frequency=command.modulation,
+            timings=timings,
+            device_id=self._static_info.device_id,
+        )
+
+
+async_setup_entry = partial(
+    platform_async_setup_entry,
+    info_type=InfraredInfo,
+    entity_type=EsphomeInfraredEntity,
+    state_type=EntityState,
+    info_filter=lambda info: bool(info.capabilities & InfraredCapability.TRANSMITTER),
+)

homeassistant/components/esphome/light.py

@@ -241,7 +241,7 @@ class EsphomeLight(EsphomeEntity[LightInfo, LightState], LightEntity):
 
         if (color_temp_k := kwargs.get(ATTR_COLOR_TEMP_KELVIN)) is not None:
             # Do not use kelvin_to_mired here to prevent precision loss
-            data["color_temperature"] = 1000000.0 / color_temp_k
+            data["color_temperature"] = 1_000_000.0 / color_temp_k
             if color_temp_modes := _filter_color_modes(
                 color_modes, LightColorCapability.COLOR_TEMPERATURE
             ):

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==20260302.0"]
 }

homeassistant/components/govee_ble/manifest.json

@@ -54,6 +54,10 @@
       "connectable": false,
       "local_name": "GVH5110*"
     },
+    {
+      "connectable": false,
+      "local_name": "GV5140*"
+    },
     {
       "connectable": false,
       "manufacturer_id": 1,

homeassistant/components/govee_ble/sensor.py

@@ -21,6 +21,7 @@ from homeassistant.components.sensor import (
 )
 from homeassistant.const import (
     CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
+    CONCENTRATION_PARTS_PER_MILLION,
     PERCENTAGE,
     SIGNAL_STRENGTH_DECIBELS_MILLIWATT,
     UnitOfTemperature,
@@ -72,6 +73,12 @@ SENSOR_DESCRIPTIONS = {
         native_unit_of_measurement=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
         state_class=SensorStateClass.MEASUREMENT,
     ),
+    (DeviceClass.CO2, Units.CONCENTRATION_PARTS_PER_MILLION): SensorEntityDescription(
+        key=f"{DeviceClass.CO2}_{Units.CONCENTRATION_PARTS_PER_MILLION}",
+        device_class=SensorDeviceClass.CO2,
+        native_unit_of_measurement=CONCENTRATION_PARTS_PER_MILLION,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
 }
 
 

homeassistant/components/matter/lock_helpers.py

@@ -14,7 +14,6 @@ from chip.clusters.Types import NullValue
 from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
 
 from .const import (
-    CLEAR_ALL_INDEX,
     CRED_TYPE_FACE,
     CRED_TYPE_FINGER_VEIN,
     CRED_TYPE_FINGERPRINT,
@@ -222,42 +221,6 @@ def _format_user_response(user_data: Any) -> LockUserData | None:
 # --- Credential management helpers ---
 
 
-async def _clear_user_credentials(
-    matter_client: MatterClient,
-    node_id: int,
-    endpoint_id: int,
-    user_index: int,
-) -> None:
-    """Clear all credentials for a specific user.
-
-    Fetches the user to get credential list, then clears each credential.
-    """
-    get_user_response = await matter_client.send_device_command(
-        node_id=node_id,
-        endpoint_id=endpoint_id,
-        command=clusters.DoorLock.Commands.GetUser(userIndex=user_index),
-    )
-
-    creds = _get_attr(get_user_response, "credentials")
-    if not creds:
-        return
-
-    for cred in creds:
-        cred_type = _get_attr(cred, "credentialType")
-        cred_index = _get_attr(cred, "credentialIndex")
-        await matter_client.send_device_command(
-            node_id=node_id,
-            endpoint_id=endpoint_id,
-            command=clusters.DoorLock.Commands.ClearCredential(
-                credential=clusters.DoorLock.Structs.CredentialStruct(
-                    credentialType=cred_type,
-                    credentialIndex=cred_index,
-                ),
-            ),
-            timed_request_timeout_ms=LOCK_TIMED_REQUEST_TIMEOUT_MS,
-        )
-
-
 class LockEndpointNotFoundError(HomeAssistantError):
     """Lock endpoint not found on node."""
 
@@ -557,33 +520,16 @@ async def clear_lock_user(
     node: MatterNode,
     user_index: int,
 ) -> None:
-    """Clear a user from the lock, cleaning up credentials first.
+    """Clear a user from the lock.
 
+    Per the Matter spec, ClearUser also clears all associated credentials
+    and schedules for the user.
     Use index 0xFFFE (CLEAR_ALL_INDEX) to clear all users.
     Raises HomeAssistantError on failure.
     """
     lock_endpoint = _get_lock_endpoint_or_raise(node)
     _ensure_usr_support(lock_endpoint)
 
-    if user_index == CLEAR_ALL_INDEX:
-        # Clear all: clear all credentials first, then all users
-        await matter_client.send_device_command(
-            node_id=node.node_id,
-            endpoint_id=lock_endpoint.endpoint_id,
-            command=clusters.DoorLock.Commands.ClearCredential(
-                credential=None,
-            ),
-            timed_request_timeout_ms=LOCK_TIMED_REQUEST_TIMEOUT_MS,
-        )
-    else:
-        # Clear credentials for this specific user before deleting them
-        await _clear_user_credentials(
-            matter_client,
-            node.node_id,
-            lock_endpoint.endpoint_id,
-            user_index,
-        )
-
     await matter_client.send_device_command(
         node_id=node.node_id,
         endpoint_id=lock_endpoint.endpoint_id,

homeassistant/components/matter/strings.json

@@ -642,7 +642,7 @@
   },
   "services": {
     "clear_lock_credential": {
-      "description": "Removes a credential from the lock.",
+      "description": "Removes a credential from a lock.",
       "fields": {
         "credential_index": {
           "description": "The credential slot index to clear.",
@@ -666,7 +666,7 @@
       "name": "Clear lock user"
     },
     "get_lock_credential_status": {
-      "description": "Returns the status of a credential slot on the lock.",
+      "description": "Returns the status of a credential slot on a lock.",
       "fields": {
         "credential_index": {
           "description": "The credential slot index to query.",
@@ -684,7 +684,7 @@
       "name": "Get lock info"
     },
     "get_lock_users": {
-      "description": "Returns all users configured on the lock with their credentials.",
+      "description": "Returns all users configured on a lock with their credentials.",
       "name": "Get lock users"
     },
     "open_commissioning_window": {
@@ -698,7 +698,7 @@
       "name": "Open commissioning window"
     },
     "set_lock_credential": {
-      "description": "Adds or updates a credential on the lock.",
+      "description": "Adds or updates a credential on a lock.",
       "fields": {
         "credential_data": {
           "description": "The credential data. For PIN: digits only. For RFID: hexadecimal string.",

homeassistant/components/medcom_ble/__init__.py

@@ -3,19 +3,17 @@
 from __future__ import annotations
 
 from homeassistant.components import bluetooth
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
 
-from .const import DOMAIN
-from .coordinator import MedcomBleUpdateCoordinator
+from .coordinator import MedcomBleConfigEntry, MedcomBleUpdateCoordinator
 
 # Supported platforms
 PLATFORMS: list[Platform] = [Platform.SENSOR]
 
 
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_setup_entry(hass: HomeAssistant, entry: MedcomBleConfigEntry) -> bool:
     """Set up Medcom BLE radiation monitor from a config entry."""
 
     address = entry.unique_id
@@ -31,16 +29,13 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
     await coordinator.async_config_entry_first_refresh()
 
-    hass.data.setdefault(DOMAIN, {})[entry.entry_id] = coordinator
+    entry.runtime_data = coordinator
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_unload_entry(hass: HomeAssistant, entry: MedcomBleConfigEntry) -> bool:
     """Unload a config entry."""
-    if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
-        hass.data[DOMAIN].pop(entry.entry_id)
-
-    return unload_ok
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/medcom_ble/coordinator.py

@@ -18,13 +18,17 @@ from .const import DEFAULT_SCAN_INTERVAL, DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
+type MedcomBleConfigEntry = ConfigEntry[MedcomBleUpdateCoordinator]
+
 
 class MedcomBleUpdateCoordinator(DataUpdateCoordinator[MedcomBleDevice]):
     """Coordinator for Medcom BLE radiation monitor data."""
 
-    config_entry: ConfigEntry
+    config_entry: MedcomBleConfigEntry
 
-    def __init__(self, hass: HomeAssistant, entry: ConfigEntry, address: str) -> None:
+    def __init__(
+        self, hass: HomeAssistant, entry: MedcomBleConfigEntry, address: str
+    ) -> None:
         """Initialize the coordinator."""
         super().__init__(
             hass,

homeassistant/components/medcom_ble/sensor.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import logging
 
-from homeassistant import config_entries
 from homeassistant.components.sensor import (
     SensorEntity,
     SensorEntityDescription,
@@ -15,8 +14,8 @@ from homeassistant.helpers.device_registry import CONNECTION_BLUETOOTH, DeviceIn
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from .const import DOMAIN, UNIT_CPM
-from .coordinator import MedcomBleUpdateCoordinator
+from .const import UNIT_CPM
+from .coordinator import MedcomBleConfigEntry, MedcomBleUpdateCoordinator
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -32,12 +31,12 @@ SENSORS_MAPPING_TEMPLATE: dict[str, SensorEntityDescription] = {
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: config_entries.ConfigEntry,
+    entry: MedcomBleConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Medcom BLE radiation monitor sensors."""
 
-    coordinator: MedcomBleUpdateCoordinator = hass.data[DOMAIN][entry.entry_id]
+    coordinator = entry.runtime_data
 
     entities = []
     _LOGGER.debug("got sensors: %s", coordinator.data.sensors)

homeassistant/components/microbees/__init__.py

@@ -13,22 +13,25 @@ from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import config_entry_oauth2_flow
 
-from .const import DOMAIN, PLATFORMS
+from .const import PLATFORMS
 from .coordinator import MicroBeesUpdateCoordinator
 
 _LOGGER = logging.getLogger(__name__)
 
 
+type MicroBeesConfigEntry = ConfigEntry[HomeAssistantMicroBeesData]
+
+
 @dataclass(frozen=True, kw_only=True)
 class HomeAssistantMicroBeesData:
-    """Microbees data stored in the Home Assistant data object."""
+    """Microbees data stored in the config entry runtime_data."""
 
     connector: MicroBees
     coordinator: MicroBeesUpdateCoordinator
     session: config_entry_oauth2_flow.OAuth2Session
 
 
-async def async_migrate_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_migrate_entry(hass: HomeAssistant, entry: MicroBeesConfigEntry) -> bool:
     """Migrate entry."""
     _LOGGER.debug("Migrating from version %s.%s", entry.version, entry.minor_version)
 
@@ -45,7 +48,7 @@ async def async_migrate_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     return True
 
 
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_setup_entry(hass: HomeAssistant, entry: MicroBeesConfigEntry) -> bool:
     """Set up microBees from a config entry."""
     implementation = (
         await config_entry_oauth2_flow.async_get_config_entry_implementation(
@@ -67,7 +70,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     microbees = MicroBees(token=session.token[CONF_ACCESS_TOKEN])
     coordinator = MicroBeesUpdateCoordinator(hass, entry, microbees)
     await coordinator.async_config_entry_first_refresh()
-    hass.data.setdefault(DOMAIN, {})[entry.entry_id] = HomeAssistantMicroBeesData(
+    entry.runtime_data = HomeAssistantMicroBeesData(
         connector=microbees,
         coordinator=coordinator,
         session=session,
@@ -76,9 +79,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_unload_entry(hass: HomeAssistant, entry: MicroBeesConfigEntry) -> bool:
     """Unload a config entry."""
-    if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
-        hass.data[DOMAIN].pop(entry.entry_id)
-
-    return unload_ok
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/microbees/binary_sensor.py

@@ -7,11 +7,10 @@ from homeassistant.components.binary_sensor import (
     BinarySensorEntity,
     BinarySensorEntityDescription,
 )
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import DOMAIN
+from . import MicroBeesConfigEntry
 from .coordinator import MicroBeesUpdateCoordinator
 from .entity import MicroBeesEntity
 
@@ -37,13 +36,11 @@ BINARYSENSOR_TYPES = {
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: ConfigEntry,
+    entry: MicroBeesConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the microBees binary sensor platform."""
-    coordinator: MicroBeesUpdateCoordinator = hass.data[DOMAIN][
-        entry.entry_id
-    ].coordinator
+    coordinator = entry.runtime_data.coordinator
     async_add_entities(
         MBBinarySensor(coordinator, entity_description, bee_id, binary_sensor.id)
         for bee_id, bee in coordinator.data.bees.items()

homeassistant/components/microbees/button.py

@@ -3,11 +3,10 @@
 from typing import Any
 
 from homeassistant.components.button import ButtonEntity
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import DOMAIN
+from . import MicroBeesConfigEntry
 from .coordinator import MicroBeesUpdateCoordinator
 from .entity import MicroBeesActuatorEntity
 
@@ -16,13 +15,11 @@ BUTTON_TRANSLATIONS = {51: "button_gate", 91: "button_panic"}
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: ConfigEntry,
+    entry: MicroBeesConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the microBees button platform."""
-    coordinator: MicroBeesUpdateCoordinator = hass.data[DOMAIN][
-        entry.entry_id
-    ].coordinator
+    coordinator = entry.runtime_data.coordinator
     async_add_entities(
         MBButton(coordinator, bee_id, button.id)
         for bee_id, bee in coordinator.data.bees.items()

homeassistant/components/microbees/climate.py

@@ -7,13 +7,12 @@ from homeassistant.components.climate import (
     ClimateEntityFeature,
     HVACMode,
 )
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import DOMAIN
+from . import MicroBeesConfigEntry
 from .coordinator import MicroBeesUpdateCoordinator
 from .entity import MicroBeesActuatorEntity
 
@@ -27,13 +26,11 @@ THERMOVALVE_SENSOR_ID = 782
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: ConfigEntry,
+    entry: MicroBeesConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the microBees climate platform."""
-    coordinator: MicroBeesUpdateCoordinator = hass.data[DOMAIN][
-        entry.entry_id
-    ].coordinator
+    coordinator = entry.runtime_data.coordinator
     async_add_entities(
         MBClimate(
             coordinator,

homeassistant/components/microbees/coordinator.py

@@ -1,19 +1,24 @@
 """The microBees Coordinator."""
 
+from __future__ import annotations
+
 import asyncio
 from dataclasses import dataclass
 from datetime import timedelta
 from http import HTTPStatus
 import logging
+from typing import TYPE_CHECKING
 
 import aiohttp
 from microBeesPy import Actuator, Bee, MicroBees, MicroBeesException, Sensor
 
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
+if TYPE_CHECKING:
+    from . import MicroBeesConfigEntry
+
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -29,10 +34,13 @@ class MicroBeesCoordinatorData:
 class MicroBeesUpdateCoordinator(DataUpdateCoordinator[MicroBeesCoordinatorData]):
     """MicroBees coordinator."""
 
-    config_entry: ConfigEntry
+    config_entry: MicroBeesConfigEntry
 
     def __init__(
-        self, hass: HomeAssistant, config_entry: ConfigEntry, microbees: MicroBees
+        self,
+        hass: HomeAssistant,
+        config_entry: MicroBeesConfigEntry,
+        microbees: MicroBees,
     ) -> None:
         """Initialize microBees coordinator."""
         super().__init__(

homeassistant/components/microbees/cover.py

@@ -9,14 +9,12 @@ from homeassistant.components.cover import (
     CoverEntity,
     CoverEntityFeature,
 )
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.event import async_call_later
 
-from .const import DOMAIN
-from .coordinator import MicroBeesUpdateCoordinator
+from . import MicroBeesConfigEntry
 from .entity import MicroBeesEntity
 
 COVER_IDS = {47: "roller_shutter"}
@@ -24,13 +22,11 @@ COVER_IDS = {47: "roller_shutter"}
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: ConfigEntry,
+    entry: MicroBeesConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the microBees cover platform."""
-    coordinator: MicroBeesUpdateCoordinator = hass.data[DOMAIN][
-        entry.entry_id
-    ].coordinator
+    coordinator = entry.runtime_data.coordinator
 
     async_add_entities(
         MBCover(

homeassistant/components/microbees/light.py

@@ -3,25 +3,22 @@
 from typing import Any
 
 from homeassistant.components.light import ATTR_RGBW_COLOR, ColorMode, LightEntity
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import DOMAIN
+from . import MicroBeesConfigEntry
 from .coordinator import MicroBeesUpdateCoordinator
 from .entity import MicroBeesActuatorEntity
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: ConfigEntry,
+    entry: MicroBeesConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Config entry."""
-    coordinator: MicroBeesUpdateCoordinator = hass.data[DOMAIN][
-        entry.entry_id
-    ].coordinator
+    coordinator = entry.runtime_data.coordinator
     async_add_entities(
         MBLight(coordinator, bee_id, light.id)
         for bee_id, bee in coordinator.data.bees.items()

homeassistant/components/microbees/sensor.py

@@ -8,7 +8,6 @@ from homeassistant.components.sensor import (
     SensorEntityDescription,
     SensorStateClass,
 )
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
     CONCENTRATION_PARTS_PER_MILLION,
     LIGHT_LUX,
@@ -19,7 +18,7 @@ from homeassistant.const import (
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import DOMAIN
+from . import MicroBeesConfigEntry
 from .coordinator import MicroBeesUpdateCoordinator
 from .entity import MicroBeesEntity
 
@@ -64,11 +63,11 @@ SENSOR_TYPES = {
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: ConfigEntry,
+    entry: MicroBeesConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Config entry."""
-    coordinator = hass.data[DOMAIN][entry.entry_id].coordinator
+    coordinator = entry.runtime_data.coordinator
 
     async_add_entities(
         MBSensor(coordinator, desc, bee_id, sensor.id)

homeassistant/components/microbees/switch.py

@@ -3,12 +3,11 @@
 from typing import Any
 
 from homeassistant.components.switch import SwitchEntity
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import DOMAIN
+from . import MicroBeesConfigEntry
 from .coordinator import MicroBeesUpdateCoordinator
 from .entity import MicroBeesActuatorEntity
 
@@ -18,11 +17,11 @@ SWITCH_PRODUCT_IDS = {25, 26, 27, 35, 38, 46, 63, 64, 65, 86}
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: ConfigEntry,
+    entry: MicroBeesConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Config entry."""
-    coordinator = hass.data[DOMAIN][entry.entry_id].coordinator
+    coordinator = entry.runtime_data.coordinator
 
     async_add_entities(
         MBSwitch(coordinator, bee_id, switch.id)

homeassistant/components/moat/__init__.py

@@ -14,27 +14,26 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 
-from .const import DOMAIN
-
 PLATFORMS: list[Platform] = [Platform.SENSOR]
 
 _LOGGER = logging.getLogger(__name__)
 
+type MoatConfigEntry = ConfigEntry[PassiveBluetoothProcessorCoordinator]
 
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+
+async def async_setup_entry(hass: HomeAssistant, entry: MoatConfigEntry) -> bool:
     """Set up Moat BLE device from a config entry."""
     address = entry.unique_id
     assert address is not None
     data = MoatBluetoothDeviceData()
-    coordinator = hass.data.setdefault(DOMAIN, {})[entry.entry_id] = (
-        PassiveBluetoothProcessorCoordinator(
-            hass,
-            _LOGGER,
-            address=address,
-            mode=BluetoothScanningMode.PASSIVE,
-            update_method=data.update,
-        )
+    coordinator = PassiveBluetoothProcessorCoordinator(
+        hass,
+        _LOGGER,
+        address=address,
+        mode=BluetoothScanningMode.PASSIVE,
+        update_method=data.update,
     )
+    entry.runtime_data = coordinator
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
     entry.async_on_unload(
         coordinator.async_start()
@@ -42,9 +41,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_unload_entry(hass: HomeAssistant, entry: MoatConfigEntry) -> bool:
     """Unload a config entry."""
-    if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
-        hass.data[DOMAIN].pop(entry.entry_id)
-
-    return unload_ok
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/moat/sensor.py

@@ -4,12 +4,10 @@ from __future__ import annotations
 
 from moat_ble import DeviceClass, DeviceKey, SensorUpdate, Units
 
-from homeassistant import config_entries
 from homeassistant.components.bluetooth.passive_update_processor import (
     PassiveBluetoothDataProcessor,
     PassiveBluetoothDataUpdate,
     PassiveBluetoothEntityKey,
-    PassiveBluetoothProcessorCoordinator,
     PassiveBluetoothProcessorEntity,
 )
 from homeassistant.components.sensor import (
@@ -28,7 +26,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.sensor import sensor_device_info_to_hass_device_info
 
-from .const import DOMAIN
+from . import MoatConfigEntry
 
 SENSOR_DESCRIPTIONS = {
     (DeviceClass.TEMPERATURE, Units.TEMP_CELSIUS): SensorEntityDescription(
@@ -104,13 +102,11 @@ def sensor_update_to_bluetooth_data_update(
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: config_entries.ConfigEntry,
+    entry: MoatConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the Moat BLE sensors."""
-    coordinator: PassiveBluetoothProcessorCoordinator = hass.data[DOMAIN][
-        entry.entry_id
-    ]
+    coordinator = entry.runtime_data
     processor = PassiveBluetoothDataProcessor(sensor_update_to_bluetooth_data_update)
     entry.async_on_unload(
         processor.async_add_entities_listener(

homeassistant/components/monzo/__init__.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import logging
 
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
@@ -14,15 +13,14 @@ from homeassistant.helpers.config_entry_oauth2_flow import (
 )
 
 from .api import AuthenticatedMonzoAPI
-from .const import DOMAIN
-from .coordinator import MonzoCoordinator
+from .coordinator import MonzoConfigEntry, MonzoCoordinator
 
 _LOGGER = logging.getLogger(__name__)
 
 PLATFORMS: list[Platform] = [Platform.SENSOR]
 
 
-async def async_migrate_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_migrate_entry(hass: HomeAssistant, entry: MonzoConfigEntry) -> bool:
     """Migrate entry."""
     _LOGGER.debug("Migrating from version %s.%s", entry.version, entry.minor_version)
 
@@ -39,7 +37,7 @@ async def async_migrate_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     return True
 
 
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_setup_entry(hass: HomeAssistant, entry: MonzoConfigEntry) -> bool:
     """Set up Monzo from a config entry."""
     implementation = await async_get_config_entry_implementation(hass, entry)
 
@@ -51,15 +49,12 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
     await coordinator.async_config_entry_first_refresh()
 
-    hass.data.setdefault(DOMAIN, {})[entry.entry_id] = coordinator
+    entry.runtime_data = coordinator
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_unload_entry(hass: HomeAssistant, entry: MonzoConfigEntry) -> bool:
     """Unload a config entry."""
-    unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
-    if unload_ok:
-        hass.data[DOMAIN].pop(entry.entry_id)
-    return unload_ok
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/monzo/coordinator.py

@@ -1,5 +1,7 @@
 """The Monzo integration."""
 
+from __future__ import annotations
+
 from dataclasses import dataclass
 from datetime import timedelta
 import logging
@@ -18,6 +20,8 @@ from .const import DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
+type MonzoConfigEntry = ConfigEntry[MonzoCoordinator]
+
 
 @dataclass
 class MonzoData:
@@ -30,10 +34,13 @@ class MonzoData:
 class MonzoCoordinator(DataUpdateCoordinator[MonzoData]):
     """Class to manage fetching Monzo data from the API."""
 
-    config_entry: ConfigEntry
+    config_entry: MonzoConfigEntry
 
     def __init__(
-        self, hass: HomeAssistant, config_entry: ConfigEntry, api: AuthenticatedMonzoAPI
+        self,
+        hass: HomeAssistant,
+        config_entry: MonzoConfigEntry,
+        api: AuthenticatedMonzoAPI,
     ) -> None:
         """Initialize."""
         super().__init__(

homeassistant/components/monzo/sensor.py

@@ -11,14 +11,11 @@ from homeassistant.components.sensor import (
     SensorEntity,
     SensorEntityDescription,
 )
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
 
-from . import MonzoCoordinator
-from .const import DOMAIN
-from .coordinator import MonzoData
+from .coordinator import MonzoConfigEntry, MonzoCoordinator, MonzoData
 from .entity import MonzoBaseEntity
 
 
@@ -64,11 +61,11 @@ MODEL_POT = "Pot"
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: ConfigEntry,
+    config_entry: MonzoConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Defer sensor setup to the shared sensor module."""
-    coordinator: MonzoCoordinator = hass.data[DOMAIN][config_entry.entry_id]
+    coordinator = config_entry.runtime_data
 
     accounts = [
         MonzoSensor(

homeassistant/components/motioneye/__init__.py

@@ -56,7 +56,6 @@ from homeassistant.helpers.dispatcher import (
     async_dispatcher_send,
 )
 from homeassistant.helpers.network import NoURLAvailableError, get_url
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
 from .const import (
     ATTR_EVENT_TYPE,
@@ -69,7 +68,6 @@ from .const import (
     CONF_SURVEILLANCE_USERNAME,
     CONF_WEBHOOK_SET,
     CONF_WEBHOOK_SET_OVERWRITE,
-    DEFAULT_SCAN_INTERVAL,
     DEFAULT_WEBHOOK_SET,
     DEFAULT_WEBHOOK_SET_OVERWRITE,
     DOMAIN,
@@ -84,6 +82,7 @@ from .const import (
     WEB_HOOK_SENTINEL_KEY,
     WEB_HOOK_SENTINEL_VALUE,
 )
+from .coordinator import MotionEyeUpdateCoordinator
 
 _LOGGER = logging.getLogger(__name__)
 PLATFORMS = [CAMERA_DOMAIN, SENSOR_DOMAIN, SWITCH_DOMAIN]
@@ -308,20 +307,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         hass, DOMAIN, "motionEye", entry.data[CONF_WEBHOOK_ID], handle_webhook
     )
 
-    async def async_update_data() -> dict[str, Any] | None:
-        try:
-            return await client.async_get_cameras()
-        except MotionEyeClientError as exc:
-            raise UpdateFailed("Error communicating with API") from exc
-
-    coordinator = DataUpdateCoordinator(
-        hass,
-        _LOGGER,
-        config_entry=entry,
-        name=DOMAIN,
-        update_method=async_update_data,
-        update_interval=DEFAULT_SCAN_INTERVAL,
-    )
+    coordinator = MotionEyeUpdateCoordinator(hass, entry, client)
     hass.data[DOMAIN][entry.entry_id] = {
         CONF_CLIENT: client,
         CONF_COORDINATOR: coordinator,

homeassistant/components/motioneye/camera.py

@@ -43,7 +43,6 @@ from homeassistant.const import (
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import config_validation as cv, entity_platform
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 
 from . import get_camera_from_cameras, is_acceptable_camera, listen_for_new_cameras
 from .const import (
@@ -60,6 +59,7 @@ from .const import (
     SERVICE_SNAPSHOT,
     TYPE_MOTIONEYE_MJPEG_CAMERA,
 )
+from .coordinator import MotionEyeUpdateCoordinator
 from .entity import MotionEyeEntity
 
 PLATFORMS = [Platform.CAMERA]
@@ -153,7 +153,7 @@ class MotionEyeMjpegCamera(MotionEyeEntity, MjpegCamera):
         password: str,
         camera: dict[str, Any],
         client: MotionEyeClient,
-        coordinator: DataUpdateCoordinator,
+        coordinator: MotionEyeUpdateCoordinator,
         options: Mapping[str, str],
     ) -> None:
         """Initialize a MJPEG camera."""

homeassistant/components/motioneye/coordinator.py

@@ -0,0 +1,41 @@
+"""Coordinator for the motionEye integration."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from motioneye_client.client import MotionEyeClient, MotionEyeClientError
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+from .const import DEFAULT_SCAN_INTERVAL, DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class MotionEyeUpdateCoordinator(DataUpdateCoordinator[dict[str, Any] | None]):
+    """Coordinator for motionEye data."""
+
+    config_entry: ConfigEntry
+
+    def __init__(
+        self, hass: HomeAssistant, entry: ConfigEntry, client: MotionEyeClient
+    ) -> None:
+        """Initialize the coordinator."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            name=DOMAIN,
+            config_entry=entry,
+            update_interval=DEFAULT_SCAN_INTERVAL,
+        )
+        self.client = client
+
+    async def _async_update_data(self) -> dict[str, Any] | None:
+        try:
+            return await self.client.async_get_cameras()
+        except MotionEyeClientError as exc:
+            raise UpdateFailed("Error communicating with API") from exc

homeassistant/components/motioneye/entity.py

@@ -10,12 +10,10 @@ from motioneye_client.const import KEY_ID
 
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity import EntityDescription
-from homeassistant.helpers.update_coordinator import (
-    CoordinatorEntity,
-    DataUpdateCoordinator,
-)
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from . import get_motioneye_device_identifier
+from .coordinator import MotionEyeUpdateCoordinator
 
 
 def get_motioneye_entity_unique_id(
@@ -25,7 +23,7 @@ def get_motioneye_entity_unique_id(
     return f"{config_entry_id}_{camera_id}_{entity_type}"
 
 
-class MotionEyeEntity(CoordinatorEntity):
+class MotionEyeEntity(CoordinatorEntity[MotionEyeUpdateCoordinator]):
     """Base class for motionEye entities."""
 
     _attr_has_entity_name = True
@@ -36,7 +34,7 @@ class MotionEyeEntity(CoordinatorEntity):
         type_name: str,
         camera: dict[str, Any],
         client: MotionEyeClient,
-        coordinator: DataUpdateCoordinator,
+        coordinator: MotionEyeUpdateCoordinator,
         options: Mapping[str, Any],
         entity_description: EntityDescription | None = None,
     ) -> None:

homeassistant/components/motioneye/sensor.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 from collections.abc import Mapping
-import logging
 from typing import Any
 
 from motioneye_client.client import MotionEyeClient
@@ -14,14 +13,12 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 
 from . import get_camera_from_cameras, listen_for_new_cameras
 from .const import CONF_CLIENT, CONF_COORDINATOR, DOMAIN, TYPE_MOTIONEYE_ACTION_SENSOR
+from .coordinator import MotionEyeUpdateCoordinator
 from .entity import MotionEyeEntity
 
-_LOGGER = logging.getLogger(__name__)
-
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -59,7 +56,7 @@ class MotionEyeActionSensor(MotionEyeEntity, SensorEntity):
         config_entry_id: str,
         camera: dict[str, Any],
         client: MotionEyeClient,
-        coordinator: DataUpdateCoordinator,
+        coordinator: MotionEyeUpdateCoordinator,
         options: Mapping[str, str],
     ) -> None:
         """Initialize an action sensor."""

homeassistant/components/motioneye/switch.py

@@ -20,10 +20,10 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import EntityCategory
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 
 from . import get_camera_from_cameras, listen_for_new_cameras
 from .const import CONF_CLIENT, CONF_COORDINATOR, DOMAIN, TYPE_MOTIONEYE_SWITCH_BASE
+from .coordinator import MotionEyeUpdateCoordinator
 from .entity import MotionEyeEntity
 
 MOTIONEYE_SWITCHES = [
@@ -102,7 +102,7 @@ class MotionEyeSwitch(MotionEyeEntity, SwitchEntity):
         config_entry_id: str,
         camera: dict[str, Any],
         client: MotionEyeClient,
-        coordinator: DataUpdateCoordinator,
+        coordinator: MotionEyeUpdateCoordinator,
         options: Mapping[str, str],
         entity_description: SwitchEntityDescription,
     ) -> None:

homeassistant/components/netatmo/config_flow.py

@@ -218,7 +218,7 @@ def fix_coordinates(user_input: dict) -> dict:
     # Ensure coordinates have acceptable length for the Netatmo API
     for coordinate in (CONF_LAT_NE, CONF_LAT_SW, CONF_LON_NE, CONF_LON_SW):
         if len(str(user_input[coordinate]).split(".")[1]) < 7:
-            user_input[coordinate] = user_input[coordinate] + 0.0000001
+            user_input[coordinate] = user_input[coordinate] + 1e-7
 
     # Swap coordinates if entered in wrong order
     if user_input[CONF_LAT_NE] < user_input[CONF_LAT_SW]:

homeassistant/components/onvif/event.py

@@ -16,23 +16,30 @@ from onvif.client import (
 )
 from onvif.exceptions import ONVIFError
 from onvif.util import stringify_onvif_error
+import onvif_parsers
 from zeep.exceptions import Fault, TransportError, ValidationError, XMLParseError
 
 from homeassistant.components import webhook
 from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import EntityCategory
 from homeassistant.core import CALLBACK_TYPE, HassJob, HomeAssistant, callback
 from homeassistant.helpers.device_registry import format_mac
 from homeassistant.helpers.event import async_call_later
 from homeassistant.helpers.network import NoURLAvailableError, get_url
+from homeassistant.util import dt as dt_util
 
 from .const import DOMAIN, LOGGER
 from .models import Event, PullPointManagerState, WebHookManagerState
-from .parsers import PARSERS
 
 # Topics in this list are ignored because we do not want to create
 # entities for them.
 UNHANDLED_TOPICS: set[str] = {"tns1:MediaControl/VideoEncoderConfiguration"}
 
+ENTITY_CATEGORY_MAPPING: dict[str, EntityCategory] = {
+    "diagnostic": EntityCategory.DIAGNOSTIC,
+    "config": EntityCategory.CONFIG,
+}
+
 SUBSCRIPTION_ERRORS = (Fault, TimeoutError, TransportError)
 CREATE_ERRORS = (
     ONVIFError,
@@ -81,6 +88,18 @@ PULLPOINT_MESSAGE_LIMIT = 100
 PULLPOINT_COOLDOWN_TIME = 0.75
 
 
+def _local_datetime_or_none(value: str) -> dt.datetime | None:
+    """Convert strings to datetimes, if invalid, return None."""
+    # Handle cameras that return times like '0000-00-00T00:00:00Z' (e.g. Hikvision)
+    try:
+        ret = dt_util.parse_datetime(value)
+    except ValueError:
+        return None
+    if ret is not None:
+        return dt_util.as_local(ret)
+    return None
+
+
 class EventManager:
     """ONVIF Event Manager."""
 
@@ -176,7 +195,10 @@ class EventManager:
             # tns1:RuleEngine/CellMotionDetector/Motion
             topic = msg.Topic._value_1.rstrip("/.")  # noqa: SLF001
 
-            if not (parser := PARSERS.get(topic)):
+            try:
+                event = await onvif_parsers.parse(topic, unique_id, msg)
+                error = None
+            except onvif_parsers.errors.UnknownTopicError:
                 if topic not in UNHANDLED_TOPICS:
                     LOGGER.warning(
                         "%s: No registered handler for event from %s: %s",
@@ -186,10 +208,6 @@ class EventManager:
                     )
                     UNHANDLED_TOPICS.add(topic)
                 continue
-
-            try:
-                event = await parser(unique_id, msg)
-                error = None
             except (AttributeError, KeyError) as e:
                 event = None
                 error = e
@@ -202,10 +220,26 @@ class EventManager:
                     error,
                     msg,
                 )
-                return
+                continue
 
-            self.get_uids_by_platform(event.platform).add(event.uid)
-            self._events[event.uid] = event
+            value = event.value
+            if event.device_class == "timestamp" and isinstance(value, str):
+                value = _local_datetime_or_none(value)
+
+            ha_event = Event(
+                uid=event.uid,
+                name=event.name,
+                platform=event.platform,
+                device_class=event.device_class,
+                unit_of_measurement=event.unit_of_measurement,
+                value=value,
+                entity_category=ENTITY_CATEGORY_MAPPING.get(
+                    event.entity_category or ""
+                ),
+                entity_enabled=event.entity_enabled,
+            )
+            self.get_uids_by_platform(ha_event.platform).add(ha_event.uid)
+            self._events[ha_event.uid] = ha_event
 
     def get_uid(self, uid: str) -> Event | None:
         """Retrieve event for given id."""

homeassistant/components/onvif/manifest.json

@@ -13,5 +13,9 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["onvif", "wsdiscovery", "zeep"],
-  "requirements": ["onvif-zeep-async==4.0.4", "WSDiscovery==2.1.2"]
+  "requirements": [
+    "onvif-zeep-async==4.0.4",
+    "onvif_parsers==1.2.2",
+    "WSDiscovery==2.1.2"
+  ]
 }

homeassistant/components/onvif/parsers.py

@@ -1,755 +0,0 @@
-"""ONVIF event parsers."""
-
-from __future__ import annotations
-
-from collections.abc import Callable, Coroutine
-import dataclasses
-import datetime
-from typing import Any
-
-from homeassistant.const import EntityCategory
-from homeassistant.util import dt as dt_util
-from homeassistant.util.decorator import Registry
-
-from .models import Event
-
-PARSERS: Registry[str, Callable[[str, Any], Coroutine[Any, Any, Event | None]]] = (
-    Registry()
-)
-
-VIDEO_SOURCE_MAPPING = {
-    "vsconf": "VideoSourceToken",
-}
-
-
-def extract_message(msg: Any) -> tuple[str, Any]:
-    """Extract the message content and the topic."""
-    return msg.Topic._value_1, msg.Message._value_1  # noqa: SLF001
-
-
-def _normalize_video_source(source: str) -> str:
-    """Normalize video source.
-
-    Some cameras do not set the VideoSourceToken correctly so we get duplicate
-    sensors, so we need to normalize it to the correct value.
-    """
-    return VIDEO_SOURCE_MAPPING.get(source, source)
-
-
-def local_datetime_or_none(value: str) -> datetime.datetime | None:
-    """Convert strings to datetimes, if invalid, return None."""
-    # To handle cameras that return times like '0000-00-00T00:00:00Z' (e.g. hikvision)
-    try:
-        ret = dt_util.parse_datetime(value)
-    except ValueError:
-        return None
-    if ret is not None:
-        return dt_util.as_local(ret)
-    return None
-
-
-@PARSERS.register("tns1:VideoSource/MotionAlarm")
-@PARSERS.register("tns1:Device/Trigger/tnshik:AlarmIn")
-async def async_parse_motion_alarm(uid: str, msg) -> Event | None:
-    """Handle parsing event message.
-
-    Topic: tns1:VideoSource/MotionAlarm
-    """
-    topic, payload = extract_message(msg)
-    source = payload.Source.SimpleItem[0].Value
-    return Event(
-        f"{uid}_{topic}_{source}",
-        "Motion Alarm",
-        "binary_sensor",
-        "motion",
-        None,
-        payload.Data.SimpleItem[0].Value == "true",
-    )
-
-
-@PARSERS.register("tns1:VideoSource/ImageTooBlurry/AnalyticsService")
-@PARSERS.register("tns1:VideoSource/ImageTooBlurry/ImagingService")
-@PARSERS.register("tns1:VideoSource/ImageTooBlurry/RecordingService")
-async def async_parse_image_too_blurry(uid: str, msg) -> Event | None:
-    """Handle parsing event message.
-
-    Topic: tns1:VideoSource/ImageTooBlurry/*
-    """
-    topic, payload = extract_message(msg)
-    source = payload.Source.SimpleItem[0].Value
-    return Event(
-        f"{uid}_{topic}_{source}",
-        "Image Too Blurry",
-        "binary_sensor",
-        "problem",
-        None,
-        payload.Data.SimpleItem[0].Value == "true",
-        EntityCategory.DIAGNOSTIC,
-    )
-
-
-@PARSERS.register("tns1:VideoSource/ImageTooDark/AnalyticsService")
-@PARSERS.register("tns1:VideoSource/ImageTooDark/ImagingService")
-@PARSERS.register("tns1:VideoSource/ImageTooDark/RecordingService")
-async def async_parse_image_too_dark(uid: str, msg) -> Event | None:
-    """Handle parsing event message.
-
-    Topic: tns1:VideoSource/ImageTooDark/*
-    """
-    topic, payload = extract_message(msg)
-    source = payload.Source.SimpleItem[0].Value
-    return Event(
-        f"{uid}_{topic}_{source}",
-        "Image Too Dark",
-        "binary_sensor",
-        "problem",
-        None,
-        payload.Data.SimpleItem[0].Value == "true",
-        EntityCategory.DIAGNOSTIC,
-    )
-
-
-@PARSERS.register("tns1:VideoSource/ImageTooBright/AnalyticsService")
-@PARSERS.register("tns1:VideoSource/ImageTooBright/ImagingService")
-@PARSERS.register("tns1:VideoSource/ImageTooBright/RecordingService")
-async def async_parse_image_too_bright(uid: str, msg) -> Event | None:
-    """Handle parsing event message.
-
-    Topic: tns1:VideoSource/ImageTooBright/*
-    """
-    topic, payload = extract_message(msg)
-    source = payload.Source.SimpleItem[0].Value
-    return Event(
-        f"{uid}_{topic}_{source}",
-        "Image Too Bright",
-        "binary_sensor",
-        "problem",
-        None,
-        payload.Data.SimpleItem[0].Value == "true",
-        EntityCategory.DIAGNOSTIC,
-    )
-
-
-@PARSERS.register("tns1:VideoSource/GlobalSceneChange/AnalyticsService")
-@PARSERS.register("tns1:VideoSource/GlobalSceneChange/ImagingService")
-@PARSERS.register("tns1:VideoSource/GlobalSceneChange/RecordingService")
-async def async_parse_scene_change(uid: str, msg) -> Event | None:
-    """Handle parsing event message.
-
-    Topic: tns1:VideoSource/GlobalSceneChange/*
-    """
-    topic, payload = extract_message(msg)
-    source = payload.Source.SimpleItem[0].Value
-    return Event(
-        f"{uid}_{topic}_{source}",
-        "Global Scene Change",
-        "binary_sensor",
-        "problem",
-        None,
-        payload.Data.SimpleItem[0].Value == "true",
-    )
-
-
-@PARSERS.register("tns1:AudioAnalytics/Audio/DetectedSound")
-async def async_parse_detected_sound(uid: str, msg) -> Event | None:
-    """Handle parsing event message.
-
-    Topic: tns1:AudioAnalytics/Audio/DetectedSound
-    """
-    audio_source = ""
-    audio_analytics = ""
-    rule = ""
-    topic, payload = extract_message(msg)
-    for source in payload.Source.SimpleItem:
-        if source.Name == "AudioSourceConfigurationToken":
-            audio_source = source.Value
-        if source.Name == "AudioAnalyticsConfigurationToken":
-            audio_analytics = source.Value
-        if source.Name == "Rule":
-            rule = source.Value
-
-    return Event(
-        f"{uid}_{topic}_{audio_source}_{audio_analytics}_{rule}",
-        "Detected Sound",
-        "binary_sensor",
-        "sound",
-        None,
-        payload.Data.SimpleItem[0].Value == "true",
-    )
-
-
-@PARSERS.register("tns1:RuleEngine/FieldDetector/ObjectsInside")
-async def async_parse_field_detector(uid: str, msg) -> Event | None:
-    """Handle parsing event message.
-
-    Topic: tns1:RuleEngine/FieldDetector/ObjectsInside
-    """
-    video_source = ""
-    video_analytics = ""
-    rule = ""
-    topic, payload = extract_message(msg)
-    for source in payload.Source.SimpleItem:
-        if source.Name == "VideoSourceConfigurationToken":
-            video_source = _normalize_video_source(source.Value)
-        if source.Name == "VideoAnalyticsConfigurationToken":
-            video_analytics = source.Value
-        if source.Name == "Rule":
-            rule = source.Value
-
-    return Event(
-        f"{uid}_{topic}_{video_source}_{video_analytics}_{rule}",
-        "Field Detection",
-        "binary_sensor",
-        "motion",
-        None,
-        payload.Data.SimpleItem[0].Value == "true",
-    )
-
-
-@PARSERS.register("tns1:RuleEngine/CellMotionDetector/Motion")
-async def async_parse_cell_motion_detector(uid: str, msg) -> Event | None:
-    """Handle parsing event message.
-
-    Topic: tns1:RuleEngine/CellMotionDetector/Motion
-    """
-    video_source = ""
-    video_analytics = ""
-    rule = ""
-    topic, payload = extract_message(msg)
-    for source in payload.Source.SimpleItem:
-        if source.Name == "VideoSourceConfigurationToken":
-            video_source = _normalize_video_source(source.Value)
-        if source.Name == "VideoAnalyticsConfigurationToken":
-            video_analytics = source.Value
-        if source.Name == "Rule":
-            rule = source.Value
-
-    return Event(
-        f"{uid}_{topic}_{video_source}_{video_analytics}_{rule}",
-        "Cell Motion Detection",
-        "binary_sensor",
-        "motion",
-        None,
-        payload.Data.SimpleItem[0].Value == "true",
-    )
-
-
-@PARSERS.register("tns1:RuleEngine/MotionRegionDetector/Motion")
-async def async_parse_motion_region_detector(uid: str, msg) -> Event | None:
-    """Handle parsing event message.
-
-    Topic: tns1:RuleEngine/MotionRegionDetector/Motion
-    """
-    video_source = ""
-    video_analytics = ""
-    rule = ""
-    topic, payload = extract_message(msg)
-    for source in payload.Source.SimpleItem:
-        if source.Name == "VideoSourceConfigurationToken":
-            video_source = _normalize_video_source(source.Value)
-        if source.Name == "VideoAnalyticsConfigurationToken":
-            video_analytics = source.Value
-        if source.Name == "Rule":
-            rule = source.Value
-
-    return Event(
-        f"{uid}_{topic}_{video_source}_{video_analytics}_{rule}",
-        "Motion Region Detection",
-        "binary_sensor",
-        "motion",
-        None,
-        payload.Data.SimpleItem[0].Value in ["1", "true"],
-    )
-
-
-@PARSERS.register("tns1:RuleEngine/TamperDetector/Tamper")
-async def async_parse_tamper_detector(uid: str, msg) -> Event | None:
-    """Handle parsing event message.
-
-    Topic: tns1:RuleEngine/TamperDetector/Tamper
-    """
-    video_source = ""
-    video_analytics = ""
-    rule = ""
-    topic, payload = extract_message(msg)
-    for source in payload.Source.SimpleItem:
-        if source.Name == "VideoSourceConfigurationToken":
-            video_source = _normalize_video_source(source.Value)
-        if source.Name == "VideoAnalyticsConfigurationToken":
-            video_analytics = source.Value
-        if source.Name == "Rule":
-            rule = source.Value
-
-    return Event(
-        f"{uid}_{topic}_{video_source}_{video_analytics}_{rule}",
-        "Tamper Detection",
-        "binary_sensor",
-        "problem",
-        None,
-        payload.Data.SimpleItem[0].Value == "true",
-        EntityCategory.DIAGNOSTIC,
-    )
-
-
-@PARSERS.register("tns1:RuleEngine/MyRuleDetector/DogCatDetect")
-async def async_parse_dog_cat_detector(uid: str, msg) -> Event | None:
-    """Handle parsing event message.
-
-    Topic: tns1:RuleEngine/MyRuleDetector/DogCatDetect
-    """
-    video_source = ""
-    topic, payload = extract_message(msg)
-    for source in payload.Source.SimpleItem:
-        if source.Name == "Source":
-            video_source = _normalize_video_source(source.Value)
-
-    return Event(
-        f"{uid}_{topic}_{video_source}",
-        "Pet Detection",
-        "binary_sensor",
-        "motion",
-        None,
-        payload.Data.SimpleItem[0].Value == "true",
-    )
-
-
-@PARSERS.register("tns1:RuleEngine/MyRuleDetector/VehicleDetect")
-async def async_parse_vehicle_detector(uid: str, msg) -> Event | None:
-    """Handle parsing event message.
-
-    Topic: tns1:RuleEngine/MyRuleDetector/VehicleDetect
-    """
-    video_source = ""
-    topic, payload = extract_message(msg)
-    for source in payload.Source.SimpleItem:
-        if source.Name == "Source":
-            video_source = _normalize_video_source(source.Value)
-
-    return Event(
-        f"{uid}_{topic}_{video_source}",
-        "Vehicle Detection",
-        "binary_sensor",
-        "motion",
-        None,
-        payload.Data.SimpleItem[0].Value == "true",
-    )
-
-
-_TAPO_EVENT_TEMPLATES: dict[str, Event] = {
-    "IsVehicle": Event(
-        uid="",
-        name="Vehicle Detection",
-        platform="binary_sensor",
-        device_class="motion",
-    ),
-    "IsPeople": Event(
-        uid="", name="Person Detection", platform="binary_sensor", device_class="motion"
-    ),
-    "IsPet": Event(
-        uid="", name="Pet Detection", platform="binary_sensor", device_class="motion"
-    ),
-    "IsLineCross": Event(
-        uid="",
-        name="Line Detector Crossed",
-        platform="binary_sensor",
-        device_class="motion",
-    ),
-    "IsTamper": Event(
-        uid="", name="Tamper Detection", platform="binary_sensor", device_class="tamper"
-    ),
-    "IsIntrusion": Event(
-        uid="",
-        name="Intrusion Detection",
-        platform="binary_sensor",
-        device_class="safety",
-    ),
-}
-
-
-@PARSERS.register("tns1:RuleEngine/CellMotionDetector/Intrusion")
-@PARSERS.register("tns1:RuleEngine/CellMotionDetector/LineCross")
-@PARSERS.register("tns1:RuleEngine/CellMotionDetector/People")
-@PARSERS.register("tns1:RuleEngine/CellMotionDetector/Tamper")
-@PARSERS.register("tns1:RuleEngine/CellMotionDetector/TpSmartEvent")
-@PARSERS.register("tns1:RuleEngine/PeopleDetector/People")
-@PARSERS.register("tns1:RuleEngine/TPSmartEventDetector/TPSmartEvent")
-async def async_parse_tplink_detector(uid: str, msg) -> Event | None:
-    """Handle parsing tplink smart event messages.
-
-    Topic: tns1:RuleEngine/CellMotionDetector/Intrusion
-    Topic: tns1:RuleEngine/CellMotionDetector/LineCross
-    Topic: tns1:RuleEngine/CellMotionDetector/People
-    Topic: tns1:RuleEngine/CellMotionDetector/Tamper
-    Topic: tns1:RuleEngine/CellMotionDetector/TpSmartEvent
-    Topic: tns1:RuleEngine/PeopleDetector/People
-    Topic: tns1:RuleEngine/TPSmartEventDetector/TPSmartEvent
-    """
-    video_source = ""
-    video_analytics = ""
-    rule = ""
-    topic, payload = extract_message(msg)
-    for source in payload.Source.SimpleItem:
-        if source.Name == "VideoSourceConfigurationToken":
-            video_source = _normalize_video_source(source.Value)
-        if source.Name == "VideoAnalyticsConfigurationToken":
-            video_analytics = source.Value
-        if source.Name == "Rule":
-            rule = source.Value
-
-    for item in payload.Data.SimpleItem:
-        event_template = _TAPO_EVENT_TEMPLATES.get(item.Name)
-        if event_template is None:
-            continue
-
-        return dataclasses.replace(
-            event_template,
-            uid=f"{uid}_{topic}_{video_source}_{video_analytics}_{rule}",
-            value=item.Value == "true",
-        )
-
-    return None
-
-
-@PARSERS.register("tns1:RuleEngine/MyRuleDetector/PeopleDetect")
-async def async_parse_person_detector(uid: str, msg) -> Event | None:
-    """Handle parsing event message.
-
-    Topic: tns1:RuleEngine/MyRuleDetector/PeopleDetect
-    """
-    video_source = ""
-    topic, payload = extract_message(msg)
-    for source in payload.Source.SimpleItem:
-        if source.Name == "Source":
-            video_source = _normalize_video_source(source.Value)
-
-    return Event(
-        f"{uid}_{topic}_{video_source}",
-        "Person Detection",
-        "binary_sensor",
-        "motion",
-        None,
-        payload.Data.SimpleItem[0].Value == "true",
-    )
-
-
-@PARSERS.register("tns1:RuleEngine/MyRuleDetector/FaceDetect")
-async def async_parse_face_detector(uid: str, msg) -> Event | None:
-    """Handle parsing event message.
-
-    Topic: tns1:RuleEngine/MyRuleDetector/FaceDetect
-    """
-    video_source = ""
-    topic, payload = extract_message(msg)
-    for source in payload.Source.SimpleItem:
-        if source.Name == "Source":
-            video_source = _normalize_video_source(source.Value)
-
-    return Event(
-        f"{uid}_{topic}_{video_source}",
-        "Face Detection",
-        "binary_sensor",
-        "motion",
-        None,
-        payload.Data.SimpleItem[0].Value == "true",
-    )
-
-
-@PARSERS.register("tns1:RuleEngine/MyRuleDetector/Visitor")
-async def async_parse_visitor_detector(uid: str, msg) -> Event | None:
-    """Handle parsing event message.
-
-    Topic: tns1:RuleEngine/MyRuleDetector/Visitor
-    """
-    video_source = ""
-    topic, payload = extract_message(msg)
-    for source in payload.Source.SimpleItem:
-        if source.Name == "Source":
-            video_source = _normalize_video_source(source.Value)
-
-    return Event(
-        f"{uid}_{topic}_{video_source}",
-        "Visitor Detection",
-        "binary_sensor",
-        "occupancy",
-        None,
-        payload.Data.SimpleItem[0].Value == "true",
-    )
-
-
-@PARSERS.register("tns1:RuleEngine/MyRuleDetector/Package")
-async def async_parse_package_detector(uid: str, msg) -> Event | None:
-    """Handle parsing event message.
-
-    Topic: tns1:RuleEngine/MyRuleDetector/Package
-    """
-    video_source = ""
-    topic, payload = extract_message(msg)
-    for source in payload.Source.SimpleItem:
-        if source.Name == "Source":
-            video_source = _normalize_video_source(source.Value)
-
-    return Event(
-        f"{uid}_{topic}_{video_source}",
-        "Package Detection",
-        "binary_sensor",
-        "occupancy",
-        None,
-        payload.Data.SimpleItem[0].Value == "true",
-    )
-
-
-@PARSERS.register("tns1:Device/Trigger/DigitalInput")
-async def async_parse_digital_input(uid: str, msg) -> Event | None:
-    """Handle parsing event message.
-
-    Topic: tns1:Device/Trigger/DigitalInput
-    """
-    topic, payload = extract_message(msg)
-    source = payload.Source.SimpleItem[0].Value
-    return Event(
-        f"{uid}_{topic}_{source}",
-        "Digital Input",
-        "binary_sensor",
-        None,
-        None,
-        payload.Data.SimpleItem[0].Value == "true",
-    )
-
-
-@PARSERS.register("tns1:Device/Trigger/Relay")
-async def async_parse_relay(uid: str, msg) -> Event | None:
-    """Handle parsing event message.
-
-    Topic: tns1:Device/Trigger/Relay
-    """
-    topic, payload = extract_message(msg)
-    source = payload.Source.SimpleItem[0].Value
-    return Event(
-        f"{uid}_{topic}_{source}",
-        "Relay Triggered",
-        "binary_sensor",
-        None,
-        None,
-        payload.Data.SimpleItem[0].Value == "active",
-    )
-
-
-@PARSERS.register("tns1:Device/HardwareFailure/StorageFailure")
-async def async_parse_storage_failure(uid: str, msg) -> Event | None:
-    """Handle parsing event message.
-
-    Topic: tns1:Device/HardwareFailure/StorageFailure
-    """
-    topic, payload = extract_message(msg)
-    source = payload.Source.SimpleItem[0].Value
-    return Event(
-        f"{uid}_{topic}_{source}",
-        "Storage Failure",
-        "binary_sensor",
-        "problem",
-        None,
-        payload.Data.SimpleItem[0].Value == "true",
-        EntityCategory.DIAGNOSTIC,
-    )
-
-
-@PARSERS.register("tns1:Monitoring/ProcessorUsage")
-async def async_parse_processor_usage(uid: str, msg) -> Event | None:
-    """Handle parsing event message.
-
-    Topic: tns1:Monitoring/ProcessorUsage
-    """
-    topic, payload = extract_message(msg)
-    usage = float(payload.Data.SimpleItem[0].Value)
-    if usage <= 1:
-        usage *= 100
-
-    return Event(
-        f"{uid}_{topic}",
-        "Processor Usage",
-        "sensor",
-        None,
-        "percent",
-        int(usage),
-        EntityCategory.DIAGNOSTIC,
-    )
-
-
-@PARSERS.register("tns1:Monitoring/OperatingTime/LastReboot")
-async def async_parse_last_reboot(uid: str, msg) -> Event | None:
-    """Handle parsing event message.
-
-    Topic: tns1:Monitoring/OperatingTime/LastReboot
-    """
-    topic, payload = extract_message(msg)
-    date_time = local_datetime_or_none(payload.Data.SimpleItem[0].Value)
-    return Event(
-        f"{uid}_{topic}",
-        "Last Reboot",
-        "sensor",
-        "timestamp",
-        None,
-        date_time,
-        EntityCategory.DIAGNOSTIC,
-    )
-
-
-@PARSERS.register("tns1:Monitoring/OperatingTime/LastReset")
-async def async_parse_last_reset(uid: str, msg) -> Event | None:
-    """Handle parsing event message.
-
-    Topic: tns1:Monitoring/OperatingTime/LastReset
-    """
-    topic, payload = extract_message(msg)
-    date_time = local_datetime_or_none(payload.Data.SimpleItem[0].Value)
-    return Event(
-        f"{uid}_{topic}",
-        "Last Reset",
-        "sensor",
-        "timestamp",
-        None,
-        date_time,
-        EntityCategory.DIAGNOSTIC,
-        entity_enabled=False,
-    )
-
-
-@PARSERS.register("tns1:Monitoring/Backup/Last")
-async def async_parse_backup_last(uid: str, msg) -> Event | None:
-    """Handle parsing event message.
-
-    Topic: tns1:Monitoring/Backup/Last
-    """
-    topic, payload = extract_message(msg)
-    date_time = local_datetime_or_none(payload.Data.SimpleItem[0].Value)
-    return Event(
-        f"{uid}_{topic}",
-        "Last Backup",
-        "sensor",
-        "timestamp",
-        None,
-        date_time,
-        EntityCategory.DIAGNOSTIC,
-        entity_enabled=False,
-    )
-
-
-@PARSERS.register("tns1:Monitoring/OperatingTime/LastClockSynchronization")
-async def async_parse_last_clock_sync(uid: str, msg) -> Event | None:
-    """Handle parsing event message.
-
-    Topic: tns1:Monitoring/OperatingTime/LastClockSynchronization
-    """
-    topic, payload = extract_message(msg)
-    date_time = local_datetime_or_none(payload.Data.SimpleItem[0].Value)
-    return Event(
-        f"{uid}_{topic}",
-        "Last Clock Synchronization",
-        "sensor",
-        "timestamp",
-        None,
-        date_time,
-        EntityCategory.DIAGNOSTIC,
-        entity_enabled=False,
-    )
-
-
-@PARSERS.register("tns1:RecordingConfig/JobState")
-async def async_parse_jobstate(uid: str, msg) -> Event | None:
-    """Handle parsing event message.
-
-    Topic: tns1:RecordingConfig/JobState
-    """
-
-    topic, payload = extract_message(msg)
-    source = payload.Source.SimpleItem[0].Value
-    return Event(
-        f"{uid}_{topic}_{source}",
-        "Recording Job State",
-        "binary_sensor",
-        None,
-        None,
-        payload.Data.SimpleItem[0].Value == "Active",
-        EntityCategory.DIAGNOSTIC,
-    )
-
-
-@PARSERS.register("tns1:RuleEngine/LineDetector/Crossed")
-async def async_parse_linedetector_crossed(uid: str, msg) -> Event | None:
-    """Handle parsing event message.
-
-    Topic: tns1:RuleEngine/LineDetector/Crossed
-    """
-    video_source = ""
-    video_analytics = ""
-    rule = ""
-    topic, payload = extract_message(msg)
-    for source in payload.Source.SimpleItem:
-        if source.Name == "VideoSourceConfigurationToken":
-            video_source = source.Value
-        if source.Name == "VideoAnalyticsConfigurationToken":
-            video_analytics = source.Value
-        if source.Name == "Rule":
-            rule = source.Value
-
-    return Event(
-        f"{uid}_{topic}_{video_source}_{video_analytics}_{rule}",
-        "Line Detector Crossed",
-        "sensor",
-        None,
-        None,
-        payload.Data.SimpleItem[0].Value,
-        EntityCategory.DIAGNOSTIC,
-    )
-
-
-@PARSERS.register("tns1:RuleEngine/CountAggregation/Counter")
-async def async_parse_count_aggregation_counter(uid: str, msg) -> Event | None:
-    """Handle parsing event message.
-
-    Topic: tns1:RuleEngine/CountAggregation/Counter
-    """
-    video_source = ""
-    video_analytics = ""
-    rule = ""
-    topic, payload = extract_message(msg)
-    for source in payload.Source.SimpleItem:
-        if source.Name == "VideoSourceConfigurationToken":
-            video_source = _normalize_video_source(source.Value)
-        if source.Name == "VideoAnalyticsConfigurationToken":
-            video_analytics = source.Value
-        if source.Name == "Rule":
-            rule = source.Value
-
-    return Event(
-        f"{uid}_{topic}_{video_source}_{video_analytics}_{rule}",
-        "Count Aggregation Counter",
-        "sensor",
-        None,
-        None,
-        payload.Data.SimpleItem[0].Value,
-        EntityCategory.DIAGNOSTIC,
-    )
-
-
-@PARSERS.register("tns1:UserAlarm/IVA/HumanShapeDetect")
-async def async_parse_human_shape_detect(uid: str, msg) -> Event | None:
-    """Handle parsing event message.
-
-    Topic: tns1:UserAlarm/IVA/HumanShapeDetect
-    """
-    topic, payload = extract_message(msg)
-    video_source = ""
-    for source in payload.Source.SimpleItem:
-        if source.Name == "VideoSourceConfigurationToken":
-            video_source = _normalize_video_source(source.Value)
-            break
-
-    return Event(
-        f"{uid}_{topic}_{video_source}",
-        "Human Shape Detect",
-        "binary_sensor",
-        "motion",
-        None,
-        payload.Data.SimpleItem[0].Value == "true",
-    )

homeassistant/components/smartthings/icons.json

@@ -102,6 +102,9 @@
       "robot_cleaner_driving_mode": {
         "default": "mdi:car-cog"
       },
+      "robot_cleaner_water_spray_level": {
+        "default": "mdi:spray-bottle"
+      },
       "selected_zone": {
         "state": {
           "all": "mdi:card",

homeassistant/components/smartthings/select.py

@@ -43,6 +43,14 @@ WASHER_SOIL_LEVEL_TO_HA = {
     "down": "down",
 }
 
+WATER_SPRAY_LEVEL_TO_HA = {
+    "high": "high",
+    "mediumHigh": "moderate_high",
+    "medium": "medium",
+    "mediumLow": "moderate_low",
+    "low": "low",
+}
+
 WASHER_SPIN_LEVEL_TO_HA = {
     "none": "none",
     "rinseHold": "rinse_hold",
@@ -202,6 +210,15 @@ CAPABILITIES_TO_SELECT: dict[Capability | str, SmartThingsSelectDescription] = {
         options_map=WASHER_WATER_TEMPERATURE_TO_HA,
         entity_category=EntityCategory.CONFIG,
     ),
+    Capability.SAMSUNG_CE_ROBOT_CLEANER_WATER_SPRAY_LEVEL: SmartThingsSelectDescription(
+        key=Capability.SAMSUNG_CE_ROBOT_CLEANER_WATER_SPRAY_LEVEL,
+        translation_key="robot_cleaner_water_spray_level",
+        options_attribute=Attribute.SUPPORTED_WATER_SPRAY_LEVELS,
+        status_attribute=Attribute.WATER_SPRAY_LEVEL,
+        command=Command.SET_WATER_SPRAY_LEVEL,
+        options_map=WATER_SPRAY_LEVEL_TO_HA,
+        entity_category=EntityCategory.CONFIG,
+    ),
     Capability.SAMSUNG_CE_ROBOT_CLEANER_DRIVING_MODE: SmartThingsSelectDescription(
         key=Capability.SAMSUNG_CE_ROBOT_CLEANER_DRIVING_MODE,
         translation_key="robot_cleaner_driving_mode",

homeassistant/components/smartthings/strings.json

@@ -237,6 +237,16 @@
           "walls_first": "Walls first"
         }
       },
+      "robot_cleaner_water_spray_level": {
+        "name": "Water level",
+        "state": {
+          "high": "[%key:common::state::high%]",
+          "low": "[%key:common::state::low%]",
+          "medium": "Medium",
+          "moderate_high": "Moderate high",
+          "moderate_low": "Moderate low"
+        }
+      },
       "selected_zone": {
         "name": "Selected zone",
         "state": {

homeassistant/components/switchbot_cloud/climate.py

@@ -17,13 +17,11 @@ from homeassistant.components import climate as FanState
 from homeassistant.components.climate import (
     ATTR_FAN_MODE,
     ATTR_TEMPERATURE,
-    PRESET_AWAY,
     PRESET_BOOST,
     PRESET_COMFORT,
     PRESET_ECO,
     PRESET_HOME,
     PRESET_NONE,
-    PRESET_SLEEP,
     ClimateEntity,
     ClimateEntityFeature,
     HVACMode,
@@ -40,7 +38,11 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.restore_state import RestoreEntity
 
 from . import SwitchbotCloudData, SwitchBotCoordinator
-from .const import DOMAIN, SMART_RADIATOR_THERMOSTAT_AFTER_COMMAND_REFRESH
+from .const import (
+    CLIMATE_PRESET_SCHEDULE,
+    DOMAIN,
+    SMART_RADIATOR_THERMOSTAT_AFTER_COMMAND_REFRESH,
+)
 from .entity import SwitchBotCloudEntity
 
 _LOGGER = getLogger(__name__)
@@ -206,6 +208,7 @@ RADIATOR_PRESET_MODE_MAP: dict[str, SmartRadiatorThermostatMode] = {
     PRESET_BOOST: SmartRadiatorThermostatMode.FAST_HEATING,
     PRESET_COMFORT: SmartRadiatorThermostatMode.COMFORT,
     PRESET_HOME: SmartRadiatorThermostatMode.MANUAL,
+    CLIMATE_PRESET_SCHEDULE: SmartRadiatorThermostatMode.SCHEDULE,
 }
 
 RADIATOR_HA_PRESET_MODE_MAP = {
@@ -227,15 +230,10 @@ class SwitchBotCloudSmartRadiatorThermostat(SwitchBotCloudEntity, ClimateEntity)
     _attr_target_temperature_step = PRECISION_TENTHS
     _attr_temperature_unit = UnitOfTemperature.CELSIUS
 
-    _attr_preset_modes = [
-        PRESET_NONE,
-        PRESET_ECO,
-        PRESET_AWAY,
-        PRESET_BOOST,
-        PRESET_COMFORT,
-        PRESET_HOME,
-        PRESET_SLEEP,
-    ]
+    _attr_preset_modes = list(RADIATOR_PRESET_MODE_MAP)
+
+    _attr_translation_key = "smart_radiator_thermostat"
+
     _attr_preset_mode = PRESET_HOME
 
     _attr_hvac_modes = [
@@ -300,7 +298,7 @@ class SwitchBotCloudSmartRadiatorThermostat(SwitchBotCloudEntity, ClimateEntity)
             SmartRadiatorThermostatMode(mode)
         ]
 
-        if self.preset_mode in [PRESET_NONE, PRESET_AWAY]:
+        if self.preset_mode == PRESET_NONE:
             self._attr_hvac_mode = HVACMode.OFF
         else:
             self._attr_hvac_mode = HVACMode.HEAT

homeassistant/components/switchbot_cloud/const.py

@@ -17,6 +17,9 @@ VACUUM_FAN_SPEED_STANDARD = "standard"
 VACUUM_FAN_SPEED_STRONG = "strong"
 VACUUM_FAN_SPEED_MAX = "max"
 
+
+CLIMATE_PRESET_SCHEDULE = "schedule"
+
 AFTER_COMMAND_REFRESH = 5
 COVER_ENTITY_AFTER_COMMAND_REFRESH = 10
 SMART_RADIATOR_THERMOSTAT_AFTER_COMMAND_REFRESH = 30

homeassistant/components/switchbot_cloud/icons.json

@@ -8,6 +8,17 @@
         "default": "mdi:chevron-left-box"
       }
     },
+    "climate": {
+      "smart_radiator_thermostat": {
+        "state_attributes": {
+          "preset_mode": {
+            "state": {
+              "schedule": "mdi:clock-outline"
+            }
+          }
+        }
+      }
+    },
     "fan": {
       "air_purifier": {
         "default": "mdi:air-purifier",

homeassistant/components/switchbot_cloud/strings.json

@@ -26,6 +26,17 @@
         "name": "Previous"
       }
     },
+    "climate": {
+      "smart_radiator_thermostat": {
+        "state_attributes": {
+          "preset_mode": {
+            "state": {
+              "schedule": "Schedule"
+            }
+          }
+        }
+      }
+    },
     "fan": {
       "air_purifier": {
         "state_attributes": {

homeassistant/components/tankerkoenig/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["aiotankerkoenig"],
   "quality_scale": "platinum",
-  "requirements": ["aiotankerkoenig==0.4.2"]
+  "requirements": ["aiotankerkoenig==0.5.1"]
 }

homeassistant/components/tuya/alarm_control_panel.py

@@ -37,23 +37,23 @@ ALARM: dict[DeviceCategory, tuple[AlarmControlPanelEntityDescription, ...]] = {
 }
 
 
-class _AlarmChangedByWrapper(DPCodeRawWrapper[str]):
+class _AlarmChangedByWrapper(DPCodeRawWrapper):
     """Wrapper for changed_by.
 
     Decode base64 to utf-16be string, but only if alarm has been triggered.
     """
 
-    def read_device_status(self, device: CustomerDevice) -> str | None:
+    def read_device_status(self, device: CustomerDevice) -> str | None:  # type: ignore[override]
         """Read the device status."""
         if (
             device.status.get(DPCode.MASTER_STATE) != "alarm"
-            or (status := self._read_dpcode_value(device)) is None
+            or (status := super().read_device_status(device)) is None
         ):
             return None
         return status.decode("utf-16be")
 
 
-class _AlarmStateWrapper(DPCodeEnumWrapper[AlarmControlPanelState]):
+class _AlarmStateWrapper(DPCodeEnumWrapper):
     """Wrapper for the alarm state of a device.
 
     Handles alarm mode enum values and determines the alarm state,
@@ -84,7 +84,7 @@ class _AlarmStateWrapper(DPCodeEnumWrapper[AlarmControlPanelState]):
             ):
                 return AlarmControlPanelState.TRIGGERED
 
-        if (status := self._read_dpcode_value(device)) is None:
+        if (status := super().read_device_status(device)) is None:
             return None
         return self._STATE_MAPPINGS.get(status)
 
@@ -139,10 +139,10 @@ async def async_setup_entry(
                         action_wrapper=_AlarmActionWrapper(
                             master_mode.dpcode, master_mode
                         ),
-                        changed_by_wrapper=_AlarmChangedByWrapper.find_dpcode(  # type: ignore[arg-type]
+                        changed_by_wrapper=_AlarmChangedByWrapper.find_dpcode(
                             device, DPCode.ALARM_MSG
                         ),
-                        state_wrapper=_AlarmStateWrapper(  # type: ignore[arg-type]
+                        state_wrapper=_AlarmStateWrapper(
                             master_mode.dpcode, master_mode
                         ),
                     )

homeassistant/components/tuya/binary_sensor.py

@@ -376,7 +376,7 @@ BINARY_SENSORS: dict[DeviceCategory, tuple[TuyaBinarySensorEntityDescription, ..
 }
 
 
-class _CustomDPCodeWrapper(DPCodeWrapper[bool]):
+class _CustomDPCodeWrapper(DPCodeWrapper):
     """Custom DPCode Wrapper to check for values in a set."""
 
     _valid_values: set[bool | float | int | str]

homeassistant/components/tuya/climate.py

@@ -54,18 +54,18 @@ TUYA_HVAC_TO_HA = {
 }
 
 
-class _RoundedIntegerWrapper(DPCodeIntegerWrapper[int]):
+class _RoundedIntegerWrapper(DPCodeIntegerWrapper):
     """An integer that always rounds its value."""
 
     def read_device_status(self, device: CustomerDevice) -> int | None:
         """Read and round the device status."""
-        if (value := self._read_dpcode_value(device)) is None:
+        if (value := super().read_device_status(device)) is None:
             return None
         return round(value)
 
 
 @dataclass(kw_only=True)
-class _SwingModeWrapper(DeviceWrapper[str]):
+class _SwingModeWrapper(DeviceWrapper):
     """Wrapper for managing climate swing mode operations across multiple DPCodes."""
 
     on_off: DPCodeBooleanWrapper | None = None
@@ -158,7 +158,7 @@ def _filter_hvac_mode_mappings(tuya_range: list[str]) -> dict[str, HVACMode | No
     return modes_in_range
 
 
-class _HvacModeWrapper(DPCodeEnumWrapper[HVACMode]):
+class _HvacModeWrapper(DPCodeEnumWrapper):
     """Wrapper for managing climate HVACMode."""
 
     # Modes that do not map to HVAC modes are ignored (they are handled by PresetWrapper)
@@ -173,11 +173,11 @@ class _HvacModeWrapper(DPCodeEnumWrapper[HVACMode]):
 
     def read_device_status(self, device: CustomerDevice) -> HVACMode | None:
         """Read the device status."""
-        if (raw := self._read_dpcode_value(device)) not in TUYA_HVAC_TO_HA:
+        if (raw := super().read_device_status(device)) not in TUYA_HVAC_TO_HA:
             return None
         return TUYA_HVAC_TO_HA[raw]
 
-    def _convert_value_to_raw_value(
+    def _convert_value_to_raw_value(  # type: ignore[override]
         self,
         device: CustomerDevice,
         value: HVACMode,
@@ -205,7 +205,7 @@ class _PresetWrapper(DPCodeEnumWrapper):
 
     def read_device_status(self, device: CustomerDevice) -> str | None:
         """Read the device status."""
-        if (raw := self._read_dpcode_value(device)) in TUYA_HVAC_TO_HA:
+        if (raw := super().read_device_status(device)) in TUYA_HVAC_TO_HA:
             return None
         return raw
 
@@ -358,7 +358,7 @@ async def async_setup_entry(
                         device,
                         manager,
                         CLIMATE_DESCRIPTIONS[device.category],
-                        current_humidity_wrapper=_RoundedIntegerWrapper.find_dpcode(  # type: ignore[arg-type]
+                        current_humidity_wrapper=_RoundedIntegerWrapper.find_dpcode(
                             device, DPCode.HUMIDITY_CURRENT
                         ),
                         current_temperature_wrapper=temperature_wrappers[0],
@@ -367,7 +367,7 @@ async def async_setup_entry(
                             (DPCode.FAN_SPEED_ENUM, DPCode.LEVEL, DPCode.WINDSPEED),
                             prefer_function=True,
                         ),
-                        hvac_mode_wrapper=_HvacModeWrapper.find_dpcode(  # type: ignore[arg-type]
+                        hvac_mode_wrapper=_HvacModeWrapper.find_dpcode(
                             device, DPCode.MODE, prefer_function=True
                         ),
                         preset_wrapper=_PresetWrapper.find_dpcode(
@@ -378,7 +378,7 @@ async def async_setup_entry(
                         switch_wrapper=DPCodeBooleanWrapper.find_dpcode(
                             device, DPCode.SWITCH, prefer_function=True
                         ),
-                        target_humidity_wrapper=_RoundedIntegerWrapper.find_dpcode(  # type: ignore[arg-type]
+                        target_humidity_wrapper=_RoundedIntegerWrapper.find_dpcode(
                             device, DPCode.HUMIDITY_SET, prefer_function=True
                         ),
                         temperature_unit=temperature_wrappers[2],

homeassistant/components/tuya/cover.py

@@ -35,7 +35,7 @@ from .const import TUYA_DISCOVERY_NEW, DeviceCategory, DPCode
 from .entity import TuyaEntity
 
 
-class _DPCodePercentageMappingWrapper(DPCodeIntegerWrapper[int]):
+class _DPCodePercentageMappingWrapper(DPCodeIntegerWrapper):
     """Wrapper for DPCode position values mapping to 0-100 range."""
 
     def __init__(self, dpcode: str, type_information: IntegerTypeInformation) -> None:
@@ -47,7 +47,7 @@ class _DPCodePercentageMappingWrapper(DPCodeIntegerWrapper[int]):
         """Check if the position and direction should be reversed."""
         return False
 
-    def read_device_status(self, device: CustomerDevice) -> int | None:
+    def read_device_status(self, device: CustomerDevice) -> float | None:
         if (value := device.status.get(self.dpcode)) is None:
             return None
 
@@ -87,7 +87,7 @@ class _InstructionBooleanWrapper(DPCodeBooleanWrapper):
     options = ["open", "close"]
     _ACTION_MAPPINGS = {"open": True, "close": False}
 
-    def _convert_value_to_raw_value(self, device: CustomerDevice, value: str) -> bool:
+    def _convert_value_to_raw_value(self, device: CustomerDevice, value: str) -> bool:  # type: ignore[override]
         return self._ACTION_MAPPINGS[value]
 
 
@@ -118,12 +118,12 @@ class _IsClosedInvertedWrapper(DPCodeBooleanWrapper):
     """Boolean wrapper for checking if cover is closed (inverted)."""
 
     def read_device_status(self, device: CustomerDevice) -> bool | None:
-        if (value := self._read_dpcode_value(device)) is None:
+        if (value := super().read_device_status(device)) is None:
             return None
         return not value
 
 
-class _IsClosedEnumWrapper(DPCodeEnumWrapper[bool]):
+class _IsClosedEnumWrapper(DPCodeEnumWrapper):
     """Enum wrapper for checking if state is closed."""
 
     _MAPPINGS = {
@@ -133,8 +133,8 @@ class _IsClosedEnumWrapper(DPCodeEnumWrapper[bool]):
         "fully_open": False,
     }
 
-    def read_device_status(self, device: CustomerDevice) -> bool | None:
-        if (value := self._read_dpcode_value(device)) is None:
+    def read_device_status(self, device: CustomerDevice) -> bool | None:  # type: ignore[override]
+        if (value := super().read_device_status(device)) is None:
             return None
         return self._MAPPINGS.get(value)
 
@@ -291,19 +291,19 @@ async def async_setup_entry(
                         device,
                         manager,
                         description,
-                        current_position=description.position_wrapper.find_dpcode(  # type: ignore[arg-type]
+                        current_position=description.position_wrapper.find_dpcode(
                             device, description.current_position
                         ),
-                        current_state_wrapper=description.current_state_wrapper.find_dpcode(  # type: ignore[arg-type]
+                        current_state_wrapper=description.current_state_wrapper.find_dpcode(
                             device, description.current_state
                         ),
                         instruction_wrapper=_get_instruction_wrapper(
                             device, description
                         ),
-                        set_position=description.position_wrapper.find_dpcode(  # type: ignore[arg-type]
+                        set_position=description.position_wrapper.find_dpcode(
                             device, description.set_position, prefer_function=True
                         ),
-                        tilt_position=description.position_wrapper.find_dpcode(  # type: ignore[arg-type]
+                        tilt_position=description.position_wrapper.find_dpcode(
                             device,
                             (DPCode.ANGLE_HORIZONTAL, DPCode.ANGLE_VERTICAL),
                             prefer_function=True,

homeassistant/components/tuya/event.py

@@ -29,17 +29,19 @@ from .const import TUYA_DISCOVERY_NEW, DeviceCategory, DPCode
 from .entity import TuyaEntity
 
 
-class _EventEnumWrapper(DPCodeEnumWrapper[tuple[str, None]]):
+class _EventEnumWrapper(DPCodeEnumWrapper):
     """Wrapper for event enum DP codes."""
 
-    def read_device_status(self, device: CustomerDevice) -> tuple[str, None] | None:
+    def read_device_status(  # type: ignore[override]
+        self, device: CustomerDevice
+    ) -> tuple[str, None] | None:
         """Return the event details."""
-        if (raw_value := self._read_dpcode_value(device)) is None:
+        if (raw_value := super().read_device_status(device)) is None:
             return None
         return (raw_value, None)
 
 
-class _AlarmMessageWrapper(DPCodeStringWrapper[tuple[str, dict[str, Any]]]):
+class _AlarmMessageWrapper(DPCodeStringWrapper):
     """Wrapper for a STRING message on DPCode.ALARM_MESSAGE."""
 
     def __init__(self, dpcode: str, type_information: Any) -> None:
@@ -47,16 +49,16 @@ class _AlarmMessageWrapper(DPCodeStringWrapper[tuple[str, dict[str, Any]]]):
         super().__init__(dpcode, type_information)
         self.options = ["triggered"]
 
-    def read_device_status(  # type: ignore[override]
+    def read_device_status(
         self, device: CustomerDevice
     ) -> tuple[str, dict[str, Any]] | None:
         """Return the event attributes for the alarm message."""
-        if (raw_value := self._read_dpcode_value(device)) is None:
+        if (raw_value := super().read_device_status(device)) is None:
             return None
         return ("triggered", {"message": b64decode(raw_value).decode("utf-8")})
 
 
-class _DoorbellPicWrapper(DPCodeRawWrapper[tuple[str, dict[str, Any]]]):
+class _DoorbellPicWrapper(DPCodeRawWrapper):
     """Wrapper for a RAW message on DPCode.DOORBELL_PIC.
 
     It is expected that the RAW data is base64/utf8 encoded URL of the picture.
@@ -67,11 +69,11 @@ class _DoorbellPicWrapper(DPCodeRawWrapper[tuple[str, dict[str, Any]]]):
         super().__init__(dpcode, type_information)
         self.options = ["triggered"]
 
-    def read_device_status(
+    def read_device_status(  # type: ignore[override]
         self, device: CustomerDevice
     ) -> tuple[str, dict[str, Any]] | None:
         """Return the event attributes for the doorbell picture."""
-        if (status := self._read_dpcode_value(device)) is None:
+        if (status := super().read_device_status(device)) is None:
             return None
         return ("triggered", {"message": status.decode("utf-8")})
 

homeassistant/components/tuya/fan.py

@@ -59,7 +59,7 @@ class _DirectionEnumWrapper(DPCodeEnumWrapper):
 
     def read_device_status(self, device: CustomerDevice) -> str | None:
         """Read the device status and return the direction string."""
-        if (value := self._read_dpcode_value(device)) and value in {
+        if (value := super().read_device_status(device)) and value in {
             DIRECTION_FORWARD,
             DIRECTION_REVERSE,
         }:
@@ -80,12 +80,12 @@ def _has_a_valid_dpcode(device: CustomerDevice) -> bool:
     return any(get_dpcode(device, code) for code in properties_to_check)
 
 
-class _FanSpeedEnumWrapper(DPCodeEnumWrapper[int]):
+class _FanSpeedEnumWrapper(DPCodeEnumWrapper):
     """Wrapper for fan speed DP code (from an enum)."""
 
-    def read_device_status(self, device: CustomerDevice) -> int | None:
+    def read_device_status(self, device: CustomerDevice) -> int | None:  # type: ignore[override]
         """Get the current speed as a percentage."""
-        if (value := self._read_dpcode_value(device)) is None:
+        if (value := super().read_device_status(device)) is None:
             return None
         return ordered_list_item_to_percentage(self.options, value)
 
@@ -94,7 +94,7 @@ class _FanSpeedEnumWrapper(DPCodeEnumWrapper[int]):
         return percentage_to_ordered_list_item(self.options, value)
 
 
-class _FanSpeedIntegerWrapper(DPCodeIntegerWrapper[int]):
+class _FanSpeedIntegerWrapper(DPCodeIntegerWrapper):
     """Wrapper for fan speed DP code (from an integer)."""
 
     def __init__(self, dpcode: str, type_information: IntegerTypeInformation) -> None:
@@ -104,7 +104,7 @@ class _FanSpeedIntegerWrapper(DPCodeIntegerWrapper[int]):
 
     def read_device_status(self, device: CustomerDevice) -> int | None:
         """Get the current speed as a percentage."""
-        if (value := self._read_dpcode_value(device)) is None:
+        if (value := super().read_device_status(device)) is None:
             return None
         return round(self._remap_helper.remap_value_to(value))
 
@@ -154,7 +154,7 @@ async def async_setup_entry(
                         oscillate_wrapper=DPCodeBooleanWrapper.find_dpcode(
                             device, _OSCILLATE_DPCODES, prefer_function=True
                         ),
-                        speed_wrapper=_get_speed_wrapper(device),  # type: ignore[arg-type]
+                        speed_wrapper=_get_speed_wrapper(device),
                         switch_wrapper=DPCodeBooleanWrapper.find_dpcode(
                             device, _SWITCH_DPCODES, prefer_function=True
                         ),

homeassistant/components/tuya/humidifier.py

@@ -29,12 +29,12 @@ from .entity import TuyaEntity
 from .util import ActionDPCodeNotFoundError, get_dpcode
 
 
-class _RoundedIntegerWrapper(DPCodeIntegerWrapper[int]):
+class _RoundedIntegerWrapper(DPCodeIntegerWrapper):
     """An integer that always rounds its value."""
 
     def read_device_status(self, device: CustomerDevice) -> int | None:
         """Read and round the device status."""
-        if (value := self._read_dpcode_value(device)) is None:
+        if (value := super().read_device_status(device)) is None:
             return None
         return round(value)
 
@@ -104,7 +104,7 @@ async def async_setup_entry(
                         device,
                         manager,
                         description,
-                        current_humidity_wrapper=_RoundedIntegerWrapper.find_dpcode(  # type: ignore[arg-type]
+                        current_humidity_wrapper=_RoundedIntegerWrapper.find_dpcode(
                             device, description.current_humidity
                         ),
                         mode_wrapper=DPCodeEnumWrapper.find_dpcode(
@@ -115,7 +115,7 @@ async def async_setup_entry(
                             description.dpcode or description.key,
                             prefer_function=True,
                         ),
-                        target_humidity_wrapper=_RoundedIntegerWrapper.find_dpcode(  # type: ignore[arg-type]
+                        target_humidity_wrapper=_RoundedIntegerWrapper.find_dpcode(
                             device, description.humidity, prefer_function=True
                         ),
                     )

homeassistant/components/tuya/light.py

@@ -41,7 +41,7 @@ from .const import TUYA_DISCOVERY_NEW, DeviceCategory, DPCode, WorkMode
 from .entity import TuyaEntity
 
 
-class _BrightnessWrapper(DPCodeIntegerWrapper[int]):
+class _BrightnessWrapper(DPCodeIntegerWrapper):
     """Wrapper for brightness DP code.
 
     Handles brightness value conversion between device scale and Home Assistant's
@@ -59,7 +59,7 @@ class _BrightnessWrapper(DPCodeIntegerWrapper[int]):
         super().__init__(dpcode, type_information)
         self._remap_helper = RemapHelper.from_type_information(type_information, 0, 255)
 
-    def read_device_status(self, device: CustomerDevice) -> int | None:
+    def read_device_status(self, device: CustomerDevice) -> Any | None:
         """Return the brightness of this light between 0..255."""
         if (brightness := device.status.get(self.dpcode)) is None:
             return None
@@ -123,7 +123,7 @@ class _BrightnessWrapper(DPCodeIntegerWrapper[int]):
         return round(self._remap_helper.remap_value_from(value))
 
 
-class _ColorTempWrapper(DPCodeIntegerWrapper[int]):
+class _ColorTempWrapper(DPCodeIntegerWrapper):
     """Wrapper for color temperature DP code."""
 
     def __init__(self, dpcode: str, type_information: IntegerTypeInformation) -> None:
@@ -133,7 +133,7 @@ class _ColorTempWrapper(DPCodeIntegerWrapper[int]):
             type_information, MIN_MIREDS, MAX_MIREDS
         )
 
-    def read_device_status(self, device: CustomerDevice) -> int | None:
+    def read_device_status(self, device: CustomerDevice) -> Any | None:
         """Return the color temperature value in Kelvin."""
         if (temperature := device.status.get(self.dpcode)) is None:
             return None
@@ -167,18 +167,18 @@ DEFAULT_V_TYPE_V2 = RemapHelper(
 )
 
 
-class _ColorDataWrapper(DPCodeJsonWrapper[tuple[float, float, float]]):
+class _ColorDataWrapper(DPCodeJsonWrapper):
     """Wrapper for color data DP code."""
 
     h_type = DEFAULT_H_TYPE
     s_type = DEFAULT_S_TYPE
     v_type = DEFAULT_V_TYPE
 
-    def read_device_status(
+    def read_device_status(  # type: ignore[override]
         self, device: CustomerDevice
     ) -> tuple[float, float, float] | None:
         """Return a tuple (H, S, V) from this color data."""
-        if (status := self._read_dpcode_value(device)) is None:
+        if (status := super().read_device_status(device)) is None:
             return None
         return (
             self.h_type.remap_value_to(status["h"]),
@@ -633,17 +633,17 @@ async def async_setup_entry(
                         manager,
                         description,
                         brightness_wrapper=(
-                            brightness_wrapper := _get_brightness_wrapper(  # type: ignore[arg-type]
+                            brightness_wrapper := _get_brightness_wrapper(
                                 device, description
                             )
                         ),
-                        color_data_wrapper=_get_color_data_wrapper(  # type: ignore[arg-type]
+                        color_data_wrapper=_get_color_data_wrapper(
                             device, description, brightness_wrapper
                         ),
                         color_mode_wrapper=DPCodeEnumWrapper.find_dpcode(
                             device, description.color_mode, prefer_function=True
                         ),
-                        color_temp_wrapper=_ColorTempWrapper.find_dpcode(  # type: ignore[arg-type]
+                        color_temp_wrapper=_ColorTempWrapper.find_dpcode(
                             device, description.color_temp, prefer_function=True
                         ),
                         switch_wrapper=switch_wrapper,

homeassistant/components/tuya/manifest.json

@@ -44,7 +44,7 @@
   "iot_class": "cloud_push",
   "loggers": ["tuya_sharing"],
   "requirements": [
-    "tuya-device-handlers==0.0.11",
+    "tuya-device-handlers==0.0.10",
     "tuya-device-sharing-sdk==0.2.8"
   ]
 }

homeassistant/components/tuya/vacuum.py

@@ -25,7 +25,7 @@ from .const import TUYA_DISCOVERY_NEW, DeviceCategory, DPCode
 from .entity import TuyaEntity
 
 
-class _VacuumActivityWrapper(DeviceWrapper[VacuumActivity]):
+class _VacuumActivityWrapper(DeviceWrapper):
     """Wrapper for the state of a device."""
 
     _TUYA_STATUS_TO_HA = {

homeassistant/components/vacuum/__init__.py

@@ -23,6 +23,7 @@ from homeassistant.const import (  # noqa: F401 # STATE_PAUSED/IDLE are API
     STATE_ON,
 )
 from homeassistant.core import HomeAssistant, callback
+from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers import config_validation as cv, issue_registry as ir
 from homeassistant.helpers.entity import Entity, EntityDescription
 from homeassistant.helpers.entity_component import EntityComponent
@@ -63,7 +64,6 @@ SERVICE_STOP = "stop"
 DEFAULT_NAME = "Vacuum cleaner robot"
 
 ISSUE_SEGMENTS_CHANGED = "segments_changed"
-ISSUE_SEGMENTS_MAPPING_NOT_CONFIGURED = "segments_mapping_not_configured"
 
 _BATTERY_DEPRECATION_IGNORED_PLATFORMS = ("template",)
 
@@ -438,7 +438,14 @@ class StateVacuumEntity(
             )
 
         options: Mapping[str, Any] = self.registry_entry.options.get(DOMAIN, {})
-        area_mapping: dict[str, list[str]] = options.get("area_mapping", {})
+        area_mapping: dict[str, list[str]] | None = options.get("area_mapping")
+
+        if area_mapping is None:
+            raise ServiceValidationError(
+                translation_domain=DOMAIN,
+                translation_key="area_mapping_not_configured",
+                translation_placeholders={"entity_id": self.entity_id},
+            )
 
         # We use a dict to preserve the order of segments.
         segment_ids: dict[str, None] = {}

homeassistant/components/vacuum/strings.json

@@ -89,6 +89,11 @@
       }
     }
   },
+  "exceptions": {
+    "area_mapping_not_configured": {
+      "message": "Area mapping is not configured for `{entity_id}`. Configure the segment-to-area mapping before using this action."
+    }
+  },
   "issues": {
     "segments_changed": {
       "description": "",

homeassistant/generated/bluetooth.py

@@ -212,6 +212,11 @@ BLUETOOTH: Final[list[dict[str, bool | str | int | list[int]]]] = [
         "domain": "govee_ble",
         "local_name": "GVH5110*",
     },
+    {
+        "connectable": False,
+        "domain": "govee_ble",
+        "local_name": "GV5140*",
+    },
     {
         "connectable": False,
         "domain": "govee_ble",

homeassistant/helpers/importlib.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import asyncio
-from contextlib import suppress
 import importlib
 import logging
 import sys
@@ -53,11 +52,10 @@ async def async_import_module(hass: HomeAssistant, name: str) -> ModuleType:
         if isinstance(ex, ModuleNotFoundError):
             failure_cache[name] = True
         import_future.set_exception(ex)
-        with suppress(BaseException):
-            # Set the exception retrieved flag on the future since
-            # it will never be retrieved unless there
-            # are concurrent calls
-            import_future.result()
+        # Set the exception retrieved flag on the future since
+        # it will never be retrieved unless there
+        # are concurrent calls
+        import_future.exception()
         raise
     finally:
         del import_futures[name]

homeassistant/package_constraints.txt

@@ -40,7 +40,7 @@ habluetooth==5.8.0
 hass-nabucasa==1.15.0
 hassil==3.5.0
 home-assistant-bluetooth==1.13.1
-home-assistant-frontend==20260226.0
+home-assistant-frontend==20260302.0
 home-assistant-intents==2026.2.13
 httpx==0.28.1
 ifaddr==0.2.0

homeassistant/util/color.py

@@ -283,7 +283,7 @@ def color_xy_brightness_to_RGB(
     Y = brightness
 
     if vY == 0.0:
-        vY += 0.00000000001
+        vY += 1e-11
 
     X = (Y / vY) * vX
     Z = (Y / vY) * (1 - vX - vY)

homeassistant/util/unit_conversion.py

@@ -477,7 +477,7 @@ class MassVolumeConcentrationConverter(BaseUnitConverter):
 
     UNIT_CLASS = "concentration"
     _UNIT_CONVERSION: dict[str | None, float] = {
-        CONCENTRATION_MICROGRAMS_PER_CUBIC_METER: 1000000.0,  # 1000 µg/m³ = 1 mg/m³
+        CONCENTRATION_MICROGRAMS_PER_CUBIC_METER: 1_000_000.0,  # 1000 µg/m³ = 1 mg/m³
         CONCENTRATION_MILLIGRAMS_PER_CUBIC_METER: 1000.0,  # 1000 mg/m³ = 1 g/m³
         CONCENTRATION_GRAMS_PER_CUBIC_METER: 1.0,
     }

requirements_all.txt

@@ -416,7 +416,7 @@ aioswitcher==6.1.0
 aiosyncthing==0.7.1
 
 # homeassistant.components.tankerkoenig
-aiotankerkoenig==0.4.2
+aiotankerkoenig==0.5.1
 
 # homeassistant.components.tedee
 aiotedee==0.2.25
@@ -828,7 +828,7 @@ dremel3dpy==2.1.1
 dropmqttapi==1.0.3
 
 # homeassistant.components.dsmr
-dsmr-parser==1.4.3
+dsmr-parser==1.5.0
 
 # homeassistant.components.dwd_weather_warnings
 dwdwfsapi==1.0.7
@@ -1223,7 +1223,7 @@ hole==0.9.0
 holidays==0.84
 
 # homeassistant.components.frontend
-home-assistant-frontend==20260226.0
+home-assistant-frontend==20260302.0
 
 # homeassistant.components.conversation
 home-assistant-intents==2026.2.13
@@ -1681,6 +1681,9 @@ onedrive-personal-sdk==0.1.4
 # homeassistant.components.onvif
 onvif-zeep-async==4.0.4
 
+# homeassistant.components.onvif
+onvif_parsers==1.2.2
+
 # homeassistant.components.opengarage
 open-garage==0.2.0
 
@@ -3121,7 +3124,7 @@ ttls==1.8.3
 ttn_client==1.2.3
 
 # homeassistant.components.tuya
-tuya-device-handlers==0.0.11
+tuya-device-handlers==0.0.10
 
 # homeassistant.components.tuya
 tuya-device-sharing-sdk==0.2.8

requirements_test_all.txt

@@ -401,7 +401,7 @@ aioswitcher==6.1.0
 aiosyncthing==0.7.1
 
 # homeassistant.components.tankerkoenig
-aiotankerkoenig==0.4.2
+aiotankerkoenig==0.5.1
 
 # homeassistant.components.tedee
 aiotedee==0.2.25
@@ -734,7 +734,7 @@ dremel3dpy==2.1.1
 dropmqttapi==1.0.3
 
 # homeassistant.components.dsmr
-dsmr-parser==1.4.3
+dsmr-parser==1.5.0
 
 # homeassistant.components.dwd_weather_warnings
 dwdwfsapi==1.0.7
@@ -1084,7 +1084,7 @@ hole==0.9.0
 holidays==0.84
 
 # homeassistant.components.frontend
-home-assistant-frontend==20260226.0
+home-assistant-frontend==20260302.0
 
 # homeassistant.components.conversation
 home-assistant-intents==2026.2.13
@@ -1467,6 +1467,9 @@ onedrive-personal-sdk==0.1.4
 # homeassistant.components.onvif
 onvif-zeep-async==4.0.4
 
+# homeassistant.components.onvif
+onvif_parsers==1.2.2
+
 # homeassistant.components.opengarage
 open-garage==0.2.0
 
@@ -2624,7 +2627,7 @@ ttls==1.8.3
 ttn_client==1.2.3
 
 # homeassistant.components.tuya
-tuya-device-handlers==0.0.11
+tuya-device-handlers==0.0.10
 
 # homeassistant.components.tuya
 tuya-device-sharing-sdk==0.2.8

tests/components/conversation/test_http.py

@@ -16,6 +16,7 @@ from homeassistant.components.conversation import (
     async_get_chat_log,
 )
 from homeassistant.components.conversation.const import HOME_ASSISTANT_AGENT
+from homeassistant.components.conversation.models import ConversationResult
 from homeassistant.components.light import DOMAIN as LIGHT_DOMAIN
 from homeassistant.const import ATTR_FRIENDLY_NAME
 from homeassistant.core import HomeAssistant
@@ -173,6 +174,36 @@ async def test_http_api_wrong_data(
     assert resp.status == HTTPStatus.BAD_REQUEST
 
 
+async def test_http_processing_intent_with_device_satellite_ids(
+    hass: HomeAssistant,
+    init_components,
+    hass_client: ClientSessionGenerator,
+) -> None:
+    """Test processing intent via HTTP API with both device_id and satellite_id."""
+    client = await hass_client()
+    mock_result = intent.IntentResponse(language=hass.config.language)
+    mock_result.async_set_speech("test")
+
+    with patch(
+        "homeassistant.components.conversation.http.async_converse",
+        return_value=ConversationResult(response=mock_result),
+    ) as mock_converse:
+        resp = await client.post(
+            "/api/conversation/process",
+            json={
+                "text": "test",
+                "device_id": "test-device-id",
+                "satellite_id": "test-satellite-id",
+            },
+        )
+
+        assert resp.status == HTTPStatus.OK
+        mock_converse.assert_called_once()
+        call_kwargs = mock_converse.call_args[1]
+        assert call_kwargs["device_id"] == "test-device-id"
+        assert call_kwargs["satellite_id"] == "test-satellite-id"
+
+
 @pytest.mark.parametrize(
     "payload",
     [
@@ -221,6 +252,38 @@ async def test_ws_api(
     assert msg["result"]["response"]["data"]["code"] == "no_intent_match"
 
 
+async def test_ws_api_with_device_satellite_ids(
+    hass: HomeAssistant,
+    init_components,
+    hass_ws_client: WebSocketGenerator,
+) -> None:
+    """Test the Websocket conversation API with both device_id and satellite_id."""
+    client = await hass_ws_client(hass)
+    mock_result = intent.IntentResponse(language=hass.config.language)
+    mock_result.async_set_speech("test")
+
+    with patch(
+        "homeassistant.components.conversation.http.async_converse",
+        return_value=ConversationResult(response=mock_result),
+    ) as mock_converse:
+        await client.send_json_auto_id(
+            {
+                "type": "conversation/process",
+                "text": "test",
+                "device_id": "test-device-id",
+                "satellite_id": "test-satellite-id",
+            }
+        )
+
+        msg = await client.receive_json()
+
+        assert msg["success"]
+        mock_converse.assert_called_once()
+        call_kwargs = mock_converse.call_args[1]
+        assert call_kwargs["device_id"] == "test-device-id"
+        assert call_kwargs["satellite_id"] == "test-satellite-id"
+
+
 @pytest.mark.parametrize("agent_id", AGENT_ID_OPTIONS)
 async def test_ws_prepare(
     hass: HomeAssistant, init_components, hass_ws_client: WebSocketGenerator, agent_id

tests/components/esphome/test_infrared.py

@@ -0,0 +1,173 @@
+"""Test ESPHome infrared platform."""
+
+from aioesphomeapi import (
+    APIClient,
+    APIConnectionError,
+    InfraredCapability,
+    InfraredInfo,
+)
+from infrared_protocols import NECCommand
+import pytest
+
+from homeassistant.components import infrared
+from homeassistant.const import STATE_UNAVAILABLE
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+
+from .conftest import MockESPHomeDevice, MockESPHomeDeviceType
+
+ENTITY_ID = "infrared.test_ir"
+
+
+async def _mock_ir_device(
+    mock_esphome_device: MockESPHomeDeviceType,
+    mock_client: APIClient,
+    capabilities: InfraredCapability = InfraredCapability.TRANSMITTER,
+) -> MockESPHomeDevice:
+    entity_info = [
+        InfraredInfo(object_id="ir", key=1, name="IR", capabilities=capabilities)
+    ]
+    return await mock_esphome_device(
+        mock_client=mock_client, entity_info=entity_info, states=[]
+    )
+
+
+@pytest.mark.parametrize(
+    ("capabilities", "entity_created"),
+    [
+        (InfraredCapability.TRANSMITTER, True),
+        (InfraredCapability.RECEIVER, False),
+        (InfraredCapability.TRANSMITTER | InfraredCapability.RECEIVER, True),
+        (InfraredCapability(0), False),
+    ],
+)
+async def test_infrared_entity_transmitter(
+    hass: HomeAssistant,
+    mock_client: APIClient,
+    mock_esphome_device: MockESPHomeDeviceType,
+    capabilities: InfraredCapability,
+    entity_created: bool,
+) -> None:
+    """Test infrared entity with transmitter capability is created."""
+    await _mock_ir_device(mock_esphome_device, mock_client, capabilities)
+
+    state = hass.states.get(ENTITY_ID)
+    assert (state is not None) == entity_created
+
+    emitters = infrared.async_get_emitters(hass)
+    assert (len(emitters) == 1) == entity_created
+
+
+async def test_infrared_multiple_entities_mixed_capabilities(
+    hass: HomeAssistant,
+    mock_client: APIClient,
+    mock_esphome_device: MockESPHomeDeviceType,
+) -> None:
+    """Test multiple infrared entities with mixed capabilities."""
+    entity_info = [
+        InfraredInfo(
+            object_id="ir_transmitter",
+            key=1,
+            name="IR Transmitter",
+            capabilities=InfraredCapability.TRANSMITTER,
+        ),
+        InfraredInfo(
+            object_id="ir_receiver",
+            key=2,
+            name="IR Receiver",
+            capabilities=InfraredCapability.RECEIVER,
+        ),
+        InfraredInfo(
+            object_id="ir_transceiver",
+            key=3,
+            name="IR Transceiver",
+            capabilities=InfraredCapability.TRANSMITTER | InfraredCapability.RECEIVER,
+        ),
+    ]
+    await mock_esphome_device(
+        mock_client=mock_client,
+        entity_info=entity_info,
+        states=[],
+    )
+
+    # Only transmitter and transceiver should be created
+    assert hass.states.get("infrared.test_ir_transmitter") is not None
+    assert hass.states.get("infrared.test_ir_receiver") is None
+    assert hass.states.get("infrared.test_ir_transceiver") is not None
+
+    emitters = infrared.async_get_emitters(hass)
+    assert len(emitters) == 2
+
+
+async def test_infrared_send_command_success(
+    hass: HomeAssistant,
+    mock_client: APIClient,
+    mock_esphome_device: MockESPHomeDeviceType,
+) -> None:
+    """Test sending IR command successfully."""
+    await _mock_ir_device(mock_esphome_device, mock_client)
+
+    command = NECCommand(address=0x04, command=0x08, modulation=38000)
+    await infrared.async_send_command(hass, ENTITY_ID, command)
+
+    # Verify the command was sent to the ESPHome client
+    mock_client.infrared_rf_transmit_raw_timings.assert_called_once()
+    call_args = mock_client.infrared_rf_transmit_raw_timings.call_args
+    assert call_args[0][0] == 1  # key
+    assert call_args[1]["carrier_frequency"] == 38000
+    assert call_args[1]["device_id"] == 0
+
+    # Verify timings (alternating positive/negative values)
+    timings = call_args[1]["timings"]
+    assert len(timings) > 0
+    for i in range(0, len(timings), 2):
+        assert timings[i] >= 0
+    for i in range(1, len(timings), 2):
+        assert timings[i] <= 0
+
+
+async def test_infrared_send_command_failure(
+    hass: HomeAssistant,
+    mock_client: APIClient,
+    mock_esphome_device: MockESPHomeDeviceType,
+) -> None:
+    """Test sending IR command with APIConnectionError raises HomeAssistantError."""
+    await _mock_ir_device(mock_esphome_device, mock_client)
+
+    mock_client.infrared_rf_transmit_raw_timings.side_effect = APIConnectionError(
+        "Connection lost"
+    )
+
+    command = NECCommand(address=0x04, command=0x08, modulation=38000)
+
+    with pytest.raises(HomeAssistantError) as exc_info:
+        await infrared.async_send_command(hass, ENTITY_ID, command)
+    assert exc_info.value.translation_domain == "esphome"
+    assert exc_info.value.translation_key == "error_communicating_with_device"
+
+
+async def test_infrared_entity_availability(
+    hass: HomeAssistant,
+    mock_client: APIClient,
+    mock_esphome_device: MockESPHomeDeviceType,
+) -> None:
+    """Test infrared entity becomes available after device reconnects."""
+    mock_device = await _mock_ir_device(mock_esphome_device, mock_client)
+
+    state = hass.states.get(ENTITY_ID)
+    assert state is not None
+    assert state.state != STATE_UNAVAILABLE
+
+    await mock_device.mock_disconnect(False)
+    await hass.async_block_till_done()
+
+    state = hass.states.get(ENTITY_ID)
+    assert state is not None
+    assert state.state == STATE_UNAVAILABLE
+
+    await mock_device.mock_connect()
+    await hass.async_block_till_done()
+
+    state = hass.states.get(ENTITY_ID)
+    assert state is not None
+    assert state.state != STATE_UNAVAILABLE

tests/components/govee_ble/__init__.py

@@ -84,7 +84,6 @@ GVH5106_SERVICE_INFO = BluetoothServiceInfo(
     source="local",
 )
 
-
 GV5125_BUTTON_0_SERVICE_INFO = BluetoothServiceInfo(
     name="GV51255367",
     address="C1:37:37:32:0F:45",
@@ -163,6 +162,16 @@ GV5123_CLOSED_SERVICE_INFO = BluetoothServiceInfo(
     source="24:4C:AB:03:E6:B8",
 )
 
+# Encodes: temperature=21.6°C, humidity=67.8%, CO2=531 ppm, no error
+GV5140_SERVICE_INFO = BluetoothServiceInfo(
+    name="GV5140EEFF",
+    address="AA:BB:CC:DD:EE:FF",
+    rssi=-63,
+    manufacturer_data={1: b"\x01\x01\x03\x4e\x66\x02\x13\x00"},
+    service_uuids=["0000ec88-0000-1000-8000-00805f9b34fb"],
+    service_data={},
+    source="local",
+)
 
 GVH5124_SERVICE_INFO = BluetoothServiceInfo(
     name="GV51242F68",

tests/components/govee_ble/test_sensor.py

@@ -17,6 +17,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.util import dt as dt_util
 
 from . import (
+    GV5140_SERVICE_INFO,
     GVH5075_SERVICE_INFO,
     GVH5106_SERVICE_INFO,
     GVH5178_PRIMARY_SERVICE_INFO,
@@ -163,6 +164,33 @@ async def test_gvh5178_multi_sensor(hass: HomeAssistant) -> None:
     assert primary_temp_sensor.state == STATE_UNAVAILABLE
 
 
+async def test_gv5140(hass: HomeAssistant) -> None:
+    """Test setting up creates the sensors for a device with CO2."""
+    entry = MockConfigEntry(
+        domain=DOMAIN,
+        unique_id="AA:BB:CC:DD:EE:FF",
+    )
+    entry.add_to_hass(hass)
+
+    assert await hass.config_entries.async_setup(entry.entry_id)
+    await hass.async_block_till_done()
+
+    assert len(hass.states.async_all()) == 0
+    inject_bluetooth_service_info(hass, GV5140_SERVICE_INFO)
+    await hass.async_block_till_done()
+    assert len(hass.states.async_all()) == 3
+
+    co2_sensor = hass.states.get("sensor.5140eeff_carbon_dioxide")
+    co2_sensor_attributes = co2_sensor.attributes
+    assert co2_sensor.state == "531"
+    assert co2_sensor_attributes[ATTR_FRIENDLY_NAME] == "5140EEFF Carbon Dioxide"
+    assert co2_sensor_attributes[ATTR_UNIT_OF_MEASUREMENT] == "ppm"
+    assert co2_sensor_attributes[ATTR_STATE_CLASS] == "measurement"
+
+    assert await hass.config_entries.async_unload(entry.entry_id)
+    await hass.async_block_till_done()
+
+
 async def test_gvh5106(hass: HomeAssistant) -> None:
     """Test setting up creates the sensors for a device with PM25."""
     entry = MockConfigEntry(

tests/components/matter/test_lock.py

@@ -485,13 +485,7 @@ async def test_clear_lock_user_service(
     matter_node: MatterNode,
 ) -> None:
     """Test clear_lock_user entity service."""
-    matter_client.send_device_command = AsyncMock(
-        side_effect=[
-            # clear_user_credentials: GetUser returns user with no creds
-            {"userStatus": 1, "credentials": None},
-            None,  # ClearUser
-        ]
-    )
+    matter_client.send_device_command = AsyncMock(return_value=None)
 
     await hass.services.async_call(
         DOMAIN,
@@ -503,127 +497,9 @@ async def test_clear_lock_user_service(
         blocking=True,
     )
 
-    assert matter_client.send_device_command.call_count == 2
-    # Verify GetUser was called to check credentials
-    assert matter_client.send_device_command.call_args_list[0] == call(
-        node_id=matter_node.node_id,
-        endpoint_id=1,
-        command=clusters.DoorLock.Commands.GetUser(userIndex=1),
-    )
-    # Verify ClearUser was called
-    assert matter_client.send_device_command.call_args_list[1] == call(
-        node_id=matter_node.node_id,
-        endpoint_id=1,
-        command=clusters.DoorLock.Commands.ClearUser(userIndex=1),
-        timed_request_timeout_ms=10000,
-    )
-
-
-@pytest.mark.parametrize("node_fixture", ["mock_door_lock"])
-@pytest.mark.parametrize("attributes", [{"1/257/65532": _FEATURE_USR_PIN}])
-async def test_clear_lock_user_credentials_nullvalue(
-    hass: HomeAssistant,
-    matter_client: MagicMock,
-    matter_node: MatterNode,
-) -> None:
-    """Test clear_lock_user handles NullValue credentials from Matter SDK."""
-    matter_client.send_device_command = AsyncMock(
-        side_effect=[
-            # GetUser returns NullValue for credentials (truthy but not iterable)
-            {"userStatus": 1, "credentials": NullValue},
-            None,  # ClearUser
-        ]
-    )
-
-    await hass.services.async_call(
-        DOMAIN,
-        "clear_lock_user",
-        {
-            ATTR_ENTITY_ID: "lock.mock_door_lock",
-            ATTR_USER_INDEX: 1,
-        },
-        blocking=True,
-    )
-
-    # GetUser + ClearUser (no ClearCredential since NullValue means no credentials)
-    assert matter_client.send_device_command.call_count == 2
-    assert matter_client.send_device_command.call_args_list[0] == call(
-        node_id=matter_node.node_id,
-        endpoint_id=1,
-        command=clusters.DoorLock.Commands.GetUser(userIndex=1),
-    )
-    assert matter_client.send_device_command.call_args_list[1] == call(
-        node_id=matter_node.node_id,
-        endpoint_id=1,
-        command=clusters.DoorLock.Commands.ClearUser(userIndex=1),
-        timed_request_timeout_ms=10000,
-    )
-
-
-@pytest.mark.parametrize("node_fixture", ["mock_door_lock"])
-@pytest.mark.parametrize("attributes", [{"1/257/65532": _FEATURE_USR_PIN}])
-async def test_clear_lock_user_clears_credentials_first(
-    hass: HomeAssistant,
-    matter_client: MagicMock,
-    matter_node: MatterNode,
-) -> None:
-    """Test clear_lock_user clears credentials before clearing user."""
-    matter_client.send_device_command = AsyncMock(
-        side_effect=[
-            # clear_user_credentials: GetUser returns user with credentials
-            {
-                "userStatus": 1,
-                "credentials": [
-                    {"credentialType": 1, "credentialIndex": 1},
-                    {"credentialType": 1, "credentialIndex": 2},
-                ],
-            },
-            None,  # ClearCredential for first
-            None,  # ClearCredential for second
-            None,  # ClearUser
-        ]
-    )
-
-    await hass.services.async_call(
-        DOMAIN,
-        "clear_lock_user",
-        {
-            ATTR_ENTITY_ID: "lock.mock_door_lock",
-            ATTR_USER_INDEX: 1,
-        },
-        blocking=True,
-    )
-
-    # GetUser + 2 ClearCredential + ClearUser
-    assert matter_client.send_device_command.call_count == 4
-    assert matter_client.send_device_command.call_args_list[0] == call(
-        node_id=matter_node.node_id,
-        endpoint_id=1,
-        command=clusters.DoorLock.Commands.GetUser(userIndex=1),
-    )
-    assert matter_client.send_device_command.call_args_list[1] == call(
-        node_id=matter_node.node_id,
-        endpoint_id=1,
-        command=clusters.DoorLock.Commands.ClearCredential(
-            credential=clusters.DoorLock.Structs.CredentialStruct(
-                credentialType=1,
-                credentialIndex=1,
-            ),
-        ),
-        timed_request_timeout_ms=10000,
-    )
-    assert matter_client.send_device_command.call_args_list[2] == call(
-        node_id=matter_node.node_id,
-        endpoint_id=1,
-        command=clusters.DoorLock.Commands.ClearCredential(
-            credential=clusters.DoorLock.Structs.CredentialStruct(
-                credentialType=1,
-                credentialIndex=2,
-            ),
-        ),
-        timed_request_timeout_ms=10000,
-    )
-    assert matter_client.send_device_command.call_args_list[3] == call(
+    # ClearUser handles credential cleanup per the Matter spec
+    assert matter_client.send_device_command.call_count == 1
+    assert matter_client.send_device_command.call_args == call(
         node_id=matter_node.node_id,
         endpoint_id=1,
         command=clusters.DoorLock.Commands.ClearUser(userIndex=1),
@@ -2169,13 +2045,8 @@ async def test_clear_lock_user_clear_all(
     matter_client: MagicMock,
     matter_node: MatterNode,
 ) -> None:
-    """Test clear_lock_user with CLEAR_ALL_INDEX clears all credentials then users."""
-    matter_client.send_device_command = AsyncMock(
-        side_effect=[
-            None,  # ClearCredential(None) - clear all credentials
-            None,  # ClearUser(0xFFFE) - clear all users
-        ]
-    )
+    """Test clear_lock_user with CLEAR_ALL_INDEX clears all users."""
+    matter_client.send_device_command = AsyncMock(return_value=None)
 
     await hass.services.async_call(
         DOMAIN,
@@ -2187,16 +2058,9 @@ async def test_clear_lock_user_clear_all(
         blocking=True,
     )
 
-    assert matter_client.send_device_command.call_count == 2
-    # First: ClearCredential with None (clear all)
-    assert matter_client.send_device_command.call_args_list[0] == call(
-        node_id=matter_node.node_id,
-        endpoint_id=1,
-        command=clusters.DoorLock.Commands.ClearCredential(credential=None),
-        timed_request_timeout_ms=10000,
-    )
-    # Second: ClearUser with CLEAR_ALL_INDEX
-    assert matter_client.send_device_command.call_args_list[1] == call(
+    # ClearUser handles credential cleanup per the Matter spec
+    assert matter_client.send_device_command.call_count == 1
+    assert matter_client.send_device_command.call_args == call(
         node_id=matter_node.node_id,
         endpoint_id=1,
         command=clusters.DoorLock.Commands.ClearUser(userIndex=CLEAR_ALL_INDEX),
@@ -2702,69 +2566,3 @@ async def test_set_lock_user_update_with_explicit_type_and_rule(
         ),
         timed_request_timeout_ms=10000,
     )
-
-
-# --- clear_lock_user with mixed credential types ---
-
-
-@pytest.mark.parametrize("node_fixture", ["mock_door_lock"])
-@pytest.mark.parametrize("attributes", [{"1/257/65532": _FEATURE_USR_PIN_RFID}])
-async def test_clear_lock_user_mixed_credential_types(
-    hass: HomeAssistant,
-    matter_client: MagicMock,
-    matter_node: MatterNode,
-) -> None:
-    """Test clear_lock_user clears mixed PIN and RFID credentials."""
-    pin_type = clusters.DoorLock.Enums.CredentialTypeEnum.kPin
-    rfid_type = clusters.DoorLock.Enums.CredentialTypeEnum.kRfid
-    matter_client.send_device_command = AsyncMock(
-        side_effect=[
-            # GetUser returns user with PIN and RFID credentials
-            {
-                "userStatus": 1,
-                "credentials": [
-                    {"credentialType": pin_type, "credentialIndex": 1},
-                    {"credentialType": rfid_type, "credentialIndex": 2},
-                ],
-            },
-            None,  # ClearCredential for PIN
-            None,  # ClearCredential for RFID
-            None,  # ClearUser
-        ]
-    )
-
-    await hass.services.async_call(
-        DOMAIN,
-        "clear_lock_user",
-        {
-            ATTR_ENTITY_ID: "lock.mock_door_lock",
-            ATTR_USER_INDEX: 1,
-        },
-        blocking=True,
-    )
-
-    assert matter_client.send_device_command.call_count == 4
-    # Verify PIN credential was cleared
-    assert matter_client.send_device_command.call_args_list[1] == call(
-        node_id=matter_node.node_id,
-        endpoint_id=1,
-        command=clusters.DoorLock.Commands.ClearCredential(
-            credential=clusters.DoorLock.Structs.CredentialStruct(
-                credentialType=pin_type,
-                credentialIndex=1,
-            ),
-        ),
-        timed_request_timeout_ms=10000,
-    )
-    # Verify RFID credential was cleared
-    assert matter_client.send_device_command.call_args_list[2] == call(
-        node_id=matter_node.node_id,
-        endpoint_id=1,
-        command=clusters.DoorLock.Commands.ClearCredential(
-            credential=clusters.DoorLock.Structs.CredentialStruct(
-                credentialType=rfid_type,
-                credentialIndex=2,
-            ),
-        ),
-        timed_request_timeout_ms=10000,
-    )

tests/components/onvif/__init__.py

@@ -1,16 +1,22 @@
 """Tests for the ONVIF integration."""
 
+from __future__ import annotations
+
+from collections import defaultdict
 from unittest.mock import AsyncMock, MagicMock, patch
 
 from onvif.exceptions import ONVIFError
+from onvif_parsers.model import EventEntity
 from zeep.exceptions import Fault
 
 from homeassistant import config_entries
 from homeassistant.components.onvif import config_flow
 from homeassistant.components.onvif.const import CONF_SNAPSHOT_AUTH
+from homeassistant.components.onvif.event import EventManager
 from homeassistant.components.onvif.models import (
     Capabilities,
     DeviceInfo,
+    Event,
     Profile,
     PullPointManagerState,
     Resolution,
@@ -123,7 +129,7 @@ def setup_mock_onvif_camera(
     mock_onvif_camera.side_effect = mock_constructor
 
 
-def setup_mock_device(mock_device, capabilities=None, profiles=None):
+def setup_mock_device(mock_device, capabilities=None, profiles=None, events=None):
     """Prepare mock ONVIFDevice."""
     mock_device.async_setup = AsyncMock(return_value=True)
     mock_device.port = 80
@@ -149,7 +155,11 @@ def setup_mock_device(mock_device, capabilities=None, profiles=None):
     mock_device.events = MagicMock(
         webhook_manager=MagicMock(state=WebHookManagerState.STARTED),
         pullpoint_manager=MagicMock(state=PullPointManagerState.PAUSED),
+        async_stop=AsyncMock(),
     )
+    mock_device.device.close = AsyncMock()
+    if events:
+        _setup_mock_events(mock_device.events, events)
 
     def mock_constructor(
         hass: HomeAssistant, config: config_entries.ConfigEntry
@@ -160,6 +170,23 @@ def setup_mock_device(mock_device, capabilities=None, profiles=None):
     mock_device.side_effect = mock_constructor
 
 
+def _setup_mock_events(mock_events: MagicMock, events: list[Event]) -> None:
+    """Configure mock events to return proper Event objects."""
+    events_by_platform: dict[str, list[Event]] = defaultdict(list)
+    events_by_uid: dict[str, Event] = {}
+    uids_by_platform: dict[str, set[str]] = defaultdict(set)
+    for event in events:
+        events_by_platform[event.platform].append(event)
+        events_by_uid[event.uid] = event
+        uids_by_platform[event.platform].add(event.uid)
+
+    mock_events.get_platform.side_effect = lambda p: list(events_by_platform.get(p, []))
+    mock_events.get_uid.side_effect = events_by_uid.get
+    mock_events.get_uids_by_platform.side_effect = lambda p: set(
+        uids_by_platform.get(p, set())
+    )
+
+
 async def setup_onvif_integration(
     hass: HomeAssistant,
     config=None,
@@ -168,6 +195,8 @@ async def setup_onvif_integration(
     entry_id="1",
     source=config_entries.SOURCE_USER,
     capabilities=None,
+    events=None,
+    raw_events: list[tuple[str, EventEntity]] | None = None,
 ) -> tuple[MockConfigEntry, MagicMock, MagicMock]:
     """Create an ONVIF config entry."""
     if not config:
@@ -202,8 +231,35 @@ async def setup_onvif_integration(
         setup_mock_onvif_camera(mock_onvif_camera, two_profiles=True)
         # no discovery
         mock_discovery.return_value = []
-        setup_mock_device(mock_device, capabilities=capabilities)
+        setup_mock_device(mock_device, capabilities=capabilities, events=events)
         mock_device.device = mock_onvif_camera
+
+        if raw_events:
+            # Process raw library events through a real EventManager
+            # to test the full parsing pipeline including conversions
+            event_manager = EventManager(hass, mock_onvif_camera, config_entry, NAME)
+            mock_messages = []
+            event_by_topic: dict[str, EventEntity] = {}
+            for topic, raw_event in raw_events:
+                mock_msg = MagicMock()
+                mock_msg.Topic._value_1 = topic
+                mock_messages.append(mock_msg)
+                event_by_topic[topic] = raw_event
+
+            async def mock_parse(topic, unique_id, msg):
+                return event_by_topic.get(topic)
+
+            with patch(
+                "homeassistant.components.onvif.event.onvif_parsers"
+            ) as mock_parsers:
+                mock_parsers.parse = mock_parse
+                mock_parsers.errors.UnknownTopicError = type(
+                    "UnknownTopicError", (Exception,), {}
+                )
+                await event_manager.async_parse_messages(mock_messages)
+
+            mock_device.events = event_manager
+
         await hass.config_entries.async_setup(config_entry.entry_id)
         await hass.async_block_till_done()
     return config_entry, mock_onvif_camera, mock_device

tests/components/onvif/test_event.py

@@ -0,0 +1,137 @@
+"""Test ONVIF event handling end-to-end."""
+
+from onvif_parsers.model import EventEntity
+
+from homeassistant.components.onvif.models import Capabilities, Event
+from homeassistant.const import ATTR_DEVICE_CLASS, STATE_OFF, STATE_ON, EntityCategory
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import entity_registry as er
+
+from . import MAC, setup_onvif_integration
+
+MOTION_ALARM_UID = f"{MAC}_tns1:VideoSource/MotionAlarm_VideoSourceToken"
+IMAGE_TOO_BLURRY_UID = (
+    f"{MAC}_tns1:VideoSource/ImageTooBlurry/AnalyticsService_VideoSourceToken"
+)
+LAST_RESET_UID = f"{MAC}_tns1:Monitoring/LastReset_0"
+
+
+async def test_motion_alarm_event(hass: HomeAssistant) -> None:
+    """Test that a motion alarm event creates a binary sensor."""
+    await setup_onvif_integration(
+        hass,
+        capabilities=Capabilities(events=True, imaging=True, ptz=True),
+        events=[
+            Event(
+                uid=MOTION_ALARM_UID,
+                name="Motion Alarm",
+                platform="binary_sensor",
+                device_class="motion",
+                value=True,
+            ),
+        ],
+    )
+
+    state = hass.states.get("binary_sensor.testcamera_motion_alarm")
+    assert state is not None
+    assert state.state == STATE_ON
+    assert state.attributes[ATTR_DEVICE_CLASS] == "motion"
+
+
+async def test_motion_alarm_event_off(hass: HomeAssistant) -> None:
+    """Test that a motion alarm event with false value is off."""
+    await setup_onvif_integration(
+        hass,
+        capabilities=Capabilities(events=True, imaging=True, ptz=True),
+        events=[
+            Event(
+                uid=MOTION_ALARM_UID,
+                name="Motion Alarm",
+                platform="binary_sensor",
+                device_class="motion",
+                value=False,
+            ),
+        ],
+    )
+
+    state = hass.states.get("binary_sensor.testcamera_motion_alarm")
+    assert state is not None
+    assert state.state == STATE_OFF
+
+
+async def test_diagnostic_event_entity_category(
+    hass: HomeAssistant, entity_registry: er.EntityRegistry
+) -> None:
+    """Test that a diagnostic event gets the correct entity category."""
+    await setup_onvif_integration(
+        hass,
+        capabilities=Capabilities(events=True, imaging=True, ptz=True),
+        events=[
+            Event(
+                uid=IMAGE_TOO_BLURRY_UID,
+                name="Image Too Blurry",
+                platform="binary_sensor",
+                device_class="problem",
+                value=True,
+                entity_category=EntityCategory.DIAGNOSTIC,
+            ),
+        ],
+    )
+
+    state = hass.states.get("binary_sensor.testcamera_image_too_blurry")
+    assert state is not None
+    assert state.state == STATE_ON
+
+    entry = entity_registry.async_get("binary_sensor.testcamera_image_too_blurry")
+    assert entry is not None
+    assert entry.entity_category is EntityCategory.DIAGNOSTIC
+
+
+async def test_timestamp_event_conversion(hass: HomeAssistant) -> None:
+    """Test that timestamp sensor events get string values converted to datetime."""
+    await setup_onvif_integration(
+        hass,
+        capabilities=Capabilities(events=True, imaging=True, ptz=True),
+        raw_events=[
+            (
+                "tns1:Monitoring/LastReset",
+                EventEntity(
+                    uid=LAST_RESET_UID,
+                    name="Last Reset",
+                    platform="sensor",
+                    device_class="timestamp",
+                    value="2023-10-01T12:00:00Z",
+                ),
+            ),
+        ],
+    )
+
+    state = hass.states.get("sensor.testcamera_last_reset")
+    assert state is not None
+    # Verify the string was converted to a datetime (raw string would end
+    # with "Z", converted datetime rendered by SensorEntity has "+00:00")
+    assert state.state == "2023-10-01T12:00:00+00:00"
+
+
+async def test_timestamp_event_invalid_value(hass: HomeAssistant) -> None:
+    """Test that invalid timestamp values result in unknown state."""
+    await setup_onvif_integration(
+        hass,
+        capabilities=Capabilities(events=True, imaging=True, ptz=True),
+        raw_events=[
+            (
+                "tns1:Monitoring/LastReset",
+                EventEntity(
+                    uid=LAST_RESET_UID,
+                    name="Last Reset",
+                    platform="sensor",
+                    device_class="timestamp",
+                    value="0000-00-00T00:00:00Z",
+                ),
+            ),
+        ],
+    )
+
+    state = hass.states.get("sensor.testcamera_last_reset")
+    assert state is not None
+    assert state.state == "unknown"

tests/components/onvif/test_parsers.py

@@ -1,881 +0,0 @@
-"""Test ONVIF parsers."""
-
-import datetime
-import os
-
-import onvif
-import onvif.settings
-import pytest
-from zeep import Client
-from zeep.transports import Transport
-
-from homeassistant.components.onvif import models, parsers
-from homeassistant.core import HomeAssistant
-
-TEST_UID = "test-unique-id"
-
-
-async def get_event(notification_data: dict) -> models.Event:
-    """Take in a zeep dict, run it through the parser, and return an Event.
-
-    When the parser encounters an unknown topic that it doesn't know how to parse,
-    it outputs a message 'No registered handler for event from ...' along with a
-    print out of the serialized xml message from zeep. If it tries to parse and
-    can't, it prints out 'Unable to parse event from ...' along with the same
-    serialized message. This method can take the output directly from these log
-    messages and run them through the parser, which makes it easy to add new unit
-    tests that verify the message can now be parsed.
-    """
-    zeep_client = Client(
-        f"{os.path.dirname(onvif.__file__)}/wsdl/events.wsdl",
-        wsse=None,
-        transport=Transport(),
-    )
-
-    notif_msg_type = zeep_client.get_type("ns5:NotificationMessageHolderType")
-    assert notif_msg_type is not None
-    notif_msg = notif_msg_type(**notification_data)
-    assert notif_msg is not None
-
-    # The xsd:any type embedded inside the message doesn't parse, so parse it manually.
-    msg_elem = zeep_client.get_element("ns8:Message")
-    assert msg_elem is not None
-    msg_data = msg_elem(**notification_data["Message"]["_value_1"])
-    assert msg_data is not None
-    notif_msg.Message._value_1 = msg_data
-
-    parser = parsers.PARSERS.get(notif_msg.Topic._value_1)
-    assert parser is not None
-
-    return await parser(TEST_UID, notif_msg)
-
-
-async def test_line_detector_crossed(hass: HomeAssistant) -> None:
-    """Tests tns1:RuleEngine/LineDetector/Crossed."""
-    event = await get_event(
-        {
-            "SubscriptionReference": {
-                "Address": {"_value_1": None, "_attr_1": None},
-                "ReferenceParameters": None,
-                "Metadata": None,
-                "_value_1": None,
-                "_attr_1": None,
-            },
-            "Topic": {
-                "_value_1": "tns1:RuleEngine/LineDetector/Crossed",
-                "Dialect": "http://www.onvif.org/ver10/tev/topicExpression/ConcreteSet",
-                "_attr_1": {},
-            },
-            "ProducerReference": {
-                "Address": {
-                    "_value_1": "xx.xx.xx.xx/onvif/event/alarm",
-                    "_attr_1": None,
-                },
-                "ReferenceParameters": None,
-                "Metadata": None,
-                "_value_1": None,
-                "_attr_1": None,
-            },
-            "Message": {
-                "_value_1": {
-                    "Source": {
-                        "SimpleItem": [
-                            {
-                                "Name": "VideoSourceConfigurationToken",
-                                "Value": "video_source_config1",
-                            },
-                            {
-                                "Name": "VideoAnalyticsConfigurationToken",
-                                "Value": "analytics_video_source",
-                            },
-                            {"Name": "Rule", "Value": "MyLineDetectorRule"},
-                        ],
-                        "ElementItem": [],
-                        "Extension": None,
-                        "_attr_1": None,
-                    },
-                    "Key": None,
-                    "Data": {
-                        "SimpleItem": [{"Name": "ObjectId", "Value": "0"}],
-                        "ElementItem": [],
-                        "Extension": None,
-                        "_attr_1": None,
-                    },
-                    "Extension": None,
-                    "UtcTime": datetime.datetime(2020, 5, 24, 7, 24, 47),
-                    "PropertyOperation": "Initialized",
-                    "_attr_1": {},
-                }
-            },
-        }
-    )
-
-    assert event is not None
-    assert event.name == "Line Detector Crossed"
-    assert event.platform == "sensor"
-    assert event.value == "0"
-    assert event.uid == (
-        f"{TEST_UID}_tns1:RuleEngine/LineDetector/"
-        "Crossed_video_source_config1_analytics_video_source_MyLineDetectorRule"
-    )
-
-
-async def test_tapo_line_crossed(hass: HomeAssistant) -> None:
-    """Tests tns1:RuleEngine/CellMotionDetector/LineCross."""
-    event = await get_event(
-        {
-            "SubscriptionReference": {
-                "Address": {
-                    "_value_1": "http://CAMERA_LOCAL_IP:2020/event-0_2020",
-                    "_attr_1": None,
-                },
-                "ReferenceParameters": None,
-                "Metadata": None,
-                "_value_1": None,
-                "_attr_1": None,
-            },
-            "Topic": {
-                "_value_1": "tns1:RuleEngine/CellMotionDetector/LineCross",
-                "Dialect": "http://www.onvif.org/ver10/tev/topicExpression/ConcreteSet",
-                "_attr_1": {},
-            },
-            "ProducerReference": {
-                "Address": {
-                    "_value_1": "http://CAMERA_LOCAL_IP:5656/event",
-                    "_attr_1": None,
-                },
-                "ReferenceParameters": None,
-                "Metadata": None,
-                "_value_1": None,
-                "_attr_1": None,
-            },
-            "Message": {
-                "_value_1": {
-                    "Source": {
-                        "SimpleItem": [
-                            {
-                                "Name": "VideoSourceConfigurationToken",
-                                "Value": "vsconf",
-                            },
-                            {
-                                "Name": "VideoAnalyticsConfigurationToken",
-                                "Value": "VideoAnalyticsToken",
-                            },
-                            {"Name": "Rule", "Value": "MyLineCrossDetectorRule"},
-                        ],
-                        "ElementItem": [],
-                        "Extension": None,
-                        "_attr_1": None,
-                    },
-                    "Key": None,
-                    "Data": {
-                        "SimpleItem": [{"Name": "IsLineCross", "Value": "true"}],
-                        "ElementItem": [],
-                        "Extension": None,
-                        "_attr_1": None,
-                    },
-                    "Extension": None,
-                    "UtcTime": datetime.datetime(
-                        2025, 1, 3, 21, 5, 14, tzinfo=datetime.UTC
-                    ),
-                    "PropertyOperation": "Changed",
-                    "_attr_1": {},
-                }
-            },
-        }
-    )
-
-    assert event is not None
-    assert event.name == "Line Detector Crossed"
-    assert event.platform == "binary_sensor"
-    assert event.device_class == "motion"
-    assert event.value
-    assert event.uid == (
-        f"{TEST_UID}_tns1:RuleEngine/CellMotionDetector/"
-        "LineCross_VideoSourceToken_VideoAnalyticsToken_MyLineCrossDetectorRule"
-    )
-
-
-async def test_tapo_tpsmartevent_vehicle(hass: HomeAssistant) -> None:
-    """Tests tns1:RuleEngine/TPSmartEventDetector/TPSmartEvent - vehicle."""
-    event = await get_event(
-        {
-            "Message": {
-                "_value_1": {
-                    "Data": {
-                        "ElementItem": [],
-                        "Extension": None,
-                        "SimpleItem": [{"Name": "IsVehicle", "Value": "true"}],
-                        "_attr_1": None,
-                    },
-                    "Extension": None,
-                    "Key": None,
-                    "PropertyOperation": "Changed",
-                    "Source": {
-                        "ElementItem": [],
-                        "Extension": None,
-                        "SimpleItem": [
-                            {
-                                "Name": "VideoSourceConfigurationToken",
-                                "Value": "vsconf",
-                            },
-                            {
-                                "Name": "VideoAnalyticsConfigurationToken",
-                                "Value": "VideoAnalyticsToken",
-                            },
-                            {
-                                "Name": "Rule",
-                                "Value": "MyTPSmartEventDetectorRule",
-                            },
-                        ],
-                        "_attr_1": None,
-                    },
-                    "UtcTime": datetime.datetime(
-                        2024, 11, 2, 0, 33, 11, tzinfo=datetime.UTC
-                    ),
-                    "_attr_1": {},
-                }
-            },
-            "ProducerReference": {
-                "Address": {
-                    "_attr_1": None,
-                    "_value_1": "http://192.168.56.127:5656/event",
-                },
-                "Metadata": None,
-                "ReferenceParameters": None,
-                "_attr_1": None,
-                "_value_1": None,
-            },
-            "SubscriptionReference": {
-                "Address": {
-                    "_attr_1": None,
-                    "_value_1": "http://192.168.56.127:2020/event-0_2020",
-                },
-                "Metadata": None,
-                "ReferenceParameters": None,
-                "_attr_1": None,
-                "_value_1": None,
-            },
-            "Topic": {
-                "Dialect": "http://www.onvif.org/ver10/tev/topicExpression/ConcreteSet",
-                "_attr_1": {},
-                "_value_1": "tns1:RuleEngine/TPSmartEventDetector/TPSmartEvent",
-            },
-        }
-    )
-
-    assert event is not None
-    assert event.name == "Vehicle Detection"
-    assert event.platform == "binary_sensor"
-    assert event.device_class == "motion"
-    assert event.value
-    assert event.uid == (
-        f"{TEST_UID}_tns1:RuleEngine/TPSmartEventDetector/"
-        "TPSmartEvent_VideoSourceToken_VideoAnalyticsToken_MyTPSmartEventDetectorRule"
-    )
-
-
-async def test_tapo_cellmotiondetector_vehicle(hass: HomeAssistant) -> None:
-    """Tests tns1:RuleEngine/CellMotionDetector/TpSmartEvent - vehicle."""
-    event = await get_event(
-        {
-            "SubscriptionReference": {
-                "Address": {
-                    "_value_1": "http://CAMERA_LOCAL_IP:2020/event-0_2020",
-                    "_attr_1": None,
-                },
-                "ReferenceParameters": None,
-                "Metadata": None,
-                "_value_1": None,
-                "_attr_1": None,
-            },
-            "Topic": {
-                "_value_1": "tns1:RuleEngine/CellMotionDetector/TpSmartEvent",
-                "Dialect": "http://www.onvif.org/ver10/tev/topicExpression/ConcreteSet",
-                "_attr_1": {},
-            },
-            "ProducerReference": {
-                "Address": {
-                    "_value_1": "http://CAMERA_LOCAL_IP:5656/event",
-                    "_attr_1": None,
-                },
-                "ReferenceParameters": None,
-                "Metadata": None,
-                "_value_1": None,
-                "_attr_1": None,
-            },
-            "Message": {
-                "_value_1": {
-                    "Source": {
-                        "SimpleItem": [
-                            {
-                                "Name": "VideoSourceConfigurationToken",
-                                "Value": "vsconf",
-                            },
-                            {
-                                "Name": "VideoAnalyticsConfigurationToken",
-                                "Value": "VideoAnalyticsToken",
-                            },
-                            {"Name": "Rule", "Value": "MyTPSmartEventDetectorRule"},
-                        ],
-                        "ElementItem": [],
-                        "Extension": None,
-                        "_attr_1": None,
-                    },
-                    "Key": None,
-                    "Data": {
-                        "SimpleItem": [{"Name": "IsVehicle", "Value": "true"}],
-                        "ElementItem": [],
-                        "Extension": None,
-                        "_attr_1": None,
-                    },
-                    "Extension": None,
-                    "UtcTime": datetime.datetime(
-                        2025, 1, 5, 14, 2, 9, tzinfo=datetime.UTC
-                    ),
-                    "PropertyOperation": "Changed",
-                    "_attr_1": {},
-                }
-            },
-        }
-    )
-
-    assert event is not None
-    assert event.name == "Vehicle Detection"
-    assert event.platform == "binary_sensor"
-    assert event.device_class == "motion"
-    assert event.value
-    assert event.uid == (
-        f"{TEST_UID}_tns1:RuleEngine/CellMotionDetector/"
-        "TpSmartEvent_VideoSourceToken_VideoAnalyticsToken_MyTPSmartEventDetectorRule"
-    )
-
-
-async def test_tapo_tpsmartevent_person(hass: HomeAssistant) -> None:
-    """Tests tns1:RuleEngine/TPSmartEventDetector/TPSmartEvent - person."""
-    event = await get_event(
-        {
-            "Message": {
-                "_value_1": {
-                    "Data": {
-                        "ElementItem": [],
-                        "Extension": None,
-                        "SimpleItem": [{"Name": "IsPeople", "Value": "true"}],
-                        "_attr_1": None,
-                    },
-                    "Extension": None,
-                    "Key": None,
-                    "PropertyOperation": "Changed",
-                    "Source": {
-                        "ElementItem": [],
-                        "Extension": None,
-                        "SimpleItem": [
-                            {
-                                "Name": "VideoSourceConfigurationToken",
-                                "Value": "vsconf",
-                            },
-                            {
-                                "Name": "VideoAnalyticsConfigurationToken",
-                                "Value": "VideoAnalyticsToken",
-                            },
-                            {"Name": "Rule", "Value": "MyPeopleDetectorRule"},
-                        ],
-                        "_attr_1": None,
-                    },
-                    "UtcTime": datetime.datetime(
-                        2024, 11, 3, 18, 40, 43, tzinfo=datetime.UTC
-                    ),
-                    "_attr_1": {},
-                }
-            },
-            "ProducerReference": {
-                "Address": {
-                    "_attr_1": None,
-                    "_value_1": "http://192.168.56.127:5656/event",
-                },
-                "Metadata": None,
-                "ReferenceParameters": None,
-                "_attr_1": None,
-                "_value_1": None,
-            },
-            "SubscriptionReference": {
-                "Address": {
-                    "_attr_1": None,
-                    "_value_1": "http://192.168.56.127:2020/event-0_2020",
-                },
-                "Metadata": None,
-                "ReferenceParameters": None,
-                "_attr_1": None,
-                "_value_1": None,
-            },
-            "Topic": {
-                "Dialect": "http://www.onvif.org/ver10/tev/topicExpression/ConcreteSet",
-                "_attr_1": {},
-                "_value_1": "tns1:RuleEngine/PeopleDetector/People",
-            },
-        }
-    )
-
-    assert event is not None
-    assert event.name == "Person Detection"
-    assert event.platform == "binary_sensor"
-    assert event.device_class == "motion"
-    assert event.value
-    assert event.uid == (
-        f"{TEST_UID}_tns1:RuleEngine/PeopleDetector/"
-        "People_VideoSourceToken_VideoAnalyticsToken_MyPeopleDetectorRule"
-    )
-
-
-async def test_tapo_tpsmartevent_pet(hass: HomeAssistant) -> None:
-    """Tests tns1:RuleEngine/TPSmartEventDetector/TPSmartEvent - pet."""
-    event = await get_event(
-        {
-            "SubscriptionReference": {
-                "Address": {
-                    "_value_1": "http://192.168.56.63:2020/event-0_2020",
-                    "_attr_1": None,
-                },
-                "ReferenceParameters": None,
-                "Metadata": None,
-                "_value_1": None,
-                "_attr_1": None,
-            },
-            "Topic": {
-                "_value_1": "tns1:RuleEngine/TPSmartEventDetector/TPSmartEvent",
-                "Dialect": "http://www.onvif.org/ver10/tev/topicExpression/ConcreteSet",
-                "_attr_1": {},
-            },
-            "ProducerReference": {
-                "Address": {
-                    "_value_1": "http://192.168.56.63:5656/event",
-                    "_attr_1": None,
-                },
-                "ReferenceParameters": None,
-                "Metadata": None,
-                "_value_1": None,
-                "_attr_1": None,
-            },
-            "Message": {
-                "_value_1": {
-                    "Source": {
-                        "SimpleItem": [
-                            {
-                                "Name": "VideoSourceConfigurationToken",
-                                "Value": "vsconf",
-                            },
-                            {
-                                "Name": "VideoAnalyticsConfigurationToken",
-                                "Value": "VideoAnalyticsToken",
-                            },
-                            {"Name": "Rule", "Value": "MyTPSmartEventDetectorRule"},
-                        ],
-                        "ElementItem": [],
-                        "Extension": None,
-                        "_attr_1": None,
-                    },
-                    "Key": None,
-                    "Data": {
-                        "SimpleItem": [{"Name": "IsPet", "Value": "true"}],
-                        "ElementItem": [],
-                        "Extension": None,
-                        "_attr_1": None,
-                    },
-                    "Extension": None,
-                    "UtcTime": datetime.datetime(
-                        2025, 1, 22, 13, 24, 57, tzinfo=datetime.UTC
-                    ),
-                    "PropertyOperation": "Changed",
-                    "_attr_1": {},
-                }
-            },
-        }
-    )
-
-    assert event is not None
-    assert event.name == "Pet Detection"
-    assert event.platform == "binary_sensor"
-    assert event.device_class == "motion"
-    assert event.value
-    assert event.uid == (
-        f"{TEST_UID}_tns1:RuleEngine/TPSmartEventDetector/"
-        "TPSmartEvent_VideoSourceToken_VideoAnalyticsToken_MyTPSmartEventDetectorRule"
-    )
-
-
-async def test_tapo_cellmotiondetector_person(hass: HomeAssistant) -> None:
-    """Tests tns1:RuleEngine/CellMotionDetector/People - person."""
-    event = await get_event(
-        {
-            "SubscriptionReference": {
-                "Address": {
-                    "_value_1": "http://192.168.56.63:2020/event-0_2020",
-                    "_attr_1": None,
-                },
-                "ReferenceParameters": None,
-                "Metadata": None,
-                "_value_1": None,
-                "_attr_1": None,
-            },
-            "Topic": {
-                "_value_1": "tns1:RuleEngine/CellMotionDetector/People",
-                "Dialect": "http://www.onvif.org/ver10/tev/topicExpression/ConcreteSet",
-                "_attr_1": {},
-            },
-            "ProducerReference": {
-                "Address": {
-                    "_value_1": "http://192.168.56.63:5656/event",
-                    "_attr_1": None,
-                },
-                "ReferenceParameters": None,
-                "Metadata": None,
-                "_value_1": None,
-                "_attr_1": None,
-            },
-            "Message": {
-                "_value_1": {
-                    "Source": {
-                        "SimpleItem": [
-                            {
-                                "Name": "VideoSourceConfigurationToken",
-                                "Value": "vsconf",
-                            },
-                            {
-                                "Name": "VideoAnalyticsConfigurationToken",
-                                "Value": "VideoAnalyticsToken",
-                            },
-                            {"Name": "Rule", "Value": "MyPeopleDetectorRule"},
-                        ],
-                        "ElementItem": [],
-                        "Extension": None,
-                        "_attr_1": None,
-                    },
-                    "Key": None,
-                    "Data": {
-                        "SimpleItem": [{"Name": "IsPeople", "Value": "true"}],
-                        "ElementItem": [],
-                        "Extension": None,
-                        "_attr_1": None,
-                    },
-                    "Extension": None,
-                    "UtcTime": datetime.datetime(
-                        2025, 1, 3, 20, 9, 22, tzinfo=datetime.UTC
-                    ),
-                    "PropertyOperation": "Changed",
-                    "_attr_1": {},
-                }
-            },
-        }
-    )
-
-    assert event is not None
-    assert event.name == "Person Detection"
-    assert event.platform == "binary_sensor"
-    assert event.device_class == "motion"
-    assert event.value
-    assert event.uid == (
-        f"{TEST_UID}_tns1:RuleEngine/CellMotionDetector/"
-        "People_VideoSourceToken_VideoAnalyticsToken_MyPeopleDetectorRule"
-    )
-
-
-async def test_tapo_tamper(hass: HomeAssistant) -> None:
-    """Tests tns1:RuleEngine/CellMotionDetector/Tamper - tamper."""
-    event = await get_event(
-        {
-            "SubscriptionReference": {
-                "Address": {
-                    "_value_1": "http://CAMERA_LOCAL_IP:2020/event-0_2020",
-                    "_attr_1": None,
-                },
-                "ReferenceParameters": None,
-                "Metadata": None,
-                "_value_1": None,
-                "_attr_1": None,
-            },
-            "Topic": {
-                "_value_1": "tns1:RuleEngine/CellMotionDetector/Tamper",
-                "Dialect": "http://www.onvif.org/ver10/tev/topicExpression/ConcreteSet",
-                "_attr_1": {},
-            },
-            "ProducerReference": {
-                "Address": {
-                    "_value_1": "http://CAMERA_LOCAL_IP:5656/event",
-                    "_attr_1": None,
-                },
-                "ReferenceParameters": None,
-                "Metadata": None,
-                "_value_1": None,
-                "_attr_1": None,
-            },
-            "Message": {
-                "_value_1": {
-                    "Source": {
-                        "SimpleItem": [
-                            {
-                                "Name": "VideoSourceConfigurationToken",
-                                "Value": "vsconf",
-                            },
-                            {
-                                "Name": "VideoAnalyticsConfigurationToken",
-                                "Value": "VideoAnalyticsToken",
-                            },
-                            {"Name": "Rule", "Value": "MyTamperDetectorRule"},
-                        ],
-                        "ElementItem": [],
-                        "Extension": None,
-                        "_attr_1": None,
-                    },
-                    "Key": None,
-                    "Data": {
-                        "SimpleItem": [{"Name": "IsTamper", "Value": "true"}],
-                        "ElementItem": [],
-                        "Extension": None,
-                        "_attr_1": None,
-                    },
-                    "Extension": None,
-                    "UtcTime": datetime.datetime(
-                        2025, 1, 5, 21, 1, 5, tzinfo=datetime.UTC
-                    ),
-                    "PropertyOperation": "Changed",
-                    "_attr_1": {},
-                }
-            },
-        }
-    )
-
-    assert event is not None
-    assert event.name == "Tamper Detection"
-    assert event.platform == "binary_sensor"
-    assert event.device_class == "tamper"
-    assert event.value
-    assert event.uid == (
-        f"{TEST_UID}_tns1:RuleEngine/CellMotionDetector/"
-        "Tamper_VideoSourceToken_VideoAnalyticsToken_MyTamperDetectorRule"
-    )
-
-
-async def test_tapo_intrusion(hass: HomeAssistant) -> None:
-    """Tests tns1:RuleEngine/CellMotionDetector/Intrusion - intrusion."""
-    event = await get_event(
-        {
-            "SubscriptionReference": {
-                "Address": {
-                    "_value_1": "http://192.168.100.155:2020/event-0_2020",
-                    "_attr_1": None,
-                },
-                "ReferenceParameters": None,
-                "Metadata": None,
-                "_value_1": None,
-                "_attr_1": None,
-            },
-            "Topic": {
-                "_value_1": "tns1:RuleEngine/CellMotionDetector/Intrusion",
-                "Dialect": "http://www.onvif.org/ver10/tev/topicExpression/ConcreteSet",
-                "_attr_1": {},
-            },
-            "ProducerReference": {
-                "Address": {
-                    "_value_1": "http://192.168.100.155:5656/event",
-                    "_attr_1": None,
-                },
-                "ReferenceParameters": None,
-                "Metadata": None,
-                "_value_1": None,
-                "_attr_1": None,
-            },
-            "Message": {
-                "_value_1": {
-                    "Source": {
-                        "SimpleItem": [
-                            {
-                                "Name": "VideoSourceConfigurationToken",
-                                "Value": "vsconf",
-                            },
-                            {
-                                "Name": "VideoAnalyticsConfigurationToken",
-                                "Value": "VideoAnalyticsToken",
-                            },
-                            {"Name": "Rule", "Value": "MyIntrusionDetectorRule"},
-                        ],
-                        "ElementItem": [],
-                        "Extension": None,
-                        "_attr_1": None,
-                    },
-                    "Key": None,
-                    "Data": {
-                        "SimpleItem": [{"Name": "IsIntrusion", "Value": "true"}],
-                        "ElementItem": [],
-                        "Extension": None,
-                        "_attr_1": None,
-                    },
-                    "Extension": None,
-                    "UtcTime": datetime.datetime(
-                        2025, 1, 11, 10, 40, 45, tzinfo=datetime.UTC
-                    ),
-                    "PropertyOperation": "Changed",
-                    "_attr_1": {},
-                }
-            },
-        }
-    )
-
-    assert event is not None
-    assert event.name == "Intrusion Detection"
-    assert event.platform == "binary_sensor"
-    assert event.device_class == "safety"
-    assert event.value
-    assert event.uid == (
-        f"{TEST_UID}_tns1:RuleEngine/CellMotionDetector/"
-        "Intrusion_VideoSourceToken_VideoAnalyticsToken_MyIntrusionDetectorRule"
-    )
-
-
-async def test_tapo_missing_attributes(hass: HomeAssistant) -> None:
-    """Tests async_parse_tplink_detector with missing fields."""
-    with pytest.raises(AttributeError, match="SimpleItem"):
-        await get_event(
-            {
-                "Message": {
-                    "_value_1": {
-                        "Data": {
-                            "ElementItem": [],
-                            "Extension": None,
-                            "SimpleItem": [{"Name": "IsPeople", "Value": "true"}],
-                            "_attr_1": None,
-                        },
-                    }
-                },
-                "Topic": {
-                    "_value_1": "tns1:RuleEngine/PeopleDetector/People",
-                },
-            }
-        )
-
-
-async def test_tapo_unknown_type(hass: HomeAssistant) -> None:
-    """Tests async_parse_tplink_detector with unknown event type."""
-    event = await get_event(
-        {
-            "Message": {
-                "_value_1": {
-                    "Data": {
-                        "ElementItem": [],
-                        "Extension": None,
-                        "SimpleItem": [{"Name": "IsNotPerson", "Value": "true"}],
-                        "_attr_1": None,
-                    },
-                    "Source": {
-                        "ElementItem": [],
-                        "Extension": None,
-                        "SimpleItem": [
-                            {
-                                "Name": "VideoSourceConfigurationToken",
-                                "Value": "vsconf",
-                            },
-                            {
-                                "Name": "VideoAnalyticsConfigurationToken",
-                                "Value": "VideoAnalyticsToken",
-                            },
-                            {"Name": "Rule", "Value": "MyPeopleDetectorRule"},
-                        ],
-                    },
-                }
-            },
-            "Topic": {
-                "_value_1": "tns1:RuleEngine/PeopleDetector/People",
-            },
-        }
-    )
-
-    assert event is None
-
-
-async def test_reolink_package(hass: HomeAssistant) -> None:
-    """Tests reolink package event."""
-    event = await get_event(
-        {
-            "SubscriptionReference": None,
-            "Topic": {
-                "_value_1": "tns1:RuleEngine/MyRuleDetector/Package",
-                "Dialect": "http://www.onvif.org/ver10/tev/topicExpression/ConcreteSet",
-                "_attr_1": {},
-            },
-            "ProducerReference": None,
-            "Message": {
-                "_value_1": {
-                    "Source": {
-                        "SimpleItem": [{"Name": "Source", "Value": "000"}],
-                        "ElementItem": [],
-                        "Extension": None,
-                        "_attr_1": None,
-                    },
-                    "Key": None,
-                    "Data": {
-                        "SimpleItem": [{"Name": "State", "Value": "true"}],
-                        "ElementItem": [],
-                        "Extension": None,
-                        "_attr_1": None,
-                    },
-                    "Extension": None,
-                    "UtcTime": datetime.datetime(
-                        2025, 3, 12, 9, 54, 27, tzinfo=datetime.UTC
-                    ),
-                    "PropertyOperation": "Initialized",
-                    "_attr_1": {},
-                }
-            },
-        }
-    )
-
-    assert event is not None
-    assert event.name == "Package Detection"
-    assert event.platform == "binary_sensor"
-    assert event.device_class == "occupancy"
-    assert event.value
-    assert event.uid == (f"{TEST_UID}_tns1:RuleEngine/MyRuleDetector/Package_000")
-
-
-async def test_hikvision_alarm(hass: HomeAssistant) -> None:
-    """Tests hikvision camera alarm event."""
-    event = await get_event(
-        {
-            "SubscriptionReference": None,
-            "Topic": {
-                "_value_1": "tns1:Device/Trigger/tnshik:AlarmIn",
-                "Dialect": "http://www.onvif.org/ver10/tev/topicExpression/ConcreteSet",
-                "_attr_1": {},
-            },
-            "ProducerReference": None,
-            "Message": {
-                "_value_1": {
-                    "Source": {
-                        "SimpleItem": [{"Name": "AlarmInToken", "Value": "AlarmIn_1"}],
-                        "ElementItem": [],
-                        "Extension": None,
-                        "_attr_1": None,
-                    },
-                    "Key": None,
-                    "Data": {
-                        "SimpleItem": [{"Name": "State", "Value": "true"}],
-                        "ElementItem": [],
-                        "Extension": None,
-                        "_attr_1": None,
-                    },
-                    "Extension": None,
-                    "UtcTime": datetime.datetime(
-                        2025, 3, 13, 22, 57, 26, tzinfo=datetime.UTC
-                    ),
-                    "PropertyOperation": "Initialized",
-                    "_attr_1": {},
-                }
-            },
-        }
-    )
-
-    assert event is not None
-    assert event.name == "Motion Alarm"
-    assert event.platform == "binary_sensor"
-    assert event.device_class == "motion"
-    assert event.value
-    assert event.uid == (f"{TEST_UID}_tns1:Device/Trigger/tnshik:AlarmIn_AlarmIn_1")

tests/components/smartthings/snapshots/test_select.ambr

@@ -593,6 +593,70 @@
     'state': 'medium',
   })
 # ---
+# name: test_all_entities[da_rvc_map_01011][select.robot_vacuum_water_level-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'options': list([
+        'high',
+        'moderate_high',
+        'medium',
+        'moderate_low',
+        'low',
+      ]),
+    }),
+    'config_entry_id': <ANY>,
+    'config_subentry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'select',
+    'entity_category': <EntityCategory.CONFIG: 'config'>,
+    'entity_id': 'select.robot_vacuum_water_level',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'object_id_base': 'Water level',
+    'options': dict({
+    }),
+    'original_device_class': None,
+    'original_icon': None,
+    'original_name': 'Water level',
+    'platform': 'smartthings',
+    'previous_unique_id': None,
+    'suggested_object_id': None,
+    'supported_features': 0,
+    'translation_key': 'robot_cleaner_water_spray_level',
+    'unique_id': '01b28624-5907-c8bc-0325-8ad23f03a637_main_samsungce.robotCleanerWaterSprayLevel_waterSprayLevel_waterSprayLevel',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_all_entities[da_rvc_map_01011][select.robot_vacuum_water_level-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'friendly_name': 'Robot Vacuum Water level',
+      'options': list([
+        'high',
+        'moderate_high',
+        'medium',
+        'moderate_low',
+        'low',
+      ]),
+    }),
+    'context': <ANY>,
+    'entity_id': 'select.robot_vacuum_water_level',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'medium',
+  })
+# ---
 # name: test_all_entities[da_wm_dw_000001][select.dishwasher-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({

tests/components/vacuum/test_init.py

@@ -24,6 +24,7 @@ from homeassistant.components.vacuum import (
     VacuumEntityFeature,
 )
 from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers import entity_registry as er, issue_registry as ir
 
 from . import (
@@ -276,6 +277,41 @@ async def test_clean_area_service(
     assert mock_vacuum.clean_segments_calls[0][0] == targeted_segments
 
 
+@pytest.mark.usefixtures("config_flow_fixture")
+async def test_clean_area_not_configured(hass: HomeAssistant) -> None:
+    """Test clean_area raises when area mapping is not configured."""
+    mock_vacuum = MockVacuumWithCleanArea(name="Testing", entity_id="vacuum.testing")
+
+    config_entry = MockConfigEntry(domain="test")
+    config_entry.add_to_hass(hass)
+
+    mock_integration(
+        hass,
+        MockModule(
+            "test",
+            async_setup_entry=help_async_setup_entry_init,
+            async_unload_entry=help_async_unload_entry,
+        ),
+    )
+    setup_test_component_platform(hass, DOMAIN, [mock_vacuum], from_config_entry=True)
+    assert await hass.config_entries.async_setup(config_entry.entry_id)
+    await hass.async_block_till_done()
+
+    with pytest.raises(ServiceValidationError) as exc_info:
+        await hass.services.async_call(
+            DOMAIN,
+            SERVICE_CLEAN_AREA,
+            {"entity_id": mock_vacuum.entity_id, "cleaning_area_id": ["area_1"]},
+            blocking=True,
+        )
+
+    assert exc_info.value.translation_domain == DOMAIN
+    assert exc_info.value.translation_key == "area_mapping_not_configured"
+    assert exc_info.value.translation_placeholders == {
+        "entity_id": mock_vacuum.entity_id
+    }
+
+
 @pytest.mark.usefixtures("config_flow_fixture")
 @pytest.mark.parametrize(
     ("area_mapping", "targeted_areas"),
@@ -308,13 +344,6 @@ async def test_clean_area_no_segments(
     assert await hass.config_entries.async_setup(config_entry.entry_id)
     await hass.async_block_till_done()
 
-    await hass.services.async_call(
-        DOMAIN,
-        SERVICE_CLEAN_AREA,
-        {"entity_id": mock_vacuum.entity_id, "cleaning_area_id": targeted_areas},
-        blocking=True,
-    )
-
     entity_registry.async_update_entity_options(
         mock_vacuum.entity_id,
         DOMAIN,