python-roborock 0.39.2__tar.gz → 0.41.0__tar.gz

{python_roborock-0.39.2 → python_roborock-0.41.0}/PKG-INFO

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

{python_roborock-0.39.2 → python_roborock-0.41.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-roborock"
-version = "0.39.2"
+version = "0.41.0"
 description = "A package to control Roborock vacuums."
 authors = ["humbertogontijo <humbertogontijo@users.noreply.github.com>"]
 license = "GPL-3.0-only"
@@ -33,7 +33,7 @@ construct = "^2.10.57"
 
 
 [build-system]
-requires = ["poetry-core==1.7.1"]
+requires = ["poetry-core==1.8.0"]
 build-backend = "poetry.core.masonry.api"
 
 [tool.poetry.group.dev.dependencies]

{python_roborock-0.39.2 → python_roborock-0.41.0}/roborock/api.py

@@ -3,40 +3,25 @@
 from __future__ import annotations
 
 import asyncio
+import base64
 import dataclasses
 import hashlib
 import json
 import logging
-import math
 import secrets
 import struct
 import time
 from collections.abc import Callable, Coroutine
-from random import randint
 from typing import Any, TypeVar, final
 
-from .code_mappings import RoborockDockTypeCode
 from .command_cache import CacheableAttribute, CommandType, RoborockAttribute, find_cacheable_attribute, get_cache_map
 from .containers import (
-    ChildLockStatus,
-    CleanRecord,
-    CleanSummary,
     Consumable,
     DeviceData,
-    DnDTimer,
-    DustCollectionMode,
-    FlowLedStatus,
     ModelStatus,
-    MultiMapsList,
-    NetworkInfo,
     RoborockBase,
-    RoomMapping,
     S7MaxVStatus,
-    ServerTimer,
-    SmartWashParams,
     Status,
-    ValleyElectricityTimer,
-    WashTowelMode,
 )
 from .exceptions import (
     RoborockException,
@@ -53,21 +38,12 @@ from .roborock_message import (
     RoborockMessage,
     RoborockMessageProtocol,
 )
-from .roborock_typing import DeviceProp, DockSummary, RoborockCommand
-from .util import RepeatableTask, RoborockLoggerAdapter, get_running_loop_or_create_one, unpack_list
+from .roborock_typing import RoborockCommand
+from .util import RepeatableTask, RoborockLoggerAdapter, get_running_loop_or_create_one
 
 _LOGGER = logging.getLogger(__name__)
 KEEPALIVE = 60
-COMMANDS_SECURED = [
-    RoborockCommand.GET_MAP_V1,
-    RoborockCommand.GET_MULTI_MAP,
-]
 RT = TypeVar("RT", bound=RoborockBase)
-WASH_N_FILL_DOCK = [
-    RoborockDockTypeCode.empty_wash_fill_dock,
-    RoborockDockTypeCode.s8_dock,
-    RoborockDockTypeCode.p10_dock,
-]
 
 
 def md5hex(message: str) -> str:
@@ -156,7 +132,9 @@ class RoborockClient:
         self._last_device_msg_in = self.time_func()
         self._last_disconnection = self.time_func()
         self.keep_alive = KEEPALIVE
-        self._diagnostic_data: dict[str, dict[str, Any]] = {}
+        self._diagnostic_data: dict[str, dict[str, Any]] = {
+            "misc_info": {"Nonce": base64.b64encode(self._nonce).decode("utf-8")}
+        }
         self._logger = RoborockLoggerAdapter(device_info.device.name, _LOGGER)
         self.cache: dict[CacheableAttribute, AttributeCache] = {
             cacheable_attribute: AttributeCache(attr, self) for cacheable_attribute, attr in get_cache_map().items()
@@ -283,7 +261,7 @@ class RoborockClient:
                         try:
                             decrypted = Utils.decrypt_cbc(data.payload[24:], self._nonce)
                         except ValueError as err:
-                            raise RoborockException("Failed to decode %s for %s", data.payload, data.protocol) from err
+                            raise RoborockException(f"Failed to decode {data.payload!r} for {data.protocol}") from err
                         decompressed = Utils.decompress(decrypted)
                         queue = self._waiting_queue.get(request_id)
                         if queue:
@@ -333,35 +311,6 @@ class RoborockClient:
         self._waiting_queue[request_id] = queue
         return self._wait_response(request_id, queue)
 
-    def _get_payload(
-        self,
-        method: RoborockCommand | str,
-        params: list | dict | int | None = None,
-        secured=False,
-    ):
-        timestamp = math.floor(time.time())
-        request_id = randint(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
-
     async def send_message(self, roborock_message: RoborockMessage):
         raise NotImplementedError
 
@@ -399,148 +348,6 @@ class RoborockClient:
             return return_type.from_dict(response)
         return response
 
-    async def get_status(self) -> Status:
-        data = self._status_type.from_dict(await self.cache[CacheableAttribute.status].async_value())
-        if data is None:
-            return self._status_type()
-        return data
-
-    async def get_dnd_timer(self) -> DnDTimer | None:
-        return DnDTimer.from_dict(await self.cache[CacheableAttribute.dnd_timer].async_value())
-
-    async def get_valley_electricity_timer(self) -> ValleyElectricityTimer | None:
-        return ValleyElectricityTimer.from_dict(
-            await self.cache[CacheableAttribute.valley_electricity_timer].async_value()
-        )
-
-    async def get_clean_summary(self) -> CleanSummary | None:
-        clean_summary: dict | list | int = await self.send_command(RoborockCommand.GET_CLEAN_SUMMARY)
-        if isinstance(clean_summary, dict):
-            return CleanSummary.from_dict(clean_summary)
-        elif isinstance(clean_summary, list):
-            clean_time, clean_area, clean_count, records = unpack_list(clean_summary, 4)
-            return CleanSummary(
-                clean_time=clean_time,
-                clean_area=clean_area,
-                clean_count=clean_count,
-                records=records,
-            )
-        elif isinstance(clean_summary, int):
-            return CleanSummary(clean_time=clean_summary)
-        return None
-
-    async def get_clean_record(self, record_id: int) -> CleanRecord | None:
-        record: dict | list = await self.send_command(RoborockCommand.GET_CLEAN_RECORD, [record_id])
-        if isinstance(record, dict):
-            return CleanRecord.from_dict(record)
-        elif isinstance(record, list):
-            # There are still a few unknown variables in this.
-            begin, end, duration, area = unpack_list(record, 4)
-            return CleanRecord(begin=begin, end=end, duration=duration, area=area)
-        else:
-            _LOGGER.warning("Clean record was of a new type, please submit an issue request: %s", record)
-            return None
-
-    async def get_consumable(self) -> Consumable:
-        data = Consumable.from_dict(await self.cache[CacheableAttribute.consumable].async_value())
-        if data is None:
-            return Consumable()
-        return data
-
-    async def get_wash_towel_mode(self) -> WashTowelMode | None:
-        return WashTowelMode.from_dict(await self.cache[CacheableAttribute.wash_towel_mode].async_value())
-
-    async def get_dust_collection_mode(self) -> DustCollectionMode | None:
-        return DustCollectionMode.from_dict(await self.cache[CacheableAttribute.dust_collection_mode].async_value())
-
-    async def get_smart_wash_params(self) -> SmartWashParams | None:
-        return SmartWashParams.from_dict(await self.cache[CacheableAttribute.smart_wash_params].async_value())
-
-    async def get_dock_summary(self, dock_type: RoborockDockTypeCode) -> DockSummary:
-        """Gets the status summary from the dock with the methods available for a given dock.
-
-        :param dock_type: RoborockDockTypeCode"""
-        commands: list[
-            Coroutine[
-                Any,
-                Any,
-                DustCollectionMode | WashTowelMode | SmartWashParams | None,
-            ]
-        ] = [self.get_dust_collection_mode()]
-        if dock_type in WASH_N_FILL_DOCK:
-            commands += [
-                self.get_wash_towel_mode(),
-                self.get_smart_wash_params(),
-            ]
-        [dust_collection_mode, wash_towel_mode, smart_wash_params] = unpack_list(
-            list(await asyncio.gather(*commands)), 3
-        )  # type: DustCollectionMode, WashTowelMode | None, SmartWashParams | None # type: ignore
-
-        return DockSummary(dust_collection_mode, wash_towel_mode, smart_wash_params)
-
-    async def get_prop(self) -> DeviceProp | None:
-        """Gets device general properties."""
-        # Mypy thinks that each one of these is typed as a union of all the others. so we do type ignore.
-        status, clean_summary, consumable = await asyncio.gather(
-            *[
-                self.get_status(),
-                self.get_clean_summary(),
-                self.get_consumable(),
-            ]
-        )  # type: Status, CleanSummary, Consumable # type: ignore
-        last_clean_record = None
-        if clean_summary and clean_summary.records and len(clean_summary.records) > 0:
-            last_clean_record = await self.get_clean_record(clean_summary.records[0])
-        dock_summary = None
-        if status and status.dock_type is not None and status.dock_type != RoborockDockTypeCode.no_dock:
-            dock_summary = await self.get_dock_summary(status.dock_type)
-        if any([status, clean_summary, consumable]):
-            return DeviceProp(
-                status,
-                clean_summary,
-                consumable,
-                last_clean_record,
-                dock_summary,
-            )
-        return None
-
-    async def get_multi_maps_list(self) -> MultiMapsList | None:
-        return await self.send_command(RoborockCommand.GET_MULTI_MAPS_LIST, return_type=MultiMapsList)
-
-    async def get_networking(self) -> NetworkInfo | None:
-        return await self.send_command(RoborockCommand.GET_NETWORK_INFO, return_type=NetworkInfo)
-
-    async def get_room_mapping(self) -> list[RoomMapping] | None:
-        """Gets the mapping from segment id -> iot id. Only works on local api."""
-        mapping: list = await self.send_command(RoborockCommand.GET_ROOM_MAPPING)
-        if isinstance(mapping, list):
-            return [
-                RoomMapping(segment_id=segment_id, iot_id=iot_id)  # type: ignore
-                for segment_id, iot_id in [unpack_list(room, 2) for room in mapping if isinstance(room, list)]
-            ]
-        return None
-
-    async def get_child_lock_status(self) -> ChildLockStatus:
-        """Gets current child lock status."""
-        return ChildLockStatus.from_dict(await self.cache[CacheableAttribute.child_lock_status].async_value())
-
-    async def get_flow_led_status(self) -> FlowLedStatus:
-        """Gets current flow led status."""
-        return FlowLedStatus.from_dict(await self.cache[CacheableAttribute.flow_led_status].async_value())
-
-    async def get_sound_volume(self) -> int | None:
-        """Gets current volume level."""
-        return await self.cache[CacheableAttribute.sound_volume].async_value()
-
-    async def get_server_timer(self) -> list[ServerTimer]:
-        """Gets current server timer."""
-        server_timers = await self.cache[CacheableAttribute.server_timer].async_value()
-        if server_timers:
-            if isinstance(server_timers[0], list):
-                return [ServerTimer(*server_timer) for server_timer in server_timers]
-            return [ServerTimer(*server_timers)]
-        return []
-
     def add_listener(
         self, protocol: RoborockDataProtocol, listener: Callable, cache: dict[CacheableAttribute, AttributeCache]
     ) -> None:

{python_roborock-0.39.2 → python_roborock-0.41.0}/roborock/cli.py

@@ -11,10 +11,10 @@ from pyshark.capture.live_capture import LiveCapture, UnknownInterfaceException
 from pyshark.packet.packet import Packet  # type: ignore
 
 from roborock import RoborockException
-from roborock.cloud_api import RoborockMqttClient
 from roborock.containers import DeviceData, LoginData
 from roborock.protocol import MessageParser
 from roborock.util import run_sync
+from roborock.version_1_apis.roborock_mqtt_client_v1 import RoborockMqttClientV1
 from roborock.web_api import RoborockApiClient
 
 _LOGGER = logging.getLogger(__name__)
@@ -135,7 +135,7 @@ async def command(ctx, cmd, device_id, params):
     if model is None:
         raise RoborockException(f"Could not find model for device {device.name}")
     device_info = DeviceData(device=device, model=model)
-    mqtt_client = RoborockMqttClient(login_data.user_data, device_info)
+    mqtt_client = RoborockMqttClientV1(login_data.user_data, device_info)
     await mqtt_client.send_command(cmd, json.loads(params) if params is not None else None)
     mqtt_client.__del__()
 

{python_roborock-0.39.2 → python_roborock-0.41.0}/roborock/cloud_api.py

@@ -11,12 +11,12 @@ from urllib.parse import urlparse
 
 import paho.mqtt.client as mqtt
 
-from .api import COMMANDS_SECURED, KEEPALIVE, RoborockClient, md5hex
+from .api import KEEPALIVE, RoborockClient, md5hex
 from .containers import DeviceData, UserData
-from .exceptions import CommandVacuumError, RoborockException, VacuumError
+from .exceptions import RoborockException, VacuumError
 from .protocol import MessageParser, Utils
 from .roborock_future import RoborockFuture
-from .roborock_message import RoborockMessage, RoborockMessageProtocol
+from .roborock_message import RoborockMessage
 from .roborock_typing import RoborockCommand
 from .util import RoborockLoggerAdapter
 
@@ -167,44 +167,11 @@ class RoborockMqttClient(RoborockClient, mqtt.Client):
             raise RoborockException(f"Failed to publish ({mqtt.error_string(info.rc)})")
 
     async def send_message(self, roborock_message: RoborockMessage):
-        await self.validate_connection()
-        method = roborock_message.get_method()
-        params = roborock_message.get_params()
-        request_id = roborock_message.get_request_id()
-        if request_id is None:
-            raise RoborockException(f"Failed build message {roborock_message}")
-        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)
-        self._logger.debug(f"id={request_id} Requesting method {method} with {params}")
-        async_response = asyncio.ensure_future(self._async_response(request_id, response_protocol))
-        self._send_msg_raw(msg)
-        (response, err) = await async_response
-        self._diagnostic_data[method if method is not None else "unknown"] = {
-            "params": roborock_message.get_params(),
-            "response": response,
-            "error": err,
-        }
-        if err:
-            raise CommandVacuumError(method, err) from err
-        if response_protocol == RoborockMessageProtocol.MAP_RESPONSE:
-            self._logger.debug(f"id={request_id} Response from {method}: {len(response)} bytes")
-        else:
-            self._logger.debug(f"id={request_id} Response from {method}: {response}")
-        return response
+        raise NotImplementedError
 
     async def _send_command(
         self,
         method: RoborockCommand | str,
         params: list | dict | int | None = None,
     ):
-        request_id, timestamp, payload = super()._get_payload(method, params, True)
-        request_protocol = RoborockMessageProtocol.RPC_REQUEST
-        roborock_message = RoborockMessage(timestamp=timestamp, protocol=request_protocol, payload=payload)
-        return await self.send_message(roborock_message)
-
-    async def get_map_v1(self):
-        return await self.send_command(RoborockCommand.GET_MAP_V1)
+        raise NotImplementedError

{python_roborock-0.39.2 → python_roborock-0.41.0}/roborock/local_api.py

@@ -7,10 +7,10 @@ from asyncio import Lock, TimerHandle, Transport
 import async_timeout
 
 from . import DeviceData
-from .api import COMMANDS_SECURED, RoborockClient
+from .api import RoborockClient
 from .exceptions import CommandVacuumError, RoborockConnectionException, RoborockException
 from .protocol import MessageParser
-from .roborock_message import MessageRetry, RoborockMessage, RoborockMessageProtocol
+from .roborock_message import RoborockMessage, RoborockMessageProtocol
 from .roborock_typing import RoborockCommand
 from .util import RoborockLoggerAdapter
 
@@ -21,7 +21,6 @@ class RoborockLocalClient(RoborockClient, asyncio.Protocol):
     def __init__(self, device_data: DeviceData, queue_timeout: int = 4):
         if device_data.host is None:
             raise RoborockException("Host is required")
-        super().__init__("abc", device_data, queue_timeout)
         self.host = device_data.host
         self._batch_structs: list[RoborockMessage] = []
         self._executing = False
@@ -30,6 +29,7 @@ class RoborockLocalClient(RoborockClient, asyncio.Protocol):
         self._mutex = Lock()
         self.keep_alive_task: TimerHandle | None = None
         self._logger = RoborockLoggerAdapter(device_data.device.name, _LOGGER)
+        RoborockClient.__init__(self, "abc", device_data, queue_timeout)
 
     def data_received(self, message):
         if self.remaining:
@@ -82,19 +82,6 @@ class RoborockLocalClient(RoborockClient, asyncio.Protocol):
         async with self._mutex:
             self.sync_disconnect()
 
-    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)
-        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 hello(self):
         request_id = 1
         protocol = RoborockMessageProtocol.HELLO_REQUEST
@@ -125,8 +112,7 @@ class RoborockLocalClient(RoborockClient, asyncio.Protocol):
         method: RoborockCommand | str,
         params: list | dict | int | None = None,
     ):
-        roborock_message = self.build_roborock_message(method, params)
-        return await self.send_message(roborock_message)
+        raise NotImplementedError
 
     def _send_msg_raw(self, data: bytes):
         try:

python_roborock-0.41.0/roborock/version_1_apis/roborock_client_v1.py

@@ -0,0 +1,227 @@
+import asyncio
+import json
+import math
+import time
+from collections.abc import Coroutine
+from random import randint
+from typing import Any
+
+from roborock import DeviceProp, DockSummary, RoborockCommand, RoborockDockTypeCode
+from roborock.api import RoborockClient
+from roborock.command_cache import CacheableAttribute
+from roborock.containers import (
+    ChildLockStatus,
+    CleanRecord,
+    CleanSummary,
+    Consumable,
+    DeviceData,
+    DnDTimer,
+    DustCollectionMode,
+    FlowLedStatus,
+    ModelStatus,
+    MultiMapsList,
+    NetworkInfo,
+    RoomMapping,
+    S7MaxVStatus,
+    ServerTimer,
+    SmartWashParams,
+    Status,
+    ValleyElectricityTimer,
+    WashTowelMode,
+)
+from roborock.util import unpack_list
+
+COMMANDS_SECURED = [
+    RoborockCommand.GET_MAP_V1,
+    RoborockCommand.GET_MULTI_MAP,
+]
+
+WASH_N_FILL_DOCK = [
+    RoborockDockTypeCode.empty_wash_fill_dock,
+    RoborockDockTypeCode.s8_dock,
+    RoborockDockTypeCode.p10_dock,
+]
+
+
+class RoborockClientV1(RoborockClient):
+    def __init__(self, device_info: DeviceData, cache, logger, endpoint: str):
+        super().__init__(endpoint, device_info)
+        self._status_type: type[Status] = ModelStatus.get(device_info.model, S7MaxVStatus)
+        self.cache = cache
+        self._logger = logger
+
+    @property
+    def status_type(self) -> type[Status]:
+        """Gets the status type for this device"""
+        return self._status_type
+
+    async def get_status(self) -> Status:
+        data = self._status_type.from_dict(await self.cache[CacheableAttribute.status].async_value())
+        if data is None:
+            return self._status_type()
+        return data
+
+    async def get_dnd_timer(self) -> DnDTimer | None:
+        return DnDTimer.from_dict(await self.cache[CacheableAttribute.dnd_timer].async_value())
+
+    async def get_valley_electricity_timer(self) -> ValleyElectricityTimer | None:
+        return ValleyElectricityTimer.from_dict(
+            await self.cache[CacheableAttribute.valley_electricity_timer].async_value()
+        )
+
+    async def get_clean_summary(self) -> CleanSummary | None:
+        clean_summary: dict | list | int = await self.send_command(RoborockCommand.GET_CLEAN_SUMMARY)
+        if isinstance(clean_summary, dict):
+            return CleanSummary.from_dict(clean_summary)
+        elif isinstance(clean_summary, list):
+            clean_time, clean_area, clean_count, records = unpack_list(clean_summary, 4)
+            return CleanSummary(
+                clean_time=clean_time,
+                clean_area=clean_area,
+                clean_count=clean_count,
+                records=records,
+            )
+        elif isinstance(clean_summary, int):
+            return CleanSummary(clean_time=clean_summary)
+        return None
+
+    async def get_clean_record(self, record_id: int) -> CleanRecord | None:
+        record: dict | list = await self.send_command(RoborockCommand.GET_CLEAN_RECORD, [record_id])
+        if isinstance(record, dict):
+            return CleanRecord.from_dict(record)
+        elif isinstance(record, list):
+            # There are still a few unknown variables in this.
+            begin, end, duration, area = unpack_list(record, 4)
+            return CleanRecord(begin=begin, end=end, duration=duration, area=area)
+        else:
+            self._logger.warning("Clean record was of a new type, please submit an issue request: %s", record)
+            return None
+
+    async def get_consumable(self) -> Consumable:
+        data = Consumable.from_dict(await self.cache[CacheableAttribute.consumable].async_value())
+        if data is None:
+            return Consumable()
+        return data
+
+    async def get_wash_towel_mode(self) -> WashTowelMode | None:
+        return WashTowelMode.from_dict(await self.cache[CacheableAttribute.wash_towel_mode].async_value())
+
+    async def get_dust_collection_mode(self) -> DustCollectionMode | None:
+        return DustCollectionMode.from_dict(await self.cache[CacheableAttribute.dust_collection_mode].async_value())
+
+    async def get_smart_wash_params(self) -> SmartWashParams | None:
+        return SmartWashParams.from_dict(await self.cache[CacheableAttribute.smart_wash_params].async_value())
+
+    async def get_dock_summary(self, dock_type: RoborockDockTypeCode) -> DockSummary:
+        """Gets the status summary from the dock with the methods available for a given dock.
+
+        :param dock_type: RoborockDockTypeCode"""
+        commands: list[
+            Coroutine[
+                Any,
+                Any,
+                DustCollectionMode | WashTowelMode | SmartWashParams | None,
+            ]
+        ] = [self.get_dust_collection_mode()]
+        if dock_type in WASH_N_FILL_DOCK:
+            commands += [
+                self.get_wash_towel_mode(),
+                self.get_smart_wash_params(),
+            ]
+        [dust_collection_mode, wash_towel_mode, smart_wash_params] = unpack_list(
+            list(await asyncio.gather(*commands)), 3
+        )  # type: DustCollectionMode, WashTowelMode | None, SmartWashParams | None # type: ignore
+
+        return DockSummary(dust_collection_mode, wash_towel_mode, smart_wash_params)
+
+    async def get_prop(self) -> DeviceProp | None:
+        """Gets device general properties."""
+        # Mypy thinks that each one of these is typed as a union of all the others. so we do type ignore.
+        status, clean_summary, consumable = await asyncio.gather(
+            *[
+                self.get_status(),
+                self.get_clean_summary(),
+                self.get_consumable(),
+            ]
+        )  # type: Status, CleanSummary, Consumable # type: ignore
+        last_clean_record = None
+        if clean_summary and clean_summary.records and len(clean_summary.records) > 0:
+            last_clean_record = await self.get_clean_record(clean_summary.records[0])
+        dock_summary = None
+        if status and status.dock_type is not None and status.dock_type != RoborockDockTypeCode.no_dock:
+            dock_summary = await self.get_dock_summary(status.dock_type)
+        if any([status, clean_summary, consumable]):
+            return DeviceProp(
+                status,
+                clean_summary,
+                consumable,
+                last_clean_record,
+                dock_summary,
+            )
+        return None
+
+    async def get_multi_maps_list(self) -> MultiMapsList | None:
+        return await self.send_command(RoborockCommand.GET_MULTI_MAPS_LIST, return_type=MultiMapsList)
+
+    async def get_networking(self) -> NetworkInfo | None:
+        return await self.send_command(RoborockCommand.GET_NETWORK_INFO, return_type=NetworkInfo)
+
+    async def get_room_mapping(self) -> list[RoomMapping] | None:
+        """Gets the mapping from segment id -> iot id. Only works on local api."""
+        mapping: list = await self.send_command(RoborockCommand.GET_ROOM_MAPPING)
+        if isinstance(mapping, list):
+            return [
+                RoomMapping(segment_id=segment_id, iot_id=iot_id)  # type: ignore
+                for segment_id, iot_id in [unpack_list(room, 2) for room in mapping if isinstance(room, list)]
+            ]
+        return None
+
+    async def get_child_lock_status(self) -> ChildLockStatus:
+        """Gets current child lock status."""
+        return ChildLockStatus.from_dict(await self.cache[CacheableAttribute.child_lock_status].async_value())
+
+    async def get_flow_led_status(self) -> FlowLedStatus:
+        """Gets current flow led status."""
+        return FlowLedStatus.from_dict(await self.cache[CacheableAttribute.flow_led_status].async_value())
+
+    async def get_sound_volume(self) -> int | None:
+        """Gets current volume level."""
+        return await self.cache[CacheableAttribute.sound_volume].async_value()
+
+    async def get_server_timer(self) -> list[ServerTimer]:
+        """Gets current server timer."""
+        server_timers = await self.cache[CacheableAttribute.server_timer].async_value()
+        if server_timers:
+            if isinstance(server_timers[0], list):
+                return [ServerTimer(*server_timer) for server_timer in server_timers]
+            return [ServerTimer(*server_timers)]
+        return []
+
+    def _get_payload(
+        self,
+        method: RoborockCommand | str,
+        params: list | dict | int | None = None,
+        secured=False,
+    ):
+        timestamp = math.floor(time.time())
+        request_id = randint(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

python_roborock-0.41.0/roborock/version_1_apis/roborock_local_client_v1.py

@@ -0,0 +1,32 @@
+from roborock.local_api import RoborockLocalClient
+
+from .. import DeviceData, RoborockCommand
+from ..roborock_message import MessageRetry, RoborockMessage, RoborockMessageProtocol
+from .roborock_client_v1 import COMMANDS_SECURED, RoborockClientV1
+
+
+class RoborockLocalClientV1(RoborockLocalClient, RoborockClientV1):
+    def __init__(self, device_data: DeviceData, queue_timeout: int = 4):
+        RoborockLocalClient.__init__(self, device_data, queue_timeout)
+        RoborockClientV1.__init__(self, device_data, self.cache, self._logger, "abc")
+
+    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)
+        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)
+        return await self.send_message(roborock_message)

python_roborock-0.41.0/roborock/version_1_apis/roborock_mqtt_client_v1.py

@@ -0,0 +1,72 @@
+import asyncio
+import base64
+
+import paho.mqtt.client as mqtt
+
+from roborock.cloud_api import RoborockMqttClient
+
+from ..containers import DeviceData, UserData
+from ..exceptions import CommandVacuumError, RoborockException
+from ..protocol import MessageParser, Utils
+from ..roborock_message import RoborockMessage, RoborockMessageProtocol
+from ..roborock_typing import RoborockCommand
+from .roborock_client_v1 import COMMANDS_SECURED, RoborockClientV1
+
+
+class RoborockMqttClientV1(RoborockMqttClient, RoborockClientV1):
+    def __init__(self, user_data: UserData, device_info: DeviceData, queue_timeout: int = 10) -> None:
+        rriot = user_data.rriot
+        if rriot is None:
+            raise RoborockException("Got no rriot data from user_data")
+        endpoint = base64.b64encode(Utils.md5(rriot.k.encode())[8:14]).decode()
+
+        RoborockMqttClient.__init__(self, user_data, device_info, queue_timeout)
+        RoborockClientV1.__init__(self, device_info, self.cache, self._logger, endpoint)
+
+    def _send_msg_raw(self, msg: bytes) -> None:
+        info = self.publish(f"rr/m/i/{self._mqtt_user}/{self._hashed_user}/{self.device_info.device.duid}", msg)
+        if info.rc != mqtt.MQTT_ERR_SUCCESS:
+            raise RoborockException(f"Failed to publish ({mqtt.error_string(info.rc)})")
+
+    async def send_message(self, roborock_message: RoborockMessage):
+        await self.validate_connection()
+        method = roborock_message.get_method()
+        params = roborock_message.get_params()
+        request_id = roborock_message.get_request_id()
+        if request_id is None:
+            raise RoborockException(f"Failed build message {roborock_message}")
+        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)
+        self._logger.debug(f"id={request_id} Requesting method {method} with {params}")
+        async_response = asyncio.ensure_future(self._async_response(request_id, response_protocol))
+        self._send_msg_raw(msg)
+        (response, err) = await async_response
+        self._diagnostic_data[method if method is not None else "unknown"] = {
+            "params": roborock_message.get_params(),
+            "response": response,
+            "error": err,
+        }
+        if err:
+            raise CommandVacuumError(method, err) from err
+        if response_protocol == RoborockMessageProtocol.MAP_RESPONSE:
+            self._logger.debug(f"id={request_id} Response from {method}: {len(response)} bytes")
+        else:
+            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,
+    ):
+        request_id, timestamp, payload = self._get_payload(method, params, True)
+        request_protocol = RoborockMessageProtocol.RPC_REQUEST
+        roborock_message = RoborockMessage(timestamp=timestamp, protocol=request_protocol, payload=payload)
+        return await self.send_message(roborock_message)
+
+    async def get_map_v1(self):
+        return await self.send_command(RoborockCommand.GET_MAP_V1)