fix: improving logs

Author: humbertogontijo

roborock/api.py

@@ -189,7 +189,7 @@ async def _async_response(self, request_id: int, protocol_id: int = 0) -> tuple[
             (response, err) = await queue.async_get(QUEUE_TIMEOUT)
             return response, err
         except (asyncio.TimeoutError, asyncio.CancelledError):
-            raise RoborockTimeout(f"Timeout after {QUEUE_TIMEOUT} seconds waiting for response") from None
+            raise RoborockTimeout(f"id={request_id} Timeout after {QUEUE_TIMEOUT} seconds") from None
         finally:
             del self._waiting_queue[request_id]
 

roborock/cloud_api.py

@@ -56,19 +56,19 @@ def on_connect(self, *args, **kwargs):
         _, __, ___, rc, ____ = args
         connection_queue = self._waiting_queue.get(CONNECT_REQUEST_ID)
         if rc != mqtt.MQTT_ERR_SUCCESS:
-            message = f"Failed to connect (rc: {rc})"
+            message = f"Failed to connect ({mqtt.error_string(rc)})"
             _LOGGER.error(message)
             if connection_queue:
-                connection_queue.resolve((None, VacuumError(rc, message)))
+                connection_queue.resolve((None, VacuumError(message)))
             return
         _LOGGER.info(f"Connected to mqtt {self._mqtt_host}:{self._mqtt_port}")
         topic = f"rr/m/o/{self._mqtt_user}/{self._hashed_user}/{self.device_info.device.duid}"
         (result, mid) = self.subscribe(topic)
         if result != 0:
-            message = f"Failed to subscribe (rc: {result})"
+            message = f"Failed to subscribe ({mqtt.error_string(rc)})"
             _LOGGER.error(message)
             if connection_queue:
-                connection_queue.resolve((None, VacuumError(rc, message)))
+                connection_queue.resolve((None, VacuumError(message)))
             return
         _LOGGER.info(f"Subscribed to topic {topic}")
         if connection_queue:
@@ -85,7 +85,7 @@ def on_message(self, *args, **kwargs):
     def on_disconnect(self, *args, **kwargs):
         _, __, rc, ___ = args
         try:
-            super().on_connection_lost(RoborockException(f"(rc: {rc})"))
+            super().on_connection_lost(RoborockException(mqtt.error_string(rc)))
             if rc == mqtt.MQTT_ERR_PROTOCOL:
                 self.update_client_id()
             connection_queue = self._waiting_queue.get(DISCONNECT_REQUEST_ID)
@@ -114,7 +114,7 @@ def sync_disconnect(self) -> bool:
             _LOGGER.info("Disconnecting from mqtt")
             rc = super().disconnect()
             if rc not in [mqtt.MQTT_ERR_SUCCESS, mqtt.MQTT_ERR_NO_CONN]:
-                raise RoborockException(f"Failed to disconnect (rc:{rc})")
+                raise RoborockException(f"Failed to disconnect ({mqtt.error_string(rc)})")
         return rc == mqtt.MQTT_ERR_SUCCESS
 
     def sync_connect(self) -> bool:
@@ -146,7 +146,7 @@ async def async_connect(self) -> None:
     def _send_msg_raw(self, msg: bytes) -> None:
         info = self.publish(f"rr/m/i/{self._mqtt_user}/{self._hashed_user}/{self.device_info.device.duid}", msg)
         if info.rc != mqtt.MQTT_ERR_SUCCESS:
-            raise RoborockException(f"Failed to publish (rc: {info.rc})")
+            raise RoborockException(f"Failed to publish ({mqtt.error_string(info.rc)})")
 
     async def send_command(self, method: RoborockCommand, params: Optional[list | dict] = None):
         await self.validate_connection()

roborock/exceptions.py

@@ -20,15 +20,6 @@ class RoborockBackoffException(RoborockException):
 class VacuumError(RoborockException):
     """Class for vacuum errors."""
 
-    def __init__(self, code, message):
-        self.code = code
-        self.message = message
-        super().__init__()
-
-    def __str__(self, *args, **kwargs):  # real signature unknown
-        """Return str(self)."""
-        return f"{self.code}: {self.message}"
-
 
 class CommandVacuumError(RoborockException):
     """Class for command vacuum errors."""

roborock/local_api.py

@@ -85,8 +85,7 @@ def build_roborock_message(self, method: RoborockCommand, params: Optional[list
         )
 
     async def ping(self):
-        roborock_message = RoborockMessage(protocol=AP_CONFIG, payload=b"")
-        return (await self.send_message(roborock_message))[0]
+        return await self.send_command(RoborockCommand.APP_WAKEUP_ROBOT)
 
     async def send_command(self, method: RoborockCommand, params: Optional[list | dict] = None):
         roborock_message = self.build_roborock_message(method, params)