🦎 q7: align map trait with refresh-based pattern

Author: arduano

roborock/devices/rpc/b01_q7_channel.py

@@ -102,14 +102,7 @@ def find_response(response_message: RoborockMessage) -> None:
 
 
 async def send_map_command(mqtt_channel: MqttChannel, request_message: Q7RequestMessage) -> bytes:
-    """Send map upload command and wait for the map payload bytes.
-
-    On a real Q7 B01 device, map uploads arrive as a dedicated
-    ``MAP_RESPONSE`` message with raw payload bytes.
-
-    We still decode RPC responses so we can fail fast on non-zero ``code``
-    values for the initiating request (matched by msgId).
-    """
+    """Send map upload command and wait for MAP_RESPONSE payload bytes."""
 
     roborock_message = encode_mqtt_payload(request_message)
     future: asyncio.Future[bytes] = asyncio.get_running_loop().create_future()
@@ -124,29 +117,6 @@ def find_response(response_message: RoborockMessage) -> None:
             and response_message.version == roborock_message.version
         ):
             future.set_result(response_message.payload)
-            return
-
-        # Optional: look for an error response correlated by msgId.
-        try:
-            decoded_dps = decode_rpc_response(response_message)
-        except RoborockException:
-            return
-
-        dps_value = decoded_dps.get(request_message.dps)
-        if not isinstance(dps_value, str):
-            return
-
-        try:
-            inner = json.loads(dps_value)
-        except (json.JSONDecodeError, TypeError):
-            return
-
-        if not isinstance(inner, dict) or inner.get("msgId") != str(request_message.msg_id):
-            return
-
-        code = inner.get("code", 0)
-        if code != 0:
-            future.set_exception(RoborockException(f"B01 command failed with code {code} ({request_message})"))
 
     unsub = await mqtt_channel.subscribe(find_response)
     try:

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

@@ -36,10 +36,22 @@ def __init__(self, channel: MqttChannel) -> None:
         self._channel = channel
         # Map uploads are serialized per-device to avoid response cross-wiring.
         self._map_command_lock = asyncio.Lock()
-        self._map_list_cache: Q7MapList | None = None
+        self._map_list: Q7MapList | None = None
 
-    async def refresh_map_list(self) -> Q7MapList:
-        """Fetch and cache map list metadata from the robot."""
+    @property
+    def map_list(self) -> Q7MapList | None:
+        """Latest cached map list metadata, populated by ``refresh()``."""
+        return self._map_list
+
+    @property
+    def current_map_id(self) -> int | None:
+        """Current map id derived from cached map list metadata."""
+        if self._map_list is None:
+            return None
+        return self._extract_current_map_id(self._map_list)
+
+    async def refresh(self) -> None:
+        """Refresh cached map list metadata from the device."""
         response = await send_decoded_command(
             self._channel,
             Q7RequestMessage(dps=_Q7_DPS, command=RoborockB01Q7Methods.GET_MAP_LIST, params={}),
@@ -51,24 +63,9 @@ async def refresh_map_list(self) -> Q7MapList:
         if parsed is None:
             raise TypeError(f"Failed to decode map list response: {response!r}")
 
-        self._map_list_cache = parsed
-        return parsed
-
-    async def get_map_list(self, *, refresh: bool = False) -> Q7MapList:
-        """Return cached map list metadata, refreshing when requested or absent."""
-        if refresh or self._map_list_cache is None:
-            return await self.refresh_map_list()
-        return self._map_list_cache
+        self._map_list = parsed
 
-    async def get_current_map_id(self, *, refresh: bool = False) -> int:
-        """Resolve and return the currently active map id from map list metadata."""
-        map_list = await self.get_map_list(refresh=refresh)
-        map_id = self._extract_current_map_id(map_list)
-        if map_id is None:
-            raise RoborockException(f"Unable to determine map_id from map list response: {map_list!r}")
-        return map_id
-
-    async def get_map_payload(self, *, map_id: int) -> bytes:
+    async def _get_map_payload(self, *, map_id: int) -> bytes:
         """Fetch raw map payload bytes for the given map id."""
         request = Q7RequestMessage(
             dps=_Q7_DPS,
@@ -78,10 +75,15 @@ async def get_map_payload(self, *, map_id: int) -> bytes:
         async with self._map_command_lock:
             return await send_map_command(self._channel, request)
 
-    async def get_current_map_payload(self, *, refresh_map_list: bool = False) -> bytes:
+    async def get_current_map_payload(self) -> bytes:
         """Fetch raw map payload bytes for the currently selected map."""
-        map_id = await self.get_current_map_id(refresh=refresh_map_list)
-        return await self.get_map_payload(map_id=map_id)
+        if self._map_list is None:
+            await self.refresh()
+
+        map_id = self.current_map_id
+        if map_id is None:
+            raise RoborockException(f"Unable to determine map_id from map list response: {self._map_list!r}")
+        return await self._get_map_payload(map_id=map_id)
 
     @staticmethod
     def _extract_current_map_id(map_list_response: Q7MapList) -> int | None:

tests/devices/traits/b01/q7/test_init.py

@@ -309,21 +309,24 @@ async def test_q7_api_get_current_map_payload(
     assert second_payload["dps"]["10000"]["params"] == {"map_id": 1772093512}
 
 
-async def test_q7_api_map_trait_caches_map_list(
+async def test_q7_api_map_trait_refresh_populates_cached_values(
     q7_api: Q7PropertiesApi,
     fake_channel: FakeChannel,
     message_builder: B01MessageBuilder,
 ):
-    """Map list is represented as dataclasses and cached on the map trait."""
+    """Map trait follows refresh + cached-value access pattern."""
     fake_channel.response_queue.append(message_builder.build({"map_list": [{"id": 101, "cur": True}]}))
 
-    first = await q7_api.map.get_map_list()
-    second = await q7_api.map.get_map_list()
+    assert q7_api.map.map_list is None
+    assert q7_api.map.current_map_id is None
+
+    await q7_api.map.refresh()
 
     assert len(fake_channel.published_messages) == 1
-    assert first is second
-    assert first.map_list[0].id == 101
-    assert first.map_list[0].cur is True
+    assert q7_api.map.map_list is not None
+    assert q7_api.map.map_list.map_list[0].id == 101
+    assert q7_api.map.map_list.map_list[0].cur is True
+    assert q7_api.map.current_map_id == 101
 
 
 async def test_q7_api_get_current_map_payload_falls_back_to_first_map(