python-roborock 2.29.0__tar.gz → 2.30.0__tar.gz

{python_roborock-2.29.0 → python_roborock-2.30.0}/PKG-INFO

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

{python_roborock-2.29.0 → python_roborock-2.30.0}/pyproject.toml

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

{python_roborock-2.29.0 → python_roborock-2.30.0}/roborock/containers.py

@@ -1,9 +1,9 @@
-from __future__ import annotations
-
+import dataclasses
 import datetime
 import json
 import logging
 import re
+import types
 from dataclasses import asdict, dataclass, field
 from datetime import timezone
 from enum import Enum
@@ -95,105 +95,73 @@ from .exceptions import RoborockException
 _LOGGER = logging.getLogger(__name__)
 
 
-def camelize(s: str):
+def _camelize(s: str):
     first, *others = s.split("_")
     if len(others) == 0:
         return s
     return "".join([first.lower(), *map(str.title, others)])
 
 
-def decamelize(s: str):
+def _decamelize(s: str):
     return re.sub("([A-Z]+)", "_\\1", s).lower()
 
 
-def decamelize_obj(d: dict | list, ignore_keys: list[str]):
-    if isinstance(d, RoborockBase):
-        d = d.as_dict()
-    if isinstance(d, list):
-        return [decamelize_obj(i, ignore_keys) if isinstance(i, dict | list) else i for i in d]
-    return {
-        (decamelize(a) if a not in ignore_keys else a): decamelize_obj(b, ignore_keys)
-        if isinstance(b, dict | list)
-        else b
-        for a, b in d.items()
-    }
-
-
 @dataclass
 class RoborockBase:
     _ignore_keys = []  # type: ignore
-    is_cached = False
 
     @staticmethod
-    def convert_to_class_obj(type, value):
-        try:
-            class_type = eval(type)
-            if get_origin(class_type) is list:
-                return_list = []
-                cls_type = get_args(class_type)[0]
-                for obj in value:
-                    if issubclass(cls_type, RoborockBase):
-                        return_list.append(cls_type.from_dict(obj))
-                    elif cls_type in {str, int, float}:
-                        return_list.append(cls_type(obj))
-                    else:
-                        return_list.append(cls_type(**obj))
-                return return_list
-            if issubclass(class_type, RoborockBase):
-                converted_value = class_type.from_dict(value)
-            else:
-                converted_value = class_type(value)
-            return converted_value
-        except NameError as err:
-            _LOGGER.exception(err)
-        except ValueError as err:
-            _LOGGER.exception(err)
-        except Exception as err:
-            _LOGGER.exception(err)
-        raise Exception("Fail")
+    def _convert_to_class_obj(class_type: type, value):
+        if get_origin(class_type) is list:
+            sub_type = get_args(class_type)[0]
+            return [RoborockBase._convert_to_class_obj(sub_type, obj) for obj in value]
+        if get_origin(class_type) is dict:
+            _, value_type = get_args(class_type)  # assume keys are only basic types
+            return {k: RoborockBase._convert_to_class_obj(value_type, v) for k, v in value.items()}
+        if issubclass(class_type, RoborockBase):
+            return class_type.from_dict(value)
+        if class_type is Any:
+            return value
+        return class_type(value)  # type: ignore[call-arg]
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]):
-        if isinstance(data, dict):
-            ignore_keys = cls._ignore_keys
-            data = decamelize_obj(data, ignore_keys)
-            cls_annotations: dict[str, str] = {}
-            for base in reversed(cls.__mro__):
-                cls_annotations.update(getattr(base, "__annotations__", {}))
-            remove_keys = []
-            for key, value in data.items():
-                if key not in cls_annotations:
-                    remove_keys.append(key)
-                    continue
-                if value == "None" or value is None:
-                    data[key] = None
-                    continue
-                field_type: str = cls_annotations[key]
-                if "|" in field_type:
-                    # It's a union
-                    types = field_type.split("|")
-                    for type in types:
-                        if "None" in type or "Any" in type:
-                            continue
-                        try:
-                            data[key] = RoborockBase.convert_to_class_obj(type, value)
-                            break
-                        except Exception:
-                            ...
-                else:
+        """Create an instance of the class from a dictionary."""
+        if not isinstance(data, dict):
+            return None
+        field_types = {field.name: field.type for field in dataclasses.fields(cls)}
+        result: dict[str, Any] = {}
+        for key, value in data.items():
+            key = _decamelize(key)
+            if (field_type := field_types.get(key)) is None:
+                continue
+            if value == "None" or value is None:
+                result[key] = None
+                continue
+            if isinstance(field_type, types.UnionType):
+                for subtype in get_args(field_type):
+                    if subtype is types.NoneType:
+                        continue
                     try:
-                        data[key] = RoborockBase.convert_to_class_obj(field_type, value)
+                        result[key] = RoborockBase._convert_to_class_obj(subtype, value)
+                        break
                     except Exception:
-                        ...
-            for key in remove_keys:
-                del data[key]
-            return cls(**data)
+                        _LOGGER.exception(f"Failed to convert {key} with value {value} to type {subtype}")
+                        continue
+            else:
+                try:
+                    result[key] = RoborockBase._convert_to_class_obj(field_type, value)
+                except Exception:
+                    _LOGGER.exception(f"Failed to convert {key} with value {value} to type {field_type}")
+                    continue
+
+        return cls(**result)
 
     def as_dict(self) -> dict:
         return asdict(
             self,
             dict_factory=lambda _fields: {
-                camelize(key): value.value if isinstance(value, Enum) else value
+                _camelize(key): value.value if isinstance(value, Enum) else value
                 for (key, value) in _fields
                 if value is not None
             },

{python_roborock-2.29.0 → python_roborock-2.30.0}/roborock/device_features.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field, fields
-from enum import IntEnum
+from enum import IntEnum, StrEnum
 from typing import Any
 
 from roborock import RoborockProductNickname
@@ -59,6 +59,121 @@ class NewFeatureStrBit(IntEnum):
     EGG_DANCE_MODE = 87
 
 
+class ProductFeatures(StrEnum):
+    REMOTE_BACK = "remote_back"
+    CLEANMODE_MAXPLUS = "cleanmode_maxplus"
+    CLEANMODE_PURECLEANMOP = "cleanmode_purecleanmop"
+    CLEANMODE_NONE_PURECLEANMOP_WITH_MAXPLUS = "cleanmode_none_purecleanmop_with_maxplus"
+    MOP_ELECTRONIC_MODULE = "mop_electronic_module"
+    MOP_SHAKE_MODULE = "mop_shake_module"
+    MOP_SPIN_MODULE = "mop_spin_module"
+    DEFAULT_MAP3D = "map3d"
+    DEFAULT_CLEANMODECUSTOM = "custom_cleanmode"
+    REALTIMEVIDEO = "realtimevideo"
+    REALTIMEVIDEO_LIVECALL = "realtimevideo_livecall"
+    REALTIMEVIDEO_RECORDANDSHORTCUT = "realtimevideo_livecall"
+    CAMERA_SINGLELINE = "camera_singleline"
+    CAMERA_DUALLINE = "camera_dualline"
+    CAMERA_RGB = "camera_rgb"
+    CAMERA_DOUBLERGB = "camera_doublergb"
+    AIRECOGNITION_SETTING = "airecognition_setting"
+    AIRECOGNITION_SCENE = "airecognition_scene"
+    AIRECOGNITION_PET = "airecognition_pet"
+    AIRECOGNITION_OBSTACLE = "airecognition_obstacle"
+
+
+# The following combinations are pulled directly from decompiled source code.
+AIRECOGNITION_OBSTACLE = [ProductFeatures.AIRECOGNITION_OBSTACLE]
+RGB_CAMERA_FEATURES = [
+    ProductFeatures.CAMERA_RGB,
+    ProductFeatures.AIRECOGNITION_SETTING,
+    ProductFeatures.AIRECOGNITION_SCENE,
+    ProductFeatures.AIRECOGNITION_PET,
+    ProductFeatures.AIRECOGNITION_OBSTACLE,
+    ProductFeatures.REALTIMEVIDEO,
+    ProductFeatures.REALTIMEVIDEO_LIVECALL,
+    ProductFeatures.REALTIMEVIDEO_RECORDANDSHORTCUT,
+]
+DOUBLE_RGB_CAMERA_FEATURES = [
+    ProductFeatures.CAMERA_DOUBLERGB,
+    ProductFeatures.AIRECOGNITION_SETTING,
+    ProductFeatures.AIRECOGNITION_PET,
+    ProductFeatures.AIRECOGNITION_OBSTACLE,
+    ProductFeatures.REALTIMEVIDEO,
+]
+SINGLE_LINE_CAMERA_FEATURES = [
+    ProductFeatures.CAMERA_SINGLELINE,
+    ProductFeatures.AIRECOGNITION_SETTING,
+    ProductFeatures.AIRECOGNITION_OBSTACLE,
+]
+DUAL_LINE_CAMERA_FEATURES = [
+    ProductFeatures.CAMERA_DUALLINE,
+    ProductFeatures.AIRECOGNITION_SETTING,
+    ProductFeatures.AIRECOGNITION_OBSTACLE,
+    ProductFeatures.AIRECOGNITION_PET,
+]
+
+NEW_DEFAULT_FEATURES = [ProductFeatures.REMOTE_BACK, ProductFeatures.CLEANMODE_MAXPLUS]
+
+
+PEARL_FEATURES = NEW_DEFAULT_FEATURES + SINGLE_LINE_CAMERA_FEATURES + [ProductFeatures.MOP_SPIN_MODULE]
+PEARL_PLUS_FEATURES = NEW_DEFAULT_FEATURES + RGB_CAMERA_FEATURES + [ProductFeatures.MOP_SPIN_MODULE]
+ULTRON_FEATURES = NEW_DEFAULT_FEATURES + DUAL_LINE_CAMERA_FEATURES + [ProductFeatures.MOP_SHAKE_MODULE]
+ULTRONSV_FEATURES = NEW_DEFAULT_FEATURES + RGB_CAMERA_FEATURES + [ProductFeatures.MOP_SHAKE_MODULE]
+TANOSS_FEATURES = NEW_DEFAULT_FEATURES + [ProductFeatures.MOP_SHAKE_MODULE]
+TOPAZSPOWER_FEATURES = NEW_DEFAULT_FEATURES + [ProductFeatures.MOP_SHAKE_MODULE]
+
+product_feature_map = {
+    RoborockProductNickname.PEARL: PEARL_FEATURES,
+    RoborockProductNickname.PEARLS: PEARL_FEATURES,
+    RoborockProductNickname.PEARLPLUS: PEARL_PLUS_FEATURES,
+    RoborockProductNickname.VIVIAN: PEARL_PLUS_FEATURES,
+    RoborockProductNickname.CORAL: PEARL_PLUS_FEATURES,
+    RoborockProductNickname.ULTRON: ULTRON_FEATURES,
+    RoborockProductNickname.ULTRONE: [ProductFeatures.CLEANMODE_NONE_PURECLEANMOP_WITH_MAXPLUS],
+    RoborockProductNickname.ULTRONSV: ULTRONSV_FEATURES,
+    RoborockProductNickname.TOPAZSPOWER: TOPAZSPOWER_FEATURES,
+    RoborockProductNickname.TANOSS: TANOSS_FEATURES,
+    RoborockProductNickname.PEARLC: PEARL_FEATURES,
+    RoborockProductNickname.PEARLPLUSS: PEARL_PLUS_FEATURES,
+    RoborockProductNickname.PEARLSLITE: PEARL_FEATURES,
+    RoborockProductNickname.PEARLE: PEARL_FEATURES,
+    RoborockProductNickname.PEARLELITE: PEARL_FEATURES,
+    RoborockProductNickname.VIVIANC: PEARL_PLUS_FEATURES,
+    RoborockProductNickname.CORALPRO: PEARL_PLUS_FEATURES,
+    RoborockProductNickname.ULTRONLITE: SINGLE_LINE_CAMERA_FEATURES
+    + [ProductFeatures.CLEANMODE_NONE_PURECLEANMOP_WITH_MAXPLUS, ProductFeatures.MOP_ELECTRONIC_MODULE],
+    RoborockProductNickname.ULTRONSC: ULTRON_FEATURES,
+    RoborockProductNickname.ULTRONSE: [
+        ProductFeatures.CLEANMODE_NONE_PURECLEANMOP_WITH_MAXPLUS,
+        ProductFeatures.MOP_ELECTRONIC_MODULE,
+    ],
+    RoborockProductNickname.ULTRONSPLUS: ULTRON_FEATURES,
+    RoborockProductNickname.VERDELITE: ULTRONSV_FEATURES,
+    RoborockProductNickname.TOPAZS: NEW_DEFAULT_FEATURES + [ProductFeatures.MOP_SHAKE_MODULE],
+    RoborockProductNickname.TOPAZSPLUS: NEW_DEFAULT_FEATURES
+    + DUAL_LINE_CAMERA_FEATURES
+    + [ProductFeatures.MOP_SHAKE_MODULE],
+    RoborockProductNickname.TOPAZSC: TOPAZSPOWER_FEATURES + SINGLE_LINE_CAMERA_FEATURES,
+    RoborockProductNickname.TOPAZSV: NEW_DEFAULT_FEATURES + RGB_CAMERA_FEATURES + [ProductFeatures.MOP_SHAKE_MODULE],
+    RoborockProductNickname.TANOSSPLUS: TANOSS_FEATURES + DUAL_LINE_CAMERA_FEATURES,
+    RoborockProductNickname.TANOSSLITE: [ProductFeatures.MOP_ELECTRONIC_MODULE],
+    RoborockProductNickname.TANOSSC: [],
+    RoborockProductNickname.TANOSSE: [],
+    RoborockProductNickname.TANOSSMAX: NEW_DEFAULT_FEATURES
+    + DUAL_LINE_CAMERA_FEATURES
+    + [ProductFeatures.MOP_SHAKE_MODULE],
+    RoborockProductNickname.TANOS: [ProductFeatures.REMOTE_BACK],
+    RoborockProductNickname.TANOSE: [ProductFeatures.MOP_ELECTRONIC_MODULE, ProductFeatures.REMOTE_BACK],
+    RoborockProductNickname.TANOSV: DOUBLE_RGB_CAMERA_FEATURES
+    + [ProductFeatures.REMOTE_BACK, ProductFeatures.MOP_ELECTRONIC_MODULE],
+    RoborockProductNickname.RUBYPLUS: [],
+    RoborockProductNickname.RUBYSC: [],
+    RoborockProductNickname.RUBYSE: [],
+    RoborockProductNickname.RUBYSLITE: [ProductFeatures.MOP_ELECTRONIC_MODULE],
+}
+
+
 @dataclass
 class DeviceFeatures:
     """Represents the features supported by a Roborock device."""
@@ -290,6 +405,24 @@ class DeviceFeatures:
     )
     is_support_mop_back_pwm_set: bool = field(metadata={"model_whitelist": [RoborockProductNickname.PEARL]})
     is_collect_dust_mode_supported: bool = field(metadata={"model_blacklist": [RoborockProductNickname.PEARL]})
+    is_support_water_mode: bool = field(
+        metadata={
+            "product_features": [
+                ProductFeatures.MOP_ELECTRONIC_MODULE,
+                ProductFeatures.MOP_SHAKE_MODULE,
+                ProductFeatures.MOP_SPIN_MODULE,
+            ]
+        }
+    )
+    is_pure_clean_mop_supported: bool = field(metadata={"product_features": [ProductFeatures.CLEANMODE_PURECLEANMOP]})
+    is_new_remote_view_supported: bool = field(metadata={"product_features": [ProductFeatures.REMOTE_BACK]})
+    is_max_plus_mode_supported: bool = field(metadata={"product_features": [ProductFeatures.CLEANMODE_MAXPLUS]})
+    is_none_pure_clean_mop_with_max_plus: bool = field(
+        metadata={"product_features": [ProductFeatures.CLEANMODE_NONE_PURECLEANMOP_WITH_MAXPLUS]}
+    )
+    is_clean_route_setting_supported: bool = field(
+        metadata={"product_features": [ProductFeatures.MOP_SHAKE_MODULE, ProductFeatures.MOP_SPIN_MODULE]}
+    )
 
     @classmethod
     def from_feature_flags(
@@ -357,6 +490,11 @@ class DeviceFeatures:
                     kwargs[f.name] = True
                 else:
                     kwargs[f.name] = product_nickname not in blacklist
+            elif (product_features := f.metadata.get("product_features")) is not None:
+                if product_nickname is not None:
+                    available_features = product_feature_map.get(product_nickname, [])
+                    if any(feat in available_features for feat in product_features):  # type: ignore
+                        kwargs[f.name] = True
 
         return cls(**kwargs)
 

{python_roborock-2.29.0 → python_roborock-2.30.0}/roborock/roborock_typing.py

@@ -271,182 +271,6 @@ class RoborockCommand(str, Enum):
     APP_GET_ROBOT_SETTING = "app_get_robot_setting"
 
 
-@dataclass
-class CommandInfo:
-    params: list | dict | int | None = None
-
-
-CommandInfoMap: dict[RoborockCommand | None, CommandInfo] = {
-    RoborockCommand.APP_CHARGE: CommandInfo(params=[]),
-    RoborockCommand.APP_GET_DRYER_SETTING: CommandInfo(params=None),
-    RoborockCommand.APP_GET_INIT_STATUS: CommandInfo(params=[]),
-    RoborockCommand.APP_GOTO_TARGET: CommandInfo(params=[25000, 24850]),
-    RoborockCommand.APP_PAUSE: CommandInfo(params=[]),
-    RoborockCommand.APP_RC_END: CommandInfo(params=[]),
-    RoborockCommand.APP_RC_MOVE: CommandInfo(params=None),
-    RoborockCommand.APP_RC_START: CommandInfo(params=[]),
-    RoborockCommand.APP_RC_STOP: CommandInfo(params=[]),
-    RoborockCommand.APP_SEGMENT_CLEAN: CommandInfo(params=[{"segments": 16, "repeat": 2}]),
-    # RoborockCommand.APP_SEGMENT_CLEAN: CommandInfo(prefix=b"\x00\x00\x00\x87", params=None),
-    RoborockCommand.APP_SET_DRYER_SETTING: CommandInfo(params=None),
-    RoborockCommand.APP_SET_SMART_CLIFF_FORBIDDEN: CommandInfo(params={"zones": [], "map_index": 0}),
-    RoborockCommand.APP_SPOT: CommandInfo(params=[]),
-    RoborockCommand.APP_START: CommandInfo(params=None),
-    # RoborockCommand.APP_START: CommandInfo(prefix=b"\x00\x00\x00\x87", params=[{"use_new_map": 1}]),
-    RoborockCommand.APP_START_COLLECT_DUST: CommandInfo(params=None),
-    RoborockCommand.APP_START_WASH: CommandInfo(params=None),
-    RoborockCommand.APP_STAT: CommandInfo(
-        params=[
-            {
-                "ver": "0.1",
-                "data": [
-                    {
-                        "times": [1682723478],
-                        "data": {
-                            "region": "America/Sao_Paulo",
-                            "pluginVersion": "2820",
-                            "mnc": "*",
-                            "os": "ios",
-                            "osVersion": "16.1",
-                            "mcc": "not-cn",
-                            "language": "en_BR",
-                            "mobileBrand": "*",
-                            "appType": "roborock",
-                            "mobileModel": "iPhone13,1",
-                        },
-                        "type": 2,
-                    }
-                ],
-            }
-        ],
-    ),
-    RoborockCommand.APP_STOP: CommandInfo(params=[]),
-    RoborockCommand.APP_STOP_WASH: CommandInfo(params=None),
-    RoborockCommand.APP_WAKEUP_ROBOT: CommandInfo(params=[]),
-    RoborockCommand.APP_ZONED_CLEAN: CommandInfo(params=[[24900, 25100, 26300, 26450, 1]]),
-    RoborockCommand.CHANGE_SOUND_VOLUME: CommandInfo(params=None),
-    RoborockCommand.CLOSE_DND_TIMER: CommandInfo(params=[]),
-    RoborockCommand.CLOSE_VALLEY_ELECTRICITY_TIMER: CommandInfo(params=[]),
-    RoborockCommand.DNLD_INSTALL_SOUND: CommandInfo(
-        params={"url": "https://awsusor0.fds.api.xiaomi.com/app/topazsv/voice-pkg/package/en.pkg", "sid": 3, "sver": 5},
-    ),
-    RoborockCommand.ENABLE_LOG_UPLOAD: CommandInfo(params=[9, 2]),
-    RoborockCommand.END_EDIT_MAP: CommandInfo(params=[]),
-    RoborockCommand.FIND_ME: CommandInfo(params=None),
-    RoborockCommand.GET_CAMERA_STATUS: CommandInfo(params=[]),
-    RoborockCommand.GET_CARPET_CLEAN_MODE: CommandInfo(params=[]),
-    RoborockCommand.GET_CARPET_MODE: CommandInfo(params=[]),
-    RoborockCommand.GET_CHILD_LOCK_STATUS: CommandInfo(params=[]),
-    RoborockCommand.GET_CLEAN_RECORD: CommandInfo(params=[1682257961]),
-    RoborockCommand.GET_CLEAN_RECORD_MAP: CommandInfo(params={"start_time": 1682597877}),
-    RoborockCommand.GET_CLEAN_SEQUENCE: CommandInfo(params=[]),
-    RoborockCommand.GET_CLEAN_SUMMARY: CommandInfo(params=[]),
-    RoborockCommand.GET_COLLISION_AVOID_STATUS: CommandInfo(params=[]),
-    RoborockCommand.GET_CONSUMABLE: CommandInfo(params=[]),
-    RoborockCommand.GET_CURRENT_SOUND: CommandInfo(params=[]),
-    RoborockCommand.GET_CUSTOMIZE_CLEAN_MODE: CommandInfo(params=[]),
-    RoborockCommand.GET_CUSTOM_MODE: CommandInfo(params=None),
-    RoborockCommand.GET_DEVICE_ICE: CommandInfo(params=[]),
-    RoborockCommand.GET_DEVICE_SDP: CommandInfo(params=[]),
-    RoborockCommand.GET_DND_TIMER: CommandInfo(params=[]),
-    RoborockCommand.GET_DUST_COLLECTION_MODE: CommandInfo(params=None),
-    RoborockCommand.GET_FLOW_LED_STATUS: CommandInfo(params=[]),
-    RoborockCommand.GET_HOMESEC_CONNECT_STATUS: CommandInfo(params=[]),
-    RoborockCommand.GET_IDENTIFY_FURNITURE_STATUS: CommandInfo(params=[]),
-    RoborockCommand.GET_IDENTIFY_GROUND_MATERIAL_STATUS: CommandInfo(params=[]),
-    RoborockCommand.GET_LED_STATUS: CommandInfo(params=[]),
-    RoborockCommand.GET_MAP_V1: CommandInfo(params={}),
-    RoborockCommand.GET_MOP_TEMPLATE_PARAMS_SUMMARY: CommandInfo(params={}),
-    RoborockCommand.GET_MULTI_MAP: CommandInfo(params={"map_index": 0}),
-    RoborockCommand.GET_MULTI_MAPS_LIST: CommandInfo(params=[]),
-    RoborockCommand.GET_NETWORK_INFO: CommandInfo(params=[]),
-    RoborockCommand.GET_PROP: CommandInfo(params=["get_status"]),
-    RoborockCommand.GET_ROOM_MAPPING: CommandInfo(params=[]),
-    RoborockCommand.GET_SCENES_VALID_TIDS: CommandInfo(params={}),
-    RoborockCommand.GET_SERIAL_NUMBER: CommandInfo(params=[]),
-    RoborockCommand.GET_SERVER_TIMER: CommandInfo(params=[]),
-    RoborockCommand.GET_SMART_WASH_PARAMS: CommandInfo(params=None),
-    RoborockCommand.GET_SOUND_PROGRESS: CommandInfo(params=[]),
-    RoborockCommand.GET_SOUND_VOLUME: CommandInfo(params=[]),
-    RoborockCommand.GET_STATUS: CommandInfo(params=None),
-    RoborockCommand.GET_TIMEZONE: CommandInfo(params=[]),
-    RoborockCommand.GET_TURN_SERVER: CommandInfo(params=[]),
-    RoborockCommand.GET_VALLEY_ELECTRICITY_TIMER: CommandInfo(params=[]),
-    RoborockCommand.GET_WASH_TOWEL_MODE: CommandInfo(params=None),
-    RoborockCommand.LOAD_MULTI_MAP: CommandInfo(params=None),
-    RoborockCommand.NAME_SEGMENT: CommandInfo(params=None),
-    RoborockCommand.REUNION_SCENES: CommandInfo(params={"data": [{"tid": "1687830208457"}]}),
-    RoborockCommand.RESET_CONSUMABLE: CommandInfo(params=None),
-    RoborockCommand.RESUME_SEGMENT_CLEAN: CommandInfo(params=None),
-    RoborockCommand.RESUME_ZONED_CLEAN: CommandInfo(params=None),
-    RoborockCommand.RETRY_REQUEST: CommandInfo(params={"retry_id": 439374, "retry_count": 8, "method": "save_map"}),
-    RoborockCommand.SAVE_MAP: CommandInfo(
-        params={
-            "data": [
-                [1, 25043, 24952, 26167, 24952],
-                [0, 25043, 25514, 26167, 25514, 26167, 24390, 25043, 24390],
-                [2, 25038, 26782, 26162, 26782, 26162, 25658, 25038, 25658],
-                [100, 0],
-            ],
-            "need_retry": 1,
-        },
-    ),
-    RoborockCommand.SEND_ICE_TO_ROBOT: CommandInfo(
-        params={
-            "app_ice": "eyJjYW5kaWRhdGUiOiAiY2FuZGlkYXRlOjE1MzE5NzE5NTEgMSB1ZHAgNDE4MTk5MDMgNTQuMTc0LjE4Ni4yNDkgNTQxNzU"
-            "gdHlwIHJlbGF5IHJhZGRyIDE3Ny4xOC4xMzQuOTkgcnBvcnQgNjQ2OTEgZ2VuZXJhdGlvbiAwIHVmcmFnIDVOMVogbmV0d2"
-            "9yay1pZCAxIG5ldHdvcmstY29zdCAxMCIsICJzZHBNTGluZUluZGV4IjogMSwgInNkcE1pZCI6ICIxIn0="
-        },
-    ),
-    RoborockCommand.SET_APP_TIMEZONE: CommandInfo(params=["America/Sao_Paulo", 2]),
-    RoborockCommand.SET_CAMERA_STATUS: CommandInfo(params=[3493]),
-    RoborockCommand.SET_CARPET_CLEAN_MODE: CommandInfo(params={"carpet_clean_mode": 0}),
-    RoborockCommand.SET_CARPET_MODE: CommandInfo(
-        params=[{"enable": 1, "current_high": 500, "current_integral": 450, "current_low": 400, "stall_time": 10}],
-    ),
-    RoborockCommand.SET_CHILD_LOCK_STATUS: CommandInfo(params={"lock_status": 0}),
-    RoborockCommand.SET_CLEAN_MOTOR_MODE: CommandInfo(
-        params=[{"fan_power": 106, "mop_mode": 302, "water_box_mode": 204}]
-    ),
-    RoborockCommand.SET_COLLISION_AVOID_STATUS: CommandInfo(params={"status": 1}),
-    RoborockCommand.SET_CUSTOMIZE_CLEAN_MODE: CommandInfo(params={"data": [], "need_retry": 1}),
-    RoborockCommand.SET_CUSTOM_MODE: CommandInfo(params=[108]),
-    RoborockCommand.SET_DND_TIMER: CommandInfo(params=[22, 0, 8, 0]),
-    RoborockCommand.SET_DUST_COLLECTION_MODE: CommandInfo(params=None),
-    RoborockCommand.SET_FDS_ENDPOINT: CommandInfo(params=["awsusor0.fds.api.xiaomi.com"]),
-    RoborockCommand.SET_FLOW_LED_STATUS: CommandInfo(params={"status": 1}),
-    RoborockCommand.SET_IDENTIFY_FURNITURE_STATUS: CommandInfo(params={"status": 1}),
-    RoborockCommand.SET_IDENTIFY_GROUND_MATERIAL_STATUS: CommandInfo(params={"status": 1}),
-    RoborockCommand.SET_LED_STATUS: CommandInfo(params=[1]),
-    RoborockCommand.SET_MOP_MODE: CommandInfo(params=None),
-    RoborockCommand.SET_SCENES_SEGMENTS: CommandInfo(
-        params={"data": [{"tid": "1687831528786", "segs": [{"sid": 22}, {"sid": 18}]}]}
-    ),
-    RoborockCommand.SET_SCENES_ZONES: CommandInfo(
-        params={"data": [{"zones": [{"zid": 0, "range": [27700, 23750, 30850, 26900]}], "tid": "1687831073722"}]}
-    ),
-    RoborockCommand.SET_SERVER_TIMER: CommandInfo(
-        params={
-            "data": [["1687793948482", ["39 12 * * 0,1,2,3,4,5,6", ["start_clean", 106, "0", -1]]]],
-            "need_retry": 1,
-        }
-    ),
-    RoborockCommand.SET_SMART_WASH_PARAMS: CommandInfo(params=None),
-    RoborockCommand.SET_TIMEZONE: CommandInfo(params=["America/Sao_Paulo"]),
-    RoborockCommand.SET_VALLEY_ELECTRICITY_TIMER: CommandInfo(params=[0, 0, 8, 0]),
-    RoborockCommand.SET_WASH_TOWEL_MODE: CommandInfo(params=None),
-    RoborockCommand.SET_WATER_BOX_CUSTOM_MODE: CommandInfo(params=[203]),
-    RoborockCommand.START_CAMERA_PREVIEW: CommandInfo(params={"client_id": "443f8636", "quality": "SD"}),
-    RoborockCommand.START_EDIT_MAP: CommandInfo(params=[]),
-    RoborockCommand.START_WASH_THEN_CHARGE: CommandInfo(params=None),
-    RoborockCommand.STOP_CAMERA_PREVIEW: CommandInfo(params={"client_id": "443f8636"}),
-    RoborockCommand.SWITCH_WATER_MARK: CommandInfo(params={"waterMark": "OFF"}),
-    RoborockCommand.TEST_SOUND_VOLUME: CommandInfo(params=None),
-    RoborockCommand.UPD_SERVER_TIMER: CommandInfo(params=[["1687793948482", "off"]]),
-    RoborockCommand.DEL_SERVER_TIMER: CommandInfo(params=["1687793948482"]),
-}
-
-
 @dataclass
 class DockSummary(RoborockBase):
     dust_collection_mode: DustCollectionMode | None = None