python-roborock 4.17.2__tar.gz → 4.18.1__tar.gz

{python_roborock-4.17.2 → python_roborock-4.18.1}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "python-roborock"
-version = "4.17.2"
+version = "4.18.1"
 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-4.17.2 → python_roborock-4.18.1}/roborock/data/v1/v1_clean_modes.py

@@ -68,6 +68,17 @@ class WashTowelModes(RoborockModeEnum):
     SUPER_DEEP = ("super_deep", 8)
 
 
+WATER_SLIDE_MODE_MAPPING: dict[int, WaterModes] = {
+    200: WaterModes.OFF,
+    221: WaterModes.PURE_WATER_FLOW_START,
+    225: WaterModes.PURE_WATER_FLOW_SMALL,
+    235: WaterModes.PURE_WATER_FLOW_MIDDLE,
+    245: WaterModes.PURE_WATER_FLOW_LARGE,
+    248: WaterModes.PURE_WATER_SUPER_BEGIN,
+    250: WaterModes.PURE_WATER_FLOW_END,
+}
+
+
 def get_wash_towel_modes(features: DeviceFeatures) -> list[WashTowelModes]:
     """Get the valid wash towel modes for the device"""
     modes = [WashTowelModes.LIGHT, WashTowelModes.BALANCED, WashTowelModes.DEEP]
@@ -128,17 +139,9 @@ def get_clean_routes(features: DeviceFeatures, region: str) -> list[CleanRoutes]
 
 def get_water_modes(features: DeviceFeatures) -> list[WaterModes]:
     """Get the valid water modes for the device - also known as 'water flow' or 'water level'"""
-    # If the device supports water slide mode, it uses a completely different set of modes. Technically, it can even
-    # support values in between. But for now we will just support the main values.
+    # Water slide mode supports a separate set of water flow codes.
     if features.is_water_slide_mode_supported:
-        return [
-            WaterModes.PURE_WATER_FLOW_START,
-            WaterModes.PURE_WATER_FLOW_SMALL,
-            WaterModes.PURE_WATER_FLOW_MIDDLE,
-            WaterModes.PURE_WATER_FLOW_LARGE,
-            WaterModes.PURE_WATER_SUPER_BEGIN,
-            WaterModes.PURE_WATER_FLOW_END,
-        ]
+        return list(WATER_SLIDE_MODE_MAPPING.values())
 
     supported_modes = [WaterModes.OFF]
     if features.is_mop_shake_module_supported:
@@ -159,6 +162,18 @@ def get_water_modes(features: DeviceFeatures) -> list[WaterModes]:
     return supported_modes
 
 
+def get_water_mode_mapping(features: DeviceFeatures) -> dict[int, str]:
+    """Get water mode mapping by supported feature set.
+
+    WaterModes contains aliases for multiple codes that share the same value
+    string (e.g. low can be 201 or 225). For water slide mode devices we need
+    explicit code mapping to preserve those slide-specific codes.
+    """
+    if features.is_water_slide_mode_supported:
+        return {code: mode.value for code, mode in WATER_SLIDE_MODE_MAPPING.items()}
+    return {mode.code: mode.value for mode in get_water_modes(features)}
+
+
 def is_mode_customized(clean_mode: VacuumModes, water_mode: WaterModes, mop_mode: CleanRoutes) -> bool:
     """Check if any of the cleaning modes are set to a custom value."""
     return (

{python_roborock-4.17.2 → python_roborock-4.18.1}/roborock/devices/traits/v1/status.py

@@ -1,7 +1,16 @@
 from functools import cached_property
 from typing import Self
 
-from roborock import CleanRoutes, StatusV2, VacuumModes, WaterModes, get_clean_modes, get_clean_routes, get_water_modes
+from roborock import (
+    CleanRoutes,
+    StatusV2,
+    VacuumModes,
+    WaterModes,
+    get_clean_modes,
+    get_clean_routes,
+    get_water_mode_mapping,
+    get_water_modes,
+)
 from roborock.roborock_typing import RoborockCommand
 
 from . import common
@@ -55,7 +64,7 @@ class StatusTrait(StatusV2, common.V1TraitMixin):
 
     @cached_property
     def water_mode_mapping(self) -> dict[int, str]:
-        return {mop.code: mop.value for mop in self.water_mode_options}
+        return get_water_mode_mapping(self._device_features_trait)
 
     @cached_property
     def mop_route_options(self) -> list[CleanRoutes]:

{python_roborock-4.17.2 → python_roborock-4.18.1}/roborock/mqtt/roborock_session.py

@@ -11,6 +11,7 @@ receiving messages from the vacuum cleaner.
 import asyncio
 import datetime
 import logging
+import ssl
 from collections.abc import Callable
 from contextlib import asynccontextmanager
 
@@ -26,7 +27,7 @@ from .session import MqttParams, MqttSession, MqttSessionException, MqttSessionU
 _LOGGER = logging.getLogger(__name__)
 _MQTT_LOGGER = logging.getLogger(f"{__name__}.aiomqtt")
 
-CLIENT_KEEPALIVE = datetime.timedelta(seconds=60)
+CLIENT_KEEPALIVE = datetime.timedelta(seconds=45)
 TOPIC_KEEPALIVE = datetime.timedelta(seconds=60)
 
 # Exponential backoff parameters
@@ -55,9 +56,12 @@ class RoborockMqttSession(MqttSession):
     The client is run as a background task that will run until shutdown. Once
     connected, the client will wait for messages to be received in a loop. If
     the connection is lost, the client will be re-created and reconnected. There
-    is backoff to avoid spamming the broker with connection attempts. The client
-    will automatically re-establish any subscriptions when the connection is
-    re-established.
+    is backoff to avoid spamming the broker with connection attempts.
+
+    Reconnect attempts are deferred while there are no active subscriptions,
+    which avoids unnecessary reconnect churn for idle sessions. Reconnects
+    resume as soon as a subscription is added again. The client automatically
+    re-establishes any existing subscriptions when the connection returns.
     """
 
     def __init__(
@@ -174,6 +178,16 @@ class RoborockMqttSession(MqttSession):
             if self._stop:
                 _LOGGER.debug("MQTT session closed, stopping retry loop")
                 return
+            if not self._client_subscribed_topics and not self._listeners.keys():
+                _LOGGER.debug("MQTT session disconnected with no active subscriptions, deferring reconnect")
+                self._diagnostics.increment("reconnect_deferred")
+                while not self._stop and not self._client_subscribed_topics and not self._listeners.keys():
+                    await asyncio.sleep(0.1)
+                if self._stop:
+                    _LOGGER.debug("MQTT session closed while waiting for active subscriptions")
+                    return
+                self._backoff = MIN_BACKOFF_INTERVAL
+                continue
             _LOGGER.info("MQTT session disconnected, retrying in %s seconds", self._backoff.total_seconds())
             self._diagnostics.increment("reconnect_wait")
             await asyncio.sleep(self._backoff.total_seconds())
@@ -238,6 +252,9 @@ class RoborockMqttSession(MqttSession):
     async def _mqtt_client(self, params: MqttParams) -> aiomqtt.Client:
         """Connect to the MQTT broker and listen for messages."""
         _LOGGER.debug("Connecting to %s:%s for %s", params.host, params.port, params.username)
+        tls_params = None
+        if params.tls:
+            tls_params = TLSParameters(cert_reqs=ssl.CERT_REQUIRED if params.verify_tls else ssl.CERT_NONE)
         try:
             async with aiomqtt.Client(
                 hostname=params.host,
@@ -246,7 +263,7 @@ class RoborockMqttSession(MqttSession):
                 password=params.password,
                 keepalive=int(CLIENT_KEEPALIVE.total_seconds()),
                 protocol=aiomqtt.ProtocolVersion.V5,
-                tls_params=TLSParameters() if params.tls else None,
+                tls_params=tls_params,
                 timeout=params.timeout,
                 logger=_MQTT_LOGGER,
             ) as client:

{python_roborock-4.17.2 → python_roborock-4.18.1}/roborock/mqtt/session.py

@@ -32,6 +32,9 @@ class MqttParams:
     password: str
     """MQTT password to use for authentication."""
 
+    verify_tls: bool = True
+    """Verify the TLS certificate."""
+
     timeout: float = DEFAULT_TIMEOUT
     """Timeout for communications with the broker in seconds."""