python-roborock 2.34.2__tar.gz → 2.36.0__tar.gz

{python_roborock-2.34.2 → python_roborock-2.36.0}/PKG-INFO

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

{python_roborock-2.34.2 → python_roborock-2.36.0}/pyproject.toml

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

{python_roborock-2.34.2 → python_roborock-2.36.0}/roborock/api.py

@@ -3,9 +3,7 @@
 from __future__ import annotations
 
 import asyncio
-import base64
 import logging
-import secrets
 import time
 from abc import ABC, abstractmethod
 from typing import Any
@@ -37,14 +35,11 @@ class RoborockClient(ABC):
     def __init__(self, device_info: DeviceData) -> None:
         """Initialize RoborockClient."""
         self.device_info = device_info
-        self._nonce = secrets.token_bytes(16)
         self._waiting_queue: dict[int, RoborockFuture] = {}
         self._last_device_msg_in = time.monotonic()
         self._last_disconnection = time.monotonic()
         self.keep_alive = KEEPALIVE
-        self._diagnostic_data: dict[str, dict[str, Any]] = {
-            "misc_info": {"Nonce": base64.b64encode(self._nonce).decode("utf-8")}
-        }
+        self._diagnostic_data: dict[str, dict[str, Any]] = {}
         self.is_available: bool = True
 
     async def async_release(self) -> None:

python_roborock-2.36.0/roborock/clean_modes.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from enum import StrEnum
+
+from roborock import DeviceFeatures
+
+
+class RoborockModeEnum(StrEnum):
+    """A custom StrEnum that also stores an integer code for each member."""
+
+    code: int
+
+    def __new__(cls, value: str, code: int) -> RoborockModeEnum:
+        """Creates a new enum member."""
+        member = str.__new__(cls, value)
+        member._value_ = value
+        member.code = code
+        return member
+
+
+class CleanModes(RoborockModeEnum):
+    GENTLE = ("gentle", 105)
+    OFF = ("off", 105)
+    QUIET = ("quiet", 101)
+    BALANCED = ("balanced", 102)
+    TURBO = ("turbo", 103)
+    MAX = ("max", 104)
+    MAX_PLUS = ("max_plus", 108)
+    CUSTOMIZED = ("custom", 106)
+    SMART_MODE = ("smart_mode", 110)
+
+
+class CleanRoutes(RoborockModeEnum):
+    STANDARD = ("standard", 300)
+    DEEP = ("deep", 301)
+    DEEP_PLUS = ("deep_plus", 303)
+    FAST = ("fast", 304)
+    DEEP_PLUS_CN = ("deep_plus", 305)
+    SMART_MODE = ("smart_mode", 306)
+    CUSTOMIZED = ("custom", 302)
+
+
+class CleanModesOld(RoborockModeEnum):
+    QUIET = ("quiet", 38)
+    BALANCED = ("balanced", 60)
+    TURBO = ("turbo", 75)
+    MAX = ("max", 100)
+
+
+class WaterModes(RoborockModeEnum):
+    OFF = ("off", 200)
+    LOW = ("low", 201)
+    MILD = ("mild", 201)
+    MEDIUM = ("medium", 202)
+    STANDARD = ("standard", 202)
+    HIGH = ("high", 203)
+    INTENSE = ("intense", 203)
+    CUSTOMIZED = ("custom", 204)
+    CUSTOM = ("custom_water_flow", 207)
+    EXTREME = ("extreme", 208)
+    SMART_MODE = ("smart_mode", 209)
+
+
+def get_clean_modes(features: DeviceFeatures) -> list[CleanModes]:
+    """Get the valid clean modes for the device - also known as 'fan power' or 'suction mode'"""
+    modes = [CleanModes.QUIET, CleanModes.BALANCED, CleanModes.TURBO, CleanModes.MAX]
+    if features.is_max_plus_mode_supported or features.is_none_pure_clean_mop_with_max_plus:
+        # If the vacuum has max plus mode supported
+        modes.append(CleanModes.MAX_PLUS)
+    if features.is_pure_clean_mop_supported:
+        # If the vacuum is capable of 'pure mop clean' aka no vacuum
+        modes.append(CleanModes.OFF)
+    else:
+        # If not, we can add gentle
+        modes.append(CleanModes.GENTLE)
+    return modes
+
+
+def get_clean_routes(features: DeviceFeatures, region: str) -> list[CleanRoutes]:
+    """The routes that the vacuum will take while mopping"""
+    if features.is_none_pure_clean_mop_with_max_plus:
+        return [CleanRoutes.FAST, CleanRoutes.STANDARD]
+    supported = [CleanRoutes.STANDARD, CleanRoutes.DEEP]
+    if features.is_careful_slow_mop_supported:
+        if not (
+            features.is_corner_clean_mode_supported
+            and features.is_clean_route_deep_slow_plus_supported
+            and region == "CN"
+        ):
+            # for some reason there is a china specific deep plus mode
+            supported.append(CleanRoutes.DEEP_PLUS_CN)
+        else:
+            supported.append(CleanRoutes.DEEP_PLUS)
+
+    if features.is_clean_route_fast_mode_supported:
+        supported.append(CleanRoutes.FAST)
+    return supported
+
+
+def get_water_modes(features: DeviceFeatures) -> list[WaterModes]:
+    """Get the valid water modes for the device - also known as 'water flow' or 'water level'"""
+    supported_modes = [WaterModes.OFF]
+    if features.is_mop_shake_module_supported:
+        # For mops that have the vibrating mop pad, they do mild standard intense
+        supported_modes.extend([WaterModes.MILD, WaterModes.STANDARD, WaterModes.INTENSE])
+    else:
+        supported_modes.extend([WaterModes.LOW, WaterModes.MEDIUM, WaterModes.HIGH])
+    if features.is_custom_water_box_distance_supported:
+        # This is for devices that allow you to set a custom water flow from 0-100
+        supported_modes.append(WaterModes.CUSTOM)
+    if features.is_mop_shake_module_supported and features.is_mop_shake_water_max_supported:
+        supported_modes.append(WaterModes.EXTREME)
+    return supported_modes

{python_roborock-2.34.2 → python_roborock-2.36.0}/roborock/containers.py

@@ -725,6 +725,29 @@ class NetworkInfo(RoborockBase):
     rssi: int | None = None
 
 
+@dataclass
+class AppInitStatusLocalInfo(RoborockBase):
+    location: str
+    bom: str | None = None
+    featureset: int | None = None
+    language: str | None = None
+    logserver: str | None = None
+    wifiplan: str | None = None
+    timezone: str | None = None
+    name: str | None = None
+
+
+@dataclass
+class AppInitStatus(RoborockBase):
+    local_info: AppInitStatusLocalInfo
+    feature_info: list[int]
+    new_feature_info: int
+    new_feature_info_str: str
+    new_feature_info_2: int | None = None
+    carriage_type: int | None = None
+    dsp_version: int | None = None
+
+
 @dataclass
 class DeviceData(RoborockBase):
     device: HomeDataDevice

{python_roborock-2.34.2 → python_roborock-2.36.0}/roborock/device_features.py

@@ -423,6 +423,7 @@ class DeviceFeatures:
     is_clean_route_setting_supported: bool = field(
         metadata={"product_features": [ProductFeatures.MOP_SHAKE_MODULE, ProductFeatures.MOP_SPIN_MODULE]}
     )
+    is_mop_shake_module_supported: bool = field(metadata={"product_features": [ProductFeatures.MOP_SHAKE_MODULE]})
 
     @classmethod
     def from_feature_flags(

{python_roborock-2.34.2 → python_roborock-2.36.0}/roborock/devices/local_channel.py

@@ -11,6 +11,7 @@ from roborock.protocol import Decoder, Encoder, create_local_decoder, create_loc
 from roborock.roborock_message import RoborockMessage
 
 from .channel import Channel
+from .pending import PendingRpcs
 
 _LOGGER = logging.getLogger(__name__)
 _PORT = 58867
@@ -47,10 +48,9 @@ class LocalChannel(Channel):
         self._is_connected = False
 
         # RPC support
-        self._waiting_queue: dict[int, asyncio.Future[RoborockMessage]] = {}
+        self._pending_rpcs: PendingRpcs[int, RoborockMessage] = PendingRpcs()
         self._decoder: Decoder = create_local_decoder(local_key)
         self._encoder: Encoder = create_local_encoder(local_key)
-        self._queue_lock = asyncio.Lock()
 
     @property
     def is_connected(self) -> bool:
@@ -114,11 +114,7 @@ class LocalChannel(Channel):
         if (request_id := message.get_request_id()) is None:
             _LOGGER.debug("Received message with no request_id")
             return
-        async with self._queue_lock:
-            if (future := self._waiting_queue.pop(request_id, None)) is not None:
-                future.set_result(message)
-            else:
-                _LOGGER.debug("Received message with no waiting handler: request_id=%s", request_id)
+        await self._pending_rpcs.resolve(request_id, message)
 
     async def send_message(self, message: RoborockMessage, timeout: float = 10.0) -> RoborockMessage:
         """Send a command message and wait for the response message."""
@@ -132,24 +128,17 @@ class LocalChannel(Channel):
             _LOGGER.exception("Error getting request_id from message: %s", err)
             raise RoborockException(f"Invalid message format, Message must have a request_id: {err}") from err
 
-        future: asyncio.Future[RoborockMessage] = asyncio.Future()
-        async with self._queue_lock:
-            if request_id in self._waiting_queue:
-                raise RoborockException(f"Request ID {request_id} already pending, cannot send command")
-            self._waiting_queue[request_id] = future
-
+        future: asyncio.Future[RoborockMessage] = await self._pending_rpcs.start(request_id)
         try:
             encoded_msg = self._encoder(message)
             self._transport.write(encoded_msg)
             return await asyncio.wait_for(future, timeout=timeout)
         except asyncio.TimeoutError as ex:
-            async with self._queue_lock:
-                self._waiting_queue.pop(request_id, None)
+            await self._pending_rpcs.pop(request_id)
             raise RoborockException(f"Command timed out after {timeout}s") from ex
         except Exception:
             logging.exception("Uncaught error sending command")
-            async with self._queue_lock:
-                self._waiting_queue.pop(request_id, None)
+            await self._pending_rpcs.pop(request_id)
             raise
 
 

{python_roborock-2.34.2 → python_roborock-2.36.0}/roborock/devices/mqtt_channel.py

@@ -12,6 +12,7 @@ from roborock.protocol import create_mqtt_decoder, create_mqtt_encoder
 from roborock.roborock_message import RoborockMessage
 
 from .channel import Channel
+from .pending import PendingRpcs
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -31,10 +32,9 @@ class MqttChannel(Channel):
         self._mqtt_params = mqtt_params
 
         # RPC support
-        self._waiting_queue: dict[int, asyncio.Future[RoborockMessage]] = {}
+        self._pending_rpcs: PendingRpcs[int, RoborockMessage] = PendingRpcs()
         self._decoder = create_mqtt_decoder(local_key)
         self._encoder = create_mqtt_encoder(local_key)
-        self._queue_lock = asyncio.Lock()
         self._mqtt_unsub: Callable[[], None] | None = None
 
     @property
@@ -89,11 +89,7 @@ class MqttChannel(Channel):
         if (request_id := message.get_request_id()) is None:
             _LOGGER.debug("Received message with no request_id")
             return
-        async with self._queue_lock:
-            if (future := self._waiting_queue.pop(request_id, None)) is not None:
-                future.set_result(message)
-            else:
-                _LOGGER.debug("Received message with no waiting handler: request_id=%s", request_id)
+        await self._pending_rpcs.resolve(request_id, message)
 
     async def send_message(self, message: RoborockMessage, timeout: float = 10.0) -> RoborockMessage:
         """Send a command message and wait for the response message.
@@ -107,11 +103,7 @@ class MqttChannel(Channel):
             _LOGGER.exception("Error getting request_id from message: %s", err)
             raise RoborockException(f"Invalid message format, Message must have a request_id: {err}") from err
 
-        future: asyncio.Future[RoborockMessage] = asyncio.Future()
-        async with self._queue_lock:
-            if request_id in self._waiting_queue:
-                raise RoborockException(f"Request ID {request_id} already pending, cannot send command")
-            self._waiting_queue[request_id] = future
+        future: asyncio.Future[RoborockMessage] = await self._pending_rpcs.start(request_id)
 
         try:
             encoded_msg = self._encoder(message)
@@ -120,13 +112,11 @@ class MqttChannel(Channel):
             return await asyncio.wait_for(future, timeout=timeout)
 
         except asyncio.TimeoutError as ex:
-            async with self._queue_lock:
-                self._waiting_queue.pop(request_id, None)
+            await self._pending_rpcs.pop(request_id)
             raise RoborockException(f"Command timed out after {timeout}s") from ex
         except Exception:
             logging.exception("Uncaught error sending command")
-            async with self._queue_lock:
-                self._waiting_queue.pop(request_id, None)
+            await self._pending_rpcs.pop(request_id)
             raise
 
 

python_roborock-2.36.0/roborock/devices/pending.py

@@ -0,0 +1,45 @@
+"""Module for managing pending RPCs."""
+
+import asyncio
+import logging
+from typing import Generic, TypeVar
+
+from roborock.exceptions import RoborockException
+
+_LOGGER = logging.getLogger(__name__)
+
+
+K = TypeVar("K")
+V = TypeVar("V")
+
+
+class PendingRpcs(Generic[K, V]):
+    """Manage pending RPCs."""
+
+    def __init__(self) -> None:
+        """Initialize the pending RPCs."""
+        self._queue_lock = asyncio.Lock()
+        self._waiting_queue: dict[K, asyncio.Future[V]] = {}
+
+    async def start(self, key: K) -> asyncio.Future[V]:
+        """Start the pending RPCs."""
+        future: asyncio.Future[V] = asyncio.Future()
+        async with self._queue_lock:
+            if key in self._waiting_queue:
+                raise RoborockException(f"Request ID {key} already pending, cannot send command")
+            self._waiting_queue[key] = future
+        return future
+
+    async def pop(self, key: K) -> None:
+        """Pop a pending RPC."""
+        async with self._queue_lock:
+            if (future := self._waiting_queue.pop(key, None)) is not None:
+                future.cancel()
+
+    async def resolve(self, key: K, value: V) -> None:
+        """Resolve waiting future with proper locking."""
+        async with self._queue_lock:
+            if (future := self._waiting_queue.pop(key, None)) is not None:
+                future.set_result(value)
+            else:
+                _LOGGER.debug("Received unsolicited message: %s", key)

{python_roborock-2.34.2 → python_roborock-2.36.0}/roborock/protocol.py

@@ -147,6 +147,26 @@ class Utils:
             return unpad(decipher.decrypt(ciphertext), AES.block_size)
         return ciphertext
 
+    @staticmethod
+    def encrypt_cbc(plaintext: bytes, token: bytes) -> bytes:
+        """Encrypt plaintext with a given token using cbc mode.
+
+        This is currently used for testing purposes only.
+
+        :param bytes plaintext: Plaintext (json) to encrypt
+        :param bytes token: Token to use
+        :return: Encrypted bytes
+        """
+        if not isinstance(plaintext, bytes):
+            raise TypeError("plaintext requires bytes")
+        Utils.verify_token(token)
+        iv = bytes(AES.block_size)
+        cipher = AES.new(token, AES.MODE_CBC, iv)
+        if plaintext:
+            plaintext = pad(plaintext, AES.block_size)
+            return cipher.encrypt(plaintext)
+        return plaintext
+
     @staticmethod
     def decrypt_cbc(ciphertext: bytes, token: bytes) -> bytes:
         """Decrypt ciphertext with a given token using cbc mode.

{python_roborock-2.34.2 → python_roborock-2.36.0}/roborock/protocols/v1_protocol.py

@@ -7,6 +7,7 @@ import json
 import logging
 import math
 import secrets
+import struct
 import time
 from collections.abc import Callable
 from dataclasses import dataclass, field
@@ -44,6 +45,10 @@ class SecurityData:
         """Convert security data to a dictionary for sending in the payload."""
         return {"security": {"endpoint": self.endpoint, "nonce": self.nonce.hex().lower()}}
 
+    def to_diagnostic_data(self) -> dict[str, Any]:
+        """Convert security data to a dictionary for debugging purposes."""
+        return {"nonce": self.nonce.hex().lower()}
+
 
 def create_security_data(rriot: RRiot) -> SecurityData:
     """Create a SecurityData instance for the given endpoint and nonce."""
@@ -142,3 +147,37 @@ def decode_rpc_response(message: RoborockMessage) -> dict[str, Any]:
     if not isinstance(result, dict):
         raise RoborockException(f"Invalid V1 message format: 'result' should be a dictionary for {message.payload!r}")
     return result
+
+
+@dataclass
+class MapResponse:
+    """Data structure for the V1 Map response."""
+
+    request_id: int
+    """The request ID of the map response."""
+
+    data: bytes
+    """The map data, decrypted and decompressed."""
+
+
+def create_map_response_decoder(security_data: SecurityData) -> Callable[[RoborockMessage], MapResponse]:
+    """Create a decoder for V1 map response messages."""
+
+    def _decode_map_response(message: RoborockMessage) -> MapResponse:
+        """Decode a V1 map response message."""
+        if not message.payload or len(message.payload) < 24:
+            raise RoborockException("Invalid V1 map response format: missing payload")
+        header, body = message.payload[:24], message.payload[24:]
+        [endpoint, _, request_id, _] = struct.unpack("<8s8sH6s", header)
+        if not endpoint.decode().startswith(security_data.endpoint):
+            raise RoborockException(
+                f"Invalid V1 map response endpoint: {endpoint!r}, expected {security_data.endpoint!r}"
+            )
+        try:
+            decrypted = Utils.decrypt_cbc(body, security_data.nonce)
+        except ValueError as err:
+            raise RoborockException("Failed to decode map message payload") from err
+        decompressed = Utils.decompress(decrypted)
+        return MapResponse(request_id=request_id, data=decompressed)
+
+    return _decode_map_response

{python_roborock-2.34.2 → python_roborock-2.36.0}/roborock/roborock_message.py

@@ -256,23 +256,3 @@ class RoborockMessage:
                     data_point_response = json.loads(data_point)
                     return data_point_response.get("id")
         return None
-
-    def get_method(self) -> str | None:
-        protocol = self.protocol
-        if self.payload and protocol in [4, 5, 101, 102]:
-            payload = json.loads(self.payload.decode())
-            for data_point_number, data_point in payload.get("dps").items():
-                if data_point_number in ["101", "102"]:
-                    data_point_response = json.loads(data_point)
-                    return data_point_response.get("method")
-        return None
-
-    def get_params(self) -> list | dict | None:
-        protocol = self.protocol
-        if self.payload and protocol in [4, 101, 102]:
-            payload = json.loads(self.payload.decode())
-            for data_point_number, data_point in payload.get("dps").items():
-                if data_point_number in ["101", "102"]:
-                    data_point_response = json.loads(data_point)
-                    return data_point_response.get("params")
-        return None

{python_roborock-2.34.2 → python_roborock-2.36.0}/roborock/version_1_apis/roborock_client_v1.py

@@ -1,13 +1,13 @@
 import asyncio
 import dataclasses
 import json
-import struct
 import time
 from abc import ABC, abstractmethod
 from collections.abc import Callable, Coroutine
 from typing import Any, TypeVar, final
 
 from roborock import (
+    AppInitStatus,
     DeviceProp,
     DockSummary,
     RoborockCommand,
@@ -45,7 +45,7 @@ from roborock.containers import (
     ValleyElectricityTimer,
     WashTowelMode,
 )
-from roborock.protocol import Utils
+from roborock.protocols.v1_protocol import MapResponse, SecurityData, create_map_response_decoder
 from roborock.roborock_message import (
     ROBOROCK_DATA_CONSUMABLE_PROTOCOL,
     ROBOROCK_DATA_STATUS_PROTOCOL,
@@ -150,10 +150,15 @@ class RoborockClientV1(RoborockClient, ABC):
     """Roborock client base class for version 1 devices."""
 
     _listeners: dict[str, ListenerModel] = {}
+    _map_response_decoder: Callable[[RoborockMessage], MapResponse] | None = None
 
-    def __init__(self, device_info: DeviceData, endpoint: str):
+    def __init__(self, device_info: DeviceData, security_data: SecurityData | None) -> None:
         """Initializes the Roborock client."""
         super().__init__(device_info)
+        if security_data is not None:
+            self._diagnostic_data.update({"misc_info": security_data.to_diagnostic_data()})
+            self._map_response_decoder = create_map_response_decoder(security_data)
+
         self._status_type: type[Status] = ModelStatus.get(device_info.model, S7MaxVStatus)
         self.cache: dict[CacheableAttribute, AttributeCache] = {
             cacheable_attribute: AttributeCache(attr, self._send_command)
@@ -162,7 +167,6 @@ class RoborockClientV1(RoborockClient, ABC):
         if device_info.device.duid not in self._listeners:
             self._listeners[device_info.device.duid] = ListenerModel({}, self.cache)
         self.listener_model = self._listeners[device_info.device.duid]
-        self._endpoint = endpoint
 
     async def async_release(self) -> None:
         await super().async_release()
@@ -339,6 +343,10 @@ class RoborockClientV1(RoborockClient, ABC):
         """Load the map into the vacuum's memory."""
         await self.send_command(RoborockCommand.LOAD_MULTI_MAP, [map_flag])
 
+    async def get_app_init_status(self) -> AppInitStatus:
+        """Gets the app init status (needed for determining vacuum capabilities)."""
+        return await self.send_command(RoborockCommand.APP_GET_INIT_STATUS, return_type=AppInitStatus)
+
     @abstractmethod
     async def _send_command(
         self,
@@ -429,21 +437,15 @@ class RoborockClientV1(RoborockClient, ABC):
                             dps = {data_point_number: data_point}
                             self._logger.debug(f"Got unknown data point {dps}")
                 elif data.payload and protocol == RoborockMessageProtocol.MAP_RESPONSE:
-                    payload = data.payload[0:24]
-                    [endpoint, _, request_id, _] = struct.unpack("<8s8sH6s", payload)
-                    if endpoint.decode().startswith(self._endpoint):
-                        try:
-                            decrypted = Utils.decrypt_cbc(data.payload[24:], self._nonce)
-                        except ValueError as err:
-                            raise RoborockException(f"Failed to decode {data.payload!r} for {data.protocol}") from err
-                        decompressed = Utils.decompress(decrypted)
-                        queue = self._waiting_queue.get(request_id)
+                    if self._map_response_decoder is not None:
+                        map_response = self._map_response_decoder(data)
+                        queue = self._waiting_queue.get(map_response.request_id)
                         if queue:
-                            if isinstance(decompressed, list):
-                                decompressed = decompressed[0]
-                            queue.set_result(decompressed)
+                            queue.set_result(map_response.data)
                         else:
-                            self._logger.debug("Received response for unknown request id %s", request_id)
+                            self._logger.debug(
+                                "Received unsolicited map response for request_id %s", map_response.request_id
+                            )
                 else:
                     queue = self._waiting_queue.get(data.seq)
                     if queue:

{python_roborock-2.34.2 → python_roborock-2.36.0}/roborock/version_1_apis/roborock_local_client_v1.py

@@ -18,6 +18,19 @@ from .roborock_client_v1 import CLOUD_REQUIRED, RoborockClientV1
 _LOGGER = logging.getLogger(__name__)
 
 
+_HELLO_REQUEST_MESSAGE = RoborockMessage(
+    protocol=RoborockMessageProtocol.HELLO_REQUEST,
+    seq=1,
+    random=22,
+)
+
+_PING_REQUEST_MESSAGE = RoborockMessage(
+    protocol=RoborockMessageProtocol.PING_REQUEST,
+    seq=2,
+    random=23,
+)
+
+
 @dataclass
 class _LocalProtocol(asyncio.Protocol):
     """Callbacks for the Roborock local client transport."""
@@ -47,7 +60,7 @@ class RoborockLocalClientV1(RoborockClientV1, RoborockClient):
         self.transport: Transport | None = None
         self._mutex = Lock()
         self.keep_alive_task: TimerHandle | None = None
-        RoborockClientV1.__init__(self, device_data, "abc")
+        RoborockClientV1.__init__(self, device_data, security_data=None)
         RoborockClient.__init__(self, device_data)
         self._local_protocol = _LocalProtocol(self._data_received, self._connection_lost)
         self._encoder: Encoder = create_local_encoder(device_data.device.local_key)
@@ -109,29 +122,13 @@ class RoborockLocalClientV1(RoborockClientV1, RoborockClient):
             self._sync_disconnect()
 
     async def hello(self):
-        request_id = 1
-        protocol = RoborockMessageProtocol.HELLO_REQUEST
         try:
-            return await self._send_message(
-                RoborockMessage(
-                    protocol=protocol,
-                    seq=request_id,
-                    random=22,
-                )
-            )
+            return await self._send_message(_HELLO_REQUEST_MESSAGE)
         except Exception as e:
             self._logger.error(e)
 
     async def ping(self) -> None:
-        request_id = 2
-        protocol = RoborockMessageProtocol.PING_REQUEST
-        return await self._send_message(
-            RoborockMessage(
-                protocol=protocol,
-                seq=request_id,
-                random=23,
-            )
-        )
+        await self._send_message(_PING_REQUEST_MESSAGE)
 
     def _send_msg_raw(self, data: bytes):
         try:
@@ -151,12 +148,15 @@ class RoborockLocalClientV1(RoborockClientV1, RoborockClient):
 
         roborock_message = encode_local_payload(method, params)
         self._logger.debug("Building message id %s for method %s", roborock_message.get_request_id(), method)
-        return await self._send_message(roborock_message)
+        return await self._send_message(roborock_message, method, params)
 
-    async def _send_message(self, roborock_message: RoborockMessage):
+    async def _send_message(
+        self,
+        roborock_message: RoborockMessage,
+        method: str | None = None,
+        params: list | dict | int | None = None,
+    ) -> RoborockMessage:
         await self.validate_connection()
-        method = roborock_message.get_method()
-        params = roborock_message.get_params()
         request_id: int | None
         if not method or not method.startswith("get"):
             request_id = roborock_message.seq
@@ -177,16 +177,16 @@ class RoborockLocalClientV1(RoborockClientV1, RoborockClient):
             response = await async_response
         except VacuumError as err:
             self._diagnostic_data[diagnostic_key] = {
-                "params": roborock_message.get_params(),
+                "params": params,
                 "error": err,
             }
             raise CommandVacuumError(method, err) from err
         self._diagnostic_data[diagnostic_key] = {
-            "params": roborock_message.get_params(),
+            "params": params,
             "response": response,
         }
         if roborock_message.protocol == RoborockMessageProtocol.GENERAL_REQUEST:
-            self._logger.debug(f"id={request_id} Response from method {roborock_message.get_method()}: {response}")
+            self._logger.debug(f"id={request_id} Response from method {method}: {response}")
         if response == "retry":
             raise RoborockException(f"Command {method} failed with 'retry' message; Device is busy, try again later")
         return response

{python_roborock-2.34.2 → python_roborock-2.36.0}/roborock/version_1_apis/roborock_mqtt_client_v1.py

@@ -1,4 +1,3 @@
-import base64
 import logging
 
 from vacuum_map_parser_base.config.color import ColorsPalette
@@ -10,10 +9,8 @@ from roborock.cloud_api import RoborockMqttClient
 
 from ..containers import DeviceData, UserData
 from ..exceptions import CommandVacuumError, RoborockException, VacuumError
-from ..protocol import Utils
-from ..protocols.v1_protocol import SecurityData, create_mqtt_payload_encoder
+from ..protocols.v1_protocol import create_mqtt_payload_encoder, create_security_data
 from ..roborock_message import (
-    RoborockMessage,
     RoborockMessageProtocol,
 )
 from ..roborock_typing import RoborockCommand
@@ -31,20 +28,26 @@ class RoborockMqttClientV1(RoborockMqttClient, RoborockClientV1):
         rriot = user_data.rriot
         if rriot is None:
             raise RoborockException("Got no rriot data from user_data")
-        endpoint = base64.b64encode(Utils.md5(rriot.k.encode())[8:14]).decode()
-
+        security_data = create_security_data(rriot)
         RoborockMqttClient.__init__(self, user_data, device_info)
-        RoborockClientV1.__init__(self, device_info, endpoint)
+        RoborockClientV1.__init__(self, device_info, security_data=security_data)
         self.queue_timeout = queue_timeout
         self._logger = RoborockLoggerAdapter(device_info.device.name, _LOGGER)
-        self._payload_encoder = create_mqtt_payload_encoder(
-            SecurityData(endpoint=self._endpoint, nonce=self._nonce),
-        )
+        self._payload_encoder = create_mqtt_payload_encoder(security_data)
+
+    async def _send_command(
+        self,
+        method: RoborockCommand | str,
+        params: list | dict | int | None = None,
+    ):
+        if method in CUSTOM_COMMANDS:
+            # When we have more custom commands do something more complicated here
+            return await self._get_calibration_points()
+
+        roborock_message = self._payload_encoder(method, params)
+        self._logger.debug("Building message id %s for method %s", roborock_message.get_request_id, method)
 
-    async def send_message(self, roborock_message: RoborockMessage):
         await self.validate_connection()
-        method = roborock_message.get_method()
-        params = roborock_message.get_params()
         request_id = roborock_message.get_request_id()
         if request_id is None:
             raise RoborockException(f"Failed build message {roborock_message}")
@@ -60,12 +63,12 @@ class RoborockMqttClientV1(RoborockMqttClient, RoborockClientV1):
             response = await async_response
         except VacuumError as err:
             self._diagnostic_data[diagnostic_key] = {
-                "params": roborock_message.get_params(),
+                "params": params,
                 "error": err,
             }
             raise CommandVacuumError(method, err) from err
         self._diagnostic_data[diagnostic_key] = {
-            "params": roborock_message.get_params(),
+            "params": params,
             "response": response,
         }
         if response_protocol == RoborockMessageProtocol.MAP_RESPONSE:
@@ -74,19 +77,6 @@ class RoborockMqttClientV1(RoborockMqttClient, RoborockClientV1):
             self._logger.debug(f"id={request_id} Response from {method}: {response}")
         return response
 
-    async def _send_command(
-        self,
-        method: RoborockCommand | str,
-        params: list | dict | int | None = None,
-    ):
-        if method in CUSTOM_COMMANDS:
-            # When we have more custom commands do something more complicated here
-            return await self._get_calibration_points()
-
-        roborock_message = self._payload_encoder(method, params)
-        self._logger.debug("Building message id %s for method %s", roborock_message.get_request_id, method)
-        return await self.send_message(roborock_message)
-
     async def _get_calibration_points(self):
         map: bytes = await self.send_command(RoborockCommand.GET_MAP_V1)
         parser = RoborockMapDataParser(ColorsPalette(), Sizes(), [], ImageConfig(), [])