fix: adding fallback cache (to be tested)

Author: humbertogontijo

roborock/api.py

@@ -51,7 +51,7 @@
 from .roborock_future import RoborockFuture
 from .roborock_message import RoborockMessage
 from .roborock_typing import DeviceProp, DockSummary, RoborockCommand
-from .util import unpack_list
+from .util import fallback_cache, unpack_list
 
 _LOGGER = logging.getLogger(__name__)
 KEEPALIVE = 60
@@ -77,11 +77,11 @@ async def request(self, method: str, url: str, params=None, data=None, headers=N
         _headers = {**self.base_headers, **(headers or {})}
         async with aiohttp.ClientSession() as session:
             async with session.request(
-                method,
-                _url,
-                params=params,
-                data=data,
-                headers=_headers,
+                    method,
+                    _url,
+                    params=params,
+                    data=data,
+                    headers=_headers,
             ) as resp:
                 return await resp.json()
 
@@ -173,7 +173,7 @@ def on_connection_lost(self, exc: Optional[Exception]) -> None:
     def should_keepalive(self) -> bool:
         now = self.time_func()
         # noinspection PyUnresolvedReferences
-        if now - self._last_disconnection > self.keep_alive**2 and now - self._last_device_msg_in > self.keep_alive:
+        if now - self._last_disconnection > self.keep_alive ** 2 and now - self._last_device_msg_in > self.keep_alive:
             return False
         return True
 
@@ -194,10 +194,10 @@ async def _async_response(self, request_id: int, protocol_id: int = 0) -> tuple[
             del self._waiting_queue[request_id]
 
     def _get_payload(
-        self,
-        method: RoborockCommand,
-        params: Optional[list | dict] = None,
-        secured=False,
+            self,
+            method: RoborockCommand,
+            params: Optional[list | dict] = None,
+            secured=False,
     ):
         timestamp = math.floor(time.time())
         request_id = randint(10000, 99999)
@@ -225,115 +225,98 @@ def _get_payload(
     async def send_command(self, method: RoborockCommand, params: Optional[list | dict] = None):
         raise NotImplementedError
 
+    @fallback_cache()
     async def get_status(self) -> Status | None:
         status = await self.send_command(RoborockCommand.GET_STATUS)
         if isinstance(status, dict):
             _cls: Type[Status] = ModelStatus.get(
                 self.device_info.model, S7MaxVStatus
             )  # Default to S7 MAXV if we don't have the data
             return _cls.from_dict(status)
-
         return None
 
+    @fallback_cache()
     async def get_dnd_timer(self) -> DnDTimer | None:
-        try:
-            dnd_timer = await self.send_command(RoborockCommand.GET_DND_TIMER)
-            if isinstance(dnd_timer, dict):
-                return DnDTimer.from_dict(dnd_timer)
-        except RoborockTimeout as e:
-            _LOGGER.error(e)
+        dnd_timer = await self.send_command(RoborockCommand.GET_DND_TIMER)
+        if isinstance(dnd_timer, dict):
+            return DnDTimer.from_dict(dnd_timer)
         return None
 
+    @fallback_cache()
     async def get_clean_summary(self) -> CleanSummary | None:
-        try:
-            clean_summary = await self.send_command(RoborockCommand.GET_CLEAN_SUMMARY)
-            if isinstance(clean_summary, dict):
-                return CleanSummary.from_dict(clean_summary)
-            elif isinstance(clean_summary, list):
-                clean_time, clean_area, clean_count, records = unpack_list(clean_summary, 4)
-                return CleanSummary(
-                    clean_time=clean_time,
-                    clean_area=clean_area,
-                    clean_count=clean_count,
-                    records=records,
-                )
-            elif isinstance(clean_summary, int):
-                return CleanSummary(clean_time=clean_summary)
-        except RoborockTimeout as e:
-            _LOGGER.error(e)
+        clean_summary = await self.send_command(RoborockCommand.GET_CLEAN_SUMMARY)
+        if isinstance(clean_summary, dict):
+            return CleanSummary.from_dict(clean_summary)
+        elif isinstance(clean_summary, list):
+            clean_time, clean_area, clean_count, records = unpack_list(clean_summary, 4)
+            return CleanSummary(
+                clean_time=clean_time,
+                clean_area=clean_area,
+                clean_count=clean_count,
+                records=records,
+            )
+        elif isinstance(clean_summary, int):
+            return CleanSummary(clean_time=clean_summary)
         return None
 
+    @fallback_cache()
     async def get_clean_record(self, record_id: int) -> CleanRecord | None:
-        try:
-            clean_record = await self.send_command(RoborockCommand.GET_CLEAN_RECORD, [record_id])
-            if isinstance(clean_record, dict):
-                return CleanRecord.from_dict(clean_record)
-        except RoborockTimeout as e:
-            _LOGGER.error(e)
+        clean_record = await self.send_command(RoborockCommand.GET_CLEAN_RECORD, [record_id])
+        if isinstance(clean_record, dict):
+            return CleanRecord.from_dict(clean_record)
         return None
 
+    @fallback_cache()
     async def get_consumable(self) -> Consumable | None:
-        try:
-            consumable = await self.send_command(RoborockCommand.GET_CONSUMABLE)
-            if isinstance(consumable, dict):
-                return Consumable.from_dict(consumable)
-        except RoborockTimeout as e:
-            _LOGGER.error(e)
+        consumable = await self.send_command(RoborockCommand.GET_CONSUMABLE)
+        if isinstance(consumable, dict):
+            return Consumable.from_dict(consumable)
         return None
 
+    @fallback_cache()
     async def get_wash_towel_mode(self) -> WashTowelMode | None:
-        try:
-            washing_mode = await self.send_command(RoborockCommand.GET_WASH_TOWEL_MODE)
-            if isinstance(washing_mode, dict):
-                return WashTowelMode.from_dict(washing_mode)
-        except RoborockTimeout as e:
-            _LOGGER.error(e)
+        washing_mode = await self.send_command(RoborockCommand.GET_WASH_TOWEL_MODE)
+        if isinstance(washing_mode, dict):
+            return WashTowelMode.from_dict(washing_mode)
         return None
 
+    @fallback_cache()
     async def get_dust_collection_mode(self) -> DustCollectionMode | None:
-        try:
-            dust_collection = await self.send_command(RoborockCommand.GET_DUST_COLLECTION_MODE)
-            if isinstance(dust_collection, dict):
-                return DustCollectionMode.from_dict(dust_collection)
-        except RoborockTimeout as e:
-            _LOGGER.error(e)
+        dust_collection = await self.send_command(RoborockCommand.GET_DUST_COLLECTION_MODE)
+        if isinstance(dust_collection, dict):
+            return DustCollectionMode.from_dict(dust_collection)
         return None
 
+    @fallback_cache()
     async def get_smart_wash_params(self) -> SmartWashParams | None:
-        try:
-            mop_wash_mode = await self.send_command(RoborockCommand.GET_SMART_WASH_PARAMS)
-            if isinstance(mop_wash_mode, dict):
-                return SmartWashParams.from_dict(mop_wash_mode)
-        except RoborockTimeout as e:
-            _LOGGER.error(e)
+        mop_wash_mode = await self.send_command(RoborockCommand.GET_SMART_WASH_PARAMS)
+        if isinstance(mop_wash_mode, dict):
+            return SmartWashParams.from_dict(mop_wash_mode)
         return None
 
+    @fallback_cache()
     async def get_dock_summary(self, dock_type: RoborockDockTypeCode) -> DockSummary | None:
         """Gets the status summary from the dock with the methods available for a given dock.
 
         :param dock_type: RoborockDockTypeCode"""
-        try:
-            commands: list[
-                Coroutine[
-                    Any,
-                    Any,
-                    DustCollectionMode | WashTowelMode | SmartWashParams | None,
-                ]
-            ] = [self.get_dust_collection_mode()]
-            if dock_type == RoborockDockTypeCode.empty_wash_fill_dock or dock_type == RoborockDockTypeCode.s8_dock:
-                commands += [
-                    self.get_wash_towel_mode(),
-                    self.get_smart_wash_params(),
-                ]
-            [dust_collection_mode, wash_towel_mode, smart_wash_params] = unpack_list(
-                list(await asyncio.gather(*commands)), 3
-            )
-
-            return DockSummary(dust_collection_mode, wash_towel_mode, smart_wash_params)
-        except RoborockTimeout as e:
-            _LOGGER.error(e)
-        return None
+        commands: list[
+            Coroutine[
+                Any,
+                Any,
+                DustCollectionMode | WashTowelMode | SmartWashParams | None,
+            ]
+        ] = [self.get_dust_collection_mode()]
+        if dock_type == RoborockDockTypeCode.empty_wash_fill_dock or dock_type == RoborockDockTypeCode.s8_dock:
+            commands += [
+                self.get_wash_towel_mode(),
+                self.get_smart_wash_params(),
+            ]
+        [dust_collection_mode, wash_towel_mode, smart_wash_params] = unpack_list(
+            list(await asyncio.gather(*commands)), 3
+        )
+        return DockSummary(dust_collection_mode, wash_towel_mode, smart_wash_params)
 
+    @fallback_cache()
     async def get_prop(self) -> DeviceProp | None:
         [status, dnd_timer, clean_summary, consumable] = await asyncio.gather(
             *[
@@ -360,33 +343,30 @@ async def get_prop(self) -> DeviceProp | None:
             )
         return None
 
+    @fallback_cache()
     async def get_multi_maps_list(self) -> MultiMapsList | None:
-        try:
-            multi_maps_list = await self.send_command(RoborockCommand.GET_MULTI_MAPS_LIST)
-            if isinstance(multi_maps_list, dict):
-                return MultiMapsList.from_dict(multi_maps_list)
-        except RoborockTimeout as e:
-            _LOGGER.error(e)
+        multi_maps_list = await self.send_command(RoborockCommand.GET_MULTI_MAPS_LIST)
+        if isinstance(multi_maps_list, dict):
+            return MultiMapsList.from_dict(multi_maps_list)
         return None
 
+    @fallback_cache()
     async def get_networking(self) -> NetworkInfo | None:
-        try:
-            networking_info = await self.send_command(RoborockCommand.GET_NETWORK_INFO)
-            if isinstance(networking_info, dict):
-                return NetworkInfo.from_dict(networking_info)
-        except RoborockTimeout as e:
-            _LOGGER.error(e)
+        networking_info = await self.send_command(RoborockCommand.GET_NETWORK_INFO)
+        if isinstance(networking_info, dict):
+            return NetworkInfo.from_dict(networking_info)
         return None
 
-    async def get_room_mapping(self) -> list[RoomMapping]:
+    @fallback_cache()
+    async def get_room_mapping(self) -> list[RoomMapping] | None:
         """Gets the mapping from segment id -> iot id. Only works on local api."""
         mapping = await self.send_command(RoborockCommand.GET_ROOM_MAPPING)
         if isinstance(mapping, list):
             return [
                 RoomMapping(segment_id=segment_id, iot_id=iot_id)  # type: ignore
                 for segment_id, iot_id in [unpack_list(room, 2) for room in mapping]
             ]
-        return []
+        return None
 
 
 class RoborockApiClient:

roborock/util.py

@@ -32,3 +32,26 @@ def wrapped(*args, **kwargs):
         return wrapped
 
     return decorator
+
+
+class CacheableResult:
+    last_run_result = None
+
+
+def fallback_cache():
+    _run_sync = run_sync()
+    cache = CacheableResult()
+
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapped(*args, **kwargs):
+            try:
+                cache.last_run_result = _run_sync(func(*args, **kwargs))
+            except Exception as e:
+                if cache.last_run_result is None:
+                    raise e
+            return cache.last_run_result
+
+        return wrapped
+
+    return decorator