python-roborock 5.28.0__tar.gz → 5.29.0__tar.gz

{python_roborock-5.28.0 → python_roborock-5.29.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-roborock
-Version: 5.28.0
+Version: 5.29.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.28.0 → python_roborock-5.29.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-roborock"
-version = "5.28.0"
+version = "5.29.0"
 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.28.0 → python_roborock-5.29.0}/roborock/data/v1/v1_code_mappings.py

@@ -675,6 +675,7 @@ class RoborockDockTypeCode(RoborockEnum):
     type_27_dock = 27
     k1c_lite_dock = 28
     shell_2e_lite_dock = 30
+    shell_2e_heat_dock = 40
 
 
 class RoborockDockDustCollectionModeCode(RoborockEnum):

{python_roborock-5.28.0 → python_roborock-5.29.0}/roborock/device_features.py

@@ -674,6 +674,7 @@ _ONLY_X_SERIES_DOCK_TYPES = {
 
 _CLEAN_FLUID_AUTO_DELIVERY_DOCK_TYPES = {
     RoborockDockTypeCode.o4_dock,
+    RoborockDockTypeCode.o5_dock,
     RoborockDockTypeCode.pearl_plus_dock,
     RoborockDockTypeCode.shell_3s_dock,
     RoborockDockTypeCode.o6_dock,
@@ -681,7 +682,6 @@ _CLEAN_FLUID_AUTO_DELIVERY_DOCK_TYPES = {
 }
 
 _CLEAN_FLUID_AUTO_DELIVERY_AM_DOCK_TYPES = {
-    RoborockDockTypeCode.o5_dock,
     RoborockDockTypeCode.shell_2s_dock,
     RoborockDockTypeCode.shell_3_dock,
     RoborockDockTypeCode.shell_2c_dock,
@@ -734,9 +734,11 @@ _WATER_UPDOWN_DRAIN_AM_DOCK_TYPES = {
     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 = {

{python_roborock-5.28.0 → python_roborock-5.29.0}/roborock/roborock_message.py

@@ -274,6 +274,9 @@ ROBOROCK_DATA_CONSUMABLE_PROTOCOL = [
 ]
 
 
+MAX_PAYLOAD_REPR_LEN = 1024
+
+
 @dataclass
 class RoborockMessage:
     protocol: RoborockMessageProtocol
@@ -282,3 +285,18 @@ class RoborockMessage:
     version: bytes = b"1.0"
     random: int = field(default_factory=lambda: get_next_int(10000, 99999))
     timestamp: int = field(default_factory=lambda: get_timestamp())
+
+    def __repr__(self) -> str:
+        payload_repr = "None"
+        if self.payload is not None:
+            if isinstance(self.payload, (bytes, bytearray, str)) and len(self.payload) > MAX_PAYLOAD_REPR_LEN:
+                r = repr(self.payload[:MAX_PAYLOAD_REPR_LEN])
+                quote = r[-1]
+                payload_repr = f"{r[:-1]}...{quote} (length: {len(self.payload)})"
+            else:
+                payload_repr = repr(self.payload)
+        return (
+            f"RoborockMessage(protocol={self.protocol}, payload={payload_repr}, "
+            f"seq={self.seq}, version={self.version!r}, random={self.random}, "
+            f"timestamp={self.timestamp})"
+        )

{python_roborock-5.28.0 → python_roborock-5.29.0}/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.28.0 → python_roborock-5.29.0}/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.28.0 → python_roborock-5.29.0}/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: