python-roborock 3.7.1__tar.gz → 3.7.4__tar.gz

{python_roborock-3.7.1 → python_roborock-3.7.4}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "python-roborock"
-version = "3.7.1"
+version = "3.7.4"
 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"
@@ -44,7 +44,7 @@ dev = [
     "pytest",
     "pre-commit>=3.5,<5.0",
     "mypy",
-    "ruff==0.14.1",
+    "ruff==0.14.4",
     "codespell",
     "pyshark>=0.6,<0.7",
     "aioresponses>=0.7.7,<0.8",

{python_roborock-3.7.1 → python_roborock-3.7.4}/roborock/data/containers.py

@@ -140,6 +140,9 @@ class RoborockBaseTimer(RoborockBase):
             else None
         )
 
+    def as_list(self) -> list:
+        return [self.start_hour, self.start_minute, self.end_hour, self.end_minute]
+
     def __repr__(self) -> str:
         return _attr_repr(self)
 

{python_roborock-3.7.1 → python_roborock-3.7.4}/roborock/devices/traits/v1/clean_summary.py

@@ -14,7 +14,7 @@ class CleanSummaryTrait(CleanSummaryWithDetail, common.V1TraitMixin):
 
     command = RoborockCommand.GET_CLEAN_SUMMARY
 
-    async def refresh(self) -> Self:
+    async def refresh(self) -> None:
         """Refresh the clean summary data and last clean record.
 
         Assumes that the clean summary has already been fetched.
@@ -23,10 +23,9 @@ class CleanSummaryTrait(CleanSummaryWithDetail, common.V1TraitMixin):
         if not self.records:
             _LOGGER.debug("No clean records available in clean summary.")
             self.last_clean_record = None
-            return self
+            return
         last_record_id = self.records[-1]
         self.last_clean_record = await self.get_clean_record(last_record_id)
-        return self
 
     @classmethod
     def _parse_type_response(cls, response: common.V1ResponseData) -> Self:

{python_roborock-3.7.1 → python_roborock-3.7.4}/roborock/devices/traits/v1/common.py

@@ -76,7 +76,7 @@ class V1TraitMixin(ABC):
             raise ValueError("Device trait in invalid state")
         return self._rpc_channel
 
-    async def refresh(self) -> Self:
+    async def refresh(self) -> None:
         """Refresh the contents of this trait."""
         response = await self.rpc_channel.send_command(self.command)
         new_data = self._parse_response(response)
@@ -84,7 +84,6 @@ class V1TraitMixin(ABC):
             raise ValueError(f"Internal error, unexpected response type: {new_data!r}")
         _LOGGER.debug("Refreshed %s: %s", self.__class__.__name__, new_data)
         self._update_trait_values(new_data)
-        return self
 
     def _update_trait_values(self, new_data: RoborockBase) -> None:
         """Update the values of this trait from another instance."""

{python_roborock-3.7.1 → python_roborock-3.7.4}/roborock/devices/traits/v1/device_features.py

@@ -1,5 +1,4 @@
 from dataclasses import fields
-from typing import Self
 
 from roborock.data import AppInitStatus, RoborockProductNickname
 from roborock.device_features import DeviceFeatures
@@ -13,7 +12,7 @@ class DeviceFeaturesTrait(DeviceFeatures, common.V1TraitMixin):
 
     command = RoborockCommand.APP_GET_INIT_STATUS
 
-    def __init__(self, product_nickname: RoborockProductNickname, cache: Cache) -> None:
+    def __init__(self, product_nickname: RoborockProductNickname, cache: Cache) -> None:  # pylint: disable=super-init-not-called
         """Initialize MapContentTrait."""
         self._nickname = product_nickname
         self._cache = cache
@@ -22,7 +21,7 @@ class DeviceFeaturesTrait(DeviceFeatures, common.V1TraitMixin):
         for field in fields(self):
             setattr(self, field.name, False)
 
-    async def refresh(self) -> Self:
+    async def refresh(self) -> None:
         """Refresh the contents of this trait.
 
         This will use cached device features if available since they do not
@@ -32,12 +31,11 @@ class DeviceFeaturesTrait(DeviceFeatures, common.V1TraitMixin):
         cache_data = await self._cache.get()
         if cache_data.device_features is not None:
             self._update_trait_values(cache_data.device_features)
-            return self
+            return
         # Save cached device features
-        device_features = await super().refresh()
-        cache_data.device_features = device_features
+        await super().refresh()
+        cache_data.device_features = self
         await self._cache.set(cache_data)
-        return device_features
 
     def _parse_response(self, response: common.V1ResponseData) -> DeviceFeatures:
         """Parse the response from the device into a MapContentTrait instance."""

{python_roborock-3.7.1 → python_roborock-3.7.4}/roborock/devices/traits/v1/do_not_disturb.py

@@ -17,7 +17,7 @@ class DoNotDisturbTrait(DnDTimer, common.V1TraitMixin, common.RoborockSwitchBase
 
     async def set_dnd_timer(self, dnd_timer: DnDTimer) -> None:
         """Set the Do Not Disturb (DND) timer settings of the device."""
-        await self.rpc_channel.send_command(RoborockCommand.SET_DND_TIMER, params=dnd_timer.as_dict())
+        await self.rpc_channel.send_command(RoborockCommand.SET_DND_TIMER, params=dnd_timer.as_list())
 
     async def clear_dnd_timer(self) -> None:
         """Clear the Do Not Disturb (DND) timer settings of the device."""
@@ -27,18 +27,9 @@ class DoNotDisturbTrait(DnDTimer, common.V1TraitMixin, common.RoborockSwitchBase
         """Set the Do Not Disturb (DND) timer settings of the device."""
         await self.rpc_channel.send_command(
             RoborockCommand.SET_DND_TIMER,
-            params={
-                **self.as_dict(),
-                _ENABLED_PARAM: 1,
-            },
+            params=self.as_list(),
         )
 
     async def disable(self) -> None:
-        """Set the Do Not Disturb (DND) timer settings of the device."""
-        await self.rpc_channel.send_command(
-            RoborockCommand.SET_DND_TIMER,
-            params={
-                **self.as_dict(),
-                _ENABLED_PARAM: 0,
-            },
-        )
+        """Disable the Do Not Disturb (DND) timer settings of the device."""
+        await self.rpc_channel.send_command(RoborockCommand.CLOSE_DND_TIMER)

{python_roborock-3.7.1 → python_roborock-3.7.4}/roborock/devices/traits/v1/home.py

@@ -7,6 +7,12 @@ on the map. It also makes it straight forward to fetch the map image and data.
 This trait depends on the MapsTrait and RoomsTrait to gather the necessary
 information. It provides properties to access the current map, the list of
 rooms with names, and the map image and data.
+
+Callers may first call `discover_home()` to populate the home layout cache by
+iterating through all available maps on the device. This will cache the map
+information and room names for all maps to minimize map switching and improve
+performance. After the initial discovery, callers can call `refresh()` to update
+the current map's information and room names as needed.
 """
 
 import asyncio
@@ -64,6 +70,7 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
         self._map_content = map_content
         self._rooms_trait = rooms_trait
         self._cache = cache
+        self._discovery_completed = False
         self._home_map_info: dict[int, CombinedMapInfo] | None = None
         self._home_map_content: dict[int, MapContent] | None = None
 
@@ -82,6 +89,7 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
         if cache_data.home_map_info and cache_data.home_map_content:
             _LOGGER.debug("Home cache already populated, skipping discovery")
             self._home_map_info = cache_data.home_map_info
+            self._discovery_completed = True
             try:
                 self._home_map_content = {
                     k: self._map_content.parse_map_content(v) for k, v in cache_data.home_map_content.items()
@@ -101,6 +109,7 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
 
         home_map_info, home_map_content = await self._build_home_map_info()
         _LOGGER.debug("Home discovery complete, caching data for %d maps", len(home_map_info))
+        self._discovery_completed = True
         await self._update_home_cache(home_map_info, home_map_content)
 
     async def _refresh_map_info(self, map_info) -> CombinedMapInfo:
@@ -149,15 +158,22 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
             home_map_info[map_info.map_flag] = combined_map_info
         return home_map_info, home_map_content
 
-    async def refresh(self) -> Self:
+    async def refresh(self) -> None:
         """Refresh current map's underlying map and room data, updating cache as needed.
 
         This will only refresh the current map's data and will not populate non
         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_map_info is None:
-            raise RoborockException("Cannot refresh home data without home cache, did you call discover_home()?")
+        if not self._discovery_completed:
+            # Running initial discovery also populates all of the same information
+            # as below so we can just call that method. If the device is busy
+            # then we'll fall through below to refresh the current map only.
+            try:
+                await self.discover_home()
+                return
+            except RoborockDeviceBusy:
+                _LOGGER.debug("Cannot refresh home data while device is busy cleaning")
 
         # Refresh the list of map names/info
         await self._maps_trait.refresh()
@@ -170,8 +186,9 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
         new_map_content = await self._refresh_map_content()
         # Refresh the current map's room data
         combined_map_info = await self._refresh_map_info(current_map_info)
-        await self._update_current_map_cache(map_flag, combined_map_info, new_map_content)
-        return self
+        await self._update_current_map(
+            map_flag, combined_map_info, new_map_content, update_cache=self._discovery_completed
+        )
 
     @property
     def home_map_info(self) -> dict[int, CombinedMapInfo] | None:
@@ -206,16 +223,28 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
         self._home_map_info = home_map_info
         self._home_map_content = home_map_content
 
-    async def _update_current_map_cache(
-        self, map_flag: int, map_info: CombinedMapInfo, map_content: MapContent
+    async def _update_current_map(
+        self,
+        map_flag: int,
+        map_info: CombinedMapInfo,
+        map_content: MapContent,
+        update_cache: bool,
     ) -> None:
         """Update the cache for the current map only."""
-        cache_data = await self._cache.get()
-        cache_data.home_map_info[map_flag] = map_info
-        if map_content.raw_api_response:
-            cache_data.home_map_content[map_flag] = map_content.raw_api_response
-        await self._cache.set(cache_data)
-        if self._home_map_info is None or self._home_map_content is None:
-            raise RoborockException("Home cache is not initialized, cannot update current map cache")
+        # Update the persistent cache if requested e.g. home discovery has
+        # completed and we want to keep it fresh. Otherwise just update the
+        # in memory map below.
+        if update_cache:
+            cache_data = await self._cache.get()
+            cache_data.home_map_info[map_flag] = map_info
+            if map_content.raw_api_response:
+                cache_data.home_map_content[map_flag] = map_content.raw_api_response
+            await self._cache.set(cache_data)
+
+        if self._home_map_info is None:
+            self._home_map_info = {}
         self._home_map_info[map_flag] = map_info
+
+        if self._home_map_content is None:
+            self._home_map_content = {}
         self._home_map_content[map_flag] = map_content

{python_roborock-3.7.1 → python_roborock-3.7.4}/roborock/devices/traits/v1/network_info.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import logging
-from typing import Self
 
 from roborock.data import NetworkInfo
 from roborock.devices.cache import Cache
@@ -25,20 +24,20 @@ class NetworkInfoTrait(NetworkInfo, common.V1TraitMixin):
 
     command = RoborockCommand.GET_NETWORK_INFO
 
-    def __init__(self, device_uid: str, cache: Cache) -> None:
+    def __init__(self, device_uid: str, cache: Cache) -> None:  # pylint: disable=super-init-not-called
         """Initialize the trait."""
         self._device_uid = device_uid
         self._cache = cache
         self.ip = ""
 
-    async def refresh(self) -> Self:
+    async def refresh(self) -> None:
         """Refresh the network info from the cache."""
 
         cache_data = await self._cache.get()
         if cache_data.network_info and (network_info := cache_data.network_info.get(self._device_uid)):
             _LOGGER.debug("Using cached network info for device %s", self._device_uid)
             self._update_trait_values(network_info)
-            return self
+            return
 
         # Load from device if not in cache
         _LOGGER.debug("No cached network info for device %s, fetching from device", self._device_uid)
@@ -48,8 +47,6 @@ class NetworkInfoTrait(NetworkInfo, common.V1TraitMixin):
         cache_data.network_info[self._device_uid] = self
         await self._cache.set(cache_data)
 
-        return self
-
     def _parse_response(self, response: common.V1ResponseData) -> NetworkInfo:
         """Parse the response from the device into a NetworkInfo."""
         if not isinstance(response, dict):

{python_roborock-3.7.1 → python_roborock-3.7.4}/roborock/devices/traits/v1/valley_electricity_timer.py

@@ -18,7 +18,7 @@ class ValleyElectricityTimerTrait(ValleyElectricityTimer, common.V1TraitMixin, c
 
     async def set_timer(self, timer: ValleyElectricityTimer) -> None:
         """Set the Valley Electricity Timer settings of the device."""
-        await self.rpc_channel.send_command(RoborockCommand.SET_VALLEY_ELECTRICITY_TIMER, params=timer.as_dict())
+        await self.rpc_channel.send_command(RoborockCommand.SET_VALLEY_ELECTRICITY_TIMER, params=timer.as_list())
 
     async def clear_timer(self) -> None:
         """Clear the Valley Electricity Timer settings of the device."""
@@ -28,18 +28,11 @@ class ValleyElectricityTimerTrait(ValleyElectricityTimer, common.V1TraitMixin, c
         """Enable the Valley Electricity Timer settings of the device."""
         await self.rpc_channel.send_command(
             RoborockCommand.SET_VALLEY_ELECTRICITY_TIMER,
-            params={
-                **self.as_dict(),
-                _ENABLED_PARAM: 1,
-            },
+            params=self.as_list(),
         )
 
     async def disable(self) -> None:
         """Disable the Valley Electricity Timer settings of the device."""
         await self.rpc_channel.send_command(
-            RoborockCommand.SET_VALLEY_ELECTRICITY_TIMER,
-            params={
-                **self.as_dict(),
-                _ENABLED_PARAM: 0,
-            },
+            RoborockCommand.CLOSE_VALLEY_ELECTRICITY_TIMER,
         )