python-roborock 5.27.0__tar.gz → 5.28.1__tar.gz

{python_roborock-5.27.0 → python_roborock-5.28.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-roborock
-Version: 5.27.0
+Version: 5.28.1
 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.27.0 → python_roborock-5.28.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-roborock"
-version = "5.27.0"
+version = "5.28.1"
 description = "A package to control Roborock vacuums."
 authors = [{ name = "humbertogontijo", email = "humbertogontijo@users.noreply.github.com" }, {name="Lash-L"}, {name="allenporter"}]
 requires-python = ">=3.11, <4"

{python_roborock-5.27.0 → python_roborock-5.28.1}/roborock/data/v1/v1_code_mappings.py

@@ -650,22 +650,32 @@ class RoborockDockErrorCode(RoborockEnum):
 
 class RoborockDockTypeCode(RoborockEnum):
     unknown = -9999
-    no_dock = 0
-    auto_empty_dock = 1
-    empty_wash_fill_dock = 3
-    auto_empty_dock_pure = 5
-    s7_max_ultra_dock = 6
-    s8_dock = 7
-    p10_dock = 8
-    p10_pro_dock = 9
-    s8_maxv_ultra_dock = 10
-    qrevo_master_dock = 14
-    qrevo_s_dock = 15
-    saros_r10_dock = 16
-    qrevo_curv_dock = 17
-    saros_10_dock = 18
-    qrevo_s5v_dock = 22
-    saros_20_dock = 27
+    o0_dock = 0
+    o1_dock = 1
+    o2_dock = 2
+    o3_dock = 3
+    oc_dock = 5
+    o3_plus_dock = 6
+    o4_dock = 7
+    pearl_dock = 8
+    pearl_plus_dock = 9
+    o5_dock = 10
+    shell_2s_dock = 11
+    couple_dock = 13
+    shell_3_dock = 14
+    shell_2c_dock = 15
+    shell_3s_dock = 16
+    k1_dock = 17
+    o6_dock = 18
+    k1c_dock = 19
+    k1s_dock = 20
+    shell_e_dock = 21
+    shell_2e_dock = 22
+    shell_3c_dock = 23
+    type_27_dock = 27
+    k1c_lite_dock = 28
+    shell_2e_lite_dock = 30
+    shell_2e_heat_dock = 40
 
 
 class RoborockDockDustCollectionModeCode(RoborockEnum):

{python_roborock-5.27.0 → python_roborock-5.28.1}/roborock/data/v1/v1_containers.py

@@ -239,6 +239,12 @@ class Status(RoborockBase):
                 return map_flag
         return None
 
+    @property
+    def has_am(self) -> bool | None:
+        if self.dss is None:
+            return None
+        return (self.dss & 3) == 2
+
     @property
     def clear_water_box_status(self) -> ClearWaterBoxStatus | None:
         if self.dss:
@@ -376,6 +382,12 @@ class StatusV2(RoborockBase):
                 return map_flag
         return None
 
+    @property
+    def has_am(self) -> bool | None:
+        if self.dss is None:
+            return None
+        return (self.dss & 3) == 2
+
     @property
     def clear_water_box_status(self) -> ClearWaterBoxStatus | None:
         if self.dss:

{python_roborock-5.27.0 → python_roborock-5.28.1}/roborock/device_features.py

@@ -1,5 +1,6 @@
 from dataclasses import dataclass, field, fields
 from enum import IntEnum, StrEnum
+from functools import cache
 from typing import Any, Self
 
 from roborock.data.code_mappings import RoborockProductNickname
@@ -644,25 +645,221 @@ class DeviceFeatures(RoborockBase):
         return [k for k, v in vars(self).items() if v]
 
 
+_NO_DOCK_TYPES = {
+    RoborockDockTypeCode.unknown,
+    RoborockDockTypeCode.o0_dock,
+}
+
+_PURE_COLLECT_DOCK_TYPES = {
+    RoborockDockTypeCode.o1_dock,
+    RoborockDockTypeCode.oc_dock,
+}
+
+_PURE_WASH_DOCK_TYPES = {
+    RoborockDockTypeCode.o2_dock,
+}
+
+_COLLECT_WASH_DOCK_TYPES = {
+    RoborockDockTypeCode.o3_dock,
+}
+
+_ONLY_X_SERIES_DOCK_TYPES = {
+    RoborockDockTypeCode.o2_dock,
+    RoborockDockTypeCode.o3_dock,
+    RoborockDockTypeCode.o3_plus_dock,
+    RoborockDockTypeCode.o4_dock,
+    RoborockDockTypeCode.o5_dock,
+    RoborockDockTypeCode.o6_dock,
+}
+
+_CLEAN_FLUID_AUTO_DELIVERY_DOCK_TYPES = {
+    RoborockDockTypeCode.o4_dock,
+    RoborockDockTypeCode.o5_dock,
+    RoborockDockTypeCode.pearl_plus_dock,
+    RoborockDockTypeCode.shell_3s_dock,
+    RoborockDockTypeCode.o6_dock,
+    RoborockDockTypeCode.couple_dock,
+}
+
+_CLEAN_FLUID_AUTO_DELIVERY_AM_DOCK_TYPES = {
+    RoborockDockTypeCode.shell_2s_dock,
+    RoborockDockTypeCode.shell_3_dock,
+    RoborockDockTypeCode.shell_2c_dock,
+    RoborockDockTypeCode.k1_dock,
+    RoborockDockTypeCode.k1s_dock,
+    RoborockDockTypeCode.shell_e_dock,
+    RoborockDockTypeCode.shell_2e_dock,
+    RoborockDockTypeCode.shell_3c_dock,
+}
+
+_AUTO_STERILIZE_DOCK_TYPES = {
+    RoborockDockTypeCode.shell_3s_dock,
+}
+
+_INNER_CHARGE_HEAD_DOCK_TYPES = {
+    RoborockDockTypeCode.o0_dock,
+    RoborockDockTypeCode.o1_dock,
+    RoborockDockTypeCode.oc_dock,
+    RoborockDockTypeCode.o2_dock,
+    RoborockDockTypeCode.o3_dock,
+    RoborockDockTypeCode.o3_plus_dock,
+    RoborockDockTypeCode.o4_dock,
+}
+
+_DUST_BUCKET_DOCK_TYPES = {
+    RoborockDockTypeCode.o3_dock,
+    RoborockDockTypeCode.o3_plus_dock,
+    RoborockDockTypeCode.o4_dock,
+}
+
+_CLEAN_CAROUSEL_SELF_CLEAN_DOCK_TYPES = {
+    RoborockDockTypeCode.shell_3_dock,
+    RoborockDockTypeCode.k1_dock,
+    RoborockDockTypeCode.couple_dock,
+    RoborockDockTypeCode.shell_3s_dock,
+    RoborockDockTypeCode.k1s_dock,
+    RoborockDockTypeCode.shell_3c_dock,
+}
+
+_WATER_UPDOWN_DRAIN_DOCK_TYPES = {
+    RoborockDockTypeCode.o4_dock,
+    RoborockDockTypeCode.pearl_plus_dock,
+    RoborockDockTypeCode.couple_dock,
+}
+
+_WATER_UPDOWN_DRAIN_AM_DOCK_TYPES = {
+    RoborockDockTypeCode.o5_dock,
+    RoborockDockTypeCode.shell_2s_dock,
+    RoborockDockTypeCode.shell_3_dock,
+    RoborockDockTypeCode.shell_2c_dock,
+    RoborockDockTypeCode.shell_3s_dock,
+    RoborockDockTypeCode.k1_dock,
+    RoborockDockTypeCode.k1s_dock,
+    RoborockDockTypeCode.o6_dock,
+    RoborockDockTypeCode.shell_e_dock,
+    RoborockDockTypeCode.shell_2e_dock,
+    RoborockDockTypeCode.shell_3c_dock,
+}
+
+_HATCH_DOOR_DOCK_COOL_FAN_DOCK_TYPES = {
+    RoborockDockTypeCode.couple_dock,
+}
+
+_SPECIAL_WASH_TEMP_DOCK_TYPES = {
+    RoborockDockTypeCode.shell_2e_lite_dock,
+}
+
+
+@dataclass(frozen=True)
+class RoborockDockFeatures:
+    """Capabilities derived from a V1 dock type.
+
+    This mirrors the Roborock app's DK capability model: feature availability
+    should be attached to the dock family instead of repeated per trait.
+    """
+
+    dock_type: RoborockDockTypeCode
+    has_am: bool | None = None
+
+    @classmethod
+    @cache
+    def from_dock_type(cls, dock_type: RoborockDockTypeCode | None, has_am: bool | None = None) -> Self:
+        """Return cached capabilities for a V1 dock type."""
+        return cls(dock_type or RoborockDockTypeCode.o0_dock, has_am=has_am)
+
+    def _matches_am_variant(self, dock_types: set[RoborockDockTypeCode]) -> bool:
+        return self.has_am is True and self.dock_type in dock_types
+
+    def _matches_non_am_variant(self, dock_types: set[RoborockDockTypeCode]) -> bool:
+        return self.has_am is not True and self.dock_type in dock_types
+
+    @property
+    def has_dock(self) -> bool:
+        return self.dock_type not in _NO_DOCK_TYPES
+
+    @property
+    def is_pure_collect(self) -> bool:
+        return self.dock_type in _PURE_COLLECT_DOCK_TYPES
+
+    @property
+    def is_pure_wash(self) -> bool:
+        return self.dock_type in _PURE_WASH_DOCK_TYPES
+
+    @property
+    def is_collect_wash(self) -> bool:
+        return self.dock_type in _COLLECT_WASH_DOCK_TYPES
+
+    @property
+    def is_collect_wash_dry(self) -> bool:
+        return self.has_dock and not (self.is_pure_collect or self.is_pure_wash or self.is_collect_wash)
+
+    @property
+    def is_collectable(self) -> bool:
+        return self.is_collect_wash or self.is_collect_wash_dry or self.is_pure_collect
+
+    @property
+    def is_washable(self) -> bool:
+        return self.is_pure_wash or self.is_collect_wash or self.is_collect_wash_dry
+
+    @property
+    def is_dryable(self) -> bool:
+        return self.is_collect_wash_dry
+
+    @property
+    def is_only_x_series(self) -> bool:
+        return self.dock_type in _ONLY_X_SERIES_DOCK_TYPES
+
+    @property
+    def is_cleaning_brush_supported(self) -> bool:
+        return self.is_only_x_series
+
+    @property
+    def is_clean_fluid_auto_delivery_supported(self) -> bool:
+        return self.dock_type in _CLEAN_FLUID_AUTO_DELIVERY_DOCK_TYPES or self._matches_am_variant(
+            _CLEAN_FLUID_AUTO_DELIVERY_AM_DOCK_TYPES
+        )
+
+    @property
+    def is_auto_sterilize_supported(self) -> bool:
+        return self.dock_type in _AUTO_STERILIZE_DOCK_TYPES
+
+    @property
+    def is_inner_charge_head(self) -> bool:
+        return self.dock_type in _INNER_CHARGE_HEAD_DOCK_TYPES
+
+    @property
+    def is_dust_bucket_supported(self) -> bool:
+        return self.dock_type in _DUST_BUCKET_DOCK_TYPES
+
+    @property
+    def is_clean_carousel_self_clean_supported(self) -> bool:
+        return self._matches_non_am_variant(_CLEAN_CAROUSEL_SELF_CLEAN_DOCK_TYPES)
+
+    @property
+    def is_water_updown_drain_supported(self) -> bool:
+        return self.dock_type in _WATER_UPDOWN_DRAIN_DOCK_TYPES or self._matches_am_variant(
+            _WATER_UPDOWN_DRAIN_AM_DOCK_TYPES
+        )
+
+    @property
+    def is_hatch_door_dock_cool_fan_supported(self) -> bool:
+        return self.dock_type in _HATCH_DOOR_DOCK_COOL_FAN_DOCK_TYPES
+
+    @property
+    def is_special_support_wash_temp(self) -> bool:
+        return self.dock_type in _SPECIAL_WASH_TEMP_DOCK_TYPES
+
+
 WASH_N_FILL_DOCK_TYPES = [
-    RoborockDockTypeCode.empty_wash_fill_dock,
-    RoborockDockTypeCode.s8_dock,
-    RoborockDockTypeCode.p10_dock,
-    RoborockDockTypeCode.p10_pro_dock,
-    RoborockDockTypeCode.s8_maxv_ultra_dock,
-    RoborockDockTypeCode.qrevo_s_dock,
-    RoborockDockTypeCode.saros_r10_dock,
-    RoborockDockTypeCode.qrevo_curv_dock,
-    RoborockDockTypeCode.qrevo_s5v_dock,
-    RoborockDockTypeCode.saros_20_dock,
+    dock_type for dock_type in RoborockDockTypeCode if RoborockDockFeatures.from_dock_type(dock_type).is_washable
 ]
 
 
 def is_wash_n_fill_dock(dock_type: RoborockDockTypeCode) -> bool:
     """Check if the dock type is a wash and fill dock."""
-    return dock_type in WASH_N_FILL_DOCK_TYPES
+    return RoborockDockFeatures.from_dock_type(dock_type).is_washable
 
 
 def is_valid_dock(dock_type: RoborockDockTypeCode) -> bool:
     """Check if device supports a dock."""
-    return dock_type != RoborockDockTypeCode.no_dock
+    return RoborockDockFeatures.from_dock_type(dock_type).has_dock

{python_roborock-5.27.0 → python_roborock-5.28.1}/roborock/devices/traits/v1/__init__.py

@@ -42,8 +42,8 @@ optional traits:
     - `requires_feature` - The string name of the device feature that must be supported
         for this trait to be enabled. See `DeviceFeaturesTrait` for a list of
         available features.
-    - `requires_dock_type` - If set, this is a function that accepts a `RoborockDockTypeCode`
-        and returns a boolean indicating whether the trait is supported for that dock type.
+    - `requires_dock_features` - If set, this is a function that accepts a `RoborockDockFeatures`
+        and returns a boolean indicating whether the trait is supported for that dock.
 
 Additionally, DeviceFeaturesTrait has a method `is_field_supported` that is used to
 check individual trait field values. This is a more fine grained version to allow
@@ -59,6 +59,7 @@ from typing import Any, get_args
 
 from roborock.data.containers import HomeData, HomeDataProduct, RoborockBase
 from roborock.data.v1.v1_code_mappings import RoborockDockTypeCode
+from roborock.device_features import RoborockDockFeatures
 from roborock.devices.cache import DeviceCache
 from roborock.devices.traits import Trait
 from roborock.exceptions import RoborockException
@@ -262,9 +263,10 @@ class PropertiesApi(Trait):
         await self.device_features.refresh()
         # Dock type also acts like a device feature for some traits.
         dock_type = await self._dock_type()
+        dock_features = RoborockDockFeatures.from_dock_type(dock_type, has_am=self.status.has_am)
 
         # Initialize traits with special arguments before the generic loop
-        if self.wash_towel_mode is None and self._is_supported(WashTowelModeTrait, "wash_towel_mode", dock_type):
+        if self.wash_towel_mode is None and self._is_supported(WashTowelModeTrait, "wash_towel_mode", dock_features):
             wash_towel_mode = WashTowelModeTrait(self.device_features)
             wash_towel_mode._rpc_channel = self._get_rpc_channel(wash_towel_mode)  # type: ignore[assignment]
             self.wash_towel_mode = wash_towel_mode
@@ -280,7 +282,7 @@ class PropertiesApi(Trait):
 
             # Union args may not be in declared order
             item_type = union_args[0] if union_args[1] is type(None) else union_args[1]
-            if not self._is_supported(item_type, item.name, dock_type):
+            if not self._is_supported(item_type, item.name, dock_features):
                 _LOGGER.debug("Trait '%s' not supported, skipping", item.name)
                 continue
             _LOGGER.debug("Trait '%s' is supported, initializing", item.name)
@@ -288,11 +290,11 @@ class PropertiesApi(Trait):
             setattr(self, item.name, trait)
             trait._rpc_channel = self._get_rpc_channel(trait)
 
-    def _is_supported(self, trait_type: type[V1TraitMixin], name: str, dock_type: RoborockDockTypeCode) -> bool:
+    def _is_supported(self, trait_type: type[V1TraitMixin], name: str, dock_features: RoborockDockFeatures) -> bool:
         """Check if a trait is supported by the device."""
 
-        if (requires_dock_type := getattr(trait_type, "requires_dock_type", None)) is not None:
-            return requires_dock_type(dock_type)
+        if (requires_dock_features := getattr(trait_type, "requires_dock_features", None)) is not None:
+            return requires_dock_features(dock_features)
 
         if (feature_name := getattr(trait_type, "requires_feature", None)) is None:
             _LOGGER.debug("Optional trait missing 'requires_feature' attribute %s, skipping", name)
@@ -307,16 +309,23 @@ class PropertiesApi(Trait):
         if dock_type is not None:
             _LOGGER.debug("Using cached dock type: %s", dock_type)
             try:
-                return RoborockDockTypeCode(dock_type)
+                dock_type = RoborockDockTypeCode(dock_type)
             except ValueError:
                 _LOGGER.debug("Cached dock type %s is invalid, refreshing", dock_type)
+            else:
+                if self.status.dss is None:
+                    await self.status.refresh()
+                    if self.status.dock_type is not None:
+                        dock_type = self.status.dock_type
+                        await self._set_cached_trait_data("dock_type", dock_type)
+                return dock_type
 
         _LOGGER.debug("Starting dock type discovery")
         await self.status.refresh()
         _LOGGER.debug("Fetched dock type: %s", self.status.dock_type)
         if self.status.dock_type is None:
             # Explicitly set so we reuse cached value next type
-            dock_type = RoborockDockTypeCode.no_dock
+            dock_type = RoborockDockTypeCode.o0_dock
         else:
             dock_type = self.status.dock_type
         await self._set_cached_trait_data("dock_type", dock_type)

{python_roborock-5.27.0 → python_roborock-5.28.1}/roborock/devices/traits/v1/dust_collection_mode.py

@@ -1,14 +1,18 @@
 """Trait for dust collection mode."""
 
 from roborock.data import DustCollectionMode
-from roborock.device_features import is_valid_dock
+from roborock.device_features import RoborockDockFeatures
 from roborock.devices.traits.v1 import common
 from roborock.roborock_typing import RoborockCommand
 
 
+def _supports_dust_collection_mode(dock_features: RoborockDockFeatures) -> bool:
+    return dock_features.is_collectable
+
+
 class DustCollectionModeTrait(DustCollectionMode, common.V1TraitMixin):
     """Trait for dust collection mode."""
 
     command = RoborockCommand.GET_DUST_COLLECTION_MODE
     converter = common.DefaultConverter(DustCollectionMode)
-    requires_dock_type = is_valid_dock
+    requires_dock_features = _supports_dust_collection_mode

{python_roborock-5.27.0 → python_roborock-5.28.1}/roborock/devices/traits/v1/smart_wash_params.py

@@ -1,14 +1,18 @@
 """Trait for smart wash parameters."""
 
 from roborock.data import SmartWashParams
-from roborock.device_features import is_wash_n_fill_dock
+from roborock.device_features import RoborockDockFeatures
 from roborock.devices.traits.v1 import common
 from roborock.roborock_typing import RoborockCommand
 
 
+def _supports_smart_wash_params(dock_features: RoborockDockFeatures) -> bool:
+    return dock_features.is_washable
+
+
 class SmartWashParamsTrait(SmartWashParams, common.V1TraitMixin):
     """Trait for smart wash parameters."""
 
     command = RoborockCommand.GET_SMART_WASH_PARAMS
     converter = common.DefaultConverter(SmartWashParams)
-    requires_dock_type = is_wash_n_fill_dock
+    requires_dock_features = _supports_smart_wash_params

{python_roborock-5.27.0 → python_roborock-5.28.1}/roborock/devices/traits/v1/wash_towel_mode.py

@@ -4,18 +4,22 @@ from functools import cached_property
 from typing import Self
 
 from roborock.data import WashTowelMode, WashTowelModes, get_wash_towel_modes
-from roborock.device_features import is_wash_n_fill_dock
+from roborock.device_features import RoborockDockFeatures
 from roborock.devices.traits.v1 import common
 from roborock.devices.traits.v1.device_features import DeviceFeaturesTrait
 from roborock.roborock_typing import RoborockCommand
 
 
+def _supports_wash_towel_mode(dock_features: RoborockDockFeatures) -> bool:
+    return dock_features.is_washable
+
+
 class WashTowelModeTrait(WashTowelMode, common.V1TraitMixin):
     """Trait for wash towel mode."""
 
     command = RoborockCommand.GET_WASH_TOWEL_MODE
     converter = common.DefaultConverter(WashTowelMode)
-    requires_dock_type = is_wash_n_fill_dock
+    requires_dock_features = _supports_wash_towel_mode
 
     def __init__(
         self,

{python_roborock-5.27.0 → python_roborock-5.28.1}/roborock/testing/channel.py

@@ -5,7 +5,7 @@ subscription, and publishing logic at the message boundary. It acts as an
 in-memory replacement for `MqttChannel` and `LocalChannel` during testing.
 """
 
-from collections.abc import Callable
+from collections.abc import Awaitable, Callable
 from typing import Any
 from unittest.mock import AsyncMock, MagicMock
 
@@ -37,6 +37,9 @@ class FakeChannel(Channel):
       publish (useful for low-level RPC request/response testing).
     - **Push unsolicited messages**: Call ``channel.notify_subscribers(msg)``
       to simulate the device broadcasting a state change.
+    - **Intercept published messages**: Register a handler/callback via
+      ``channel.publish_handler = my_handler`` (e.g. stateful simulator)
+      to reactively process commands.
     """
 
     subscribe: Any
@@ -49,6 +52,11 @@ class FakeChannel(Channel):
         self._is_connected = False
         self._is_local = is_local
 
+        # A callback to intercept published messages (e.g., bound simulator handler).
+        # Can be either synchronous or asynchronous: Callable[[RoborockMessage], Awaitable[Any]].
+        # By default, routes to self._default_publish_handler to handle the response_queue.
+        self.publish_handler: Callable[[RoborockMessage], Awaitable[Any]] | None = self._default_publish_handler
+
         # Set this to an exception instance to make the next publish raise it.
         # This is a convenience shortcut; callers can also replace
         # ``publish.side_effect`` directly for more control.
@@ -96,14 +104,16 @@ class FakeChannel(Channel):
     async def _publish(self, message: RoborockMessage) -> None:
         """Default publish implementation.
 
-        Records the message in ``published_messages`` and, if
-        ``response_queue`` is non-empty, pops the first response and
-        delivers it to all current subscribers (simulating a
-        request/response round-trip).
+        Records the message in ``published_messages`` and executes ``publish_handler``.
         """
         self.published_messages.append(message)
         if self.publish_side_effect:
             raise self.publish_side_effect
+        if self.publish_handler:
+            await self.publish_handler(message)
+
+    async def _default_publish_handler(self, message: RoborockMessage) -> None:
+        """Default handler that pops canned responses from response_queue."""
         if self.response_queue:
             response = self.response_queue.pop(0)
             self.notify_subscribers(response)
@@ -124,3 +134,15 @@ class FakeChannel(Channel):
         """
         for subscriber in list(self.subscribers):
             subscriber(message)
+
+    def inject_error(self, exception: Exception) -> None:
+        """Inject a transient failure into all channel operations (publish, subscribe, connect)."""
+        self.publish.side_effect = exception
+        self.subscribe.side_effect = exception
+        self.connect.side_effect = exception
+
+    def clear_error(self) -> None:
+        """Restore default success behaviors on all channel operations."""
+        self.publish.side_effect = self._publish
+        self.subscribe.side_effect = self._subscribe
+        self.connect.side_effect = self._connect

{python_roborock-5.27.0 → python_roborock-5.28.1}/roborock/testing/cloud.py

@@ -6,6 +6,7 @@ to simulate physical devices connected to the Roborock Cloud.
 """
 
 import contextlib
+import datetime
 import re
 from typing import Any
 from unittest.mock import AsyncMock, patch
@@ -173,6 +174,44 @@ class FakeWebApiClient:
             callback=get_homes_callback,
         )
 
+    def get_default_home_data(self) -> HomeData:
+        """Construct the default HomeData using simulated devices registered in the cloud."""
+        devices = [d.device_info for d in self.cloud.simulated_devices.values()]
+        products = [d.product for d in self.cloud.simulated_devices.values()]
+        return HomeData(
+            id=self.cloud.home_id,
+            name=self.cloud.home_name,
+            devices=devices,
+            products=products,
+            received_devices=[],
+            rooms=[],
+        )
+
+    def set_homes_response(
+        self,
+        home_data: HomeData | None = None,
+        status: int = 200,
+    ) -> None:
+        """Easily set the faked response payload for the homes endpoint using a HomeData dataclass.
+
+        If home_data is None, it defaults to the active get_default_home_data() state.
+        """
+        self.homes_status = status
+        if status != 200:
+            self.homes_payload_override = None
+            return
+
+        if home_data is None:
+            home_data = self.get_default_home_data()
+
+        self.homes_payload_override = {
+            "api": None,
+            "code": 200,
+            "result": home_data.as_dict(),
+            "status": "ok",
+            "success": True,
+        }
+
 
 class FakeRoborockCloud:
     """A central state object representing the Roborock Cloud environment under test."""
@@ -234,7 +273,9 @@ class FakeRoborockCloud:
         with aioresponses() as mocked:
             self.web_api.mock_requests(mocked)
 
-            # Patch Channel factories and rate limiters
+            # Mock sleep logic to speed up tests.
+            sleep_time = datetime.timedelta(seconds=0.001)
+            # Patch Channel factories, rate limiters, and backoff sleep intervals
             with (
                 patch(
                     "roborock.web_api.RoborockApiClient._login_limiter.try_acquire_async",
@@ -243,5 +284,7 @@ class FakeRoborockCloud:
                 patch("roborock.web_api.RoborockApiClient._home_data_limiter.try_acquire", return_value=True),
                 patch("roborock.devices.device_manager.create_v1_channel", side_effect=mock_create_v1_channel),
                 patch("roborock.devices.device_manager.create_mqtt_channel", side_effect=mock_create_mqtt_channel),
+                patch("roborock.devices.device.MIN_BACKOFF_INTERVAL", sleep_time),
+                patch("roborock.devices.device.MAX_BACKOFF_INTERVAL", sleep_time),
             ):
                 yield

{python_roborock-5.27.0 → python_roborock-5.28.1}/roborock/testing/simulator.py

@@ -73,26 +73,20 @@ class RoborockDeviceSimulator:
 
         # MQTT channel is always present — all protocols use it.
         self.mqtt_channel = FakeChannel(is_local=False)
-        self.mqtt_channel.publish.side_effect = self._handle_mqtt_publish
+        self.mqtt_channel.publish_handler = self._handle_mqtt_publish
 
         # Local channel is only used by V1 devices. A01/B01 (MQTT-only)
         # simulators should pass has_local_channel=False.
         self.local_channel: FakeChannel | None = None
         if has_local_channel:
             self.local_channel = FakeChannel(is_local=True)
-            self.local_channel.publish.side_effect = self._handle_local_publish
+            self.local_channel.publish_handler = self._handle_local_publish
 
     async def _handle_local_publish(self, message: RoborockMessage) -> None:
         assert self.local_channel is not None
-        self.local_channel.published_messages.append(message)
-        if self.local_channel.publish_side_effect:
-            raise self.local_channel.publish_side_effect
         await self._handle_publish(message, self.local_channel)
 
     async def _handle_mqtt_publish(self, message: RoborockMessage) -> None:
-        self.mqtt_channel.published_messages.append(message)
-        if self.mqtt_channel.publish_side_effect:
-            raise self.mqtt_channel.publish_side_effect
         await self._handle_publish(message, self.mqtt_channel)
 
     async def _handle_publish(self, message: RoborockMessage, channel: FakeChannel) -> None:

{python_roborock-5.27.0 → python_roborock-5.28.1}/roborock/testing/v1_simulator.py

@@ -81,7 +81,7 @@ DEFAULT_STATUS = StatusV2(
     home_sec_enable_password=0,
     adbumper_status=[0, 0, 0],
     water_shortage_status=0,
-    dock_type=RoborockDockTypeCode.s8_dock,
+    dock_type=RoborockDockTypeCode.o4_dock,
     dust_collection_status=0,
     auto_dust_collection=1,
     avoid_count=19,