Bump aiorussound to 4.0.5

homeassistant/components/russound_rio/__init__.py

@@ -4,10 +4,11 @@
 import logging
 
 from aiorussound import RussoundClient, RussoundTcpConnectionHandler
+from aiorussound.models import CallbackType
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_HOST, CONF_PORT, Platform
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
 
 from .const import CONNECT_TIMEOUT, RUSSOUND_RIO_EXCEPTIONS
@@ -24,26 +25,26 @@ async def async_setup_entry(hass: HomeAssistant, entry: RussoundConfigEntry) ->
 
     host = entry.data[CONF_HOST]
     port = entry.data[CONF_PORT]
-    russ = RussoundClient(RussoundTcpConnectionHandler(hass.loop, host, port))
-
-    @callback
-    def is_connected_updated(connected: bool) -> None:
-        if connected:
-            _LOGGER.warning("Reconnected to controller at %s:%s", host, port)
-        else:
-            _LOGGER.warning(
-                "Disconnected from controller at %s:%s",
-                host,
-                port,
-            )
-
-    russ.connection_handler.add_connection_callback(is_connected_updated)
+    client = RussoundClient(RussoundTcpConnectionHandler(host, port))
+
+    async def _connection_update_callback(
+        _client: RussoundClient, _callback_type: CallbackType
+    ) -> None:
+        """Call when the device is notified of changes."""
+        if _callback_type == CallbackType.CONNECTION:
+            if _client.is_connected():
+                _LOGGER.warning("Reconnected to device at %s", entry.data[CONF_HOST])
+            else:
+                _LOGGER.warning("Disconnected from device at %s", entry.data[CONF_HOST])
+
+    await client.register_state_update_callbacks(_connection_update_callback)
+
     try:
         async with asyncio.timeout(CONNECT_TIMEOUT):
-            await russ.connect()
+            await client.connect()
     except RUSSOUND_RIO_EXCEPTIONS as err:
         raise ConfigEntryNotReady(f"Error while connecting to {host}:{port}") from err
-    entry.runtime_data = russ
+    entry.runtime_data = client
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
@@ -53,6 +54,6 @@ def is_connected_updated(connected: bool) -> None:
 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a config entry."""
     if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
-        await entry.runtime_data.close()
+        await entry.runtime_data.disconnect()
 
     return unload_ok

homeassistant/components/russound_rio/config_flow.py

@@ -6,19 +6,14 @@
 import logging
 from typing import Any
 
-from aiorussound import Controller, RussoundClient, RussoundTcpConnectionHandler
+from aiorussound import RussoundClient, RussoundTcpConnectionHandler
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
 from homeassistant.const import CONF_HOST, CONF_PORT
 from homeassistant.helpers import config_validation as cv
 
-from .const import (
-    CONNECT_TIMEOUT,
-    DOMAIN,
-    RUSSOUND_RIO_EXCEPTIONS,
-    NoPrimaryControllerException,
-)
+from .const import CONNECT_TIMEOUT, DOMAIN, RUSSOUND_RIO_EXCEPTIONS
 
 DATA_SCHEMA = vol.Schema(
     {
@@ -30,16 +25,6 @@
 _LOGGER = logging.getLogger(__name__)
 
 
-def find_primary_controller_metadata(
-    controllers: dict[int, Controller],
-) -> tuple[str, str]:
-    """Find the mac address of the primary Russound controller."""
-    if 1 in controllers:
-        c = controllers[1]
-        return c.mac_address, c.controller_type
-    raise NoPrimaryControllerException
-
-
 class FlowHandler(ConfigFlow, domain=DOMAIN):
     """Russound RIO configuration flow."""
 
@@ -54,28 +39,22 @@ async def async_step_user(
             host = user_input[CONF_HOST]
             port = user_input[CONF_PORT]
 
-            russ = RussoundClient(
-                RussoundTcpConnectionHandler(self.hass.loop, host, port)
-            )
+            client = RussoundClient(RussoundTcpConnectionHandler(host, port))
             try:
                 async with asyncio.timeout(CONNECT_TIMEOUT):
-                    await russ.connect()
-                    controllers = await russ.enumerate_controllers()
-                    metadata = find_primary_controller_metadata(controllers)
-                    await russ.close()
+                    await client.connect()
+                    controller = client.controllers[1]
+                    await client.disconnect()
             except RUSSOUND_RIO_EXCEPTIONS:
                 _LOGGER.exception("Could not connect to Russound RIO")
                 errors["base"] = "cannot_connect"
-            except NoPrimaryControllerException:
-                _LOGGER.exception(
-                    "Russound RIO device doesn't have a primary controller",
-                )
-                errors["base"] = "no_primary_controller"
             else:
-                await self.async_set_unique_id(metadata[0])
+                await self.async_set_unique_id(controller.mac_address)
                 self._abort_if_unique_id_configured()
                 data = {CONF_HOST: host, CONF_PORT: port}
-                return self.async_create_entry(title=metadata[1], data=data)
+                return self.async_create_entry(
+                    title=controller.controller_type, data=data
+                )
 
         return self.async_show_form(
             step_id="user", data_schema=DATA_SCHEMA, errors=errors
@@ -88,25 +67,19 @@ async def async_step_import(self, import_data: dict[str, Any]) -> ConfigFlowResu
         port = import_data.get(CONF_PORT, 9621)
 
         # Connection logic is repeated here since this method will be removed in future releases
-        russ = RussoundClient(RussoundTcpConnectionHandler(self.hass.loop, host, port))
+        client = RussoundClient(RussoundTcpConnectionHandler(host, port))
         try:
             async with asyncio.timeout(CONNECT_TIMEOUT):
-                await russ.connect()
-                controllers = await russ.enumerate_controllers()
-                metadata = find_primary_controller_metadata(controllers)
-                await russ.close()
+                await client.connect()
+                controller = client.controllers[1]
+                await client.disconnect()
         except RUSSOUND_RIO_EXCEPTIONS:
             _LOGGER.exception("Could not connect to Russound RIO")
             return self.async_abort(
                 reason="cannot_connect", description_placeholders={}
             )
-        except NoPrimaryControllerException:
-            _LOGGER.exception("Russound RIO device doesn't have a primary controller")
-            return self.async_abort(
-                reason="no_primary_controller", description_placeholders={}
-            )
         else:
-            await self.async_set_unique_id(metadata[0])
+            await self.async_set_unique_id(controller.mac_address)
             self._abort_if_unique_id_configured()
             data = {CONF_HOST: host, CONF_PORT: port}
-            return self.async_create_entry(title=metadata[1], data=data)
+            return self.async_create_entry(title=controller.controller_type, data=data)

homeassistant/components/russound_rio/const.py

@@ -17,10 +17,6 @@
 )
 
 
-class NoPrimaryControllerException(Exception):
-    """Thrown when the Russound device is not the primary unit in the RNET stack."""
-
-
 CONNECT_TIMEOUT = 5
 
 MP_FEATURES_BY_FLAG = {

homeassistant/components/russound_rio/entity.py

@@ -4,9 +4,9 @@
 from functools import wraps
 from typing import Any, Concatenate
 
-from aiorussound import Controller, RussoundTcpConnectionHandler
+from aiorussound import Controller, RussoundClient, RussoundTcpConnectionHandler
+from aiorussound.models import CallbackType
 
-from homeassistant.core import callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC, DeviceInfo
 from homeassistant.helpers.entity import Entity
@@ -46,7 +46,7 @@ def __init__(
         self._client = controller.client
         self._controller = controller
         self._primary_mac_address = (
-            controller.mac_address or controller.parent_controller.mac_address
+            controller.mac_address or self._client.controllers[1].mac_address
         )
         self._device_identifier = (
             self._controller.mac_address
@@ -64,30 +64,33 @@ def __init__(
             self._attr_device_info["configuration_url"] = (
                 f"http://{self._client.connection_handler.host}"
             )
-        if controller.parent_controller:
+        if controller.controller_id != 1:
+            assert self._client.controllers[1].mac_address
             self._attr_device_info["via_device"] = (
                 DOMAIN,
-                controller.parent_controller.mac_address,
+                self._client.controllers[1].mac_address,
             )
         else:
+            assert controller.mac_address
             self._attr_device_info["connections"] = {
                 (CONNECTION_NETWORK_MAC, controller.mac_address)
             }
 
-    @callback
-    def _is_connected_updated(self, connected: bool) -> None:
-        """Update the state when the device is ready to receive commands or is unavailable."""
-        self._attr_available = connected
+    async def _state_update_callback(
+        self, _client: RussoundClient, _callback_type: CallbackType
+    ) -> None:
+        """Call when the device is notified of changes."""
+        if _callback_type == CallbackType.CONNECTION:
+            self._attr_available = _client.is_connected()
+        self._controller = _client.controllers[self._controller.controller_id]
         self.async_write_ha_state()
 
     async def async_added_to_hass(self) -> None:
-        """Register callbacks."""
-        self._client.connection_handler.add_connection_callback(
-            self._is_connected_updated
-        )
+        """Register callback handlers."""
+        await self._client.register_state_update_callbacks(self._state_update_callback)
 
     async def async_will_remove_from_hass(self) -> None:
         """Remove callbacks."""
-        self._client.connection_handler.remove_connection_callback(
-            self._is_connected_updated
+        await self._client.unregister_state_update_callbacks(
+            self._state_update_callback
         )

homeassistant/components/russound_rio/manifest.json

@@ -7,5 +7,5 @@
   "iot_class": "local_push",
   "loggers": ["aiorussound"],
   "quality_scale": "silver",
-  "requirements": ["aiorussound==3.1.5"]
+  "requirements": ["aiorussound==4.0.5"]
 }