python-roborock 2.40.1__tar.gz → 2.41.1__tar.gz

{python_roborock-2.40.1 → python_roborock-2.41.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-roborock
-Version: 2.40.1
+Version: 2.41.1
 Summary: A package to control Roborock vacuums.
 Home-page: https://github.com/humbertogontijo/python-roborock
 License: GPL-3.0-only

{python_roborock-2.40.1 → python_roborock-2.41.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-roborock"
-version = "2.40.1"
+version = "2.41.1"
 description = "A package to control Roborock vacuums."
 authors = ["humbertogontijo <humbertogontijo@users.noreply.github.com>"]
 license = "GPL-3.0-only"

{python_roborock-2.40.1 → python_roborock-2.41.1}/roborock/containers.py

@@ -109,8 +109,6 @@ def _decamelize(s: str):
 
 @dataclass
 class RoborockBase:
-    _ignore_keys = []  # type: ignore
-
     @staticmethod
     def _convert_to_class_obj(class_type: type, value):
         if get_origin(class_type) is list:
@@ -134,8 +132,8 @@ class RoborockBase:
             return None
         field_types = {field.name: field.type for field in dataclasses.fields(cls)}
         result: dict[str, Any] = {}
-        for key, value in data.items():
-            key = _decamelize(key)
+        for orig_key, value in data.items():
+            key = _decamelize(orig_key)
             if (field_type := field_types.get(key)) is None:
                 continue
             if value == "None" or value is None:
@@ -178,16 +176,18 @@ class RoborockBaseTimer(RoborockBase):
     end_hour: int | None = None
     end_minute: int | None = None
     enabled: int | None = None
-    start_time: datetime.time | None = None
-    end_time: datetime.time | None = None
 
-    def __post_init__(self) -> None:
-        self.start_time = (
+    @property
+    def start_time(self) -> datetime.time | None:
+        return (
             datetime.time(hour=self.start_hour, minute=self.start_minute)
             if self.start_hour is not None and self.start_minute is not None
             else None
         )
-        self.end_time = (
+
+    @property
+    def end_time(self) -> datetime.time | None:
+        return (
             datetime.time(hour=self.end_hour, minute=self.end_minute)
             if self.end_hour is not None and self.end_minute is not None
             else None
@@ -684,19 +684,20 @@ class MultiMapsListMapInfoBakMaps(RoborockBase):
 
 @dataclass
 class MultiMapsListMapInfo(RoborockBase):
-    _ignore_keys = ["mapFlag"]
-
-    mapFlag: int
+    map_flag: int
     name: str
     add_time: Any | None = None
     length: Any | None = None
     bak_maps: list[MultiMapsListMapInfoBakMaps] | None = None
 
+    @property
+    def mapFlag(self) -> int:
+        """Alias for map_flag, returns the map flag as an integer."""
+        return self.map_flag
+
 
 @dataclass
 class MultiMapsList(RoborockBase):
-    _ignore_keys = ["mapFlag"]
-
     max_multi_map: int | None = None
     max_bak_map: int | None = None
     multi_map_count: int | None = None

{python_roborock-2.40.1 → python_roborock-2.41.1}/roborock/devices/device_manager.py

@@ -22,6 +22,7 @@ from .cache import Cache, NoCache
 from .channel import Channel
 from .mqtt_channel import create_mqtt_channel
 from .traits.b01.props import B01PropsApi
+from .traits.dnd import DoNotDisturbTrait
 from .traits.dyad import DyadApi
 from .traits.status import StatusTrait
 from .traits.trait import Trait
@@ -152,6 +153,7 @@ async def create_device_manager(
             case DeviceVersion.V1:
                 channel = create_v1_channel(user_data, mqtt_params, mqtt_session, device, cache)
                 traits.append(StatusTrait(product, channel.rpc_channel))
+                traits.append(DoNotDisturbTrait(channel.rpc_channel))
             case DeviceVersion.A01:
                 mqtt_channel = create_mqtt_channel(user_data, mqtt_params, mqtt_session, device)
                 match product.category:

python_roborock-2.41.1/roborock/devices/traits/dnd.py

@@ -0,0 +1,41 @@
+"""Module for Roborock V1 devices.
+
+This interface is experimental and subject to breaking changes without notice
+until the API is stable.
+"""
+
+import logging
+
+from roborock.containers import DnDTimer
+from roborock.devices.v1_rpc_channel import V1RpcChannel
+from roborock.roborock_typing import RoborockCommand
+
+from .trait import Trait
+
+_LOGGER = logging.getLogger(__name__)
+
+__all__ = [
+    "DoNotDisturbTrait",
+]
+
+
+class DoNotDisturbTrait(Trait):
+    """Trait for managing Do Not Disturb (DND) settings on Roborock devices."""
+
+    name = "do_not_disturb"
+
+    def __init__(self, rpc_channel: V1RpcChannel) -> None:
+        """Initialize the DoNotDisturbTrait."""
+        self._rpc_channel = rpc_channel
+
+    async def get_dnd_timer(self) -> DnDTimer:
+        """Get the current Do Not Disturb (DND) timer settings of the device."""
+        return await self._rpc_channel.send_command(RoborockCommand.GET_DND_TIMER, response_type=DnDTimer)
+
+    async def set_dnd_timer(self, dnd_timer: DnDTimer) -> None:
+        """Set the Do Not Disturb (DND) timer settings of the device."""
+        await self._rpc_channel.send_command(RoborockCommand.SET_DND_TIMER, params=dnd_timer.as_dict())
+
+    async def clear_dnd_timer(self) -> None:
+        """Clear the Do Not Disturb (DND) timer settings of the device."""
+        await self._rpc_channel.send_command(RoborockCommand.CLOSE_DND_TIMER)

{python_roborock-2.40.1 → python_roborock-2.41.1}/roborock/devices/traits/status.py

@@ -12,20 +12,20 @@ from roborock.containers import (
     S7MaxVStatus,
     Status,
 )
+from roborock.devices.v1_rpc_channel import V1RpcChannel
 from roborock.roborock_typing import RoborockCommand
 
-from ..v1_rpc_channel import V1RpcChannel
 from .trait import Trait
 
 _LOGGER = logging.getLogger(__name__)
 
 __all__ = [
-    "Status",
+    "StatusTrait",
 ]
 
 
 class StatusTrait(Trait):
-    """Unified Roborock device class with automatic connection setup."""
+    """Trait for managing the status of Roborock devices."""
 
     name = "status"
 

{python_roborock-2.40.1 → python_roborock-2.41.1}/roborock/devices/v1_channel.py

@@ -22,7 +22,7 @@ from .cache import Cache
 from .channel import Channel
 from .local_channel import LocalChannel, LocalSession, create_local_session
 from .mqtt_channel import MqttChannel
-from .v1_rpc_channel import V1RpcChannel, create_combined_rpc_channel, create_mqtt_rpc_channel
+from .v1_rpc_channel import PickFirstAvailable, V1RpcChannel, create_local_rpc_channel, create_mqtt_rpc_channel
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -60,7 +60,11 @@ class V1Channel(Channel):
         self._mqtt_rpc_channel = create_mqtt_rpc_channel(mqtt_channel, security_data)
         self._local_session = local_session
         self._local_channel: LocalChannel | None = None
-        self._combined_rpc_channel: V1RpcChannel | None = None
+        self._local_rpc_channel: V1RpcChannel | None = None
+        # Prefer local, fallback to MQTT
+        self._combined_rpc_channel = PickFirstAvailable(
+            [lambda: self._local_rpc_channel, lambda: self._mqtt_rpc_channel]
+        )
         self._mqtt_unsub: Callable[[], None] | None = None
         self._local_unsub: Callable[[], None] | None = None
         self._callback: Callable[[RoborockMessage], None] | None = None
@@ -84,7 +88,7 @@ class V1Channel(Channel):
     @property
     def rpc_channel(self) -> V1RpcChannel:
         """Return the combined RPC channel prefers local with a fallback to MQTT."""
-        return self._combined_rpc_channel or self._mqtt_rpc_channel
+        return self._combined_rpc_channel
 
     @property
     def mqtt_rpc_channel(self) -> V1RpcChannel:
@@ -160,7 +164,7 @@ class V1Channel(Channel):
         except RoborockException as e:
             self._local_channel = None
             raise RoborockException(f"Error connecting to local device {self._device_uid}: {e}") from e
-        self._combined_rpc_channel = create_combined_rpc_channel(self._local_channel, self._mqtt_rpc_channel)
+        self._local_rpc_channel = create_local_rpc_channel(self._local_channel)
         return await self._local_channel.subscribe(self._on_local_message)
 
     def _on_mqtt_message(self, message: RoborockMessage) -> None:

{python_roborock-2.40.1 → python_roborock-2.41.1}/roborock/devices/v1_rpc_channel.py

@@ -88,16 +88,15 @@ class BaseV1RpcChannel(V1RpcChannel):
         raise NotImplementedError
 
 
-class CombinedV1RpcChannel(BaseV1RpcChannel):
-    """A V1 RPC channel that can use both local and MQTT channels, preferring local when available."""
+class PickFirstAvailable(BaseV1RpcChannel):
+    """A V1 RPC channel that tries multiple channels and picks the first that works."""
 
     def __init__(
-        self, local_channel: LocalChannel, local_rpc_channel: V1RpcChannel, mqtt_channel: V1RpcChannel
+        self,
+        channel_cbs: list[Callable[[], V1RpcChannel | None]],
     ) -> None:
-        """Initialize the combined channel with local and MQTT channels."""
-        self._local_channel = local_channel
-        self._local_rpc_channel = local_rpc_channel
-        self._mqtt_rpc_channel = mqtt_channel
+        """Initialize the pick-first-available channel."""
+        self._channel_cbs = channel_cbs
 
     async def _send_raw_command(
         self,
@@ -106,9 +105,10 @@ class CombinedV1RpcChannel(BaseV1RpcChannel):
         params: ParamsType = None,
     ) -> Any:
         """Send a command and return a parsed response RoborockBase type."""
-        if self._local_channel.is_connected:
-            return await self._local_rpc_channel.send_command(method, params=params)
-        return await self._mqtt_rpc_channel.send_command(method, params=params)
+        for channel_cb in self._channel_cbs:
+            if channel := channel_cb():
+                return await channel.send_command(method, params=params)
+        raise RoborockException("No available connection to send command")
 
 
 class PayloadEncodedV1RpcChannel(BaseV1RpcChannel):
@@ -132,8 +132,10 @@ class PayloadEncodedV1RpcChannel(BaseV1RpcChannel):
         params: ParamsType = None,
     ) -> Any:
         """Send a command and return a parsed response RoborockBase type."""
-        _LOGGER.debug("Sending command (%s): %s, params=%s", self._name, method, params)
         request_message = RequestMessage(method, params=params)
+        _LOGGER.debug(
+            "Sending command (%s, request_id=%s): %s, params=%s", self._name, request_message.request_id, method, params
+        )
         message = self._payload_encoder(request_message)
 
         future: asyncio.Future[dict[str, Any]] = asyncio.Future()
@@ -141,8 +143,10 @@ class PayloadEncodedV1RpcChannel(BaseV1RpcChannel):
         def find_response(response_message: RoborockMessage) -> None:
             try:
                 decoded = decode_rpc_response(response_message)
-            except RoborockException:
+            except RoborockException as ex:
+                _LOGGER.debug("Exception while decoding message (%s): %s", response_message, ex)
                 return
+            _LOGGER.debug("Received response (request_id=%s): %s", self._name, decoded.request_id)
             if decoded.request_id == request_message.request_id:
                 future.set_result(decoded.data)
 
@@ -166,11 +170,10 @@ def create_mqtt_rpc_channel(mqtt_channel: MqttChannel, security_data: SecurityDa
     )
 
 
-def create_combined_rpc_channel(local_channel: LocalChannel, mqtt_rpc_channel: V1RpcChannel) -> V1RpcChannel:
-    """Create a V1 RPC channel that combines local and MQTT channels."""
-    local_rpc_channel = PayloadEncodedV1RpcChannel(
+def create_local_rpc_channel(local_channel: LocalChannel) -> V1RpcChannel:
+    """Create a V1 RPC channel using a local channel."""
+    return PayloadEncodedV1RpcChannel(
         "local",
         local_channel,
         lambda x: x.encode_message(RoborockMessageProtocol.GENERAL_REQUEST),
     )
-    return CombinedV1RpcChannel(local_channel, local_rpc_channel, mqtt_rpc_channel)

{python_roborock-2.40.1 → python_roborock-2.41.1}/roborock/protocols/v1_protocol.py

@@ -109,7 +109,7 @@ class ResponseMessage:
 def decode_rpc_response(message: RoborockMessage) -> ResponseMessage:
     """Decode a V1 RPC_RESPONSE message."""
     if not message.payload:
-        raise RoborockException("Invalid V1 message format: missing payload")
+        return ResponseMessage(request_id=message.seq, data={})
     try:
         payload = json.loads(message.payload.decode())
     except (json.JSONDecodeError, TypeError) as e:
@@ -141,6 +141,8 @@ def decode_rpc_response(message: RoborockMessage) -> ResponseMessage:
     _LOGGER.debug("Decoded V1 message result: %s", result)
     if isinstance(result, list) and result:
         result = result[0]
+    if isinstance(result, str) and result == "ok":
+        result = {}
     if not isinstance(result, dict):
         raise RoborockException(f"Invalid V1 message format: 'result' should be a dictionary for {message.payload!r}")
     return ResponseMessage(request_id=request_id, data=result)