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

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

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

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-roborock"
-version = "2.24.0"
+version = "2.25.1"
 description = "A package to control Roborock vacuums."
 authors = ["humbertogontijo <humbertogontijo@users.noreply.github.com>"]
 license = "GPL-3.0-only"
@@ -76,3 +76,4 @@ select=["E", "F", "UP", "I"]
 asyncio_mode = "auto"
 asyncio_default_fixture_loop_scope = "function"
 timeout = 30
+log_format = "%(asctime)s.%(msecs)03d %(levelname)s (%(threadName)s) [%(name)s] %(message)s"

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

@@ -300,6 +300,17 @@ class RoborockFanSpeedS8MaxVUltra(RoborockFanPowerCode):
     smart_mode = 110
 
 
+class RoborockFanSpeedSaros10R(RoborockFanPowerCode):
+    off = 105
+    quiet = 101
+    balanced = 102
+    turbo = 103
+    max = 104
+    custom = 106
+    max_plus = 108
+    smart_mode = 110
+
+
 class RoborockMopModeCode(RoborockEnum):
     """Describes the mop mode of the vacuum cleaner."""
 
@@ -341,6 +352,15 @@ class RoborockMopModeS8MaxVUltra(RoborockMopModeCode):
     smart_mode = 306
 
 
+class RoborockMopModeSaros10R(RoborockMopModeCode):
+    standard = 300
+    deep = 301
+    custom = 302
+    deep_plus = 303
+    fast = 304
+    smart_mode = 306
+
+
 class RoborockMopModeQRevoMaster(RoborockMopModeCode):
     standard = 300
     deep = 301
@@ -438,6 +458,17 @@ class RoborockMopIntensityS8MaxVUltra(RoborockMopIntensityCode):
     custom_water_flow = 207
 
 
+class RoborockMopIntensitySaros10R(RoborockMopIntensityCode):
+    off = 200
+    low = 201
+    medium = 202
+    high = 203
+    custom = 204
+    extreme = 250
+    vac_followed_by_mop = 235
+    smart_mode = 209
+
+
 class RoborockMopIntensityS5Max(RoborockMopIntensityCode):
     """Describes the mop intensity of the vacuum cleaner."""
 

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

@@ -50,6 +50,7 @@ ROBOROCK_S8_MAXV_ULTRA = "roborock.vacuum.a97"
 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_DYAD_AIR = "roborock.wetdryvac.a107"
 ROBOROCK_DYAD_PRO_COMBO = "roborock.wetdryvac.a83"

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

@@ -28,6 +28,7 @@ from .code_mappings import (
     RoborockFanSpeedS7,
     RoborockFanSpeedS7MaxV,
     RoborockFanSpeedS8MaxVUltra,
+    RoborockFanSpeedSaros10R,
     RoborockFinishReason,
     RoborockInCleaning,
     RoborockMopIntensityCode,
@@ -40,6 +41,7 @@ from .code_mappings import (
     RoborockMopIntensityS6MaxV,
     RoborockMopIntensityS7,
     RoborockMopIntensityS8MaxVUltra,
+    RoborockMopIntensitySaros10R,
     RoborockMopModeCode,
     RoborockMopModeQRevoCurv,
     RoborockMopModeQRevoMaster,
@@ -47,6 +49,7 @@ from .code_mappings import (
     RoborockMopModeS7,
     RoborockMopModeS8MaxVUltra,
     RoborockMopModeS8ProUltra,
+    RoborockMopModeSaros10R,
     RoborockStartType,
     RoborockStateCode,
 )
@@ -74,6 +77,7 @@ from .const import (
     ROBOROCK_S8,
     ROBOROCK_S8_MAXV_ULTRA,
     ROBOROCK_S8_PRO_ULTRA,
+    ROBOROCK_SAROS_10R,
     SENSOR_DIRTY_REPLACE_TIME,
     SIDE_BRUSH_REPLACE_TIME,
     STRAINER_REPLACE_TIME,
@@ -678,6 +682,13 @@ class S8MaxvUltraStatus(Status):
     mop_mode: RoborockMopModeS8MaxVUltra | None = None
 
 
+@dataclass
+class Saros10RStatus(Status):
+    fan_power: RoborockFanSpeedSaros10R | None = None
+    water_box_mode: RoborockMopIntensitySaros10R | None = None
+    mop_mode: RoborockMopModeSaros10R | None = None
+
+
 ModelStatus: dict[str, type[Status]] = {
     ROBOROCK_S4_MAX: S4MaxStatus,
     ROBOROCK_S5_MAX: S5MaxStatus,
@@ -701,6 +712,7 @@ ModelStatus: dict[str, type[Status]] = {
     ROBOROCK_QREVO_MAXV: QRevoMaxVStatus,
     ROBOROCK_QREVO_PRO: P10Status,
     ROBOROCK_S8_MAXV_ULTRA: S8MaxvUltraStatus,
+    ROBOROCK_SAROS_10R: Saros10RStatus,
 }
 
 

python_roborock-2.25.1/roborock/protocols/v1_protocol.py

@@ -0,0 +1,91 @@
+"""Roborock V1 Protocol Encoder."""
+
+from __future__ import annotations
+
+import json
+import math
+import time
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import Any
+
+from roborock.roborock_message import MessageRetry, RoborockMessage, RoborockMessageProtocol
+from roborock.roborock_typing import RoborockCommand
+from roborock.util import get_next_int
+
+CommandType = RoborockCommand | str
+ParamsType = list | dict | int | None
+
+
+@dataclass(frozen=True, kw_only=True)
+class SecurityData:
+    """Security data included in the request for some V1 commands."""
+
+    endpoint: str
+    nonce: bytes
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert security data to a dictionary for sending in the payload."""
+        return {"security": {"endpoint": self.endpoint, "nonce": self.nonce.hex().lower()}}
+
+
+@dataclass
+class RequestMessage:
+    """Data structure for v1 RoborockMessage payloads."""
+
+    method: RoborockCommand | str
+    params: ParamsType
+    timestamp: int = field(default_factory=lambda: math.floor(time.time()))
+    request_id: int = field(default_factory=lambda: get_next_int(10000, 32767))
+
+    def as_payload(self, security_data: SecurityData | None) -> bytes:
+        """Convert the request arguments to a dictionary."""
+        inner = {
+            "id": self.request_id,
+            "method": self.method,
+            "params": self.params or [],
+            **(security_data.to_dict() if security_data else {}),
+        }
+        return bytes(
+            json.dumps(
+                {
+                    "dps": {"101": json.dumps(inner, separators=(",", ":"))},
+                    "t": self.timestamp,
+                },
+                separators=(",", ":"),
+            ).encode()
+        )
+
+
+def create_mqtt_payload_encoder(security_data: SecurityData) -> Callable[[CommandType, ParamsType], RoborockMessage]:
+    """Create a payload encoder for V1 commands over MQTT."""
+
+    def _get_payload(method: CommandType, params: ParamsType) -> RoborockMessage:
+        """Build the payload for a V1 command."""
+        request = RequestMessage(method=method, params=params)
+        payload = request.as_payload(security_data)  # always secure
+        return RoborockMessage(
+            timestamp=request.timestamp,
+            protocol=RoborockMessageProtocol.RPC_REQUEST,
+            payload=payload,
+        )
+
+    return _get_payload
+
+
+def encode_local_payload(method: CommandType, params: ParamsType) -> RoborockMessage:
+    """Encode payload for V1 commands over local connection."""
+
+    request = RequestMessage(method=method, params=params)
+    payload = request.as_payload(security_data=None)
+
+    message_retry: MessageRetry | None = None
+    if method == RoborockCommand.RETRY_REQUEST and isinstance(params, dict):
+        message_retry = MessageRetry(method=method, retry_id=params["retry_id"])
+
+    return RoborockMessage(
+        timestamp=request.timestamp,
+        protocol=RoborockMessageProtocol.GENERAL_REQUEST,
+        payload=payload,
+        message_retry=message_retry,
+    )

{python_roborock-2.24.0 → python_roborock-2.25.1}/roborock/version_1_apis/roborock_client_v1.py

@@ -1,7 +1,6 @@
 import asyncio
 import dataclasses
 import json
-import math
 import struct
 import time
 from abc import ABC, abstractmethod
@@ -54,15 +53,15 @@ from roborock.roborock_message import (
     RoborockMessage,
     RoborockMessageProtocol,
 )
-from roborock.util import RepeatableTask, get_next_int, unpack_list
+from roborock.util import RepeatableTask, unpack_list
+
+CUSTOM_COMMANDS = {RoborockCommand.GET_MAP_CALIBRATION}
 
 COMMANDS_SECURED = {
     RoborockCommand.GET_MAP_V1,
     RoborockCommand.GET_MULTI_MAP,
 }
 
-CUSTOM_COMMANDS = {RoborockCommand.GET_MAP_CALIBRATION}
-
 CLOUD_REQUIRED = COMMANDS_SECURED.union(CUSTOM_COMMANDS)
 
 WASH_N_FILL_DOCK = [
@@ -340,35 +339,6 @@ class RoborockClientV1(RoborockClient, ABC):
         """Load the map into the vacuum's memory."""
         await self.send_command(RoborockCommand.LOAD_MULTI_MAP, [map_flag])
 
-    def _get_payload(
-        self,
-        method: RoborockCommand | str,
-        params: list | dict | int | None = None,
-        secured=False,
-    ):
-        timestamp = math.floor(time.time())
-        request_id = get_next_int(10000, 32767)
-        inner = {
-            "id": request_id,
-            "method": method,
-            "params": params or [],
-        }
-        if secured:
-            inner["security"] = {
-                "endpoint": self._endpoint,
-                "nonce": self._nonce.hex().lower(),
-            }
-        payload = bytes(
-            json.dumps(
-                {
-                    "dps": {"101": json.dumps(inner, separators=(",", ":"))},
-                    "t": timestamp,
-                },
-                separators=(",", ":"),
-            ).encode()
-        )
-        return request_id, timestamp, payload
-
     @abstractmethod
     async def _send_command(
         self,

{python_roborock-2.24.0 → python_roborock-2.25.1}/roborock/version_1_apis/roborock_local_client_v1.py

@@ -4,9 +4,10 @@ from roborock.local_api import RoborockLocalClient
 
 from .. import CommandVacuumError, DeviceData, RoborockCommand, RoborockException
 from ..exceptions import VacuumError
-from ..roborock_message import MessageRetry, RoborockMessage, RoborockMessageProtocol
+from ..protocols.v1_protocol import encode_local_payload
+from ..roborock_message import RoborockMessage, RoborockMessageProtocol
 from ..util import RoborockLoggerAdapter
-from .roborock_client_v1 import COMMANDS_SECURED, RoborockClientV1
+from .roborock_client_v1 import CLOUD_REQUIRED, RoborockClientV1
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -21,26 +22,16 @@ class RoborockLocalClientV1(RoborockLocalClient, RoborockClientV1):
         self.queue_timeout = queue_timeout
         self._logger = RoborockLoggerAdapter(device_data.device.name, _LOGGER)
 
-    def build_roborock_message(
-        self, method: RoborockCommand | str, params: list | dict | int | None = None
-    ) -> RoborockMessage:
-        secured = True if method in COMMANDS_SECURED else False
-        request_id, timestamp, payload = self._get_payload(method, params, secured)
-        self._logger.debug("Building message id %s for method %s", request_id, method)
-        request_protocol = RoborockMessageProtocol.GENERAL_REQUEST
-        message_retry: MessageRetry | None = None
-        if method == RoborockCommand.RETRY_REQUEST and isinstance(params, dict):
-            message_retry = MessageRetry(method=params["method"], retry_id=params["retry_id"])
-        return RoborockMessage(
-            timestamp=timestamp, protocol=request_protocol, payload=payload, message_retry=message_retry
-        )
-
     async def _send_command(
         self,
         method: RoborockCommand | str,
         params: list | dict | int | None = None,
     ):
-        roborock_message = self.build_roborock_message(method, params)
+        if method in CLOUD_REQUIRED:
+            raise RoborockException(f"Method {method} is not supported over local connection")
+
+        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)
 
     async def send_message(self, roborock_message: RoborockMessage):

{python_roborock-2.24.0 → python_roborock-2.25.1}/roborock/version_1_apis/roborock_mqtt_client_v1.py

@@ -11,6 +11,7 @@ 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 ..roborock_message import (
     RoborockMessage,
     RoborockMessageProtocol,
@@ -36,6 +37,9 @@ class RoborockMqttClientV1(RoborockMqttClient, RoborockClientV1):
         RoborockClientV1.__init__(self, device_info, endpoint)
         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),
+        )
 
     async def send_message(self, roborock_message: RoborockMessage):
         await self.validate_connection()
@@ -78,10 +82,9 @@ class RoborockMqttClientV1(RoborockMqttClient, RoborockClientV1):
         if method in CUSTOM_COMMANDS:
             # When we have more custom commands do something more complicated here
             return await self._get_calibration_points()
-        request_id, timestamp, payload = self._get_payload(method, params, True)
-        self._logger.debug("Building message id %s for method %s", request_id, method)
-        request_protocol = RoborockMessageProtocol.RPC_REQUEST
-        roborock_message = RoborockMessage(timestamp=timestamp, protocol=request_protocol, payload=payload)
+
+        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):