python-roborock 3.19.0__tar.gz → 3.20.0__tar.gz

{python_roborock-3.19.0 → python_roborock-3.20.0}/PKG-INFO

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

{python_roborock-3.19.0 → python_roborock-3.20.0}/pyproject.toml

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

{python_roborock-3.19.0 → python_roborock-3.20.0}/roborock/callbacks.py

@@ -121,7 +121,7 @@ def decoder_callback(
 
     def wrapper(data: K) -> None:
         if not (messages := decoder(data)):
-            logger.warning("Failed to decode message: %s", data)
+            logger.debug("Failed to decode message: %s", data)
             return
         for message in messages:
             logger.debug("Decoded message: %s", message)

{python_roborock-3.19.0 → python_roborock-3.20.0}/roborock/data/b01_q7/b01_q7_code_mappings.py

@@ -24,7 +24,6 @@ class SCWindMapping(RoborockModeEnum):
     STANDARD = ("balanced", 1)
     STRONG = ("turbo", 2)
     SUPER_STRONG = ("max", 3)
-    MAX = ("max_plus", 4)
 
 
 class WaterLevelMapping(RoborockModeEnum):
@@ -50,6 +49,14 @@ class CleanRepeatMapping(RoborockModeEnum):
     TWICE = ("twice", 1)
 
 
+class SCDeviceCleanParam(RoborockModeEnum):
+    """Maps the control values for cleaning tasks."""
+
+    STOP = ("stop", 0)
+    START = ("start", 1)
+    PAUSE = ("pause", 2)
+
+
 class WorkModeMapping(RoborockModeEnum):
     """Maps the detailed work modes of the robot."""
 

python_roborock-3.20.0/roborock/devices/b01_channel.py

@@ -0,0 +1,129 @@
+"""Thin wrapper around the MQTT channel for Roborock B01 devices."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from typing import Any
+
+from roborock.exceptions import RoborockException
+from roborock.protocols.b01_protocol import (
+    CommandType,
+    ParamsType,
+    decode_rpc_response,
+    encode_mqtt_payload,
+)
+from roborock.roborock_message import RoborockMessage
+from roborock.util import get_next_int
+
+from .mqtt_channel import MqttChannel
+
+_LOGGER = logging.getLogger(__name__)
+_TIMEOUT = 10.0
+
+
+async def send_decoded_command(
+    mqtt_channel: MqttChannel,
+    dps: int,
+    command: CommandType,
+    params: ParamsType,
+) -> dict[str, Any] | None:
+    """Send a command on the MQTT channel and get a decoded response."""
+    msg_id = str(get_next_int(100000000000, 999999999999))
+    _LOGGER.debug(
+        "Sending B01 MQTT command: dps=%s method=%s msg_id=%s params=%s",
+        dps,
+        command,
+        msg_id,
+        params,
+    )
+    roborock_message = encode_mqtt_payload(dps, command, params, msg_id)
+    future: asyncio.Future[Any] = asyncio.get_running_loop().create_future()
+
+    def find_response(response_message: RoborockMessage) -> None:
+        """Handle incoming messages and resolve the future."""
+        try:
+            decoded_dps = decode_rpc_response(response_message)
+        except RoborockException as ex:
+            _LOGGER.debug(
+                "Failed to decode B01 RPC response (expecting method=%s msg_id=%s): %s: %s",
+                command,
+                msg_id,
+                response_message,
+                ex,
+            )
+            return
+
+        for dps_value in decoded_dps.values():
+            # valid responses are JSON strings wrapped in the dps value
+            if not isinstance(dps_value, str):
+                _LOGGER.debug("Received unexpected response: %s", dps_value)
+                continue
+
+            try:
+                inner = json.loads(dps_value)
+            except (json.JSONDecodeError, TypeError):
+                _LOGGER.debug("Received unexpected response: %s", dps_value)
+                continue
+
+            if isinstance(inner, dict) and inner.get("msgId") == msg_id:
+                _LOGGER.debug("Received query response: %s", inner)
+                # Check for error code (0 = success, non-zero = error)
+                code = inner.get("code", 0)
+                if code != 0:
+                    error_msg = (
+                        f"B01 command failed with code {code} "
+                        f"(method={command}, msg_id={msg_id}, dps={dps}, params={params})"
+                    )
+                    _LOGGER.debug("B01 error response: %s", error_msg)
+                    if not future.done():
+                        future.set_exception(RoborockException(error_msg))
+                    return
+                data = inner.get("data")
+                # All get commands should be dicts
+                if command.endswith(".get") and not isinstance(data, dict):
+                    if not future.done():
+                        future.set_exception(
+                            RoborockException(
+                                f"Unexpected data type for response "
+                                f"(method={command}, msg_id={msg_id}, dps={dps}, params={params})"
+                            )
+                        )
+                    return
+                if not future.done():
+                    future.set_result(data)
+
+    unsub = await mqtt_channel.subscribe(find_response)
+
+    _LOGGER.debug("Sending MQTT message: %s", roborock_message)
+    try:
+        await mqtt_channel.publish(roborock_message)
+        return await asyncio.wait_for(future, timeout=_TIMEOUT)
+    except TimeoutError as ex:
+        raise RoborockException(
+            f"B01 command timed out after {_TIMEOUT}s (method={command}, msg_id={msg_id}, dps={dps}, params={params})"
+        ) from ex
+    except RoborockException as ex:
+        _LOGGER.warning(
+            "Error sending B01 decoded command (method=%s msg_id=%s dps=%s params=%s): %s",
+            command,
+            msg_id,
+            dps,
+            params,
+            ex,
+        )
+        raise
+
+    except Exception as ex:
+        _LOGGER.exception(
+            "Error sending B01 decoded command (method=%s msg_id=%s dps=%s params=%s): %s",
+            command,
+            msg_id,
+            dps,
+            params,
+            ex,
+        )
+        raise
+    finally:
+        unsub()

{python_roborock-3.19.0 → python_roborock-3.20.0}/roborock/devices/mqtt_channel.py

@@ -87,7 +87,7 @@ class MqttChannel(Channel):
         try:
             return await self._mqtt_session.publish(self._publish_topic, encoded_msg)
         except MqttSessionException as e:
-            self._logger.exception("Error publishing MQTT message: %s", e)
+            self._logger.debug("Error publishing MQTT message: %s", e)
             raise RoborockException(f"Failed to publish MQTT message: {e}") from e
 
     async def restart(self) -> None:

python_roborock-3.20.0/roborock/devices/traits/b01/q7/__init__.py

@@ -0,0 +1,115 @@
+"""Traits for Q7 B01 devices.
+Potentially other devices may fall into this category in the future."""
+
+from typing import Any
+
+from roborock import B01Props
+from roborock.data.b01_q7.b01_q7_code_mappings import (
+    CleanTaskTypeMapping,
+    SCDeviceCleanParam,
+    SCWindMapping,
+    WaterLevelMapping,
+)
+from roborock.devices.b01_channel import send_decoded_command
+from roborock.devices.mqtt_channel import MqttChannel
+from roborock.devices.traits import Trait
+from roborock.roborock_message import RoborockB01Props
+from roborock.roborock_typing import RoborockB01Q7Methods
+
+__all__ = [
+    "Q7PropertiesApi",
+]
+
+
+class Q7PropertiesApi(Trait):
+    """API for interacting with B01 devices."""
+
+    def __init__(self, channel: MqttChannel) -> None:
+        """Initialize the B01Props API."""
+        self._channel = channel
+
+    async def query_values(self, props: list[RoborockB01Props]) -> B01Props | None:
+        """Query the device for the values of the given Q7 properties."""
+        result = await self.send(
+            RoborockB01Q7Methods.GET_PROP,
+            {"property": props},
+        )
+        if not isinstance(result, dict):
+            raise TypeError(f"Unexpected response type for GET_PROP: {type(result).__name__}: {result!r}")
+        return B01Props.from_dict(result)
+
+    async def set_prop(self, prop: RoborockB01Props, value: Any) -> None:
+        """Set a property on the device."""
+        await self.send(
+            command=RoborockB01Q7Methods.SET_PROP,
+            params={prop: value},
+        )
+
+    async def set_fan_speed(self, fan_speed: SCWindMapping) -> None:
+        """Set the fan speed (wind)."""
+        await self.set_prop(RoborockB01Props.WIND, fan_speed.code)
+
+    async def set_water_level(self, water_level: WaterLevelMapping) -> None:
+        """Set the water level (water)."""
+        await self.set_prop(RoborockB01Props.WATER, water_level.code)
+
+    async def start_clean(self) -> None:
+        """Start cleaning."""
+        await self.send(
+            command=RoborockB01Q7Methods.SET_ROOM_CLEAN,
+            params={
+                "clean_type": CleanTaskTypeMapping.ALL.code,
+                "ctrl_value": SCDeviceCleanParam.START.code,
+                "room_ids": [],
+            },
+        )
+
+    async def pause_clean(self) -> None:
+        """Pause cleaning."""
+        await self.send(
+            command=RoborockB01Q7Methods.SET_ROOM_CLEAN,
+            params={
+                "clean_type": CleanTaskTypeMapping.ALL.code,
+                "ctrl_value": SCDeviceCleanParam.PAUSE.code,
+                "room_ids": [],
+            },
+        )
+
+    async def stop_clean(self) -> None:
+        """Stop cleaning."""
+        await self.send(
+            command=RoborockB01Q7Methods.SET_ROOM_CLEAN,
+            params={
+                "clean_type": CleanTaskTypeMapping.ALL.code,
+                "ctrl_value": SCDeviceCleanParam.STOP.code,
+                "room_ids": [],
+            },
+        )
+
+    async def return_to_dock(self) -> None:
+        """Return to dock."""
+        await self.send(
+            command=RoborockB01Q7Methods.START_RECHARGE,
+            params={},
+        )
+
+    async def find_me(self) -> None:
+        """Locate the robot."""
+        await self.send(
+            command=RoborockB01Q7Methods.FIND_DEVICE,
+            params={},
+        )
+
+    async def send(self, command: RoborockB01Q7Methods, params: dict) -> Any:
+        """Send a command to the device."""
+        return await send_decoded_command(
+            self._channel,
+            dps=10000,
+            command=command,
+            params=params,
+        )
+
+
+def create(channel: MqttChannel) -> Q7PropertiesApi:
+    """Create traits for B01 devices."""
+    return Q7PropertiesApi(channel)

{python_roborock-3.19.0 → python_roborock-3.20.0}/roborock/protocol.py

@@ -276,7 +276,7 @@ class EncryptionAdapter(Construct):
         if context.version == b"A01":
             iv = md5hex(format(context.random, "08x") + A01_HASH)[8:24]
             decipher = AES.new(bytes(context.search("local_key"), "utf-8"), AES.MODE_CBC, bytes(iv, "utf-8"))
-            return decipher.encrypt(pad(obj, AES.block_size))
+            return decipher.encrypt(obj)
         elif context.version == b"B01":
             iv = md5hex(f"{context.random:08x}" + B01_HASH)[9:25]
             decipher = AES.new(bytes(context.search("local_key"), "utf-8"), AES.MODE_CBC, bytes(iv, "utf-8"))
@@ -300,7 +300,7 @@ class EncryptionAdapter(Construct):
         if context.version == b"A01":
             iv = md5hex(format(context.random, "08x") + A01_HASH)[8:24]
             decipher = AES.new(bytes(context.search("local_key"), "utf-8"), AES.MODE_CBC, bytes(iv, "utf-8"))
-            return unpad(decipher.decrypt(obj), AES.block_size)
+            return decipher.decrypt(obj)
         elif context.version == b"B01":
             iv = md5hex(f"{context.random:08x}" + B01_HASH)[9:25]
             decipher = AES.new(bytes(context.search("local_key"), "utf-8"), AES.MODE_CBC, bytes(iv, "utf-8"))

{python_roborock-3.19.0 → python_roborock-3.20.0}/roborock/protocols/b01_protocol.py

@@ -28,7 +28,10 @@ def encode_mqtt_payload(dps: int, command: CommandType, params: ParamsType, msg_
             dps: {
                 "method": str(command),
                 "msgId": msg_id,
-                "params": params or [],
+                # Important: some B01 methods use an empty object `{}` (not `[]`) for
+                # "no params", and some setters legitimately send `0` which is falsy.
+                # Only default to `[]` when params is actually None.
+                "params": params if params is not None else [],
             }
         }
     }

{python_roborock-3.19.0 → python_roborock-3.20.0}/roborock/roborock_typing.py

@@ -280,6 +280,60 @@ class RoborockCommand(str, Enum):
 class RoborockB01Q7Methods(StrEnum):
     """Methods used by the Roborock Q7 model."""
 
+    # NOTE: In the Q7 Hermes dump these appear as suffixes and are also used
+    # with an "event." prefix at runtime (see `hermes/.../module_524.js`).
+    ADD_CLEAN_FAILED_POST = "add_clean_failed.post"
+    EVENT_ADD_CLEAN_FAILED_POST = "event.add_clean_failed.post"
+    CLEAN_FINISH_POST = "clean_finish.post"
+    EVENT_CLEAN_FINISH_POST = "event.clean_finish.post"
+    EVENT_BUILD_MAP_FINISH_POST = "event.BuildMapFinish.post"
+    EVENT_MAP_CHANGE_POST = "event.map_change.post"
+    EVENT_WORK_APPOINT_CLEAN_FAILED_POST = "event.work_appoint_clean_failed.post"
+    START_CLEAN_POST = "startClean.post"
+    ADD_ORDER = "service.add_order"
+    ADD_SWEEP_CLEAN = "service.add_sweep_clean"
+    ARRANGE_ROOM = "service.arrange_room"
+    DEL_MAP = "service.del_map"
+    DEL_ORDER = "service.del_order"
+    DEL_ORDERS = "service.del_orders"
+    DELETE_RECORD_BY_URL = "service.delete_record_by_url"
+    DOWNLOAD_VOICE_TYPE = "service.download_voice_type"
+    ERASE_PREFERENCE = "service.erase_preference"
+    FIND_DEVICE = "service.find_device"
+    GET_ROOM_ORDER = "service.get_room_order"
+    GET_VOICE_DOWNLOAD = "service.get_voice_download"
+    HELLO_WIKKA = "service.hello_wikka"
+    RENAME_MAP = "service.rename_map"
+    RENAME_ROOM = "service.rename_room"
+    RENAME_ROOMS = "service.rename_rooms"
+    REPLACE_MAP = "service.replace_map"
+    RESET_CONSUMABLE = "service.reset_consumable"
+    SAVE_CARPET = "service.save_carpet"
+    SAVE_RECOMMEND_FB = "service.save_recommend_fb"
+    SAVE_SILL = "service.save_sill"
+    SET_AREA_START = "service.set_area_start"
+    SET_AREAS_START = "service.set_areas_start"
+    SET_CUR_MAP = "service.set_cur_map"
+    SET_DIRECTION = "service.set_direction"
+    SET_GLOBAL_SORT = "service.set_global_sort"
+    SET_MAP_HIDE = "service.set_map_hide"
+    SET_MULTI_ROOM_MATERIAL = "service.set_multi_room_material"
+    SET_POINT_CLEAN = "service.set_point_clean"
+    SET_PREFERENCE = "service.set_preference"
+    SET_PREFERENCE_TYPE = "service.set_preference_type"
+    SET_QUIET_TIME = "service.set_quiet_time"
+    SET_ROOM_CLEAN = "service.set_room_clean"
+    SET_ROOM_ORDER = "service.set_room_order"
+    SET_VIRTUAL_WALL = "service.set_virtual_wall"
+    SET_ZONE_CLEAN = "service.set_zone_clean"
+    SET_ZONE_POINTS = "service.set_zone_points"
+    SPLIT_ROOM = "service.split_room"
+    START_EXPLORE = "service.start_explore"
+    START_POINT_CLEAN = "service.start_point_clean"
+    START_RECHARGE = "service.start_recharge"
+    STOP_RECHARGE = "service.stop_recharge"
+    UPLOAD_BY_MAPID = "service.upload_by_mapid"
+    UPLOAD_RECORD_BY_URL = "service.upload_record_by_url"
     GET_PROP = "prop.get"
     GET_MAP_LIST = "service.get_map_list"
     UPLOAD_BY_MAPTYPE = "service.upload_by_maptype"
@@ -287,7 +341,6 @@ class RoborockB01Q7Methods(StrEnum):
     GET_PREFERENCE = "service.get_preference"
     GET_RECORD_LIST = "service.get_record_list"
     GET_ORDER = "service.get_order"
-    EVENT_ORDER_LIST_POST = "event.order_list.post"
     POST_PROP = "prop.post"
 
 

python_roborock-3.19.0/roborock/devices/b01_channel.py

@@ -1,77 +0,0 @@
-"""Thin wrapper around the MQTT channel for Roborock B01 devices."""
-
-from __future__ import annotations
-
-import asyncio
-import json
-import logging
-from typing import Any
-
-from roborock.exceptions import RoborockException
-from roborock.protocols.b01_protocol import (
-    CommandType,
-    ParamsType,
-    decode_rpc_response,
-    encode_mqtt_payload,
-)
-from roborock.roborock_message import RoborockMessage
-from roborock.util import get_next_int
-
-from .mqtt_channel import MqttChannel
-
-_LOGGER = logging.getLogger(__name__)
-_TIMEOUT = 10.0
-
-
-async def send_decoded_command(
-    mqtt_channel: MqttChannel,
-    dps: int,
-    command: CommandType,
-    params: ParamsType,
-) -> dict[str, Any]:
-    """Send a command on the MQTT channel and get a decoded response."""
-    _LOGGER.debug("Sending MQTT command: %s", params)
-    msg_id = str(get_next_int(100000000000, 999999999999))
-    roborock_message = encode_mqtt_payload(dps, command, params, msg_id)
-    future: asyncio.Future[dict[str, Any]] = asyncio.get_running_loop().create_future()
-
-    def find_response(response_message: RoborockMessage) -> None:
-        """Handle incoming messages and resolve the future."""
-        try:
-            decoded_dps = decode_rpc_response(response_message)
-        except RoborockException as ex:
-            _LOGGER.info("Failed to decode b01 message: %s: %s", response_message, ex)
-            return
-
-        for dps_value in decoded_dps.values():
-            # valid responses are JSON strings wrapped in the dps value
-            if not isinstance(dps_value, str):
-                _LOGGER.debug("Received unexpected response: %s", dps_value)
-                continue
-
-            try:
-                inner = json.loads(dps_value)
-            except (json.JSONDecodeError, TypeError):
-                _LOGGER.debug("Received unexpected response: %s", dps_value)
-                continue
-
-            if isinstance(inner, dict) and inner.get("msgId") == msg_id:
-                _LOGGER.debug("Received query response: %s", inner)
-                data = inner.get("data")
-                if not future.done():
-                    if isinstance(data, dict):
-                        future.set_result(data)
-                    else:
-                        future.set_exception(RoborockException(f"Unexpected data type for response: {data}"))
-
-    unsub = await mqtt_channel.subscribe(find_response)
-
-    _LOGGER.debug("Sending MQTT message: %s", roborock_message)
-    try:
-        await mqtt_channel.publish(roborock_message)
-        try:
-            return await asyncio.wait_for(future, timeout=_TIMEOUT)
-        except TimeoutError as ex:
-            raise RoborockException(f"Command timed out after {_TIMEOUT}s") from ex
-    finally:
-        unsub()

python_roborock-3.19.0/roborock/devices/traits/b01/q7/__init__.py

@@ -1,33 +0,0 @@
-"""Traits for Q7 B01 devices.
-Potentially other devices may fall into this category in the future."""
-
-from roborock import B01Props
-from roborock.devices.b01_channel import send_decoded_command
-from roborock.devices.mqtt_channel import MqttChannel
-from roborock.devices.traits import Trait
-from roborock.roborock_message import RoborockB01Props
-from roborock.roborock_typing import RoborockB01Q7Methods
-
-__all__ = [
-    "Q7PropertiesApi",
-]
-
-
-class Q7PropertiesApi(Trait):
-    """API for interacting with B01 devices."""
-
-    def __init__(self, channel: MqttChannel) -> None:
-        """Initialize the B01Props API."""
-        self._channel = channel
-
-    async def query_values(self, props: list[RoborockB01Props]) -> B01Props | None:
-        """Query the device for the values of the given Q7 properties."""
-        result = await send_decoded_command(
-            self._channel, dps=10000, command=RoborockB01Q7Methods.GET_PROP, params={"property": props}
-        )
-        return B01Props.from_dict(result)
-
-
-def create(channel: MqttChannel) -> Q7PropertiesApi:
-    """Create traits for B01 devices."""
-    return Q7PropertiesApi(channel)