python-roborock 2.34.1__tar.gz → 2.35.0__tar.gz

{python_roborock-2.34.1 → python_roborock-2.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-roborock
-Version: 2.34.1
+Version: 2.35.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.1 → python_roborock-2.35.0}/pyproject.toml

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

{python_roborock-2.34.1 → python_roborock-2.35.0}/roborock/api.py

@@ -116,7 +116,3 @@ class RoborockClient(ABC):
             request_id = new_id
         self._waiting_queue[request_id] = queue
         return asyncio.ensure_future(self._wait_response(request_id, queue))
-
-    @abstractmethod
-    async def send_message(self, roborock_message: RoborockMessage):
-        """Send a message to the Roborock device."""

python_roborock-2.35.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.1 → python_roborock-2.35.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.1 → python_roborock-2.35.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.1/roborock/local_api.py → python_roborock-2.35.0/roborock/version_1_apis/roborock_local_client_v1.py

@@ -1,23 +1,36 @@
-from __future__ import annotations
-
 import asyncio
 import logging
-from abc import ABC
 from asyncio import Lock, TimerHandle, Transport, get_running_loop
 from collections.abc import Callable
 from dataclasses import dataclass
 
 import async_timeout
 
-from . import DeviceData
-from .api import RoborockClient
-from .exceptions import RoborockConnectionException, RoborockException
-from .protocol import Decoder, Encoder, create_local_decoder, create_local_encoder
-from .roborock_message import RoborockMessage, RoborockMessageProtocol
+from .. import CommandVacuumError, DeviceData, RoborockCommand
+from ..api import RoborockClient
+from ..exceptions import RoborockConnectionException, RoborockException, VacuumError
+from ..protocol import Decoder, Encoder, create_local_decoder, create_local_encoder
+from ..protocols.v1_protocol import encode_local_payload
+from ..roborock_message import RoborockMessage, RoborockMessageProtocol
+from ..util import RoborockLoggerAdapter
+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."""
@@ -34,10 +47,10 @@ class _LocalProtocol(asyncio.Protocol):
         self.connection_lost_cb(exc)
 
 
-class RoborockLocalClient(RoborockClient, ABC):
-    """Roborock local client base class."""
+class RoborockLocalClientV1(RoborockClientV1, RoborockClient):
+    """Roborock local client for v1 devices."""
 
-    def __init__(self, device_data: DeviceData):
+    def __init__(self, device_data: DeviceData, queue_timeout: int = 4):
         """Initialize the Roborock local client."""
         if device_data.host is None:
             raise RoborockException("Host is required")
@@ -47,10 +60,13 @@ class RoborockLocalClient(RoborockClient, ABC):
         self.transport: Transport | None = None
         self._mutex = Lock()
         self.keep_alive_task: TimerHandle | None = None
+        RoborockClientV1.__init__(self, device_data, "abc")
         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)
         self._decoder: Decoder = create_local_decoder(device_data.device.local_key)
+        self.queue_timeout = queue_timeout
+        self._logger = RoborockLoggerAdapter(device_data.device.name, _LOGGER)
 
     def _data_received(self, message):
         """Called when data is received from the transport."""
@@ -106,29 +122,13 @@ class RoborockLocalClient(RoborockClient, ABC):
             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:
@@ -137,3 +137,56 @@ class RoborockLocalClient(RoborockClient, ABC):
             self.transport.write(data)
         except Exception as e:
             raise RoborockException(e) from e
+
+    async def _send_command(
+        self,
+        method: RoborockCommand | str,
+        params: list | dict | int | None = None,
+    ):
+        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, method, params)
+
+    async def _send_message(
+        self,
+        roborock_message: RoborockMessage,
+        method: str | None = None,
+        params: list | dict | int | None = None,
+    ) -> RoborockMessage:
+        await self.validate_connection()
+        request_id: int | None
+        if not method or not method.startswith("get"):
+            request_id = roborock_message.seq
+            response_protocol = request_id + 1
+        else:
+            request_id = roborock_message.get_request_id()
+            response_protocol = RoborockMessageProtocol.GENERAL_REQUEST
+        if request_id is None:
+            raise RoborockException(f"Failed build message {roborock_message}")
+        msg = self._encoder(roborock_message)
+        if method:
+            self._logger.debug(f"id={request_id} Requesting method {method} with {params}")
+        # Send the command to the Roborock device
+        async_response = self._async_response(request_id, response_protocol)
+        self._send_msg_raw(msg)
+        diagnostic_key = method if method is not None else "unknown"
+        try:
+            response = await async_response
+        except VacuumError as err:
+            self._diagnostic_data[diagnostic_key] = {
+                "params": params,
+                "error": err,
+            }
+            raise CommandVacuumError(method, err) from err
+        self._diagnostic_data[diagnostic_key] = {
+            "params": params,
+            "response": response,
+        }
+        if roborock_message.protocol == RoborockMessageProtocol.GENERAL_REQUEST:
+            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.1 → python_roborock-2.35.0}/roborock/version_1_apis/roborock_mqtt_client_v1.py

@@ -13,7 +13,6 @@ 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,
 )
 from ..roborock_typing import RoborockCommand
@@ -41,10 +40,19 @@ class RoborockMqttClientV1(RoborockMqttClient, RoborockClientV1):
             SecurityData(endpoint=self._endpoint, nonce=self._nonce),
         )
 
-    async def send_message(self, roborock_message: RoborockMessage):
+    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)
+
         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 +68,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 +82,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(), [])

{python_roborock-2.34.1 → python_roborock-2.35.0}/roborock/version_a01_apis/roborock_mqtt_client_a01.py

@@ -39,7 +39,7 @@ class RoborockMqttClientA01(RoborockMqttClient, RoborockClientA01):
         self.queue_timeout = queue_timeout
         self._logger = RoborockLoggerAdapter(device_info.device.name, _LOGGER)
 
-    async def send_message(self, roborock_message: RoborockMessage):
+    async def _send_message(self, roborock_message: RoborockMessage):
         await self.validate_connection()
         response_protocol = RoborockMessageProtocol.RPC_RESPONSE
 
@@ -67,11 +67,11 @@ class RoborockMqttClientA01(RoborockMqttClient, RoborockClientA01):
         message = encode_mqtt_payload(
             {RoborockDyadDataProtocol.ID_QUERY: str([int(protocol) for protocol in dyad_data_protocols])}
         )
-        return await self.send_message(message)
+        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."""
         message = encode_mqtt_payload({protocol: value})
-        return await self.send_message(message)
+        return await self._send_message(message)

python_roborock-2.34.1/roborock/version_1_apis/roborock_local_client_v1.py

@@ -1,73 +0,0 @@
-import logging
-
-from roborock.local_api import RoborockLocalClient
-
-from .. import CommandVacuumError, DeviceData, RoborockCommand, RoborockException
-from ..exceptions import VacuumError
-from ..protocols.v1_protocol import encode_local_payload
-from ..roborock_message import RoborockMessage, RoborockMessageProtocol
-from ..util import RoborockLoggerAdapter
-from .roborock_client_v1 import CLOUD_REQUIRED, RoborockClientV1
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class RoborockLocalClientV1(RoborockLocalClient, RoborockClientV1):
-    """Roborock local client for v1 devices."""
-
-    def __init__(self, device_data: DeviceData, queue_timeout: int = 4):
-        """Initialize the Roborock local client."""
-        RoborockLocalClient.__init__(self, device_data)
-        RoborockClientV1.__init__(self, device_data, "abc")
-        self.queue_timeout = queue_timeout
-        self._logger = RoborockLoggerAdapter(device_data.device.name, _LOGGER)
-
-    async def _send_command(
-        self,
-        method: RoborockCommand | str,
-        params: list | dict | int | None = None,
-    ):
-        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):
-        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
-            response_protocol = request_id + 1
-        else:
-            request_id = roborock_message.get_request_id()
-            response_protocol = RoborockMessageProtocol.GENERAL_REQUEST
-        if request_id is None:
-            raise RoborockException(f"Failed build message {roborock_message}")
-        msg = self._encoder(roborock_message)
-        if method:
-            self._logger.debug(f"id={request_id} Requesting method {method} with {params}")
-        # Send the command to the Roborock device
-        async_response = self._async_response(request_id, response_protocol)
-        self._send_msg_raw(msg)
-        diagnostic_key = method if method is not None else "unknown"
-        try:
-            response = await async_response
-        except VacuumError as err:
-            self._diagnostic_data[diagnostic_key] = {
-                "params": roborock_message.get_params(),
-                "error": err,
-            }
-            raise CommandVacuumError(method, err) from err
-        self._diagnostic_data[diagnostic_key] = {
-            "params": roborock_message.get_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}")
-        if response == "retry":
-            raise RoborockException(f"Command {method} failed with 'retry' message; Device is busy, try again later")
-        return response