python-roborock 3.10.2__tar.gz → 3.10.4__tar.gz

{python_roborock-3.10.2 → python_roborock-3.10.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-roborock
-Version: 3.10.2
+Version: 3.10.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.10.2 → python_roborock-3.10.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-roborock"
-version = "3.10.2"
+version = "3.10.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.10.2 → python_roborock-3.10.4}/roborock/devices/device.py

@@ -29,6 +29,7 @@ __all__ = [
 MIN_BACKOFF_INTERVAL = datetime.timedelta(seconds=10)
 MAX_BACKOFF_INTERVAL = datetime.timedelta(minutes=30)
 BACKOFF_MULTIPLIER = 1.5
+START_ATTEMPT_TIMEOUT = datetime.timedelta(seconds=5)
 
 
 class RoborockDevice(ABC, TraitsMixin):
@@ -107,16 +108,21 @@ class RoborockDevice(ABC, TraitsMixin):
         """
         return self._channel.is_local_connected
 
-    def start_connect(self) -> None:
+    async def start_connect(self) -> None:
         """Start a background task to connect to the device.
 
-        This will attempt to connect to the device using the appropriate protocol
-        channel. If the connection fails, it will retry with exponential backoff.
+        This will give a moment for the first connection attempt to start so
+        that the device will have connections established -- however, this will
+        never directly fail.
+
+        If the connection fails, it will retry in the background with
+        exponential backoff.
 
         Once connected, the device will remain connected until `close()` is
         called. The device will automatically attempt to reconnect if the connection
         is lost.
         """
+        start_attempt: asyncio.Event = asyncio.Event()
 
         async def connect_loop() -> None:
             backoff = MIN_BACKOFF_INTERVAL
@@ -124,8 +130,10 @@ class RoborockDevice(ABC, TraitsMixin):
                 while True:
                     try:
                         await self.connect()
+                        start_attempt.set()
                         return
                     except RoborockException as e:
+                        start_attempt.set()
                         _LOGGER.info("Failed to connect to device %s: %s", self.name, e)
                         _LOGGER.info(
                             "Retrying connection to device %s in %s seconds", self.name, backoff.total_seconds()
@@ -136,9 +144,16 @@ class RoborockDevice(ABC, TraitsMixin):
                 _LOGGER.info("connect_loop for device %s was cancelled", self.name)
                 # Clean exit on cancellation
                 return
+            finally:
+                start_attempt.set()
 
         self._connect_task = asyncio.create_task(connect_loop())
 
+        try:
+            await asyncio.wait_for(start_attempt.wait(), timeout=START_ATTEMPT_TIMEOUT.total_seconds())
+        except TimeoutError:
+            _LOGGER.debug("Initial connection attempt to device %s is taking longer than expected", self.name)
+
     async def connect(self) -> None:
         """Connect to the device using the appropriate protocol channel."""
         if self._unsub:

{python_roborock-3.10.2 → python_roborock-3.10.4}/roborock/devices/device_manager.py

@@ -82,14 +82,16 @@ class DeviceManager:
 
         # These are connected serially to avoid overwhelming the MQTT broker
         new_devices = {}
+        start_tasks = []
         for duid, (device, product) in device_products.items():
             if duid in self._devices:
                 continue
             new_device = self._device_creator(home_data, device, product)
-            new_device.start_connect()
+            start_tasks.append(new_device.start_connect())
             new_devices[duid] = new_device
 
         self._devices.update(new_devices)
+        await asyncio.gather(*start_tasks)
         return list(self._devices.values())
 
     async def get_device(self, duid: str) -> RoborockDevice | None:

{python_roborock-3.10.2 → python_roborock-3.10.4}/roborock/devices/local_channel.py

@@ -176,7 +176,7 @@ class LocalChannel(Channel):
     async def connect(self) -> None:
         """Connect to the device and negotiate protocol."""
         if self._is_connected:
-            _LOGGER.warning("Already connected")
+            _LOGGER.debug("Unexpected call to connect when already connected")
             return
         _LOGGER.debug("Connecting to %s:%s", self._host, _PORT)
         loop = asyncio.get_running_loop()
@@ -214,7 +214,7 @@ class LocalChannel(Channel):
 
     def _connection_lost(self, exc: Exception | None) -> None:
         """Handle connection loss."""
-        _LOGGER.warning("Connection lost to %s", self._host, exc_info=exc)
+        _LOGGER.debug("Connection lost to %s", self._host, exc_info=exc)
         if self._keep_alive_task:
             self._keep_alive_task.cancel()
             self._keep_alive_task = None

{python_roborock-3.10.2 → python_roborock-3.10.4}/roborock/devices/v1_channel.py

@@ -70,9 +70,9 @@ class RpcStrategy:
 class RpcChannel(V1RpcChannel):
     """Provides an RPC interface around a pub/sub transport channel."""
 
-    def __init__(self, rpc_strategies: list[RpcStrategy]) -> None:
-        """Initialize the RpcChannel with on ordered list of strategies."""
-        self._rpc_strategies = rpc_strategies
+    def __init__(self, rpc_strategies_cb: Callable[[], list[RpcStrategy]]) -> None:
+        """Initialize the RpcChannel with an ordered list of strategies."""
+        self._rpc_strategies_cb = rpc_strategies_cb
 
     async def send_command(
         self,
@@ -86,11 +86,11 @@ class RpcChannel(V1RpcChannel):
 
         # Try each channel in order until one succeeds
         last_exception = None
-        for strategy in self._rpc_strategies:
+        for strategy in self._rpc_strategies_cb():
             try:
                 decoded_response = await self._send_rpc(strategy, request)
             except RoborockException as e:
-                _LOGGER.warning("Command %s failed on %s channel: %s", method, strategy.name, e)
+                _LOGGER.debug("Command %s failed on %s channel: %s", method, strategy.name, e)
                 last_exception = e
             except Exception as e:
                 _LOGGER.exception("Unexpected error sending command %s on %s channel", method, strategy.name)
@@ -203,23 +203,35 @@ class V1Channel(Channel):
 
     @property
     def rpc_channel(self) -> V1RpcChannel:
-        """Return the combined RPC channel that prefers local with a fallback to MQTT."""
-        strategies = []
-        if local_rpc_strategy := self._create_local_rpc_strategy():
-            strategies.append(local_rpc_strategy)
-        strategies.append(self._create_mqtt_rpc_strategy())
-        return RpcChannel(strategies)
+        """Return the combined RPC channel that prefers local with a fallback to MQTT.
+
+        The returned V1RpcChannel may be long lived and will respect the
+        current connection state of the underlying channels.
+        """
+
+        def rpc_strategies_cb() -> list[RpcStrategy]:
+            strategies = []
+            if local_rpc_strategy := self._create_local_rpc_strategy():
+                strategies.append(local_rpc_strategy)
+            strategies.append(self._create_mqtt_rpc_strategy())
+            return strategies
+
+        return RpcChannel(rpc_strategies_cb)
 
     @property
     def mqtt_rpc_channel(self) -> V1RpcChannel:
-        """Return the MQTT-only RPC channel."""
-        return RpcChannel([self._create_mqtt_rpc_strategy()])
+        """Return the MQTT-only RPC channel.
+
+        The returned V1RpcChannel may be long lived and will respect the
+        current connection state of the underlying channels.
+        """
+        return RpcChannel(lambda: [self._create_mqtt_rpc_strategy()])
 
     @property
     def map_rpc_channel(self) -> V1RpcChannel:
         """Return the map RPC channel used for fetching map content."""
         decoder = create_map_response_decoder(security_data=self._security_data)
-        return RpcChannel([self._create_mqtt_rpc_strategy(decoder)])
+        return RpcChannel(lambda: [self._create_mqtt_rpc_strategy(decoder)])
 
     def _create_local_rpc_strategy(self) -> RpcStrategy | None:
         """Create the RPC strategy for local transport."""
@@ -282,7 +294,7 @@ class V1Channel(Channel):
         try:
             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)
+            _LOGGER.debug("First local connection attempt for device %s failed, will retry: %s", self._device_uid, err)
 
         # Start a background task to manage the local connection health. This
         # happens independent of whether we were able to connect locally now.

{python_roborock-3.10.2 → python_roborock-3.10.4}/roborock/mqtt/roborock_session.py

@@ -24,7 +24,7 @@ from .session import MqttParams, MqttSession, MqttSessionException
 _LOGGER = logging.getLogger(__name__)
 _MQTT_LOGGER = logging.getLogger(f"{__name__}.aiomqtt")
 
-CLIENT_KEEPALIVE = datetime.timedelta(seconds=120)
+CLIENT_KEEPALIVE = datetime.timedelta(seconds=60)
 TOPIC_KEEPALIVE = datetime.timedelta(seconds=60)
 
 # Exponential backoff parameters