Add try catch

The coordinator already removes players that left the account, so this handler could never allow a deletion. Automatic removal alone satisfies the stale-devices rule.

homeassistant/components/yoto/__init__.py

@@ -19,11 +19,7 @@ from homeassistant.helpers.config_entry_oauth2_flow import (
 from .const import DOMAIN
 from .coordinator import YotoConfigEntry, YotoDataUpdateCoordinator
 
-PLATFORMS: list[Platform] = [
-    Platform.BINARY_SENSOR,
-    Platform.MEDIA_PLAYER,
-    Platform.TIME,
-]
+PLATFORMS: list[Platform] = [Platform.MEDIA_PLAYER, Platform.TIME]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: YotoConfigEntry) -> bool:

homeassistant/components/yoto/binary_sensor.py

@@ -1,87 +0,0 @@
-"""Binary sensor platform for the Yoto integration."""
-
-from collections.abc import Callable
-from dataclasses import dataclass
-
-from yoto_api import YotoPlayer
-
-from homeassistant.components.binary_sensor import (
-    BinarySensorDeviceClass,
-    BinarySensorEntity,
-    BinarySensorEntityDescription,
-)
-from homeassistant.const import EntityCategory
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .coordinator import YotoConfigEntry, YotoDataUpdateCoordinator
-from .entity import YotoPlayerEntity
-
-PARALLEL_UPDATES = 0
-
-
-@dataclass(frozen=True, kw_only=True)
-class YotoBinarySensorEntityDescription(BinarySensorEntityDescription):
-    """Describes a Yoto binary sensor entity."""
-
-    is_on_fn: Callable[[YotoPlayer], bool | None]
-
-
-BINARY_SENSORS: tuple[YotoBinarySensorEntityDescription, ...] = (
-    YotoBinarySensorEntityDescription(
-        key="charging",
-        device_class=BinarySensorDeviceClass.BATTERY_CHARGING,
-        entity_category=EntityCategory.DIAGNOSTIC,
-        is_on_fn=lambda player: player.status.is_charging,
-    ),
-    YotoBinarySensorEntityDescription(
-        key="headphones",
-        translation_key="headphones",
-        device_class=BinarySensorDeviceClass.CONNECTIVITY,
-        entity_category=EntityCategory.DIAGNOSTIC,
-        is_on_fn=lambda player: player.status.is_audio_device_connected,
-    ),
-    YotoBinarySensorEntityDescription(
-        key="bluetooth_audio",
-        translation_key="bluetooth_audio",
-        device_class=BinarySensorDeviceClass.CONNECTIVITY,
-        entity_category=EntityCategory.DIAGNOSTIC,
-        is_on_fn=lambda player: player.status.is_bluetooth_audio_connected,
-    ),
-)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: YotoConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up the Yoto binary sensor platform."""
-    coordinator = entry.runtime_data
-    async_add_entities(
-        YotoBinarySensor(coordinator, player, description)
-        for player in coordinator.client.players.values()
-        for description in BINARY_SENSORS
-    )
-
-
-class YotoBinarySensor(YotoPlayerEntity, BinarySensorEntity):
-    """Representation of a Yoto player binary sensor."""
-
-    entity_description: YotoBinarySensorEntityDescription
-
-    def __init__(
-        self,
-        coordinator: YotoDataUpdateCoordinator,
-        player: YotoPlayer,
-        description: YotoBinarySensorEntityDescription,
-    ) -> None:
-        """Initialize the binary sensor."""
-        super().__init__(coordinator, player)
-        self.entity_description = description
-        self._attr_unique_id = f"{player.id}_{description.key}"
-
-    @property
-    def is_on(self) -> bool | None:
-        """Return the binary sensor state."""
-        return self.entity_description.is_on_fn(self.player)

homeassistant/components/yoto/coordinator.py

@@ -14,6 +14,7 @@ from homeassistant.exceptions import (
     OAuth2TokenRequestError,
     OAuth2TokenRequestReauthError,
 )
+from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.config_entry_oauth2_flow import OAuth2Session
 from homeassistant.helpers.event import async_track_time_interval
@@ -46,6 +47,7 @@ class YotoDataUpdateCoordinator(DataUpdateCoordinator[dict[str, YotoPlayer]]):
         )
         self._session = session
         self.client = YotoClient(session=async_get_clientsession(hass))
+        self._subscribed_players: set[str] = set()
         self._sync_token()
 
     def _sync_token(self) -> None:
@@ -87,6 +89,8 @@ class YotoDataUpdateCoordinator(DataUpdateCoordinator[dict[str, YotoPlayer]]):
                 translation_placeholders={"error": str(err)},
             ) from err
 
+        self._subscribed_players = set(self.client.players)
+
         # The MQTT data/status topic is not pushed spontaneously; the firmware
         # only emits it in response to a command/status/request publish.
         self.config_entry.async_on_unload(
@@ -131,8 +135,37 @@ class YotoDataUpdateCoordinator(DataUpdateCoordinator[dict[str, YotoPlayer]]):
                 translation_placeholders={"error": str(err)},
             ) from err
 
+        await self._async_sync_subscriptions()
+        self._remove_stale_devices()
         return self.client.players
 
+    async def _async_sync_subscriptions(self) -> None:
+        """Subscribe new players to MQTT events and unsubscribe removed ones."""
+        current = set(self.client.players)
+        try:
+            for device_id in current - self._subscribed_players:
+                await self.client.subscribe_player_events(device_id)
+            for device_id in self._subscribed_players - current:
+                await self.client.unsubscribe_player_events(device_id)
+        except YotoError as err:
+            _LOGGER.warning("Could not update Yoto event subscriptions: %s", err)
+            return
+        self._subscribed_players = current
+
+    def _remove_stale_devices(self) -> None:
+        """Drop devices for players no longer returned by the account."""
+        device_registry = dr.async_get(self.hass)
+        for device in dr.async_entries_for_config_entry(
+            device_registry, self.config_entry.entry_id
+        ):
+            player_id = next(
+                (ident[1] for ident in device.identifiers if ident[0] == DOMAIN), None
+            )
+            if player_id is not None and player_id not in self.client.players:
+                device_registry.async_update_device(
+                    device.id, remove_config_entry_id=self.config_entry.entry_id
+                )
+
     async def _async_load_library(self) -> None:
         """Load the card library and groups; failures only affect browsing."""
         try:

homeassistant/components/yoto/icons.json

@@ -1,13 +1,5 @@
 {
   "entity": {
-    "binary_sensor": {
-      "bluetooth_audio": {
-        "default": "mdi:bluetooth-audio"
-      },
-      "headphones": {
-        "default": "mdi:headphones"
-      }
-    },
     "time": {
       "day_mode_start": {
         "default": "mdi:weather-sunny"

homeassistant/components/yoto/media_player.py

@@ -16,7 +16,7 @@ from homeassistant.components.media_player import (
     MediaPlayerState,
     MediaType,
 )
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
@@ -47,10 +47,22 @@ async def async_setup_entry(
 ) -> None:
     """Set up the Yoto media player platform."""
     coordinator = entry.runtime_data
-    async_add_entities(
-        YotoMediaPlayer(coordinator, player)
-        for player in coordinator.client.players.values()
-    )
+    known_players: set[str] = set()
+
+    @callback
+    def _add_players() -> None:
+        current = set(coordinator.data)
+        new_players = current - known_players
+        known_players.clear()
+        known_players.update(current)
+        if new_players:
+            async_add_entities(
+                YotoMediaPlayer(coordinator, coordinator.data[player_id])
+                for player_id in new_players
+            )
+
+    entry.async_on_unload(coordinator.async_add_listener(_add_players))
+    _add_players()
 
 
 class YotoMediaPlayer(YotoPlayerEntity, MediaPlayerEntity):

homeassistant/components/yoto/quality_scale.yaml

@@ -56,7 +56,7 @@ rules:
   docs-supported-functions: todo
   docs-troubleshooting: todo
   docs-use-cases: todo
-  dynamic-devices: todo
+  dynamic-devices: done
   entity-category: done
   entity-device-class: done
   entity-disabled-by-default:
@@ -71,7 +71,7 @@ rules:
   repair-issues:
     status: exempt
     comment: No repair issues are raised yet.
-  stale-devices: todo
+  stale-devices: done
 
   # Platinum
   async-dependency: done

homeassistant/components/yoto/strings.json

@@ -37,14 +37,6 @@
     }
   },
   "entity": {
-    "binary_sensor": {
-      "bluetooth_audio": {
-        "name": "Bluetooth audio"
-      },
-      "headphones": {
-        "name": "Headphones"
-      }
-    },
     "time": {
       "day_mode_start": {
         "name": "Day mode start"

tests/components/yoto/conftest.py

@@ -16,7 +16,6 @@ from yoto_api import (
     PlaybackStatus,
     PlayerConfig,
     PlayerInfo,
-    PlayerStatus,
     Track,
     YotoPlayer,
 )
@@ -94,11 +93,6 @@ def _build_player() -> YotoPlayer:
             night_time=dt_time(19, 0),
         ),
     )
-    player.status = PlayerStatus(
-        is_charging=True,
-        is_audio_device_connected=False,
-        is_bluetooth_audio_connected=False,
-    )
     player.last_event = PlaybackEvent(
         player_id=PLAYER_ID,
         playback_status=PlaybackStatus.PLAYING,

tests/components/yoto/snapshots/test_binary_sensor.ambr

@@ -1,154 +0,0 @@
-# serializer version: 1
-# name: test_all_entities[binary_sensor.nursery_yoto_bluetooth_audio-entry]
-  EntityRegistryEntrySnapshot({
-    'aliases': list([
-      None,
-    ]),
-    'area_id': None,
-    'capabilities': None,
-    'config_entry_id': <ANY>,
-    'config_subentry_id': <ANY>,
-    'device_class': None,
-    'device_id': <ANY>,
-    'disabled_by': None,
-    'domain': 'binary_sensor',
-    'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
-    'entity_id': 'binary_sensor.nursery_yoto_bluetooth_audio',
-    'has_entity_name': True,
-    'hidden_by': None,
-    'icon': None,
-    'id': <ANY>,
-    'labels': set({
-    }),
-    'name': None,
-    'object_id_base': 'Bluetooth audio',
-    'options': dict({
-    }),
-    'original_device_class': <BinarySensorDeviceClass.CONNECTIVITY: 'connectivity'>,
-    'original_icon': None,
-    'original_name': 'Bluetooth audio',
-    'platform': 'yoto',
-    'previous_unique_id': None,
-    'suggested_object_id': None,
-    'supported_features': 0,
-    'translation_key': 'bluetooth_audio',
-    'unique_id': 'player-test_bluetooth_audio',
-    'unit_of_measurement': None,
-  })
-# ---
-# name: test_all_entities[binary_sensor.nursery_yoto_bluetooth_audio-state]
-  StateSnapshot({
-    'attributes': ReadOnlyDict({
-      'device_class': 'connectivity',
-      'friendly_name': 'Nursery Yoto Bluetooth audio',
-    }),
-    'context': <ANY>,
-    'entity_id': 'binary_sensor.nursery_yoto_bluetooth_audio',
-    'last_changed': <ANY>,
-    'last_reported': <ANY>,
-    'last_updated': <ANY>,
-    'state': 'off',
-  })
-# ---
-# name: test_all_entities[binary_sensor.nursery_yoto_charging-entry]
-  EntityRegistryEntrySnapshot({
-    'aliases': list([
-      None,
-    ]),
-    'area_id': None,
-    'capabilities': None,
-    'config_entry_id': <ANY>,
-    'config_subentry_id': <ANY>,
-    'device_class': None,
-    'device_id': <ANY>,
-    'disabled_by': None,
-    'domain': 'binary_sensor',
-    'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
-    'entity_id': 'binary_sensor.nursery_yoto_charging',
-    'has_entity_name': True,
-    'hidden_by': None,
-    'icon': None,
-    'id': <ANY>,
-    'labels': set({
-    }),
-    'name': None,
-    'object_id_base': 'Charging',
-    'options': dict({
-    }),
-    'original_device_class': <BinarySensorDeviceClass.BATTERY_CHARGING: 'battery_charging'>,
-    'original_icon': None,
-    'original_name': 'Charging',
-    'platform': 'yoto',
-    'previous_unique_id': None,
-    'suggested_object_id': None,
-    'supported_features': 0,
-    'translation_key': None,
-    'unique_id': 'player-test_charging',
-    'unit_of_measurement': None,
-  })
-# ---
-# name: test_all_entities[binary_sensor.nursery_yoto_charging-state]
-  StateSnapshot({
-    'attributes': ReadOnlyDict({
-      'device_class': 'battery_charging',
-      'friendly_name': 'Nursery Yoto Charging',
-    }),
-    'context': <ANY>,
-    'entity_id': 'binary_sensor.nursery_yoto_charging',
-    'last_changed': <ANY>,
-    'last_reported': <ANY>,
-    'last_updated': <ANY>,
-    'state': 'on',
-  })
-# ---
-# name: test_all_entities[binary_sensor.nursery_yoto_headphones-entry]
-  EntityRegistryEntrySnapshot({
-    'aliases': list([
-      None,
-    ]),
-    'area_id': None,
-    'capabilities': None,
-    'config_entry_id': <ANY>,
-    'config_subentry_id': <ANY>,
-    'device_class': None,
-    'device_id': <ANY>,
-    'disabled_by': None,
-    'domain': 'binary_sensor',
-    'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
-    'entity_id': 'binary_sensor.nursery_yoto_headphones',
-    'has_entity_name': True,
-    'hidden_by': None,
-    'icon': None,
-    'id': <ANY>,
-    'labels': set({
-    }),
-    'name': None,
-    'object_id_base': 'Headphones',
-    'options': dict({
-    }),
-    'original_device_class': <BinarySensorDeviceClass.CONNECTIVITY: 'connectivity'>,
-    'original_icon': None,
-    'original_name': 'Headphones',
-    'platform': 'yoto',
-    'previous_unique_id': None,
-    'suggested_object_id': None,
-    'supported_features': 0,
-    'translation_key': 'headphones',
-    'unique_id': 'player-test_headphones',
-    'unit_of_measurement': None,
-  })
-# ---
-# name: test_all_entities[binary_sensor.nursery_yoto_headphones-state]
-  StateSnapshot({
-    'attributes': ReadOnlyDict({
-      'device_class': 'connectivity',
-      'friendly_name': 'Nursery Yoto Headphones',
-    }),
-    'context': <ANY>,
-    'entity_id': 'binary_sensor.nursery_yoto_headphones',
-    'last_changed': <ANY>,
-    'last_reported': <ANY>,
-    'last_updated': <ANY>,
-    'state': 'off',
-  })
-# ---

tests/components/yoto/test_binary_sensor.py

@@ -1,49 +0,0 @@
-"""Tests for the Yoto binary sensor platform."""
-
-from unittest.mock import MagicMock, patch
-
-import pytest
-from syrupy.assertion import SnapshotAssertion
-
-from homeassistant.const import STATE_UNAVAILABLE, Platform
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers import entity_registry as er
-
-from . import setup_integration
-
-from tests.common import MockConfigEntry, snapshot_platform
-
-pytestmark = pytest.mark.usefixtures("setup_credentials")
-
-ENTITY_ID = "binary_sensor.nursery_yoto_charging"
-
-
-@pytest.mark.usefixtures("mock_yoto_client", "entity_registry_enabled_by_default")
-async def test_all_entities(
-    hass: HomeAssistant,
-    mock_config_entry: MockConfigEntry,
-    entity_registry: er.EntityRegistry,
-    snapshot: SnapshotAssertion,
-) -> None:
-    """Snapshot every Yoto binary sensor entity."""
-    with patch("homeassistant.components.yoto.PLATFORMS", [Platform.BINARY_SENSOR]):
-        await setup_integration(hass, mock_config_entry)
-
-    await snapshot_platform(hass, entity_registry, snapshot, mock_config_entry.entry_id)
-
-
-async def test_binary_sensor_unavailable_when_offline(
-    hass: HomeAssistant,
-    mock_yoto_client: MagicMock,
-    mock_config_entry: MockConfigEntry,
-) -> None:
-    """Binary sensors are unavailable while the player is offline."""
-    player = next(iter(mock_yoto_client.players.values()))
-    player.is_online = False
-
-    with patch("homeassistant.components.yoto.PLATFORMS", [Platform.BINARY_SENSOR]):
-        await setup_integration(hass, mock_config_entry)
-
-    state = hass.states.get(ENTITY_ID)
-    assert state is not None
-    assert state.state == STATE_UNAVAILABLE

tests/components/yoto/test_init.py

@@ -5,7 +5,7 @@ from unittest.mock import MagicMock, Mock, patch
 import aiohttp
 from freezegun.api import FrozenDateTimeFactory
 import pytest
-from yoto_api import AuthenticationError, YotoAPIError, YotoError
+from yoto_api import AuthenticationError, Device, YotoAPIError, YotoError, YotoPlayer
 
 from homeassistant.components.yoto.const import (
     DOMAIN,
@@ -18,11 +18,13 @@ from homeassistant.exceptions import (
     OAuth2TokenRequestError,
     OAuth2TokenRequestReauthError,
 )
+from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.config_entry_oauth2_flow import (
     ImplementationUnavailableError,
 )
 
 from . import setup_integration
+from .conftest import PLAYER_ID
 
 from tests.common import MockConfigEntry, async_fire_time_changed
 
@@ -316,3 +318,86 @@ async def test_periodic_poll_fails_on_api_error(
 
     coordinator = mock_config_entry.runtime_data
     assert coordinator.last_update_success is False
+
+
+def _build_second_player() -> YotoPlayer:
+    """Build a second Yoto player discovered after setup."""
+    return YotoPlayer(
+        device=Device(
+            device_id="player-2",
+            name="Playroom Yoto",
+            device_type="v3",
+            device_family="v3",
+            generation="gen3",
+        ),
+        is_online=True,
+    )
+
+
+async def test_dynamic_device_added(
+    hass: HomeAssistant,
+    mock_yoto_client: MagicMock,
+    mock_config_entry: MockConfigEntry,
+    freezer: FrozenDateTimeFactory,
+) -> None:
+    """A player discovered after setup gets its entity without a reload."""
+    await setup_integration(hass, mock_config_entry)
+    assert hass.states.get("media_player.nursery_yoto") is not None
+    assert hass.states.get("media_player.playroom_yoto") is None
+
+    mock_yoto_client.players["player-2"] = _build_second_player()
+    freezer.tick(SCAN_INTERVAL)
+    async_fire_time_changed(hass)
+    await hass.async_block_till_done()
+
+    assert hass.states.get("media_player.playroom_yoto") is not None
+    mock_yoto_client.subscribe_player_events.assert_called_once_with("player-2")
+
+
+async def test_subscription_failure_does_not_fail_refresh(
+    hass: HomeAssistant,
+    mock_yoto_client: MagicMock,
+    mock_config_entry: MockConfigEntry,
+    freezer: FrozenDateTimeFactory,
+) -> None:
+    """A subscription error keeps the refreshed data and retries next cycle."""
+    await setup_integration(hass, mock_config_entry)
+    mock_yoto_client.players["player-2"] = _build_second_player()
+    mock_yoto_client.subscribe_player_events.side_effect = YotoAPIError("boom")
+
+    freezer.tick(SCAN_INTERVAL)
+    async_fire_time_changed(hass)
+    await hass.async_block_till_done()
+
+    assert hass.states.get("media_player.playroom_yoto") is not None
+    assert mock_config_entry.runtime_data.last_update_success is True
+
+    mock_yoto_client.subscribe_player_events.side_effect = None
+    mock_yoto_client.subscribe_player_events.reset_mock()
+    freezer.tick(SCAN_INTERVAL)
+    async_fire_time_changed(hass)
+    await hass.async_block_till_done()
+
+    mock_yoto_client.subscribe_player_events.assert_called_once_with("player-2")
+
+
+async def test_stale_device_removed(
+    hass: HomeAssistant,
+    mock_yoto_client: MagicMock,
+    mock_config_entry: MockConfigEntry,
+    device_registry: dr.DeviceRegistry,
+    freezer: FrozenDateTimeFactory,
+) -> None:
+    """A player removed from the account has its device dropped."""
+    await setup_integration(hass, mock_config_entry)
+    assert (
+        device_registry.async_get_device(identifiers={(DOMAIN, PLAYER_ID)}) is not None
+    )
+
+    mock_yoto_client.players.clear()
+    freezer.tick(SCAN_INTERVAL)
+    async_fire_time_changed(hass)
+    await hass.async_block_till_done()
+
+    assert device_registry.async_get_device(identifiers={(DOMAIN, PLAYER_ID)}) is None
+    mock_yoto_client.unsubscribe_player_events.assert_called_once_with(PLAYER_ID)