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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "python-roborock"
-version = "5.29.0"
+version = "5.31.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.29.0 → python_roborock-5.31.0}/roborock/data/containers.py

@@ -60,6 +60,25 @@ def _attr_repr(obj: Any) -> str:
     return f"{type(obj).__name__}({', '.join(parts)})"
 
 
+def field_metadata(**kwargs):
+    """Decorator to attach capability check metadata to a property.
+
+    This attaches a `_field_metadata` dictionary to the underlying getter function,
+    which is then preserved when decorated with `@property`.
+
+    Supported metadata keys:
+    - `feature` (str): Name of a capability property on `DeviceFeaturesTrait`.
+    - `dock_feature` (str): Name of a capability property on `RoborockDockFeatures`.
+    - `dps` (str/int): RoborockDataProtocol ID to check against supported schema IDs.
+    """
+
+    def decorator(func):
+        func._field_metadata = kwargs
+        return func
+
+    return decorator
+
+
 @dataclass(repr=False)
 class RoborockBase:
     """Base class for all Roborock data classes."""

{python_roborock-5.29.0 → python_roborock-5.31.0}/roborock/data/v1/v1_containers.py

@@ -39,7 +39,7 @@ from roborock.const import (
 from roborock.exceptions import RoborockException
 from roborock.roborock_message import RoborockDataProtocol
 
-from ..containers import NamedRoomMapping, RoborockBase, RoborockBaseTimer, _attr_repr
+from ..containers import NamedRoomMapping, RoborockBase, RoborockBaseTimer, _attr_repr, field_metadata
 from .v1_clean_modes import WashTowelModes
 from .v1_code_mappings import (
     CleanFluidStatus,
@@ -117,6 +117,15 @@ class StatusField(FieldNameBase):
     CHARGE_STATUS = "charge_status"
     DRY_STATUS = "dry_status"
     ERROR_CODE = "error_code"
+    WATER_BOX_CARRIAGE_STATUS = "water_box_carriage_status"
+    WATER_BOX_STATUS = "water_box_status"
+    WATER_SHORTAGE_STATUS = "water_shortage_status"
+    DIRTY_WATER_BOX_STATUS = "dirty_water_box_status"
+    CLEAR_WATER_BOX_STATUS = "clear_water_box_status"
+    CLEAN_FLUID_STATUS = "clean_fluid_status"
+    CLEAN_PERCENT = "clean_percent"
+    DOCK_ERROR_STATUS = "dock_error_status"
+    RDT = "rdt"
 
 
 @dataclass
@@ -246,12 +255,14 @@ class Status(RoborockBase):
         return (self.dss & 3) == 2
 
     @property
+    @field_metadata(dock_feature="is_washable")
     def clear_water_box_status(self) -> ClearWaterBoxStatus | None:
         if self.dss:
             return ClearWaterBoxStatus((self.dss >> 2) & 3)
         return None
 
     @property
+    @field_metadata(dock_feature="is_washable")
     def dirty_water_box_status(self) -> DirtyWaterBoxStatus | None:
         if self.dss:
             return DirtyWaterBoxStatus((self.dss >> 4) & 3)
@@ -270,6 +281,9 @@ class Status(RoborockBase):
         return None
 
     @property
+    @field_metadata(
+        dock_feature="is_clean_fluid_auto_delivery_supported",
+    )
     def clean_fluid_status(self) -> CleanFluidStatus | None:
         if self.dss:
             value = (self.dss >> 10) & 3
@@ -313,7 +327,7 @@ class StatusV2(RoborockBase):
     in_returning: int | None = None
     in_fresh_state: int | None = None
     lab_status: int | None = None
-    water_box_status: int | None = None
+    water_box_status: int | None = field(default=None, metadata={"feature": "is_support_water_mode"})
     back_type: int | None = None
     wash_phase: int | None = None
     wash_ready: int | None = None
@@ -323,14 +337,14 @@ class StatusV2(RoborockBase):
     is_locating: int | None = None
     lock_status: int | None = None
     water_box_mode: int | None = field(default=None, metadata={"dps": RoborockDataProtocol.WATER_BOX_MODE})
-    water_box_carriage_status: int | None = None
+    water_box_carriage_status: int | None = field(default=None, metadata={"feature": "is_support_water_mode"})
     mop_forbidden_enable: int | None = None
     camera_status: int | None = None
     is_exploring: int | None = None
     home_sec_status: int | None = None
     home_sec_enable_password: int | None = None
     adbumper_status: list[int] | None = None
-    water_shortage_status: int | None = None
+    water_shortage_status: int | None = field(default=None, metadata={"feature": "is_support_water_mode"})
     dock_type: RoborockDockTypeCode | None = None
     dust_collection_status: int | None = None
     auto_dust_collection: int | None = None
@@ -339,7 +353,8 @@ class StatusV2(RoborockBase):
     debug_mode: int | None = None
     collision_avoid_status: int | None = None
     switch_map_mode: int | None = None
-    dock_error_status: RoborockDockErrorCode | None = None
+    dock_error_status: RoborockDockErrorCode | None = field(default=None, metadata={"dock_feature": "has_dock"})
+
     charge_status: RoborockChargeStatus | None = field(
         default=None, metadata={"dps": RoborockDataProtocol.CHARGE_STATUS}
     )
@@ -349,8 +364,8 @@ class StatusV2(RoborockBase):
     distance_off: int | None = None
     in_warmup: int | None = None
     dry_status: int | None = field(default=None, metadata={"dps": RoborockDataProtocol.DRYING_STATUS})
-    rdt: int | None = None
-    clean_percent: int | None = None
+    rdt: int | None = field(default=None, metadata={"feature": "is_supported_drying"})
+    clean_percent: int | None = field(default=None, metadata={"feature": "is_support_clean_estimate"})
     rss: int | None = None
     dss: int | None = None
     common_status: int | None = None
@@ -389,12 +404,14 @@ class StatusV2(RoborockBase):
         return (self.dss & 3) == 2
 
     @property
+    @field_metadata(dock_feature="is_washable")
     def clear_water_box_status(self) -> ClearWaterBoxStatus | None:
         if self.dss:
             return ClearWaterBoxStatus((self.dss >> 2) & 3)
         return None
 
     @property
+    @field_metadata(dock_feature="is_washable")
     def dirty_water_box_status(self) -> DirtyWaterBoxStatus | None:
         if self.dss:
             return DirtyWaterBoxStatus((self.dss >> 4) & 3)
@@ -413,6 +430,9 @@ class StatusV2(RoborockBase):
         return None
 
     @property
+    @field_metadata(
+        dock_feature="is_clean_fluid_auto_delivery_supported",
+    )
     def clean_fluid_status(self) -> CleanFluidStatus | None:
         if self.dss:
             value = (self.dss >> 10) & 3

{python_roborock-5.29.0 → python_roborock-5.31.0}/roborock/devices/traits/v1/__init__.py

@@ -264,6 +264,7 @@ class PropertiesApi(Trait):
         # 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)
+        self.device_features.dock_features = dock_features
 
         # 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_features):

{python_roborock-5.29.0 → python_roborock-5.31.0}/roborock/devices/traits/v1/device_features.py

@@ -1,12 +1,33 @@
-from dataclasses import Field, fields
+from dataclasses import fields
+from typing import Any
 
 from roborock.data import AppInitStatus, HomeDataProduct, RoborockBase
+from roborock.data.v1 import RoborockDockTypeCode
 from roborock.data.v1.v1_containers import FieldNameBase
-from roborock.device_features import DeviceFeatures
+from roborock.device_features import DeviceFeatures, RoborockDockFeatures
 from roborock.devices.cache import DeviceCache
 from roborock.devices.traits.v1 import common
 from roborock.roborock_typing import RoborockCommand
 
+# Cache of metadata for each trait class
+_metadata_cache: dict[type[RoborockBase], dict[str, dict[str, Any]]] = {}
+
+
+def _get_field_metadata(cls: type[RoborockBase]) -> dict[str, Any]:
+    """Helper to get metadata from either class properties or dataclass fields."""
+    if cls not in _metadata_cache:
+        metadata_map = {}
+        # Inspect properties with @field_metadata
+        for name in dir(cls):
+            prop = getattr(cls, name, None)
+            if isinstance(prop, property):
+                metadata_map[name] = getattr(prop.fget, "_field_metadata", {})
+        # Inspect dataclass fields metadata
+        for f in fields(cls):
+            metadata_map[f.name] = f.metadata
+        _metadata_cache[cls] = metadata_map
+    return _metadata_cache[cls]
+
 
 class DeviceTraitsConverter(common.V1TraitDataConverter):
     """Converter for APP_GET_INIT_STATUS responses into DeviceFeatures."""
@@ -40,31 +61,37 @@ class DeviceFeaturesTrait(DeviceFeatures, common.V1TraitMixin):
         self.converter = DeviceTraitsConverter(product)
         self._product = product
         self._device_cache = device_cache
+        # Dock features are populated after device feature discovery
+        # is triggered.
+        self.dock_features: RoborockDockFeatures = RoborockDockFeatures.from_dock_type(RoborockDockTypeCode.o0_dock)
         # All fields of DeviceFeatures are required. Initialize them to False
         # so we have some known state.
         for field in fields(self):
             setattr(self, field.name, False)
 
-    @staticmethod
-    def _get_dataclass_field(cls: type[RoborockBase], field_name: FieldNameBase) -> Field:
-        """Look up a dataclass field by its FieldNameBase name."""
-        for f in fields(cls):
-            if f.name == field_name:
-                return f
-        raise ValueError(f"Field {field_name!r} not found in {cls}")
-
     def is_field_supported(self, cls: type[RoborockBase], field_name: FieldNameBase) -> bool:
         """Determines if the specified field is supported by this device.
 
-        We use the `dps` dataclass field metadata to get the `RoborockDataProtocol`
-        integer ID and check it against the set of supported schema IDs for the
-        device returned in the product information.
+        We inspect the metadata defined for the field (either via dataclass field metadata
+        or the `@field_metadata` decorator on properties). Supported checks include:
+
+        - `feature`: Maps to a boolean capability property on `DeviceFeatures` / `DeviceFeaturesTrait`
+          (e.g. `is_support_water_mode`).
+        - `dock_feature`: Maps to a boolean capability property on `RoborockDockFeatures` (e.g. `is_washable`).
+        - `dps`: Maps to a `RoborockDataProtocol` ID checked against the product's supported schema IDs.
         """
-        dataclass_field = self._get_dataclass_field(cls, field_name)
-        if (dps := dataclass_field.metadata.get("dps")) is None:
-            # No DPS metadata — field is assumed always supported
-            return True
-        return int(dps) in self._product.supported_schema_ids
+        if self.dock_features is None:
+            raise ValueError("DeviceFeaturesTrait was invoked but was not fully initialized")
+        metadata_map = _get_field_metadata(cls)
+        if (field_metadata := metadata_map.get(field_name)) is not None:
+            if (feature := field_metadata.get("feature")) is not None:
+                return getattr(self, feature, False)
+            if (dock_feature := field_metadata.get("dock_feature")) is not None:
+                return getattr(self.dock_features, dock_feature, False)
+            if (dps := field_metadata.get("dps")) is not None:
+                return int(dps) in self._product.supported_schema_ids
+        # No metadata, field is assumed always supported
+        return True
 
     async def refresh(self) -> None:
         """Refresh the contents of this trait.

{python_roborock-5.29.0 → python_roborock-5.31.0}/roborock/testing/__init__.py

@@ -63,6 +63,10 @@ async def test_start_vacuum_service():
 ```
 """
 
+from roborock.testing.b01_q10_simulator import (
+    DEFAULT_Q10_STATUS,
+    Q10VacuumSimulator,
+)
 from roborock.testing.channel import FakeChannel
 from roborock.testing.cloud import FakeRoborockCloud, FakeWebApiClient
 from roborock.testing.simulator import (
@@ -92,10 +96,12 @@ __all__ = [
     "DEFAULT_LOCAL_KEY",
     "DEFAULT_NETWORK_INFO",
     "DEFAULT_PRODUCT_ID",
+    "DEFAULT_Q10_STATUS",
     "DEFAULT_STATUS",
     "FakeChannel",
     "FakeRoborockCloud",
     "FakeWebApiClient",
+    "Q10VacuumSimulator",
     "RoborockDeviceSimulator",
     "V1VacuumSimulator",
 ]

python_roborock-5.31.0/roborock/testing/b01_q10_simulator.py

@@ -0,0 +1,213 @@
+"""Stateful simulator for Roborock Q10 (B01) devices."""
+
+import copy
+import json
+import logging
+from typing import Any
+
+from roborock.data import HomeDataDevice, HomeDataProduct, RoborockCategory
+from roborock.roborock_message import RoborockMessage, RoborockMessageProtocol
+from roborock.testing.simulator import RoborockDeviceSimulator
+
+_LOGGER = logging.getLogger(__name__)
+
+B01_VERSION = b"B01"
+DEFAULT_PRODUCT_ID = "product-id-q10"
+
+DEFAULT_Q10_STATUS = {
+    101: {
+        104: 0,
+        105: False,
+        109: "us",
+        207: 0,
+        25: 1,
+        26: 74,
+        29: 0,
+        30: 0,
+        31: 0,
+        37: 1,
+        40: 1,
+        45: 0,
+        47: 0,
+        50: 0,
+        51: True,
+        53: False,
+        6: 0,
+        60: 1,
+        67: 0,
+        7: 0,
+        76: 0,
+        78: 0,
+        79: {"timeZoneCity": "America/Los_Angeles", "timeZoneSec": -28800},
+        80: 0,
+        81: {"ipAdress": "1.1.1.2", "mac": "99:AA:88:BB:77:CC", "signal": -50, "wifiName": "wifi-network-name"},
+        83: 1,
+        86: 1,
+        87: 100,
+        88: 0,
+        90: 0,
+        92: {"disturb_dust_enable": 1, "disturb_light": 1, "disturb_resume_clean": 1, "disturb_voice": 1},
+        93: 1,
+        96: 0,
+    },
+    121: 8,
+    122: 100,
+    123: 2,
+    124: 1,
+    125: 0,
+    126: 0,
+    127: 0,
+    136: 1,
+    137: 1,
+    138: 0,
+    139: 5,
+}
+
+
+class Q10VacuumSimulator(RoborockDeviceSimulator):
+    """Stateful firmware simulator for Roborock Q10 (B01 ss07) devices."""
+
+    def __init__(
+        self,
+        duid: str,
+        status: dict[int, Any] | None = None,
+        device_info: HomeDataDevice | None = None,
+        product: HomeDataProduct | None = None,
+    ):
+        product = product or HomeDataProduct(
+            id=DEFAULT_PRODUCT_ID,
+            name="Roborock Q10",
+            model="roborock.vacuum.ss07",
+            category=RoborockCategory.VACUUM,
+        )
+        device_info = device_info or HomeDataDevice(
+            duid=duid,
+            name="Roborock Q10",
+            local_key="fake_localkey_16bytes",
+            product_id=product.id,
+            sn="fake_serial_number",
+            pv="B01",
+        )
+        super().__init__(duid, device_info, product, has_local_channel=False)
+        self.status = copy.deepcopy(status or DEFAULT_Q10_STATUS)
+
+    async def _handle_publish(self, message: RoborockMessage, channel: Any) -> None:
+        """Process incoming Q10 RPC command payload."""
+        if not message.payload:
+            return
+
+        try:
+            payload = json.loads(message.payload.decode())
+        except (json.JSONDecodeError, UnicodeDecodeError) as ex:
+            _LOGGER.warning("Simulator failed to parse incoming B01 payload: %s", ex)
+            return
+
+        datapoints = payload.get("dps", {})
+        if not isinstance(datapoints, dict):
+            return
+
+        updated_dps: dict[int, Any] = {}
+
+        for code_str, params in datapoints.items():
+            try:
+                code = int(code_str)
+            except ValueError:
+                continue
+
+            # Command: REQUEST_DPS (102) -> trigger status push
+            if code == 102:
+                # REQUEST_DPS triggers a dump of all status properties
+                # (both root properties and nested properties under 101)
+                self.trigger_push_update()
+                continue
+
+            # Command: START_CLEAN (201)
+            elif code == 201:
+                # 1 = sweep/mop, cmd inside dict = segment clean
+                self.status[121] = 5  # YXDeviceState.CLEANING
+                if isinstance(params, dict) and "cmd" in params:
+                    self.status[138] = params.get("cmd", 0)  # clean_task_type
+                else:
+                    self.status[138] = 1  # CLEANING
+                updated_dps[121] = self.status[121]
+                updated_dps[138] = self.status[138]
+
+            # Command: START_BACK (202)
+            elif code == 202:
+                # 5 = returning to charge
+                self.status[121] = 6  # YXDeviceState.RETURNING_HOME
+                self.status[139] = 5  # BACK_CHARGING
+                updated_dps[121] = self.status[121]
+                updated_dps[139] = self.status[139]
+
+            # Command: START_DOCK_TASK (203)
+            elif code == 203:
+                # Empty dustbin
+                self.status[121] = 22  # EMPTYING_THE_BIN
+                updated_dps[121] = self.status[121]
+
+            # Command: PAUSE (204)
+            elif code == 204:
+                self.status[121] = 10  # YXDeviceState.PAUSED
+                updated_dps[121] = self.status[121]
+
+            # Command: RESUME (205)
+            elif code == 205:
+                self.status[121] = 5  # YXDeviceState.CLEANING
+                updated_dps[121] = self.status[121]
+
+            # Command: STOP (206)
+            elif code == 206:
+                self.status[121] = 3  # YXDeviceState.IDLE
+                self.status[138] = 0  # YXDeviceCleanTask.UNKNOWN/IDLE
+                updated_dps[121] = self.status[121]
+                updated_dps[138] = self.status[138]
+
+            # Command: FAN_LEVEL (123)
+            elif code == 123:
+                self.status[123] = params
+                updated_dps[123] = params
+
+            # Command: WATER_LEVEL (124)
+            elif code == 124:
+                self.status[124] = params
+                updated_dps[124] = params
+
+            # Command: CLEAN_MODE (137)
+            elif code == 137:
+                self.status[137] = params
+                updated_dps[137] = params
+
+            # Custom settings properties routed to sub-traits (DND, child lock, volume, dust collections)
+            elif code in (26, 47, 25, 37, 50):
+                # These live in the nested dpCommon (101) dict
+                common_dict = self.status[101]
+                if isinstance(common_dict, dict):
+                    common_dict[code] = params
+                # We return them nested under 101
+                if 101 not in updated_dps:
+                    updated_dps[101] = {}
+                updated_dps[101][code] = params
+
+        if updated_dps:
+            # Send the changed datapoints back to the client
+            self.push_dps(updated_dps)
+
+    def push_dps(self, dps_updates: dict[int, Any]) -> None:
+        """Push a set of status datapoint changes to the client."""
+        payload = {
+            "dps": {
+                str(k): ({str(sub_k): sub_v for sub_k, sub_v in v.items()} if isinstance(v, dict) and k == 101 else v)
+                for k, v in dps_updates.items()
+            }
+        }
+        message = RoborockMessage(
+            protocol=RoborockMessageProtocol.RPC_RESPONSE,
+            version=B01_VERSION,
+            payload=json.dumps(payload).encode("utf-8"),
+        )
+        self.mqtt_channel.notify_subscribers(message)
+
+    def trigger_push_update(self) -> None:
+        """Send the full status dump to the client."""
+        self.push_dps(self.status)

{python_roborock-5.29.0 → python_roborock-5.31.0}/roborock/testing/channel.py

@@ -5,7 +5,8 @@ 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 Awaitable, Callable
+import asyncio
+from collections.abc import AsyncGenerator, Awaitable, Callable
 from typing import Any
 from unittest.mock import AsyncMock, MagicMock
 
@@ -53,7 +54,7 @@ class FakeChannel(Channel):
         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]].
+        # Must be 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
 
@@ -146,3 +147,17 @@ class FakeChannel(Channel):
         self.publish.side_effect = self._publish
         self.subscribe.side_effect = self._subscribe
         self.connect.side_effect = self._connect
+
+    async def subscribe_stream(self) -> AsyncGenerator[RoborockMessage, None]:
+        """Stream messages received via this channel."""
+        queue: asyncio.Queue[RoborockMessage] = asyncio.Queue()
+
+        def callback(message: RoborockMessage) -> None:
+            queue.put_nowait(message)
+
+        unsub = await self.subscribe(callback)
+        try:
+            while True:
+                yield await queue.get()
+        finally:
+            unsub()

{python_roborock-5.29.0 → python_roborock-5.31.0}/roborock/testing/cloud.py

@@ -16,6 +16,7 @@ from aioresponses import CallbackResult, aioresponses
 from roborock.data import HomeData, Reference, RRiot, UserData
 from roborock.devices.rpc.v1_channel import create_v1_channel as original_create_v1_channel
 from roborock.devices.transport.mqtt_channel import create_mqtt_channel as original_create_mqtt_channel
+from roborock.testing.b01_q10_simulator import Q10VacuumSimulator
 from roborock.testing.simulator import RoborockDeviceSimulator
 from roborock.testing.v1_simulator import V1VacuumSimulator
 
@@ -242,11 +243,6 @@ class FakeRoborockCloud:
 
         # Wrapper function for create_v1_channel
         def mock_create_v1_channel(user_data, mqtt_params, mqtt_session, device, device_cache):
-            if device.pv in ("A01", "B01"):
-                raise NotImplementedError(
-                    f"Simulating protocol {device.pv} is not yet supported. "
-                    "TODO: Implement stateful simulators for B01 (Q7/Q10) and A01 (Zeo/Dyad) devices."
-                )
             server = self.simulated_devices.get(device.duid)
             if server is not None:
                 if not isinstance(server, V1VacuumSimulator):
@@ -255,18 +251,29 @@ class FakeRoborockCloud:
                         f"simulator, but create_v1_channel requires a V1VacuumSimulator."
                     )
                 return server.v1_channel
+            if device.pv in ("A01", "B01"):
+                raise NotImplementedError(
+                    f"Simulating protocol {device.pv} is not yet supported. "
+                    "TODO: Implement stateful simulators for B01 (Q7) and A01 (Zeo/Dyad) devices."
+                )
             return original_create_v1_channel(user_data, mqtt_params, mqtt_session, device, device_cache)
 
         # Wrapper function for create_mqtt_channel
         def mock_create_mqtt_channel(user_data, mqtt_params, mqtt_session, device):
+            server = self.simulated_devices.get(device.duid)
+            if server:
+                if device.pv == "B01" and not isinstance(server, Q10VacuumSimulator):
+                    raise NotImplementedError(
+                        f"Simulating protocol {device.pv} is not yet supported. "
+                        "Only Q10VacuumSimulator is supported for B01 protocols currently."
+                    )
+                server.mqtt_channel._is_connected = True
+                return server.mqtt_channel
             if device.pv in ("A01", "B01"):
                 raise NotImplementedError(
                     f"Simulating protocol {device.pv} is not yet supported. "
-                    "TODO: Implement stateful simulators for B01 (Q7/Q10) and A01 (Zeo/Dyad) devices."
+                    "TODO: Implement stateful simulators for B01 (Q7) and A01 (Zeo/Dyad) devices."
                 )
-            server = self.simulated_devices.get(device.duid)
-            if server:
-                return server.mqtt_channel
             return original_create_mqtt_channel(user_data, mqtt_params, mqtt_session, device)
 
         # Route Web requests using the dynamic FakeWebApiClient