python-roborock 3.8.2__tar.gz → 3.8.4__tar.gz

{python_roborock-3.8.2 → python_roborock-3.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-roborock
-Version: 3.8.2
+Version: 3.8.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.8.2 → python_roborock-3.8.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-roborock"
-version = "3.8.2"
+version = "3.8.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"

{python_roborock-3.8.2 → python_roborock-3.8.4}/roborock/devices/cache.py

@@ -26,7 +26,13 @@ class CacheData:
     """Home map information indexed by map_flag."""
 
     home_map_content: dict[int, bytes] = field(default_factory=dict)
-    """Home cache content for each map data indexed by map_flag."""
+    """Home cache content for each map data indexed by map_flag.
+
+    This is deprecated in favor of `home_map_content_base64`.
+    """
+
+    home_map_content_base64: dict[int, str] = field(default_factory=dict)
+    """Home cache content for each map data (encoded base64) indexed by map_flag."""
 
     device_features: DeviceFeatures | None = None
     """Device features information."""

{python_roborock-3.8.2 → python_roborock-3.8.4}/roborock/devices/mqtt_channel.py

@@ -82,6 +82,10 @@ class MqttChannel(Channel):
             _LOGGER.exception("Error publishing MQTT message: %s", e)
             raise RoborockException(f"Failed to publish MQTT message: {e}") from e
 
+    async def restart(self) -> None:
+        """Restart the underlying MQTT session."""
+        await self._mqtt_session.restart()
+
 
 def create_mqtt_channel(
     user_data: UserData, mqtt_params: MqttParams, mqtt_session: MqttSession, device: HomeDataDevice

{python_roborock-3.8.2 → python_roborock-3.8.4}/roborock/devices/traits/v1/home.py

@@ -16,6 +16,7 @@ the current map's information and room names as needed.
 """
 
 import asyncio
+import base64
 import logging
 from typing import Self
 
@@ -86,14 +87,20 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
         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_map_info and cache_data.home_map_content:
+        if cache_data.home_map_info and (cache_data.home_map_content or cache_data.home_map_content_base64):
             _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()
-                }
+                if cache_data.home_map_content_base64:
+                    self._home_map_content = {
+                        k: self._map_content.parse_map_content(base64.b64decode(v))
+                        for k, v in cache_data.home_map_content_base64.items()
+                    }
+                else:
+                    self._home_map_content = {
+                        k: self._map_content.parse_map_content(v) for k, v in cache_data.home_map_content.items()
+                    }
             except (ValueError, RoborockException) as ex:
                 _LOGGER.warning("Failed to parse cached home map content, will re-discover: %s", ex)
                 self._home_map_content = {}
@@ -218,7 +225,12 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
         """Update the entire home cache with new map info and content."""
         cache_data = await self._cache.get()
         cache_data.home_map_info = home_map_info
-        cache_data.home_map_content = {k: v.raw_api_response for k, v in home_map_content.items() if v.raw_api_response}
+        cache_data.home_map_content_base64 = {
+            k: base64.b64encode(v.raw_api_response).decode("utf-8")
+            for k, v in home_map_content.items()
+            if v.raw_api_response
+        }
+        cache_data.home_map_content = {}
         await self._cache.set(cache_data)
         self._home_map_info = home_map_info
         self._home_map_content = home_map_content
@@ -237,8 +249,18 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
         if update_cache:
             cache_data = await self._cache.get()
             cache_data.home_map_info[map_flag] = map_info
+            # Migrate existing cached content to base64 if needed
+            if cache_data.home_map_content and not cache_data.home_map_content_base64:
+                cache_data.home_map_content_base64 = {
+                    k: base64.b64encode(v).decode("utf-8") for k, v in cache_data.home_map_content.items()
+                }
+                cache_data.home_map_content = {}
             if map_content.raw_api_response:
-                cache_data.home_map_content[map_flag] = map_content.raw_api_response
+                if cache_data.home_map_content_base64 is None:
+                    cache_data.home_map_content_base64 = {}
+                cache_data.home_map_content_base64[map_flag] = base64.b64encode(map_content.raw_api_response).decode(
+                    "utf-8"
+                )
             await self._cache.set(cache_data)
 
         if self._home_map_info is None:

{python_roborock-3.8.2 → python_roborock-3.8.4}/roborock/devices/v1_channel.py

@@ -142,7 +142,7 @@ class V1Channel(Channel):
         # Make an initial, optimistic attempt to connect to local with the
         # cache. The cache information will be refreshed by the background task.
         try:
-            await self._local_connect(use_cache=True)
+            await self._local_connect(prefer_cache=True)
         except RoborockException as err:
             _LOGGER.warning("Could not establish local connection for device %s: %s", self._device_uid, err)
 
@@ -175,13 +175,13 @@ class V1Channel(Channel):
         self._callback = callback
         return unsub
 
-    async def _get_networking_info(self, *, use_cache: bool = True) -> NetworkInfo:
+    async def _get_networking_info(self, *, prefer_cache: bool = True) -> NetworkInfo:
         """Retrieve networking information for the device.
 
         This is a cloud only command used to get the local device's IP address.
         """
         cache_data = await self._cache.get()
-        if use_cache and cache_data.network_info and (network_info := cache_data.network_info.get(self._device_uid)):
+        if prefer_cache and 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)
             return network_info
         try:
@@ -189,6 +189,10 @@ class V1Channel(Channel):
                 RoborockCommand.GET_NETWORK_INFO, response_type=NetworkInfo
             )
         except RoborockException as e:
+            _LOGGER.debug("Error fetching network info for device %s", self._device_uid)
+            if cache_data.network_info and (network_info := cache_data.network_info.get(self._device_uid)):
+                _LOGGER.debug("Falling back to cached network info for device %s after error", self._device_uid)
+                return network_info
             raise RoborockException(f"Network info failed for device {self._device_uid}") from e
         _LOGGER.debug("Network info for device %s: %s", self._device_uid, network_info)
         self._last_network_info_refresh = datetime.datetime.now(datetime.UTC)
@@ -196,12 +200,12 @@ class V1Channel(Channel):
         await self._cache.set(cache_data)
         return network_info
 
-    async def _local_connect(self, *, use_cache: bool = True) -> None:
+    async def _local_connect(self, *, prefer_cache: bool = True) -> None:
         """Set up local connection if possible."""
         _LOGGER.debug(
-            "Attempting to connect to local channel for device %s (use_cache=%s)", self._device_uid, use_cache
+            "Attempting to connect to local channel for device %s (prefer_cache=%s)", self._device_uid, prefer_cache
         )
-        networking_info = await self._get_networking_info(use_cache=use_cache)
+        networking_info = await self._get_networking_info(prefer_cache=prefer_cache)
         host = networking_info.ip
         _LOGGER.debug("Connecting to local channel at %s", host)
         # Create a new local channel and connect
@@ -236,7 +240,7 @@ class V1Channel(Channel):
                     reconnect_backoff = min(reconnect_backoff * RECONNECT_MULTIPLIER, MAX_RECONNECT_INTERVAL)
 
                 use_cache = self._should_use_cache(local_connect_failures)
-                await self._local_connect(use_cache=use_cache)
+                await self._local_connect(prefer_cache=use_cache)
                 # Reset backoff and failures on success
                 reconnect_backoff = MIN_RECONNECT_INTERVAL
                 local_connect_failures = 0

{python_roborock-3.8.2 → python_roborock-3.8.4}/roborock/devices/v1_rpc_channel.py

@@ -13,6 +13,7 @@ from typing import Any, Protocol, TypeVar, overload
 
 from roborock.data import RoborockBase
 from roborock.exceptions import RoborockException
+from roborock.mqtt.health_manager import HealthManager
 from roborock.protocols.v1_protocol import (
     CommandType,
     MapResponse,
@@ -125,12 +126,14 @@ class PayloadEncodedV1RpcChannel(BaseV1RpcChannel):
         channel: MqttChannel | LocalChannel,
         payload_encoder: Callable[[RequestMessage], RoborockMessage],
         decoder: Callable[[RoborockMessage], ResponseMessage] | Callable[[RoborockMessage], MapResponse | None],
+        health_manager: HealthManager | None = None,
     ) -> None:
         """Initialize the channel with a raw channel and an encoder function."""
         self._name = name
         self._channel = channel
         self._payload_encoder = payload_encoder
         self._decoder = decoder
+        self._health_manager = health_manager
 
     async def _send_raw_command(
         self,
@@ -165,13 +168,19 @@ class PayloadEncodedV1RpcChannel(BaseV1RpcChannel):
         unsub = await self._channel.subscribe(find_response)
         try:
             await self._channel.publish(message)
-            return await asyncio.wait_for(future, timeout=_TIMEOUT)
+            result = await asyncio.wait_for(future, timeout=_TIMEOUT)
         except TimeoutError as ex:
+            if self._health_manager:
+                await self._health_manager.on_timeout()
             future.cancel()
             raise RoborockException(f"Command timed out after {_TIMEOUT}s") from ex
         finally:
             unsub()
 
+        if self._health_manager:
+            await self._health_manager.on_success()
+        return result
+
 
 def create_mqtt_rpc_channel(mqtt_channel: MqttChannel, security_data: SecurityData) -> V1RpcChannel:
     """Create a V1 RPC channel using an MQTT channel."""
@@ -180,6 +189,7 @@ def create_mqtt_rpc_channel(mqtt_channel: MqttChannel, security_data: SecurityDa
         mqtt_channel,
         lambda x: x.encode_message(RoborockMessageProtocol.RPC_REQUEST, security_data=security_data),
         decode_rpc_response,
+        health_manager=HealthManager(mqtt_channel.restart),
     )
 
 

python_roborock-3.8.4/roborock/mqtt/health_manager.py

@@ -0,0 +1,51 @@
+"""A health manager for monitoring MQTT connections to Roborock devices.
+
+We observe a problem where sometimes the MQTT connection appears to be alive but
+no messages are being received. To mitigate this, we track consecutive timeouts
+and restart the connection if too many timeouts occur in succession.
+"""
+
+import datetime
+from collections.abc import Awaitable, Callable
+
+# Number of consecutive timeouts before considering the connection unhealthy.
+TIMEOUT_THRESHOLD = 3
+
+# We won't restart the session more often than this interval.
+RESTART_COOLDOWN = datetime.timedelta(minutes=30)
+
+
+class HealthManager:
+    """Manager for monitoring the health of MQTT connections.
+
+    This tracks communication timeouts and can trigger restarts of the MQTT
+    session if too many timeouts occur in succession.
+    """
+
+    def __init__(self, restart: Callable[[], Awaitable[None]]) -> None:
+        """Initialize the health manager.
+
+        Args:
+            restart: A callable to restart the MQTT session.
+        """
+        self._consecutive_timeouts = 0
+        self._restart = restart
+        self._last_restart: datetime.datetime | None = None
+
+    async def on_success(self) -> None:
+        """Record a successful communication event."""
+        self._consecutive_timeouts = 0
+
+    async def on_timeout(self) -> None:
+        """Record a timeout event.
+
+        This may trigger a restart of the MQTT session if too many timeouts
+        have occurred in succession.
+        """
+        self._consecutive_timeouts += 1
+        if self._consecutive_timeouts >= TIMEOUT_THRESHOLD:
+            now = datetime.datetime.now(datetime.UTC)
+            if self._last_restart is None or now - self._last_restart >= RESTART_COOLDOWN:
+                await self._restart()
+                self._last_restart = now
+                self._consecutive_timeouts = 0

{python_roborock-3.8.2 → python_roborock-3.8.4}/roborock/mqtt/roborock_session.py

@@ -49,13 +49,14 @@ class RoborockMqttSession(MqttSession):
 
     def __init__(self, params: MqttParams):
         self._params = params
-        self._background_task: asyncio.Task[None] | None = None
+        self._reconnect_task: asyncio.Task[None] | None = None
         self._healthy = False
         self._stop = False
         self._backoff = MIN_BACKOFF_INTERVAL
         self._client: aiomqtt.Client | None = None
         self._client_lock = asyncio.Lock()
         self._listeners: CallbackMap[str, bytes] = CallbackMap(_LOGGER)
+        self._connection_task: asyncio.Task[None] | None = None
 
     @property
     def connected(self) -> bool:
@@ -72,7 +73,7 @@ class RoborockMqttSession(MqttSession):
         """
         start_future: asyncio.Future[None] = asyncio.Future()
         loop = asyncio.get_event_loop()
-        self._background_task = loop.create_task(self._run_task(start_future))
+        self._reconnect_task = loop.create_task(self._run_reconnect_loop(start_future))
         try:
             await start_future
         except MqttError as err:
@@ -85,61 +86,47 @@ class RoborockMqttSession(MqttSession):
     async def close(self) -> None:
         """Cancels the MQTT loop and shutdown the client library."""
         self._stop = True
-        if self._background_task:
-            self._background_task.cancel()
-            try:
-                await self._background_task
-            except asyncio.CancelledError:
-                pass
-        async with self._client_lock:
-            if self._client:
-                await self._client.close()
+        tasks = [task for task in [self._connection_task, self._reconnect_task] if task]
+        for task in tasks:
+            task.cancel()
+        try:
+            await asyncio.gather(*tasks)
+        except asyncio.CancelledError:
+            pass
 
         self._healthy = False
 
-    async def _run_task(self, start_future: asyncio.Future[None] | None) -> None:
+    async def restart(self) -> None:
+        """Force the session to disconnect and reconnect.
+
+        The active connection task will be cancelled and restarted in the background, retried by
+        the reconnect loop. This is a no-op if there is no active connection.
+        """
+        _LOGGER.info("Forcing MQTT session restart")
+        if self._connection_task:
+            self._connection_task.cancel()
+        else:
+            _LOGGER.debug("No message loop task to cancel")
+
+    async def _run_reconnect_loop(self, start_future: asyncio.Future[None] | None) -> None:
         """Run the MQTT loop."""
         _LOGGER.info("Starting MQTT session")
         while True:
             try:
-                async with self._mqtt_client(self._params) as client:
-                    # Reset backoff once we've successfully connected
-                    self._backoff = MIN_BACKOFF_INTERVAL
-                    self._healthy = True
-                    _LOGGER.info("MQTT Session connected.")
-                    if start_future:
-                        start_future.set_result(None)
-                        start_future = None
-
-                    await self._process_message_loop(client)
-
-            except MqttError as err:
-                if start_future:
-                    _LOGGER.info("MQTT error starting session: %s", err)
-                    start_future.set_exception(err)
-                    return
-                _LOGGER.info("MQTT error: %s", err)
-            except asyncio.CancelledError as err:
-                if start_future:
-                    _LOGGER.debug("MQTT loop was cancelled while starting")
-                    start_future.set_exception(err)
-                _LOGGER.debug("MQTT loop was cancelled")
-                return
-            # Catch exceptions to avoid crashing the loop
-            # and to allow the loop to retry.
-            except Exception as err:
-                # This error is thrown when the MQTT loop is cancelled
-                # and the generator is not stopped.
-                if "generator didn't stop" in str(err) or "generator didn't yield" in str(err):
-                    _LOGGER.debug("MQTT loop was cancelled")
-                    return
-                if start_future:
-                    _LOGGER.error("Uncaught error starting MQTT session: %s", err)
-                    start_future.set_exception(err)
+                self._connection_task = asyncio.create_task(self._run_connection(start_future))
+                await self._connection_task
+            except asyncio.CancelledError:
+                _LOGGER.debug("MQTT connection task cancelled")
+            except Exception:
+                # Exceptions are logged and handled in _run_connection.
+                # There is a special case for exceptions on startup where we return
+                # immediately. Otherwise, we let the reconnect loop retry with
+                # backoff when the reconnect loop is active.
+                if start_future and start_future.done() and start_future.exception():
                     return
-                _LOGGER.exception("Uncaught error during MQTT session: %s", err)
 
             self._healthy = False
+            start_future = None
             if self._stop:
                 _LOGGER.debug("MQTT session closed, stopping retry loop")
                 return
@@ -147,6 +134,45 @@ class RoborockMqttSession(MqttSession):
             await asyncio.sleep(self._backoff.total_seconds())
             self._backoff = min(self._backoff * BACKOFF_MULTIPLIER, MAX_BACKOFF_INTERVAL)
 
+    async def _run_connection(self, start_future: asyncio.Future[None] | None) -> None:
+        """Connect to the MQTT broker and listen for messages.
+
+        This is the primary connection loop for the MQTT session that is
+        long running and processes incoming messages. If the connection
+        is lost, this method will exit.
+        """
+        try:
+            async with self._mqtt_client(self._params) as client:
+                self._backoff = MIN_BACKOFF_INTERVAL
+                self._healthy = True
+                _LOGGER.info("MQTT Session connected.")
+                if start_future and not start_future.done():
+                    start_future.set_result(None)
+
+                _LOGGER.debug("Processing MQTT messages")
+                async for message in client.messages:
+                    _LOGGER.debug("Received message: %s", message)
+                    self._listeners(message.topic.value, message.payload)
+        except MqttError as err:
+            if start_future and not start_future.done():
+                _LOGGER.info("MQTT error starting session: %s", err)
+                start_future.set_exception(err)
+            else:
+                _LOGGER.info("MQTT error: %s", err)
+            raise
+        except Exception as err:
+            # This error is thrown when the MQTT loop is cancelled
+            # and the generator is not stopped.
+            if "generator didn't stop" in str(err) or "generator didn't yield" in str(err):
+                _LOGGER.debug("MQTT loop was cancelled")
+                return
+            if start_future and not start_future.done():
+                _LOGGER.error("Uncaught error starting MQTT session: %s", err)
+                start_future.set_exception(err)
+            else:
+                _LOGGER.exception("Uncaught error during MQTT session: %s", err)
+            raise
+
     @asynccontextmanager
     async def _mqtt_client(self, params: MqttParams) -> aiomqtt.Client:
         """Connect to the MQTT broker and listen for messages."""
@@ -178,12 +204,6 @@ class RoborockMqttSession(MqttSession):
             async with self._client_lock:
                 self._client = None
 
-    async def _process_message_loop(self, client: aiomqtt.Client) -> None:
-        _LOGGER.debug("Processing MQTT messages")
-        async for message in client.messages:
-            _LOGGER.debug("Received message: %s", message)
-            self._listeners(message.topic.value, message.payload)
-
     async def subscribe(self, topic: str, callback: Callable[[bytes], None]) -> Callable[[], None]:
         """Subscribe to messages on the specified topic and invoke the callback for new messages.
 
@@ -271,6 +291,10 @@ class LazyMqttSession(MqttSession):
         """
         await self._session.close()
 
+    async def restart(self) -> None:
+        """Force the session to disconnect and reconnect."""
+        await self._session.restart()
+
 
 async def create_mqtt_session(params: MqttParams) -> MqttSession:
     """Create an MQTT session.

{python_roborock-3.8.2 → python_roborock-3.8.4}/roborock/mqtt/session.py

@@ -54,6 +54,10 @@ class MqttSession(ABC):
         This will raise an exception if the message could not be sent.
         """
 
+    @abstractmethod
+    async def restart(self) -> None:
+        """Force the session to disconnect and reconnect."""
+
     @abstractmethod
     async def close(self) -> None:
         """Cancels the mqtt loop"""