python-roborock 6.2.1__tar.gz → 7.1.1__tar.gz

{python_roborock-6.2.1 → python_roborock-7.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: python-roborock
-Version: 6.2.1
+Version: 7.1.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-6.2.1 → python_roborock-7.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-roborock"
-version = "6.2.1"
+version = "7.1.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-6.2.1 → python_roborock-7.1.1}/roborock/cli.py

@@ -594,9 +594,9 @@ async def maps(ctx, device_id: str):
     await _display_v1_trait(context, device_id, lambda v1: v1.maps)
 
 
-# The Q10 pushes its map ~9s after a dpRequestDps; firmware throttles pushes to
-# ~once per 60-70s, so a single request is answered quickly but rapid re-requests
-# may not be. This bounds how long a one-shot CLI command waits for that push.
+# The Q10 publishes its map asynchronously after a dpMultiMap list/get request.
+# Firmware throttles pushes to ~once per 60-70s, so rapid re-requests may not be
+# answered immediately. This bounds how long a one-shot CLI command waits.
 _Q10_MAP_PUSH_TIMEOUT = 30.0
 
 
@@ -607,13 +607,12 @@ async def _await_q10_map_push(
     timeout: float = _Q10_MAP_PUSH_TIMEOUT,
     allow_cached_on_timeout: bool = False,
 ) -> bool:
-    """Nudge a Q10 to push its map/trace and wait for a fresh update.
+    """Request Q10 map content and wait for usable map-trait state.
 
-    The Q10 map API is entirely push-driven: there is no synchronous get-map
-    request. A ``dpRequestDps`` causes the device to publish a ``MAP_RESPONSE``,
-    which the device's subscribe loop feeds into the map trait. Here we register
-    an update listener, send the request, and wait for a newly pushed update to
-    satisfy ``predicate``. Returns whether it did within ``timeout``.
+    A Q10 needs a saved-map ID before it can request content. The map list and
+    content have independent refresh schedules, so the list is requested only
+    when no ID is stored. The content then arrives as a later ``MAP_RESPONSE``
+    and is published through the standard trait update interface.
     """
     loop = asyncio.get_running_loop()
     updated: asyncio.Future[None] = loop.create_future()
@@ -624,8 +623,23 @@ async def _await_q10_map_push(
 
     unsub = properties.map.add_update_listener(on_update)
     try:
-        await properties.refresh()
-        await asyncio.wait_for(updated, timeout=timeout)
+        async with asyncio.timeout(timeout):
+            if properties.maps.current_map_id is None:
+                map_list_updated: asyncio.Future[None] = loop.create_future()
+
+                def on_map_list_update() -> None:
+                    if properties.maps.current_map_id is not None and not map_list_updated.done():
+                        map_list_updated.set_result(None)
+
+                unsub_maps = properties.maps.add_update_listener(on_map_list_update)
+                try:
+                    await properties.maps.refresh()
+                    if properties.maps.current_map_id is None:
+                        await map_list_updated
+                finally:
+                    unsub_maps()
+            await properties.map.refresh()
+            await updated
         return True
     except TimeoutError:
         return allow_cached_on_timeout and predicate()
@@ -706,7 +720,10 @@ async def q10_position(ctx, device_id: str, include_path: bool):
         click.echo("Feature not supported by device")
         return
     properties = device.b01_q10_properties
-    got_trace = await _await_q10_map_push(properties, lambda: bool(properties.map.path))
+    got_trace = await _await_q10_map_push(
+        properties,
+        lambda: bool(properties.map.path),
+    )
     if not got_trace:
         click.echo("No live trace available (the robot only reports position while cleaning).")
         return

{python_roborock-6.2.1 → python_roborock-7.1.1}/roborock/data/b01_q10/b01_q10_containers.py

@@ -83,11 +83,32 @@ class Q10CleanRecord(RoborockBase):
         return None
 
 
+@dataclass
+class Q10MapInfo(RoborockBase):
+    """A saved map reported by ``dpMultiMap``.
+
+    Q10 firmware represents the map identifier as a string on the wire. The
+    value is sent back unchanged in a subsequent ``{"op": "get"}`` request.
+    """
+
+    id: str
+    name: str | None = None
+    timestamp: int | None = None
+
+
 @dataclass
 class dpMultiMap(RoborockBase):
+    """Response envelope for the Q10 ``dpMultiMap`` data point."""
+
     op: str
     result: int
-    data: list
+    data: list[Q10MapInfo] = field(default_factory=list)
+
+    @property
+    def current_map_id(self) -> str | None:
+        """Return the first saved-map identifier, if one was reported."""
+        first = next((map_info for map_info in self.data if map_info.id), None)
+        return first.id if first else None
 
 
 @dataclass

{python_roborock-6.2.1 → python_roborock-7.1.1}/roborock/data/b01_q7/b01_q7_code_mappings.py

@@ -1,3 +1,5 @@
+from typing import Self, cast
+
 from ..code_mappings import RoborockModeEnum
 
 
@@ -15,6 +17,16 @@ class WorkStatusMapping(RoborockModeEnum):
     UPDATING = ("updating", 8)
     MOP_CLEANING = ("mop_cleaning", 9)
     MOP_AIRDRYING = ("mop_airdrying", 10)
+    WORKING_SLEEP = ("working_sleep", 11)
+    UNKNOWN = ("unknown", -1)
+
+    @classmethod
+    def from_code(cls, code: int) -> Self:
+        """Map unrecognized Q7 statuses to UNKNOWN without failing the response."""
+        try:
+            return super().from_code(code)
+        except ValueError:
+            return cast(Self, cls.UNKNOWN)
 
 
 class SCWindMapping(RoborockModeEnum):

{python_roborock-6.2.1 → python_roborock-7.1.1}/roborock/data/code_mappings.py

@@ -72,14 +72,21 @@ class RoborockModeEnum(StrEnum):
 
     code: int
     """The integer code associated with the enum member."""
+    _display_name_: str | None
 
-    def __new__(cls, value: str, code: int) -> Self:
+    def __new__(cls, value: str, code: int, display_name: str | None = None) -> Self:
         """Creates a new enum member."""
         member = str.__new__(cls, value)
         member._value_ = value
         member.code = code
+        member._display_name_ = display_name
         return member
 
+    @property
+    def display_name(self) -> str:
+        """Return the canonical user-facing name for the mode."""
+        return self._display_name_ or self.value
+
     @classmethod
     def from_code(cls, code: int) -> Self:
         for member in cls:
@@ -149,8 +156,8 @@ class RoborockModeEnum(StrEnum):
 
     @classmethod
     def keys(cls) -> list[str]:
-        """Returns a list of all member values."""
-        return [member.value for member in cls]
+        """Returns a de-duplicated list of canonical member names."""
+        return list(dict.fromkeys(member.display_name for member in cls))
 
     def __eq__(self, other: Any) -> bool:
         if isinstance(other, str):

{python_roborock-6.2.1 → python_roborock-7.1.1}/roborock/data/containers.py

@@ -162,13 +162,14 @@ class RoborockBase:
 
         return result
 
-    def as_dict(self) -> dict:
+    def as_dict(self, exclude: set[str] | None = None) -> dict:
+        exclude_set = exclude or set()
         return asdict(
             self,
             dict_factory=lambda _fields: {
                 _camelize(key): value.value if isinstance(value, Enum) else value
                 for (key, value) in _fields
-                if value is not None
+                if value is not None and key not in exclude_set
             },
         )
 

{python_roborock-6.2.1 → python_roborock-7.1.1}/roborock/data/mower/__init__.py

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

python_roborock-7.1.1/roborock/data/mower/mower_code_mappings.py

@@ -0,0 +1,72 @@
+"""Code mappings for Roborock mower devices."""
+
+from roborock.data.code_mappings import RoborockEnum
+
+
+class RoborockMowerStateCode(RoborockEnum):
+    """Detailed mower operating state reported by DPS 123."""
+
+    unknown = -999
+    idle = 0
+
+    map_initializing = 1
+    map_undocking = 2
+    map_undock_fault = 3
+    map_locating = 4
+    map_prepare_boundary = 5
+    map_prepare_island = 6
+    map_prepare_path = 7
+    map_boundary = 8
+    map_island = 9
+    map_path = 10
+    map_boundary_auto = 11
+    map_erasing = 12
+    map_save = 13
+    map_wait = 14
+    map_recoverable_fault = 15
+    map_fault = 16
+    map_emergency_stop = 17
+    map_waiting_fault = 18
+
+    mow_initializing = 51
+    mow_undocking = 52
+    mow_locating = 53
+    mow_adjust_cutter = 54
+    mow_zig_zag = 55
+    mow_edge = 56
+    mow_goto = 57
+    mow_suspend = 58
+    mow_recoverable_fault = 59
+    mow_fault = 60
+    mow_docked_rainfall = 61
+    mow_docked_do_not_disturb = 62
+    mow_docked_low_battery = 63
+    mow_wait = 64
+    mow_prepare_remote = 65
+    mow_remote = 66
+    mow_emergency_stop = 67
+    mow_docked_manual = 68
+    mow_dock_fault = 69
+    mow_remote_undocking = 70
+    mow_to_dock_initializing = 71
+    mow_to_dock_locating = 72
+    mow_to_dock_recoverable_fault = 73
+    mow_to_dock_fault = 74
+    mow_to_dock_emergency_stop = 75
+    mow_to_dock_charging = 76
+    mow_to_dock_charge_completed = 77
+
+    free = 101
+    free_initializing = 102
+    free_locating = 103
+    free_docked_manual = 104
+    free_docked_mow_end = 105
+    free_docked_plan_end = 106
+    free_emergency_stop = 107
+    free_recoverable_fault = 108
+    free_fault = 109
+
+    charge_charging = 151
+    charge_completed = 152
+    charge_waiting = 153
+    charge_fault = 154

{python_roborock-6.2.1 → python_roborock-7.1.1}/roborock/data/mower/mower_containers.py

@@ -1,11 +1,13 @@
 """Data containers for Roborock mower devices."""
 
-from dataclasses import dataclass, field
-from typing import Any
+from dataclasses import dataclass, field, fields
+from typing import Any, Self
 
 from roborock.data.containers import RoborockBase
 from roborock.roborock_message import RoborockMowerDataProtocol
 
+from .mower_code_mappings import RoborockMowerStateCode
+
 
 @dataclass
 class MowerStatus(RoborockBase):
@@ -14,7 +16,9 @@ class MowerStatus(RoborockBase):
     error_code: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.ERROR_CODE})
     battery: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.BATTERY})
     mow_type: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.MOW_TYPE})
-    mow_state: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.MOW_STATE})
+    mow_state: RoborockMowerStateCode | None = field(
+        default=None, metadata={"dps": RoborockMowerDataProtocol.MOW_STATE}
+    )
     mapping_type: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.MAPPING_TYPE})
     mapping_state: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.MAPPING_STATE})
     ota_state: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.OTA_STATE})
@@ -41,3 +45,25 @@ class MowerStatus(RoborockBase):
     )
     afs_status: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.AFS_STATUS})
     network_channel: int | None = field(default=None, metadata={"dps": RoborockMowerDataProtocol.NETWORK_CHANNEL})
+
+    @classmethod
+    def from_dps(cls, dps: dict[int | str, Any] | None) -> Self:
+        """Create mower status from raw DPS data.
+
+        Cloud snapshots use string DPS keys while decoded MQTT messages may use
+        integer keys. Unknown and malformed keys are ignored.
+        """
+        field_by_dps = {
+            int(field_info.metadata["dps"]): field_info.name
+            for field_info in fields(cls)
+            if "dps" in field_info.metadata
+        }
+        values: dict[str, Any] = {}
+        for key, value in (dps or {}).items():
+            try:
+                dps_id = int(key)
+            except (TypeError, ValueError):
+                continue
+            if field_name := field_by_dps.get(dps_id):
+                values[field_name] = value
+        return cls.from_dict(values)

{python_roborock-6.2.1 → python_roborock-7.1.1}/roborock/data/v1/v1_clean_modes.py

@@ -29,7 +29,7 @@ class CleanRoutes(RoborockModeEnum):
     DEEP = ("deep", 301)
     DEEP_PLUS = ("deep_plus", 303)
     FAST = ("fast", 304)
-    DEEP_PLUS_CN = ("deep_plus", 305)
+    DEEP_PLUS_CN = ("deep_plus_cn", 305, "deep_plus")
     SMART_MODE = ("smart_mode", 306)
     CUSTOMIZED = ("custom", 302)
 
@@ -118,10 +118,7 @@ def get_clean_modes(features: DeviceFeatures) -> list[VacuumModes]:
         modes.append(VacuumModes.MAX_PLUS)
     if features.is_pure_clean_mop_supported:
         # If the vacuum is capable of 'pure mop clean' aka no vacuum
-        if features.is_support_main_brush_up_down_supported:
-            modes.append(VacuumModes.OFF_RAISE_MAIN_BRUSH)
-        else:
-            modes.append(VacuumModes.OFF)
+        modes.append(VacuumModes.OFF)
     else:
         # If not, we can add gentle
         modes.append(VacuumModes.GENTLE)
@@ -134,16 +131,19 @@ def get_clean_modes(features: DeviceFeatures) -> list[VacuumModes]:
 
 def get_clean_routes(features: DeviceFeatures, region: str) -> list[CleanRoutes]:
     """The routes that the vacuum will take while mopping"""
+    if not features.is_clean_route_setting_supported:
+        return []
     if features.is_none_pure_clean_mop_with_max_plus:
         return [CleanRoutes.FAST, CleanRoutes.STANDARD]
-    supported = [CleanRoutes.STANDARD, CleanRoutes.DEEP]
+    supported = [CleanRoutes.STANDARD]
+    if not features.is_clean_efficiency_supported:
+        supported.append(CleanRoutes.DEEP)
     if features.is_careful_slow_mop_supported:
-        if not (
-            features.is_corner_clean_mode_supported
+        if (
+            not features.is_corner_clean_mode_supported
             and features.is_clean_route_deep_slow_plus_supported
             and region == "cn"
         ):
-            # for some reason there is a china specific deep plus mode
             supported.append(CleanRoutes.DEEP_PLUS_CN)
         else:
             supported.append(CleanRoutes.DEEP_PLUS)
@@ -218,17 +218,11 @@ def get_cleaning_mode_options(features: DeviceFeatures) -> list[CleaningMode]:
 
 
 def get_mop_only_vacuum_mode(features: DeviceFeatures) -> VacuumModes:
-    """Determine the vacuum mode to use when you just want to mop.
-
-    There are three cases that must be handled:
-    1. The device does not support only mopping.
-    2. The device supports raising the vacuum brush while mopping
-    3. All other cases.
-    """
+    """Return the vacuum mode used by the app for mop-only cleaning."""
     if not features.is_pure_clean_mop_supported:
         raise RoborockUnsupportedFeature("Mop-only cleaning is not supported")
-    if features.is_support_main_brush_up_down_supported:
-        return VacuumModes.OFF_RAISE_MAIN_BRUSH
+    # Main-brush lift is a device capability, not an alternate fan-power
+    # command. The app still sends CleanModeZero (105) for mop-only cleaning.
     return VacuumModes.OFF
 
 

{python_roborock-6.2.1 → python_roborock-7.1.1}/roborock/data/zeo/zeo_code_mappings.py

@@ -1,8 +1,5 @@
 """Zeo (washing machine) device enums.
 
-Member-level comments show the manufacturer's official identifiers
-extracted from the React Native app plugin bundle.
-
 For enums that map between protocol-level positions and physical units
 (e.g. spin speed, temperature), the comment format is
 ``# L<N>, <physical-value>`` where ``L<N>`` is the protocol position
@@ -18,12 +15,7 @@ from ..code_mappings import RoborockEnum
 
 
 class ZeoFeatureBits(RoborockEnum):
-    """Bit positions in DP 237 (FEATURE_BITS).
-
-    Extracted from the official Roborock Washer app plugin bundle
-    (index.ios.bundle, module 726).  Each member's integer value
-    is the exact bit offset the device reports at DP 237.
-    """
+    """Bit positions in DP 237 (FEATURE_BITS)."""
 
     smart_hosting = 0
     silent_mode = 1
@@ -52,7 +44,7 @@ class ZeoFeatureBits(RoborockEnum):
 
 
 class ZeoMode(RoborockEnum):
-    null = 0  # (not found in app bundle)
+    null = 0
     wash = 1
     wash_and_dry = 2
     dry = 3
@@ -60,6 +52,7 @@ class ZeoMode(RoborockEnum):
 
 
 class ZeoState(RoborockEnum):
+    null = 0
     standby = 1
     weighing = 2  # Checking
     soaking = 3
@@ -83,7 +76,7 @@ class ZeoState(RoborockEnum):
 
 
 class ZeoProgram(RoborockEnum):
-    null = 0  # (not found in app bundle)
+    null = 0
     standard = 1  # Mixed
     quick = 2
     sanitize = 3  # Sterilization
@@ -152,6 +145,7 @@ class ZeoSoak(RoborockEnum):
 
 
 class ZeoTemperature(RoborockEnum):
+    null = 0
     normal = 1  # L1, 0 C
     low = 2  # L2, 30 C
     medium = 3  # L3, 40 C
@@ -203,11 +197,13 @@ class ZeoSoftenerType(RoborockEnum):
 
 
 class ZeoDetergentExpansionType(RoborockEnum):
+    null = 0
     concentrated_detergent = 1
     detergent = 2
 
 
 class ZeoSoftenerExpansionType(RoborockEnum):
+    null = 0
     softener = 1
     softener_expansion = 2
     wool_detergent = 3
@@ -241,6 +237,7 @@ class ZeoError(RoborockEnum):
 
 
 class ZeoDryingMethod(RoborockEnum):
+    null = 0
     l1 = 1  # L1, Saving
     l2 = 2  # L2, Standard
     l3 = 3  # L3, SuperFast
@@ -255,11 +252,13 @@ class ZeoSteamVolume(RoborockEnum):
 
 
 class ZeoDryAndCare(RoborockEnum):
+    null = 0
     soft = 1
     normal = 2
 
 
 class ZeoDryerStartError(RoborockEnum):
+    null = 0
     dryer_running = 1  # Washer-Dryer Pairing cannot start: Dryer is running.
     dryer_error = 2  # Washer-Dryer Pairing cannot start: Dryer has an error.
     dryer_done = 3  # Dryer drying is complete, please remove the clothes first.
@@ -269,7 +268,7 @@ class ZeoDryerStartError(RoborockEnum):
     dryer_network_fail = 7  # Please check the dryer network connection.
 
 
-# The following are App-internal lookup tables extracted from the bundle.
+# The following are App-internal lookup tables.
 # They are NOT DP protocol enums — the device never receives these values.
 # They control how the official app adjusts recommended dosages or UI visibility.
 #

{python_roborock-6.2.1 → python_roborock-7.1.1}/roborock/device_features.py

@@ -87,6 +87,7 @@ class NewFeatureStrBit(IntEnum):
     TWO_GEARS_NO_COLLISION = 118
     CARPET_SHAPE_TYPE = 119
     SR_MAP = 120
+    ROLLER_MOP = 128
 
 
 class ProductFeatures(StrEnum):
@@ -474,6 +475,7 @@ class DeviceFeatures(RoborockBase):
     )
     is_carpet_shape_type_supported: bool = field(metadata={"new_feature_str_bit": NewFeatureStrBit.CARPET_SHAPE_TYPE})
     is_sr_map_supported: bool = field(metadata={"new_feature_str_bit": NewFeatureStrBit.SR_MAP})
+    is_roller_mop_supported: bool = field(metadata={"new_feature_str_bit": NewFeatureStrBit.ROLLER_MOP})
 
     # Features from feature_info list
     is_led_status_switch_supported: bool = field(metadata={"robot_features": 119})
@@ -644,6 +646,12 @@ class DeviceFeatures(RoborockBase):
                     if any(feat in available_features for feat in product_features):  # type: ignore
                         kwargs[f.name] = True
 
+        # The app combines runtime shake-mop, model shake/spin, and roller-mop
+        # capabilities when deciding whether mop routes can be configured.
+        kwargs["is_clean_route_setting_supported"] |= (
+            kwargs["is_shake_mop_set_supported"] or kwargs["is_roller_mop_supported"]
+        )
+
         return cls(**kwargs)
 
     def get_supported_features(self) -> list[str]:

{python_roborock-6.2.1 → python_roborock-7.1.1}/roborock/devices/device.py

@@ -202,6 +202,10 @@ class RoborockDevice(ABC, TraitsMixin):
                 await self.v1_properties.start()
             elif self.b01_q10_properties is not None:
                 await self.b01_q10_properties.start()
+            elif self.b01_q7_properties is not None:
+                await self.b01_q7_properties.start()
+            elif self.zeo is not None:
+                await self.zeo.start()
         except RoborockException:
             # Expected: start() can fail transiently. Unsubscribe before propagating
             # so the retry by connect_loop() gets a clean channel.
@@ -230,6 +234,10 @@ class RoborockDevice(ABC, TraitsMixin):
             self.v1_properties.close()
         if self.b01_q10_properties is not None:
             await self.b01_q10_properties.close()
+        if self.b01_q7_properties is not None:
+            await self.b01_q7_properties.close()
+        if self.zeo is not None:
+            self.zeo.close()
         if self._unsub:
             self._unsub()
             self._unsub = None
@@ -243,6 +251,8 @@ class RoborockDevice(ABC, TraitsMixin):
         extra: dict[str, Any] = {}
         if self.v1_properties:
             extra["traits"] = self.v1_properties.as_dict()
+        elif self.b01_q10_properties:
+            extra["traits"] = self.b01_q10_properties.as_dict()
         return redact_device_data(
             {
                 "device": self.device_info.as_dict(),

{python_roborock-6.2.1 → python_roborock-7.1.1}/roborock/devices/rpc/a01_channel.py

@@ -98,8 +98,10 @@ async def send_decoded_command(
         try:
             await asyncio.wait_for(finished.wait(), timeout=_TIMEOUT)
         except TimeoutError as ex:
+            await mqtt_channel.health_manager.on_timeout()
             raise RoborockException(f"Command timed out after {_TIMEOUT}s") from ex
     finally:
         unsub()
 
+    await mqtt_channel.health_manager.on_success()
     return result  # type: ignore[return-value]

{python_roborock-6.2.1 → python_roborock-7.1.1}/roborock/devices/rpc/b01_q7_channel.py

@@ -53,6 +53,10 @@ class Q7MapRpcChannel(Protocol):
         """Send a map command and get decoded bytes."""
         ...
 
+    async def subscribe_map_pushes(self, callback: Callable[[bytes], None]) -> Callable[[], None]:
+        """Subscribe to unsolicited map pushes, invoking callback with decoded SCMap bytes."""
+        ...
+
 
 def _matches_map_response(response_message: RoborockMessage, *, version: bytes | None) -> bytes | None:
     """Return raw map payload bytes for matching MAP_RESPONSE messages."""
@@ -208,6 +212,25 @@ class B01Q7Channel(Channel, Q7RpcChannel, Q7MapRpcChannel):
 
         return decode_map_payload(raw_payload, map_key=self._map_key)
 
+    async def subscribe_map_pushes(self, callback: Callable[[bytes], None]) -> Callable[[], None]:
+        """Subscribe to unsolicited ``MAP_RESPONSE`` pushes.
+
+        The device streams full SCMap frames on its own during cleaning; the
+        callback receives the decoded (inflated) SCMap bytes for each frame.
+        """
+
+        def on_message(message: RoborockMessage) -> None:
+            if (raw_payload := _matches_map_response(message, version=B01_VERSION)) is None:
+                return
+            try:
+                decoded = decode_map_payload(raw_payload, map_key=self._map_key)
+            except RoborockException as ex:
+                _LOGGER.debug("Failed to decode pushed B01 map payload: %s", ex)
+                return
+            callback(decoded)
+
+        return await self._mqtt_channel.subscribe(on_message)
+
 
 def create_b01_q7_channel(
     device: HomeDataDevice,