python-roborock 3.8.3__tar.gz → 3.8.5__tar.gz

{python_roborock-3.8.3 → python_roborock-3.8.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-roborock
-Version: 3.8.3
+Version: 3.8.5
 Summary: A package to control Roborock vacuums.
 Project-URL: Repository, https://github.com/humbertogontijo/python-roborock
 Project-URL: Documentation, https://python-roborock.readthedocs.io/

{python_roborock-3.8.3 → python_roborock-3.8.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-roborock"
-version = "3.8.3"
+version = "3.8.5"
 description = "A package to control Roborock vacuums."
 authors = [{ name = "humbertogontijo", email = "humbertogontijo@users.noreply.github.com" }, {name="Lash-L"}, {name="allenporter"}]
 requires-python = ">=3.11, <4"

{python_roborock-3.8.3 → python_roborock-3.8.5}/roborock/devices/cache.py

@@ -26,7 +26,13 @@ class CacheData:
     """Home map information indexed by map_flag."""
 
     home_map_content: dict[int, bytes] = field(default_factory=dict)
-    """Home cache content for each map data indexed by map_flag."""
+    """Home cache content for each map data indexed by map_flag.
+
+    This is deprecated in favor of `home_map_content_base64`.
+    """
+
+    home_map_content_base64: dict[int, str] = field(default_factory=dict)
+    """Home cache content for each map data (encoded base64) indexed by map_flag."""
 
     device_features: DeviceFeatures | None = None
     """Device features information."""

{python_roborock-3.8.3 → python_roborock-3.8.5}/roborock/devices/mqtt_channel.py

@@ -90,5 +90,5 @@ class MqttChannel(Channel):
 def create_mqtt_channel(
     user_data: UserData, mqtt_params: MqttParams, mqtt_session: MqttSession, device: HomeDataDevice
 ) -> MqttChannel:
-    """Create a V1Channel for the given device."""
+    """Create a MQTT channel for the given device."""
     return MqttChannel(mqtt_session, device.duid, device.local_key, user_data.rriot, mqtt_params)

{python_roborock-3.8.3 → python_roborock-3.8.5}/roborock/devices/traits/v1/__init__.py

@@ -38,8 +38,8 @@ from roborock.data.containers import HomeData, HomeDataProduct, RoborockBase
 from roborock.data.v1.v1_code_mappings import RoborockDockTypeCode
 from roborock.devices.cache import Cache
 from roborock.devices.traits import Trait
-from roborock.devices.v1_rpc_channel import V1RpcChannel
 from roborock.map.map_parser import MapParserConfig
+from roborock.protocols.v1_protocol import V1RpcChannel
 from roborock.web_api import UserWebApiClient
 
 from .child_lock import ChildLockTrait

{python_roborock-3.8.3 → python_roborock-3.8.5}/roborock/devices/traits/v1/common.py

@@ -9,7 +9,7 @@ from dataclasses import dataclass, fields
 from typing import ClassVar, Self
 
 from roborock.data import RoborockBase
-from roborock.devices.v1_rpc_channel import V1RpcChannel
+from roborock.protocols.v1_protocol import V1RpcChannel
 from roborock.roborock_typing import RoborockCommand
 
 _LOGGER = logging.getLogger(__name__)

{python_roborock-3.8.3 → python_roborock-3.8.5}/roborock/devices/traits/v1/home.py

@@ -16,6 +16,7 @@ the current map's information and room names as needed.
 """
 
 import asyncio
+import base64
 import logging
 from typing import Self
 
@@ -86,14 +87,20 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
         After discovery, the home cache will be populated and can be accessed via the `home_map_info` property.
         """
         cache_data = await self._cache.get()
-        if cache_data.home_map_info and cache_data.home_map_content:
+        if cache_data.home_map_info and (cache_data.home_map_content or cache_data.home_map_content_base64):
             _LOGGER.debug("Home cache already populated, skipping discovery")
             self._home_map_info = cache_data.home_map_info
             self._discovery_completed = True
             try:
-                self._home_map_content = {
-                    k: self._map_content.parse_map_content(v) for k, v in cache_data.home_map_content.items()
-                }
+                if cache_data.home_map_content_base64:
+                    self._home_map_content = {
+                        k: self._map_content.parse_map_content(base64.b64decode(v))
+                        for k, v in cache_data.home_map_content_base64.items()
+                    }
+                else:
+                    self._home_map_content = {
+                        k: self._map_content.parse_map_content(v) for k, v in cache_data.home_map_content.items()
+                    }
             except (ValueError, RoborockException) as ex:
                 _LOGGER.warning("Failed to parse cached home map content, will re-discover: %s", ex)
                 self._home_map_content = {}
@@ -218,7 +225,12 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
         """Update the entire home cache with new map info and content."""
         cache_data = await self._cache.get()
         cache_data.home_map_info = home_map_info
-        cache_data.home_map_content = {k: v.raw_api_response for k, v in home_map_content.items() if v.raw_api_response}
+        cache_data.home_map_content_base64 = {
+            k: base64.b64encode(v.raw_api_response).decode("utf-8")
+            for k, v in home_map_content.items()
+            if v.raw_api_response
+        }
+        cache_data.home_map_content = {}
         await self._cache.set(cache_data)
         self._home_map_info = home_map_info
         self._home_map_content = home_map_content
@@ -237,8 +249,18 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
         if update_cache:
             cache_data = await self._cache.get()
             cache_data.home_map_info[map_flag] = map_info
+            # Migrate existing cached content to base64 if needed
+            if cache_data.home_map_content and not cache_data.home_map_content_base64:
+                cache_data.home_map_content_base64 = {
+                    k: base64.b64encode(v).decode("utf-8") for k, v in cache_data.home_map_content.items()
+                }
+                cache_data.home_map_content = {}
             if map_content.raw_api_response:
-                cache_data.home_map_content[map_flag] = map_content.raw_api_response
+                if cache_data.home_map_content_base64 is None:
+                    cache_data.home_map_content_base64 = {}
+                cache_data.home_map_content_base64[map_flag] = base64.b64encode(map_content.raw_api_response).decode(
+                    "utf-8"
+                )
             await self._cache.set(cache_data)
 
         if self._home_map_info is None:

{python_roborock-3.8.3 → python_roborock-3.8.5}/roborock/devices/v1_channel.py

@@ -8,37 +8,43 @@ import asyncio
 import datetime
 import logging
 from collections.abc import Callable
-from typing import TypeVar
+from dataclasses import dataclass
+from typing import Any, TypeVar
 
 from roborock.data import HomeDataDevice, NetworkInfo, RoborockBase, UserData
 from roborock.exceptions import RoborockException
+from roborock.mqtt.health_manager import HealthManager
 from roborock.mqtt.session import MqttParams, MqttSession
 from roborock.protocols.v1_protocol import (
+    CommandType,
+    MapResponse,
+    ParamsType,
+    RequestMessage,
+    ResponseData,
+    ResponseMessage,
     SecurityData,
+    V1RpcChannel,
+    create_map_response_decoder,
     create_security_data,
+    decode_rpc_response,
 )
-from roborock.roborock_message import RoborockMessage
+from roborock.roborock_message import RoborockMessage, RoborockMessageProtocol
 from roborock.roborock_typing import RoborockCommand
 
 from .cache import Cache
 from .channel import Channel
 from .local_channel import LocalChannel, LocalSession, create_local_session
 from .mqtt_channel import MqttChannel
-from .v1_rpc_channel import (
-    PickFirstAvailable,
-    V1RpcChannel,
-    create_local_rpc_channel,
-    create_map_rpc_channel,
-    create_mqtt_rpc_channel,
-)
 
 _LOGGER = logging.getLogger(__name__)
 
 __all__ = [
-    "V1Channel",
+    "create_v1_channel",
 ]
 
 _T = TypeVar("_T", bound=RoborockBase)
+_TIMEOUT = 10.0
+
 
 # Exponential backoff parameters for reconnecting to local
 MIN_RECONNECT_INTERVAL = datetime.timedelta(minutes=1)
@@ -50,6 +56,106 @@ NETWORK_INFO_REFRESH_INTERVAL = datetime.timedelta(hours=12)
 LOCAL_CONNECTION_CHECK_INTERVAL = datetime.timedelta(seconds=15)
 
 
+@dataclass(frozen=True)
+class RpcStrategy:
+    """Strategy for encoding/sending/decoding RPC commands."""
+
+    name: str  # For debug logging
+    channel: LocalChannel | MqttChannel
+    encoder: Callable[[RequestMessage], RoborockMessage]
+    decoder: Callable[[RoborockMessage], ResponseMessage | MapResponse | None]
+    health_manager: HealthManager | None = None
+
+
+class RpcChannel(V1RpcChannel):
+    """Provides an RPC interface around a pub/sub transport channel."""
+
+    def __init__(self, rpc_strategies: list[RpcStrategy]) -> None:
+        """Initialize the RpcChannel with on ordered list of strategies."""
+        self._rpc_strategies = rpc_strategies
+
+    async def send_command(
+        self,
+        method: CommandType,
+        *,
+        response_type: type[_T] | None = None,
+        params: ParamsType = None,
+    ) -> _T | Any:
+        """Send a command and return either a decoded or parsed response."""
+        request = RequestMessage(method, params=params)
+
+        # Try each channel in order until one succeeds
+        last_exception = None
+        for strategy in self._rpc_strategies:
+            try:
+                decoded_response = await self._send_rpc(strategy, request)
+            except RoborockException as e:
+                _LOGGER.warning("Command %s failed on %s channel: %s", method, strategy.name, e)
+                last_exception = e
+            except Exception as e:
+                _LOGGER.exception("Unexpected error sending command %s on %s channel", method, strategy.name)
+                last_exception = RoborockException(f"Unexpected error: {e}")
+            else:
+                if response_type is not None:
+                    if not isinstance(decoded_response, dict):
+                        raise RoborockException(
+                            f"Expected dict response to parse {response_type.__name__}, got {type(decoded_response)}"
+                        )
+                    return response_type.from_dict(decoded_response)
+                return decoded_response
+
+        raise last_exception or RoborockException("No available connection to send command")
+
+    @staticmethod
+    async def _send_rpc(strategy: RpcStrategy, request: RequestMessage) -> ResponseData | bytes:
+        """Send a command and return a decoded response type.
+
+        This provides an RPC interface over a given channel strategy. The device
+        channel only supports publish and subscribe, so this function handles
+        associating requests with their corresponding responses.
+        """
+        future: asyncio.Future[ResponseData | bytes] = asyncio.Future()
+        _LOGGER.debug(
+            "Sending command (%s, request_id=%s): %s, params=%s",
+            strategy.name,
+            request.request_id,
+            request.method,
+            request.params,
+        )
+
+        message = strategy.encoder(request)
+
+        def find_response(response_message: RoborockMessage) -> None:
+            try:
+                decoded = strategy.decoder(response_message)
+            except RoborockException as ex:
+                _LOGGER.debug("Exception while decoding message (%s): %s", response_message, ex)
+                return
+            if decoded is None:
+                return
+            _LOGGER.debug("Received response (%s, request_id=%s)", strategy.name, decoded.request_id)
+            if decoded.request_id == request.request_id:
+                if isinstance(decoded, ResponseMessage) and decoded.api_error:
+                    future.set_exception(decoded.api_error)
+                else:
+                    future.set_result(decoded.data)
+
+        unsub = await strategy.channel.subscribe(find_response)
+        try:
+            await strategy.channel.publish(message)
+            result = await asyncio.wait_for(future, timeout=_TIMEOUT)
+        except TimeoutError as ex:
+            if strategy.health_manager:
+                await strategy.health_manager.on_timeout()
+            future.cancel()
+            raise RoborockException(f"Command timed out after {_TIMEOUT}s") from ex
+        finally:
+            unsub()
+        if strategy.health_manager:
+            await strategy.health_manager.on_success()
+        return result
+
+
 class V1Channel(Channel):
     """Unified V1 protocol channel with automatic MQTT/local connection handling.
 
@@ -66,23 +172,13 @@ class V1Channel(Channel):
         local_session: LocalSession,
         cache: Cache,
     ) -> None:
-        """Initialize the V1Channel.
-
-        Args:
-            mqtt_channel: MQTT channel for cloud communication
-            local_session: Factory that creates LocalChannels for a hostname.
-        """
+        """Initialize the V1Channel."""
         self._device_uid = device_uid
+        self._security_data = security_data
         self._mqtt_channel = mqtt_channel
-        self._mqtt_rpc_channel = create_mqtt_rpc_channel(mqtt_channel, security_data)
+        self._mqtt_health_manager = HealthManager(self._mqtt_channel.restart)
         self._local_session = local_session
         self._local_channel: LocalChannel | None = None
-        self._local_rpc_channel: V1RpcChannel | None = None
-        # Prefer local, fallback to MQTT
-        self._combined_rpc_channel = PickFirstAvailable(
-            [lambda: self._local_rpc_channel, lambda: self._mqtt_rpc_channel]
-        )
-        self._map_rpc_channel = create_map_rpc_channel(mqtt_channel, security_data)
         self._mqtt_unsub: Callable[[], None] | None = None
         self._local_unsub: Callable[[], None] | None = None
         self._callback: Callable[[RoborockMessage], None] | None = None
@@ -107,18 +203,60 @@ class V1Channel(Channel):
 
     @property
     def rpc_channel(self) -> V1RpcChannel:
-        """Return the combined RPC channel prefers local with a fallback to MQTT."""
-        return self._combined_rpc_channel
+        """Return the combined RPC channel that prefers local with a fallback to MQTT."""
+        strategies = []
+        if local_rpc_strategy := self._create_local_rpc_strategy():
+            strategies.append(local_rpc_strategy)
+        strategies.append(self._create_mqtt_rpc_strategy())
+        return RpcChannel(strategies)
 
     @property
     def mqtt_rpc_channel(self) -> V1RpcChannel:
-        """Return the MQTT RPC channel."""
-        return self._mqtt_rpc_channel
+        """Return the MQTT-only RPC channel."""
+        return RpcChannel([self._create_mqtt_rpc_strategy()])
 
     @property
     def map_rpc_channel(self) -> V1RpcChannel:
         """Return the map RPC channel used for fetching map content."""
-        return self._map_rpc_channel
+        decoder = create_map_response_decoder(security_data=self._security_data)
+        return RpcChannel([self._create_mqtt_rpc_strategy(decoder)])
+
+    def _create_local_rpc_strategy(self) -> RpcStrategy | None:
+        """Create the RPC strategy for local transport."""
+        if self._local_channel is None or not self.is_local_connected:
+            return None
+        return RpcStrategy(
+            name="local",
+            channel=self._local_channel,
+            encoder=self._local_encoder,
+            decoder=decode_rpc_response,
+        )
+
+    def _local_encoder(self, x: RequestMessage) -> RoborockMessage:
+        """Encode a request message for local transport.
+
+        This will read the current local channel's protocol version which
+        changes as the protocol version is discovered.
+        """
+        if self._local_channel is None:
+            raise ValueError("Local channel unavailable for encoding")
+        return x.encode_message(
+            RoborockMessageProtocol.GENERAL_REQUEST,
+            version=self._local_channel.protocol_version,
+        )
+
+    def _create_mqtt_rpc_strategy(self, decoder: Callable[[RoborockMessage], Any] = decode_rpc_response) -> RpcStrategy:
+        """Create the RPC strategy for MQTT transport with optional custom decoder."""
+        return RpcStrategy(
+            name="mqtt",
+            channel=self._mqtt_channel,
+            encoder=lambda x: x.encode_message(
+                RoborockMessageProtocol.RPC_REQUEST,
+                security_data=self._security_data,
+            ),
+            decoder=decoder,
+            health_manager=self._mqtt_health_manager,
+        )
 
     async def subscribe(self, callback: Callable[[RoborockMessage], None]) -> Callable[[], None]:
         """Subscribe to all messages from the device.
@@ -142,7 +280,7 @@ class V1Channel(Channel):
         # Make an initial, optimistic attempt to connect to local with the
         # cache. The cache information will be refreshed by the background task.
         try:
-            await self._local_connect(use_cache=True)
+            await self._local_connect(prefer_cache=True)
         except RoborockException as err:
             _LOGGER.warning("Could not establish local connection for device %s: %s", self._device_uid, err)
 
@@ -175,20 +313,24 @@ class V1Channel(Channel):
         self._callback = callback
         return unsub
 
-    async def _get_networking_info(self, *, use_cache: bool = True) -> NetworkInfo:
+    async def _get_networking_info(self, *, prefer_cache: bool = True) -> NetworkInfo:
         """Retrieve networking information for the device.
 
         This is a cloud only command used to get the local device's IP address.
         """
         cache_data = await self._cache.get()
-        if use_cache and cache_data.network_info and (network_info := cache_data.network_info.get(self._device_uid)):
+        if prefer_cache and cache_data.network_info and (network_info := cache_data.network_info.get(self._device_uid)):
             _LOGGER.debug("Using cached network info for device %s", self._device_uid)
             return network_info
         try:
-            network_info = await self._mqtt_rpc_channel.send_command(
+            network_info = await self.mqtt_rpc_channel.send_command(
                 RoborockCommand.GET_NETWORK_INFO, response_type=NetworkInfo
             )
         except RoborockException as e:
+            _LOGGER.debug("Error fetching network info for device %s", self._device_uid)
+            if cache_data.network_info and (network_info := cache_data.network_info.get(self._device_uid)):
+                _LOGGER.debug("Falling back to cached network info for device %s after error", self._device_uid)
+                return network_info
             raise RoborockException(f"Network info failed for device {self._device_uid}") from e
         _LOGGER.debug("Network info for device %s: %s", self._device_uid, network_info)
         self._last_network_info_refresh = datetime.datetime.now(datetime.UTC)
@@ -196,12 +338,12 @@ class V1Channel(Channel):
         await self._cache.set(cache_data)
         return network_info
 
-    async def _local_connect(self, *, use_cache: bool = True) -> None:
+    async def _local_connect(self, *, prefer_cache: bool = True) -> None:
         """Set up local connection if possible."""
         _LOGGER.debug(
-            "Attempting to connect to local channel for device %s (use_cache=%s)", self._device_uid, use_cache
+            "Attempting to connect to local channel for device %s (prefer_cache=%s)", self._device_uid, prefer_cache
         )
-        networking_info = await self._get_networking_info(use_cache=use_cache)
+        networking_info = await self._get_networking_info(prefer_cache=prefer_cache)
         host = networking_info.ip
         _LOGGER.debug("Connecting to local channel at %s", host)
         # Create a new local channel and connect
@@ -212,7 +354,6 @@ class V1Channel(Channel):
             raise RoborockException(f"Error connecting to local device {self._device_uid}: {e}") from e
         # Wire up the new channel
         self._local_channel = local_channel
-        self._local_rpc_channel = create_local_rpc_channel(self._local_channel)
         self._local_unsub = await self._local_channel.subscribe(self._on_local_message)
         _LOGGER.info("Successfully connected to local device %s", self._device_uid)
 
@@ -236,7 +377,7 @@ class V1Channel(Channel):
                     reconnect_backoff = min(reconnect_backoff * RECONNECT_MULTIPLIER, MAX_RECONNECT_INTERVAL)
 
                 use_cache = self._should_use_cache(local_connect_failures)
-                await self._local_connect(use_cache=use_cache)
+                await self._local_connect(prefer_cache=use_cache)
                 # Reset backoff and failures on success
                 reconnect_backoff = MIN_RECONNECT_INTERVAL
                 local_connect_failures = 0

{python_roborock-3.8.3 → python_roborock-3.8.5}/roborock/protocols/v1_protocol.py

@@ -12,9 +12,9 @@ import time
 from collections.abc import Callable
 from dataclasses import dataclass, field
 from enum import StrEnum
-from typing import Any
+from typing import Any, Protocol, TypeVar, overload
 
-from roborock.data import RRiot
+from roborock.data import RoborockBase, RRiot
 from roborock.exceptions import RoborockException, RoborockUnsupportedFeature
 from roborock.protocol import Utils
 from roborock.roborock_message import RoborockMessage, RoborockMessageProtocol
@@ -27,6 +27,7 @@ __all__ = [
     "SecurityData",
     "create_security_data",
     "decode_rpc_response",
+    "V1RpcChannel",
 ]
 
 CommandType = RoborockCommand | str
@@ -208,3 +209,35 @@ def create_map_response_decoder(security_data: SecurityData) -> Callable[[Roboro
         return MapResponse(request_id=request_id, data=decompressed)
 
     return _decode_map_response
+
+
+_T = TypeVar("_T", bound=RoborockBase)
+
+
+class V1RpcChannel(Protocol):
+    """Protocol for V1 RPC channels.
+
+    This is a wrapper around a raw channel that provides a high-level interface
+    for sending commands and receiving responses.
+    """
+
+    @overload
+    async def send_command(
+        self,
+        method: CommandType,
+        *,
+        params: ParamsType = None,
+    ) -> Any:
+        """Send a command and return a decoded response."""
+        ...
+
+    @overload
+    async def send_command(
+        self,
+        method: CommandType,
+        *,
+        response_type: type[_T],
+        params: ParamsType = None,
+    ) -> _T:
+        """Send a command and return a parsed response RoborockBase type."""
+        ...

python_roborock-3.8.3/roborock/devices/v1_rpc_channel.py

@@ -1,221 +0,0 @@
-"""V1 Rpc Channel for Roborock devices.
-
-This is a wrapper around the V1 channel that provides a higher level interface
-for sending typed commands and receiving typed responses. This also provides
-a simple interface for sending commands and receiving responses over both MQTT
-and local connections, preferring local when available.
-"""
-
-import asyncio
-import logging
-from collections.abc import Callable
-from typing import Any, Protocol, TypeVar, overload
-
-from roborock.data import RoborockBase
-from roborock.exceptions import RoborockException
-from roborock.mqtt.health_manager import HealthManager
-from roborock.protocols.v1_protocol import (
-    CommandType,
-    MapResponse,
-    ParamsType,
-    RequestMessage,
-    ResponseData,
-    ResponseMessage,
-    SecurityData,
-    create_map_response_decoder,
-    decode_rpc_response,
-)
-from roborock.roborock_message import RoborockMessage, RoborockMessageProtocol
-
-from .local_channel import LocalChannel
-from .mqtt_channel import MqttChannel
-
-_LOGGER = logging.getLogger(__name__)
-_TIMEOUT = 10.0
-
-
-_T = TypeVar("_T", bound=RoborockBase)
-_V = TypeVar("_V")
-
-
-class V1RpcChannel(Protocol):
-    """Protocol for V1 RPC channels.
-
-    This is a wrapper around a raw channel that provides a high-level interface
-    for sending commands and receiving responses.
-    """
-
-    @overload
-    async def send_command(
-        self,
-        method: CommandType,
-        *,
-        params: ParamsType = None,
-    ) -> Any:
-        """Send a command and return a decoded response."""
-        ...
-
-    @overload
-    async def send_command(
-        self,
-        method: CommandType,
-        *,
-        response_type: type[_T],
-        params: ParamsType = None,
-    ) -> _T:
-        """Send a command and return a parsed response RoborockBase type."""
-        ...
-
-
-class BaseV1RpcChannel(V1RpcChannel):
-    """Base implementation that provides the typed response logic."""
-
-    async def send_command(
-        self,
-        method: CommandType,
-        *,
-        response_type: type[_T] | None = None,
-        params: ParamsType = None,
-    ) -> _T | Any:
-        """Send a command and return either a decoded or parsed response."""
-        decoded_response = await self._send_raw_command(method, params=params)
-
-        if response_type is not None:
-            return response_type.from_dict(decoded_response)
-        return decoded_response
-
-    async def _send_raw_command(
-        self,
-        method: CommandType,
-        *,
-        params: ParamsType = None,
-    ) -> Any:
-        """Send a raw command and return the decoded response. Must be implemented by subclasses."""
-        raise NotImplementedError
-
-
-class PickFirstAvailable(BaseV1RpcChannel):
-    """A V1 RPC channel that tries multiple channels and picks the first that works."""
-
-    def __init__(
-        self,
-        channel_cbs: list[Callable[[], V1RpcChannel | None]],
-    ) -> None:
-        """Initialize the pick-first-available channel."""
-        self._channel_cbs = channel_cbs
-
-    async def _send_raw_command(
-        self,
-        method: CommandType,
-        *,
-        params: ParamsType = None,
-    ) -> Any:
-        """Send a command and return a parsed response RoborockBase type."""
-        for channel_cb in self._channel_cbs:
-            if channel := channel_cb():
-                return await channel.send_command(method, params=params)
-        raise RoborockException("No available connection to send command")
-
-
-class PayloadEncodedV1RpcChannel(BaseV1RpcChannel):
-    """Protocol for V1 channels that send encoded commands."""
-
-    def __init__(
-        self,
-        name: str,
-        channel: MqttChannel | LocalChannel,
-        payload_encoder: Callable[[RequestMessage], RoborockMessage],
-        decoder: Callable[[RoborockMessage], ResponseMessage] | Callable[[RoborockMessage], MapResponse | None],
-        health_manager: HealthManager | None = None,
-    ) -> None:
-        """Initialize the channel with a raw channel and an encoder function."""
-        self._name = name
-        self._channel = channel
-        self._payload_encoder = payload_encoder
-        self._decoder = decoder
-        self._health_manager = health_manager
-
-    async def _send_raw_command(
-        self,
-        method: CommandType,
-        *,
-        params: ParamsType = None,
-    ) -> ResponseData | bytes:
-        """Send a command and return a parsed response RoborockBase type."""
-        request_message = RequestMessage(method, params=params)
-        _LOGGER.debug(
-            "Sending command (%s, request_id=%s): %s, params=%s", self._name, request_message.request_id, method, params
-        )
-        message = self._payload_encoder(request_message)
-
-        future: asyncio.Future[ResponseData | bytes] = asyncio.Future()
-
-        def find_response(response_message: RoborockMessage) -> None:
-            try:
-                decoded = self._decoder(response_message)
-            except RoborockException as ex:
-                _LOGGER.debug("Exception while decoding message (%s): %s", response_message, ex)
-                return
-            if decoded is None:
-                return
-            _LOGGER.debug("Received response (%s, request_id=%s)", self._name, decoded.request_id)
-            if decoded.request_id == request_message.request_id:
-                if isinstance(decoded, ResponseMessage) and decoded.api_error:
-                    future.set_exception(decoded.api_error)
-                else:
-                    future.set_result(decoded.data)
-
-        unsub = await self._channel.subscribe(find_response)
-        try:
-            await self._channel.publish(message)
-            result = await asyncio.wait_for(future, timeout=_TIMEOUT)
-        except TimeoutError as ex:
-            if self._health_manager:
-                await self._health_manager.on_timeout()
-            future.cancel()
-            raise RoborockException(f"Command timed out after {_TIMEOUT}s") from ex
-        finally:
-            unsub()
-
-        if self._health_manager:
-            await self._health_manager.on_success()
-        return result
-
-
-def create_mqtt_rpc_channel(mqtt_channel: MqttChannel, security_data: SecurityData) -> V1RpcChannel:
-    """Create a V1 RPC channel using an MQTT channel."""
-    return PayloadEncodedV1RpcChannel(
-        "mqtt",
-        mqtt_channel,
-        lambda x: x.encode_message(RoborockMessageProtocol.RPC_REQUEST, security_data=security_data),
-        decode_rpc_response,
-        health_manager=HealthManager(mqtt_channel.restart),
-    )
-
-
-def create_local_rpc_channel(local_channel: LocalChannel) -> V1RpcChannel:
-    """Create a V1 RPC channel using a local channel."""
-    return PayloadEncodedV1RpcChannel(
-        "local",
-        local_channel,
-        lambda x: x.encode_message(RoborockMessageProtocol.GENERAL_REQUEST, version=local_channel.protocol_version),
-        decode_rpc_response,
-    )
-
-
-def create_map_rpc_channel(
-    mqtt_channel: MqttChannel,
-    security_data: SecurityData,
-) -> V1RpcChannel:
-    """Create a V1 RPC channel that fetches map data.
-
-    This will prefer local channels when available, falling back to MQTT
-    channels if not. If neither is available, an exception will be raised
-    when trying to send a command.
-    """
-    return PayloadEncodedV1RpcChannel(
-        "map",
-        mqtt_channel,
-        lambda x: x.encode_message(RoborockMessageProtocol.RPC_REQUEST, security_data=security_data),
-        create_map_response_decoder(security_data=security_data),
-    )