Merge branch 'main' into leo/pr774-split-01-q7-commands

Author: arduano

CHANGELOG.md

@@ -2,6 +2,72 @@
 
 <!-- version list -->
 
+## v4.20.0 (2026-03-09)
+
+### Chores
+
+- Update current_rooms to return empty list instead of None
+  ([#781](https://github.com/Python-roborock/python-roborock/pull/781),
+  [`5853450`](https://github.com/Python-roborock/python-roborock/commit/5853450f182f1b04e65ae553633afc83fbf80c02))
+
+### Features
+
+- Add `current_rooms` property to the `Home` trait and include corresponding tests.
+  ([#781](https://github.com/Python-roborock/python-roborock/pull/781),
+  [`5853450`](https://github.com/Python-roborock/python-roborock/commit/5853450f182f1b04e65ae553633afc83fbf80c02))
+
+- Allow rooms trait to unconditionally override map info rooms during merging.
+  ([#781](https://github.com/Python-roborock/python-roborock/pull/781),
+  [`5853450`](https://github.com/Python-roborock/python-roborock/commit/5853450f182f1b04e65ae553633afc83fbf80c02))
+
+- Improve room naming and data integration
+  ([#781](https://github.com/Python-roborock/python-roborock/pull/781),
+  [`5853450`](https://github.com/Python-roborock/python-roborock/commit/5853450f182f1b04e65ae553633afc83fbf80c02))
+
+- Improve room naming and data integration by introducing `raw_name` to `NamedRoomMapping` and
+  enhancing `iot_id` and name mapping from `HomeData`.
+  ([#781](https://github.com/Python-roborock/python-roborock/pull/781),
+  [`5853450`](https://github.com/Python-roborock/python-roborock/commit/5853450f182f1b04e65ae553633afc83fbf80c02))
+
+### Refactoring
+
+- Move NamedRoomMapping import from roborock.data.containers to roborock.data
+  ([#781](https://github.com/Python-roborock/python-roborock/pull/781),
+  [`5853450`](https://github.com/Python-roborock/python-roborock/commit/5853450f182f1b04e65ae553633afc83fbf80c02))
+
+- Update rooms_map dictionary key type from string to integer
+  ([#781](https://github.com/Python-roborock/python-roborock/pull/781),
+  [`5853450`](https://github.com/Python-roborock/python-roborock/commit/5853450f182f1b04e65ae553633afc83fbf80c02))
+
+
+## v4.19.1 (2026-03-09)
+
+### Bug Fixes
+
+- Add missing return value ([#782](https://github.com/Python-roborock/python-roborock/pull/782),
+  [`3625590`](https://github.com/Python-roborock/python-roborock/commit/36255901f1ade071b97bd116bf2b00c6d152c042))
+
+
+## v4.19.0 (2026-03-08)
+
+### Bug Fixes
+
+- Make room name always room num and not unknown
+  ([#780](https://github.com/Python-roborock/python-roborock/pull/780),
+  [`2bd569c`](https://github.com/Python-roborock/python-roborock/commit/2bd569caffe7e85bc08637fd9b8ed70eeade5aa8))
+
+### Chores
+
+- Address comments ([#780](https://github.com/Python-roborock/python-roborock/pull/780),
+  [`2bd569c`](https://github.com/Python-roborock/python-roborock/commit/2bd569caffe7e85bc08637fd9b8ed70eeade5aa8))
+
+### Features
+
+- Use get_rooms to limit issues with missing room names
+  ([#780](https://github.com/Python-roborock/python-roborock/pull/780),
+  [`2bd569c`](https://github.com/Python-roborock/python-roborock/commit/2bd569caffe7e85bc08637fd9b8ed70eeade5aa8))
+
+
 ## v4.18.1 (2026-03-07)
 
 ### Bug Fixes

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-roborock"
-version = "4.18.1"
+version = "4.20.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"

roborock/data/containers.py

@@ -301,6 +301,11 @@ class HomeDataRoom(RoborockBase):
     id: int
     name: str
 
+    @property
+    def iot_id(self) -> str:
+        """Return the room's ID as a string IOT ID."""
+        return str(self.id)
+
 
 @dataclass
 class HomeDataScene(RoborockBase):
@@ -352,6 +357,16 @@ def device_products(self) -> dict[str, tuple[HomeDataDevice, HomeDataProduct]]:
             if (product := product_map.get(device.product_id)) is not None
         }
 
+    @property
+    def rooms_map(self) -> dict[str, HomeDataRoom]:
+        """Returns a dictionary of Room iot_id to rooms"""
+        return {room.iot_id: room for room in self.rooms}
+
+    @property
+    def rooms_name_map(self) -> dict[str, str]:
+        """Returns a dictionary of Room iot_id to room names."""
+        return {room.iot_id: room.name for room in self.rooms}
+
 
 @dataclass
 class LoginData(RoborockBase):
@@ -388,8 +403,13 @@ class NamedRoomMapping(RoomMapping):
     from the HomeData based on the iot_id from the room.
     """
 
-    name: str
-    """The human-readable name of the room, if available."""
+    @property
+    def name(self) -> str:
+        """The human-readable name of the room, or a default name if not available."""
+        return self.raw_name or f"Room {self.segment_id}"
+
+    raw_name: str | None = None
+    """The raw name of the room, as provided by the device."""
 
 
 @dataclass
@@ -409,6 +429,11 @@ class CombinedMapInfo(RoborockBase):
     rooms: list[NamedRoomMapping]
     """The list of rooms in the map."""
 
+    @property
+    def rooms_map(self) -> dict[int, NamedRoomMapping]:
+        """Returns a mapping of segment_id to NamedRoomMapping."""
+        return {room.segment_id: room for room in self.rooms}
+
 
 @dataclass
 class BroadcastMessage(RoborockBase):

roborock/data/v1/v1_containers.py

@@ -38,7 +38,7 @@
 )
 from roborock.exceptions import RoborockException
 
-from ..containers import RoborockBase, RoborockBaseTimer, _attr_repr
+from ..containers import NamedRoomMapping, RoborockBase, RoborockBaseTimer, _attr_repr
 from .v1_code_mappings import (
     CleanFluidStatus,
     ClearWaterBoxStatus,
@@ -400,6 +400,7 @@ def clean_fluid_status(self) -> CleanFluidStatus | None:
             value = (self.dss >> 10) & 3
             if value == 0:
                 return None  # Feature not supported by this device
+            return CleanFluidStatus(value)
         return None
 
     @property
@@ -686,6 +687,17 @@ class MultiMapsListRoom(RoborockBase):
     iot_name_id: str | None = None
     iot_name: str | None = None
 
+    @property
+    def named_room_mapping(self) -> NamedRoomMapping | None:
+        """Returns a NamedRoomMapping object if valid."""
+        if self.id is None or self.iot_name_id is None:
+            return None
+        return NamedRoomMapping(
+            segment_id=self.id,
+            iot_id=self.iot_name_id,
+            raw_name=self.iot_name,
+        )
+
 
 @dataclass
 class MultiMapsListMapInfoBakMaps(RoborockBase):
@@ -707,6 +719,15 @@ def mapFlag(self) -> int:
         """Alias for map_flag, returns the map flag as an integer."""
         return self.map_flag
 
+    @property
+    def rooms_map(self) -> dict[int, NamedRoomMapping]:
+        """Returns a dictionary of room mappings by segment id."""
+        return {
+            room.id: mapping
+            for room in self.rooms or ()
+            if room.id is not None and (mapping := room.named_room_mapping) is not None
+        }
+
 
 @dataclass
 class MultiMapsList(RoborockBase):

roborock/devices/traits/v1/__init__.py

@@ -193,7 +193,7 @@ def __init__(
         self.device_features = DeviceFeaturesTrait(product, self._device_cache)
         self.status = StatusTrait(self.device_features, region=self._region)
         self.consumables = ConsumableTrait()
-        self.rooms = RoomsTrait(home_data)
+        self.rooms = RoomsTrait(home_data, web_api)
         self.maps = MapsTrait(self.status)
         self.map_content = MapContentTrait(map_parser_config)
         self.home = HomeTrait(self.status, self.maps, self.map_content, self.rooms, self._device_cache)

roborock/devices/traits/v1/home.py

@@ -20,7 +20,7 @@
 import logging
 from typing import Self
 
-from roborock.data import CombinedMapInfo, NamedRoomMapping, RoborockBase
+from roborock.data import CombinedMapInfo, MultiMapsListMapInfo, NamedRoomMapping, RoborockBase
 from roborock.data.v1.v1_code_mappings import RoborockStateCode
 from roborock.devices.cache import DeviceCache
 from roborock.devices.traits.v1 import common
@@ -114,34 +114,24 @@ async def discover_home(self) -> None:
         self._discovery_completed = True
         await self._update_home_cache(home_map_info, home_map_content)
 
-    async def _refresh_map_info(self, map_info) -> CombinedMapInfo:
+    async def _refresh_map_info(self, map_info: MultiMapsListMapInfo) -> CombinedMapInfo:
         """Collect room data for a specific map and return CombinedMapInfo."""
         await self._rooms_trait.refresh()
 
-        rooms: dict[int, NamedRoomMapping] = {}
-        if map_info.rooms:
-            # Not all vacuums resopnd with rooms inside map_info.
-            for room in map_info.rooms:
-                if room.id is not None and room.iot_name_id is not None:
-                    rooms[room.id] = NamedRoomMapping(
-                        segment_id=room.id,
-                        iot_id=room.iot_name_id,
-                        name=room.iot_name or "Unknown",
-                    )
-
-        # Add rooms from rooms_trait. If room already exists and rooms_trait has "Unknown", don't override.
-        if self._rooms_trait.rooms:
-            for room in self._rooms_trait.rooms:
-                if room.segment_id is not None and room.name:
-                    if room.segment_id not in rooms or room.name != "Unknown":
-                        # Add the room to rooms if the room segment is not already in it
-                        # or if the room name isn't unknown.
-                        rooms[room.segment_id] = room
-
+        # We have room names from multiple sources:
+        # - The map_info.rooms which we just received from the MultiMapsList
+        # - RoomsTrait rooms come from the GET_ROOM_MAPPING command for the current device (only)
+        # - RoomsTrait rooms that are pulled from the cloud API
+        # We always prefer the RoomsTrait room names since they are always newer and
+        # just refreshed above.
+        rooms_map: dict[int, NamedRoomMapping] = {
+            **map_info.rooms_map,
+            **{room.segment_id: room for room in self._rooms_trait.rooms or ()},
+        }
         return CombinedMapInfo(
             map_flag=map_info.map_flag,
             name=map_info.name,
-            rooms=list(rooms.values()),
+            rooms=list(rooms_map.values()),
         )
 
     async def _refresh_map_content(self) -> MapContent:
@@ -231,6 +221,13 @@ def current_map_data(self) -> CombinedMapInfo | None:
             return None
         return self._home_map_info.get(current_map_flag)
 
+    @property
+    def current_rooms(self) -> list[NamedRoomMapping]:
+        """Returns the room names for the current map."""
+        if self.current_map_data is None:
+            return []
+        return self.current_map_data.rooms
+
     @property
     def home_map_content(self) -> dict[int, MapContent] | None:
         """Returns the map content for all cached maps."""

roborock/devices/traits/v1/rooms.py

@@ -3,14 +3,13 @@
 import logging
 from dataclasses import dataclass
 
-from roborock.data import HomeData, NamedRoomMapping, RoborockBase
+from roborock.data import HomeData, HomeDataRoom, NamedRoomMapping, RoborockBase
 from roborock.devices.traits.v1 import common
 from roborock.roborock_typing import RoborockCommand
+from roborock.web_api import UserWebApiClient
 
 _LOGGER = logging.getLogger(__name__)
 
-_DEFAULT_NAME = "Unknown"
-
 
 @dataclass
 class Rooms(RoborockBase):
@@ -32,50 +31,75 @@ class RoomsTrait(Rooms, common.V1TraitMixin):
 
     command = RoborockCommand.GET_ROOM_MAPPING
 
-    def __init__(self, home_data: HomeData) -> None:
+    def __init__(self, home_data: HomeData, web_api: UserWebApiClient) -> None:
         """Initialize the RoomsTrait."""
         super().__init__()
         self._home_data = home_data
+        self._web_api = web_api
+        self._discovered_iot_ids: set[str] = set()
 
-    @property
-    def _iot_id_room_name_map(self) -> dict[str, str]:
-        """Returns a dictionary of Room IOT IDs to room names."""
-        return {str(room.id): room.name for room in self._home_data.rooms or ()}
-
-    def _parse_response(self, response: common.V1ResponseData) -> Rooms:
-        """Parse the response from the device into a list of NamedRoomMapping."""
+    async def refresh(self) -> None:
+        """Refresh room mappings and backfill unknown room names from the web API."""
+        response = await self.rpc_channel.send_command(self.command)
         if not isinstance(response, list):
             raise ValueError(f"Unexpected RoomsTrait response format: {response!r}")
-        name_map = self._iot_id_room_name_map
-        segment_pairs = _extract_segment_pairs(response)
+
+        segment_map = _extract_segment_map(response)
+        # Track all iot ids seen before. Refresh the room list when new ids are found.
+        new_iot_ids = set(segment_map.values()) - set(self._home_data.rooms_map.keys())
+        if new_iot_ids - self._discovered_iot_ids:
+            _LOGGER.debug("Refreshing room list to discover new room names")
+            if updated_rooms := await self._refresh_rooms():
+                _LOGGER.debug("Updating rooms: %s", list(updated_rooms))
+                self._home_data.rooms = updated_rooms
+            self._discovered_iot_ids.update(new_iot_ids)
+
+        new_data = self._parse_rooms(segment_map, self._home_data.rooms_name_map)
+        self._update_trait_values(new_data)
+        _LOGGER.debug("Refreshed %s: %s", self.__class__.__name__, new_data)
+
+    @staticmethod
+    def _parse_rooms(
+        segment_map: dict[int, str],
+        name_map: dict[str, str],
+    ) -> Rooms:
+        """Parse the response from the device into a list of NamedRoomMapping."""
         return Rooms(
             rooms=[
-                NamedRoomMapping(segment_id=segment_id, iot_id=iot_id, name=name_map.get(iot_id, _DEFAULT_NAME))
-                for segment_id, iot_id in segment_pairs
+                NamedRoomMapping(segment_id=segment_id, iot_id=iot_id, raw_name=name_map.get(iot_id))
+                for segment_id, iot_id in segment_map.items()
             ]
         )
 
+    async def _refresh_rooms(self) -> list[HomeDataRoom]:
+        """Fetch the latest rooms from the web API."""
+        try:
+            return await self._web_api.get_rooms()
+        except Exception:
+            _LOGGER.debug("Failed to fetch rooms from web API", exc_info=True)
+            return []
+
 
-def _extract_segment_pairs(response: list) -> list[tuple[int, str]]:
-    """Extract segment_id and iot_id pairs from the response.
+def _extract_segment_map(response: list) -> dict[int, str]:
+    """Extract a segment_id -> iot_id mapping from the response.
 
     The response format can be either a flat list of [segment_id, iot_id] or a
     list of lists, where each inner list is a pair of [segment_id, iot_id]. This
-    function normalizes the response into a list of (segment_id, iot_id) tuples
+    function normalizes the response into a dict of segment_id to iot_id.
 
     NOTE: We currently only partial samples of the room mapping formats, so
     improving test coverage with samples from a real device with this format
     would be helpful.
     """
     if len(response) == 2 and not isinstance(response[0], list):
         segment_id, iot_id = response[0], response[1]
-        return [(segment_id, iot_id)]
+        return {segment_id: str(iot_id)}
 
-    segment_pairs: list[tuple[int, str]] = []
+    segment_map: dict[int, str] = {}
     for part in response:
         if not isinstance(part, list) or len(part) < 2:
             _LOGGER.warning("Unexpected room mapping entry format: %r", part)
             continue
         segment_id, iot_id = part[0], part[1]
-        segment_pairs.append((segment_id, iot_id))
-    return segment_pairs
+        segment_map[segment_id] = str(iot_id)
+    return segment_map