python-roborock 7.2.2__py3-none-any.whl → 7.3.0__py3-none-any.whl

{python_roborock-7.2.2.dist-info → python_roborock-7.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: python-roborock
-Version: 7.2.2
+Version: 7.3.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-7.2.2.dist-info → python_roborock-7.3.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
 roborock/__init__.py,sha256=jpp3MEmevRvoJ5tq2waCDGH5VfJk--Lv1DmrwEdDyEQ,375
 roborock/broadcast_protocol.py,sha256=fjNQW7NdBKRzSy6126TfCSoYGpT2Esj9Jd-t7tXFc_E,4015
 roborock/callbacks.py,sha256=w2yPXtWFH7zfoFsLPYoCTbfwbE9p1ivA7iDcw20lJQI,4300
-roborock/cli.py,sha256=3OrJAmd9c52cyKLC9jF4-O5UkVXJAWZilOzvnxP7jyc,64097
+roborock/cli.py,sha256=0xTv7rfXSKU19bc2b2SILuFifTVYDcAj-FSQDSOgi1k,63308
 roborock/const.py,sha256=fWpgUPrCgLnaXmncgjCLZET-t7wHWQlpyzV8qHtTjb4,2860
 roborock/device_features.py,sha256=EbMvw4vz0HvN23x9stj5CfNu45HE1tqg4HyygAzkU5Q,46753
 roborock/diagnostics.py,sha256=OVfPCjBVidAlQtFz-WRlgCWOBIaXlO-73xQloXJaLwI,5107
@@ -37,8 +37,8 @@ roborock/data/zeo/zeo_containers.py,sha256=huDeisutagKz1rzsLZr_tGAietec_qOd0KB3i
 roborock/devices/README.md,sha256=zjssyRIlFWTgQz8hLdsJC9_stlHdUQybz7r2af_8q1k,2186
 roborock/devices/__init__.py,sha256=yOWuncnp5wwKPLzcnblsBMGD0v8hcDDDC_x7YdSrN70,129
 roborock/devices/cache.py,sha256=V3KC16LzTEAp_cdAirNtWPjZAgz6ugn3zfsYPyrbWsE,4633
-roborock/devices/device.py,sha256=bhRvHsZC2yhNiwg2yBJVjC8ZO_BJ_NkZMajuABXMHuo,10122
-roborock/devices/device_manager.py,sha256=RPuvbhYxLjdCBrsjYP91dvHTnO8inODsa26m5987VR4,11777
+roborock/devices/device.py,sha256=npRjwXubKBubgFmCesYWugo90kS4TfiLlN6Z_xnP55o,10266
+roborock/devices/device_manager.py,sha256=_1ofbZluoDM-ro7yMnppwaCPAPEGMhDytppuEcMCNyE,11813
 roborock/devices/file_cache.py,sha256=-G2Bm4ra8K_DvSBjntv5hGaRDB-VzSoKWcI0Y_kK6jw,2724
 roborock/devices/rpc/__init__.py,sha256=MDtZovvHi3F4Wbgyzu6gyjAjkZ6xYGU1LRQmtiIapuU,561
 roborock/devices/rpc/a01_channel.py,sha256=R33NQ3hK6pWjPzF2kaWVv93r9RrTWskg6_YWi3Oiiq4,3886
@@ -48,7 +48,7 @@ roborock/devices/rpc/v1_channel.py,sha256=xCQ9YqgTFteU-ptc9-H0w6HtZK3OyH8GBS4QNs
 roborock/devices/traits/__init__.py,sha256=YaL9qoxG6IBG0XXDP0HMTvoc0Jkmq7AF6iH2oYWNtcg,765
 roborock/devices/traits/common.py,sha256=n3fHK4i4bkTU1QL7skMStJiUPIDlpN37z0T9mPQYoOY,4588
 roborock/devices/traits/traits_mixin.py,sha256=7t15l_Ty1cN-3-fKNtRH1XR6-mfadPnTBCQRZP4rAtc,2092
-roborock/devices/traits/a01/__init__.py,sha256=GKu_SWJ9l57u0DU_vd8ec4j6smwrR9s4gUF0yMB-xWA,13284
+roborock/devices/traits/a01/__init__.py,sha256=rRrdXgSsolyNC6MOCyYIfW8oaUmzt-p_uppuhzfYYIU,18375
 roborock/devices/traits/a01/device_feature.py,sha256=6--fV8kRv4nxWIaQlxHt0XFyovhqk6dGeVm-E1n5y_U,13514
 roborock/devices/traits/b01/__init__.py,sha256=pGN6wEocE6Fr2BTasG8Z_75crD6OdTwpju59Vw7eTDk,202
 roborock/devices/traits/b01/q10/__init__.py,sha256=BpeCO7vrM11ISy8JZwBiSkHsTs5-vp68c9YwnWKEIDk,6747
@@ -60,7 +60,7 @@ roborock/devices/traits/b01/q10/common.py,sha256=Qxl3zBAUulqdrjFZJ0DPEFEIJLvlPqU
 roborock/devices/traits/b01/q10/consumable.py,sha256=MbtMgYKqzNdVn6M1iyOAqZPCYTbN_Q_Pr4h8EYGEiuY,669
 roborock/devices/traits/b01/q10/do_not_disturb.py,sha256=klyGQZ_nHyO6bhPlwBl8vElTnMwPf4A8VXwxkU8rMlM,1157
 roborock/devices/traits/b01/q10/dust_collection.py,sha256=LM-0YH4pMrEqLUCFP2g-DymhL5ZUQ4bHd-2EyKHmucY,1582
-roborock/devices/traits/b01/q10/map.py,sha256=1_gFfiSTgJ0XbdfBsiH6QM2Nh6aF25i-IElojEf85v4,7541
+roborock/devices/traits/b01/q10/map.py,sha256=xWODSaUo4LHOhmF89WLPHvxpLgBzlTt6pPmOVCP2Oyc,7276
 roborock/devices/traits/b01/q10/maps.py,sha256=qWk1K47aIf3iJead3A2zQ3Lo0wZ1wcS2mo4qVfiiTDw,2101
 roborock/devices/traits/b01/q10/network_info.py,sha256=XiCr6YPu7xkvhgeaGwXli-_4SB88QW63ykiegyaau2k,656
 roborock/devices/traits/b01/q10/remote.py,sha256=8-fg4SA5M-tdMufHPeD9hIcax7y9Qh7pzcE7rBBVW_o,1267
@@ -125,8 +125,8 @@ roborock/testing/channel.py,sha256=vjulT5MHBe8lAq6XITUqcxJVcCILWx7ZEcw5imTx0Tk,7
 roborock/testing/cloud.py,sha256=L2L0KlZDYaMuoV19KUQUoq5EAUDeNQ1lJ8Ew5YaOgjo,11946
 roborock/testing/simulator.py,sha256=g8ZUWVSjgAzuRRxWOCeOq-7deodyEItwUpqEw9RzCmQ,4347
 roborock/testing/v1_simulator.py,sha256=TQ2PsRoP_4kJvVn-Tm532ByHuaCKltsVjvTa2Ju4PAo,14407
-python_roborock-7.2.2.dist-info/METADATA,sha256=vTfS-_x5Ut3raIemhgfVUN--QARO-jlmV5Ft9Fr0Xrs,5278
-python_roborock-7.2.2.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-python_roborock-7.2.2.dist-info/entry_points.txt,sha256=EvC1nMqi9ZXKgZnqlNXA33v_3nzgPNjnM0mzWlrehnY,47
-python_roborock-7.2.2.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-python_roborock-7.2.2.dist-info/RECORD,,
+python_roborock-7.3.0.dist-info/METADATA,sha256=-UHI17_l7Ty6Txpqlc7NcpxYnkhKNsFsb3u4L3qxn7k,5278
+python_roborock-7.3.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+python_roborock-7.3.0.dist-info/entry_points.txt,sha256=EvC1nMqi9ZXKgZnqlNXA33v_3nzgPNjnM0mzWlrehnY,47
+python_roborock-7.3.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+python_roborock-7.3.0.dist-info/RECORD,,

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 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.
+# The Q10 publishes its current map asynchronously after a REQUEST_DPS. 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
 
 
@@ -609,10 +609,9 @@ async def _await_q10_map_push(
 ) -> bool:
     """Request Q10 map content and wait for usable map-trait state.
 
-    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.
+    The read-only ``REQUEST_DPS`` request returns immediately; current map
+    content 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,20 +623,6 @@ async def _await_q10_map_push(
     unsub = properties.map.add_update_listener(on_update)
     try:
         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

roborock/devices/device.py

@@ -206,6 +206,8 @@ class RoborockDevice(ABC, TraitsMixin):
                 await self.b01_q7_properties.start()
             elif self.zeo is not None:
                 await self.zeo.start()
+            elif self.dyad is not None:
+                await self.dyad.start()
         except RoborockException:
             # Expected: start() can fail transiently. Unsubscribe before propagating
             # so the retry by connect_loop() gets a clean channel.
@@ -238,6 +240,8 @@ class RoborockDevice(ABC, TraitsMixin):
             await self.b01_q7_properties.close()
         if self.zeo is not None:
             self.zeo.close()
+        if self.dyad is not None:
+            self.dyad.close()
         if self._unsub:
             self._unsub()
             self._unsub = None

roborock/devices/device_manager.py

@@ -255,7 +255,7 @@ async def create_device_manager(
                 )
             case DeviceVersion.A01:
                 channel = create_mqtt_channel(user_data, mqtt_params, mqtt_session, device)
-                trait = a01.create(product, channel)
+                trait = a01.create(product, channel, device_status=device.device_status)
             case DeviceVersion.B01:
                 mqtt_channel = create_mqtt_channel(user_data, mqtt_params, mqtt_session, device)
                 model_part = product.model.split(".")[-1]

roborock/devices/traits/a01/__init__.py

@@ -6,7 +6,7 @@ Dyad (Wet/Dry Vacuums) and Zeo (Washing Machines).
 Using A01 APIs
 --------------
 A01 devices expose a single API object that handles all device interactions. This API is
-available on the device instance (typically via `device.a01_properties`).
+available on the device instance (`device.dyad` or `device.zeo`).
 
 The API provides these methods:
 1.  **query_values(protocols)**: Fetches current state for specific data points.
@@ -14,18 +14,22 @@ The API provides these methods:
     `RoborockZeoProtocol`) to request specific data.
 2.  **set_value(protocol, value)**: Sends a command to the device to change a setting
     or perform an action.
-3.  **add_listener(callback)**: Subscribes to state the device pushes on its own (for
-    example when its state changes), invoking the callback with decoded values.
-
-Note that these APIs fetch data directly from the device upon request and do not
-cache state internally.
+3.  **values**: The latest known state, merged from query responses and unsolicited
+    pushes in arrival order.
+4.  **add_update_listener(callback)**: Registers a callback invoked whenever `values`
+    changes; read `values` from the callback to get the updated state.
+
+The device pushes only the data points that changed, so `values` is the merged view
+of everything seen so far. State tracking is active once the device is connected
+(the device calls `start()` on the API, which subscribes to the MQTT topic).
 """
 
 import json
 import logging
+from abc import abstractmethod
 from collections.abc import Callable
-from datetime import time
-from typing import Any
+from datetime import UTC, datetime, time
+from typing import Any, Generic, TypeVar
 
 from roborock.data import DyadProductInfo, DyadSndState, HomeDataProduct, RoborockCategory
 from roborock.data.dyad.dyad_code_mappings import (
@@ -73,6 +77,7 @@ from roborock.roborock_message import (
 _LOGGER = logging.getLogger(__name__)
 
 __all__ = [
+    "A01Api",
     "DyadApi",
     "ZeoApi",
 ]
@@ -155,14 +160,121 @@ def convert_zeo_value(protocol_value: RoborockZeoProtocol, value: Any) -> Any:
 
 
 _DYAD_PROTOCOL_VALUES = frozenset(protocol.value for protocol in RoborockDyadDataProtocol)
+_ZEO_PROTOCOL_VALUES = frozenset(protocol.value for protocol in RoborockZeoProtocol)
 
+_P = TypeVar("_P", RoborockDyadDataProtocol, RoborockZeoProtocol)
 
-class DyadApi(Trait):
-    """API for interacting with Dyad devices."""
 
-    def __init__(self, channel: MqttChannel) -> None:
-        """Initialize the Dyad API."""
+class A01Api(Trait, TraitUpdateListener, Generic[_P]):
+    """Base class for A01 device APIs with device state tracking.
+
+    Query responses and unsolicited pushes both arrive on the same MQTT topic,
+    so a single subscription merges every decoded message into `values` in
+    arrival order. Update listeners are notified whenever a value changes.
+    """
+
+    def __init__(self, channel: MqttChannel, initial_status: dict[int, Any] | None = None) -> None:
+        """Initialize the A01 API, optionally seeding `values` from a cloud status snapshot."""
+        TraitUpdateListener.__init__(self, _LOGGER)
         self._channel = channel
+        self._values: dict[_P, Any] = {}
+        self._unsub: Callable[[], None] | None = None
+        self._last_message_time: datetime | None = None
+        if initial_status:
+            self._merge_values(self._decode_datapoints(initial_status))
+
+    @property
+    def values(self) -> dict[_P, Any]:
+        """Latest known device state, merged from query responses and pushes.
+
+        The device pushes only the data points that changed, so this is the
+        merged view of everything seen so far. A protocol the device has not
+        reported yet is absent from the dictionary.
+        """
+        return dict(self._values)
+
+    @property
+    def last_message_time(self) -> datetime | None:
+        """Time the last message was received from the device.
+
+        Updated on every decoded message, even when no value changed: idle
+        devices push an identical heartbeat, so this is the liveness signal
+        even when `values` stays the same and update listeners stay silent.
+        The initial cloud status snapshot does not count as a message.
+        """
+        return self._last_message_time
+
+    async def start(self) -> None:
+        """Subscribe to the device state topic and start tracking `values`."""
+        await self._ensure_subscribed()
+
+    def close(self) -> None:
+        """Unsubscribe from MQTT push and release resources."""
+        if self._unsub is not None:
+            self._unsub()
+            self._unsub = None
+
+    async def _ensure_subscribed(self) -> None:
+        """Subscribe to MQTT DPS push (idempotent)."""
+        if self._unsub is not None:
+            return
+        self._unsub = await self._channel.subscribe(self._on_message)
+
+    @abstractmethod
+    def _decode_datapoints(self, datapoints: dict[int, Any]) -> dict[_P, Any]:
+        """Convert raw datapoints to typed values, skipping unknown codes."""
+
+    def _on_message(self, message: RoborockMessage) -> None:
+        """Handle a message on the device topic (query response or push)."""
+        if message.protocol != RoborockMessageProtocol.RPC_RESPONSE:
+            return
+        try:
+            datapoints = decode_rpc_response(message)
+        except RoborockException:
+            _LOGGER.debug("Dropped malformed push message", exc_info=True)
+            return
+        self._last_message_time = datetime.now(UTC)
+        self._merge_values(self._decode_datapoints(datapoints))
+
+    def _merge_query_response(self, values: dict[_P, Any]) -> None:
+        """Record a successful query response when there is no subscription.
+
+        When subscribed, the response was already merged in arrival order and
+        timestamped by `_on_message`; merging again here could overwrite a
+        push that arrived after it.
+        """
+        if self._unsub is not None:
+            return
+        self._last_message_time = datetime.now(UTC)
+        self._merge_values(values)
+
+    def _merge_values(self, values: dict[_P, Any]) -> None:
+        """Merge decoded values into the cache and notify on change."""
+        changed = False
+        for protocol, value in values.items():
+            if value is None:
+                continue
+            if protocol not in self._values or self._values[protocol] != value:
+                self._values[protocol] = value
+                changed = True
+        if changed:
+            self._notify_update()
+
+
+class DyadApi(A01Api[RoborockDyadDataProtocol]):
+    """API for interacting with Dyad devices."""
+
+    name = "dyad"
+
+    def _decode_datapoints(self, datapoints: dict[int, Any]) -> dict[RoborockDyadDataProtocol, Any]:
+        """Convert raw datapoints to typed values, skipping unknown codes."""
+        values: dict[RoborockDyadDataProtocol, Any] = {}
+        for code, value in datapoints.items():
+            if code not in _DYAD_PROTOCOL_VALUES:
+                continue
+            protocol = RoborockDyadDataProtocol(code)
+            values[protocol] = convert_dyad_value(protocol, value)
+        return values
 
     async def query_values(self, protocols: list[RoborockDyadDataProtocol]) -> dict[RoborockDyadDataProtocol, Any]:
         """Query the device for the values of the given Dyad protocols."""
@@ -171,7 +283,9 @@ class DyadApi(Trait):
             {RoborockDyadDataProtocol.ID_QUERY: protocols},
             value_encoder=json.dumps,
         )
-        return {protocol: convert_dyad_value(protocol, response.get(protocol)) for protocol in protocols}
+        values = {protocol: convert_dyad_value(protocol, response.get(protocol)) for protocol in protocols}
+        self._merge_query_response(values)
+        return values
 
     async def set_value(self, protocol: RoborockDyadDataProtocol, value: Any) -> dict[RoborockDyadDataProtocol, Any]:
         """Set a value for a specific protocol on the device."""
@@ -184,6 +298,9 @@ class DyadApi(Trait):
         The callback is invoked with decoded values whenever the device sends a
         message, including unsolicited pushes when its state changes. Only known
         protocols are delivered. Returns a callable to remove the listener.
+
+        Prefer `add_update_listener` together with `values`, which handle the
+        merging of partial pushes for you.
         """
 
         def on_message(message: RoborockMessage) -> None:
@@ -191,31 +308,24 @@ class DyadApi(Trait):
                 datapoints = decode_rpc_response(message)
             except RoborockException:
                 return
-            values: dict[RoborockDyadDataProtocol, Any] = {}
-            for code, value in datapoints.items():
-                if code not in _DYAD_PROTOCOL_VALUES:
-                    continue
-                protocol = RoborockDyadDataProtocol(code)
-                values[protocol] = convert_dyad_value(protocol, value)
-            if values:
+            if values := self._decode_datapoints(datapoints):
                 callback(values)
 
         return await self._channel.subscribe(on_message)
 
 
-class ZeoApi(Trait, TraitUpdateListener):
+class ZeoApi(A01Api[RoborockZeoProtocol]):
     """API for interacting with Zeo devices."""
 
     name = "zeo"
 
-    def __init__(self, channel: MqttChannel, model: str | None = None) -> None:
+    def __init__(
+        self, channel: MqttChannel, model: str | None = None, initial_status: dict[int, Any] | None = None
+    ) -> None:
         """Initialize the Zeo API."""
-        TraitUpdateListener.__init__(self, _LOGGER)
-        self._channel = channel
-        self._dps_cache: dict[int, Any] = {}
-        self._dps_unsub: Callable[[], None] | None = None
         self._feature_bits: int = 0
         self._model = model
+        super().__init__(channel, initial_status)
 
     async def start(self) -> None:
         """Subscribe to MQTT push and trigger a full state sync.
@@ -230,17 +340,15 @@ class ZeoApi(Trait, TraitUpdateListener):
         await self._force_load()
         await self._load_feature_dps()
 
-    def close(self) -> None:
-        """Unsubscribe from MQTT push and release resources."""
-        if self._dps_unsub is not None:
-            self._dps_unsub()
-            self._dps_unsub = None
-
-    async def _ensure_subscribed(self) -> None:
-        """Subscribe to MQTT DPS push (idempotent)."""
-        if self._dps_unsub is not None:
-            return
-        self._dps_unsub = await self._channel.subscribe(self._on_dps_message)
+    def _decode_datapoints(self, datapoints: dict[int, Any]) -> dict[RoborockZeoProtocol, Any]:
+        """Convert raw datapoints to typed values, skipping unknown codes."""
+        values: dict[RoborockZeoProtocol, Any] = {}
+        for code, value in datapoints.items():
+            if code not in _ZEO_PROTOCOL_VALUES:
+                continue
+            protocol = RoborockZeoProtocol(code)
+            values[protocol] = convert_zeo_value(protocol, value)
+        return values
 
     async def _force_load(self) -> None:
         """Send ID_QUERY with the base DP list to trigger a full state push.
@@ -279,18 +387,6 @@ class ZeoApi(Trait, TraitUpdateListener):
         """Check whether the device supports a given feature bit."""
         return bool(self._feature_bits & (1 << feature.value))
 
-    def _on_dps_message(self, message: RoborockMessage) -> None:
-        """Handle unsolicited MQTT push (protocol 102 — RPC_RESPONSE)."""
-        if message.protocol != RoborockMessageProtocol.RPC_RESPONSE:
-            return
-        try:
-            decoded = decode_rpc_response(message)
-        except RoborockException:
-            _LOGGER.debug("Dropped malformed push message", exc_info=True)
-            return
-        self._dps_cache.update(decoded)
-        self._notify_update()
-
     async def query_values(self, protocols: list[RoborockZeoProtocol]) -> dict[RoborockZeoProtocol, Any]:
         """Query the device for the values of the given protocols."""
         response = await send_decoded_command(
@@ -298,7 +394,9 @@ class ZeoApi(Trait, TraitUpdateListener):
             {RoborockZeoProtocol.ID_QUERY: protocols},
             value_encoder=json.dumps,
         )
-        return {protocol: convert_zeo_value(protocol, response.get(protocol)) for protocol in protocols}
+        values = {protocol: convert_zeo_value(protocol, response.get(protocol)) for protocol in protocols}
+        self._merge_query_response(values)
+        return values
 
     async def set_value(self, protocol: RoborockZeoProtocol, value: Any) -> dict[RoborockZeoProtocol, Any]:
         """Set a value for a specific protocol on the device."""
@@ -306,12 +404,28 @@ class ZeoApi(Trait, TraitUpdateListener):
         return await send_decoded_command(self._channel, params, value_encoder=lambda x: x)
 
 
-def create(product: HomeDataProduct, mqtt_channel: MqttChannel) -> DyadApi | ZeoApi:
-    """Create traits for A01 devices."""
+def _parse_device_status(device_status: dict | None) -> dict[int, Any] | None:
+    """Normalize the cloud home data status snapshot to integer datapoint codes."""
+    if not device_status:
+        return None
+    try:
+        return {int(code): value for code, value in device_status.items()}
+    except (TypeError, ValueError):
+        _LOGGER.debug("Ignoring malformed device status snapshot: %s", device_status)
+        return None
+
+
+def create(product: HomeDataProduct, mqtt_channel: MqttChannel, device_status: dict | None = None) -> DyadApi | ZeoApi:
+    """Create traits for A01 devices.
+
+    The optional `device_status` is the cloud home data status snapshot, used
+    to seed `values` so state is available before the first device round trip.
+    """
+    initial_status = _parse_device_status(device_status)
     match product.category:
         case RoborockCategory.WET_DRY_VAC:
-            return DyadApi(mqtt_channel)
+            return DyadApi(mqtt_channel, initial_status=initial_status)
         case RoborockCategory.WASHING_MACHINE:
-            return ZeoApi(mqtt_channel, model=product.model)
+            return ZeoApi(mqtt_channel, model=product.model, initial_status=initial_status)
         case _:
             raise NotImplementedError(f"Unsupported category {product.category}")

roborock/devices/traits/b01/q10/map.py

@@ -7,10 +7,10 @@ Map-related state arrives on three independent streams:
 * restricted zones, virtual walls and dock state arrive as ordinary DPS values.
 
 ``MapDpsTrait`` owns the low-level map-specific DPS read model.
-``MapContentTrait`` uses a stored ID from ``MapsTrait`` only when it requests
-content. It combines the latest map and trace packets with the map DPS state
-through the pure functions in :mod:`roborock.map.b01_q10_render`. Map-list
-updates do not refresh content.
+``MapContentTrait`` requests a current-map push through ``REQUEST_DPS`` and
+combines the latest map and trace packets with the map DPS state through the
+pure functions in :mod:`roborock.map.b01_q10_render`. Saved-map list/detail
+operations remain on ``MapsTrait``.
 """
 
 import logging
@@ -107,20 +107,13 @@ class MapContentTrait(TraitUpdateListener):
         self._map_dps.add_update_listener(self._map_dps_updated)
 
     async def refresh(self) -> None:
-        """Request content for the first map in the latest saved-map list."""
-        if (map_id := self._maps.current_map_id) is None:
-            raise RoborockException("Cannot request Q10 map content before the map list is available")
-        # Map lists and map content can change at different times. Reuse the
-        # stored ID so a content refresh does not also refresh the list.
-        await self._command.send(
-            B01_Q10_DP.COMMON,
-            {
-                str(B01_Q10_DP.MULTI_MAP.code): {
-                    "op": "get",
-                    "id": map_id,
-                }
-            },
-        )
+        """Request a safe asynchronous current-map/status push.
+
+        Some ss07 firmware treats ``dpMultiMap op:get`` as an active
+        cleaning/relocation command. ``REQUEST_DPS`` is the device's read-only
+        current-map request and does not depend on a saved-map ID.
+        """
+        await self._command.send(B01_Q10_DP.REQUEST_DPS, params={})
 
     @property
     def image_content(self) -> bytes | None: