python-roborock 4.18.0__tar.gz → 4.19.0__tar.gz

{python_roborock-4.18.0 → python_roborock-4.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-roborock
-Version: 4.18.0
+Version: 4.19.0
 Summary: A package to control Roborock vacuums.
 Project-URL: Repository, https://github.com/humbertogontijo/python-roborock
 Project-URL: Documentation, https://python-roborock.readthedocs.io/

{python_roborock-4.18.0 → python_roborock-4.19.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-roborock"
-version = "4.18.0"
+version = "4.19.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-4.18.0 → python_roborock-4.19.0}/roborock/devices/traits/v1/__init__.py

@@ -193,7 +193,7 @@ class PropertiesApi(Trait):
         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)

{python_roborock-4.18.0 → python_roborock-4.19.0}/roborock/devices/traits/v1/home.py

@@ -120,22 +120,23 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
 
         rooms: dict[int, NamedRoomMapping] = {}
         if map_info.rooms:
-            # Not all vacuums resopnd with rooms inside map_info.
+            # Not all vacuums respond with rooms inside map_info.
+            # If we can determine if all vacuums will return everything with get_rooms, we could remove this step.
             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",
+                        name=room.iot_name or f"Room {room.id}",
                     )
 
-        # Add rooms from rooms_trait. If room already exists and rooms_trait has "Unknown", don't override.
+        # Add rooms from rooms_trait.
+        # Keep existing names from map_info unless they are fallback names.
         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.
+                    existing_room = rooms.get(room.segment_id)
+                    if existing_room is None or existing_room.name == f"Room {room.segment_id}":
                         rooms[room.segment_id] = room
 
         return CombinedMapInfo(

{python_roborock-4.18.0 → python_roborock-4.19.0}/roborock/devices/traits/v1/rooms.py

@@ -6,11 +6,10 @@ from dataclasses import dataclass
 from roborock.data import HomeData, 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,36 +31,69 @@ 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._seen_unknown_room_iot_ids: set[str] = set()
+
+    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}")
+
+        segment_map = _extract_segment_map(response)
+        await self._populate_missing_home_data_rooms(segment_map)
+
+        new_data = self._parse_response(response, segment_map)
+        self._update_trait_values(new_data)
+        _LOGGER.debug("Refreshed %s: %s", self.__class__.__name__, new_data)
 
     @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:
+    def _parse_response(self, response: common.V1ResponseData, segment_map: dict[int, str] | None = None) -> Rooms:
         """Parse the response from the device into a list of NamedRoomMapping."""
         if not isinstance(response, list):
             raise ValueError(f"Unexpected RoomsTrait response format: {response!r}")
+        if segment_map is None:
+            segment_map = _extract_segment_map(response)
         name_map = self._iot_id_room_name_map
-        segment_pairs = _extract_segment_pairs(response)
         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, name=name_map.get(iot_id, f"Room {segment_id}"))
+                for segment_id, iot_id in segment_map.items()
             ]
         )
 
+    async def _populate_missing_home_data_rooms(self, segment_map: dict[int, str]) -> None:
+        """Load missing room names into home data for newly-seen unknown room ids."""
+        missing_room_iot_ids = set(segment_map.values()) - set(self._iot_id_room_name_map.keys())
+        new_missing_room_iot_ids = missing_room_iot_ids - self._seen_unknown_room_iot_ids
+        if not new_missing_room_iot_ids:
+            return
+
+        try:
+            web_rooms = await self._web_api.get_rooms()
+        except Exception:
+            _LOGGER.debug("Failed to fetch rooms from web API", exc_info=True)
+        else:
+            if isinstance(web_rooms, list) and web_rooms:
+                self._home_data.rooms = web_rooms
+
+        self._seen_unknown_room_iot_ids.update(missing_room_iot_ids)
+
 
-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
@@ -69,13 +101,13 @@ def _extract_segment_pairs(response: list) -> list[tuple[int, str]]:
     """
     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

{python_roborock-4.18.0 → python_roborock-4.19.0}/roborock/mqtt/roborock_session.py

@@ -27,7 +27,7 @@ from .session import MqttParams, MqttSession, MqttSessionException, MqttSessionU
 _LOGGER = logging.getLogger(__name__)
 _MQTT_LOGGER = logging.getLogger(f"{__name__}.aiomqtt")
 
-CLIENT_KEEPALIVE = datetime.timedelta(seconds=60)
+CLIENT_KEEPALIVE = datetime.timedelta(seconds=45)
 TOPIC_KEEPALIVE = datetime.timedelta(seconds=60)
 
 # Exponential backoff parameters
@@ -56,9 +56,12 @@ class RoborockMqttSession(MqttSession):
     The client is run as a background task that will run until shutdown. Once
     connected, the client will wait for messages to be received in a loop. If
     the connection is lost, the client will be re-created and reconnected. There
-    is backoff to avoid spamming the broker with connection attempts. The client
-    will automatically re-establish any subscriptions when the connection is
-    re-established.
+    is backoff to avoid spamming the broker with connection attempts.
+
+    Reconnect attempts are deferred while there are no active subscriptions,
+    which avoids unnecessary reconnect churn for idle sessions. Reconnects
+    resume as soon as a subscription is added again. The client automatically
+    re-establishes any existing subscriptions when the connection returns.
     """
 
     def __init__(
@@ -175,6 +178,16 @@ class RoborockMqttSession(MqttSession):
             if self._stop:
                 _LOGGER.debug("MQTT session closed, stopping retry loop")
                 return
+            if not self._client_subscribed_topics and not self._listeners.keys():
+                _LOGGER.debug("MQTT session disconnected with no active subscriptions, deferring reconnect")
+                self._diagnostics.increment("reconnect_deferred")
+                while not self._stop and not self._client_subscribed_topics and not self._listeners.keys():
+                    await asyncio.sleep(0.1)
+                if self._stop:
+                    _LOGGER.debug("MQTT session closed while waiting for active subscriptions")
+                    return
+                self._backoff = MIN_BACKOFF_INTERVAL
+                continue
             _LOGGER.info("MQTT session disconnected, retrying in %s seconds", self._backoff.total_seconds())
             self._diagnostics.increment("reconnect_wait")
             await asyncio.sleep(self._backoff.total_seconds())

{python_roborock-4.18.0 → python_roborock-4.19.0}/roborock/web_api.py

@@ -544,10 +544,10 @@ class RoborockApiClient:
             rriot.r.a,
             self.session,
             {
-                "Authorization": _get_hawk_authentication(rriot, "/v2/user/homes/" + str(home_id)),
+                "Authorization": _get_hawk_authentication(rriot, f"/user/homes/{home_id}/rooms"),
             },
         )
-        room_response = await room_request.request("get", f"/user/homes/{str(home_id)}/rooms" + str(home_id))
+        room_response = await room_request.request("get", f"/user/homes/{home_id}/rooms")
         if not room_response.get("success"):
             raise RoborockException(room_response)
         rooms = room_response.get("result")
@@ -752,6 +752,10 @@ class UserWebApiClient:
         """Fetch routines (scenes) for a specific device."""
         return await self._web_api.get_scenes(self._user_data, device_id)
 
+    async def get_rooms(self) -> list[HomeDataRoom]:
+        """Fetch rooms using the API client."""
+        return await self._web_api.get_rooms(self._user_data)
+
     async def execute_routine(self, scene_id: int) -> None:
         """Execute a specific routine (scene) by its ID."""
         await self._web_api.execute_scene(self._user_data, scene_id)