python-roborock 2.20.0__tar.gz → 2.22.0__tar.gz

{python_roborock-2.20.0 → python_roborock-2.22.0}/PKG-INFO

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

{python_roborock-2.20.0 → python_roborock-2.22.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-roborock"
-version = "2.20.0"
+version = "2.22.0"
 description = "A package to control Roborock vacuums."
 authors = ["humbertogontijo <humbertogontijo@users.noreply.github.com>"]
 license = "GPL-3.0-only"
@@ -75,4 +75,4 @@ select=["E", "F", "UP", "I"]
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 asyncio_default_fixture_loop_scope = "function"
-timeout = 20
+timeout = 30

{python_roborock-2.20.0 → python_roborock-2.22.0}/roborock/cli.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import json
 import logging
 from pathlib import Path
@@ -12,7 +13,8 @@ from pyshark.packet.packet import Packet  # type: ignore
 
 from roborock import RoborockException
 from roborock.containers import DeviceData, HomeDataProduct, LoginData
-from roborock.protocol import MessageParser
+from roborock.mqtt.roborock_session import create_mqtt_session
+from roborock.protocol import MessageParser, create_mqtt_params
 from roborock.util import run_sync
 from roborock.version_1_apis.roborock_local_client_v1 import RoborockLocalClientV1
 from roborock.version_1_apis.roborock_mqtt_client_v1 import RoborockMqttClientV1
@@ -45,7 +47,8 @@ class RoborockContext:
         if self._login_data is None:
             raise RoborockException("You must login first")
 
-    def login_data(self):
+    def login_data(self) -> LoginData:
+        """Get the login data."""
         self.validate()
         return self._login_data
 
@@ -62,7 +65,11 @@ def cli(ctx, debug: int):
 
 @click.command()
 @click.option("--email", required=True)
-@click.option("--password", required=True)
+@click.option(
+    "--password",
+    required=False,
+    help="Password for the Roborock account. If not provided, an email code will be requested.",
+)
 @click.pass_context
 @run_sync()
 async def login(ctx, email, password):
@@ -75,10 +82,65 @@ async def login(ctx, email, password):
     except RoborockException:
         pass
     client = RoborockApiClient(email)
-    user_data = await client.pass_login(password)
+    if password is not None:
+        user_data = await client.pass_login(password)
+    else:
+        print(f"Requesting code for {email}")
+        await client.request_code()
+        code = click.prompt("A code has been sent to your email, please enter the code", type=str)
+        user_data = await client.code_login(code)
+        print("Login successful")
     context.update(LoginData(user_data=user_data, email=email))
 
 
+@click.command()
+@click.pass_context
+@click.option("--duration", default=10, help="Duration to run the MQTT session in seconds")
+@run_sync()
+async def session(ctx, duration: int):
+    context: RoborockContext = ctx.obj
+    login_data = context.login_data()
+
+    # Discovery devices if not already available
+    if not login_data.home_data:
+        await _discover(ctx)
+        login_data = context.login_data()
+    if not login_data.home_data or not login_data.home_data.devices:
+        raise RoborockException("Unable to discover devices")
+
+    all_devices = login_data.home_data.devices + login_data.home_data.received_devices
+    click.echo(f"Discovered devices: {', '.join([device.name for device in all_devices])}")
+
+    rriot = login_data.user_data.rriot
+    params = create_mqtt_params(rriot)
+
+    mqtt_session = await create_mqtt_session(params)
+    click.echo("Starting MQTT session...")
+    if not mqtt_session.connected:
+        raise RoborockException("Failed to connect to MQTT broker")
+
+    def on_message(bytes: bytes):
+        """Callback function to handle incoming MQTT messages."""
+        # Decode the first 20 bytes of the message for display
+        bytes = bytes[:20]
+
+        click.echo(f"Received message: {bytes}...")
+
+    unsubs = []
+    for device in all_devices:
+        device_topic = f"rr/m/o/{rriot.u}/{params.username}/{device.duid}"
+        unsub = await mqtt_session.subscribe(device_topic, on_message)
+        unsubs.append(unsub)
+
+    click.echo("MQTT session started. Listening for messages...")
+    await asyncio.sleep(duration)
+
+    click.echo("Stopping MQTT session...")
+    for unsub in unsubs:
+        unsub()
+    await mqtt_session.close()
+
+
 async def _discover(ctx):
     context: RoborockContext = ctx.obj
     login_data = context.login_data()
@@ -253,6 +315,7 @@ cli.add_command(execute_scene)
 cli.add_command(status)
 cli.add_command(command)
 cli.add_command(parser)
+cli.add_command(session)
 
 
 def main():

{python_roborock-2.20.0 → python_roborock-2.22.0}/roborock/cloud_api.py

@@ -6,14 +6,19 @@ import threading
 from abc import ABC
 from asyncio import Lock
 from typing import Any
-from urllib.parse import urlparse
 
 import paho.mqtt.client as mqtt
 
 from .api import KEEPALIVE, RoborockClient
 from .containers import DeviceData, UserData
 from .exceptions import RoborockException, VacuumError
-from .protocol import MessageParser, md5hex
+from .protocol import (
+    Decoder,
+    Encoder,
+    create_mqtt_decoder,
+    create_mqtt_encoder,
+    create_mqtt_params,
+)
 from .roborock_future import RoborockFuture
 
 _LOGGER = logging.getLogger(__name__)
@@ -53,27 +58,24 @@ class RoborockMqttClient(RoborockClient, ABC):
         if rriot is None:
             raise RoborockException("Got no rriot data from user_data")
         RoborockClient.__init__(self, device_info)
+        mqtt_params = create_mqtt_params(rriot)
         self._mqtt_user = rriot.u
-        self._hashed_user = md5hex(self._mqtt_user + ":" + rriot.k)[2:10]
-        url = urlparse(rriot.r.m)
-        if not isinstance(url.hostname, str):
-            raise RoborockException("Url parsing returned an invalid hostname")
-        self._mqtt_host = str(url.hostname)
-        self._mqtt_port = url.port
-        self._mqtt_ssl = url.scheme == "ssl"
+        self._hashed_user = mqtt_params.username
+        self._mqtt_host = mqtt_params.host
+        self._mqtt_port = mqtt_params.port
 
         self._mqtt_client = _Mqtt()
         self._mqtt_client.on_connect = self._mqtt_on_connect
         self._mqtt_client.on_message = self._mqtt_on_message
         self._mqtt_client.on_disconnect = self._mqtt_on_disconnect
-        if self._mqtt_ssl:
+        if mqtt_params.tls:
             self._mqtt_client.tls_set()
 
-        self._mqtt_password = rriot.s
-        self._hashed_password = md5hex(self._mqtt_password + ":" + rriot.k)[16:]
-        self._mqtt_client.username_pw_set(self._hashed_user, self._hashed_password)
+        self._mqtt_client.username_pw_set(mqtt_params.username, mqtt_params.password)
         self._waiting_queue: dict[int, RoborockFuture] = {}
         self._mutex = Lock()
+        self._decoder: Decoder = create_mqtt_decoder(device_info.device.local_key)
+        self._encoder: Encoder = create_mqtt_encoder(device_info.device.local_key)
 
     def _mqtt_on_connect(self, *args, **kwargs):
         _, __, ___, rc, ____ = args
@@ -102,7 +104,7 @@ class RoborockMqttClient(RoborockClient, ABC):
     def _mqtt_on_message(self, *args, **kwargs):
         client, __, msg = args
         try:
-            messages, _ = MessageParser.parse(msg.payload, local_key=self.device_info.device.local_key)
+            messages = self._decoder(msg.payload)
             super().on_message_received(messages)
         except Exception as ex:
             self._logger.exception(ex)

{python_roborock-2.20.0 → python_roborock-2.22.0}/roborock/containers.py

@@ -7,6 +7,7 @@ import re
 from dataclasses import asdict, dataclass, field
 from datetime import timezone
 from enum import Enum
+from functools import cached_property
 from typing import Any, NamedTuple, get_args, get_origin
 
 from .code_mappings import (
@@ -469,6 +470,21 @@ class HomeData(RoborockBase):
             devices += self.received_devices
         return devices
 
+    @cached_property
+    def product_map(self) -> dict[str, HomeDataProduct]:
+        """Returns a dictionary of product IDs to HomeDataProduct objects."""
+        return {product.id: product for product in self.products}
+
+    @cached_property
+    def device_products(self) -> dict[str, tuple[HomeDataDevice, HomeDataProduct]]:
+        """Returns a dictionary of device DUIDs to HomeDataDeviceProduct objects."""
+        product_map = self.product_map
+        return {
+            device.duid: (device, product)
+            for device in self.get_all_devices()
+            if (product := product_map.get(device.product_id)) is not None
+        }
+
 
 @dataclass
 class LoginData(RoborockBase):

python_roborock-2.22.0/roborock/devices/README.md

@@ -0,0 +1,98 @@
+# Roborock Device Discovery
+
+This page documents the full lifecycle of device discovery across Cloud and Network.
+
+## Init account setup
+
+### Login
+
+- Login can happen with either email and password or email and sending a code. We
+  currently prefer email with sending a code -- however the roborock no longer
+  supports this method of login. In the future we may want to migrate to password
+  if this login method is no longer supported.
+- The Login API provides a `userData` object with information on connecting to the cloud APIs
+- This `rriot` data contains per-session information, unique each time you login.
+  - This contains information used to connect to MQTT
+  - You get an `-eu` suffix in the API URLs if you are in the eu and `-us` if you are in the us
+
+## Home Data
+
+The `HomeData` includes information about the various devices in the home. We use `v3`
+and it is notable that if devices don't show up in the `home_data` response it is likely
+that a newer version of the API should be used.
+
+- `products`: This is a list of all of the products you have on your account. These objects are always the same (i.e. a s7 maxv is always the exact same.)
+  - It only shows the products for devices available on your account
+- `devices` and `received_devices`:
+  - These both share the same objects, but one is for devices that have been shared with you and one is those that are on your account.
+  - The big things here are (MOST are static):
+    - `duid`: A unique identifier for your device (this is always the same i think)
+    - `name`: The name of the device in your app
+    - `local_key`: The local key that is needed for encoding and decoding messages for the device. This stays the same unless someone sets their vacuum back up.
+    - `pv`: the protocol version (i.e. 1.0 or A1 or B1)
+    - `product_id`: The id of the product from the above products list.
+    - `device_status`: An initial status for some of the data we care about, though this changes on each update.
+- `rooms`: The rooms in the home.
+  - This changes if the user adds a new room or changes its name.
+  - We have to combine this with the room numbers from `GET_ROOM_MAPPING` on the device
+  - There is another REST request `get_rooms` that will do the same thing.
+  - Note: If we cache home_data, we likely need to use `get_rooms` to get rooms fresh
+
+## Device Connections
+
+### MQTT connection
+
+- Initial device information must be obtained from MQTT
+- We typically set up the MQTT device connection before the local device connection.
+  - The `NetworkingInfo` needs to be fetched to get additional information about connecting to the device:
+    - e.g. Local IP Address
+  - This networking info can be cached to reduce network calls
+  - MQTT also is the only way to get the device Map
+- Incoming and outgoing messages are decoded/encoded using the device `local_key`
+- Otherwise all commands may be performed locally.
+
+## Local connection
+
+- We can use the `ip` from the `NetworkingInfo` to find the device
+- The local connection is preferred to for improved latency and reducing load on the cloud servers to avoid rate limiting.
+- Connections are made using a normal TCP socket on port `58867`
+- Incoming and outgoing messages are decoded/encoded using the device `local_key`
+- Messages received on the stream may be partially received so we keep a running as messages are partially decoded
+
+## Design
+
+### Current API Issues
+
+- Complex Inheritance Hierarchy: Multiple inheritance with classes like RoborockMqttClientV1 inheriting from both RoborockMqttClient and RoborockClientV1
+
+- Callback-Heavy Design: Heavy reliance on callbacks and listeners in RoborockClientV1.on_message_received and the ListenerModel system
+
+- Version Fragmentation: Separate v1 and A01 APIs with different patterns and abstractions
+
+- Mixed Concerns: Classes handle both communication protocols (MQTT/local) and device-specific logic
+
+- Complex Caching: The AttributeCache system with RepeatableTask adds complexity
+
+- Manual Connection Management: Users need to manually set up both MQTT and local clients as shown in the README example
+
+## Design Changes
+
+- Prefer a single unfieid client that handles both MQTT and local connections internally.
+
+- Home and device discovery (fetching home data and device setup) will be behind a single API.
+
+- Asyncio First: Everything should be asyncio as much as possible, with fewer callbacks.
+
+- The clients should be working in terms of devices. We need to detect capabilities for each device and not expose details about API versions.
+
+- Reliability issues: The current Home Assistant integration has issues with reliability and needs to be simplified. It may be that there are bugs with the exception handling and it's too heavy the cloud APIs and could benefit from more seamless caching.
+
+## Implementation Details
+
+- We don't really need to worry about backwards compatibility for the new set of APIs.
+
+- We'll have a `RoborockManager` responsible for managing the connections and getting devices.
+
+- Caching can be persisted to disk. The caller can implement the cache storage themselves, but we need to give them an API to do so.
+
+- Users don't really choose between cloud vs local. However, we will want to allow the caller to know if its using the locale connection so we can show a warnings.

python_roborock-2.22.0/roborock/devices/__init__.py

@@ -0,0 +1,6 @@
+"""The devices module provides functionality to discover Roborock devices on the network."""
+
+__all__ = [
+    "device",
+    "device_manager",
+]

python_roborock-2.22.0/roborock/devices/device.py

@@ -0,0 +1,65 @@
+"""Module for Roborock devices.
+
+This interface is experimental and subject to breaking changes without notice
+until the API is stable.
+"""
+
+import enum
+import logging
+from functools import cached_property
+
+from roborock.containers import HomeDataDevice, HomeDataProduct, UserData
+
+_LOGGER = logging.getLogger(__name__)
+
+__all__ = [
+    "RoborockDevice",
+    "DeviceVersion",
+]
+
+
+class DeviceVersion(enum.StrEnum):
+    """Enum for device versions."""
+
+    V1 = "1.0"
+    A01 = "A01"
+    UNKNOWN = "unknown"
+
+
+class RoborockDevice:
+    """Unified Roborock device class with automatic connection setup."""
+
+    def __init__(self, user_data: UserData, device_info: HomeDataDevice, product_info: HomeDataProduct) -> None:
+        """Initialize the RoborockDevice with device info, user data, and capabilities."""
+        self._user_data = user_data
+        self._device_info = device_info
+        self._product_info = product_info
+
+    @property
+    def duid(self) -> str:
+        """Return the device unique identifier (DUID)."""
+        return self._device_info.duid
+
+    @property
+    def name(self) -> str:
+        """Return the device name."""
+        return self._device_info.name
+
+    @cached_property
+    def device_version(self) -> str:
+        """Return the device version.
+
+        At the moment this is a simple check against the product version (pv) of the device
+        and used as a placeholder for upcoming functionality for devices that will behave
+        differently based on the version and capabilities.
+        """
+        if self._device_info.pv == DeviceVersion.V1.value:
+            return DeviceVersion.V1
+        elif self._device_info.pv == DeviceVersion.A01.value:
+            return DeviceVersion.A01
+        _LOGGER.warning(
+            "Unknown device version %s for device %s, using default UNKNOWN",
+            self._device_info.pv,
+            self._device_info.name,
+        )
+        return DeviceVersion.UNKNOWN

python_roborock-2.22.0/roborock/devices/device_manager.py

@@ -0,0 +1,91 @@
+"""Module for discovering Roborock devices."""
+
+import logging
+from collections.abc import Awaitable, Callable
+
+from roborock.containers import (
+    HomeData,
+    HomeDataDevice,
+    HomeDataProduct,
+    UserData,
+)
+from roborock.devices.device import RoborockDevice
+from roborock.web_api import RoborockApiClient
+
+_LOGGER = logging.getLogger(__name__)
+
+__all__ = [
+    "create_device_manager",
+    "create_home_data_api",
+    "DeviceManager",
+    "HomeDataApi",
+    "DeviceCreator",
+]
+
+
+HomeDataApi = Callable[[], Awaitable[HomeData]]
+DeviceCreator = Callable[[HomeDataDevice, HomeDataProduct], RoborockDevice]
+
+
+class DeviceManager:
+    """Central manager for Roborock device discovery and connections."""
+
+    def __init__(
+        self,
+        home_data_api: HomeDataApi,
+        device_creator: DeviceCreator,
+    ) -> None:
+        """Initialize the DeviceManager with user data and optional cache storage."""
+        self._home_data_api = home_data_api
+        self._device_creator = device_creator
+        self._devices: dict[str, RoborockDevice] = {}
+
+    async def discover_devices(self) -> list[RoborockDevice]:
+        """Discover all devices for the logged-in user."""
+        home_data = await self._home_data_api()
+        device_products = home_data.device_products
+        _LOGGER.debug("Discovered %d devices %s", len(device_products), home_data)
+
+        self._devices = {
+            duid: self._device_creator(device, product) for duid, (device, product) in device_products.items()
+        }
+        return list(self._devices.values())
+
+    async def get_device(self, duid: str) -> RoborockDevice | None:
+        """Get a specific device by DUID."""
+        return self._devices.get(duid)
+
+    async def get_devices(self) -> list[RoborockDevice]:
+        """Get all discovered devices."""
+        return list(self._devices.values())
+
+
+def create_home_data_api(email: str, user_data: UserData) -> HomeDataApi:
+    """Create a home data API wrapper.
+
+    This function creates a wrapper around the Roborock API client to fetch
+    home data for the user.
+    """
+
+    client = RoborockApiClient(email, user_data)
+
+    async def home_data_api() -> HomeData:
+        return await client.get_home_data(user_data)
+
+    return home_data_api
+
+
+async def create_device_manager(user_data: UserData, home_data_api: HomeDataApi) -> DeviceManager:
+    """Convenience function to create and initialize a DeviceManager.
+
+    The Home Data is fetched using the provided home_data_api callable which
+    is exposed this way to allow for swapping out other implementations to
+    include caching or other optimizations.
+    """
+
+    def device_creator(device: HomeDataDevice, product: HomeDataProduct) -> RoborockDevice:
+        return RoborockDevice(user_data, device, product)
+
+    manager = DeviceManager(home_data_api, device_creator)
+    await manager.discover_devices()
+    return manager

{python_roborock-2.20.0 → python_roborock-2.22.0}/roborock/local_api.py

@@ -12,7 +12,7 @@ import async_timeout
 from . import DeviceData
 from .api import RoborockClient
 from .exceptions import RoborockConnectionException, RoborockException
-from .protocol import MessageParser
+from .protocol import Decoder, Encoder, create_local_decoder, create_local_encoder
 from .roborock_message import RoborockMessage, RoborockMessageProtocol
 
 _LOGGER = logging.getLogger(__name__)
@@ -44,20 +44,18 @@ class RoborockLocalClient(RoborockClient, ABC):
         self.host = device_data.host
         self._batch_structs: list[RoborockMessage] = []
         self._executing = False
-        self.remaining = b""
         self.transport: Transport | None = None
         self._mutex = Lock()
         self.keep_alive_task: TimerHandle | None = 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)
+        self._decoder: Decoder = create_local_decoder(device_data.device.local_key)
 
     def _data_received(self, message):
         """Called when data is received from the transport."""
-        if self.remaining:
-            message = self.remaining + message
-            self.remaining = b""
-        parser_msg, self.remaining = MessageParser.parse(message, local_key=self.device_info.device.local_key)
-        self.on_message_received(parser_msg)
+        parsed_msg = self._decoder(message)
+        self.on_message_received(parsed_msg)
 
     def _connection_lost(self, exc: Exception | None):
         """Called when the transport connection is lost."""

python_roborock-2.22.0/roborock/mqtt/__init__.py

@@ -0,0 +1,10 @@
+"""This module contains the low level MQTT client for the Roborock vacuum cleaner.
+
+This is not meant to be used directly, but rather as a base for the higher level
+modules.
+"""
+
+# This module is part of the Roborock Python library, which provides a way to
+# interact with Roborock devices using MQTT. It is not intended to be used directly,
+# but rather as a base for higher level modules.
+__all__: list[str] = []

{python_roborock-2.20.0 → python_roborock-2.22.0}/roborock/mqtt/roborock_session.py

@@ -116,9 +116,9 @@ class RoborockMqttSession(MqttSession):
                 _LOGGER.info("MQTT error: %s", err)
             except asyncio.CancelledError as err:
                 if start_future:
-                    _LOGGER.debug("MQTT loop was cancelled")
+                    _LOGGER.debug("MQTT loop was cancelled while starting")
                     start_future.set_exception(err)
-                _LOGGER.debug("MQTT loop was cancelled while starting")
+                _LOGGER.debug("MQTT loop was cancelled")
                 return
             # Catch exceptions to avoid crashing the loop
             # and to allow the loop to retry.
@@ -171,8 +171,7 @@ class RoborockMqttSession(MqttSession):
                 self._client = None
 
     async def _process_message_loop(self, client: aiomqtt.Client) -> None:
-        _LOGGER.debug("client=%s", client)
-        _LOGGER.debug("Processing MQTT messages: %s", client.messages)
+        _LOGGER.debug("Processing MQTT messages")
         async for message in client.messages:
             _LOGGER.debug("Received message: %s", message)
             for listener in self._listeners.get(message.topic.value, []):

{python_roborock-2.20.0 → python_roborock-2.22.0}/roborock/protocol.py

@@ -8,6 +8,7 @@ import json
 import logging
 from asyncio import BaseTransport, Lock
 from collections.abc import Callable
+from urllib.parse import urlparse
 
 from construct import (  # type: ignore
     Bytes,
@@ -30,7 +31,9 @@ from construct import (  # type: ignore
 from Crypto.Cipher import AES
 from Crypto.Util.Padding import pad, unpad
 
-from roborock import BroadcastMessage, RoborockException
+from roborock.containers import BroadcastMessage, RRiot
+from roborock.exceptions import RoborockException
+from roborock.mqtt.session import MqttParams
 from roborock.roborock_message import RoborockMessage
 
 _LOGGER = logging.getLogger(__name__)
@@ -359,3 +362,74 @@ class _Parser:
 
 MessageParser: _Parser = _Parser(_Messages, True)
 BroadcastParser: _Parser = _Parser(_BroadcastMessage, False)
+
+
+def create_mqtt_params(rriot: RRiot) -> MqttParams:
+    """Return the MQTT parameters for this user."""
+    url = urlparse(rriot.r.m)
+    if not isinstance(url.hostname, str):
+        raise RoborockException(f"Url parsing '{rriot.r.m}' returned an invalid hostname")
+    if not url.port:
+        raise RoborockException(f"Url parsing '{rriot.r.m}' returned an invalid port")
+    hashed_user = md5hex(rriot.u + ":" + rriot.k)[2:10]
+    hashed_password = md5hex(rriot.s + ":" + rriot.k)[16:]
+    return MqttParams(
+        host=str(url.hostname),
+        port=url.port,
+        tls=(url.scheme == "ssl"),
+        username=hashed_user,
+        password=hashed_password,
+    )
+
+
+Decoder = Callable[[bytes], list[RoborockMessage]]
+Encoder = Callable[[RoborockMessage], bytes]
+
+
+def create_mqtt_decoder(local_key: str) -> Decoder:
+    """Create a decoder for MQTT messages."""
+
+    def decode(data: bytes) -> list[RoborockMessage]:
+        """Parse the given data into Roborock messages."""
+        messages, _ = MessageParser.parse(data, local_key)
+        return messages
+
+    return decode
+
+
+def create_mqtt_encoder(local_key: str) -> Encoder:
+    """Create an encoder for MQTT messages."""
+
+    def encode(messages: RoborockMessage) -> bytes:
+        """Build the given Roborock messages into a byte string."""
+        return MessageParser.build(messages, local_key, prefixed=False)
+
+    return encode
+
+
+def create_local_decoder(local_key: str) -> Decoder:
+    """Create a decoder for local API messages."""
+
+    # This buffer is used to accumulate bytes until a complete message can be parsed.
+    # It is defined outside the decode function to maintain state across calls.
+    buffer: bytes = b""
+
+    def decode(bytes: bytes) -> list[RoborockMessage]:
+        """Parse the given data into Roborock messages."""
+        nonlocal buffer
+        buffer += bytes
+        parsed_messages, remaining = MessageParser.parse(buffer, local_key=local_key)
+        buffer = remaining
+        return parsed_messages
+
+    return decode
+
+
+def create_local_encoder(local_key: str) -> Encoder:
+    """Create an encoder for local API messages."""
+
+    def encode(message: RoborockMessage) -> bytes:
+        """Called when data is sent to the transport."""
+        return MessageParser.build(message, local_key=local_key)
+
+    return encode

{python_roborock-2.20.0 → python_roborock-2.22.0}/roborock/version_1_apis/roborock_local_client_v1.py

@@ -4,7 +4,6 @@ from roborock.local_api import RoborockLocalClient
 
 from .. import CommandVacuumError, DeviceData, RoborockCommand, RoborockException
 from ..exceptions import VacuumError
-from ..protocol import MessageParser
 from ..roborock_message import MessageRetry, RoborockMessage, RoborockMessageProtocol
 from ..util import RoborockLoggerAdapter
 from .roborock_client_v1 import COMMANDS_SECURED, RoborockClientV1
@@ -57,8 +56,7 @@ class RoborockLocalClientV1(RoborockLocalClient, RoborockClientV1):
             response_protocol = RoborockMessageProtocol.GENERAL_REQUEST
         if request_id is None:
             raise RoborockException(f"Failed build message {roborock_message}")
-        local_key = self.device_info.device.local_key
-        msg = MessageParser.build(roborock_message, local_key=local_key)
+        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

{python_roborock-2.20.0 → python_roborock-2.22.0}/roborock/version_1_apis/roborock_mqtt_client_v1.py

@@ -10,7 +10,7 @@ from roborock.cloud_api import RoborockMqttClient
 
 from ..containers import DeviceData, UserData
 from ..exceptions import CommandVacuumError, RoborockException, VacuumError
-from ..protocol import MessageParser, Utils
+from ..protocol import Utils
 from ..roborock_message import (
     RoborockMessage,
     RoborockMessageProtocol,
@@ -47,9 +47,7 @@ class RoborockMqttClientV1(RoborockMqttClient, RoborockClientV1):
         response_protocol = (
             RoborockMessageProtocol.MAP_RESPONSE if method in COMMANDS_SECURED else RoborockMessageProtocol.RPC_RESPONSE
         )
-
-        local_key = self.device_info.device.local_key
-        msg = MessageParser.build(roborock_message, local_key, False)
+        msg = self._encoder(roborock_message)
         self._logger.debug(f"id={request_id} Requesting method {method} with {params}")
         async_response = self._async_response(request_id, response_protocol)
         self._send_msg_raw(msg)

{python_roborock-2.20.0 → python_roborock-2.22.0}/roborock/version_a01_apis/roborock_mqtt_client_a01.py

@@ -9,7 +9,6 @@ from Crypto.Util.Padding import pad, unpad
 from roborock.cloud_api import RoborockMqttClient
 from roborock.containers import DeviceData, RoborockCategory, UserData
 from roborock.exceptions import RoborockException
-from roborock.protocol import MessageParser
 from roborock.roborock_message import (
     RoborockDyadDataProtocol,
     RoborockMessage,
@@ -43,8 +42,7 @@ class RoborockMqttClientA01(RoborockMqttClient, RoborockClientA01):
         await self.validate_connection()
         response_protocol = RoborockMessageProtocol.RPC_RESPONSE
 
-        local_key = self.device_info.device.local_key
-        m = MessageParser.build(roborock_message, local_key, prefixed=False)
+        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 = []

{python_roborock-2.20.0 → python_roborock-2.22.0}/roborock/web_api.py

@@ -90,39 +90,6 @@ class RoborockApiClient:
         md5.update(self._device_identifier.encode())
         return base64.b64encode(md5.digest()).decode()
 
-    def _process_extra_hawk_values(self, values: dict | None) -> str:
-        if values is None:
-            return ""
-        else:
-            sorted_keys = sorted(values.keys())
-            result = []
-            for key in sorted_keys:
-                value = values.get(key)
-                result.append(f"{key}={value}")
-            return hashlib.md5("&".join(result).encode()).hexdigest()
-
-    def _get_hawk_authentication(
-        self, rriot: RRiot, url: str, formdata: dict | None = None, params: dict | None = None
-    ) -> str:
-        timestamp = math.floor(time.time())
-        nonce = secrets.token_urlsafe(6)
-        formdata_str = self._process_extra_hawk_values(formdata)
-        params_str = self._process_extra_hawk_values(params)
-
-        prestr = ":".join(
-            [
-                rriot.u,
-                rriot.s,
-                nonce,
-                str(timestamp),
-                hashlib.md5(url.encode()).hexdigest(),
-                params_str,
-                formdata_str,
-            ]
-        )
-        mac = base64.b64encode(hmac.new(rriot.h.encode(), prestr.encode(), hashlib.sha256).digest()).decode()
-        return f'Hawk id="{rriot.u}",s="{rriot.s}",ts="{timestamp}",nonce="{nonce}",mac="{mac}"'
-
     async def nc_prepare(self, user_data: UserData, timezone: str) -> dict:
         """This gets a few critical parameters for adding a device to your account."""
         if (
@@ -144,7 +111,7 @@ class RoborockApiClient:
             "post",
             "/nc/prepare",
             headers={
-                "Authorization": self._get_hawk_authentication(
+                "Authorization": _get_hawk_authentication(
                     user_data.rriot, "/nc/prepare", {"hid": hid, "tzid": timezone}
                 ),
             },
@@ -177,7 +144,7 @@ class RoborockApiClient:
             "GET",
             "/user/devices/newadd",
             headers={
-                "Authorization": self._get_hawk_authentication(
+                "Authorization": _get_hawk_authentication(
                     user_data.rriot, "/user/devices/newadd", params={"s": s, "t": t}
                 ),
             },
@@ -337,7 +304,7 @@ class RoborockApiClient:
             rriot.r.a,
             self.session,
             {
-                "Authorization": self._get_hawk_authentication(rriot, f"/user/homes/{str(home_id)}"),
+                "Authorization": _get_hawk_authentication(rriot, f"/user/homes/{str(home_id)}"),
             },
         )
         home_response = await home_request.request("get", "/user/homes/" + str(home_id))
@@ -366,7 +333,7 @@ class RoborockApiClient:
             rriot.r.a,
             self.session,
             {
-                "Authorization": self._get_hawk_authentication(rriot, "/v2/user/homes/" + str(home_id)),
+                "Authorization": _get_hawk_authentication(rriot, "/v2/user/homes/" + str(home_id)),
             },
         )
         home_response = await home_request.request("get", "/v2/user/homes/" + str(home_id))
@@ -393,7 +360,7 @@ class RoborockApiClient:
             rriot.r.a,
             self.session,
             {
-                "Authorization": self._get_hawk_authentication(rriot, "/v3/user/homes/" + str(home_id)),
+                "Authorization": _get_hawk_authentication(rriot, "/v3/user/homes/" + str(home_id)),
             },
         )
         home_response = await home_request.request("get", "/v3/user/homes/" + str(home_id))
@@ -416,7 +383,7 @@ class RoborockApiClient:
             rriot.r.a,
             self.session,
             {
-                "Authorization": self._get_hawk_authentication(rriot, "/v2/user/homes/" + str(home_id)),
+                "Authorization": _get_hawk_authentication(rriot, "/v2/user/homes/" + str(home_id)),
             },
         )
         room_response = await room_request.request("get", f"/user/homes/{str(home_id)}/rooms" + str(home_id))
@@ -441,7 +408,7 @@ class RoborockApiClient:
             rriot.r.a,
             self.session,
             {
-                "Authorization": self._get_hawk_authentication(rriot, f"/user/scene/device/{str(device_id)}"),
+                "Authorization": _get_hawk_authentication(rriot, f"/user/scene/device/{str(device_id)}"),
             },
         )
         scenes_response = await scenes_request.request("get", f"/user/scene/device/{str(device_id)}")
@@ -463,7 +430,7 @@ class RoborockApiClient:
             rriot.r.a,
             self.session,
             {
-                "Authorization": self._get_hawk_authentication(rriot, f"/user/scene/{str(scene_id)}/execute"),
+                "Authorization": _get_hawk_authentication(rriot, f"/user/scene/{str(scene_id)}/execute"),
             },
         )
         execute_scene_response = await execute_scene_request.request("POST", f"/user/scene/{str(scene_id)}/execute")
@@ -546,3 +513,36 @@ class PreparedRequest:
         finally:
             if close_session:
                 await session.close()
+
+
+def _process_extra_hawk_values(values: dict | None) -> str:
+    if values is None:
+        return ""
+    else:
+        sorted_keys = sorted(values.keys())
+        result = []
+        for key in sorted_keys:
+            value = values.get(key)
+            result.append(f"{key}={value}")
+        return hashlib.md5("&".join(result).encode()).hexdigest()
+
+
+def _get_hawk_authentication(rriot: RRiot, url: str, formdata: dict | None = None, params: dict | None = None) -> str:
+    timestamp = math.floor(time.time())
+    nonce = secrets.token_urlsafe(6)
+    formdata_str = _process_extra_hawk_values(formdata)
+    params_str = _process_extra_hawk_values(params)
+
+    prestr = ":".join(
+        [
+            rriot.u,
+            rriot.s,
+            nonce,
+            str(timestamp),
+            hashlib.md5(url.encode()).hexdigest(),
+            params_str,
+            formdata_str,
+        ]
+    )
+    mac = base64.b64encode(hmac.new(rriot.h.encode(), prestr.encode(), hashlib.sha256).digest()).decode()
+    return f'Hawk id="{rriot.u}",s="{rriot.s}",ts="{timestamp}",nonce="{nonce}",mac="{mac}"'

python_roborock-2.20.0/roborock/mqtt/__init__.py

@@ -1,7 +0,0 @@
-"""This module contains the low level MQTT client for the Roborock vacuum cleaner.
-
-This is not meant to be used directly, but rather as a base for the higher level
-modules.
-"""
-
-__all__: list[str] = []