python-roborock 3.14.3__tar.gz → 3.16.0__tar.gz

{python_roborock-3.14.3 → python_roborock-3.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-roborock
-Version: 3.14.3
+Version: 3.16.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.14.3 → python_roborock-3.16.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-roborock"
-version = "3.14.3"
+version = "3.16.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.16.0/roborock/data/b01_q7/b01_q7_containers.py

@@ -0,0 +1,130 @@
+from dataclasses import dataclass, field
+
+from ..containers import RoborockBase
+from .b01_q7_code_mappings import B01Fault, SCWindMapping, WorkModeMapping, WorkStatusMapping
+
+
+@dataclass
+class NetStatus(RoborockBase):
+    """Represents the network status of the device."""
+
+    rssi: str
+    loss: int
+    ping: int
+    ip: str
+    mac: str
+    ssid: str
+    frequency: int
+    bssid: str
+
+
+@dataclass
+class OrderTotal(RoborockBase):
+    """Represents the order total information."""
+
+    total: int
+    enable: int
+
+
+@dataclass
+class Privacy(RoborockBase):
+    """Represents the privacy settings of the device."""
+
+    ai_recognize: int
+    dirt_recognize: int
+    pet_recognize: int
+    carpet_turbo: int
+    carpet_avoid: int
+    carpet_show: int
+    map_uploads: int
+    ai_agent: int
+    ai_avoidance: int
+    record_uploads: int
+    along_floor: int
+    auto_upgrade: int
+
+
+@dataclass
+class PvCharging(RoborockBase):
+    """Represents the photovoltaic charging status."""
+
+    status: int
+    begin_time: int
+    end_time: int
+
+
+@dataclass
+class Recommend(RoborockBase):
+    """Represents cleaning recommendations."""
+
+    sill: int
+    wall: int
+    room_id: list[int] = field(default_factory=list)
+
+
+@dataclass
+class B01Props(RoborockBase):
+    """
+    Represents the complete properties and status for a Roborock B01 model.
+    This dataclass is generated based on the device's status JSON object.
+    """
+
+    status: WorkStatusMapping | None = None
+    fault: B01Fault | None = None
+    wind: SCWindMapping | None = None
+    water: int | None = None
+    mode: int | None = None
+    quantity: int | None = None
+    alarm: int | None = None
+    volume: int | None = None
+    hypa: int | None = None
+    main_brush: int | None = None
+    side_brush: int | None = None
+    mop_life: int | None = None
+    main_sensor: int | None = None
+    net_status: NetStatus | None = None
+    repeat_state: int | None = None
+    tank_state: int | None = None
+    sweep_type: int | None = None
+    clean_path_preference: int | None = None
+    cloth_state: int | None = None
+    time_zone: int | None = None
+    time_zone_info: str | None = None
+    language: int | None = None
+    cleaning_time: int | None = None
+    real_clean_time: int | None = None
+    cleaning_area: int | None = None
+    custom_type: int | None = None
+    sound: int | None = None
+    work_mode: WorkModeMapping | None = None
+    station_act: int | None = None
+    charge_state: int | None = None
+    current_map_id: int | None = None
+    map_num: int | None = None
+    dust_action: int | None = None
+    quiet_is_open: int | None = None
+    quiet_begin_time: int | None = None
+    quiet_end_time: int | None = None
+    clean_finish: int | None = None
+    voice_type: int | None = None
+    voice_type_version: int | None = None
+    order_total: OrderTotal | None = None
+    build_map: int | None = None
+    privacy: Privacy | None = None
+    dust_auto_state: int | None = None
+    dust_frequency: int | None = None
+    child_lock: int | None = None
+    multi_floor: int | None = None
+    map_save: int | None = None
+    light_mode: int | None = None
+    green_laser: int | None = None
+    dust_bag_used: int | None = None
+    order_save_mode: int | None = None
+    manufacturer: str | None = None
+    back_to_wash: int | None = None
+    charge_station_type: int | None = None
+    pv_cut_charge: int | None = None
+    pv_charging: PvCharging | None = None
+    serial_number: str | None = None
+    recommend: Recommend | None = None
+    add_sweep_status: int | None = None

{python_roborock-3.14.3 → python_roborock-3.16.0}/roborock/data/containers.py

@@ -284,6 +284,15 @@ class HomeDataScene(RoborockBase):
     name: str
 
 
+@dataclass
+class HomeDataSchedule(RoborockBase):
+    id: int
+    cron: str
+    repeated: bool
+    enabled: bool
+    param: dict | None = None
+
+
 @dataclass
 class HomeData(RoborockBase):
     id: int

python_roborock-3.16.0/roborock/devices/b01_channel.py

@@ -0,0 +1,77 @@
+"""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.14.3 → python_roborock-3.16.0}/roborock/devices/device.py

@@ -147,34 +147,45 @@ class RoborockDevice(ABC, TraitsMixin):
         called. The device will automatically attempt to reconnect if the connection
         is lost.
         """
-        start_attempt: asyncio.Event = asyncio.Event()
+        # The future will be set to True if the first attempt succeeds, False if
+        # it fails, or an exception if an unexpected error occurs.
+        # We use this to wait a short time for the first attempt to complete. We
+        # don't actually care about the result, just that we waited long enough.
+        start_attempt: asyncio.Future[bool] = asyncio.Future()
 
         async def connect_loop() -> None:
-            backoff = MIN_BACKOFF_INTERVAL
             try:
+                backoff = MIN_BACKOFF_INTERVAL
                 while True:
                     try:
                         await self.connect()
-                        start_attempt.set()
+                        if not start_attempt.done():
+                            start_attempt.set_result(True)
                         self._has_connected = True
                         self._ready_callbacks(self)
                         return
                     except RoborockException as e:
-                        start_attempt.set()
+                        if not start_attempt.done():
+                            start_attempt.set_result(False)
                         self._logger.info("Failed to connect (retry %s): %s", backoff.total_seconds(), e)
                         await asyncio.sleep(backoff.total_seconds())
                         backoff = min(backoff * BACKOFF_MULTIPLIER, MAX_BACKOFF_INTERVAL)
+                    except Exception as e:  # pylint: disable=broad-except
+                        if not start_attempt.done():
+                            start_attempt.set_exception(e)
+                        self._logger.exception("Uncaught error during connect: %s", e)
+                        return
             except asyncio.CancelledError:
                 self._logger.debug("connect_loop was cancelled for device %s", self.duid)
-                # Clean exit on cancellation
-                return
             finally:
-                start_attempt.set()
+                if not start_attempt.done():
+                    start_attempt.set_result(False)
 
         self._connect_task = asyncio.create_task(connect_loop())
 
         try:
-            await asyncio.wait_for(start_attempt.wait(), timeout=START_ATTEMPT_TIMEOUT.total_seconds())
+            async with asyncio.timeout(START_ATTEMPT_TIMEOUT.total_seconds()):
+                await start_attempt
         except TimeoutError:
             self._logger.debug("Initial connection attempt took longer than expected, will keep trying in background")
 
@@ -189,6 +200,7 @@ class RoborockDevice(ABC, TraitsMixin):
             except RoborockException:
                 unsub()
                 raise
+        self._logger.info("Connected to device")
         self._unsub = unsub
 
     async def close(self) -> None:

{python_roborock-3.14.3 → python_roborock-3.16.0}/roborock/devices/traits/b01/q7/__init__.py

@@ -1,6 +1,7 @@
 """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
@@ -13,17 +14,18 @@ __all__ = [
 
 
 class Q7PropertiesApi(Trait):
-    """API for interacting with Q7 B01 devices."""
+    """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]) -> None:
+    async def query_values(self, props: list[RoborockB01Props]) -> B01Props | None:
         """Query the device for the values of the given Q7 properties."""
-        await send_decoded_command(
+        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:

{python_roborock-3.14.3 → python_roborock-3.16.0}/roborock/mqtt/roborock_session.py

@@ -69,6 +69,7 @@ class RoborockMqttSession(MqttSession):
         self._stop = False
         self._backoff = MIN_BACKOFF_INTERVAL
         self._client: aiomqtt.Client | None = None
+        self._client_subscribed_topics: set[str] = set()
         self._client_lock = asyncio.Lock()
         self._listeners: CallbackMap[str, bytes] = CallbackMap(_LOGGER)
         self._connection_task: asyncio.Task[None] | None = None
@@ -218,7 +219,7 @@ class RoborockMqttSession(MqttSession):
                 # Re-establish any existing subscriptions
                 async with self._client_lock:
                     self._client = client
-                    for topic in self._listeners.keys():
+                    for topic in self._client_subscribed_topics:
                         _LOGGER.debug("Re-establishing subscription to topic %s", topic)
                         # TODO: If this fails it will break the whole connection. Make
                         # this retry again in the background with backoff.
@@ -249,32 +250,42 @@ class RoborockMqttSession(MqttSession):
         unsub = self._listeners.add_callback(topic, callback)
 
         async with self._client_lock:
-            if self._client:
-                _LOGGER.debug("Establishing subscription to topic %s", topic)
-                try:
-                    await self._client.subscribe(topic)
-                except MqttError as err:
-                    # Clean up the callback if subscription fails
-                    unsub()
-                    raise MqttSessionException(f"Error subscribing to topic: {err}") from err
-            else:
-                _LOGGER.debug("Client not connected, will establish subscription later")
-
-        def schedule_unsubscribe():
+            if topic not in self._client_subscribed_topics:
+                self._client_subscribed_topics.add(topic)
+                if self._client:
+                    _LOGGER.debug("Establishing subscription to topic %s", topic)
+                    try:
+                        await self._client.subscribe(topic)
+                    except MqttError as err:
+                        # Clean up the callback if subscription fails
+                        unsub()
+                        self._client_subscribed_topics.discard(topic)
+                        raise MqttSessionException(f"Error subscribing to topic: {err}") from err
+                else:
+                    _LOGGER.debug("Client not connected, will establish subscription later")
+
+        def schedule_unsubscribe() -> None:
             async def idle_unsubscribe():
                 try:
                     await asyncio.sleep(self._topic_idle_timeout.total_seconds())
                     # Only unsubscribe if there are no callbacks left for this topic
                     if not self._listeners.get_callbacks(topic):
                         async with self._client_lock:
+                            # Check again if we have listeners, in case a subscribe happened
+                            # while we were waiting for the lock or after we popped the timer.
+                            if self._listeners.get_callbacks(topic):
+                                _LOGGER.debug("Skipping unsubscribe for %s, new listeners added", topic)
+                                return
+
+                            self._idle_timers.pop(topic, None)
+                            self._client_subscribed_topics.discard(topic)
+
                             if self._client:
                                 _LOGGER.debug("Idle timeout expired, unsubscribing from topic %s", topic)
                                 try:
                                     await self._client.unsubscribe(topic)
                                 except MqttError as err:
                                     _LOGGER.warning("Error unsubscribing from topic %s: %s", topic, err)
-                    # Clean up timer from dict
-                    self._idle_timers.pop(topic, None)
                 except asyncio.CancelledError:
                     _LOGGER.debug("Idle unsubscribe for topic %s cancelled", topic)
 
@@ -286,7 +297,10 @@ class RoborockMqttSession(MqttSession):
             unsub()  # Remove the callback from CallbackMap
             # If no more callbacks for this topic, start idle timer
             if not self._listeners.get_callbacks(topic):
+                _LOGGER.debug("Unsubscribing topic %s, starting idle timer", topic)
                 schedule_unsubscribe()
+            else:
+                _LOGGER.debug("Unsubscribing topic %s, still have active callbacks", topic)
 
         return delayed_unsub
 

{python_roborock-3.14.3 → python_roborock-3.16.0}/roborock/protocol.py

@@ -276,12 +276,11 @@ 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"))
-            f = decipher.encrypt(obj)
-            return f
+            return decipher.encrypt(pad(obj, AES.block_size))
         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"))
-            return decipher.encrypt(obj)
+            return decipher.encrypt(pad(obj, AES.block_size))
         elif context.version == b"L01":
             return Utils.encrypt_gcm_l01(
                 plaintext=obj,
@@ -301,12 +300,11 @@ 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"))
-            f = decipher.decrypt(obj)
-            return f
+            return unpad(decipher.decrypt(obj), AES.block_size)
         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"))
-            return decipher.decrypt(obj)
+            return unpad(decipher.decrypt(obj), AES.block_size)
         elif context.version == b"L01":
             return Utils.decrypt_gcm_l01(
                 payload=obj,
@@ -350,6 +348,11 @@ class PrefixedStruct(Struct):
             # Read remaining data to find a valid header
             data = stream.read()
 
+            if not data:
+                # EOF reached, let the parser fail naturally without logging
+                stream_seek(stream, current_pos, 0, path)
+                return super()._parse(stream, context, path)
+
             start_index = -1
             # Find the earliest occurrence of any valid version in a single pass
             for i in range(len(data) - 2):

{python_roborock-3.14.3 → python_roborock-3.16.0}/roborock/protocols/b01_protocol.py

@@ -13,7 +13,6 @@ from roborock.roborock_message import (
     RoborockMessage,
     RoborockMessageProtocol,
 )
-from roborock.util import get_next_int
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -22,13 +21,13 @@ CommandType = RoborockB01Q7Methods | str
 ParamsType = list | dict | int | None
 
 
-def encode_mqtt_payload(dps: int, command: CommandType, params: ParamsType) -> RoborockMessage:
+def encode_mqtt_payload(dps: int, command: CommandType, params: ParamsType, msg_id: str) -> RoborockMessage:
     """Encode payload for B01 commands over MQTT."""
     dps_data = {
         "dps": {
             dps: {
                 "method": str(command),
-                "msgId": str(get_next_int(100000000000, 999999999999)),
+                "msgId": msg_id,
                 "params": params or [],
             }
         }
@@ -47,8 +46,9 @@ def decode_rpc_response(message: RoborockMessage) -> dict[int, Any]:
         raise RoborockException("Invalid B01 message format: missing payload")
     try:
         unpadded = unpad(message.payload, AES.block_size)
-    except ValueError as err:
-        raise RoborockException(f"Unable to unpad B01 payload: {err}")
+    except ValueError:
+        # It would be better to fail down the line.
+        unpadded = message.payload
 
     try:
         payload = json.loads(unpadded.decode())

{python_roborock-3.14.3 → python_roborock-3.16.0}/roborock/web_api.py

@@ -14,6 +14,7 @@ import aiohttp
 from aiohttp import ContentTypeError, FormData
 from pyrate_limiter import BucketFullException, Duration, Limiter, Rate
 
+from roborock import HomeDataSchedule
 from roborock.data import HomeData, HomeDataRoom, HomeDataScene, ProductResponse, RRiot, UserData
 from roborock.exceptions import (
     RoborockAccountDoesNotExist,
@@ -607,6 +608,28 @@ class RoborockApiClient:
         if not execute_scene_response.get("success"):
             raise RoborockException(execute_scene_response)
 
+    async def get_schedules(self, user_data: UserData, device_id: str) -> list[HomeDataSchedule]:
+        rriot = user_data.rriot
+        if rriot is None:
+            raise RoborockException("rriot is none")
+        if rriot.r.a is None:
+            raise RoborockException("Missing field 'a' in rriot reference")
+        schedules_request = PreparedRequest(
+            rriot.r.a,
+            self.session,
+            {
+                "Authorization": _get_hawk_authentication(rriot, f"/user/devices/{device_id}/jobs"),
+            },
+        )
+        schedules_response = await schedules_request.request("get", f"/user/devices/{str(device_id)}/jobs")
+        if not schedules_response.get("success"):
+            raise RoborockException(schedules_response)
+        schedules = schedules_response.get("result")
+        if isinstance(schedules, list):
+            return [HomeDataSchedule.from_dict(schedule) for schedule in schedules]
+        else:
+            raise RoborockException(f"schedule_response result was an unexpected type: {schedules}")
+
     async def get_products(self, user_data: UserData) -> ProductResponse:
         """Gets all products and their schemas, good for determining status codes and model numbers."""
         base_url = await self.base_url

python_roborock-3.14.3/roborock/data/b01_q7/b01_q7_containers.py

@@ -1,130 +0,0 @@
-from dataclasses import dataclass, field
-
-from ..containers import RoborockBase
-from .b01_q7_code_mappings import B01Fault, SCWindMapping, WorkModeMapping, WorkStatusMapping
-
-
-@dataclass
-class NetStatus(RoborockBase):
-    """Represents the network status of the device."""
-
-    rssi: str
-    loss: int
-    ping: int
-    ip: str
-    mac: str
-    ssid: str
-    frequency: int
-    bssid: str
-
-
-@dataclass
-class OrderTotal(RoborockBase):
-    """Represents the order total information."""
-
-    total: int
-    enable: int
-
-
-@dataclass
-class Privacy(RoborockBase):
-    """Represents the privacy settings of the device."""
-
-    ai_recognize: int
-    dirt_recognize: int
-    pet_recognize: int
-    carpet_turbo: int
-    carpet_avoid: int
-    carpet_show: int
-    map_uploads: int
-    ai_agent: int
-    ai_avoidance: int
-    record_uploads: int
-    along_floor: int
-    auto_upgrade: int
-
-
-@dataclass
-class PvCharging(RoborockBase):
-    """Represents the photovoltaic charging status."""
-
-    status: int
-    begin_time: int
-    end_time: int
-
-
-@dataclass
-class Recommend(RoborockBase):
-    """Represents cleaning recommendations."""
-
-    sill: int
-    wall: int
-    room_id: list[int] = field(default_factory=list)
-
-
-@dataclass
-class B01Props(RoborockBase):
-    """
-    Represents the complete properties and status for a Roborock B01 model.
-    This dataclass is generated based on the device's status JSON object.
-    """
-
-    status: WorkStatusMapping
-    fault: B01Fault
-    wind: SCWindMapping
-    water: int
-    mode: int
-    quantity: int
-    alarm: int
-    volume: int
-    hypa: int
-    main_brush: int
-    side_brush: int
-    mop_life: int
-    main_sensor: int
-    net_status: NetStatus
-    repeat_state: int
-    tank_state: int
-    sweep_type: int
-    clean_path_preference: int
-    cloth_state: int
-    time_zone: int
-    time_zone_info: str
-    language: int
-    cleaning_time: int
-    real_clean_time: int
-    cleaning_area: int
-    custom_type: int
-    sound: int
-    work_mode: WorkModeMapping
-    station_act: int
-    charge_state: int
-    current_map_id: int
-    map_num: int
-    dust_action: int
-    quiet_is_open: int
-    quiet_begin_time: int
-    quiet_end_time: int
-    clean_finish: int
-    voice_type: int
-    voice_type_version: int
-    order_total: OrderTotal
-    build_map: int
-    privacy: Privacy
-    dust_auto_state: int
-    dust_frequency: int
-    child_lock: int
-    multi_floor: int
-    map_save: int
-    light_mode: int
-    green_laser: int
-    dust_bag_used: int
-    order_save_mode: int
-    manufacturer: str
-    back_to_wash: int
-    charge_station_type: int
-    pv_cut_charge: int
-    pv_charging: PvCharging
-    serial_number: str
-    recommend: Recommend
-    add_sweep_status: int

python_roborock-3.14.3/roborock/devices/b01_channel.py

@@ -1,27 +0,0 @@
-"""Thin wrapper around the MQTT channel for Roborock B01 devices."""
-
-from __future__ import annotations
-
-import logging
-
-from roborock.protocols.b01_protocol import (
-    CommandType,
-    ParamsType,
-    encode_mqtt_payload,
-)
-
-from .mqtt_channel import MqttChannel
-
-_LOGGER = logging.getLogger(__name__)
-
-
-async def send_decoded_command(
-    mqtt_channel: MqttChannel,
-    dps: int,
-    command: CommandType,
-    params: ParamsType,
-) -> None:
-    """Send a command on the MQTT channel and get a decoded response."""
-    _LOGGER.debug("Sending MQTT command: %s", params)
-    roborock_message = encode_mqtt_payload(dps, command, params)
-    await mqtt_channel.publish(roborock_message)