python-roborock 2.40.0__tar.gz → 2.41.0__tar.gz

{python_roborock-2.40.0 → python_roborock-2.41.0}/PKG-INFO

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

{python_roborock-2.40.0 → python_roborock-2.41.0}/pyproject.toml

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

{python_roborock-2.40.0 → python_roborock-2.41.0}/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.0 → python_roborock-2.41.0}/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.0/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.0 → python_roborock-2.41.0}/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.0 → python_roborock-2.41.0}/roborock/devices/v1_rpc_channel.py

@@ -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)
 

{python_roborock-2.40.0 → python_roborock-2.41.0}/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)
@@ -157,19 +159,18 @@ class MapResponse:
     """The map data, decrypted and decompressed."""
 
 
-def create_map_response_decoder(security_data: SecurityData) -> Callable[[RoborockMessage], MapResponse]:
+def create_map_response_decoder(security_data: SecurityData) -> Callable[[RoborockMessage], MapResponse | None]:
     """Create a decoder for V1 map response messages."""
 
-    def _decode_map_response(message: RoborockMessage) -> MapResponse:
+    def _decode_map_response(message: RoborockMessage) -> MapResponse | None:
         """Decode a V1 map response message."""
         if not message.payload or len(message.payload) < 24:
             raise RoborockException("Invalid V1 map response format: missing payload")
         header, body = message.payload[:24], message.payload[24:]
         [endpoint, _, request_id, _] = struct.unpack("<8s8sH6s", header)
         if not endpoint.decode().startswith(security_data.endpoint):
-            raise RoborockException(
-                f"Invalid V1 map response endpoint: {endpoint!r}, expected {security_data.endpoint!r}"
-            )
+            _LOGGER.debug("Received map response requested not made by this device, ignoring.")
+            return None
         try:
             decrypted = Utils.decrypt_cbc(body, security_data.nonce)
         except ValueError as err:

{python_roborock-2.40.0 → python_roborock-2.41.0}/roborock/version_1_apis/roborock_client_v1.py

@@ -150,7 +150,7 @@ class RoborockClientV1(RoborockClient, ABC):
     """Roborock client base class for version 1 devices."""
 
     _listeners: dict[str, ListenerModel] = {}
-    _map_response_decoder: Callable[[RoborockMessage], MapResponse] | None = None
+    _map_response_decoder: Callable[[RoborockMessage], MapResponse | None] | None = None
 
     def __init__(self, device_info: DeviceData, security_data: SecurityData | None) -> None:
         """Initializes the Roborock client."""
@@ -439,13 +439,14 @@ class RoborockClientV1(RoborockClient, ABC):
                 elif data.payload and protocol == RoborockMessageProtocol.MAP_RESPONSE:
                     if self._map_response_decoder is not None:
                         map_response = self._map_response_decoder(data)
-                        queue = self._waiting_queue.get(map_response.request_id)
-                        if queue:
-                            queue.set_result(map_response.data)
-                        else:
-                            self._logger.debug(
-                                "Received unsolicited map response for request_id %s", map_response.request_id
-                            )
+                        if map_response is not None:
+                            queue = self._waiting_queue.get(map_response.request_id)
+                            if queue:
+                                queue.set_result(map_response.data)
+                            else:
+                                self._logger.debug(
+                                    "Received unsolicited map response for request_id %s", map_response.request_id
+                                )
                 else:
                     queue = self._waiting_queue.get(data.seq)
                     if queue: