homeassistant 2025.6.3__py3-none-any.whl → 2025.7.0b5__py3-none-any.whl

homeassistant/components/eq3btsmart/switch.py

@@ -1,26 +1,45 @@
 """Platform for eq3 switch entities."""
 
-from collections.abc import Awaitable, Callable
+from collections.abc import Callable, Coroutine
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any
+from datetime import timedelta
+from functools import partial
+from typing import Any
 
 from eq3btsmart import Thermostat
+from eq3btsmart.const import EQ3_DEFAULT_AWAY_TEMP, Eq3OperationMode
 from eq3btsmart.models import Status
 
 from homeassistant.components.switch import SwitchEntity, SwitchEntityDescription
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+import homeassistant.util.dt as dt_util
 
 from . import Eq3ConfigEntry
-from .const import ENTITY_KEY_AWAY, ENTITY_KEY_BOOST, ENTITY_KEY_LOCK
+from .const import (
+    DEFAULT_AWAY_HOURS,
+    ENTITY_KEY_AWAY,
+    ENTITY_KEY_BOOST,
+    ENTITY_KEY_LOCK,
+)
 from .entity import Eq3Entity
 
 
+async def async_set_away(thermostat: Thermostat, enable: bool) -> Status:
+    """Backport old async_set_away behavior."""
+
+    if not enable:
+        return await thermostat.async_set_mode(Eq3OperationMode.AUTO)
+
+    away_until = dt_util.now() + timedelta(hours=DEFAULT_AWAY_HOURS)
+    return await thermostat.async_set_away(away_until, EQ3_DEFAULT_AWAY_TEMP)
+
+
 @dataclass(frozen=True, kw_only=True)
 class Eq3SwitchEntityDescription(SwitchEntityDescription):
     """Entity description for eq3 switch entities."""
 
-    toggle_func: Callable[[Thermostat], Callable[[bool], Awaitable[None]]]
+    toggle_func: Callable[[Thermostat], Callable[[bool], Coroutine[None, None, Status]]]
     value_func: Callable[[Status], bool]
 
 
@@ -40,7 +59,7 @@ SWITCH_ENTITY_DESCRIPTIONS = [
     Eq3SwitchEntityDescription(
         key=ENTITY_KEY_AWAY,
         translation_key=ENTITY_KEY_AWAY,
-        toggle_func=lambda thermostat: thermostat.async_set_away,
+        toggle_func=lambda thermostat: partial(async_set_away, thermostat),
         value_func=lambda status: status.is_away,
     ),
 ]
@@ -88,7 +107,4 @@ class Eq3SwitchEntity(Eq3Entity, SwitchEntity):
     def is_on(self) -> bool:
         """Return the state of the switch."""
 
-        if TYPE_CHECKING:
-            assert self._thermostat.status is not None
-
         return self.entity_description.value_func(self._thermostat.status)

homeassistant/components/eq3btsmart/translations/nl.json

@@ -5,6 +5,13 @@
         },
         "error": {
             "invalid_mac_address": "Ongeldig MAC-adres"
+        },
+        "step": {
+            "user": {
+                "data": {
+                    "mac": "MAC adres"
+                }
+            }
         }
     },
     "entity": {
@@ -12,6 +19,11 @@
             "comfort": {
                 "name": "Comforttemperatuur"
             }
+        },
+        "sensor": {
+            "valve": {
+                "name": "Klep"
+            }
         }
     }
 }

homeassistant/components/esphome/assist_satellite.py

@@ -60,6 +60,7 @@ _VOICE_ASSISTANT_EVENT_TYPES: EsphomeEnumMapper[
         VoiceAssistantEventType.VOICE_ASSISTANT_STT_START: PipelineEventType.STT_START,
         VoiceAssistantEventType.VOICE_ASSISTANT_STT_END: PipelineEventType.STT_END,
         VoiceAssistantEventType.VOICE_ASSISTANT_INTENT_START: PipelineEventType.INTENT_START,
+        VoiceAssistantEventType.VOICE_ASSISTANT_INTENT_PROGRESS: PipelineEventType.INTENT_PROGRESS,
         VoiceAssistantEventType.VOICE_ASSISTANT_INTENT_END: PipelineEventType.INTENT_END,
         VoiceAssistantEventType.VOICE_ASSISTANT_TTS_START: PipelineEventType.TTS_START,
         VoiceAssistantEventType.VOICE_ASSISTANT_TTS_END: PipelineEventType.TTS_END,
@@ -282,6 +283,16 @@ class EsphomeAssistSatellite(
         elif event_type == VoiceAssistantEventType.VOICE_ASSISTANT_STT_END:
             assert event.data is not None
             data_to_send = {"text": event.data["stt_output"]["text"]}
+        elif event_type == VoiceAssistantEventType.VOICE_ASSISTANT_INTENT_PROGRESS:
+            if (
+                not event.data
+                or ("tts_start_streaming" not in event.data)
+                or (not event.data["tts_start_streaming"])
+            ):
+                # ESPHome only needs to know if early TTS streaming is available
+                return
+
+            data_to_send = {"tts_start_streaming": "1"}
         elif event_type == VoiceAssistantEventType.VOICE_ASSISTANT_INTENT_END:
             assert event.data is not None
             data_to_send = {
@@ -332,7 +343,7 @@ class EsphomeAssistSatellite(
             }
         elif event_type == VoiceAssistantEventType.VOICE_ASSISTANT_RUN_START:
             assert event.data is not None
-            if tts_output := event.data["tts_output"]:
+            if tts_output := event.data.get("tts_output"):
                 path = tts_output["url"]
                 url = async_process_play_media_url(self.hass, path)
                 data_to_send = {"url": url}

homeassistant/components/esphome/dashboard.py

@@ -63,9 +63,7 @@ class ESPHomeDashboardManager:
         if not (data := self._data) or not (info := data.get("info")):
             return
         if is_hassio(self._hass):
-            from homeassistant.components.hassio import (  # pylint: disable=import-outside-toplevel
-                get_addons_info,
-            )
+            from homeassistant.components.hassio import get_addons_info  # noqa: PLC0415
 
             if (addons := get_addons_info(self._hass)) is not None and info[
                 "addon_slug"

homeassistant/components/esphome/entity.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from collections.abc import Awaitable, Callable, Coroutine
 import functools
+import logging
 import math
 from typing import TYPE_CHECKING, Any, Concatenate, Generic, TypeVar, cast
 
@@ -13,7 +14,6 @@ from aioesphomeapi import (
     EntityCategory as EsphomeEntityCategory,
     EntityInfo,
     EntityState,
-    build_unique_id,
 )
 import voluptuous as vol
 
@@ -24,6 +24,7 @@ from homeassistant.helpers import (
     config_validation as cv,
     device_registry as dr,
     entity_platform,
+    entity_registry as er,
 )
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity import Entity
@@ -32,9 +33,11 @@ from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from .const import DOMAIN
 
 # Import config flow so that it's added to the registry
-from .entry_data import ESPHomeConfigEntry, RuntimeEntryData
+from .entry_data import ESPHomeConfigEntry, RuntimeEntryData, build_device_unique_id
 from .enum_mapper import EsphomeEnumMapper
 
+_LOGGER = logging.getLogger(__name__)
+
 _InfoT = TypeVar("_InfoT", bound=EntityInfo)
 _EntityT = TypeVar("_EntityT", bound="EsphomeEntity[Any,Any]")
 _StateT = TypeVar("_StateT", bound=EntityState)
@@ -53,21 +56,74 @@ def async_static_info_updated(
 ) -> None:
     """Update entities of this platform when entities are listed."""
     current_infos = entry_data.info[info_type]
+    device_info = entry_data.device_info
+    if TYPE_CHECKING:
+        assert device_info is not None
     new_infos: dict[int, EntityInfo] = {}
     add_entities: list[_EntityT] = []
 
+    ent_reg = er.async_get(hass)
+    dev_reg = dr.async_get(hass)
+
     for info in infos:
-        if not current_infos.pop(info.key, None):
-            # Create new entity
+        new_infos[info.key] = info
+
+        # Create new entity if it doesn't exist
+        if not (old_info := current_infos.pop(info.key, None)):
             entity = entity_type(entry_data, platform.domain, info, state_type)
             add_entities.append(entity)
-        new_infos[info.key] = info
+            continue
+
+        # Entity exists - check if device_id has changed
+        if old_info.device_id == info.device_id:
+            continue
+
+        # Entity has switched devices, need to migrate unique_id
+        old_unique_id = build_device_unique_id(device_info.mac_address, old_info)
+        entity_id = ent_reg.async_get_entity_id(platform.domain, DOMAIN, old_unique_id)
+
+        # If entity not found in registry, re-add it
+        # This happens when the device_id changed and the old device was deleted
+        if entity_id is None:
+            _LOGGER.info(
+                "Entity with old unique_id %s not found in registry after device_id "
+                "changed from %s to %s, re-adding entity",
+                old_unique_id,
+                old_info.device_id,
+                info.device_id,
+            )
+            entity = entity_type(entry_data, platform.domain, info, state_type)
+            add_entities.append(entity)
+            continue
+
+        updates: dict[str, Any] = {}
+        new_unique_id = build_device_unique_id(device_info.mac_address, info)
+
+        # Update unique_id if it changed
+        if old_unique_id != new_unique_id:
+            updates["new_unique_id"] = new_unique_id
+
+        # Update device assignment
+        if info.device_id:
+            # Entity now belongs to a sub device
+            new_device = dev_reg.async_get_device(
+                identifiers={(DOMAIN, f"{device_info.mac_address}_{info.device_id}")}
+            )
+        else:
+            # Entity now belongs to the main device
+            new_device = dev_reg.async_get_device(
+                connections={(dr.CONNECTION_NETWORK_MAC, device_info.mac_address)}
+            )
+
+        if new_device:
+            updates["device_id"] = new_device.id
+
+        # Apply all updates at once
+        if updates:
+            ent_reg.async_update_entity(entity_id, **updates)
 
     # Anything still in current_infos is now gone
     if current_infos:
-        device_info = entry_data.device_info
-        if TYPE_CHECKING:
-            assert device_info is not None
         entry_data.async_remove_entities(
             hass, current_infos.values(), device_info.mac_address
         )
@@ -244,11 +300,28 @@ class EsphomeEntity(EsphomeBaseEntity, Generic[_InfoT, _StateT]):
         self._key = entity_info.key
         self._state_type = state_type
         self._on_static_info_update(entity_info)
-        self._attr_device_info = DeviceInfo(
-            connections={(dr.CONNECTION_NETWORK_MAC, device_info.mac_address)}
-        )
+
+        device_name = device_info.name
+        # Determine the device connection based on whether this entity belongs to a sub device
+        if entity_info.device_id:
+            # Entity belongs to a sub device
+            self._attr_device_info = DeviceInfo(
+                identifiers={
+                    (DOMAIN, f"{device_info.mac_address}_{entity_info.device_id}")
+                }
+            )
+            # Use the pre-computed device_id_to_name mapping for O(1) lookup
+            device_name = entry_data.device_id_to_name.get(
+                entity_info.device_id, device_info.name
+            )
+        else:
+            # Entity belongs to the main device
+            self._attr_device_info = DeviceInfo(
+                connections={(dr.CONNECTION_NETWORK_MAC, device_info.mac_address)}
+            )
+
         if entity_info.name:
-            self.entity_id = f"{domain}.{device_info.name}_{entity_info.object_id}"
+            self.entity_id = f"{domain}.{device_name}_{entity_info.name}"
         else:
             # https://github.com/home-assistant/core/issues/132532
             # If name is not set, ESPHome will use the sanitized friendly name
@@ -256,7 +329,7 @@ class EsphomeEntity(EsphomeBaseEntity, Generic[_InfoT, _StateT]):
             # as the entity_id before it is sanitized since the sanitizer
             # is not utf-8 aware. In this case, its always going to be
             # an empty string so we drop the object_id.
-            self.entity_id = f"{domain}.{device_info.name}"
+            self.entity_id = f"{domain}.{device_name}"
 
     async def async_added_to_hass(self) -> None:
         """Register callbacks."""
@@ -290,7 +363,9 @@ class EsphomeEntity(EsphomeBaseEntity, Generic[_InfoT, _StateT]):
             static_info = cast(_InfoT, static_info)
             assert device_info
         self._static_info = static_info
-        self._attr_unique_id = build_unique_id(device_info.mac_address, static_info)
+        self._attr_unique_id = build_device_unique_id(
+            device_info.mac_address, static_info
+        )
         self._attr_entity_registry_enabled_default = not static_info.disabled_by_default
         # https://github.com/home-assistant/core/issues/132532
         # If the name is "", we need to set it to None since otherwise

homeassistant/components/esphome/entry_data.py

@@ -95,6 +95,22 @@ INFO_TYPE_TO_PLATFORM: dict[type[EntityInfo], Platform] = {
 }
 
 
+def build_device_unique_id(mac: str, entity_info: EntityInfo) -> str:
+    """Build unique ID for entity, appending @device_id if it belongs to a sub-device.
+
+    This wrapper around build_unique_id ensures that entities belonging to sub-devices
+    have their device_id appended to the unique_id to handle proper migration when
+    entities move between devices.
+    """
+    base_unique_id = build_unique_id(mac, entity_info)
+
+    # If entity belongs to a sub-device, append @device_id
+    if entity_info.device_id:
+        return f"{base_unique_id}@{entity_info.device_id}"
+
+    return base_unique_id
+
+
 class StoreData(TypedDict, total=False):
     """ESPHome storage data."""
 
@@ -160,6 +176,7 @@ class RuntimeEntryData:
     assist_satellite_set_wake_word_callbacks: list[Callable[[str], None]] = field(
         default_factory=list
     )
+    device_id_to_name: dict[int, str] = field(default_factory=dict)
 
     @property
     def name(self) -> str:
@@ -222,7 +239,9 @@ class RuntimeEntryData:
         ent_reg = er.async_get(hass)
         for info in static_infos:
             if entry := ent_reg.async_get_entity_id(
-                INFO_TYPE_TO_PLATFORM[type(info)], DOMAIN, build_unique_id(mac, info)
+                INFO_TYPE_TO_PLATFORM[type(info)],
+                DOMAIN,
+                build_device_unique_id(mac, info),
             ):
                 ent_reg.async_remove(entry)
 
@@ -278,7 +297,8 @@ class RuntimeEntryData:
             if (
                 (old_unique_id := info.unique_id)
                 and (old_entry := registry_get_entity(platform, DOMAIN, old_unique_id))
-                and (new_unique_id := build_unique_id(mac, info)) != old_unique_id
+                and (new_unique_id := build_device_unique_id(mac, info))
+                != old_unique_id
                 and not registry_get_entity(platform, DOMAIN, new_unique_id)
             ):
                 ent_reg.async_update_entity(old_entry, new_unique_id=new_unique_id)

homeassistant/components/esphome/manager.py

@@ -527,6 +527,11 @@ class ESPHomeManager:
                 device_info.name,
                 device_mac,
             )
+        # Build device_id_to_name mapping for efficient lookup
+        entry_data.device_id_to_name = {
+            sub_device.device_id: sub_device.name or device_info.name
+            for sub_device in device_info.devices
+        }
         self.device_id = _async_setup_device_registry(hass, entry, entry_data)
 
         entry_data.async_update_device_state()
@@ -751,6 +756,28 @@ def _async_setup_device_registry(
     device_info = entry_data.device_info
     if TYPE_CHECKING:
         assert device_info is not None
+
+    device_registry = dr.async_get(hass)
+    # Build sets of valid device identifiers and connections
+    valid_connections = {
+        (dr.CONNECTION_NETWORK_MAC, format_mac(device_info.mac_address))
+    }
+    valid_identifiers = {
+        (DOMAIN, f"{device_info.mac_address}_{sub_device.device_id}")
+        for sub_device in device_info.devices
+    }
+
+    # Remove devices that no longer exist
+    for device in dr.async_entries_for_config_entry(device_registry, entry.entry_id):
+        # Skip devices we want to keep
+        if (
+            device.connections & valid_connections
+            or device.identifiers & valid_identifiers
+        ):
+            continue
+        # Remove everything else
+        device_registry.async_remove_device(device.id)
+
     sw_version = device_info.esphome_version
     if device_info.compilation_time:
         sw_version += f" ({device_info.compilation_time})"
@@ -779,11 +806,14 @@ def _async_setup_device_registry(
             f"{device_info.project_version} (ESPHome {device_info.esphome_version})"
         )
 
-    suggested_area = None
-    if device_info.suggested_area:
+    suggested_area: str | None = None
+    if device_info.area and device_info.area.name:
+        # Prefer device_info.area over suggested_area when area name is not empty
+        suggested_area = device_info.area.name
+    elif device_info.suggested_area:
         suggested_area = device_info.suggested_area
 
-    device_registry = dr.async_get(hass)
+    # Create/update main device
     device_entry = device_registry.async_get_or_create(
         config_entry_id=entry.entry_id,
         configuration_url=configuration_url,
@@ -794,6 +824,36 @@ def _async_setup_device_registry(
         sw_version=sw_version,
         suggested_area=suggested_area,
     )
+
+    # Handle sub devices
+    # Find available areas from device_info
+    areas_by_id = {area.area_id: area for area in device_info.areas}
+    # Add the main device's area if it exists
+    if device_info.area:
+        areas_by_id[device_info.area.area_id] = device_info.area
+    # Create/update sub devices that should exist
+    for sub_device in device_info.devices:
+        # Determine the area for this sub device
+        sub_device_suggested_area: str | None = None
+        if sub_device.area_id is not None and sub_device.area_id in areas_by_id:
+            sub_device_suggested_area = areas_by_id[sub_device.area_id].name
+
+        sub_device_entry = device_registry.async_get_or_create(
+            config_entry_id=entry.entry_id,
+            identifiers={(DOMAIN, f"{device_info.mac_address}_{sub_device.device_id}")},
+            name=sub_device.name or device_entry.name,
+            manufacturer=manufacturer,
+            model=model,
+            sw_version=sw_version,
+            suggested_area=sub_device_suggested_area,
+        )
+
+        # Update the sub device to set via_device_id
+        device_registry.async_update_device(
+            sub_device_entry.id,
+            via_device_id=device_entry.id,
+        )
+
     return device_entry.id
 
 

homeassistant/components/esphome/manifest.json

@@ -17,7 +17,7 @@
   "mqtt": ["esphome/discover/#"],
   "quality_scale": "platinum",
   "requirements": [
-    "aioesphomeapi==33.0.0",
+    "aioesphomeapi==33.1.1",
     "esphome-dashboard-api==1.3.0",
     "bleak-esphome==2.16.0"
   ],

homeassistant/components/esphome/translations/sv.json

@@ -131,10 +131,10 @@
             "message": "Fel vid kommunikation med enheten {device_name}: {error}"
         },
         "error_compiling": {
-            "message": "Fel vid kompilering av {configuration}. F\u00f6rs\u00f6k igen i ESPHomes instrumentpanel f\u00f6r mer information."
+            "message": "Fel vid kompilering av {configuration}. F\u00f6rs\u00f6k igen i ESPHomes kontrollpanel f\u00f6r mer information."
         },
         "error_uploading": {
-            "message": "Fel vid OTA (Over-the-air) f\u00f6r {configuration}. F\u00f6rs\u00f6k igen i ESPHomes instrumentpanel f\u00f6r mer information."
+            "message": "Fel under OTA-uppdatering (over-the-air) f\u00f6r {configuration}. F\u00f6rs\u00f6k igen i ESPHomes kontrollpanel f\u00f6r mer information."
         },
         "ota_in_progress": {
             "message": "En OTA-uppdatering (Over-the-air) p\u00e5g\u00e5r redan f\u00f6r {configuration}."

homeassistant/components/evohome/water_heater.py

@@ -71,6 +71,11 @@ class EvoDHW(EvoChild, WaterHeaterEntity):
     _attr_name = "DHW controller"
     _attr_icon = "mdi:thermometer-lines"
     _attr_operation_list = list(HA_STATE_TO_EVO)
+    _attr_supported_features = (
+        WaterHeaterEntityFeature.AWAY_MODE
+        | WaterHeaterEntityFeature.ON_OFF
+        | WaterHeaterEntityFeature.OPERATION_MODE
+    )
     _attr_temperature_unit = UnitOfTemperature.CELSIUS
 
     _evo_device: evo.HotWater
@@ -91,9 +96,6 @@ class EvoDHW(EvoChild, WaterHeaterEntity):
         self._attr_precision = (
             PRECISION_TENTHS if coordinator.client_v1 else PRECISION_WHOLE
         )
-        self._attr_supported_features = (
-            WaterHeaterEntityFeature.AWAY_MODE | WaterHeaterEntityFeature.OPERATION_MODE
-        )
 
     @property
     def current_operation(self) -> str | None:

homeassistant/components/ezviz/select.py

@@ -2,9 +2,17 @@
 
 from __future__ import annotations
 
+from collections.abc import Callable
 from dataclasses import dataclass
-
-from pyezvizapi.constants import DeviceSwitchType, SoundMode
+from typing import cast
+
+from pyezvizapi.constants import (
+    BatteryCameraWorkMode,
+    DeviceCatagories,
+    DeviceSwitchType,
+    SoundMode,
+    SupportExt,
+)
 from pyezvizapi.exceptions import HTTPError, PyEzvizError
 
 from homeassistant.components.select import SelectEntity, SelectEntityDescription
@@ -24,17 +32,83 @@ class EzvizSelectEntityDescription(SelectEntityDescription):
     """Describe a EZVIZ Select entity."""
 
     supported_switch: int
+    current_option: Callable[[EzvizSelect], str | None]
+    select_option: Callable[[EzvizSelect, str, str], None]
+
+
+def alarm_sound_mode_current_option(ezvizSelect: EzvizSelect) -> str | None:
+    """Return the selected entity option to represent the entity state."""
+    sound_mode_value = getattr(
+        SoundMode, ezvizSelect.data[ezvizSelect.entity_description.key]
+    ).value
+    if sound_mode_value in [0, 1, 2]:
+        return ezvizSelect.options[sound_mode_value]
+
+    return None
+
+
+def alarm_sound_mode_select_option(
+    ezvizSelect: EzvizSelect, serial: str, option: str
+) -> None:
+    """Change the selected option."""
+    sound_mode_value = ezvizSelect.options.index(option)
+    ezvizSelect.coordinator.ezviz_client.alarm_sound(serial, sound_mode_value, 1)
 
 
-SELECT_TYPE = EzvizSelectEntityDescription(
+ALARM_SOUND_MODE_SELECT_TYPE = EzvizSelectEntityDescription(
     key="alarm_sound_mod",
     translation_key="alarm_sound_mode",
     entity_category=EntityCategory.CONFIG,
     options=["soft", "intensive", "silent"],
     supported_switch=DeviceSwitchType.ALARM_TONE.value,
+    current_option=alarm_sound_mode_current_option,
+    select_option=alarm_sound_mode_select_option,
 )
 
 
+def battery_work_mode_current_option(ezvizSelect: EzvizSelect) -> str | None:
+    """Return the selected entity option to represent the entity state."""
+    battery_work_mode = getattr(
+        BatteryCameraWorkMode,
+        ezvizSelect.data[ezvizSelect.entity_description.key],
+        BatteryCameraWorkMode.UNKNOWN,
+    )
+    if battery_work_mode == BatteryCameraWorkMode.UNKNOWN:
+        return None
+
+    return battery_work_mode.name.lower()
+
+
+def battery_work_mode_select_option(
+    ezvizSelect: EzvizSelect, serial: str, option: str
+) -> None:
+    """Change the selected option."""
+    battery_work_mode = getattr(BatteryCameraWorkMode, option.upper())
+    ezvizSelect.coordinator.ezviz_client.set_battery_camera_work_mode(
+        serial, battery_work_mode.value
+    )
+
+
+BATTERY_WORK_MODE_SELECT_TYPE = EzvizSelectEntityDescription(
+    key="battery_camera_work_mode",
+    translation_key="battery_camera_work_mode",
+    icon="mdi:battery-sync",
+    entity_category=EntityCategory.CONFIG,
+    options=[
+        "plugged_in",
+        "high_performance",
+        "power_save",
+        "super_power_save",
+        "custom",
+    ],
+    supported_switch=-1,
+    current_option=battery_work_mode_current_option,
+    select_option=battery_work_mode_select_option,
+)
+
+SELECT_TYPES = [ALARM_SOUND_MODE_SELECT_TYPE, BATTERY_WORK_MODE_SELECT_TYPE]
+
+
 async def async_setup_entry(
     hass: HomeAssistant,
     entry: EzvizConfigEntry,
@@ -43,12 +117,26 @@ async def async_setup_entry(
     """Set up EZVIZ select entities based on a config entry."""
     coordinator = entry.runtime_data
 
-    async_add_entities(
-        EzvizSelect(coordinator, camera)
+    entities = [
+        EzvizSelect(coordinator, camera, ALARM_SOUND_MODE_SELECT_TYPE)
         for camera in coordinator.data
         for switch in coordinator.data[camera]["switches"]
-        if switch == SELECT_TYPE.supported_switch
-    )
+        if switch == ALARM_SOUND_MODE_SELECT_TYPE.supported_switch
+    ]
+
+    for camera in coordinator.data:
+        device_category = coordinator.data[camera].get("device_category")
+        supportExt = coordinator.data[camera].get("supportExt")
+        if (
+            device_category == DeviceCatagories.BATTERY_CAMERA_DEVICE_CATEGORY.value
+            and supportExt
+            and str(SupportExt.SupportBatteryManage.value) in supportExt
+        ):
+            entities.append(
+                EzvizSelect(coordinator, camera, BATTERY_WORK_MODE_SELECT_TYPE)
+            )
+
+    async_add_entities(entities)
 
 
 class EzvizSelect(EzvizEntity, SelectEntity):
@@ -58,31 +146,23 @@ class EzvizSelect(EzvizEntity, SelectEntity):
         self,
         coordinator: EzvizDataUpdateCoordinator,
         serial: str,
+        description: EzvizSelectEntityDescription,
     ) -> None:
-        """Initialize the sensor."""
+        """Initialize the select entity."""
         super().__init__(coordinator, serial)
-        self._attr_unique_id = f"{serial}_{SELECT_TYPE.key}"
-        self.entity_description = SELECT_TYPE
+        self._attr_unique_id = f"{serial}_{description.key}"
+        self.entity_description = description
 
     @property
     def current_option(self) -> str | None:
         """Return the selected entity option to represent the entity state."""
-        sound_mode_value = getattr(
-            SoundMode, self.data[self.entity_description.key]
-        ).value
-        if sound_mode_value in [0, 1, 2]:
-            return self.options[sound_mode_value]
-
-        return None
+        desc = cast(EzvizSelectEntityDescription, self.entity_description)
+        return desc.current_option(self)
 
     def select_option(self, option: str) -> None:
         """Change the selected option."""
-        sound_mode_value = self.options.index(option)
-
+        desc = cast(EzvizSelectEntityDescription, self.entity_description)
         try:
-            self.coordinator.ezviz_client.alarm_sound(self._serial, sound_mode_value, 1)
-
+            return desc.select_option(self, self._serial, option)
         except (HTTPError, PyEzvizError) as err:
-            raise HomeAssistantError(
-                f"Cannot set Warning sound level for {self.entity_id}"
-            ) from err
+            raise HomeAssistantError(f"Cannot select option for {desc.key}") from err