python-roborock 3.3.2__tar.gz → 3.4.0__tar.gz

{python_roborock-3.3.2 → python_roborock-3.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-roborock
-Version: 3.3.2
+Version: 3.4.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-3.3.2 → python_roborock-3.4.0}/pyproject.toml

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

@@ -118,7 +118,7 @@ class ConnectionCache(RoborockBase):
     email: str
     home_data: HomeData | None = None
     network_info: dict[str, NetworkInfo] | None = None
-    home_cache: dict[int, CombinedMapInfo] | None = None
+    home_map_info: dict[int, CombinedMapInfo] | None = None
     trait_data: dict[str, Any] | None = None
 
 
@@ -267,7 +267,7 @@ class RoborockContext(Cache):
         return CacheData(
             home_data=connection_cache.home_data,
             network_info=connection_cache.network_info or {},
-            home_cache=connection_cache.home_cache,
+            home_map_info=connection_cache.home_map_info,
             trait_data=connection_cache.trait_data or {},
         )
 
@@ -277,7 +277,7 @@ class RoborockContext(Cache):
         connection_cache = self.cache_data()
         connection_cache.home_data = value.home_data
         connection_cache.network_info = value.network_info
-        connection_cache.home_cache = value.home_cache
+        connection_cache.home_map_info = value.home_map_info
         connection_cache.trait_data = value.trait_data
         self.update(connection_cache)
 
@@ -717,14 +717,14 @@ async def home(ctx, device_id: str, refresh: bool):
         await home_trait.refresh()
 
     # Display the discovered home cache
-    if home_trait.home_cache:
+    if home_trait.home_map_info:
         cache_summary = {
             map_flag: {
                 "name": map_data.name,
                 "room_count": len(map_data.rooms),
                 "rooms": [{"segment_id": room.segment_id, "name": room.name} for room in map_data.rooms],
             }
-            for map_flag, map_data in home_trait.home_cache.items()
+            for map_flag, map_data in home_trait.home_map_info.items()
         }
         click.echo(dump_json(cache_summary))
     else:

{python_roborock-3.3.2 → python_roborock-3.4.0}/roborock/devices/cache.py

@@ -22,8 +22,8 @@ class CacheData:
     network_info: dict[str, NetworkInfo] = field(default_factory=dict)
     """Network information indexed by device DUID."""
 
-    home_cache: dict[int, CombinedMapInfo] = field(default_factory=dict)
-    """Home cache information indexed by map_flag."""
+    home_map_info: dict[int, CombinedMapInfo] = field(default_factory=dict)
+    """Home map information indexed by map_flag."""
 
     device_features: DeviceFeatures | None = None
     """Device features information."""

{python_roborock-3.3.2 → python_roborock-3.4.0}/roborock/devices/traits/v1/clean_summary.py

@@ -53,6 +53,8 @@ class CleanSummaryTrait(CleanSummaryWithDetail, common.V1TraitMixin):
     @classmethod
     def _parse_clean_record_response(cls, response: common.V1ResponseData) -> CleanRecord:
         """Parse the response from the device into a CleanRecord."""
+        if isinstance(response, list) and len(response) == 1:
+            response = response[0]
         if isinstance(response, dict):
             return CleanRecord.from_dict(response)
         if isinstance(response, list):

{python_roborock-3.3.2 → python_roborock-3.4.0}/roborock/devices/traits/v1/home.py

@@ -61,7 +61,7 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
         self._maps_trait = maps_trait
         self._rooms_trait = rooms_trait
         self._cache = cache
-        self._home_cache: dict[int, CombinedMapInfo] | None = None
+        self._home_map_info: dict[int, CombinedMapInfo] | None = None
 
     async def discover_home(self) -> None:
         """Iterate through all maps to discover rooms and cache them.
@@ -72,12 +72,12 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
         cleaning process. This will raise `RoborockDeviceBusy` if the device is
         currently cleaning.
 
-        After discovery, the home cache will be populated and can be accessed via the `home_cache` property.
+        After discovery, the home cache will be populated and can be accessed via the `home_map_info` property.
         """
         cache_data = await self._cache.get()
-        if cache_data.home_cache:
+        if cache_data.home_map_info:
             _LOGGER.debug("Home cache already populated, skipping discovery")
-            self._home_cache = cache_data.home_cache
+            self._home_map_info = cache_data.home_map_info
             return
 
         if self._status_trait.state == RoborockStateCode.cleaning:
@@ -87,11 +87,11 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
         if self._maps_trait.current_map_info is None:
             raise RoborockException("Cannot perform home discovery without current map info")
 
-        home_cache = await self._build_home_cache()
-        _LOGGER.debug("Home discovery complete, caching data for %d maps", len(home_cache))
-        await self._update_home_cache(home_cache)
+        home_map_info = await self._build_home_map_info()
+        _LOGGER.debug("Home discovery complete, caching data for %d maps", len(home_map_info))
+        await self._update_home_map_info(home_map_info)
 
-    async def _refresh_map_data(self, map_info) -> CombinedMapInfo:
+    async def _refresh_map_info(self, map_info) -> CombinedMapInfo:
         """Collect room data for a specific map and return CombinedMapInfo."""
         await self._rooms_trait.refresh()
         return CombinedMapInfo(
@@ -100,9 +100,9 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
             rooms=self._rooms_trait.rooms or [],
         )
 
-    async def _build_home_cache(self) -> dict[int, CombinedMapInfo]:
+    async def _build_home_map_info(self) -> dict[int, CombinedMapInfo]:
         """Perform the actual discovery and caching of home data."""
-        home_cache: dict[int, CombinedMapInfo] = {}
+        home_map_info: dict[int, CombinedMapInfo] = {}
 
         # Sort map_info to process the current map last, reducing map switching.
         # False (non-original maps) sorts before True (original map). We ensure
@@ -120,9 +120,9 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
                 await self._maps_trait.set_current_map(map_info.map_flag)
                 await asyncio.sleep(MAP_SLEEP)
 
-            map_data = await self._refresh_map_data(map_info)
-            home_cache[map_info.map_flag] = map_data
-        return home_cache
+            map_data = await self._refresh_map_info(map_info)
+            home_map_info[map_info.map_flag] = map_data
+        return home_map_info
 
     async def refresh(self) -> Self:
         """Refresh current map's underlying map and room data, updating cache as needed.
@@ -131,7 +131,7 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
         active maps or re-discover the home. It is expected that this will keep
         information up to date for the current map as users switch to that map.
         """
-        if self._home_cache is None:
+        if self._home_map_info is None:
             raise RoborockException("Cannot refresh home data without home cache, did you call discover_home()?")
 
         # Refresh the list of map names/info
@@ -142,33 +142,33 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
             raise RoborockException("Cannot refresh home data without current map info")
 
         # Refresh the current map's room data
-        current_map_data = self._home_cache.get(map_flag)
+        current_map_data = self._home_map_info.get(map_flag)
         if current_map_data:
-            map_data = await self._refresh_map_data(current_map_info)
+            map_data = await self._refresh_map_info(current_map_info)
             if map_data != current_map_data:
-                await self._update_home_cache({**self._home_cache, map_flag: map_data})
+                await self._update_home_map_info({**self._home_map_info, map_flag: map_data})
 
         return self
 
     @property
-    def home_cache(self) -> dict[int, CombinedMapInfo] | None:
+    def home_map_info(self) -> dict[int, CombinedMapInfo] | None:
         """Returns the map information for all cached maps."""
-        return self._home_cache
+        return self._home_map_info
 
     @property
     def current_map_data(self) -> CombinedMapInfo | None:
         """Returns the map data for the current map."""
         current_map_flag = self._maps_trait.current_map
-        if current_map_flag is None or self._home_cache is None:
+        if current_map_flag is None or self._home_map_info is None:
             return None
-        return self._home_cache.get(current_map_flag)
+        return self._home_map_info.get(current_map_flag)
 
     def _parse_response(self, response: common.V1ResponseData) -> Self:
         """This trait does not parse responses directly."""
         raise NotImplementedError("HomeTrait does not support direct command responses")
 
-    async def _update_home_cache(self, home_cache: dict[int, CombinedMapInfo]) -> None:
+    async def _update_home_map_info(self, home_map_info: dict[int, CombinedMapInfo]) -> None:
         cache_data = await self._cache.get()
-        cache_data.home_cache = home_cache
+        cache_data.home_map_info = home_map_info
         await self._cache.set(cache_data)
-        self._home_cache = home_cache
+        self._home_map_info = home_map_info

{python_roborock-3.3.2 → python_roborock-3.4.0}/roborock/version_1_apis/roborock_local_client_v1.py

@@ -210,6 +210,7 @@ class RoborockLocalClientV1(RoborockClientV1, RoborockClient):
             version=self.local_protocol_version,
         )
         self._logger.debug("Building message id %s for method %s", request_message.request_id, method)
+        await self._validate_connection()
         return await self._send_message(
             roborock_message,
             request_id=request_message.request_id,
@@ -226,7 +227,6 @@ class RoborockLocalClientV1(RoborockClientV1, RoborockClient):
         method: str | None = None,
         params: list | dict | int | None = None,
     ) -> RoborockMessage:
-        await self._validate_connection()
         msg = self._encoder(roborock_message)
         if method:
             self._logger.debug(f"id={request_id} Requesting method {method} with {params}")