python-roborock 2.37.0__tar.gz → 2.39.0__tar.gz

{python_roborock-2.37.0 → python_roborock-2.39.0}/PKG-INFO

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

{python_roborock-2.37.0 → python_roborock-2.39.0}/pyproject.toml

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

{python_roborock-2.37.0 → python_roborock-2.39.0}/roborock/__init__.py

@@ -1,5 +1,6 @@
 """Roborock API."""
 
+from roborock.b01_containers import *
 from roborock.code_mappings import *
 from roborock.containers import *
 from roborock.exceptions import *

python_roborock-2.39.0/roborock/b01_containers.py

@@ -0,0 +1,417 @@
+from dataclasses import dataclass, field
+
+from .code_mappings import RoborockModeEnum
+from .containers import RoborockBase
+
+
+class WorkStatusMapping(RoborockModeEnum):
+    """Maps the general status of the robot."""
+
+    SLEEPING = ("sleeping", 0)
+    WAITING_FOR_ORDERS = ("waiting_for_orders", 1)
+    PAUSED = ("paused", 2)
+    DOCKING = ("docking", 3)
+    CHARGING = ("charging", 4)
+    SWEEP_MOPING = ("sweep_moping", 5)
+    SWEEP_MOPING_2 = ("sweep_moping_2", 6)
+    MOPING = ("moping", 7)
+    UPDATING = ("updating", 8)
+    MOP_CLEANING = ("mop_cleaning", 9)
+    MOP_AIRDRYING = ("mop_airdrying", 10)
+
+
+class SCWindMapping(RoborockModeEnum):
+    """Maps suction power levels."""
+
+    SILENCE = ("quiet", 0)
+    STANDARD = ("balanced", 1)
+    STRONG = ("turbo", 2)
+    SUPER_STRONG = ("max", 3)
+    MAX = ("max_plus", 4)
+
+
+class WaterLevelMapping(RoborockModeEnum):
+    """Maps water flow levels."""
+
+    LOW = ("low", 0)
+    MEDIUM = ("medium", 1)
+    HIGH = ("high", 2)
+
+
+class CleanTypeMapping(RoborockModeEnum):
+    """Maps the type of cleaning (Vacuum, Mop, or both)."""
+
+    VACUUM = ("vacuum", 0)
+    VAC_AND_MOP = ("vac_and_mop", 1)
+    MOP = ("mop", 2)
+
+
+class CleanRepeatMapping(RoborockModeEnum):
+    """Maps the cleaning repeat parameter."""
+
+    ONCE = ("once", 0)
+    TWICE = ("twice", 1)
+
+
+class WorkModeMapping(RoborockModeEnum):
+    """Maps the detailed work modes of the robot."""
+
+    IDLE = ("idle", 0)
+    AUTO = ("auto", 1)
+    MANUAL = ("manual", 2)
+    AREA = ("area", 3)
+    AUTO_PAUSE = ("auto_pause", 4)
+    BACK_CHARGE = ("back_charge", 5)
+    POINT = ("point", 6)
+    NAVI = ("navi", 7)
+    AREA_PAUSE = ("area_pause", 8)
+    NAVI_PAUSE = ("navi_pause", 9)
+    GLOBAL_GO_HOME = ("global_go_home", 10)
+    GLOBAL_BROKEN = ("global_broken", 11)
+    NAVI_GO_HOME = ("navi_go_home", 12)
+    POINT_GO_HOME = ("point_go_home", 13)
+    NAVI_IDLE = ("navi_idle", 14)
+    SCREW = ("screw", 20)
+    SCREW_GO_HOME = ("screw_go_home", 21)
+    POINT_IDLE = ("point_idle", 22)
+    SCREW_IDLE = ("screw_idle", 23)
+    BORDER = ("border", 25)
+    BORDER_GO_HOME = ("border_go_home", 26)
+    BORDER_PAUSE = ("border_pause", 27)
+    BORDER_BROKEN = ("border_broken", 28)
+    BORDER_IDLE = ("border_idle", 29)
+    PLAN_AREA = ("plan_area", 30)
+    PLAN_AREA_PAUSE = ("plan_area_pause", 31)
+    PLAN_AREA_GO_HOME = ("plan_area_go_home", 32)
+    PLAN_AREA_BROKEN = ("plan_area_broken", 33)
+    PLAN_AREA_IDLE = ("plan_area_idle", 35)
+    MOPPING = ("mopping", 36)
+    MOPPING_PAUSE = ("mopping_pause", 37)
+    MOPPING_GO_HOME = ("mopping_go_home", 38)
+    MOPPING_BROKEN = ("mopping_broken", 39)
+    MOPPING_IDLE = ("mopping_idle", 40)
+    EXPLORING = ("exploring", 45)
+    EXPLORE_PAUSE = ("explore_pause", 46)
+    EXPLORE_GO_HOME = ("explore_go_home", 47)
+    EXPLORE_BROKEN = ("explore_broken", 48)
+    EXPLORE_IDLE = ("explore_idle", 49)
+
+
+class StationActionMapping(RoborockModeEnum):
+    """Maps actions for the cleaning/drying station."""
+
+    STOP_CLEAN_OR_AIRDRY = ("stop_clean_or_airdry", 0)
+    MOP_CLEAN = ("mop_clean", 1)
+    MOP_AIRDRY = ("mop_airdry", 2)
+
+
+class CleanTaskTypeMapping(RoborockModeEnum):
+    """Maps the high-level type of cleaning task selected."""
+
+    ALL = ("full", 0)
+    ROOM = ("room", 1)
+    AREA = ("zones", 4)
+    ROOM_NORMAL = ("room_normal", 5)
+    CUSTOM_MODE = ("customize", 6)
+    ALL_CUSTOM = ("all_custom", 11)
+    AREA_CUSTOM = ("area_custom", 99)
+
+
+class CarpetModeMapping(RoborockModeEnum):
+    """Maps carpet handling parameters."""
+
+    FOLLOW_GLOBAL = ("follow_global", 0)
+    ON = ("on", 1)
+    OFF = ("off", 2)
+
+
+@dataclass
+class NetStatus(RoborockBase):
+    """Represents the network status of the device."""
+
+    rssi: str
+    loss: int
+    ping: int
+    ip: str
+    mac: str
+    ssid: str
+    frequency: int
+    bssid: str
+
+
+@dataclass
+class OrderTotal(RoborockBase):
+    """Represents the order total information."""
+
+    total: int
+    enable: int
+
+
+@dataclass
+class Privacy(RoborockBase):
+    """Represents the privacy settings of the device."""
+
+    ai_recognize: int
+    dirt_recognize: int
+    pet_recognize: int
+    carpet_turbo: int
+    carpet_avoid: int
+    carpet_show: int
+    map_uploads: int
+    ai_agent: int
+    ai_avoidance: int
+    record_uploads: int
+    along_floor: int
+    auto_upgrade: int
+
+
+@dataclass
+class PvCharging(RoborockBase):
+    """Represents the photovoltaic charging status."""
+
+    status: int
+    begin_time: int
+    end_time: int
+
+
+@dataclass
+class Recommend(RoborockBase):
+    """Represents cleaning recommendations."""
+
+    sill: int
+    wall: int
+    room_id: list[int] = field(default_factory=list)
+
+
+class B01Fault(RoborockModeEnum):
+    """B01 fault codes and their descriptions."""
+
+    F_0 = ("fault_0", 0)
+    F_407 = ("cleaning_in_progress", 407)  # Cleaning in progress. Scheduled cleanup ignored.
+    F_500 = (
+        "lidar_blocked",
+        500,
+    )  # LiDAR turret or laser blocked. Check for obstruction and retry. LiDAR sensor obstructed or stuck.
+    # Remove foreign objects if any. If the problem persists, move the robot away and restart.
+    F_501 = (
+        "robot_suspended",
+        501,
+    )  # Robot suspended. Move the robot away and restart. Cliff sensors dirty. Wipe them clean.
+    F_502 = (
+        "low_battery",
+        502,
+    )  # Low battery. Recharge now. Battery low. Put the robot on the dock to charge it to 20% before starting.
+    F_503 = (
+        "dustbin_not_installed",
+        503,
+    )  # Check that the dustbin and filter are installed properly. Reinstall the dustbin and filter in place.
+    # If the problem persists, replace the filter.
+    F_504 = ("fault_504", 504)
+    F_505 = ("fault_505", 505)
+    F_506 = ("fault_506", 506)
+    F_507 = ("fault_507", 507)
+    F_508 = ("fault_508", 508)
+    F_509 = ("cliff_sensor_error", 509)  # Cliff sensors error. Clean them, move the robot away from drops, and restart.
+    F_510 = (
+        "bumper_stuck",
+        510,
+    )  # Bumper stuck. Clean it and lightly tap to release it. Tap it repeatedly to release it. If no foreign object
+    # exists, move the robot away and restart.
+    F_511 = (
+        "docking_error",
+        511,
+    )  # Docking error. Put the robot on the dock. Clear obstacles around the dock, clean charging contacts, and put
+    # the robot on the dock.
+    F_512 = (
+        "docking_error",
+        512,
+    )  # Docking error. Put the robot on the dock. Clear obstacles around the dock, clean charging contacts, and put
+    # the robot on the dock.
+    F_513 = (
+        "robot_trapped",
+        513,
+    )  # Robot trapped. Move the robot away and restart. Clear obstacles around robot or move robot away and restart.
+    F_514 = (
+        "robot_trapped",
+        514,
+    )  # Robot trapped. Move the robot away and restart. Clear obstacles around robot or move robot away and restart.
+    F_515 = ("fault_515", 515)
+    F_517 = ("fault_517", 517)
+    F_518 = (
+        "low_battery",
+        518,
+    )  # Low battery. Recharge now. Battery low. Put the robot on the dock to charge it to 20% before starting.
+    F_519 = ("fault_519", 519)
+    F_520 = ("fault_520", 520)
+    F_521 = ("fault_521", 521)
+    F_522 = ("mop_not_installed", 522)  # Check that the mop is properly installed. Mop not installed. Reinstall it.
+    F_523 = ("fault_523", 523)
+    F_525 = ("fault_525", 525)
+    F_526 = ("fault_526", 526)
+    F_527 = ("fault_527", 527)
+    F_528 = ("fault_528", 528)
+    F_529 = ("fault_529", 529)
+    F_530 = ("fault_530", 530)
+    F_531 = ("fault_531", 531)
+    F_532 = ("fault_532", 532)
+    F_533 = ("long_sleep", 533)  # About to shut down after a long time of sleep. Charge the robot.
+    F_534 = (
+        "low_battery_shutdown",
+        534,
+    )  # Low battery. Turning off. About to shut down due to low battery. Charge the robot.
+    F_535 = ("fault_535", 535)
+    F_536 = ("fault_536", 536)
+    F_540 = ("fault_540", 540)
+    F_541 = ("fault_541", 541)
+    F_542 = ("fault_542", 542)
+    F_550 = ("fault_550", 550)
+    F_551 = ("fault_551", 551)
+    F_559 = ("fault_559", 559)
+    F_560 = ("side_brush_entangled", 560)  # Side brush entangled. Remove and clean it.
+    F_561 = ("fault_561", 561)
+    F_562 = ("fault_562", 562)
+    F_563 = ("fault_563", 563)
+    F_564 = ("fault_564", 564)
+    F_565 = ("fault_565", 565)
+    F_566 = ("fault_566", 566)
+    F_567 = ("fault_567", 567)
+    F_568 = ("main_wheels_entangled", 568)  # Clean main wheels, move the robot away and restart.
+    F_569 = ("main_wheels_entangled", 569)  # Clean main wheels, move the robot away and restart.
+    F_570 = ("main_brush_entangled", 570)  # Main brush entangled. Remove and clean it and its bearing.
+    F_571 = ("fault_571", 571)
+    F_572 = ("main_brush_entangled", 572)  # Main brush entangled. Remove and clean it and its bearing.
+    F_573 = ("fault_573", 573)
+    F_574 = ("fault_574", 574)
+    F_580 = ("fault_580", 580)
+    F_581 = ("fault_581", 581)
+    F_582 = ("fault_582", 582)
+    F_583 = ("fault_583", 583)
+    F_584 = ("fault_584", 584)
+    F_585 = ("fault_585", 585)
+    F_586 = ("fault_586", 586)
+    F_587 = ("fault_587", 587)
+    F_588 = ("fault_588", 588)
+    F_589 = ("fault_589", 589)
+    F_590 = ("fault_590", 590)
+    F_591 = ("fault_591", 591)
+    F_592 = ("fault_592", 592)
+    F_593 = ("fault_593", 593)
+    F_594 = (
+        "dust_bag_not_installed",
+        594,
+    )  # Make sure the dust bag is properly installed. Dust bag not installed. Check that it is installed properly.
+    F_601 = ("fault_601", 601)
+    F_602 = ("fault_602", 602)
+    F_603 = ("fault_603", 603)
+    F_604 = ("fault_604", 604)
+    F_605 = ("fault_605", 605)
+    F_611 = ("positioning_failed", 611)  # Positioning failed. Move the robot back to the dock and remap.
+    F_612 = (
+        "map_changed",
+        612,
+    )  # Map changed. Positioning failed. Try again. New environment detected. Map changed. Positioning failed.
+    # Try again after remapping.
+    F_629 = ("mop_mount_fell_off", 629)  # Mop cloth mount fell off. Reinstall it to resume working.
+    F_668 = (
+        "system_error",
+        668,
+    )  # Robot error. Reset the system. Fan error. Reset the system. If the problem persists, contact customer service.
+    F_2000 = ("fault_2000", 2000)
+    F_2003 = ("low_battery_schedule_canceled", 2003)  # Battery level below 20%. Scheduled task canceled.
+    F_2007 = (
+        "cannot_reach_target",
+        2007,
+    )  # Unable to reach the target. Cleaning ended. Ensure the door to the target area is open or unobstructed.
+    F_2012 = (
+        "cannot_reach_target",
+        2012,
+    )  # Unable to reach the target. Cleaning ended. Ensure the door to the target area is open or unobstructed.
+    F_2013 = ("fault_2013", 2013)
+    F_2015 = ("fault_2015", 2015)
+    F_2017 = ("fault_2017", 2017)
+    F_2100 = (
+        "low_battery_resume_later",
+        2100,
+    )  # Low battery. Resume cleaning after recharging. Low battery. Starting to recharge. Resume cleaning after
+    # charging.
+    F_2101 = ("fault_2101", 2101)
+    F_2102 = ("cleaning_complete", 2102)  # Cleaning completed. Returning to the dock.
+    F_2103 = ("fault_2103", 2103)
+    F_2104 = ("fault_2104", 2104)
+    F_2105 = ("fault_2105", 2105)
+    F_2108 = ("fault_2108", 2108)
+    F_2109 = ("fault_2109", 2109)
+    F_2110 = ("fault_2110", 2110)
+    F_2111 = ("fault_2111", 2111)
+    F_2112 = ("fault_2112", 2112)
+    F_2113 = ("fault_2113", 2113)
+    F_2114 = ("fault_2114", 2114)
+    F_2115 = ("fault_2115", 2115)
+
+
+@dataclass
+class B01Props(RoborockBase):
+    """
+    Represents the complete properties and status for a Roborock B01 model.
+    This dataclass is generated based on the device's status JSON object.
+    """
+
+    status: WorkStatusMapping
+    fault: B01Fault
+    wind: SCWindMapping
+    water: int
+    mode: int
+    quantity: int
+    alarm: int
+    volume: int
+    hypa: int
+    main_brush: int
+    side_brush: int
+    mop_life: int
+    main_sensor: int
+    net_status: NetStatus
+    repeat_state: int
+    tank_state: int
+    sweep_type: int
+    clean_path_preference: int
+    cloth_state: int
+    time_zone: int
+    time_zone_info: str
+    language: int
+    cleaning_time: int
+    real_clean_time: int
+    cleaning_area: int
+    custom_type: int
+    sound: int
+    work_mode: WorkModeMapping
+    station_act: int
+    charge_state: int
+    current_map_id: int
+    map_num: int
+    dust_action: int
+    quiet_is_open: int
+    quiet_begin_time: int
+    quiet_end_time: int
+    clean_finish: int
+    voice_type: int
+    voice_type_version: int
+    order_total: OrderTotal
+    build_map: int
+    privacy: Privacy
+    dust_auto_state: int
+    dust_frequency: int
+    child_lock: int
+    multi_floor: int
+    map_save: int
+    light_mode: int
+    green_laser: int
+    dust_bag_used: int
+    order_save_mode: int
+    manufacturer: str
+    back_to_wash: int
+    charge_station_type: int
+    pv_cut_charge: int
+    pv_charging: PvCharging
+    serial_number: str
+    recommend: Recommend
+    add_sweep_status: int

python_roborock-2.39.0/roborock/callbacks.py

@@ -0,0 +1,126 @@
+"""Module for managing callback utility functions."""
+
+import logging
+from collections.abc import Callable
+from typing import Generic, TypeVar
+
+_LOGGER = logging.getLogger(__name__)
+
+K = TypeVar("K")
+V = TypeVar("V")
+
+
+def safe_callback(callback: Callable[[V], None], logger: logging.Logger | None = None) -> Callable[[V], None]:
+    """Wrap a callback to catch and log exceptions.
+
+    This is useful for ensuring that errors in callbacks do not propagate
+    and cause unexpected behavior. Any failures during callback execution will be logged.
+    """
+
+    if logger is None:
+        logger = _LOGGER
+
+    def wrapper(value: V) -> None:
+        try:
+            callback(value)
+        except Exception as ex:  # noqa: BLE001
+            logger.error("Uncaught error in callback '%s': %s", callback.__name__, ex)
+
+    return wrapper
+
+
+class CallbackMap(Generic[K, V]):
+    """A mapping of callbacks for specific keys.
+
+    This allows for registering multiple callbacks for different keys and invoking them
+    when a value is received for a specific key.
+    """
+
+    def __init__(self, logger: logging.Logger | None = None) -> None:
+        self._callbacks: dict[K, list[Callable[[V], None]]] = {}
+        self._logger = logger or _LOGGER
+
+    def keys(self) -> list[K]:
+        """Get all keys in the callback map."""
+        return list(self._callbacks.keys())
+
+    def add_callback(self, key: K, callback: Callable[[V], None]) -> Callable[[], None]:
+        """Add a callback for a specific key.
+
+        Any failures during callback execution will be logged.
+
+        Returns a callable that can be used to remove the callback.
+        """
+        self._callbacks.setdefault(key, []).append(callback)
+
+        def remove_callback() -> None:
+            """Remove the callback for the specific key."""
+            if cb_list := self._callbacks.get(key):
+                cb_list.remove(callback)
+                if not cb_list:
+                    del self._callbacks[key]
+
+        return remove_callback
+
+    def get_callbacks(self, key: K) -> list[Callable[[V], None]]:
+        """Get all callbacks for a specific key."""
+        return self._callbacks.get(key, [])
+
+    def __call__(self, key: K, value: V) -> None:
+        """Invoke all callbacks for a specific key."""
+        for callback in self.get_callbacks(key):
+            safe_callback(callback, self._logger)(value)
+
+
+class CallbackList(Generic[V]):
+    """A list of callbacks that can be invoked.
+
+    This combines a list of callbacks into a single callable. Callers can add
+    additional callbacks to the list at any time.
+    """
+
+    def __init__(self, logger: logging.Logger | None = None) -> None:
+        self._callbacks: list[Callable[[V], None]] = []
+        self._logger = logger or _LOGGER
+
+    def add_callback(self, callback: Callable[[V], None]) -> Callable[[], None]:
+        """Add a callback to the list.
+
+        Any failures during callback execution will be logged.
+
+        Returns a callable that can be used to remove the callback.
+        """
+        self._callbacks.append(callback)
+
+        return lambda: self._callbacks.remove(callback)
+
+    def __call__(self, value: V) -> None:
+        """Invoke all callbacks in the list."""
+        for callback in self._callbacks:
+            safe_callback(callback, self._logger)(value)
+
+
+def decoder_callback(
+    decoder: Callable[[K], list[V]], callback: Callable[[V], None], logger: logging.Logger | None = None
+) -> Callable[[K], None]:
+    """Create a callback that decodes messages using a decoder and invokes a callback.
+
+    The decoder converts a value into a list of values. The callback is then invoked
+    for each value in the list.
+
+    Any failures during decoding or invoking the callbacks will be logged.
+    """
+    if logger is None:
+        logger = _LOGGER
+
+    safe_cb = safe_callback(callback, logger)
+
+    def wrapper(data: K) -> None:
+        if not (messages := decoder(data)):
+            logger.warning("Failed to decode message: %s", data)
+            return
+        for message in messages:
+            _LOGGER.debug("Decoded message: %s", message)
+            safe_cb(message)
+
+    return wrapper

{python_roborock-2.37.0 → python_roborock-2.39.0}/roborock/clean_modes.py

@@ -1,21 +1,8 @@
 from __future__ import annotations
 
-from enum import StrEnum
-
 from roborock import DeviceFeatures
 
-
-class RoborockModeEnum(StrEnum):
-    """A custom StrEnum that also stores an integer code for each member."""
-
-    code: int
-
-    def __new__(cls, value: str, code: int) -> RoborockModeEnum:
-        """Creates a new enum member."""
-        member = str.__new__(cls, value)
-        member._value_ = value
-        member.code = code
-        return member
+from .code_mappings import RoborockModeEnum
 
 
 class CleanModes(RoborockModeEnum):

{python_roborock-2.37.0 → python_roborock-2.39.0}/roborock/cli.py

@@ -1,16 +1,17 @@
 import asyncio
 import json
 import logging
-from dataclasses import dataclass
+from dataclasses import asdict, dataclass
 from pathlib import Path
 from typing import Any
 
 import click
+import yaml
 from pyshark import FileCapture  # type: ignore
 from pyshark.capture.live_capture import LiveCapture, UnknownInterfaceException  # type: ignore
 from pyshark.packet.packet import Packet  # type: ignore
 
-from roborock import RoborockException
+from roborock import SHORT_MODEL_TO_ENUM, DeviceFeatures, RoborockCommand, RoborockException
 from roborock.containers import DeviceData, HomeData, HomeDataProduct, LoginData, NetworkInfo, RoborockBase, UserData
 from roborock.devices.cache import Cache, CacheData
 from roborock.devices.device_manager import create_device_manager, create_home_data_api
@@ -325,6 +326,159 @@ async def parser(_, local_key, device_ip, file):
         )
 
 
+@click.command()
+@click.pass_context
+@run_sync()
+async def get_device_info(ctx: click.Context):
+    """
+    Connects to devices and prints their feature information in YAML format.
+    """
+    click.echo("Discovering devices...")
+    context: RoborockContext = await _load_and_discover(ctx)
+    cache_data = context.cache_data()
+
+    home_data = cache_data.home_data
+
+    all_devices = home_data.devices + home_data.received_devices
+    if not all_devices:
+        click.echo("No devices found.")
+        return
+
+    click.echo(f"Found {len(all_devices)} devices. Fetching data...")
+
+    all_products_data = {}
+
+    for device in all_devices:
+        click.echo(f"  - Processing {device.name} ({device.duid})")
+        product_info = home_data.product_map[device.product_id]
+        device_data = DeviceData(device, product_info.model)
+        mqtt_client = RoborockMqttClientV1(cache_data.user_data, device_data)
+
+        try:
+            init_status_result = await mqtt_client.send_command(
+                RoborockCommand.APP_GET_INIT_STATUS,
+            )
+            product_nickname = SHORT_MODEL_TO_ENUM.get(product_info.model.split(".")[-1]).name
+            current_product_data = {
+                "Protocol Version": device.pv,
+                "Product Nickname": product_nickname,
+                "New Feature Info": init_status_result.get("new_feature_info"),
+                "New Feature Info Str": init_status_result.get("new_feature_info_str"),
+                "Feature Info": init_status_result.get("feature_info"),
+            }
+
+            all_products_data[product_info.model] = current_product_data
+
+        except Exception as e:
+            click.echo(f"    - Error processing device {device.name}: {e}", err=True)
+        finally:
+            await mqtt_client.async_release()
+
+    if all_products_data:
+        click.echo("\n--- Device Information (copy to your YAML file) ---\n")
+        # Use yaml.dump to print in a clean, copy-paste friendly format
+        click.echo(yaml.dump(all_products_data, sort_keys=False))
+
+
+@click.command()
+@click.option("--data-file", default="../device_info.yaml", help="Path to the YAML file with device feature data.")
+@click.option("--output-file", default="../SUPPORTED_FEATURES.md", help="Path to the output markdown file.")
+def update_docs(data_file: str, output_file: str):
+    """
+    Generates a markdown file by processing raw feature data from a YAML file.
+    """
+    data_path = Path(data_file)
+    output_path = Path(output_file)
+
+    if not data_path.exists():
+        click.echo(f"Error: Data file not found at '{data_path}'", err=True)
+        return
+
+    click.echo(f"Loading data from {data_path}...")
+    with open(data_path, encoding="utf-8") as f:
+        product_data_from_yaml = yaml.safe_load(f)
+
+    if not product_data_from_yaml:
+        click.echo("No data found in YAML file. Exiting.", err=True)
+        return
+
+    product_features_map = {}
+    all_feature_names = set()
+
+    # Process the raw data from YAML to build the feature map
+    for model, data in product_data_from_yaml.items():
+        # Reconstruct the DeviceFeatures object from the raw data in the YAML file
+        device_features = DeviceFeatures.from_feature_flags(
+            new_feature_info=data.get("New Feature Info"),
+            new_feature_info_str=data.get("New Feature Info Str"),
+            feature_info=data.get("Feature Info"),
+            product_nickname=data.get("Product Nickname"),
+        )
+        features_dict = asdict(device_features)
+
+        # This dictionary will hold the final data for the markdown table row
+        current_product_data = {
+            "Product Nickname": data.get("Product Nickname", ""),
+            "Protocol Version": data.get("Protocol Version", ""),
+            "New Feature Info": data.get("New Feature Info", ""),
+            "New Feature Info Str": data.get("New Feature Info Str", ""),
+        }
+
+        # Populate features from the calculated DeviceFeatures object
+        for feature, is_supported in features_dict.items():
+            all_feature_names.add(feature)
+            if is_supported:
+                current_product_data[feature] = "X"
+
+        supported_codes = data.get("Feature Info", [])
+        if isinstance(supported_codes, list):
+            for code in supported_codes:
+                feature_name = str(code)
+                all_feature_names.add(feature_name)
+                current_product_data[feature_name] = "X"
+
+        product_features_map[model] = current_product_data
+
+    # --- Helper function to write the markdown table ---
+    def write_markdown_table(product_features: dict[str, dict[str, any]], all_features: set[str]):
+        """Writes the data into a markdown table (products as columns)."""
+        sorted_products = sorted(product_features.keys())
+        special_rows = [
+            "Product Nickname",
+            "Protocol Version",
+            "New Feature Info",
+            "New Feature Info Str",
+        ]
+        # Regular features are the remaining keys, sorted alphabetically
+        # We filter out the special rows to avoid duplicating them.
+        sorted_features = sorted(list(all_features - set(special_rows)))
+
+        header = ["Feature"] + sorted_products
+
+        click.echo(f"Writing documentation to {output_path}...")
+        with open(output_path, "w", encoding="utf-8") as f:
+            f.write("| " + " | ".join(header) + " |\n")
+            f.write("|" + "---|" * len(header) + "\n")
+
+            # Write the special metadata rows first
+            for row_name in special_rows:
+                row_values = [str(product_features[p].get(row_name, "")) for p in sorted_products]
+                f.write("| " + " | ".join([row_name] + row_values) + " |\n")
+
+            # Write the feature rows
+            for feature in sorted_features:
+                # Use backticks for feature names that are just numbers (from the list)
+                display_feature = f"`{feature}`"
+                feature_row = [display_feature]
+                for product in sorted_products:
+                    # Use .get() to place an 'X' or an empty string
+                    feature_row.append(product_features[product].get(feature, ""))
+                f.write("| " + " | ".join(feature_row) + " |\n")
+
+    write_markdown_table(product_features_map, all_feature_names)
+    click.echo("Done.")
+
+
 cli.add_command(login)
 cli.add_command(discover)
 cli.add_command(list_devices)
@@ -334,6 +488,8 @@ cli.add_command(status)
 cli.add_command(command)
 cli.add_command(parser)
 cli.add_command(session)
+cli.add_command(get_device_info)
+cli.add_command(update_docs)
 
 
 def main():

{python_roborock-2.37.0 → python_roborock-2.39.0}/roborock/code_mappings.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import logging
 from collections import namedtuple
-from enum import Enum, IntEnum
+from enum import Enum, IntEnum, StrEnum
 
 _LOGGER = logging.getLogger(__name__)
 completed_warnings = set()
@@ -51,6 +51,26 @@ class RoborockEnum(IntEnum):
         return cls.as_dict().items()
 
 
+class RoborockModeEnum(StrEnum):
+    """A custom StrEnum that also stores an integer code for each member."""
+
+    code: int
+
+    def __new__(cls, value: str, code: int) -> RoborockModeEnum:
+        """Creates a new enum member."""
+        member = str.__new__(cls, value)
+        member._value_ = value
+        member.code = code
+        return member
+
+    @classmethod
+    def from_code(cls, code: int):
+        for member in cls:
+            if member.code == code:
+                return member
+        raise ValueError(f"{code} is not a valid code for {cls.__name__}")
+
+
 ProductInfo = namedtuple("ProductInfo", ["nickname", "short_models"])
 
 

{python_roborock-2.37.0 → python_roborock-2.39.0}/roborock/containers.py

@@ -33,6 +33,7 @@ from .code_mappings import (
     RoborockFanSpeedSaros10R,
     RoborockFinishReason,
     RoborockInCleaning,
+    RoborockModeEnum,
     RoborockMopIntensityCode,
     RoborockMopIntensityP10,
     RoborockMopIntensityQ7Max,
@@ -120,6 +121,8 @@ class RoborockBase:
             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 issubclass(class_type, RoborockModeEnum):
+            return class_type.from_code(value)
         if class_type is Any:
             return value
         return class_type(value)  # type: ignore[call-arg]

{python_roborock-2.37.0 → python_roborock-2.39.0}/roborock/device_features.py

@@ -4,7 +4,7 @@ from dataclasses import dataclass, field, fields
 from enum import IntEnum, StrEnum
 from typing import Any
 
-from roborock import RoborockProductNickname
+from .code_mappings import RoborockProductNickname
 
 
 class NewFeatureStrBit(IntEnum):

{python_roborock-2.37.0 → python_roborock-2.39.0}/roborock/devices/device_manager.py

@@ -162,8 +162,8 @@ async def create_device_manager(
                     case _:
                         raise NotImplementedError(f"Device {device.name} has unsupported category {product.category}")
             case DeviceVersion.B01:
-                mqtt_channel = create_mqtt_channel(user_data, mqtt_params, mqtt_session, device)
-                traits.append(B01PropsApi(mqtt_channel))
+                channel = create_mqtt_channel(user_data, mqtt_params, mqtt_session, device)
+                traits.append(B01PropsApi(channel))
             case _:
                 raise NotImplementedError(f"Device {device.name} has unsupported version {device.pv}")
         return RoborockDevice(device, channel, traits)

{python_roborock-2.37.0 → python_roborock-2.39.0}/roborock/devices/local_channel.py

@@ -5,6 +5,7 @@ import logging
 from collections.abc import Callable
 from dataclasses import dataclass
 
+from roborock.callbacks import CallbackList, decoder_callback
 from roborock.exceptions import RoborockConnectionException, RoborockException
 from roborock.protocol import Decoder, Encoder, create_local_decoder, create_local_encoder
 from roborock.roborock_message import RoborockMessage
@@ -42,11 +43,13 @@ class LocalChannel(Channel):
         self._host = host
         self._transport: asyncio.Transport | None = None
         self._protocol: _LocalProtocol | None = None
-        self._subscribers: list[Callable[[RoborockMessage], None]] = []
+        self._subscribers: CallbackList[RoborockMessage] = CallbackList(_LOGGER)
         self._is_connected = False
 
         self._decoder: Decoder = create_local_decoder(local_key)
         self._encoder: Encoder = create_local_encoder(local_key)
+        # Callback to decode messages and dispatch to subscribers
+        self._data_received: Callable[[bytes], None] = decoder_callback(self._decoder, self._subscribers, _LOGGER)
 
     @property
     def is_connected(self) -> bool:
@@ -76,19 +79,6 @@ class LocalChannel(Channel):
         self._transport = None
         self._is_connected = False
 
-    def _data_received(self, data: bytes) -> None:
-        """Handle incoming data from the transport."""
-        if not (messages := self._decoder(data)):
-            _LOGGER.warning("Failed to decode local message: %s", data)
-            return
-        for message in messages:
-            _LOGGER.debug("Received message: %s", message)
-            for callback in self._subscribers:
-                try:
-                    callback(message)
-                except Exception as e:
-                    _LOGGER.exception("Uncaught error in message handler callback: %s", e)
-
     def _connection_lost(self, exc: Exception | None) -> None:
         """Handle connection loss."""
         _LOGGER.warning("Connection lost to %s", self._host, exc_info=exc)
@@ -97,12 +87,7 @@ class LocalChannel(Channel):
 
     async def subscribe(self, callback: Callable[[RoborockMessage], None]) -> Callable[[], None]:
         """Subscribe to all messages from the device."""
-        self._subscribers.append(callback)
-
-        def unsubscribe() -> None:
-            self._subscribers.remove(callback)
-
-        return unsubscribe
+        return self._subscribers.add_callback(callback)
 
     async def publish(self, message: RoborockMessage) -> None:
         """Send a command message.

{python_roborock-2.37.0 → python_roborock-2.39.0}/roborock/devices/mqtt_channel.py

@@ -3,6 +3,7 @@
 import logging
 from collections.abc import Callable
 
+from roborock.callbacks import decoder_callback
 from roborock.containers import HomeDataDevice, RRiot, UserData
 from roborock.exceptions import RoborockException
 from roborock.mqtt.session import MqttParams, MqttSession, MqttSessionException
@@ -56,19 +57,8 @@ class MqttChannel(Channel):
 
         Returns a callable that can be used to unsubscribe from the topic.
         """
-
-        def message_handler(payload: bytes) -> None:
-            if not (messages := self._decoder(payload)):
-                _LOGGER.warning("Failed to decode MQTT message: %s", payload)
-                return
-            for message in messages:
-                _LOGGER.debug("Received message: %s", message)
-                try:
-                    callback(message)
-                except Exception as e:
-                    _LOGGER.exception("Uncaught error in message handler callback: %s", e)
-
-        return await self._mqtt_session.subscribe(self._subscribe_topic, message_handler)
+        dispatch = decoder_callback(self._decoder, callback, _LOGGER)
+        return await self._mqtt_session.subscribe(self._subscribe_topic, dispatch)
 
     async def publish(self, message: RoborockMessage) -> None:
         """Publish a command message.

{python_roborock-2.37.0 → python_roborock-2.39.0}/roborock/devices/traits/b01/props.py

@@ -27,4 +27,6 @@ class B01PropsApi(Trait):
 
     async def query_values(self, props: list[RoborockB01Props]) -> None:
         """Query the device for the values of the given Dyad protocols."""
-        await send_decoded_command(self._channel, dps=10000, command=RoborockB01Methods.GET_PROP, params=props)
+        await send_decoded_command(
+            self._channel, dps=10000, command=RoborockB01Methods.GET_PROP, params={"property": props}
+        )

{python_roborock-2.37.0 → python_roborock-2.39.0}/roborock/mqtt/roborock_session.py

@@ -17,6 +17,8 @@ from contextlib import asynccontextmanager
 import aiomqtt
 from aiomqtt import MqttError, TLSParameters
 
+from roborock.callbacks import CallbackMap
+
 from .session import MqttParams, MqttSession, MqttSessionException
 
 _LOGGER = logging.getLogger(__name__)
@@ -53,7 +55,7 @@ class RoborockMqttSession(MqttSession):
         self._backoff = MIN_BACKOFF_INTERVAL
         self._client: aiomqtt.Client | None = None
         self._client_lock = asyncio.Lock()
-        self._listeners: dict[str, list[Callable[[bytes], None]]] = {}
+        self._listeners: CallbackMap[str, bytes] = CallbackMap(_LOGGER)
 
     @property
     def connected(self) -> bool:
@@ -164,7 +166,7 @@ class RoborockMqttSession(MqttSession):
                 # Re-establish any existing subscriptions
                 async with self._client_lock:
                     self._client = client
-                    for topic in self._listeners:
+                    for topic in self._listeners.keys():
                         _LOGGER.debug("Re-establishing subscription to topic %s", topic)
                         # TODO: If this fails it will break the whole connection. Make
                         # this retry again in the background with backoff.
@@ -179,13 +181,7 @@ class RoborockMqttSession(MqttSession):
         _LOGGER.debug("Processing MQTT messages")
         async for message in client.messages:
             _LOGGER.debug("Received message: %s", message)
-            for listener in self._listeners.get(message.topic.value, []):
-                try:
-                    listener(message.payload)
-                except asyncio.CancelledError:
-                    raise
-                except Exception as e:
-                    _LOGGER.exception("Uncaught exception in subscriber callback: %s", e)
+            self._listeners(message.topic.value, message.payload)
 
     async def subscribe(self, topic: str, callback: Callable[[bytes], None]) -> Callable[[], None]:
         """Subscribe to messages on the specified topic and invoke the callback for new messages.
@@ -196,9 +192,7 @@ class RoborockMqttSession(MqttSession):
         The returned callable unsubscribes from the topic when called.
         """
         _LOGGER.debug("Subscribing to topic %s", topic)
-        if topic not in self._listeners:
-            self._listeners[topic] = []
-        self._listeners[topic].append(callback)
+        unsub = self._listeners.add_callback(topic, callback)
 
         async with self._client_lock:
             if self._client:
@@ -210,7 +204,7 @@ class RoborockMqttSession(MqttSession):
             else:
                 _LOGGER.debug("Client not connected, will establish subscription later")
 
-        return lambda: self._listeners[topic].remove(callback)
+        return unsub
 
     async def publish(self, topic: str, message: bytes) -> None:
         """Publish a message on the topic."""

{python_roborock-2.37.0 → python_roborock-2.39.0}/roborock/protocols/b01_protocol.py

@@ -13,6 +13,7 @@ from roborock.roborock_message import (
     RoborockMessage,
     RoborockMessageProtocol,
 )
+from roborock.util import get_next_int
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -23,7 +24,15 @@ ParamsType = list | dict | int | None
 
 def encode_mqtt_payload(dps: int, command: CommandType, params: ParamsType) -> RoborockMessage:
     """Encode payload for B01 commands over MQTT."""
-    dps_data = {"dps": {dps: {"method": command, "params": params or []}}}
+    dps_data = {
+        "dps": {
+            dps: {
+                "method": str(command),
+                "msgId": str(get_next_int(100000000000, 999999999999)),
+                "params": params or [],
+            }
+        }
+    }
     payload = pad(json.dumps(dps_data).encode("utf-8"), AES.block_size)
     return RoborockMessage(
         protocol=RoborockMessageProtocol.RPC_REQUEST,