python-roborock 1.0.0__tar.gz → 2.1.0__tar.gz

{python_roborock-1.0.0 → python_roborock-2.1.0}/PKG-INFO

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

{python_roborock-1.0.0 → python_roborock-2.1.0}/pyproject.toml

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

{python_roborock-1.0.0 → python_roborock-2.1.0}/roborock/api.py

@@ -12,9 +12,6 @@ from typing import Any
 
 from .containers import (
     DeviceData,
-    ModelStatus,
-    S7MaxVStatus,
-    Status,
 )
 from .exceptions import (
     RoborockTimeout,
@@ -48,16 +45,10 @@ class RoborockClient:
         self._logger = RoborockLoggerAdapter(device_info.device.name, _LOGGER)
         self.is_available: bool = True
         self.queue_timeout = queue_timeout
-        self._status_type: type[Status] = ModelStatus.get(self.device_info.model, S7MaxVStatus)
 
     def __del__(self) -> None:
         self.release()
 
-    @property
-    def status_type(self) -> type[Status]:
-        """Gets the status type for this device"""
-        return self._status_type
-
     def release(self):
         self.sync_disconnect()
 

{python_roborock-1.0.0 → python_roborock-2.1.0}/roborock/code_mappings.py

@@ -65,10 +65,12 @@ class RoborockStateCode(RoborockEnum):
     segment_cleaning = 18
     emptying_the_bin = 22  # on s7+
     washing_the_mop = 23  # on a46
+    washing_the_mop_2 = 25
     going_to_wash_the_mop = 26  # on a46
     in_call = 28
     mapping = 29
     egg_attack = 30
+    patrol = 32
     charging_complete = 100
     device_offline = 101
     locked = 103
@@ -126,6 +128,7 @@ class RoborockErrorCode(RoborockEnum):
     side_brush_error = 17
     fan_error = 18
     dock = 19  # Dock not connected to power
+    optical_flow_sensor_dirt = 20
     vertical_bumper_pressed = 21
     dock_locator_error = 22
     return_to_dock_fail = 23
@@ -150,7 +153,14 @@ class RoborockErrorCode(RoborockEnum):
     clear_brush_exception_2 = 43  # Positioning button error
     filter_screen_exception = 44  # Clean the dock water filter
     mopping_roller_2 = 45  # Wash roller may be jammed
+    up_water_exception = 48
+    drain_water_exception = 49
     temperature_protection = 51  # Unit temperature protection
+    clean_carousel_exception = 52
+    clean_carousel_water_full = 53
+    water_carriage_drop = 54
+    check_clean_carouse = 55
+    audio_error = 56
 
 
 class RoborockFanPowerCode(RoborockEnum):
@@ -236,6 +246,14 @@ class RoborockFanSpeedP10(RoborockFanPowerCode):
     max_plus = 108
 
 
+class RoborockFanSpeedS8MaxVUltra(RoborockFanPowerCode):
+    off = 105
+    balanced = 102
+    custom = 106
+    max_plus = 108
+    smart_mode = 110
+
+
 class RoborockMopModeCode(RoborockEnum):
     """Describes the mop mode of the vacuum cleaner."""
 
@@ -257,6 +275,15 @@ class RoborockMopModeS8ProUltra(RoborockMopModeCode):
     custom = 302
 
 
+class RoborockMopModeS8MaxVUltra(RoborockMopModeCode):
+    standard = 300
+    deep = 301
+    deep_plus = 303
+    fast = 304
+    deep_plus_pearl = 305
+    smart_mode = 306
+
+
 class RoborockMopIntensityCode(RoborockEnum):
     """Describes the mop intensity of the vacuum cleaner."""
 
@@ -292,6 +319,14 @@ class RoborockMopIntensityP10(RoborockMopIntensityCode):
     custom_water_flow = 207
 
 
+class RoborockMopIntensityS8MaxVUltra(RoborockMopIntensityCode):
+    off = 200
+    low = 201
+    medium = 202
+    smart_mode = 209
+    custom_water_flow = 207
+
+
 class RoborockMopIntensityS5Max(RoborockMopIntensityCode):
     """Describes the mop intensity of the vacuum cleaner."""
 
@@ -321,6 +356,7 @@ class RoborockDockErrorCode(RoborockEnum):
     duct_blockage = 34
     water_empty = 38
     waste_water_tank_full = 39
+    maintenance_brush_jammed = 42
     dirty_tank_latch_open = 44
     no_dustbin = 46
     cleaning_tank_full_or_blocked = 53
@@ -335,6 +371,7 @@ class RoborockDockTypeCode(RoborockEnum):
     s7_max_ultra_dock = 6
     s8_dock = 7
     p10_dock = 8
+    s8_maxv_ultra_dock = 10
 
 
 class RoborockDockDustCollectionModeCode(RoborockEnum):
@@ -450,3 +487,138 @@ class DyadError(RoborockEnum):
     dirty_charging_contacts = 10007  # Disconnection between the device and dock. Wipe charging contacts.
     low_battery = 20017  # Low battery level. Charge before starting self-cleaning.
     battery_under_10 = 20018  # Charge until the battery level exceeds 10% before manually starting self-cleaning.
+
+
+class ZeoMode(RoborockEnum):
+    wash = 1
+    wash_and_dry = 2
+    dry = 3
+
+
+class ZeoState(RoborockEnum):
+    standby = 1
+    weighing = 2
+    soaking = 3
+    washing = 4
+    rinsing = 5
+    spinning = 6
+    drying = 7
+    cooling = 8
+    under_delay_start = 9
+    done = 10
+
+
+class ZeoProgram(RoborockEnum):
+    standard = 1
+    quick = 2
+    sanitize = 3
+    wool = 4
+    air_refresh = 5
+    custom = 6
+    bedding = 7
+    down = 8
+    silk = 9
+    rinse_and_spin = 10
+    spin = 11
+    down_clean = 12
+    baby_care = 13
+    anti_allergen = 14
+    sportswear = 15
+    night = 16
+    new_clothes = 17
+    shirts = 18
+    synthetics = 19
+    underwear = 20
+    gentle = 21
+    intensive = 22
+    cotton_linen = 23
+    season = 24
+    warming = 25
+    bra = 26
+    panties = 27
+    boiling_wash = 28
+    socks = 30
+    towels = 31
+    anti_mite = 32
+    exo_40_60 = 33
+    twenty_c = 34
+    t_shirts = 35
+    stain_removal = 36
+
+
+class ZeoSoak(RoborockEnum):
+    normal = 0
+    low = 1
+    medium = 2
+    high = 3
+    max = 4
+
+
+class ZeoTemperature(RoborockEnum):
+    normal = 1
+    low = 2
+    medium = 3
+    high = 4
+    max = 5
+    twenty_c = 6
+
+
+class ZeoRinse(RoborockEnum):
+    none = 0
+    min = 1
+    low = 2
+    mid = 3
+    high = 4
+    max = 5
+
+
+class ZeoSpin(RoborockEnum):
+    none = 1
+    very_low = 2
+    low = 3
+    mid = 4
+    high = 5
+    very_high = 6
+    max = 7
+
+
+class ZeoDryingMode(RoborockEnum):
+    none = 0
+    quick = 1
+    iron = 2
+    store = 3
+
+
+class ZeoDetergentType(RoborockEnum):
+    empty = 0
+    low = 1
+    medium = 2
+    high = 3
+
+
+class ZeoSoftenerType(RoborockEnum):
+    empty = 0
+    low = 1
+    medium = 2
+    high = 3
+
+
+class ZeoError(RoborockEnum):
+    none = 0
+    refill_error = 1
+    drain_error = 2
+    door_lock_error = 3
+    water_level_error = 4
+    inverter_error = 5
+    heating_error = 6
+    temperature_error = 7
+    communication_error = 10
+    drying_error = 11
+    drying_error_e_12 = 12
+    drying_error_e_13 = 13
+    drying_error_e_14 = 14
+    drying_error_e_15 = 15
+    drying_error_e_16 = 16
+    drying_error_water_flow = 17  # Check for normal water flow
+    drying_error_restart = 18  # Restart the washer and try again
+    spin_error = 19  # re-arrange clothes

{python_roborock-1.0.0 → python_roborock-2.1.0}/roborock/const.py

@@ -43,6 +43,7 @@ ROBOROCK_C1 = "roborock.vacuum.c1"
 ROBOROCK_S8_PRO_ULTRA = "roborock.vacuum.a70"
 ROBOROCK_S8 = "roborock.vacuum.a51"
 ROBOROCK_P10 = "roborock.vacuum.a75"
+ROBOROCK_S8_MAXV_ULTRA = "roborock.vacuum.a97"
 
 ROBOROCK_DYAD_AIR = "roborock.wetdryvac.a107"
 ROBOROCK_DYAD_PRO_COMBO = "roborock.wetdryvac.a83"

{python_roborock-1.0.0 → python_roborock-2.1.0}/roborock/containers.py

@@ -24,14 +24,17 @@ from .code_mappings import (
     RoborockFanSpeedS6Pure,
     RoborockFanSpeedS7,
     RoborockFanSpeedS7MaxV,
+    RoborockFanSpeedS8MaxVUltra,
     RoborockMopIntensityCode,
     RoborockMopIntensityP10,
     RoborockMopIntensityS5Max,
     RoborockMopIntensityS6MaxV,
     RoborockMopIntensityS7,
+    RoborockMopIntensityS8MaxVUltra,
     RoborockMopIntensityV2,
     RoborockMopModeCode,
     RoborockMopModeS7,
+    RoborockMopModeS8MaxVUltra,
     RoborockMopModeS8ProUltra,
     RoborockStateCode,
 )
@@ -52,6 +55,7 @@ from .const import (
     ROBOROCK_S7,
     ROBOROCK_S7_MAXV,
     ROBOROCK_S8,
+    ROBOROCK_S8_MAXV_ULTRA,
     ROBOROCK_S8_PRO_ULTRA,
     SENSOR_DIRTY_REPLACE_TIME,
     SIDE_BRUSH_REPLACE_TIME,
@@ -550,6 +554,13 @@ class P10Status(Status):
     mop_mode: RoborockMopModeS8ProUltra | None = None
 
 
+@dataclass
+class S8MaxvUltraStatus(Status):
+    fan_power: RoborockFanSpeedS8MaxVUltra | None = None
+    water_box_mode: RoborockMopIntensityS8MaxVUltra | None = None
+    mop_mode: RoborockMopModeS8MaxVUltra | None = None
+
+
 ModelStatus: dict[str, type[Status]] = {
     ROBOROCK_S4_MAX: S4MaxStatus,
     ROBOROCK_S5_MAX: S5MaxStatus,
@@ -563,6 +574,7 @@ ModelStatus: dict[str, type[Status]] = {
     ROBOROCK_S8_PRO_ULTRA: S8ProUltraStatus,
     ROBOROCK_G10S_PRO: S7MaxVStatus,
     ROBOROCK_P10: P10Status,
+    ROBOROCK_S8_MAXV_ULTRA: S8MaxvUltraStatus,
 }
 
 

{python_roborock-1.0.0 → python_roborock-2.1.0}/roborock/protocol.py

@@ -36,7 +36,6 @@ from roborock.roborock_message import RoborockMessage
 _LOGGER = logging.getLogger(__name__)
 SALT = b"TXdfu$jyZ#TZHsg4"
 A01_HASH = "726f626f726f636b2d67a6d6da"
-A01_AES_DECIPHER = "ELSYN0wTI4AUm7C4"
 BROADCAST_TOKEN = b"qWKYcdQWrbm9hPqe"
 AP_CONFIG = 1
 SOCK_DISCOVERY = 2
@@ -208,7 +207,7 @@ class EncryptionAdapter(Construct):
         """
         if context.version == b"A01":
             iv = md5hex(format(context.random, "08x") + A01_HASH)[8:24]
-            decipher = AES.new(bytes(A01_AES_DECIPHER, "utf-8"), AES.MODE_CBC, bytes(iv, "utf-8"))
+            decipher = AES.new(bytes(context.search("local_key"), "utf-8"), AES.MODE_CBC, bytes(iv, "utf-8"))
             f = decipher.encrypt(obj)
             return f
         token = self.token_func(context)
@@ -219,7 +218,7 @@ class EncryptionAdapter(Construct):
         """Decrypts the given payload with the token stored in the context."""
         if context.version == b"A01":
             iv = md5hex(format(context.random, "08x") + A01_HASH)[8:24]
-            decipher = AES.new(bytes(A01_AES_DECIPHER, "utf-8"), AES.MODE_CBC, bytes(iv, "utf-8"))
+            decipher = AES.new(bytes(context.search("local_key"), "utf-8"), AES.MODE_CBC, bytes(iv, "utf-8"))
             f = decipher.decrypt(obj)
             return f
         token = self.token_func(context)

{python_roborock-1.0.0 → python_roborock-2.1.0}/roborock/roborock_message.py

@@ -87,6 +87,48 @@ class RoborockDyadDataProtocol(RoborockEnum):
     RPC_RESPONSE = 10102
 
 
+class RoborockZeoProtocol(RoborockEnum):
+    START = 200  # rw
+    PAUSE = 201  # rw
+    SHUTDOWN = 202  # rw
+    STATE = 203  # ro
+    MODE = 204  # rw
+    PROGRAM = 205  # rw
+    CHILD_LOCK = 206  # rw
+    TEMP = 207  # rw
+    RINSE_TIMES = 208  # rw
+    SPIN_LEVEL = 209  # rw
+    DRYING_MODE = 210  # rw
+    DETERGENT_SET = 211  # rw
+    SOFTENER_SET = 212  # rw
+    DETERGENT_TYPE = 213  # rw
+    SOFTENER_TYPE = 214  # rw
+    COUNTDOWN = 217  # rw
+    WASHING_LEFT = 218  # ro
+    DOORLOCK_STATE = 219  # ro
+    ERROR = 220  # ro
+    CUSTOM_PARAM_SAVE = 221  # rw
+    CUSTOM_PARAM_GET = 222  # ro
+    SOUND_SET = 223  # rw
+    TIMES_AFTER_CLEAN = 224  # ro
+    DEFAULT_SETTING = 225  # rw
+    DETERGENT_EMPTY = 226  # ro
+    SOFTENER_EMPTY = 227  # ro
+    LIGHT_SETTING = 229  # rw
+    DETERGENT_VOLUME = 230  # rw
+    SOFTENER_VOLUME = 231  # rw
+    APP_AUTHORIZATION = 232  # rw
+    ID_QUERY = 10000
+    F_C = 10001
+    SND_STATE = 10004
+    PRODUCT_INFO = 10005
+    PRIVACY_INFO = 10006
+    OTA_NFO = 10007
+    WASHING_LOG = 10008
+    RPC_REQ = 10101
+    RPC_RESp = 10102
+
+
 ROBOROCK_DATA_STATUS_PROTOCOL = [
     RoborockDataProtocol.ERROR_CODE,
     RoborockDataProtocol.STATE,

{python_roborock-1.0.0 → python_roborock-2.1.0}/roborock/roborock_typing.py

@@ -35,10 +35,13 @@ class RoborockCommand(str, Enum):
     APP_RC_START = "app_rc_start"
     APP_RC_STOP = "app_rc_stop"
     APP_RESUME_BUILD_MAP = "app_resume_build_map"
+    APP_RESUME_PATROL = "app_resume_patrol"
     APP_SEGMENT_CLEAN = "app_segment_clean"
     APP_SET_AMETHYST_STATUS = "app_set_amethyst_status"
     APP_SET_CARPET_DEEP_CLEAN_STATUS = "app_set_carpet_deep_clean_status"
+    APP_SET_CROSS_CARPET_CLEANING_STATUS = "app_set_cross_carpet_cleaning_status"
     APP_SET_DOOR_SILL_BLOCKS = "app_set_door_sill_blocks"
+    APP_SET_DIRTY_REPLENISH_CLEAN_STATUS = "app_set_dirty_replenish_clean_status"
     APP_SET_DRYER_SETTING = "app_set_dryer_setting"
     APP_SET_DRYER_STATUS = "app_set_dryer_status"
     APP_SET_DYNAMIC_CONFIG = "app_set_dynamic_config"
@@ -50,6 +53,8 @@ class RoborockCommand(str, Enum):
     APP_START_BUILD_MAP = "app_start_build_map"
     APP_START_COLLECT_DUST = "app_start_collect_dust"
     APP_START_EASTER_EGG = "app_start_easter_egg"
+    APP_START_PATROL = "app_start_patrol"
+    APP_START_PET_PATROL = "app_start_pet_patrol"
     APP_START_WASH = "app_start_wash"
     APP_STAT = "app_stat"
     APP_STOP = "app_stop"
@@ -177,6 +182,7 @@ class RoborockCommand(str, Enum):
     SET_CLEAN_FOLLOW_GROUND_MATERIAL_STATUS = "set_clean_follow_ground_material_status"
     SET_CLEAN_MOTOR_MODE = "set_clean_motor_mode"
     SET_CLEAN_SEQUENCE = "set_clean_sequence"
+    SET_CLEAN_REPEAT_TIMES = "set_clean_repeat_times"
     SET_COLLISION_AVOID_STATUS = "set_collision_avoid_status"
     SET_CUSTOM_MODE = "set_custom_mode"
     SET_CUSTOMIZE_CLEAN_MODE = "set_customize_clean_mode"
@@ -239,6 +245,29 @@ class RoborockCommand(str, Enum):
     USE_NEW_MAP = "use_new_map"
     USE_OLD_MAP = "use_old_map"
     USER_UPLOAD_LOG = "user_upload_log"
+    SET_STRETCH_TAG_STATUS = "set_stretch_tag_status"
+    GET_STRETCH_TAG_STATUS = "get_stretch_tag_status"
+    SET_RIGHT_BRUSH_STRETCH_STATUS = "set_right_brush_stretch_status"
+    GET_RIGHT_BRUSH_STRETCH_STATUS = "get_right_brush_stretch_status"
+    SET_DIRTY_OBJECT_DETECT_STATUS = "set_dirty_object_detect_status"
+    GET_DIRTY_OBJECT_DETECT_STATUS = "get_dirty_object_detect_status"
+    SET_WASH_WATER_TEMPERATURE = "set_wash_water_temperature"
+    GET_WASH_WATER_TEMPERATURE = "get_wash_water_temperature"
+    APP_EMPTY_RINSE_TANK_WATER = "app_empty_rinse_tank_water"
+    SET_PET_SUPPLIES_DEEP_CLEAN_STATUS = "set_pet_supplies_deep_clean_status"
+    GET_PET_SUPPLIES_DEEP_CLEAN_STATUS = "get_pet_supplies_deep_clean_status"
+    SET_AP_MIC_LED_STATUS = "set_ap_mic_led_status"
+    GET_AP_MIC_LED_STATUS = "get_ap_mic_led_status"
+    SET_HANDLE_LEAK_WATER_STATUS = "set_handle_leak_water_status"
+    GET_HANDLE_LEAK_WATER_STATUS = "get_handle_leak_water_status"
+    APP_IGNORE_DIRTY_OBJECTS = "app_ignore_dirty_objects"
+    MATTER_GET_STATUS = "matter.get_status"
+    MATTER_DNLD_KEY = "matter.dnld_key"
+    MATTER_RESET = "matter.reset"
+    SET_GAP_DEEP_CLEAN_STATUS = "set_gap_deep_clean_status"
+    GET_GAP_DEEP_CLEAN_STATUS = "get_gap_deep_clean_status"
+    APP_SET_ROBOT_SETTING = "app_set_robot_setting"
+    APP_GET_ROBOT_SETTING = "app_get_robot_setting"
 
 
 @dataclass

python_roborock-2.1.0/roborock/version_a01_apis/roborock_client_a01.py

@@ -0,0 +1,142 @@
+import dataclasses
+import json
+import typing
+from collections.abc import Callable
+from datetime import time
+
+from Crypto.Cipher import AES
+from Crypto.Util.Padding import unpad
+
+from roborock import DeviceData
+from roborock.api import RoborockClient
+from roborock.code_mappings import (
+    DyadBrushSpeed,
+    DyadCleanMode,
+    DyadError,
+    DyadSelfCleanLevel,
+    DyadSelfCleanMode,
+    DyadSuction,
+    DyadWarmLevel,
+    DyadWaterLevel,
+    RoborockDyadStateCode,
+    ZeoDetergentType,
+    ZeoDryingMode,
+    ZeoError,
+    ZeoMode,
+    ZeoProgram,
+    ZeoRinse,
+    ZeoSoftenerType,
+    ZeoSpin,
+    ZeoState,
+    ZeoTemperature,
+)
+from roborock.containers import DyadProductInfo, DyadSndState, RoborockCategory
+from roborock.roborock_message import (
+    RoborockDyadDataProtocol,
+    RoborockMessage,
+    RoborockMessageProtocol,
+    RoborockZeoProtocol,
+)
+
+
+@dataclasses.dataclass
+class A01ProtocolCacheEntry:
+    post_process_fn: Callable
+    value: typing.Any | None = None
+
+
+# Right now this cache is not active, it was too much complexity for the initial addition of dyad.
+protocol_entries = {
+    RoborockDyadDataProtocol.STATUS: A01ProtocolCacheEntry(lambda val: RoborockDyadStateCode(val).name),
+    RoborockDyadDataProtocol.SELF_CLEAN_MODE: A01ProtocolCacheEntry(lambda val: DyadSelfCleanMode(val).name),
+    RoborockDyadDataProtocol.SELF_CLEAN_LEVEL: A01ProtocolCacheEntry(lambda val: DyadSelfCleanLevel(val).name),
+    RoborockDyadDataProtocol.WARM_LEVEL: A01ProtocolCacheEntry(lambda val: DyadWarmLevel(val).name),
+    RoborockDyadDataProtocol.CLEAN_MODE: A01ProtocolCacheEntry(lambda val: DyadCleanMode(val).name),
+    RoborockDyadDataProtocol.SUCTION: A01ProtocolCacheEntry(lambda val: DyadSuction(val).name),
+    RoborockDyadDataProtocol.WATER_LEVEL: A01ProtocolCacheEntry(lambda val: DyadWaterLevel(val).name),
+    RoborockDyadDataProtocol.BRUSH_SPEED: A01ProtocolCacheEntry(lambda val: DyadBrushSpeed(val).name),
+    RoborockDyadDataProtocol.POWER: A01ProtocolCacheEntry(lambda val: int(val)),
+    RoborockDyadDataProtocol.AUTO_DRY: A01ProtocolCacheEntry(lambda val: bool(val)),
+    RoborockDyadDataProtocol.MESH_LEFT: A01ProtocolCacheEntry(lambda val: int(360000 - val * 60)),
+    RoborockDyadDataProtocol.BRUSH_LEFT: A01ProtocolCacheEntry(lambda val: int(360000 - val * 60)),
+    RoborockDyadDataProtocol.ERROR: A01ProtocolCacheEntry(lambda val: DyadError(val).name),
+    RoborockDyadDataProtocol.VOLUME_SET: A01ProtocolCacheEntry(lambda val: int(val)),
+    RoborockDyadDataProtocol.STAND_LOCK_AUTO_RUN: A01ProtocolCacheEntry(lambda val: bool(val)),
+    RoborockDyadDataProtocol.AUTO_DRY_MODE: A01ProtocolCacheEntry(lambda val: bool(val)),
+    RoborockDyadDataProtocol.SILENT_DRY_DURATION: A01ProtocolCacheEntry(lambda val: int(val)),  # in minutes
+    RoborockDyadDataProtocol.SILENT_MODE: A01ProtocolCacheEntry(lambda val: bool(val)),
+    RoborockDyadDataProtocol.SILENT_MODE_START_TIME: A01ProtocolCacheEntry(
+        lambda val: time(hour=int(val / 60), minute=val % 60)
+    ),  # in minutes since 00:00
+    RoborockDyadDataProtocol.SILENT_MODE_END_TIME: A01ProtocolCacheEntry(
+        lambda val: time(hour=int(val / 60), minute=val % 60)
+    ),  # in minutes since 00:00
+    RoborockDyadDataProtocol.RECENT_RUN_TIME: A01ProtocolCacheEntry(
+        lambda val: [int(v) for v in val.split(",")]
+    ),  # minutes of cleaning in past few days.
+    RoborockDyadDataProtocol.TOTAL_RUN_TIME: A01ProtocolCacheEntry(lambda val: int(val)),
+    RoborockDyadDataProtocol.SND_STATE: A01ProtocolCacheEntry(lambda val: DyadSndState.from_dict(val)),
+    RoborockDyadDataProtocol.PRODUCT_INFO: A01ProtocolCacheEntry(lambda val: DyadProductInfo.from_dict(val)),
+}
+
+zeo_data_protocol_entries = {
+    # ro
+    RoborockZeoProtocol.STATE: A01ProtocolCacheEntry(lambda val: ZeoState(val).name),
+    RoborockZeoProtocol.COUNTDOWN: A01ProtocolCacheEntry(lambda val: int(val)),
+    RoborockZeoProtocol.WASHING_LEFT: A01ProtocolCacheEntry(lambda val: int(val)),
+    RoborockZeoProtocol.ERROR: A01ProtocolCacheEntry(lambda val: ZeoError(val).name),
+    RoborockZeoProtocol.TIMES_AFTER_CLEAN: A01ProtocolCacheEntry(lambda val: int(val)),
+    RoborockZeoProtocol.DETERGENT_EMPTY: A01ProtocolCacheEntry(lambda val: bool(val)),
+    RoborockZeoProtocol.SOFTENER_EMPTY: A01ProtocolCacheEntry(lambda val: bool(val)),
+    # rw
+    RoborockZeoProtocol.MODE: A01ProtocolCacheEntry(lambda val: ZeoMode(val).name),
+    RoborockZeoProtocol.PROGRAM: A01ProtocolCacheEntry(lambda val: ZeoProgram(val).name),
+    RoborockZeoProtocol.TEMP: A01ProtocolCacheEntry(lambda val: ZeoTemperature(val).name),
+    RoborockZeoProtocol.RINSE_TIMES: A01ProtocolCacheEntry(lambda val: ZeoRinse(val).name),
+    RoborockZeoProtocol.SPIN_LEVEL: A01ProtocolCacheEntry(lambda val: ZeoSpin(val).name),
+    RoborockZeoProtocol.DRYING_MODE: A01ProtocolCacheEntry(lambda val: ZeoDryingMode(val).name),
+    RoborockZeoProtocol.DETERGENT_TYPE: A01ProtocolCacheEntry(lambda val: ZeoDetergentType(val).name),
+    RoborockZeoProtocol.SOFTENER_TYPE: A01ProtocolCacheEntry(lambda val: ZeoSoftenerType(val).name),
+    RoborockZeoProtocol.SOUND_SET: A01ProtocolCacheEntry(lambda val: bool(val)),
+}
+
+
+class RoborockClientA01(RoborockClient):
+    def __init__(self, endpoint: str, device_info: DeviceData, category: RoborockCategory, queue_timeout: int = 4):
+        super().__init__(endpoint, device_info, queue_timeout)
+        self.category = category
+
+    def on_message_received(self, messages: list[RoborockMessage]) -> None:
+        for message in messages:
+            protocol = message.protocol
+            if message.payload and protocol in [
+                RoborockMessageProtocol.RPC_RESPONSE,
+                RoborockMessageProtocol.GENERAL_REQUEST,
+            ]:
+                payload = message.payload
+                try:
+                    payload = unpad(payload, AES.block_size)
+                except Exception:
+                    continue
+                payload_json = json.loads(payload.decode())
+                for data_point_number, data_point in payload_json.get("dps").items():
+                    data_point_protocol: RoborockDyadDataProtocol | RoborockZeoProtocol
+                    entries: dict
+                    if self.category == RoborockCategory.WET_DRY_VAC:
+                        data_point_protocol = RoborockDyadDataProtocol(int(data_point_number))
+                        entries = protocol_entries
+                    elif self.category == RoborockCategory.WASHING_MACHINE:
+                        data_point_protocol = RoborockZeoProtocol(int(data_point_number))
+                        entries = zeo_data_protocol_entries
+                    else:
+                        continue
+                    if data_point_protocol in entries:
+                        # Auto convert into data struct we want.
+                        converted_response = entries[data_point_protocol].post_process_fn(data_point)
+                        queue = self._waiting_queue.get(int(data_point_number))
+                        if queue and queue.protocol == protocol:
+                            queue.resolve((converted_response, None))
+
+    async def update_values(self, dyad_data_protocols: list[RoborockDyadDataProtocol | RoborockZeoProtocol]):
+        """This should handle updating for each given protocol."""
+        raise NotImplementedError

{python_roborock-1.0.0 → python_roborock-2.1.0}/roborock/version_a01_apis/roborock_mqtt_client_a01.py

@@ -1,28 +1,36 @@
 import asyncio
 import base64
 import json
+import typing
 
 from Crypto.Cipher import AES
 from Crypto.Util.Padding import pad, unpad
 
 from roborock.cloud_api import RoborockMqttClient
-from roborock.containers import DeviceData, UserData
+from roborock.containers import DeviceData, RoborockCategory, UserData
 from roborock.exceptions import RoborockException
 from roborock.protocol import MessageParser, Utils
-from roborock.roborock_message import RoborockDyadDataProtocol, RoborockMessage, RoborockMessageProtocol
+from roborock.roborock_message import (
+    RoborockDyadDataProtocol,
+    RoborockMessage,
+    RoborockMessageProtocol,
+    RoborockZeoProtocol,
+)
 
 from .roborock_client_a01 import RoborockClientA01
 
 
 class RoborockMqttClientA01(RoborockMqttClient, RoborockClientA01):
-    def __init__(self, user_data: UserData, device_info: DeviceData, queue_timeout: int = 10) -> None:
+    def __init__(
+        self, user_data: UserData, device_info: DeviceData, category: RoborockCategory, 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)
-        RoborockClientA01.__init__(self, endpoint, device_info)
+        RoborockClientA01.__init__(self, endpoint, device_info, category, queue_timeout)
 
     async def send_message(self, roborock_message: RoborockMessage):
         await self.validate_connection()
@@ -37,14 +45,19 @@ class RoborockMqttClientA01(RoborockMqttClient, RoborockClientA01):
             for dps in json.loads(payload["dps"]["10000"]):
                 futures.append(asyncio.ensure_future(self._async_response(dps, response_protocol)))
         self._send_msg_raw(m)
-        responses = await asyncio.gather(*futures)
-        dps_responses = {}
+        responses = await asyncio.gather(*futures, return_exceptions=True)
+        dps_responses: dict[int, typing.Any] = {}
         if "10000" in payload["dps"]:
             for i, dps in enumerate(json.loads(payload["dps"]["10000"])):
-                dps_responses[dps] = responses[i][0]
+                response = responses[i]
+                if isinstance(response, BaseException):
+                    self._logger.warning("Timed out get req for %s after %s s", dps, self.queue_timeout)
+                    dps_responses[dps] = None
+                else:
+                    dps_responses[dps] = response[0]
         return dps_responses
 
-    async def update_values(self, dyad_data_protocols: list[RoborockDyadDataProtocol]):
+    async def update_values(self, dyad_data_protocols: list[RoborockDyadDataProtocol | RoborockZeoProtocol]):
         payload = {"dps": {RoborockDyadDataProtocol.ID_QUERY: str([int(protocol) for protocol in dyad_data_protocols])}}
         return await self.send_message(
             RoborockMessage(

python_roborock-1.0.0/roborock/version_a01_apis/roborock_client_a01.py

@@ -1,100 +0,0 @@
-import dataclasses
-import json
-import typing
-from collections.abc import Callable
-from datetime import time
-
-from Crypto.Cipher import AES
-from Crypto.Util.Padding import unpad
-
-from roborock import DeviceData
-from roborock.api import RoborockClient
-from roborock.code_mappings import (
-    DyadBrushSpeed,
-    DyadCleanMode,
-    DyadError,
-    DyadSelfCleanLevel,
-    DyadSelfCleanMode,
-    DyadSuction,
-    DyadWarmLevel,
-    DyadWaterLevel,
-    RoborockDyadStateCode,
-)
-from roborock.containers import DyadProductInfo, DyadSndState
-from roborock.roborock_message import (
-    RoborockDyadDataProtocol,
-    RoborockMessage,
-    RoborockMessageProtocol,
-)
-
-
-@dataclasses.dataclass
-class DyadProtocolCacheEntry:
-    post_process_fn: Callable
-    value: typing.Any | None = None
-
-
-# Right now this cache is not active, it was too much complexity for the initial addition of dyad.
-protocol_entries = {
-    RoborockDyadDataProtocol.STATUS: DyadProtocolCacheEntry(lambda val: RoborockDyadStateCode(val).name),
-    RoborockDyadDataProtocol.SELF_CLEAN_MODE: DyadProtocolCacheEntry(lambda val: DyadSelfCleanMode(val).name),
-    RoborockDyadDataProtocol.SELF_CLEAN_LEVEL: DyadProtocolCacheEntry(lambda val: DyadSelfCleanLevel(val).name),
-    RoborockDyadDataProtocol.WARM_LEVEL: DyadProtocolCacheEntry(lambda val: DyadWarmLevel(val).name),
-    RoborockDyadDataProtocol.CLEAN_MODE: DyadProtocolCacheEntry(lambda val: DyadCleanMode(val).name),
-    RoborockDyadDataProtocol.SUCTION: DyadProtocolCacheEntry(lambda val: DyadSuction(val).name),
-    RoborockDyadDataProtocol.WATER_LEVEL: DyadProtocolCacheEntry(lambda val: DyadWaterLevel(val).name),
-    RoborockDyadDataProtocol.BRUSH_SPEED: DyadProtocolCacheEntry(lambda val: DyadBrushSpeed(val).name),
-    RoborockDyadDataProtocol.POWER: DyadProtocolCacheEntry(lambda val: int(val)),
-    RoborockDyadDataProtocol.AUTO_DRY: DyadProtocolCacheEntry(lambda val: bool(val)),
-    RoborockDyadDataProtocol.MESH_LEFT: DyadProtocolCacheEntry(lambda val: int(360000 - val * 60)),
-    RoborockDyadDataProtocol.BRUSH_LEFT: DyadProtocolCacheEntry(lambda val: int(360000 - val * 60)),
-    RoborockDyadDataProtocol.ERROR: DyadProtocolCacheEntry(lambda val: DyadError(val).name),
-    RoborockDyadDataProtocol.VOLUME_SET: DyadProtocolCacheEntry(lambda val: int(val)),
-    RoborockDyadDataProtocol.STAND_LOCK_AUTO_RUN: DyadProtocolCacheEntry(lambda val: bool(val)),
-    RoborockDyadDataProtocol.AUTO_DRY_MODE: DyadProtocolCacheEntry(lambda val: bool(val)),
-    RoborockDyadDataProtocol.SILENT_DRY_DURATION: DyadProtocolCacheEntry(lambda val: int(val)),  # in minutes
-    RoborockDyadDataProtocol.SILENT_MODE: DyadProtocolCacheEntry(lambda val: bool(val)),
-    RoborockDyadDataProtocol.SILENT_MODE_START_TIME: DyadProtocolCacheEntry(
-        lambda val: time(hour=int(val / 60), minute=val % 60)
-    ),  # in minutes since 00:00
-    RoborockDyadDataProtocol.SILENT_MODE_END_TIME: DyadProtocolCacheEntry(
-        lambda val: time(hour=int(val / 60), minute=val % 60)
-    ),  # in minutes since 00:00
-    RoborockDyadDataProtocol.RECENT_RUN_TIME: DyadProtocolCacheEntry(
-        lambda val: [int(v) for v in val.split(",")]
-    ),  # minutes of cleaning in past few days.
-    RoborockDyadDataProtocol.TOTAL_RUN_TIME: DyadProtocolCacheEntry(lambda val: int(val)),
-    RoborockDyadDataProtocol.SND_STATE: DyadProtocolCacheEntry(lambda val: DyadSndState.from_dict(val)),
-    RoborockDyadDataProtocol.PRODUCT_INFO: DyadProtocolCacheEntry(lambda val: DyadProductInfo.from_dict(val)),
-}
-
-
-class RoborockClientA01(RoborockClient):
-    def __init__(self, endpoint: str, device_info: DeviceData):
-        super().__init__(endpoint, device_info)
-
-    def on_message_received(self, messages: list[RoborockMessage]) -> None:
-        for message in messages:
-            protocol = message.protocol
-            if message.payload and protocol in [
-                RoborockMessageProtocol.RPC_RESPONSE,
-                RoborockMessageProtocol.GENERAL_REQUEST,
-            ]:
-                payload = message.payload
-                try:
-                    payload = unpad(payload, AES.block_size)
-                except Exception:
-                    continue
-                payload_json = json.loads(payload.decode())
-                for data_point_number, data_point in payload_json.get("dps").items():
-                    data_point_protocol = RoborockDyadDataProtocol(int(data_point_number))
-                    if data_point_protocol in protocol_entries:
-                        # Auto convert into data struct we want.
-                        converted_response = protocol_entries[data_point_protocol].post_process_fn(data_point)
-                        queue = self._waiting_queue.get(int(data_point_number))
-                        if queue and queue.protocol == protocol:
-                            queue.resolve((converted_response, None))
-
-    async def update_values(self, dyad_data_protocols: list[RoborockDyadDataProtocol]):
-        """This should handle updating for each given protocol."""
-        raise NotImplementedError