homeassistant 2025.6.2__py3-none-any.whl → 2025.7.0b0__py3-none-any.whl

homeassistant/components/sonos/binary_sensor.py

@@ -9,7 +9,6 @@ from homeassistant.components.binary_sensor import (
     BinarySensorDeviceClass,
     BinarySensorEntity,
 )
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import EntityCategory
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
@@ -17,7 +16,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .const import SONOS_CREATE_BATTERY, SONOS_CREATE_MIC_SENSOR
 from .entity import SonosEntity
-from .helpers import soco_error
+from .helpers import SonosConfigEntry, soco_error
 from .speaker import SonosSpeaker
 
 ATTR_BATTERY_POWER_SOURCE = "power_source"
@@ -27,7 +26,7 @@ _LOGGER = logging.getLogger(__name__)
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: ConfigEntry,
+    config_entry: SonosConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Sonos from a config entry."""
@@ -35,13 +34,13 @@ async def async_setup_entry(
     @callback
     def _async_create_battery_entity(speaker: SonosSpeaker) -> None:
         _LOGGER.debug("Creating battery binary_sensor on %s", speaker.zone_name)
-        entity = SonosPowerEntity(speaker)
+        entity = SonosPowerEntity(speaker, config_entry)
         async_add_entities([entity])
 
     @callback
     def _async_create_mic_entity(speaker: SonosSpeaker) -> None:
         _LOGGER.debug("Creating microphone binary_sensor on %s", speaker.zone_name)
-        async_add_entities([SonosMicrophoneSensorEntity(speaker)])
+        async_add_entities([SonosMicrophoneSensorEntity(speaker, config_entry)])
 
     config_entry.async_on_unload(
         async_dispatcher_connect(
@@ -62,9 +61,9 @@ class SonosPowerEntity(SonosEntity, BinarySensorEntity):
     _attr_entity_category = EntityCategory.DIAGNOSTIC
     _attr_device_class = BinarySensorDeviceClass.BATTERY_CHARGING
 
-    def __init__(self, speaker: SonosSpeaker) -> None:
+    def __init__(self, speaker: SonosSpeaker, config_entry: SonosConfigEntry) -> None:
         """Initialize the power entity binary sensor."""
-        super().__init__(speaker)
+        super().__init__(speaker, config_entry)
         self._attr_unique_id = f"{self.soco.uid}-power"
 
     async def _async_fallback_poll(self) -> None:
@@ -95,9 +94,9 @@ class SonosMicrophoneSensorEntity(SonosEntity, BinarySensorEntity):
     _attr_entity_category = EntityCategory.DIAGNOSTIC
     _attr_translation_key = "microphone"
 
-    def __init__(self, speaker: SonosSpeaker) -> None:
+    def __init__(self, speaker: SonosSpeaker, config_entry: SonosConfigEntry) -> None:
         """Initialize the microphone binary sensor entity."""
-        super().__init__(speaker)
+        super().__init__(speaker, config_entry)
         self._attr_unique_id = f"{self.soco.uid}-microphone"
 
     async def _async_fallback_poll(self) -> None:

homeassistant/components/sonos/const.py

@@ -10,7 +10,6 @@ from homeassistant.const import Platform
 UPNP_ST = "urn:schemas-upnp-org:device:ZonePlayer:1"
 
 DOMAIN = "sonos"
-DATA_SONOS = "sonos_media_player"
 DATA_SONOS_DISCOVERY_MANAGER = "sonos_discovery_manager"
 PLATFORMS = [
     Platform.BINARY_SENSOR,

homeassistant/components/sonos/diagnostics.py

@@ -5,11 +5,12 @@ from __future__ import annotations
 import time
 from typing import Any
 
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.device_registry import DeviceEntry
 
-from .const import DATA_SONOS, DOMAIN
+from .const import DOMAIN
+from .helpers import SonosConfigEntry
 from .speaker import SonosSpeaker
 
 MEDIA_DIAGNOSTIC_ATTRIBUTES = (
@@ -45,27 +46,29 @@ SPEAKER_DIAGNOSTIC_ATTRIBUTES = (
 
 
 async def async_get_config_entry_diagnostics(
-    hass: HomeAssistant, config_entry: ConfigEntry
+    hass: HomeAssistant, config_entry: SonosConfigEntry
 ) -> dict[str, Any]:
     """Return diagnostics for a config entry."""
     payload: dict[str, Any] = {"current_timestamp": time.monotonic()}
 
     for section in ("discovered", "discovery_known"):
         payload[section] = {}
-        data: set[Any] | dict[str, Any] = getattr(hass.data[DATA_SONOS], section)
+        data: set[Any] | dict[str, Any] = getattr(config_entry.runtime_data, section)
         if isinstance(data, set):
             payload[section] = data
             continue
         for key, value in data.items():
             if isinstance(value, SonosSpeaker):
-                payload[section][key] = await async_generate_speaker_info(hass, value)
+                payload[section][key] = await async_generate_speaker_info(
+                    hass, config_entry, value
+                )
             else:
                 payload[section][key] = value
     return payload
 
 
 async def async_get_device_diagnostics(
-    hass: HomeAssistant, config_entry: ConfigEntry, device: DeviceEntry
+    hass: HomeAssistant, config_entry: SonosConfigEntry, device: DeviceEntry
 ) -> dict[str, Any]:
     """Return diagnostics for a device."""
     uid = next(
@@ -75,10 +78,10 @@ async def async_get_device_diagnostics(
     if uid is None:
         return {}
 
-    if (speaker := hass.data[DATA_SONOS].discovered.get(uid)) is None:
+    if (speaker := config_entry.runtime_data.discovered.get(uid)) is None:
         return {}
 
-    return await async_generate_speaker_info(hass, speaker)
+    return await async_generate_speaker_info(hass, config_entry, speaker)
 
 
 async def async_generate_media_info(
@@ -107,7 +110,7 @@ async def async_generate_media_info(
 
 
 async def async_generate_speaker_info(
-    hass: HomeAssistant, speaker: SonosSpeaker
+    hass: HomeAssistant, config_entry: SonosConfigEntry, speaker: SonosSpeaker
 ) -> dict[str, Any]:
     """Generate the diagnostic payload for a specific speaker."""
     payload: dict[str, Any] = {}
@@ -130,11 +133,23 @@ async def async_generate_speaker_info(
         value = getattr(speaker, attrib)
         payload[attrib] = get_contents(value)
 
-    payload["enabled_entities"] = {
-        entity_id
-        for entity_id, s in hass.data[DATA_SONOS].entity_id_mappings.items()
-        if s is speaker
-    }
+    entity_registry = er.async_get(hass)
+    payload["enabled_entities"] = sorted(
+        registry_entry.entity_id
+        for registry_entry in entity_registry.entities.get_entries_for_config_entry_id(
+            config_entry.entry_id
+        )
+        if (
+            (
+                entity_speaker
+                := config_entry.runtime_data.unique_id_speaker_mappings.get(
+                    registry_entry.unique_id
+                )
+            )
+            and speaker.uid == entity_speaker.uid
+        )
+    )
+
     payload["media"] = await async_generate_media_info(hass, speaker)
     payload["activity_stats"] = speaker.activity_stats.report()
     payload["event_stats"] = speaker.event_stats.report()

homeassistant/components/sonos/entity.py

@@ -13,8 +13,9 @@ from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity import Entity
 
-from .const import DATA_SONOS, DOMAIN, SONOS_FALLBACK_POLL, SONOS_STATE_UPDATED
+from .const import DOMAIN, SONOS_FALLBACK_POLL, SONOS_STATE_UPDATED
 from .exception import SonosUpdateError
+from .helpers import SonosConfigEntry
 from .speaker import SonosSpeaker
 
 _LOGGER = logging.getLogger(__name__)
@@ -26,13 +27,17 @@ class SonosEntity(Entity):
     _attr_should_poll = False
     _attr_has_entity_name = True
 
-    def __init__(self, speaker: SonosSpeaker) -> None:
+    def __init__(self, speaker: SonosSpeaker, config_entry: SonosConfigEntry) -> None:
         """Initialize a SonosEntity."""
         self.speaker = speaker
+        self.config_entry = config_entry
 
     async def async_added_to_hass(self) -> None:
         """Handle common setup when added to hass."""
-        self.hass.data[DATA_SONOS].entity_id_mappings[self.entity_id] = self.speaker
+        assert self.unique_id
+        self.config_entry.runtime_data.unique_id_speaker_mappings[self.unique_id] = (
+            self.speaker
+        )
         self.async_on_remove(
             async_dispatcher_connect(
                 self.hass,
@@ -50,7 +55,8 @@ class SonosEntity(Entity):
 
     async def async_will_remove_from_hass(self) -> None:
         """Clean up when entity is removed."""
-        del self.hass.data[DATA_SONOS].entity_id_mappings[self.entity_id]
+        assert self.unique_id
+        del self.config_entry.runtime_data.unique_id_speaker_mappings[self.unique_id]
 
     async def async_fallback_poll(self, now: datetime.datetime) -> None:
         """Poll the entity if subscriptions fail."""

homeassistant/components/sonos/helpers.py

@@ -2,7 +2,10 @@
 
 from __future__ import annotations
 
+import asyncio
+from collections import OrderedDict
 from collections.abc import Callable
+from dataclasses import dataclass, field
 import logging
 from typing import TYPE_CHECKING, Any, Concatenate, overload
 
@@ -10,13 +13,17 @@ from requests.exceptions import Timeout
 from soco import SoCo
 from soco.exceptions import SoCoException, SoCoUPnPException
 
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import CALLBACK_TYPE
 from homeassistant.helpers.dispatcher import dispatcher_send
 
 from .const import SONOS_SPEAKER_ACTIVITY
 from .exception import SonosUpdateError
 
 if TYPE_CHECKING:
+    from .alarms import SonosAlarms
     from .entity import SonosEntity
+    from .favorites import SonosFavorites
     from .household_coordinator import SonosHouseholdCoordinator
     from .media import SonosMedia
     from .speaker import SonosSpeaker
@@ -120,3 +127,31 @@ def sync_get_visible_zones(soco: SoCo) -> set[SoCo]:
     _ = soco.household_id
     _ = soco.uid
     return soco.visible_zones
+
+
+@dataclass
+class UnjoinData:
+    """Class to track data necessary for unjoin coalescing."""
+
+    speakers: list[SonosSpeaker] = field(default_factory=list)
+    event: asyncio.Event = field(default_factory=asyncio.Event)
+
+
+@dataclass
+class SonosData:
+    """Storage class for platform global data."""
+
+    discovered: OrderedDict[str, SonosSpeaker] = field(default_factory=OrderedDict)
+    favorites: dict[str, SonosFavorites] = field(default_factory=dict)
+    alarms: dict[str, SonosAlarms] = field(default_factory=dict)
+    topology_condition: asyncio.Condition = field(default_factory=asyncio.Condition)
+    hosts_heartbeat: CALLBACK_TYPE | None = None
+    discovery_known: set[str] = field(default_factory=set)
+    boot_counts: dict[str, int] = field(default_factory=dict)
+    mdns_names: dict[str, str] = field(default_factory=dict)
+    # Maps the entity unique id to the associated SonosSpeaker instance.
+    unique_id_speaker_mappings: dict[str, SonosSpeaker] = field(default_factory=dict)
+    unjoin_data: dict[str, UnjoinData] = field(default_factory=dict)
+
+
+type SonosConfigEntry = ConfigEntry[SonosData]

homeassistant/components/sonos/household_coordinator.py

@@ -5,16 +5,18 @@ from __future__ import annotations
 import asyncio
 from collections.abc import Callable, Coroutine
 import logging
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from soco import SoCo
 
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.debounce import Debouncer
 
-from .const import DATA_SONOS
 from .exception import SonosUpdateError
 
+if TYPE_CHECKING:
+    from .helpers import SonosConfigEntry
+
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -23,12 +25,15 @@ class SonosHouseholdCoordinator:
 
     cache_update_lock: asyncio.Lock
 
-    def __init__(self, hass: HomeAssistant, household_id: str) -> None:
+    def __init__(
+        self, hass: HomeAssistant, household_id: str, config_entry: SonosConfigEntry
+    ) -> None:
         """Initialize the data."""
         self.hass = hass
         self.household_id = household_id
         self.async_poll: Callable[[], Coroutine[None, None, None]] | None = None
         self.last_processed_event_id: int | None = None
+        self.config_entry = config_entry
 
     def setup(self, soco: SoCo) -> None:
         """Set up the SonosAlarm instance."""
@@ -54,7 +59,7 @@ class SonosHouseholdCoordinator:
 
     async def _async_poll(self) -> None:
         """Poll any known speaker."""
-        discovered = self.hass.data[DATA_SONOS].discovered
+        discovered = self.config_entry.runtime_data.discovered
 
         for uid, speaker in discovered.items():
             _LOGGER.debug("Polling %s using %s", self.class_type, speaker.soco)

homeassistant/components/sonos/media_player.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import datetime
 from functools import partial
 import logging
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from soco import SoCo, alarms
 from soco.core import (
@@ -40,18 +40,21 @@ from homeassistant.components.media_player import (
 )
 from homeassistant.components.plex import PLEX_URI_SCHEME
 from homeassistant.components.plex.services import process_plex_payload
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import ATTR_TIME
 from homeassistant.core import HomeAssistant, ServiceCall, SupportsResponse, callback
 from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
-from homeassistant.helpers import config_validation as cv, entity_platform, service
+from homeassistant.helpers import (
+    config_validation as cv,
+    entity_platform,
+    entity_registry as er,
+    service,
+)
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.event import async_call_later
 
-from . import UnjoinData, media_browser
+from . import media_browser
 from .const import (
-    DATA_SONOS,
     DOMAIN,
     MEDIA_TYPE_DIRECTORY,
     MEDIA_TYPES_TO_SONOS,
@@ -67,9 +70,12 @@ from .const import (
     SOURCE_TV,
 )
 from .entity import SonosEntity
-from .helpers import soco_error
+from .helpers import UnjoinData, soco_error
 from .speaker import SonosMedia, SonosSpeaker
 
+if TYPE_CHECKING:
+    from .helpers import SonosConfigEntry
+
 _LOGGER = logging.getLogger(__name__)
 
 LONG_SERVICE_TIMEOUT = 30.0
@@ -108,7 +114,7 @@ ATTR_QUEUE_POSITION = "queue_position"
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: ConfigEntry,
+    config_entry: SonosConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Sonos from a config entry."""
@@ -118,7 +124,7 @@ async def async_setup_entry(
     def async_create_entities(speaker: SonosSpeaker) -> None:
         """Handle device discovery and create entities."""
         _LOGGER.debug("Creating media_player on %s", speaker.zone_name)
-        async_add_entities([SonosMediaPlayerEntity(speaker)])
+        async_add_entities([SonosMediaPlayerEntity(speaker, config_entry)])
 
     @service.verify_domain_control(hass, DOMAIN)
     async def async_service_handle(service_call: ServiceCall) -> None:
@@ -136,11 +142,11 @@ async def async_setup_entry(
 
         if service_call.service == SERVICE_SNAPSHOT:
             await SonosSpeaker.snapshot_multi(
-                hass, speakers, service_call.data[ATTR_WITH_GROUP]
+                hass, config_entry, speakers, service_call.data[ATTR_WITH_GROUP]
             )
         elif service_call.service == SERVICE_RESTORE:
             await SonosSpeaker.restore_multi(
-                hass, speakers, service_call.data[ATTR_WITH_GROUP]
+                hass, config_entry, speakers, service_call.data[ATTR_WITH_GROUP]
             )
 
     config_entry.async_on_unload(
@@ -231,9 +237,9 @@ class SonosMediaPlayerEntity(SonosEntity, MediaPlayerEntity):
     _attr_media_content_type = MediaType.MUSIC
     _attr_device_class = MediaPlayerDeviceClass.SPEAKER
 
-    def __init__(self, speaker: SonosSpeaker) -> None:
+    def __init__(self, speaker: SonosSpeaker, config_entry: SonosConfigEntry) -> None:
         """Initialize the media player entity."""
-        super().__init__(speaker)
+        super().__init__(speaker, config_entry)
         self._attr_unique_id = self.soco.uid
 
     async def async_added_to_hass(self) -> None:
@@ -298,9 +304,9 @@ class SonosMediaPlayerEntity(SonosEntity, MediaPlayerEntity):
 
     async def _async_fallback_poll(self) -> None:
         """Retrieve latest state by polling."""
-        await (
-            self.hass.data[DATA_SONOS].favorites[self.speaker.household_id].async_poll()
-        )
+        favorites = self.config_entry.runtime_data.favorites[self.speaker.household_id]
+        assert favorites.async_poll
+        await favorites.async_poll()
         await self.hass.async_add_executor_job(self._update)
 
     def _update(self) -> None:
@@ -879,13 +885,32 @@ class SonosMediaPlayerEntity(SonosEntity, MediaPlayerEntity):
     async def async_join_players(self, group_members: list[str]) -> None:
         """Join `group_members` as a player group with the current player."""
         speakers = []
+
+        entity_registry = er.async_get(self.hass)
         for entity_id in group_members:
-            if speaker := self.hass.data[DATA_SONOS].entity_id_mappings.get(entity_id):
-                speakers.append(speaker)
-            else:
-                raise HomeAssistantError(f"Not a known Sonos entity_id: {entity_id}")
+            if not (entity_reg_entry := entity_registry.async_get(entity_id)):
+                raise HomeAssistantError(
+                    translation_domain=DOMAIN,
+                    translation_key="entity_not_found",
+                    translation_placeholders={"entity_id": entity_id},
+                )
+            if not (
+                speaker
+                := self.config_entry.runtime_data.unique_id_speaker_mappings.get(
+                    entity_reg_entry.unique_id
+                )
+            ):
+                raise HomeAssistantError(
+                    translation_domain=DOMAIN,
+                    translation_key="speaker_not_found",
+                    translation_placeholders={"entity_id": entity_id},
+                )
+
+            speakers.append(speaker)
 
-        await SonosSpeaker.join_multi(self.hass, self.speaker, speakers)
+        await SonosSpeaker.join_multi(
+            self.hass, self.config_entry, self.speaker, speakers
+        )
 
     async def async_unjoin_player(self) -> None:
         """Remove this player from any group.
@@ -894,7 +919,7 @@ class SonosMediaPlayerEntity(SonosEntity, MediaPlayerEntity):
         which optimizes the order in which speakers are removed from their groups.
         Removing coordinators last better preserves playqueues on the speakers.
         """
-        sonos_data = self.hass.data[DATA_SONOS]
+        sonos_data = self.config_entry.runtime_data
         household_id = self.speaker.household_id
 
         async def async_process_unjoin(now: datetime.datetime) -> None:
@@ -903,7 +928,9 @@ class SonosMediaPlayerEntity(SonosEntity, MediaPlayerEntity):
             _LOGGER.debug(
                 "Processing unjoins for %s", [x.zone_name for x in unjoin_data.speakers]
             )
-            await SonosSpeaker.unjoin_multi(self.hass, unjoin_data.speakers)
+            await SonosSpeaker.unjoin_multi(
+                self.hass, self.config_entry, unjoin_data.speakers
+            )
             unjoin_data.event.set()
 
         if unjoin_data := sonos_data.unjoin_data.get(household_id):

homeassistant/components/sonos/number.py

@@ -6,7 +6,6 @@ import logging
 from typing import cast
 
 from homeassistant.components.number import NumberEntity
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import EntityCategory
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
@@ -14,7 +13,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .const import SONOS_CREATE_LEVELS
 from .entity import SonosEntity
-from .helpers import soco_error
+from .helpers import SonosConfigEntry, soco_error
 from .speaker import SonosSpeaker
 
 LEVEL_TYPES = {
@@ -69,7 +68,7 @@ LEVEL_FROM_NUMBER = {"balance": _balance_from_number}
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: ConfigEntry,
+    config_entry: SonosConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the Sonos number platform from a config entry."""
@@ -93,7 +92,9 @@ async def async_setup_entry(
             _LOGGER.debug(
                 "Creating %s number control on %s", level_type, speaker.zone_name
             )
-            entities.append(SonosLevelEntity(speaker, level_type, valid_range))
+            entities.append(
+                SonosLevelEntity(speaker, config_entry, level_type, valid_range)
+            )
         async_add_entities(entities)
 
     config_entry.async_on_unload(
@@ -107,10 +108,14 @@ class SonosLevelEntity(SonosEntity, NumberEntity):
     _attr_entity_category = EntityCategory.CONFIG
 
     def __init__(
-        self, speaker: SonosSpeaker, level_type: str, valid_range: tuple[int, int]
+        self,
+        speaker: SonosSpeaker,
+        config_entry: SonosConfigEntry,
+        level_type: str,
+        valid_range: tuple[int, int],
     ) -> None:
         """Initialize the level entity."""
-        super().__init__(speaker)
+        super().__init__(speaker, config_entry)
         self._attr_unique_id = f"{self.soco.uid}-{level_type}"
         self._attr_translation_key = level_type
         self.level_type = level_type

homeassistant/components/sonos/sensor.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 import logging
 
 from homeassistant.components.sensor import SensorDeviceClass, SensorEntity
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import PERCENTAGE, EntityCategory
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
@@ -20,7 +19,7 @@ from .const import (
 )
 from .entity import SonosEntity, SonosPollingEntity
 from .favorites import SonosFavorites
-from .helpers import soco_error
+from .helpers import SonosConfigEntry, soco_error
 from .speaker import SonosSpeaker
 
 _LOGGER = logging.getLogger(__name__)
@@ -28,7 +27,7 @@ _LOGGER = logging.getLogger(__name__)
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: ConfigEntry,
+    config_entry: SonosConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Sonos from a config entry."""
@@ -38,13 +37,13 @@ async def async_setup_entry(
         speaker: SonosSpeaker, audio_format: str
     ) -> None:
         _LOGGER.debug("Creating audio input format sensor on %s", speaker.zone_name)
-        entity = SonosAudioInputFormatSensorEntity(speaker, audio_format)
+        entity = SonosAudioInputFormatSensorEntity(speaker, config_entry, audio_format)
         async_add_entities([entity])
 
     @callback
     def _async_create_battery_sensor(speaker: SonosSpeaker) -> None:
         _LOGGER.debug("Creating battery level sensor on %s", speaker.zone_name)
-        entity = SonosBatteryEntity(speaker)
+        entity = SonosBatteryEntity(speaker, config_entry)
         async_add_entities([entity])
 
     @callback
@@ -82,9 +81,9 @@ class SonosBatteryEntity(SonosEntity, SensorEntity):
     _attr_entity_category = EntityCategory.DIAGNOSTIC
     _attr_native_unit_of_measurement = PERCENTAGE
 
-    def __init__(self, speaker: SonosSpeaker) -> None:
+    def __init__(self, speaker: SonosSpeaker, config_entry: SonosConfigEntry) -> None:
         """Initialize the battery sensor."""
-        super().__init__(speaker)
+        super().__init__(speaker, config_entry)
         self._attr_unique_id = f"{self.soco.uid}-battery"
 
     async def _async_fallback_poll(self) -> None:
@@ -109,9 +108,11 @@ class SonosAudioInputFormatSensorEntity(SonosPollingEntity, SensorEntity):
     _attr_translation_key = "audio_input_format"
     _attr_should_poll = True
 
-    def __init__(self, speaker: SonosSpeaker, audio_format: str) -> None:
+    def __init__(
+        self, speaker: SonosSpeaker, config_entry: SonosConfigEntry, audio_format: str
+    ) -> None:
         """Initialize the audio input format sensor."""
-        super().__init__(speaker)
+        super().__init__(speaker, config_entry)
         self._attr_unique_id = f"{self.soco.uid}-audio-format"
         self._attr_native_value = audio_format