fix: minor fixes

Author: humbertogontijo

roborock/cloud_api.py

@@ -85,7 +85,8 @@ def on_message(self, *args, **kwargs):
     def on_disconnect(self, *args, **kwargs):
         _, __, rc, ___ = args
         try:
-            super().on_connection_lost(RoborockException(mqtt.error_string(rc)))
+            exc = RoborockException(mqtt.error_string(rc)) if rc != mqtt.MQTT_ERR_SUCCESS else None
+            super().on_connection_lost(exc)
             if rc == mqtt.MQTT_ERR_PROTOCOL:
                 self.update_client_id()
             connection_queue = self._waiting_queue.get(DISCONNECT_REQUEST_ID)

roborock/local_api.py

@@ -40,7 +40,7 @@ def data_received(self, message):
         self.on_message_received(parser_msg)
 
     def connection_lost(self, exc: Optional[Exception]):
-        self.sync_disconnect()
+        self.loop.run_until_complete(self.async_disconnect())
         self.on_connection_lost(exc)
 
     def is_connected(self):
@@ -55,7 +55,6 @@ async def async_connect(self) -> None:
             try:
                 is_connected = self.is_connected()
                 if not is_connected:
-                    self.sync_disconnect()
                     async with async_timeout.timeout(QUEUE_TIMEOUT):
                         _LOGGER.info(f"Connecting to {self.host}")
                         self.transport, _ = await self.loop.create_connection(  # type: ignore
@@ -68,16 +67,13 @@ async def async_connect(self) -> None:
             await self.hello()
             await self.keep_alive_func()
 
-    def sync_disconnect(self) -> None:
-        if self.transport and self.loop.is_running():
-            _LOGGER.debug(f"Disconnecting from {self.host}")
-            self.transport.close()
-        if self.keep_alive_task:
-            self.keep_alive_task.cancel()
-
     async def async_disconnect(self) -> None:
         async with self._mutex:
-            self.sync_disconnect()
+            if self.transport and self.loop.is_running():
+                _LOGGER.debug(f"Disconnecting from {self.host}")
+                self.transport.close()
+            if self.keep_alive_task:
+                self.keep_alive_task.cancel()
 
     def build_roborock_message(self, method: RoborockCommand, params: Optional[list | dict] = None) -> RoborockMessage:
         secured = True if method in COMMANDS_SECURED else False

roborock/roborock_typing.py

@@ -87,7 +87,6 @@ class RoborockCommand(str, Enum):
     GET_WASH_TOWEL_MODE = "get_wash_towel_mode"
     LOAD_MULTI_MAP = "load_multi_map"
     NAME_SEGMENT = "name_segment"
-    NONE = ""
     RESET_CONSUMABLE = "reset_consumable"
     RESUME_SEGMENT_CLEAN = "resume_segment_clean"
     RESUME_ZONED_CLEAN = "resume_zoned_clean"
@@ -232,7 +231,6 @@ class CommandInfo:
     RoborockCommand.GET_WASH_TOWEL_MODE: CommandInfo(params=None),
     RoborockCommand.LOAD_MULTI_MAP: CommandInfo(params=None),
     RoborockCommand.NAME_SEGMENT: CommandInfo(params=None),
-    RoborockCommand.NONE: CommandInfo(params=None),
     RoborockCommand.RESET_CONSUMABLE: CommandInfo(params=None),
     RoborockCommand.RESUME_SEGMENT_CLEAN: CommandInfo(params=None),
     RoborockCommand.RESUME_ZONED_CLEAN: CommandInfo(params=None),

roborock/util.py

@@ -36,7 +36,6 @@ def wrapped(*args, **kwargs):
 
 class CacheableResult:
     last_run_result = None
-    use_count = 0
 
 
 RT = TypeVar("RT", bound=Callable[..., Coroutine])
@@ -48,13 +47,14 @@ def fallback_cache(func: RT) -> RT:
     @functools.wraps(func)
     async def wrapped(*args, **kwargs):
         try:
-            cache.last_run_result = await func(*args, **kwargs)
-            cache.use_count = 0
+            last_run_result = await func(*args, **kwargs)
+            cache.last_run_result = last_run_result
         except Exception as e:
-            if cache.last_run_result is None or cache.use_count > 0:
+            if cache.last_run_result is None:
                 raise e
-            cache.last_run_result.is_cached = True
-            cache.use_count += 1
-        return cache.last_run_result
+            last_run_result = cache.last_run_result
+            cache.last_run_result = None
+            return last_run_result
+        return last_run_result
 
     return wrapped  # type: ignore