python-roborock 2.25.1__tar.gz → 2.27.0__tar.gz

{python_roborock-2.25.1 → python_roborock-2.27.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-roborock
-Version: 2.25.1
+Version: 2.27.0
 Summary: A package to control Roborock vacuums.
 Home-page: https://github.com/humbertogontijo/python-roborock
 License: GPL-3.0-only

{python_roborock-2.25.1 → python_roborock-2.27.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-roborock"
-version = "2.25.1"
+version = "2.27.0"
 description = "A package to control Roborock vacuums."
 authors = ["humbertogontijo <humbertogontijo@users.noreply.github.com>"]
 license = "GPL-3.0-only"

{python_roborock-2.25.1 → python_roborock-2.27.0}/roborock/cli.py

@@ -115,7 +115,16 @@ async def session(ctx, duration: int):
     devices = await device_manager.get_devices()
     click.echo(f"Discovered devices: {', '.join([device.name for device in devices])}")
 
-    click.echo("MQTT session started. Listening for messages...")
+    click.echo("MQTT session started. Querying devices...")
+    for device in devices:
+        try:
+            status = await device.get_status()
+        except RoborockException as e:
+            click.echo(f"Failed to get status for {device.name}: {e}")
+        else:
+            click.echo(f"Device {device.name} status: {status.as_dict()}")
+
+    click.echo("Listening for messages.")
     await asyncio.sleep(duration)
 
     # Close the device manager (this will close all devices and MQTT session)

{python_roborock-2.25.1 → python_roborock-2.27.0}/roborock/code_mappings.py

@@ -300,6 +300,17 @@ class RoborockFanSpeedS8MaxVUltra(RoborockFanPowerCode):
     smart_mode = 110
 
 
+class RoborockFanSpeedSaros10(RoborockFanPowerCode):
+    off = 105
+    quiet = 101
+    balanced = 102
+    turbo = 103
+    max = 104
+    custom = 106
+    max_plus = 108
+    smart_mode = 110
+
+
 class RoborockFanSpeedSaros10R(RoborockFanPowerCode):
     off = 105
     quiet = 101
@@ -379,6 +390,15 @@ class RoborockMopModeQRevoMaxV(RoborockMopModeCode):
     smart_mode = 306
 
 
+class RoborockMopModeSaros10(RoborockMopModeCode):
+    standard = 300
+    deep = 301
+    custom = 302
+    deep_plus = 303
+    fast = 304
+    smart_mode = 306
+
+
 class RoborockMopIntensityCode(RoborockEnum):
     """Describes the mop intensity of the vacuum cleaner."""
 
@@ -458,6 +478,16 @@ class RoborockMopIntensityS8MaxVUltra(RoborockMopIntensityCode):
     custom_water_flow = 207
 
 
+class RoborockMopIntensitySaros10(RoborockMopIntensityCode):
+    off = 200
+    mild = 201
+    standard = 202
+    intense = 203
+    extreme = 208
+    custom = 204
+    smart_mode = 209
+
+
 class RoborockMopIntensitySaros10R(RoborockMopIntensityCode):
     off = 200
     low = 201

{python_roborock-2.25.1 → python_roborock-2.27.0}/roborock/const.py

@@ -51,6 +51,7 @@ ROBOROCK_QREVO_S = "roborock.vacuum.a104"
 ROBOROCK_QREVO_PRO = "roborock.vacuum.a101"
 ROBOROCK_QREVO_MAXV = "roborock.vacuum.a87"
 ROBOROCK_SAROS_10R = "roborock.vacuum.a144"
+ROBOROCK_SAROS_10 = "roborock.vacuum.a147"
 
 ROBOROCK_DYAD_AIR = "roborock.wetdryvac.a107"
 ROBOROCK_DYAD_PRO_COMBO = "roborock.wetdryvac.a83"

{python_roborock-2.25.1 → python_roborock-2.27.0}/roborock/containers.py

@@ -28,6 +28,7 @@ from .code_mappings import (
     RoborockFanSpeedS7,
     RoborockFanSpeedS7MaxV,
     RoborockFanSpeedS8MaxVUltra,
+    RoborockFanSpeedSaros10,
     RoborockFanSpeedSaros10R,
     RoborockFinishReason,
     RoborockInCleaning,
@@ -41,6 +42,7 @@ from .code_mappings import (
     RoborockMopIntensityS6MaxV,
     RoborockMopIntensityS7,
     RoborockMopIntensityS8MaxVUltra,
+    RoborockMopIntensitySaros10,
     RoborockMopIntensitySaros10R,
     RoborockMopModeCode,
     RoborockMopModeQRevoCurv,
@@ -49,6 +51,7 @@ from .code_mappings import (
     RoborockMopModeS7,
     RoborockMopModeS8MaxVUltra,
     RoborockMopModeS8ProUltra,
+    RoborockMopModeSaros10,
     RoborockMopModeSaros10R,
     RoborockStartType,
     RoborockStateCode,
@@ -77,6 +80,7 @@ from .const import (
     ROBOROCK_S8,
     ROBOROCK_S8_MAXV_ULTRA,
     ROBOROCK_S8_PRO_ULTRA,
+    ROBOROCK_SAROS_10,
     ROBOROCK_SAROS_10R,
     SENSOR_DIRTY_REPLACE_TIME,
     SIDE_BRUSH_REPLACE_TIME,
@@ -689,6 +693,13 @@ class Saros10RStatus(Status):
     mop_mode: RoborockMopModeSaros10R | None = None
 
 
+@dataclass
+class Saros10Status(Status):
+    fan_power: RoborockFanSpeedSaros10 | None = None
+    water_box_mode: RoborockMopIntensitySaros10 | None = None
+    mop_mode: RoborockMopModeSaros10 | None = None
+
+
 ModelStatus: dict[str, type[Status]] = {
     ROBOROCK_S4_MAX: S4MaxStatus,
     ROBOROCK_S5_MAX: S5MaxStatus,
@@ -713,6 +724,7 @@ ModelStatus: dict[str, type[Status]] = {
     ROBOROCK_QREVO_PRO: P10Status,
     ROBOROCK_S8_MAXV_ULTRA: S8MaxvUltraStatus,
     ROBOROCK_SAROS_10R: Saros10RStatus,
+    ROBOROCK_SAROS_10: Saros10Status,
 }
 
 

{python_roborock-2.25.1 → python_roborock-2.27.0}/roborock/devices/device.py

@@ -9,10 +9,18 @@ import logging
 from collections.abc import Callable
 from functools import cached_property
 
-from roborock.containers import HomeDataDevice, HomeDataProduct, UserData
+from roborock.containers import (
+    HomeDataDevice,
+    HomeDataProduct,
+    ModelStatus,
+    S7MaxVStatus,
+    Status,
+    UserData,
+)
 from roborock.roborock_message import RoborockMessage
+from roborock.roborock_typing import RoborockCommand
 
-from .mqtt_channel import MqttChannel
+from .v1_channel import V1Channel
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -38,19 +46,18 @@ class RoborockDevice:
         user_data: UserData,
         device_info: HomeDataDevice,
         product_info: HomeDataProduct,
-        mqtt_channel: MqttChannel,
+        v1_channel: V1Channel,
     ) -> None:
         """Initialize the RoborockDevice.
 
-        The device takes ownership of the MQTT channel for communication with the device.
-        Use `connect()` to establish the connection, which will set up the MQTT channel
-        for receiving messages from the device. Use `close()` to unsubscribe from the MQTT
-        channel.
+        The device takes ownership of the V1 channel for communication with the device.
+        Use `connect()` to establish the connection, which will set up the appropriate
+        protocol channel. Use `close()` to clean up all connections.
         """
         self._user_data = user_data
         self._device_info = device_info
         self._product_info = product_info
-        self._mqtt_channel = mqtt_channel
+        self._v1_channel = v1_channel
         self._unsub: Callable[[], None] | None = None
 
     @property
@@ -82,27 +89,32 @@ class RoborockDevice:
         )
         return DeviceVersion.UNKNOWN
 
-    async def connect(self) -> None:
-        """Connect to the device using MQTT.
+    @property
+    def is_connected(self) -> bool:
+        """Return whether the device is connected."""
+        return self._v1_channel.is_mqtt_connected or self._v1_channel.is_local_connected
 
-        This method will set up the MQTT channel for communication with the device.
-        """
+    async def connect(self) -> None:
+        """Connect to the device using the appropriate protocol channel."""
         if self._unsub:
             raise ValueError("Already connected to the device")
-        self._unsub = await self._mqtt_channel.subscribe(self._on_mqtt_message)
+        self._unsub = await self._v1_channel.subscribe(self._on_message)
+        _LOGGER.info("Connected to V1 device %s", self.name)
 
     async def close(self) -> None:
-        """Close the MQTT connection to the device.
-
-        This method will unsubscribe from the MQTT channel and clean up resources.
-        """
+        """Close all connections to the device."""
         if self._unsub:
             self._unsub()
             self._unsub = None
 
-    def _on_mqtt_message(self, message: RoborockMessage) -> None:
-        """Handle incoming MQTT messages from the device.
+    def _on_message(self, message: RoborockMessage) -> None:
+        """Handle incoming messages from the device."""
+        _LOGGER.debug("Received message from device: %s", message)
+
+    async def get_status(self) -> Status:
+        """Get the current status of the device.
 
-        This method should be overridden in subclasses to handle specific device messages.
+        This is a placeholder command and will likely be changed/moved in the future.
         """
-        _LOGGER.debug("Received message from device %s: %s", self.duid, message)
+        status_type: type[Status] = ModelStatus.get(self._product_info.model, S7MaxVStatus)
+        return await self._v1_channel.send_decoded_command(RoborockCommand.GET_STATUS, response_type=status_type)

{python_roborock-2.25.1 → python_roborock-2.27.0}/roborock/devices/device_manager.py

@@ -10,13 +10,13 @@ from roborock.containers import (
     HomeDataProduct,
     UserData,
 )
-from roborock.devices.device import RoborockDevice
+from roborock.devices.device import DeviceVersion, RoborockDevice
 from roborock.mqtt.roborock_session import create_mqtt_session
 from roborock.mqtt.session import MqttSession
 from roborock.protocol import create_mqtt_params
 from roborock.web_api import RoborockApiClient
 
-from .mqtt_channel import MqttChannel
+from .v1_channel import create_v1_channel
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -114,8 +114,15 @@ async def create_device_manager(user_data: UserData, home_data_api: HomeDataApi)
     mqtt_session = await create_mqtt_session(mqtt_params)
 
     def device_creator(device: HomeDataDevice, product: HomeDataProduct) -> RoborockDevice:
-        mqtt_channel = MqttChannel(mqtt_session, device.duid, device.local_key, user_data.rriot, mqtt_params)
-        return RoborockDevice(user_data, device, product, mqtt_channel)
+        # Check device version and only support V1 for now
+        if device.pv != DeviceVersion.V1.value:
+            raise NotImplementedError(
+                f"Device {device.name} has version {device.pv}, but only V1 devices "
+                f"are supported through the unified interface."
+            )
+        # Create V1 channel that handles both MQTT and local connections
+        v1_channel = create_v1_channel(user_data, mqtt_params, mqtt_session, device)
+        return RoborockDevice(user_data, device, product, v1_channel)
 
     manager = DeviceManager(home_data_api, device_creator, mqtt_session=mqtt_session)
     await manager.discover_devices()

{python_roborock-2.25.1 → python_roborock-2.27.0}/roborock/devices/local_channel.py

@@ -64,7 +64,7 @@ class LocalChannel:
         except OSError as e:
             raise RoborockConnectionException(f"Failed to connect to {self._host}:{_PORT}") from e
 
-    async def close(self) -> None:
+    def close(self) -> None:
         """Disconnect from the device."""
         if self._transport:
             self._transport.close()
@@ -144,3 +144,25 @@ class LocalChannel:
             async with self._queue_lock:
                 self._waiting_queue.pop(request_id, None)
             raise
+
+
+# This module provides a factory function to create LocalChannel instances.
+#
+# TODO: Make a separate LocalSession and use it to manage retries with the host,
+# similar to how MqttSession works. For now this is a simple factory function
+# for creating channels.
+LocalSession = Callable[[str], LocalChannel]
+
+
+def create_local_session(local_key: str) -> LocalSession:
+    """Creates a local session which can create local channels.
+
+    This plays a role similar to the MqttSession but is really just a factory
+    for creating LocalChannel instances with the same local key.
+    """
+
+    def create_local_channel(host: str) -> LocalChannel:
+        """Create a LocalChannel instance for the given host."""
+        return LocalChannel(host, local_key)
+
+    return create_local_channel

python_roborock-2.27.0/roborock/devices/v1_channel.py

@@ -0,0 +1,212 @@
+"""V1 Channel for Roborock devices.
+
+This module provides a unified channel interface for V1 protocol devices,
+handling both MQTT and local connections with automatic fallback.
+"""
+
+import logging
+from collections.abc import Callable
+from typing import Any, TypeVar
+
+from roborock.containers import HomeDataDevice, NetworkInfo, RoborockBase, UserData
+from roborock.exceptions import RoborockException
+from roborock.mqtt.session import MqttParams, MqttSession
+from roborock.protocols.v1_protocol import (
+    CommandType,
+    ParamsType,
+    SecurityData,
+    create_mqtt_payload_encoder,
+    create_security_data,
+    decode_rpc_response,
+    encode_local_payload,
+)
+from roborock.roborock_message import RoborockMessage
+from roborock.roborock_typing import RoborockCommand
+
+from .local_channel import LocalChannel, LocalSession, create_local_session
+from .mqtt_channel import MqttChannel
+
+_LOGGER = logging.getLogger(__name__)
+
+__all__ = [
+    "V1Channel",
+]
+
+_T = TypeVar("_T", bound=RoborockBase)
+
+
+class V1Channel:
+    """Unified V1 protocol channel with automatic MQTT/local connection handling.
+
+    This channel abstracts away the complexity of choosing between MQTT and local
+    connections, and provides high-level V1 protocol methods. It automatically
+    handles connection setup, fallback logic, and protocol encoding/decoding.
+    """
+
+    def __init__(
+        self,
+        device_uid: str,
+        security_data: SecurityData,
+        mqtt_channel: MqttChannel,
+        local_session: LocalSession,
+    ) -> None:
+        """Initialize the V1Channel.
+
+        Args:
+            mqtt_channel: MQTT channel for cloud communication
+            local_session: Factory that creates LocalChannels for a hostname.
+        """
+        self._device_uid = device_uid
+        self._mqtt_channel = mqtt_channel
+        self._mqtt_payload_encoder = create_mqtt_payload_encoder(security_data)
+        self._local_session = local_session
+        self._local_channel: LocalChannel | None = None
+        self._mqtt_unsub: Callable[[], None] | None = None
+        self._local_unsub: Callable[[], None] | None = None
+        self._callback: Callable[[RoborockMessage], None] | None = None
+        self._networking_info: NetworkInfo | None = None
+
+    @property
+    def is_local_connected(self) -> bool:
+        """Return whether local connection is available."""
+        return self._local_unsub is not None
+
+    @property
+    def is_mqtt_connected(self) -> bool:
+        """Return whether MQTT connection is available."""
+        return self._mqtt_unsub is not None
+
+    async def subscribe(self, callback: Callable[[RoborockMessage], None]) -> Callable[[], None]:
+        """Subscribe to all messages from the device.
+
+        This will establish MQTT connection first, and also attempt to set up
+        local connection if possible. Any failures to subscribe to MQTT will raise
+        a RoborockException. A local connection failure will not raise an exception,
+        since the local connection is optional.
+        """
+
+        if self._mqtt_unsub:
+            raise ValueError("Already connected to the device")
+        self._callback = callback
+
+        # First establish MQTT connection
+        self._mqtt_unsub = await self._mqtt_channel.subscribe(self._on_mqtt_message)
+        _LOGGER.debug("V1Channel connected to device %s via MQTT", self._device_uid)
+
+        # Try to establish an optional local connection as well.
+        try:
+            self._local_unsub = await self._local_connect()
+        except RoborockException as err:
+            _LOGGER.warning("Could not establish local connection for device %s: %s", self._device_uid, err)
+        else:
+            _LOGGER.debug("Local connection established for device %s", self._device_uid)
+
+        def unsub() -> None:
+            """Unsubscribe from all messages."""
+            if self._mqtt_unsub:
+                self._mqtt_unsub()
+                self._mqtt_unsub = None
+            if self._local_unsub:
+                self._local_unsub()
+                self._local_unsub = None
+            _LOGGER.debug("Unsubscribed from device %s", self._device_uid)
+
+        return unsub
+
+    async def _get_networking_info(self) -> NetworkInfo:
+        """Retrieve networking information for the device.
+
+        This is a cloud only command used to get the local device's IP address.
+        """
+        try:
+            return await self._send_mqtt_decoded_command(RoborockCommand.GET_NETWORK_INFO, response_type=NetworkInfo)
+        except RoborockException as e:
+            raise RoborockException(f"Network info failed for device {self._device_uid}") from e
+
+    async def _local_connect(self) -> Callable[[], None]:
+        """Set up local connection if possible."""
+        _LOGGER.debug("Attempting to connect to local channel for device %s", self._device_uid)
+        if self._networking_info is None:
+            self._networking_info = await self._get_networking_info()
+        host = self._networking_info.ip
+        _LOGGER.debug("Connecting to local channel at %s", host)
+        self._local_channel = self._local_session(host)
+        try:
+            await self._local_channel.connect()
+        except RoborockException as e:
+            self._local_channel = None
+            raise RoborockException(f"Error connecting to local device {self._device_uid}: {e}") from e
+
+        return await self._local_channel.subscribe(self._on_local_message)
+
+    async def send_decoded_command(
+        self,
+        method: CommandType,
+        *,
+        response_type: type[_T],
+        params: ParamsType = None,
+    ) -> _T:
+        """Send a command using the best available transport.
+
+        Will prefer local connection if available, falling back to MQTT.
+        """
+        connection = "local" if self.is_local_connected else "mqtt"
+        _LOGGER.debug("Sending command (%s): %s, params=%s", connection, method, params)
+        if self._local_channel:
+            return await self._send_local_decoded_command(method, response_type=response_type, params=params)
+        return await self._send_mqtt_decoded_command(method, response_type=response_type, params=params)
+
+    async def _send_mqtt_raw_command(self, method: CommandType, params: ParamsType | None = None) -> dict[str, Any]:
+        """Send a raw command and return a raw unparsed response."""
+        message = self._mqtt_payload_encoder(method, params)
+        _LOGGER.debug("Sending MQTT message for device %s: %s", self._device_uid, message)
+        response = await self._mqtt_channel.send_command(message)
+        return decode_rpc_response(response)
+
+    async def _send_mqtt_decoded_command(
+        self, method: CommandType, *, response_type: type[_T], params: ParamsType | None = None
+    ) -> _T:
+        """Send a command over MQTT and decode the response."""
+        decoded_response = await self._send_mqtt_raw_command(method, params)
+        return response_type.from_dict(decoded_response)
+
+    async def _send_local_raw_command(self, method: CommandType, params: ParamsType | None = None) -> dict[str, Any]:
+        """Send a raw command over local connection."""
+        if not self._local_channel:
+            raise RoborockException("Local channel is not connected")
+
+        message = encode_local_payload(method, params)
+        _LOGGER.debug("Sending local message for device %s: %s", self._device_uid, message)
+        response = await self._local_channel.send_command(message)
+        return decode_rpc_response(response)
+
+    async def _send_local_decoded_command(
+        self, method: CommandType, *, response_type: type[_T], params: ParamsType | None = None
+    ) -> _T:
+        """Send a command over local connection and decode the response."""
+        if not self._local_channel:
+            raise RoborockException("Local channel is not connected")
+        decoded_response = await self._send_local_raw_command(method, params)
+        return response_type.from_dict(decoded_response)
+
+    def _on_mqtt_message(self, message: RoborockMessage) -> None:
+        """Handle incoming MQTT messages."""
+        _LOGGER.debug("V1Channel received MQTT message from device %s: %s", self._device_uid, message)
+        if self._callback:
+            self._callback(message)
+
+    def _on_local_message(self, message: RoborockMessage) -> None:
+        """Handle incoming local messages."""
+        _LOGGER.debug("V1Channel received local message from device %s: %s", self._device_uid, message)
+        if self._callback:
+            self._callback(message)
+
+
+def create_v1_channel(
+    user_data: UserData, mqtt_params: MqttParams, mqtt_session: MqttSession, device: HomeDataDevice
+) -> V1Channel:
+    """Create a V1Channel for the given device."""
+    security_data = create_security_data(user_data.rriot)
+    mqtt_channel = MqttChannel(mqtt_session, device.duid, device.local_key, user_data.rriot, mqtt_params)
+    local_session = create_local_session(device.local_key)
+    return V1Channel(device.duid, security_data, mqtt_channel, local_session=local_session)

python_roborock-2.27.0/roborock/protocols/a01_protocol.py

@@ -0,0 +1,54 @@
+"""Roborock A01 Protocol encoding and decoding."""
+
+import json
+import logging
+from typing import Any
+
+from Crypto.Cipher import AES
+from Crypto.Util.Padding import pad, unpad
+
+from roborock.exceptions import RoborockException
+from roborock.roborock_message import (
+    RoborockDyadDataProtocol,
+    RoborockMessage,
+    RoborockMessageProtocol,
+    RoborockZeoProtocol,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+A01_VERSION = b"A01"
+
+
+def encode_mqtt_payload(data: dict[RoborockDyadDataProtocol | RoborockZeoProtocol, Any]) -> RoborockMessage:
+    """Encode payload for A01 commands over MQTT."""
+    dps_data = {"dps": data}
+    payload = pad(json.dumps(dps_data).encode("utf-8"), AES.block_size)
+    return RoborockMessage(
+        protocol=RoborockMessageProtocol.RPC_REQUEST,
+        version=A01_VERSION,
+        payload=payload,
+    )
+
+
+def decode_rpc_response(message: RoborockMessage) -> dict[int, Any]:
+    """Decode a V1 RPC_RESPONSE message."""
+    if not message.payload:
+        raise RoborockException("Invalid A01 message format: missing payload")
+    try:
+        unpadded = unpad(message.payload, AES.block_size)
+    except ValueError as err:
+        raise RoborockException(f"Unable to unpad A01 payload: {err}")
+
+    try:
+        payload = json.loads(unpadded.decode())
+    except (json.JSONDecodeError, TypeError) as e:
+        raise RoborockException(f"Invalid A01 message payload: {e} for {message.payload!r}") from e
+
+    datapoints = payload.get("dps", {})
+    if not isinstance(datapoints, dict):
+        raise RoborockException(f"Invalid A01 message format: 'dps' should be a dictionary for {message.payload!r}")
+    try:
+        return {int(key): value for key, value in datapoints.items()}
+    except ValueError:
+        raise RoborockException(f"Invalid A01 message format: 'dps' key should be an integer for {message.payload!r}")

{python_roborock-2.25.1 → python_roborock-2.27.0}/roborock/protocols/v1_protocol.py

@@ -2,17 +2,33 @@
 
 from __future__ import annotations
 
+import base64
 import json
+import logging
 import math
+import secrets
 import time
 from collections.abc import Callable
 from dataclasses import dataclass, field
 from typing import Any
 
+from roborock.containers import RRiot
+from roborock.exceptions import RoborockException
+from roborock.protocol import Utils
 from roborock.roborock_message import MessageRetry, RoborockMessage, RoborockMessageProtocol
 from roborock.roborock_typing import RoborockCommand
 from roborock.util import get_next_int
 
+_LOGGER = logging.getLogger(__name__)
+
+__all__ = [
+    "SecurityData",
+    "create_security_data",
+    "create_mqtt_payload_encoder",
+    "encode_local_payload",
+    "decode_rpc_response",
+]
+
 CommandType = RoborockCommand | str
 ParamsType = list | dict | int | None
 
@@ -29,6 +45,13 @@ class SecurityData:
         return {"security": {"endpoint": self.endpoint, "nonce": self.nonce.hex().lower()}}
 
 
+def create_security_data(rriot: RRiot) -> SecurityData:
+    """Create a SecurityData instance for the given endpoint and nonce."""
+    nonce = secrets.token_bytes(16)
+    endpoint = base64.b64encode(Utils.md5(rriot.k.encode())[8:14]).decode()
+    return SecurityData(endpoint=endpoint, nonce=nonce)
+
+
 @dataclass
 class RequestMessage:
     """Data structure for v1 RoborockMessage payloads."""
@@ -89,3 +112,38 @@ def encode_local_payload(method: CommandType, params: ParamsType) -> RoborockMes
         payload=payload,
         message_retry=message_retry,
     )
+
+
+def decode_rpc_response(message: RoborockMessage) -> dict[str, Any]:
+    """Decode a V1 RPC_RESPONSE message."""
+    if not message.payload:
+        raise RoborockException("Invalid V1 message format: missing payload")
+    try:
+        payload = json.loads(message.payload.decode())
+    except (json.JSONDecodeError, TypeError) as e:
+        raise RoborockException(f"Invalid V1 message payload: {e} for {message.payload!r}") from e
+
+    _LOGGER.debug("Decoded V1 message payload: %s", payload)
+    datapoints = payload.get("dps", {})
+    if not isinstance(datapoints, dict):
+        raise RoborockException(f"Invalid V1 message format: 'dps' should be a dictionary for {message.payload!r}")
+
+    if not (data_point := datapoints.get("102")):
+        raise RoborockException("Invalid V1 message format: missing '102' data point")
+
+    try:
+        data_point_response = json.loads(data_point)
+    except (json.JSONDecodeError, TypeError) as e:
+        raise RoborockException(f"Invalid V1 message data point '102': {e} for {message.payload!r}") from e
+
+    if error := data_point_response.get("error"):
+        raise RoborockException(f"Error in message: {error}")
+
+    if not (result := data_point_response.get("result")):
+        raise RoborockException(f"Invalid V1 message format: missing 'result' in data point for {message.payload!r}")
+    _LOGGER.debug("Decoded V1 message result: %s", result)
+    if isinstance(result, list) and result:
+        result = result[0]
+    if not isinstance(result, dict):
+        raise RoborockException(f"Invalid V1 message format: 'result' should be a dictionary for {message.payload!r}")
+    return result

python_roborock-2.27.0/roborock/version_a01_apis/roborock_client_a01.py

@@ -0,0 +1,159 @@
+import logging
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+from datetime import time
+from typing import Any
+
+from roborock import DeviceData
+from roborock.api import RoborockClient
+from roborock.code_mappings import (
+    DyadBrushSpeed,
+    DyadCleanMode,
+    DyadError,
+    DyadSelfCleanLevel,
+    DyadSelfCleanMode,
+    DyadSuction,
+    DyadWarmLevel,
+    DyadWaterLevel,
+    RoborockDyadStateCode,
+    ZeoDetergentType,
+    ZeoDryingMode,
+    ZeoError,
+    ZeoMode,
+    ZeoProgram,
+    ZeoRinse,
+    ZeoSoftenerType,
+    ZeoSpin,
+    ZeoState,
+    ZeoTemperature,
+)
+from roborock.containers import DyadProductInfo, DyadSndState, RoborockCategory
+from roborock.exceptions import RoborockException
+from roborock.protocols.a01_protocol import decode_rpc_response
+from roborock.roborock_message import (
+    RoborockDyadDataProtocol,
+    RoborockMessage,
+    RoborockMessageProtocol,
+    RoborockZeoProtocol,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+DYAD_PROTOCOL_ENTRIES: dict[RoborockDyadDataProtocol, Callable] = {
+    RoborockDyadDataProtocol.STATUS: lambda val: RoborockDyadStateCode(val).name,
+    RoborockDyadDataProtocol.SELF_CLEAN_MODE: lambda val: DyadSelfCleanMode(val).name,
+    RoborockDyadDataProtocol.SELF_CLEAN_LEVEL: lambda val: DyadSelfCleanLevel(val).name,
+    RoborockDyadDataProtocol.WARM_LEVEL: lambda val: DyadWarmLevel(val).name,
+    RoborockDyadDataProtocol.CLEAN_MODE: lambda val: DyadCleanMode(val).name,
+    RoborockDyadDataProtocol.SUCTION: lambda val: DyadSuction(val).name,
+    RoborockDyadDataProtocol.WATER_LEVEL: lambda val: DyadWaterLevel(val).name,
+    RoborockDyadDataProtocol.BRUSH_SPEED: lambda val: DyadBrushSpeed(val).name,
+    RoborockDyadDataProtocol.POWER: lambda val: int(val),
+    RoborockDyadDataProtocol.AUTO_DRY: lambda val: bool(val),
+    RoborockDyadDataProtocol.MESH_LEFT: lambda val: int(360000 - val * 60),
+    RoborockDyadDataProtocol.BRUSH_LEFT: lambda val: int(360000 - val * 60),
+    RoborockDyadDataProtocol.ERROR: lambda val: DyadError(val).name,
+    RoborockDyadDataProtocol.VOLUME_SET: lambda val: int(val),
+    RoborockDyadDataProtocol.STAND_LOCK_AUTO_RUN: lambda val: bool(val),
+    RoborockDyadDataProtocol.AUTO_DRY_MODE: lambda val: bool(val),
+    RoborockDyadDataProtocol.SILENT_DRY_DURATION: lambda val: int(val),  # in minutes
+    RoborockDyadDataProtocol.SILENT_MODE: lambda val: bool(val),
+    RoborockDyadDataProtocol.SILENT_MODE_START_TIME: lambda val: time(
+        hour=int(val / 60), minute=val % 60
+    ),  # in minutes since 00:00
+    RoborockDyadDataProtocol.SILENT_MODE_END_TIME: lambda val: time(
+        hour=int(val / 60), minute=val % 60
+    ),  # in minutes since 00:00
+    RoborockDyadDataProtocol.RECENT_RUN_TIME: lambda val: [
+        int(v) for v in val.split(",")
+    ],  # minutes of cleaning in past few days.
+    RoborockDyadDataProtocol.TOTAL_RUN_TIME: lambda val: int(val),
+    RoborockDyadDataProtocol.SND_STATE: lambda val: DyadSndState.from_dict(val),
+    RoborockDyadDataProtocol.PRODUCT_INFO: lambda val: DyadProductInfo.from_dict(val),
+}
+
+ZEO_PROTOCOL_ENTRIES: dict[RoborockZeoProtocol, Callable] = {
+    # ro
+    RoborockZeoProtocol.STATE: lambda val: ZeoState(val).name,
+    RoborockZeoProtocol.COUNTDOWN: lambda val: int(val),
+    RoborockZeoProtocol.WASHING_LEFT: lambda val: int(val),
+    RoborockZeoProtocol.ERROR: lambda val: ZeoError(val).name,
+    RoborockZeoProtocol.TIMES_AFTER_CLEAN: lambda val: int(val),
+    RoborockZeoProtocol.DETERGENT_EMPTY: lambda val: bool(val),
+    RoborockZeoProtocol.SOFTENER_EMPTY: lambda val: bool(val),
+    # rw
+    RoborockZeoProtocol.MODE: lambda val: ZeoMode(val).name,
+    RoborockZeoProtocol.PROGRAM: lambda val: ZeoProgram(val).name,
+    RoborockZeoProtocol.TEMP: lambda val: ZeoTemperature(val).name,
+    RoborockZeoProtocol.RINSE_TIMES: lambda val: ZeoRinse(val).name,
+    RoborockZeoProtocol.SPIN_LEVEL: lambda val: ZeoSpin(val).name,
+    RoborockZeoProtocol.DRYING_MODE: lambda val: ZeoDryingMode(val).name,
+    RoborockZeoProtocol.DETERGENT_TYPE: lambda val: ZeoDetergentType(val).name,
+    RoborockZeoProtocol.SOFTENER_TYPE: lambda val: ZeoSoftenerType(val).name,
+    RoborockZeoProtocol.SOUND_SET: lambda val: bool(val),
+}
+
+
+def convert_dyad_value(protocol: int, value: Any) -> Any:
+    """Convert a dyad protocol value to its corresponding type."""
+    protocol_value = RoborockDyadDataProtocol(protocol)
+    if (converter := DYAD_PROTOCOL_ENTRIES.get(protocol_value)) is not None:
+        return converter(value)
+    return None
+
+
+def convert_zeo_value(protocol: int, value: Any) -> Any:
+    """Convert a zeo protocol value to its corresponding type."""
+    protocol_value = RoborockZeoProtocol(protocol)
+    if (converter := ZEO_PROTOCOL_ENTRIES.get(protocol_value)) is not None:
+        return converter(value)
+    return None
+
+
+class RoborockClientA01(RoborockClient, ABC):
+    """Roborock client base class for A01 devices."""
+
+    value_converter: Callable[[int, Any], Any] | None = None
+
+    def __init__(self, device_info: DeviceData, category: RoborockCategory):
+        """Initialize the Roborock client."""
+        super().__init__(device_info)
+        if category == RoborockCategory.WET_DRY_VAC:
+            self.value_converter = convert_dyad_value
+        elif category == RoborockCategory.WASHING_MACHINE:
+            self.value_converter = convert_zeo_value
+        else:
+            _LOGGER.debug("Device category %s is not (yet) supported", category)
+            self.value_converter = None
+
+    def on_message_received(self, messages: list[RoborockMessage]) -> None:
+        if self.value_converter is None:
+            return
+        for message in messages:
+            protocol = message.protocol
+            if message.payload and protocol in [
+                RoborockMessageProtocol.RPC_RESPONSE,
+                RoborockMessageProtocol.GENERAL_REQUEST,
+            ]:
+                try:
+                    data_points = decode_rpc_response(message)
+                except RoborockException as err:
+                    self._logger.debug("Failed to decode message: %s", err)
+                    continue
+                for data_point_number, data_point in data_points.items():
+                    self._logger.debug("received msg with dps, protocol: %s, %s", data_point_number, protocol)
+                    if converted_response := self.value_converter(data_point_number, data_point):
+                        queue = self._waiting_queue.get(int(data_point_number))
+                        if queue and queue.protocol == protocol:
+                            queue.set_result(converted_response)
+                    else:
+                        self._logger.debug(
+                            "Received unknown data point %s for protocol %s, ignoring", data_point_number, protocol
+                        )
+
+    @abstractmethod
+    async def update_values(
+        self, dyad_data_protocols: list[RoborockDyadDataProtocol | RoborockZeoProtocol]
+    ) -> dict[RoborockDyadDataProtocol | RoborockZeoProtocol, Any]:
+        """This should handle updating for each given protocol."""

{python_roborock-2.25.1 → python_roborock-2.27.0}/roborock/version_a01_apis/roborock_mqtt_client_a01.py

@@ -4,11 +4,12 @@ import logging
 import typing
 
 from Crypto.Cipher import AES
-from Crypto.Util.Padding import pad, unpad
+from Crypto.Util.Padding import unpad
 
 from roborock.cloud_api import RoborockMqttClient
 from roborock.containers import DeviceData, RoborockCategory, UserData
 from roborock.exceptions import RoborockException
+from roborock.protocols.a01_protocol import encode_mqtt_payload
 from roborock.roborock_message import (
     RoborockDyadDataProtocol,
     RoborockMessage,
@@ -43,7 +44,6 @@ class RoborockMqttClientA01(RoborockMqttClient, RoborockClientA01):
         response_protocol = RoborockMessageProtocol.RPC_RESPONSE
 
         m = self._encoder(roborock_message)
-        # self._logger.debug(f"id={request_id} Requesting method {method} with {params}")
         payload = json.loads(unpad(roborock_message.payload, AES.block_size))
         futures = []
         if "10000" in payload["dps"]:
@@ -56,7 +56,6 @@ class RoborockMqttClientA01(RoborockMqttClient, RoborockClientA01):
             for i, dps in enumerate(json.loads(payload["dps"]["10000"])):
                 response = responses[i]
                 if isinstance(response, BaseException):
-                    self._logger.warning("Timed out get req for %s after %s s", dps, self.queue_timeout)
                     dps_responses[dps] = None
                 else:
                     dps_responses[dps] = response
@@ -65,24 +64,14 @@ class RoborockMqttClientA01(RoborockMqttClient, RoborockClientA01):
     async def update_values(
         self, dyad_data_protocols: list[RoborockDyadDataProtocol | RoborockZeoProtocol]
     ) -> dict[RoborockDyadDataProtocol | RoborockZeoProtocol, typing.Any]:
-        payload = {"dps": {RoborockDyadDataProtocol.ID_QUERY: str([int(protocol) for protocol in dyad_data_protocols])}}
-        return await self.send_message(
-            RoborockMessage(
-                protocol=RoborockMessageProtocol.RPC_REQUEST,
-                version=b"A01",
-                payload=pad(json.dumps(payload).encode("utf-8"), AES.block_size),
-            )
+        message = encode_mqtt_payload(
+            {RoborockDyadDataProtocol.ID_QUERY: str([int(protocol) for protocol in dyad_data_protocols])}
         )
+        return await self.send_message(message)
 
     async def set_value(
         self, protocol: RoborockDyadDataProtocol | RoborockZeoProtocol, value: typing.Any
     ) -> dict[int, typing.Any]:
         """Set a value for a specific protocol on the A01 device."""
-        payload = {"dps": {int(protocol): value}}
-        return await self.send_message(
-            RoborockMessage(
-                protocol=RoborockMessageProtocol.RPC_REQUEST,
-                version=b"A01",
-                payload=pad(json.dumps(payload).encode("utf-8"), AES.block_size),
-            )
-        )
+        message = encode_mqtt_payload({protocol: value})
+        return await self.send_message(message)

python_roborock-2.25.1/roborock/version_a01_apis/roborock_client_a01.py

@@ -1,153 +0,0 @@
-import dataclasses
-import json
-import logging
-import typing
-from abc import ABC, abstractmethod
-from collections.abc import Callable
-from datetime import time
-
-from Crypto.Cipher import AES
-from Crypto.Util.Padding import unpad
-
-from roborock import DeviceData
-from roborock.api import RoborockClient
-from roborock.code_mappings import (
-    DyadBrushSpeed,
-    DyadCleanMode,
-    DyadError,
-    DyadSelfCleanLevel,
-    DyadSelfCleanMode,
-    DyadSuction,
-    DyadWarmLevel,
-    DyadWaterLevel,
-    RoborockDyadStateCode,
-    ZeoDetergentType,
-    ZeoDryingMode,
-    ZeoError,
-    ZeoMode,
-    ZeoProgram,
-    ZeoRinse,
-    ZeoSoftenerType,
-    ZeoSpin,
-    ZeoState,
-    ZeoTemperature,
-)
-from roborock.containers import DyadProductInfo, DyadSndState, RoborockCategory
-from roborock.roborock_message import (
-    RoborockDyadDataProtocol,
-    RoborockMessage,
-    RoborockMessageProtocol,
-    RoborockZeoProtocol,
-)
-
-_LOGGER = logging.getLogger(__name__)
-
-
-@dataclasses.dataclass
-class A01ProtocolCacheEntry:
-    post_process_fn: Callable
-    value: typing.Any | None = None
-
-
-# Right now this cache is not active, it was too much complexity for the initial addition of dyad.
-protocol_entries = {
-    RoborockDyadDataProtocol.STATUS: A01ProtocolCacheEntry(lambda val: RoborockDyadStateCode(val).name),
-    RoborockDyadDataProtocol.SELF_CLEAN_MODE: A01ProtocolCacheEntry(lambda val: DyadSelfCleanMode(val).name),
-    RoborockDyadDataProtocol.SELF_CLEAN_LEVEL: A01ProtocolCacheEntry(lambda val: DyadSelfCleanLevel(val).name),
-    RoborockDyadDataProtocol.WARM_LEVEL: A01ProtocolCacheEntry(lambda val: DyadWarmLevel(val).name),
-    RoborockDyadDataProtocol.CLEAN_MODE: A01ProtocolCacheEntry(lambda val: DyadCleanMode(val).name),
-    RoborockDyadDataProtocol.SUCTION: A01ProtocolCacheEntry(lambda val: DyadSuction(val).name),
-    RoborockDyadDataProtocol.WATER_LEVEL: A01ProtocolCacheEntry(lambda val: DyadWaterLevel(val).name),
-    RoborockDyadDataProtocol.BRUSH_SPEED: A01ProtocolCacheEntry(lambda val: DyadBrushSpeed(val).name),
-    RoborockDyadDataProtocol.POWER: A01ProtocolCacheEntry(lambda val: int(val)),
-    RoborockDyadDataProtocol.AUTO_DRY: A01ProtocolCacheEntry(lambda val: bool(val)),
-    RoborockDyadDataProtocol.MESH_LEFT: A01ProtocolCacheEntry(lambda val: int(360000 - val * 60)),
-    RoborockDyadDataProtocol.BRUSH_LEFT: A01ProtocolCacheEntry(lambda val: int(360000 - val * 60)),
-    RoborockDyadDataProtocol.ERROR: A01ProtocolCacheEntry(lambda val: DyadError(val).name),
-    RoborockDyadDataProtocol.VOLUME_SET: A01ProtocolCacheEntry(lambda val: int(val)),
-    RoborockDyadDataProtocol.STAND_LOCK_AUTO_RUN: A01ProtocolCacheEntry(lambda val: bool(val)),
-    RoborockDyadDataProtocol.AUTO_DRY_MODE: A01ProtocolCacheEntry(lambda val: bool(val)),
-    RoborockDyadDataProtocol.SILENT_DRY_DURATION: A01ProtocolCacheEntry(lambda val: int(val)),  # in minutes
-    RoborockDyadDataProtocol.SILENT_MODE: A01ProtocolCacheEntry(lambda val: bool(val)),
-    RoborockDyadDataProtocol.SILENT_MODE_START_TIME: A01ProtocolCacheEntry(
-        lambda val: time(hour=int(val / 60), minute=val % 60)
-    ),  # in minutes since 00:00
-    RoborockDyadDataProtocol.SILENT_MODE_END_TIME: A01ProtocolCacheEntry(
-        lambda val: time(hour=int(val / 60), minute=val % 60)
-    ),  # in minutes since 00:00
-    RoborockDyadDataProtocol.RECENT_RUN_TIME: A01ProtocolCacheEntry(
-        lambda val: [int(v) for v in val.split(",")]
-    ),  # minutes of cleaning in past few days.
-    RoborockDyadDataProtocol.TOTAL_RUN_TIME: A01ProtocolCacheEntry(lambda val: int(val)),
-    RoborockDyadDataProtocol.SND_STATE: A01ProtocolCacheEntry(lambda val: DyadSndState.from_dict(val)),
-    RoborockDyadDataProtocol.PRODUCT_INFO: A01ProtocolCacheEntry(lambda val: DyadProductInfo.from_dict(val)),
-}
-
-zeo_data_protocol_entries = {
-    # ro
-    RoborockZeoProtocol.STATE: A01ProtocolCacheEntry(lambda val: ZeoState(val).name),
-    RoborockZeoProtocol.COUNTDOWN: A01ProtocolCacheEntry(lambda val: int(val)),
-    RoborockZeoProtocol.WASHING_LEFT: A01ProtocolCacheEntry(lambda val: int(val)),
-    RoborockZeoProtocol.ERROR: A01ProtocolCacheEntry(lambda val: ZeoError(val).name),
-    RoborockZeoProtocol.TIMES_AFTER_CLEAN: A01ProtocolCacheEntry(lambda val: int(val)),
-    RoborockZeoProtocol.DETERGENT_EMPTY: A01ProtocolCacheEntry(lambda val: bool(val)),
-    RoborockZeoProtocol.SOFTENER_EMPTY: A01ProtocolCacheEntry(lambda val: bool(val)),
-    # rw
-    RoborockZeoProtocol.MODE: A01ProtocolCacheEntry(lambda val: ZeoMode(val).name),
-    RoborockZeoProtocol.PROGRAM: A01ProtocolCacheEntry(lambda val: ZeoProgram(val).name),
-    RoborockZeoProtocol.TEMP: A01ProtocolCacheEntry(lambda val: ZeoTemperature(val).name),
-    RoborockZeoProtocol.RINSE_TIMES: A01ProtocolCacheEntry(lambda val: ZeoRinse(val).name),
-    RoborockZeoProtocol.SPIN_LEVEL: A01ProtocolCacheEntry(lambda val: ZeoSpin(val).name),
-    RoborockZeoProtocol.DRYING_MODE: A01ProtocolCacheEntry(lambda val: ZeoDryingMode(val).name),
-    RoborockZeoProtocol.DETERGENT_TYPE: A01ProtocolCacheEntry(lambda val: ZeoDetergentType(val).name),
-    RoborockZeoProtocol.SOFTENER_TYPE: A01ProtocolCacheEntry(lambda val: ZeoSoftenerType(val).name),
-    RoborockZeoProtocol.SOUND_SET: A01ProtocolCacheEntry(lambda val: bool(val)),
-}
-
-
-class RoborockClientA01(RoborockClient, ABC):
-    """Roborock client base class for A01 devices."""
-
-    def __init__(self, device_info: DeviceData, category: RoborockCategory):
-        """Initialize the Roborock client."""
-        super().__init__(device_info)
-        self.category = category
-
-    def on_message_received(self, messages: list[RoborockMessage]) -> None:
-        for message in messages:
-            protocol = message.protocol
-            if message.payload and protocol in [
-                RoborockMessageProtocol.RPC_RESPONSE,
-                RoborockMessageProtocol.GENERAL_REQUEST,
-            ]:
-                payload = message.payload
-                try:
-                    payload = unpad(payload, AES.block_size)
-                except Exception as err:
-                    self._logger.debug("Failed to unpad payload: %s", err)
-                    continue
-                payload_json = json.loads(payload.decode())
-                for data_point_number, data_point in payload_json.get("dps").items():
-                    data_point_protocol: RoborockDyadDataProtocol | RoborockZeoProtocol
-                    self._logger.debug("received msg with dps, protocol: %s, %s", data_point_number, protocol)
-                    entries: dict
-                    if self.category == RoborockCategory.WET_DRY_VAC:
-                        data_point_protocol = RoborockDyadDataProtocol(int(data_point_number))
-                        entries = protocol_entries
-                    elif self.category == RoborockCategory.WASHING_MACHINE:
-                        data_point_protocol = RoborockZeoProtocol(int(data_point_number))
-                        entries = zeo_data_protocol_entries
-                    else:
-                        continue
-                    if data_point_protocol in entries:
-                        # Auto convert into data struct we want.
-                        converted_response = entries[data_point_protocol].post_process_fn(data_point)
-                        queue = self._waiting_queue.get(int(data_point_number))
-                        if queue and queue.protocol == protocol:
-                            queue.set_result(converted_response)
-
-    @abstractmethod
-    async def update_values(
-        self, dyad_data_protocols: list[RoborockDyadDataProtocol | RoborockZeoProtocol]
-    ) -> dict[RoborockDyadDataProtocol | RoborockZeoProtocol, typing.Any]:
-        """This should handle updating for each given protocol."""