python-roborock 5.24.0__py3-none-any.whl → 5.26.0__py3-none-any.whl

{python_roborock-5.24.0.dist-info → python_roborock-5.26.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-roborock
-Version: 5.24.0
+Version: 5.26.0
 Summary: A package to control Roborock vacuums.
 Project-URL: Repository, https://github.com/python-roborock/python-roborock
 Project-URL: Documentation, https://python-roborock.readthedocs.io/

{python_roborock-5.24.0.dist-info → python_roborock-5.26.0.dist-info}/RECORD

@@ -8,24 +8,26 @@ roborock/diagnostics.py,sha256=YIc7BhC6Cy6W2a6hykvfSRPG8NpLrPZCc_7jTX2Zdho,5091
 roborock/exceptions.py,sha256=t2YvfSRMymZPtdPV238itjxVJTaTq5-uBL_EM5FTlfg,3159
 roborock/protocol.py,sha256=eNUL6UGmtSdfsGM1mlYjmorukGGudV45iKXUA7a-Qa8,20193
 roborock/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-roborock/roborock_message.py,sha256=BPDT_uzCeD4L_4LottCMeft1kYmYPoG9ktcqqj0SYhQ,6466
+roborock/roborock_message.py,sha256=e7gDnBhv2RkG3G2eXmoNVnt5aUWWlLEA3i5LTIBFBy8,7349
 roborock/roborock_typing.py,sha256=Rwx0c0oZCMY-4O8VMLnFSO_OUNb_D59cyG_ktZTZoZI,17134
 roborock/util.py,sha256=mjw329ujLjoWPPAr9mG0VZstaVL06dmVvNnYACB-Pxk,1650
 roborock/web_api.py,sha256=M_A4PiRK5cwkoT3oS8fvglOU97s1jpWKuuCxeeCiF_E,37507
-roborock/data/__init__.py,sha256=DikqaVM7VPVddkBNkHSss5zb1_iKB7GYmc2GiHoMAkA,257
+roborock/data/__init__.py,sha256=jSZHOrd-LfVN-TdBkjNW334ef99rGBz4-hPT_7KvoLs,278
 roborock/data/code_mappings.py,sha256=Cj1nEQkv3Vko7Mh8FODNtfIS5gn5KlTq2QXFtcincHo,8948
 roborock/data/containers.py,sha256=-b6H2snGQTzsJSsctgil6sx8rLtCDihTTzdkxcFRdlE,16489
 roborock/data/b01_q10/__init__.py,sha256=E4lwJcz4AI1z92FcYOJ-cY3fcfHSoXqvYVgfA-TgaRk,71
-roborock/data/b01_q10/b01_q10_code_mappings.py,sha256=aIKSHYSWD3DNjifpRB8aywwxYWNP4d6n6N0weI7SbsU,11218
-roborock/data/b01_q10/b01_q10_containers.py,sha256=RhujRDmojBeHEVUZgt4xzFLD3QfPXN2PPKhA7J6pbXE,10937
+roborock/data/b01_q10/b01_q10_code_mappings.py,sha256=UBFkxCWLYCGQatENmNwR0owkXrcB8AosnD-hICfS2AY,15203
+roborock/data/b01_q10/b01_q10_containers.py,sha256=jieHxHeWIRm2NHVdv15J6kYSeHjAZunGrvZsob-RIH8,11130
 roborock/data/b01_q7/__init__.py,sha256=D-Cd8eB0njf1PQPM6Exl_9A0AhpzIjrL0hapGOCEkkA,69
 roborock/data/b01_q7/b01_q7_code_mappings.py,sha256=EHSCZSv_Os049NcenKo4tkPjDOB4vpmQ2p2Psr9FRCc,10698
 roborock/data/b01_q7/b01_q7_containers.py,sha256=jNEHoNEdq276XJZGGUmtSyJ81cSIzJwem-O_NOgmfdQ,10270
 roborock/data/dyad/__init__.py,sha256=Ksx7Ri1alsAYAyILOpj9iNbCC_6sF7xvETFRnTO4rdM,65
 roborock/data/dyad/dyad_code_mappings.py,sha256=MVhAuQaI2TcDBMQKQcbRk4MbFObx_5XEXTc3n4uAeWc,2836
 roborock/data/dyad/dyad_containers.py,sha256=klJD2wV-2McjAoSN8Bthuyeid59L7M8nzSvc3MtmqOI,434
+roborock/data/mower/__init__.py,sha256=v-bMapgWFzlb0jJVJBmsnmDfgnER7oTjP0OH3ikwGdE,79
+roborock/data/mower/mower_containers.py,sha256=mCsRFTE2AZ2wC9wzrzsr-3z7T2M63CH5ax9kPqPygIY,3194
 roborock/data/v1/__init__.py,sha256=Lx_D6baZrCMxp57D0NcdiA8rssJ5NnInZwUwrT79XOI,91
-roborock/data/v1/v1_clean_modes.py,sha256=pJBwykCToEKZv9zs11x45Jjq3giUKfp0zibAjQ_LuOQ,7194
+roborock/data/v1/v1_clean_modes.py,sha256=71_olE6rsdx_UwxkBEPlcHTz0vnyKSnURGxIwuqhOwM,14056
 roborock/data/v1/v1_code_mappings.py,sha256=EgkR3mexyNnPoHZSZHgxA0-ClLDCOFtPIlyEUrWfDIE,17448
 roborock/data/v1/v1_containers.py,sha256=SW7NhY5zbu9j7gG9qEUwpfzMpRn_4RQHOtgnbeMRX5Y,27936
 roborock/data/zeo/__init__.py,sha256=VxG5qG4M24DGOq2YAaxownWp6bEfj9DEOgOMHmTpcqY,63
@@ -35,23 +37,23 @@ roborock/devices/README.md,sha256=zjssyRIlFWTgQz8hLdsJC9_stlHdUQybz7r2af_8q1k,21
 roborock/devices/__init__.py,sha256=yOWuncnp5wwKPLzcnblsBMGD0v8hcDDDC_x7YdSrN70,129
 roborock/devices/cache.py,sha256=V3KC16LzTEAp_cdAirNtWPjZAgz6ugn3zfsYPyrbWsE,4633
 roborock/devices/device.py,sha256=8lHdjLlHhrENPjrZxllpYU0CEh7Os9rp9spnwhdUOoc,9678
-roborock/devices/device_manager.py,sha256=u9Z4INuTxOILJnLFx-rcHKH1Z4C2AH-z2wEe9usLnjM,11190
+roborock/devices/device_manager.py,sha256=NRQK9przB_FYFsljf7fz9_fL1NJCQSGzcvXchP-kplc,11731
 roborock/devices/file_cache.py,sha256=-G2Bm4ra8K_DvSBjntv5hGaRDB-VzSoKWcI0Y_kK6jw,2724
 roborock/devices/rpc/__init__.py,sha256=MDtZovvHi3F4Wbgyzu6gyjAjkZ6xYGU1LRQmtiIapuU,561
 roborock/devices/rpc/a01_channel.py,sha256=9Cf3AlTTAHbts7sodX4gAXAGOIf5CA6WtqykZcYAfnk,3350
-roborock/devices/rpc/b01_q10_channel.py,sha256=stXKvkN3t0m0Reosu54CbVDuMwhrZIOc-pL4ZJ7IAxk,1929
-roborock/devices/rpc/b01_q7_channel.py,sha256=Dz6WnAKTzXS21auv17CDHmJrkLWzHoXE1uAgAXcQsVo,6163
+roborock/devices/rpc/b01_q10_channel.py,sha256=nT7fsTtti37alm68CHzId8Wy3GMd6npiSNB8Gjegy3I,3494
+roborock/devices/rpc/b01_q7_channel.py,sha256=cxJR_DjJobP6SsAch_O3tNcJdiQGMIwpxH8Wx8bb9xA,7689
 roborock/devices/rpc/v1_channel.py,sha256=aYlBZ0zC7jbwJhhHvKzBfHUZLAf7KOmIPOJQiiLKwvE,22275
 roborock/devices/traits/__init__.py,sha256=YaL9qoxG6IBG0XXDP0HMTvoc0Jkmq7AF6iH2oYWNtcg,765
 roborock/devices/traits/common.py,sha256=KUlXvx2UcFVeNXEhPiCAdy2APu7zrJmM_jME_bM8Odg,4474
 roborock/devices/traits/traits_mixin.py,sha256=7t15l_Ty1cN-3-fKNtRH1XR6-mfadPnTBCQRZP4rAtc,2092
 roborock/devices/traits/a01/__init__.py,sha256=i-us9zLPWPfSQ5XWq8t0MiYLYe5NkcLvk3aEQTYT7E0,8104
 roborock/devices/traits/b01/__init__.py,sha256=pGN6wEocE6Fr2BTasG8Z_75crD6OdTwpju59Vw7eTDk,202
-roborock/devices/traits/b01/q10/__init__.py,sha256=0-vLn_ltHyE2aABuCpgmW8Yr87RI7wHoi1m4e90befE,6086
+roborock/devices/traits/b01/q10/__init__.py,sha256=wvXErH_V6L6bW-EYQFw1PfC8LouKpwItVSsTx2TYMJ4,6010
 roborock/devices/traits/b01/q10/button_light.py,sha256=_CCWSjFe_iZnnSXgBHOju31VUmwG1KKd_jGkmSpLew4,994
 roborock/devices/traits/b01/q10/child_lock.py,sha256=bTsbAMxn7AF1zpWteyZCkQm4jj3NiWD8ddZTM3tlG_0,1131
 roborock/devices/traits/b01/q10/clean_history.py,sha256=OsuzliXtWl2RDMAdKElCaebp9Pr2czVOex180k4jzVs,6672
-roborock/devices/traits/b01/q10/command.py,sha256=mcWNRSq72bfa79_EjKRgMEIDTV3vWFh2ofBe4aF7EOE,1306
+roborock/devices/traits/b01/q10/command.py,sha256=M0sZu1eIvKYfsOpmJc-H4LKsSrF-kTp_vc_jCRBAvaY,1264
 roborock/devices/traits/b01/q10/common.py,sha256=Qxl3zBAUulqdrjFZJ0DPEFEIJLvlPqUKuTQGPloy7Ds,3089
 roborock/devices/traits/b01/q10/consumable.py,sha256=MbtMgYKqzNdVn6M1iyOAqZPCYTbN_Q_Pr4h8EYGEiuY,669
 roborock/devices/traits/b01/q10/do_not_disturb.py,sha256=klyGQZ_nHyO6bhPlwBl8vElTnMwPf4A8VXwxkU8rMlM,1157
@@ -62,10 +64,10 @@ roborock/devices/traits/b01/q10/remote.py,sha256=8-fg4SA5M-tdMufHPeD9hIcax7y9Qh7
 roborock/devices/traits/b01/q10/status.py,sha256=JAPixbsQ8jfN3OvI7o_NxISXFk8l7rGHFYcL4pH97Jk,859
 roborock/devices/traits/b01/q10/vacuum.py,sha256=w2FftNH5n-Tb-9drR3-5OiMy85FJfTDNmtt34LklC8w,4374
 roborock/devices/traits/b01/q10/volume.py,sha256=UnT0yYDQntxYwnpv4_NVychm0FnGAYRAWA_FJR4yJag,1001
-roborock/devices/traits/b01/q7/__init__.py,sha256=gHgIK-KBLDJDEneBmSJfTa38sumj1IuZl-lcvoZeYLY,8116
-roborock/devices/traits/b01/q7/clean_summary.py,sha256=Tod29LUHBsOS0XL8SU1SdBQEHWTCifGZVCwSWGhYpy8,2933
-roborock/devices/traits/b01/q7/map.py,sha256=Zrvj8LNctIFksCBoiZVQ1x4hgG3wwp1jqPY-If__JXw,1489
-roborock/devices/traits/b01/q7/map_content.py,sha256=rI21-kMmIgf1TY98HXrWG_4rEEs9qzdYBm7RTU47yN4,3519
+roborock/devices/traits/b01/q7/__init__.py,sha256=y3NV-DYHyQoPcpWnmGppX5Y1GjF9MylVxyoIVldKFCA,7935
+roborock/devices/traits/b01/q7/clean_summary.py,sha256=M43iJVeYjrkBV6ZxXdHtn4Rd5Mx-KAK7WLU5fABiN8I,2742
+roborock/devices/traits/b01/q7/map.py,sha256=NfPQAEwNCUsb0SYGMxmGeq4q4rEHqDJK0zTD5cE-ESs,1299
+roborock/devices/traits/b01/q7/map_content.py,sha256=5l7WJSDEfUzXkwXYcvTWhuNz3mlXvA_u2o5Pnh6f5kE,3372
 roborock/devices/traits/v1/__init__.py,sha256=yUa3oN5CZtuVh-fst8FlstpCy1XnS3q42oPlQG9fFYw,15616
 roborock/devices/traits/v1/child_lock.py,sha256=NeaPqcEoBRXvEzKZGonkyINkwCBOK3xa4zSWvJW66kA,1161
 roborock/devices/traits/v1/clean_summary.py,sha256=2uDl3Tg6H9INf7HTEPPat_PBgodoWeX_ko5MJgWggn8,4625
@@ -84,7 +86,7 @@ roborock/devices/traits/v1/network_info.py,sha256=CX9-ye2Zb_8lAWPGvegXWSOguxMY2K
 roborock/devices/traits/v1/rooms.py,sha256=PKNEvzL_Pk5pxGpiMC-XgGpgWVRjivMw_yv7vpGlz3s,6221
 roborock/devices/traits/v1/routines.py,sha256=BfktlpnyDjD2DB3zBDS5BnmjZPE38aHa-wjMontPnik,931
 roborock/devices/traits/v1/smart_wash_params.py,sha256=fAhJpMgUUP1kJcfEAAPeD3anMmCsuX7I1SEoUrUgfjE,504
-roborock/devices/traits/v1/status.py,sha256=g71kUSZ5XKMSF9mEH2QGr-d9L9ecyUGB1M-LKiKz-js,3915
+roborock/devices/traits/v1/status.py,sha256=Y5VBJPZQhmlGDPQvPIp8mFCFsUf4hheZ5k_nnxOoXHI,5071
 roborock/devices/traits/v1/valley_electricity_timer.py,sha256=vE9bLJe8TdFGVh_9mDRkEoC3_DTBkDcdlSMSiYq0YTw,1863
 roborock/devices/traits/v1/volume.py,sha256=etRIYE0ynZZLEo2ez7Dm7_JbijmElrdjpn59hyLWqsQ,814
 roborock/devices/traits/v1/wash_towel_mode.py,sha256=MpVIGYVBC-WNSSFy6PPN-1eeIgJm_XoEzMSTEp9R29g,1913
@@ -110,8 +112,8 @@ roborock/protocols/a01_protocol.py,sha256=JCIhUuVNamcENu0gtZR2x8rBz6dpAZLcbA-NQg
 roborock/protocols/b01_q10_protocol.py,sha256=Ac3_VHJ2DAwBiXFMPYOHExEV0prxS9Ju0djiC8nKtiI,4935
 roborock/protocols/b01_q7_protocol.py,sha256=o8repRrxhxknzspsg1K27ds643rs87ilWXbj8RJtOCs,4619
 roborock/protocols/v1_protocol.py,sha256=uA-EMXd1AUBAXjkjAm0VxZlPLre0v2X9Kei5UqyPzaY,11141
-python_roborock-5.24.0.dist-info/METADATA,sha256=nYXBxUJ0Sf16pHOh1T0wbZrPD39O6U-gJi4YVJtR-M4,5281
-python_roborock-5.24.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-python_roborock-5.24.0.dist-info/entry_points.txt,sha256=EvC1nMqi9ZXKgZnqlNXA33v_3nzgPNjnM0mzWlrehnY,47
-python_roborock-5.24.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-python_roborock-5.24.0.dist-info/RECORD,,
+python_roborock-5.26.0.dist-info/METADATA,sha256=S6gc78zARVWGikbdJL_rBkkWOMFx-q5COvsyzCSjblc,5281
+python_roborock-5.26.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+python_roborock-5.26.0.dist-info/entry_points.txt,sha256=EvC1nMqi9ZXKgZnqlNXA33v_3nzgPNjnM0mzWlrehnY,47
+python_roborock-5.26.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+python_roborock-5.26.0.dist-info/RECORD,,

roborock/data/__init__.py

@@ -5,5 +5,6 @@ from .b01_q10 import *
 from .code_mappings import *
 from .containers import *
 from .dyad import *
+from .mower import *
 from .v1 import *
 from .zeo import *

roborock/data/b01_q10/b01_q10_code_mappings.py

@@ -289,6 +289,70 @@ class YXCarpetCleanType(RoborockModeEnum):
     CROSS = "cross", 3
 
 
+class YXFault(RoborockModeEnum):
+    """Q10 (B01/ss07) ``dpFault`` (90) codes, from the ss07 fault spec.
+
+    ``dpFault`` is *overloaded*: several values are lifecycle/status rather than
+    errors (e.g. 400 = scheduled clean starting, 501 = returning to dock,
+    502 = recharge). A non-zero fault is not necessarily a blocking error.
+    The converse also holds: the device can sit in its error state (``dpStatus``
+    12) with ``dpFault`` still 0 (observed live with the dust-bin module
+    removed), so a ``None``/``NONE`` fault does not imply the absence of an
+    error condition.
+
+    These labels differ from the Q7 ``B01Fault`` for several shared numbers
+    (500, 501, 503, 569, 570) -- so this is a Q10-specific map, not a reuse of
+    ``B01Fault``. Codes marked "hw-confirmed" were observed firing live on a
+    physical ss07 in a context matching the label; the rest are from the spec
+    only, not yet observed live (single device).
+    """
+
+    UNKNOWN = "unknown", -1
+    NONE = "none", 0
+    LIDAR_BLOCKED = "lidar_blocked", 1
+    BUMPER_STUCK = "bumper_stuck", 2  # hw-confirmed (bumper held in during commanded motion)
+    ROBOT_SUSPENDED = "robot_suspended", 3  # hw-confirmed (wheels lifted off the floor mid-task)
+    CLIFF_SENSOR_ERROR = "cliff_sensor_error", 4  # hw-confirmed (one side lifted mid-task)
+    MAIN_BRUSH_STUCK = "main_brush_stuck", 5  # hw-confirmed (two physical brush jams)
+    MAIN_WHEELS_STUCK = "main_wheels_stuck", 7
+    ROBOT_TRAPPED = "robot_trapped", 8  # hw-confirmed
+    CHECK_DUSTBIN_FILTER = "check_dustbin_filter", 9
+    LOW_BATTERY = "low_battery", 12  # hw-confirmed (fired at 14% mid clean)
+    TEMPERATURE_THRESHOLD = "temperature_threshold", 14
+    ROBOT_TILTED = "robot_tilted", 16
+    LIDAR_COVER_OBSTRUCTED = "lidar_cover_obstructed", 21
+    NO_GO_ZONE_DETECTED = "no_go_zone_detected", 24
+    MOPPING_MODULE_STUCK = "mopping_module_stuck", 27
+    CARPET_AVOIDANCE = "carpet_avoidance", 28
+    CANNOT_CROSS_CARPET = "cannot_cross_carpet", 29
+    INSTALL_DUST_BAG = "install_dust_bag", 46  # hw-confirmed (docked with bag removed; fires at dock contact)
+    MOP_MOUNT_FELL_OFF = "mop_mount_fell_off", 54
+    LIDAR_DIRTY = "lidar_dirty", 58
+    FILTER_SERVICE_LIFE = "filter_service_life", 301
+    MAIN_BRUSH_SERVICE_LIFE = "main_brush_service_life", 302
+    SIDE_BRUSH_SERVICE_LIFE = "side_brush_service_life", 303
+    SENSOR_NEEDS_CLEANING = "sensor_needs_cleaning", 304  # hw-confirmed (fired during auto-empty)
+    DUST_BAG_FULL = "dust_bag_full", 310  # inferred from auto-empty context; not hw-confirmed
+    STARTING_SCHEDULED_CLEAN = "starting_scheduled_clean", 400  # hw-confirmed x3; lifecycle, not an error
+    # hw-confirmed (a due scheduled clean fired mid-clean and was ignored); lifecycle, not an error
+    CLEANING_IN_PROGRESS = "cleaning_in_progress", 407
+    EMPTY_DUSTBIN = "empty_dustbin", 500  # ss07 != Q7 B01Fault (lidar_blocked); spec-only
+    # hw-confirmed, fires per completed task; ss07 != Q7 (robot_suspended)
+    CLEANING_COMPLETED_RETURNING = "cleaning_completed_returning", 501
+    LOW_BATTERY_RESUME = "low_battery_resume", 502  # hw-confirmed; lifecycle
+    DOCKING_ERROR = "docking_error", 503  # hw-confirmed; ss07 != Q7 (dustbin_not_installed)
+    POSITIONING_FAILED = "positioning_failed", 556  # hw-confirmed; relocalization
+    # hw-confirmed (3rd auto-empty in ~15 min: dock refuses to run the cycle); ss07 != Q7 (main_wheels_entangled)
+    TOO_FREQUENT_EMPTYING = "too_frequent_emptying", 569
+    CANNOT_REACH_TARGET = "cannot_reach_target", 570  # hw-confirmed; ss07 != Q7 (main_brush_entangled)
+    OFFLINE_WARNING_ASLEEP = "offline_warning_asleep", 588
+    OFFLINE_WARNING_LOW_BATTERY = "offline_warning_low_battery", 589
+    DND_AUTO_TOPUP_DISABLED = "dnd_auto_topup_disabled", 591
+    CLEAN_CARPET_ULTRASONIC_SENSORS = "clean_carpet_ultrasonic_sensors", 707
+    ROBOT_ERROR_RESET = "robot_error_reset", 1002
+    VOICE_PACK_UPDATE_AVAILABLE = "voice_pack_update_available", 3001
+
+
 class RemoteCommand(IntEnum):
     FORWARD = 0
     LEFT = 2

roborock/data/b01_q10/b01_q10_containers.py

@@ -23,6 +23,7 @@ from .b01_q10_code_mappings import (
     YXDeviceDustCollectionFrequency,
     YXDeviceState,
     YXFanLevel,
+    YXFault,
     YXStartMethod,
     YXWaterLevel,
 )
@@ -165,7 +166,7 @@ class Q10Status(RoborockBase):
     clean_task_type: YXDeviceCleanTask | None = field(default=None, metadata={"dps": B01_Q10_DP.CLEAN_TASK_TYPE})
     back_type: YXBackType | None = field(default=None, metadata={"dps": B01_Q10_DP.BACK_TYPE})
     cleaning_progress: int | None = field(default=None, metadata={"dps": B01_Q10_DP.CLEAN_PROGRESS})
-    fault: int | None = field(default=None, metadata={"dps": B01_Q10_DP.FAULT})
+    fault: YXFault | None = field(default=None, metadata={"dps": B01_Q10_DP.FAULT})
 
     # Additional state reported in the device's full status dump.
     clean_line: YXCleanLine | None = field(default=None, metadata={"dps": B01_Q10_DP.CLEAN_LINE})
@@ -203,6 +204,11 @@ class Q10Status(RoborockBase):
     filter_life: int | None = field(default=None, metadata={"dps": B01_Q10_DP.FILTER_LIFE})
     sensor_life: int | None = field(default=None, metadata={"dps": B01_Q10_DP.SENSOR_LIFE})
 
+    @property
+    def fault_name(self) -> str | None:
+        """Returns the name of the current fault."""
+        return self.fault.value if self.fault is not None else None
+
 
 @dataclass
 class SoundVolume(RoborockBase):

roborock/data/mower/__init__.py

@@ -0,0 +1,3 @@
+"""Dataclasses for Roborock mower devices."""
+
+from .mower_containers import *

roborock/data/mower/mower_containers.py

@@ -0,0 +1,43 @@
+"""Data containers for Roborock mower devices."""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from roborock.data.containers import RoborockBase
+from roborock.roborock_message import RoborockMowerDataProtocol
+
+
+@dataclass
+class MowerStatus(RoborockBase):
+    """Core mower status backed by mower DPS updates."""
+
+    error_code: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.ERROR_CODE})
+    battery: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.BATTERY})
+    mow_type: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.MOW_TYPE})
+    mow_state: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.MOW_STATE})
+    mapping_type: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.MAPPING_TYPE})
+    mapping_state: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.MAPPING_STATE})
+    ota_state: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.OTA_STATE})
+    charge_state: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.CHARGE_STATE})
+    dock_state: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.DOCK_STATE})
+    charge_type: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.CHARGE_TYPE})
+    pend_type: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.PEND_TYPE})
+    remote_state: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.REMOTE_STATE})
+    mow_start_type: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.MOW_START_TYPE})
+    mow_eff_mode: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.MOW_EFF_MODE})
+    mow_height: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.MOW_HEIGHT})
+    mow_direction_angle: int | None = field(
+        default=None, metadata={"dps": RoborockMowerDataProtocol.MOW_DIRECTION_ANGLE}
+    )
+    mow_pattern: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.MOW_PATTERN})
+    mow_conf_mode: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.MOW_CONF_MODE})
+    offline_status: Any | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.OFFLINE_STATUS})
+    mow_progress: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.MOW_PROGRESS})
+    blade_lifespan: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.BLADE_LIFESPAN})
+    fc_state: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.FC_STATE})
+    gps_coordinate: Any | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.GPS_COORDINATE})
+    off_dock_no_task_status: int | None = field(
+        default=None, metadata={"dps": RoborockMowerDataProtocol.OFF_DOCK_NO_TASK_STATUS}
+    )
+    afs_status: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.AFS_STATUS})
+    network_channel: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.NETWORK_CHANNEL})

roborock/data/v1/v1_clean_modes.py

@@ -1,7 +1,10 @@
 from __future__ import annotations
 
 import typing
+from enum import StrEnum
+from typing import TypeVar
 
+from ...exceptions import RoborockUnsupportedFeature
 from ..code_mappings import RoborockModeEnum
 
 if typing.TYPE_CHECKING:
@@ -68,6 +71,22 @@ class WashTowelModes(RoborockModeEnum):
     SUPER_DEEP = ("super_deep", 8)
 
 
+class CleaningMode(StrEnum):
+    """High-level cleaning intent derived from the lower-level motor settings.
+
+    Prefer this abstraction when you want to present or switch between the
+    user-facing cleaning behaviors exposed by the app. The lower-level
+    `VacuumModes`, `WaterModes`, and `CleanRoutes` enums are still useful for
+    fine-grained selection.
+    """
+
+    VACUUM = "vacuum"
+    VAC_AND_MOP = "vac_and_mop"
+    MOP = "mop"
+    CUSTOM = "custom"
+    SMART_MODE = "smart_mode"
+
+
 WATER_SLIDE_MODE_MAPPING: dict[int, WaterModes] = {
     200: WaterModes.OFF,
     221: WaterModes.PURE_WATER_FLOW_START,
@@ -78,6 +97,8 @@ WATER_SLIDE_MODE_MAPPING: dict[int, WaterModes] = {
     250: WaterModes.PURE_WATER_FLOW_END,
 }
 
+ModeEnumT = TypeVar("ModeEnumT", bound=RoborockModeEnum)
+
 
 def get_wash_towel_modes(features: DeviceFeatures) -> list[WashTowelModes]:
     """Get the valid wash towel modes for the device"""
@@ -174,7 +195,151 @@ def get_water_mode_mapping(features: DeviceFeatures) -> dict[int, str]:
     return {mode.code: mode.value for mode in get_water_modes(features)}
 
 
-def is_mode_customized(clean_mode: VacuumModes, water_mode: WaterModes, mop_mode: CleanRoutes) -> bool:
+def get_cleaning_mode_options(features: DeviceFeatures) -> list[CleaningMode]:
+    """Return the supported high-level cleaning modes for the device.
+
+    These options are the preferred user-facing choices because they bundle the
+    correct fan, water, and mop-route settings together for the device. Callers
+    should generally present these instead of mixing lower-level mode enums
+    unless they explicitly need fine-grained control.
+    """
+    if not features.is_support_water_mode:
+        return []
+
+    supported_water_modes = get_water_modes(features)
+    options = [CleaningMode.VACUUM, CleaningMode.VAC_AND_MOP]
+    if features.is_pure_clean_mop_supported:
+        options.append(CleaningMode.MOP)
+    if features.is_customized_clean_supported and WaterModes.CUSTOMIZED in supported_water_modes:
+        options.append(CleaningMode.CUSTOM)
+    if features.is_smart_clean_mode_set_supported and WaterModes.SMART_MODE in supported_water_modes:
+        options.append(CleaningMode.SMART_MODE)
+    return options
+
+
+def get_mop_only_vacuum_mode(features: DeviceFeatures) -> VacuumModes:
+    """Determine the vacuum mode to use when you just want to mop.
+
+    There are three cases that must be handled:
+    1. The device does not support only mopping.
+    2. The device supports raising the vacuum brush while mopping
+    3. All other cases.
+    """
+    if not features.is_pure_clean_mop_supported:
+        raise RoborockUnsupportedFeature("Mop-only cleaning is not supported")
+    if features.is_support_main_brush_up_down_supported:
+        return VacuumModes.OFF_RAISE_MAIN_BRUSH
+    return VacuumModes.OFF
+
+
+def _get_default_mopping_water_mode(features: DeviceFeatures) -> WaterModes:
+    """Pick a sensible default water mode when mopping for the device."""
+    # Water-slide devices use a disjoint set of water codes; pick a mid-flow
+    # slide code instead of the standard 202, which they don't accept.
+    if features.is_water_slide_mode_supported:
+        return WaterModes.PURE_WATER_FLOW_MIDDLE
+    return WaterModes.STANDARD
+
+
+def _get_clean_motor_mode_params(
+    mode: CleaningMode,
+    features: DeviceFeatures,
+) -> tuple[VacuumModes, WaterModes, CleanRoutes]:
+    """Return (fan_power, water_box_mode, mop_mode) enums for the high-level mode."""
+    if mode == CleaningMode.VACUUM:
+        return (VacuumModes.BALANCED, WaterModes.OFF, CleanRoutes.STANDARD)
+    if mode == CleaningMode.VAC_AND_MOP:
+        return (VacuumModes.BALANCED, _get_default_mopping_water_mode(features), CleanRoutes.STANDARD)
+    if mode == CleaningMode.MOP:
+        return (
+            get_mop_only_vacuum_mode(features),
+            _get_default_mopping_water_mode(features),
+            CleanRoutes.STANDARD,
+        )
+    if mode == CleaningMode.CUSTOM:
+        return (VacuumModes.CUSTOMIZED, WaterModes.CUSTOMIZED, CleanRoutes.CUSTOMIZED)
+    if mode == CleaningMode.SMART_MODE:
+        return (VacuumModes.SMART_MODE, WaterModes.SMART_MODE, CleanRoutes.SMART_MODE)
+    raise RoborockUnsupportedFeature(f"Cleaning mode {mode.value!r} is not supported")
+
+
+def resolve_cleaning_mode(cleaning_mode: str | CleaningMode) -> CleaningMode:
+    """Resolve a string or enum into a CleaningMode value."""
+    if isinstance(cleaning_mode, CleaningMode):
+        return cleaning_mode
+    try:
+        return CleaningMode(cleaning_mode)
+    except ValueError as err:
+        raise RoborockUnsupportedFeature(f"Cleaning mode {cleaning_mode!r} is not supported") from err
+
+
+def get_cleaning_mode_parameters(cleaning_mode: CleaningMode, features: DeviceFeatures) -> list[dict[str, int]]:
+    """Get the RPC payload for switching the high-level cleaning mode."""
+    if cleaning_mode not in get_cleaning_mode_options(features):
+        raise RoborockUnsupportedFeature(f"Cleaning mode {cleaning_mode.value!r} is not supported")
+
+    fan_power, water_box_mode, mop_mode = _get_clean_motor_mode_params(cleaning_mode, features)
+    params: dict[str, int] = {"fan_power": fan_power.code, "water_box_mode": water_box_mode.code}
+    if features.is_clean_route_setting_supported:
+        params["mop_mode"] = mop_mode.code
+    return [params]
+
+
+def _resolve_mode_code(value: int | ModeEnumT | None, mode_cls: type[ModeEnumT]) -> ModeEnumT | None:
+    """Resolve a raw code or enum into a RoborockModeEnum."""
+    if value is None:
+        return None
+    if isinstance(value, mode_cls):
+        return value
+    return mode_cls.from_code_optional(int(value))
+
+
+def _resolve_clean_mode(value: int | VacuumModes | None, features: DeviceFeatures) -> VacuumModes | None:
+    """Resolve a vacuum mode code, accounting for feature-specific code aliases."""
+    if value is None or isinstance(value, VacuumModes):
+        return value
+    if value == VacuumModes.OFF.code:
+        if features.is_pure_clean_mop_supported:
+            return get_mop_only_vacuum_mode(features)
+        return VacuumModes.GENTLE
+    return VacuumModes.from_code_optional(value)
+
+
+def get_current_cleaning_mode(
+    clean_mode: int | VacuumModes | None,
+    water_mode: int | WaterModes | None,
+    mop_mode: int | CleanRoutes | None,
+    features: DeviceFeatures,
+) -> CleaningMode | None:
+    """Classify the current high-level cleaning mode from individual mode codes."""
+    if not features.is_support_water_mode:
+        return None
+    clean_mode_enum = _resolve_clean_mode(clean_mode, features)
+    water_mode_enum = _resolve_mode_code(water_mode, WaterModes)
+    mop_mode_enum = _resolve_mode_code(mop_mode, CleanRoutes)
+    if clean_mode_enum is None or water_mode_enum is None:
+        return None
+
+    if is_smart_mode_set(water_mode_enum, clean_mode_enum, mop_mode_enum):
+        return CleaningMode.SMART_MODE
+    if is_mode_customized(clean_mode_enum, water_mode_enum, mop_mode_enum):
+        return CleaningMode.CUSTOM
+    if water_mode_enum != WaterModes.OFF:
+        try:
+            if clean_mode_enum == get_mop_only_vacuum_mode(features):
+                return CleaningMode.MOP
+        except RoborockUnsupportedFeature:
+            pass
+    if water_mode_enum == WaterModes.OFF:
+        return CleaningMode.VACUUM
+    return CleaningMode.VAC_AND_MOP
+
+
+def is_mode_customized(
+    clean_mode: VacuumModes | None,
+    water_mode: WaterModes | None,
+    mop_mode: CleanRoutes | None,
+) -> bool:
     """Check if any of the cleaning modes are set to a custom value."""
     return (
         clean_mode == VacuumModes.CUSTOMIZED
@@ -183,7 +348,11 @@ def is_mode_customized(clean_mode: VacuumModes, water_mode: WaterModes, mop_mode
     )
 
 
-def is_smart_mode_set(water_mode: WaterModes, clean_mode: VacuumModes, mop_mode: CleanRoutes) -> bool:
+def is_smart_mode_set(
+    water_mode: WaterModes | None,
+    clean_mode: VacuumModes | None,
+    mop_mode: CleanRoutes | None,
+) -> bool:
     """Check if the smart mode is set for the given water mode and clean mode"""
     return (
         water_mode == WaterModes.SMART_MODE

roborock/devices/device_manager.py

@@ -26,6 +26,8 @@ from roborock.protocol import create_mqtt_params
 from roborock.web_api import RoborockApiClient, UserWebApiClient
 
 from .cache import Cache, DeviceCache, NoCache
+from .rpc.b01_q7_channel import create_b01_q7_channel
+from .rpc.b01_q10_channel import create_b01_q10_channel
 from .rpc.v1_channel import create_v1_channel
 from .traits import Trait, a01, b01, v1
 from .transport.channel import Channel
@@ -254,13 +256,22 @@ async def create_device_manager(
                 channel = create_mqtt_channel(user_data, mqtt_params, mqtt_session, device)
                 trait = a01.create(product, channel)
             case DeviceVersion.B01:
-                channel = create_mqtt_channel(user_data, mqtt_params, mqtt_session, device)
+                mqtt_channel = create_mqtt_channel(user_data, mqtt_params, mqtt_session, device)
                 model_part = product.model.split(".")[-1]
                 if "ss" in model_part:
+                    b01_q10_channel = create_b01_q10_channel(mqtt_channel)
+                    channel = b01_q10_channel
                     trait = b01.q10.create(channel)
                 elif "sc" in model_part:
                     # Q7 devices start with 'sc' in their model naming.
-                    trait = b01.q7.create(product, device, channel)
+                    b01_q7_channel = create_b01_q7_channel(device, product, mqtt_channel)
+                    channel = b01_q7_channel
+                    trait = b01.q7.create(
+                        product,
+                        device,
+                        rpc_channel=b01_q7_channel,
+                        map_rpc_channel=b01_q7_channel,
+                    )
                 else:
                     raise UnsupportedDeviceError(f"Device {device.name} has unsupported B01 model: {product.model}")
             case _:

roborock/devices/rpc/b01_q10_channel.py

@@ -1,9 +1,11 @@
 """Thin wrapper around the MQTT channel for Roborock B01 Q10 devices."""
 
 import logging
-from collections.abc import AsyncGenerator
+from collections.abc import AsyncGenerator, Callable
+from typing import Protocol
 
 from roborock.data.b01_q10.b01_q10_code_mappings import B01_Q10_DP
+from roborock.devices.transport.channel import Channel
 from roborock.devices.transport.mqtt_channel import MqttChannel
 from roborock.exceptions import RoborockException
 from roborock.protocols.b01_q10_protocol import (
@@ -12,10 +14,53 @@ from roborock.protocols.b01_q10_protocol import (
     decode_message,
     encode_mqtt_payload,
 )
+from roborock.roborock_message import RoborockMessage
 
 _LOGGER = logging.getLogger(__name__)
 
 
+class Q10RpcChannel(Protocol):
+    """Protocol for Q10 RPC channels."""
+
+    async def send_command(
+        self,
+        command: B01_Q10_DP,
+        params: ParamsType = None,
+    ) -> None:
+        """Send a command on the MQTT channel, without waiting for a response."""
+        ...
+
+
+class B01Q10Channel(Channel, Q10RpcChannel):
+    """Unified B01 Q10 channel wrapping MQTT transport."""
+
+    def __init__(self, mqtt_channel: MqttChannel) -> None:
+        self._mqtt_channel = mqtt_channel
+
+    @property
+    def is_connected(self) -> bool:
+        return self._mqtt_channel.is_connected
+
+    @property
+    def is_local_connected(self) -> bool:
+        return False
+
+    async def subscribe(self, callback: Callable[[RoborockMessage], None]) -> Callable[[], None]:
+        return await self._mqtt_channel.subscribe(callback)
+
+    async def subscribe_stream(self) -> AsyncGenerator[Q10Message, None]:
+        """Stream decoded Q10 messages received via MQTT."""
+        async for msg in stream_decoded_messages(self._mqtt_channel):
+            yield msg
+
+    async def send_command(
+        self,
+        command: B01_Q10_DP,
+        params: ParamsType = None,
+    ) -> None:
+        await send_command(self._mqtt_channel, command, params)
+
+
 async def stream_decoded_messages(
     mqtt_channel: MqttChannel,
 ) -> AsyncGenerator[Q10Message, None]:
@@ -59,3 +104,8 @@ async def send_command(
             ex,
         )
         raise
+
+
+def create_b01_q10_channel(mqtt_channel: MqttChannel) -> B01Q10Channel:
+    """Create a B01Q10Channel wrapping MQTT transport."""
+    return B01Q10Channel(mqtt_channel)

roborock/devices/rpc/b01_q7_channel.py

@@ -1,19 +1,23 @@
 """Thin wrapper around the MQTT channel for Roborock B01 Q7 devices."""
 
-from __future__ import annotations
-
 import asyncio
 import json
 import logging
 from collections.abc import Callable
-from typing import TypeAlias, TypeVar
+from typing import Protocol, TypeAlias, TypeVar
 
+from roborock.data import HomeDataDevice, HomeDataProduct
+from roborock.devices.transport.channel import Channel
 from roborock.devices.transport.mqtt_channel import MqttChannel
 from roborock.exceptions import RoborockException
 from roborock.protocols.b01_q7_protocol import (
+    B01_Q7_DPS,
     B01_VERSION,
+    CommandType,
     MapKey,
+    ParamsType,
     Q7RequestMessage,
+    create_map_key,
     decode_map_payload,
     decode_rpc_response,
     encode_mqtt_payload,
@@ -26,6 +30,30 @@ _T = TypeVar("_T")
 DecodedB01Response: TypeAlias = dict[str, object] | str
 
 
+class Q7RpcChannel(Protocol):
+    """Protocol for Q7 RPC channels."""
+
+    async def send_command(
+        self,
+        command: CommandType,
+        params: ParamsType = None,
+    ) -> DecodedB01Response:
+        """Send a command and get a decoded response."""
+        ...
+
+
+class Q7MapRpcChannel(Protocol):
+    """Protocol for Q7 map RPC channels."""
+
+    async def send_map_command(
+        self,
+        command: CommandType,
+        params: ParamsType = None,
+    ) -> bytes:
+        """Send a map command and get decoded bytes."""
+        ...
+
+
 def _matches_map_response(response_message: RoborockMessage, *, version: bytes | None) -> bytes | None:
     """Return raw map payload bytes for matching MAP_RESPONSE messages."""
     if (
@@ -120,39 +148,55 @@ async def send_decoded_command(
         raise RoborockException(f"B01 command timed out after {_TIMEOUT}s ({request_message})") from ex
     except RoborockException as ex:
         _LOGGER.warning(
-            "Error sending B01 decoded command (%ss): %s",
+            "Error sending B01 decoded command (%s): %s",
             request_message,
             ex,
         )
         raise
     except Exception as ex:
         _LOGGER.exception(
-            "Error sending B01 decoded command (%ss): %s",
+            "Error sending B01 decoded command (%s): %s",
             request_message,
             ex,
         )
         raise
 
 
-class MapRpcChannel:
-    """RPC channel for map-related commands on B01/Q7 devices."""
+class B01Q7Channel(Channel, Q7RpcChannel, Q7MapRpcChannel):
+    """Unified B01 Q7 channel wrapping MQTT transport."""
 
     def __init__(self, mqtt_channel: MqttChannel, map_key: MapKey) -> None:
         self._mqtt_channel = mqtt_channel
         self._map_key = map_key
 
-    async def send_map_command(self, request_message: Q7RequestMessage) -> bytes:
-        """Send a map upload command and return decoded SCMap bytes.
-
-        This publishes the request and waits for a matching ``MAP_RESPONSE`` message
-        with the correct protocol version. The raw ``MAP_RESPONSE`` payload bytes are
-        then decoded/inflated via :func:`decode_map_payload` using this channel's
-        ``map_key``, and the resulting SCMap bytes are returned.
-
-        The returned value is the decoded map data bytes suitable for passing to the
-        map parser library, not the raw MQTT ``MAP_RESPONSE`` payload bytes.
-        """
+    @property
+    def is_connected(self) -> bool:
+        return self._mqtt_channel.is_connected
+
+    @property
+    def is_local_connected(self) -> bool:
+        return False
+
+    async def subscribe(self, callback: Callable[[RoborockMessage], None]) -> Callable[[], None]:
+        return await self._mqtt_channel.subscribe(callback)
+
+    async def send_command(
+        self,
+        command: CommandType,
+        params: ParamsType = None,
+    ) -> DecodedB01Response:
+        return await send_decoded_command(
+            self._mqtt_channel,
+            Q7RequestMessage(dps=B01_Q7_DPS, command=command, params=params),
+        )
 
+    async def send_map_command(
+        self,
+        command: CommandType,
+        params: ParamsType = None,
+    ) -> bytes:
+        """Send a map upload command and return decoded SCMap bytes."""
+        request_message = Q7RequestMessage(dps=B01_Q7_DPS, command=command, params=params)
         try:
             raw_payload = await _send_command(
                 self._mqtt_channel,
@@ -163,3 +207,17 @@ class MapRpcChannel:
             raise RoborockException(f"B01 map command timed out after {_TIMEOUT}s ({request_message})") from ex
 
         return decode_map_payload(raw_payload, map_key=self._map_key)
+
+
+def create_b01_q7_channel(
+    device: HomeDataDevice,
+    product: HomeDataProduct,
+    mqtt_channel: MqttChannel,
+) -> B01Q7Channel:
+    """Create a B01Q7Channel for the given device."""
+    if device.sn is None or product.model is None:
+        raise RoborockException(
+            f"Device serial number and product model are required (sn: {device.sn}, model: {product.model})"
+        )
+    map_key = create_map_key(serial=device.sn, model=product.model)
+    return B01Q7Channel(mqtt_channel, map_key)

roborock/devices/traits/b01/q10/__init__.py

@@ -4,9 +4,8 @@ import asyncio
 import logging
 
 from roborock.data.b01_q10.b01_q10_code_mappings import B01_Q10_DP
-from roborock.devices.rpc.b01_q10_channel import stream_decoded_messages
+from roborock.devices.rpc.b01_q10_channel import B01Q10Channel
 from roborock.devices.traits import Trait
-from roborock.devices.transport.mqtt_channel import MqttChannel
 from roborock.map.b01_q10_map_parser import Q10MapPacket, Q10TracePacket
 from roborock.protocols.b01_q10_protocol import Q10DpsUpdate, Q10Message
 
@@ -83,7 +82,7 @@ class Q10PropertiesApi(Trait):
     clean_history: CleanHistoryTrait
     """Trait for fetching the device clean-record history (``dpCleanRecord``)."""
 
-    def __init__(self, channel: MqttChannel) -> None:
+    def __init__(self, channel: B01Q10Channel) -> None:
         """Initialize the B01Props API."""
         self._channel = channel
         self.command = CommandTrait(channel)
@@ -134,7 +133,7 @@ class Q10PropertiesApi(Trait):
 
     async def _subscribe_loop(self) -> None:
         """Persistent loop dispatching decoded messages to the read-model traits."""
-        async for message in stream_decoded_messages(self._channel):
+        async for message in self._channel.subscribe_stream():
             self._handle_message(message)
 
     def _handle_message(self, message: Q10Message) -> None:
@@ -157,6 +156,6 @@ class Q10PropertiesApi(Trait):
                 trait.update_from_dps(message.dps)
 
 
-def create(channel: MqttChannel) -> Q10PropertiesApi:
+def create(channel: B01Q10Channel) -> Q10PropertiesApi:
     """Create traits for B01 devices."""
     return Q10PropertiesApi(channel)

roborock/devices/traits/b01/q10/command.py

@@ -1,8 +1,7 @@
 from typing import Any
 
 from roborock.data.b01_q10.b01_q10_code_mappings import B01_Q10_DP
-from roborock.devices.rpc.b01_q10_channel import send_command
-from roborock.devices.transport.mqtt_channel import MqttChannel
+from roborock.devices.rpc.b01_q10_channel import Q10RpcChannel
 from roborock.protocols.b01_q10_protocol import ParamsType
 
 
@@ -15,9 +14,9 @@ class CommandTrait:
     available.
     """
 
-    def __init__(self, channel: MqttChannel) -> None:
+    def __init__(self, rpc_channel: Q10RpcChannel) -> None:
         """Initialize the CommandTrait."""
-        self._channel = channel
+        self._rpc_channel = rpc_channel
 
     async def send(self, command: B01_Q10_DP, params: ParamsType = None) -> Any:
         """Send a command to the device.
@@ -27,6 +26,6 @@ class CommandTrait:
         caller to ensure that any traits affected by the command are refreshed
         as needed.
         """
-        if not self._channel:
+        if not self._rpc_channel:
             raise ValueError("Device trait in invalid state")
-        return await send_command(self._channel, command, params=params)
+        return await self._rpc_channel.send_command(command, params=params)

roborock/devices/traits/b01/q7/__init__.py

@@ -3,8 +3,6 @@
 Potentially other devices may fall into this category in the future.
 """
 
-from __future__ import annotations
-
 from typing import Any
 
 from roborock import B01Props
@@ -18,11 +16,10 @@ from roborock.data.b01_q7.b01_q7_code_mappings import (
     SCWindMapping,
     WaterLevelMapping,
 )
-from roborock.devices.rpc.b01_q7_channel import MapRpcChannel, send_decoded_command
+from roborock.devices.rpc.b01_q7_channel import Q7MapRpcChannel, Q7RpcChannel
 from roborock.devices.traits import Trait
-from roborock.devices.transport.mqtt_channel import MqttChannel
 from roborock.exceptions import RoborockException
-from roborock.protocols.b01_q7_protocol import B01_Q7_DPS, CommandType, ParamsType, Q7RequestMessage, create_map_key
+from roborock.protocols.b01_q7_protocol import CommandType, ParamsType
 from roborock.roborock_message import RoborockB01Props
 from roborock.roborock_typing import RoborockB01Q7Methods
 
@@ -53,10 +50,14 @@ class Q7PropertiesApi(Trait):
     """Trait for fetching parsed current map content."""
 
     def __init__(
-        self, channel: MqttChannel, map_rpc_channel: MapRpcChannel, device: HomeDataDevice, product: HomeDataProduct
+        self,
+        rpc_channel: Q7RpcChannel,
+        map_rpc_channel: Q7MapRpcChannel,
+        device: HomeDataDevice,
+        product: HomeDataProduct,
     ) -> None:
         """Initialize the Q7 API."""
-        self._channel = channel
+        self._rpc_channel = rpc_channel
         self._map_rpc_channel = map_rpc_channel
         self._device = device
         self._product = product
@@ -64,8 +65,8 @@ class Q7PropertiesApi(Trait):
         if not device.sn or not product.model:
             raise ValueError("B01 Q7 map content requires device serial number and product model metadata")
 
-        self.clean_summary = CleanSummaryTrait(channel)
-        self.map = MapTrait(channel)
+        self.clean_summary = CleanSummaryTrait(rpc_channel)
+        self.map = MapTrait(rpc_channel)
         self.map_content = MapContentTrait(
             self._map_rpc_channel,
             self.map,
@@ -199,17 +200,23 @@ class Q7PropertiesApi(Trait):
 
     async def send(self, command: CommandType, params: ParamsType) -> Any:
         """Send a command to the device."""
-        return await send_decoded_command(
-            self._channel,
-            Q7RequestMessage(dps=B01_Q7_DPS, command=command, params=params),
-        )
+        return await self._rpc_channel.send_command(command, params)
 
 
-def create(product: HomeDataProduct, device: HomeDataDevice, channel: MqttChannel) -> Q7PropertiesApi:
+def create(
+    product: HomeDataProduct,
+    device: HomeDataDevice,
+    rpc_channel: Q7RpcChannel,
+    map_rpc_channel: Q7MapRpcChannel,
+) -> Q7PropertiesApi:
     """Create traits for B01 Q7 devices."""
     if device.sn is None or product.model is None:
         raise RoborockException(
-            f"Device serial number and product model are required (sn:: {device.sn}, model: {product.model})"
+            f"Device serial number and product model are required (sn: {device.sn}, model: {product.model})"
         )
-    map_rpc_channel = MapRpcChannel(channel, map_key=create_map_key(serial=device.sn, model=product.model))
-    return Q7PropertiesApi(channel, device=device, product=product, map_rpc_channel=map_rpc_channel)
+    return Q7PropertiesApi(
+        rpc_channel=rpc_channel,
+        map_rpc_channel=map_rpc_channel,
+        device=device,
+        product=product,
+    )

roborock/devices/traits/b01/q7/clean_summary.py

@@ -7,11 +7,9 @@ and a `record_list` whose items contain a JSON string in `detail`.
 import logging
 
 from roborock import CleanRecordDetail, CleanRecordList, CleanRecordSummary
-from roborock.devices.rpc.b01_q7_channel import send_decoded_command
+from roborock.devices.rpc.b01_q7_channel import Q7RpcChannel
 from roborock.devices.traits import Trait
-from roborock.devices.transport.mqtt_channel import MqttChannel
 from roborock.exceptions import RoborockException
-from roborock.protocols.b01_q7_protocol import B01_Q7_DPS, Q7RequestMessage
 from roborock.roborock_typing import RoborockB01Q7Methods
 
 __all__ = [
@@ -24,11 +22,11 @@ _LOGGER = logging.getLogger(__name__)
 class CleanSummaryTrait(CleanRecordSummary, Trait):
     """B01/Q7 clean summary + clean record access (via record list service)."""
 
-    def __init__(self, channel: MqttChannel) -> None:
+    def __init__(self, channel: Q7RpcChannel) -> None:
         """Initialize the clean summary trait.
 
         Args:
-            channel: MQTT channel used to communicate with the device.
+            channel: RPC channel used to communicate with the device.
         """
         super().__init__()
         self._channel = channel
@@ -46,9 +44,9 @@ class CleanSummaryTrait(CleanRecordSummary, Trait):
 
     async def _get_record_list(self) -> CleanRecordList:
         """Fetch the raw device clean record list (`service.get_record_list`)."""
-        result = await send_decoded_command(
-            self._channel,
-            Q7RequestMessage(dps=B01_Q7_DPS, command=RoborockB01Q7Methods.GET_RECORD_LIST, params={}),
+        result = await self._channel.send_command(
+            command=RoborockB01Q7Methods.GET_RECORD_LIST,
+            params={},
         )
 
         if not isinstance(result, dict):

roborock/devices/traits/b01/q7/map.py

@@ -1,11 +1,9 @@
 """Map trait for B01 Q7 devices."""
 
 from roborock.data import Q7MapList
-from roborock.devices.rpc.b01_q7_channel import send_decoded_command
+from roborock.devices.rpc.b01_q7_channel import Q7RpcChannel
 from roborock.devices.traits import Trait
-from roborock.devices.transport.mqtt_channel import MqttChannel
 from roborock.exceptions import RoborockException
-from roborock.protocols.b01_q7_protocol import B01_Q7_DPS, Q7RequestMessage
 from roborock.roborock_typing import RoborockB01Q7Methods
 
 
@@ -16,15 +14,15 @@ class MapTrait(Q7MapList, Trait):
     current map ID to fetch.
     """
 
-    def __init__(self, channel: MqttChannel) -> None:
+    def __init__(self, channel: Q7RpcChannel) -> None:
         super().__init__()
         self._channel = channel
 
     async def refresh(self) -> None:
         """Refresh cached map list metadata from the device."""
-        response = await send_decoded_command(
-            self._channel,
-            Q7RequestMessage(dps=B01_Q7_DPS, command=RoborockB01Q7Methods.GET_MAP_LIST, params={}),
+        response = await self._channel.send_command(
+            command=RoborockB01Q7Methods.GET_MAP_LIST,
+            params={},
         )
         if not isinstance(response, dict):
             raise RoborockException(

roborock/devices/traits/b01/q7/map_content.py

@@ -14,11 +14,10 @@ from dataclasses import dataclass
 from vacuum_map_parser_base.map_data import MapData
 
 from roborock.data import RoborockBase
-from roborock.devices.rpc.b01_q7_channel import MapRpcChannel
+from roborock.devices.rpc.b01_q7_channel import Q7MapRpcChannel
 from roborock.devices.traits import Trait
 from roborock.exceptions import RoborockException
 from roborock.map.b01_map_parser import B01MapParser, B01MapParserConfig
-from roborock.protocols.b01_q7_protocol import B01_Q7_DPS, Q7RequestMessage
 from roborock.roborock_typing import RoborockB01Q7Methods
 
 from .map import MapTrait
@@ -55,7 +54,7 @@ class MapContentTrait(MapContent, Trait):
 
     def __init__(
         self,
-        map_rpc_channel: MapRpcChannel,
+        map_rpc_channel: Q7MapRpcChannel,
         map_trait: MapTrait,
         *,
         map_parser_config: B01MapParserConfig | None = None,
@@ -77,13 +76,11 @@ class MapContentTrait(MapContent, Trait):
         if (map_id := self._map_trait.current_map_id) is None:
             raise RoborockException("Unable to determine current map ID")
 
-        request = Q7RequestMessage(
-            dps=B01_Q7_DPS,
-            command=RoborockB01Q7Methods.UPLOAD_BY_MAPID,
-            params={"map_id": map_id},
-        )
         async with self._map_command_lock:
-            raw_payload = await self._map_rpc_channel.send_map_command(request)
+            raw_payload = await self._map_rpc_channel.send_map_command(
+                RoborockB01Q7Methods.UPLOAD_BY_MAPID,
+                {"map_id": map_id},
+            )
 
         try:
             parsed_data = self._map_parser.parse(raw_payload)

roborock/devices/traits/v1/status.py

@@ -3,14 +3,19 @@ from functools import cached_property
 from typing import Any
 
 from roborock import (
+    CleaningMode,
     CleanRoutes,
     StatusV2,
     VacuumModes,
     WaterModes,
     get_clean_modes,
     get_clean_routes,
+    get_cleaning_mode_options,
+    get_cleaning_mode_parameters,
+    get_current_cleaning_mode,
     get_water_mode_mapping,
     get_water_modes,
+    resolve_cleaning_mode,
 )
 from roborock.devices.traits.common import DpsDataConverter, TraitUpdateListener
 from roborock.roborock_message import RoborockDataProtocol
@@ -42,10 +47,11 @@ class StatusTrait(StatusV2, common.V1TraitMixin, TraitUpdateListener):
     - Water Mode
     - Mop Route
 
-    You should call the _options() version of the attribute to know which are supported for your device
-    (i.e. fan_speed_options())
-    Then you can call the _mapping to convert an int value to the actual Enum. (i.e. fan_speed_mapping())
-    You can call the _name property to get the str value of the enum. (i.e. fan_speed_name)
+    You should use the _options version of the attribute to know which are
+    supported for your device (i.e. fan_speed_options)
+    Then you can use the _mapping to convert an int value to the actual Enum.
+    (i.e. fan_speed_mapping)
+    You can use the _name property to get the str value of the enum. (i.e. fan_speed_name)
 
     """
 
@@ -83,6 +89,10 @@ class StatusTrait(StatusV2, common.V1TraitMixin, TraitUpdateListener):
     def mop_route_mapping(self) -> dict[int, str]:
         return {route.code: route.value for route in self.mop_route_options}
 
+    @cached_property
+    def cleaning_mode_options(self) -> list[CleaningMode]:
+        return get_cleaning_mode_options(self._device_features_trait)
+
     @property
     def fan_speed_name(self) -> str | None:
         if self.fan_power is None:
@@ -101,6 +111,28 @@ class StatusTrait(StatusV2, common.V1TraitMixin, TraitUpdateListener):
             return None
         return self.mop_route_mapping.get(self.mop_mode)
 
+    @property
+    def current_cleaning_mode(self) -> CleaningMode | None:
+        return get_current_cleaning_mode(
+            clean_mode=self.fan_power,
+            water_mode=self.water_box_mode,
+            mop_mode=self.mop_mode,
+            features=self._device_features_trait,
+        )
+
+    @property
+    def current_cleaning_mode_name(self) -> str | None:
+        if (cleaning_mode := self.current_cleaning_mode) is None:
+            return None
+        return cleaning_mode.value
+
+    async def set_cleaning_mode(self, cleaning_mode: str | CleaningMode) -> None:
+        """Set the preferred high-level cleaning mode for the device."""
+        await self.rpc_channel.send_command(
+            RoborockCommand.SET_CLEAN_MOTOR_MODE,
+            params=get_cleaning_mode_parameters(resolve_cleaning_mode(cleaning_mode), self._device_features_trait),
+        )
+
     def update_from_dps(self, decoded_dps: dict[RoborockDataProtocol, Any]) -> None:
         """Update the trait from data protocol push message data.
 

roborock/roborock_message.py

@@ -40,6 +40,45 @@ class RoborockDataProtocol(RoborockEnum):
         raise ValueError(f"{key} not a valid key for Data Protocol")
 
 
+class RoborockMowerDataProtocol(RoborockEnum):
+    UNKNOWN = 0
+    ERROR_CODE = 120
+    BATTERY = 121
+    MOW_TYPE = 122
+    MOW_STATE = 123
+    MAPPING_TYPE = 124
+    MAPPING_STATE = 125
+    OTA_STATE = 126
+    CHARGE_STATE = 127
+    DOCK_STATE = 128
+    CHARGE_TYPE = 129
+    PEND_TYPE = 130
+    REMOTE_STATE = 131
+    MOW_START_TYPE = 132
+    MOW_EFF_MODE = 133
+    MOW_HEIGHT = 134
+    MOW_DIRECTION_ANGLE = 135
+    MOW_PATTERN = 136
+    MOW_CONF_MODE = 137
+    OFFLINE_STATUS = 138
+    MOW_PROGRESS = 139
+    BLADE_LIFESPAN = 140
+    FC_STATE = 141
+    GPS_COORDINATE = 142
+    OFF_DOCK_NO_TASK_STATUS = 143
+    AFS_STATUS = 144
+    NETWORK_CHANNEL = 145
+    START = 201
+    DOCK = 202
+    PAUSE = 203
+    RESUME = 204
+    STOP = 205
+
+    @classmethod
+    def _missing_(cls: type[Self], key) -> Self:
+        raise ValueError(f"{key} not a valid key for Mower Data Protocol")
+
+
 class RoborockDyadDataProtocol(RoborockEnum):
     DRYING_STATUS = 134
     START = 200