python-roborock 2.9.2__tar.gz → 2.9.4__tar.gz

{python_roborock-2.9.2 → python_roborock-2.9.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: python-roborock
-Version: 2.9.2
+Version: 2.9.4
 Summary: A package to control Roborock vacuums.
 License: GPL-3.0-only
 Keywords: roborock,vacuum,homeassistant
@@ -21,7 +21,7 @@ Requires-Dist: aiohttp (>=3.8.2,<4.0.0)
 Requires-Dist: async-timeout
 Requires-Dist: click (>=8)
 Requires-Dist: construct (>=2.10.57,<3.0.0)
-Requires-Dist: paho-mqtt (>=1.6.1,<2.0.0)
+Requires-Dist: paho-mqtt (>=1.6.1,<3.0.0)
 Requires-Dist: pycryptodome (>=3.18,<4.0)
 Requires-Dist: pycryptodomex (>=3.18,<4.0) ; sys_platform == "darwin"
 Requires-Dist: vacuum-map-parser-roborock

{python_roborock-2.9.2 → python_roborock-2.9.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-roborock"
-version = "2.9.2"
+version = "2.9.4"
 description = "A package to control Roborock vacuums."
 authors = ["humbertogontijo <humbertogontijo@users.noreply.github.com>"]
 license = "GPL-3.0-only"
@@ -27,7 +27,7 @@ aiohttp = "^3.8.2"
 async-timeout = "*"
 pycryptodome = "^3.18"
 pycryptodomex = {version = "^3.18", markers = "sys_platform == 'darwin'"}
-paho-mqtt = "^1.6.1"
+paho-mqtt = ">=1.6.1,<3.0.0"
 construct = "^2.10.57"
 vacuum-map-parser-roborock = "*"
 
@@ -45,6 +45,8 @@ ruff = "*"
 codespell = "*"
 pyshark = "^0.6"
 aioresponses = "^0.7.7"
+freezegun = "^1.5.1"
+pytest-timeout = "^2.3.1"
 
 [tool.semantic_release]
 branch = "main"
@@ -70,3 +72,5 @@ select=["E", "F", "UP", "I"]
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+timeout = 20

{python_roborock-2.9.2 → python_roborock-2.9.4}/roborock/api.py

@@ -21,7 +21,6 @@ from .roborock_future import RoborockFuture
 from .roborock_message import (
     RoborockMessage,
 )
-from .roborock_typing import RoborockCommand
 from .util import get_next_int, get_running_loop_or_create_one
 
 _LOGGER = logging.getLogger(__name__)
@@ -124,11 +123,3 @@ class RoborockClient(ABC):
     @abstractmethod
     async def send_message(self, roborock_message: RoborockMessage):
         """Send a message to the Roborock device."""
-
-    @abstractmethod
-    async def _send_command(
-        self,
-        method: RoborockCommand | str,
-        params: list | dict | int | None = None,
-    ):
-        """Send a command to the Roborock device."""

{python_roborock-2.9.2 → python_roborock-2.9.4}/roborock/cloud_api.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import logging
 import threading
-import uuid
 from abc import ABC
 from asyncio import Lock
 from typing import Any
@@ -29,16 +28,10 @@ class _Mqtt(mqtt.Client):
     """
 
     _thread: threading.Thread
-    _client_id: str
 
     def __init__(self) -> None:
         """Initialize the MQTT client."""
         super().__init__(protocol=mqtt.MQTTv5)
-        self.reset_client_id()
-
-    def reset_client_id(self):
-        """Generate a new client id to make a new session when reconnecting."""
-        self._client_id = mqtt.base62(uuid.uuid4().int, padding=22)
 
     def maybe_restart_loop(self) -> None:
         """Ensure that the MQTT loop is running in case it previously exited."""
@@ -89,6 +82,8 @@ class RoborockMqttClient(RoborockClient, ABC):
             self._logger.error(message)
             if connection_queue:
                 connection_queue.set_exception(VacuumError(message))
+            else:
+                self._logger.debug("Failed to notify connect future, not in queue")
             return
         self._logger.info(f"Connected to mqtt {self._mqtt_host}:{self._mqtt_port}")
         topic = f"rr/m/o/{self._mqtt_user}/{self._hashed_user}/{self.device_info.device.duid}"
@@ -116,8 +111,6 @@ class RoborockMqttClient(RoborockClient, ABC):
         try:
             exc = RoborockException(mqtt.error_string(rc)) if rc != mqtt.MQTT_ERR_SUCCESS else None
             super().on_connection_lost(exc)
-            if rc == mqtt.MQTT_ERR_PROTOCOL:
-                self._mqtt_client.reset_client_id()
             connection_queue = self._waiting_queue.get(DISCONNECT_REQUEST_ID)
             if connection_queue:
                 connection_queue.set_result(True)
@@ -163,10 +156,9 @@ class RoborockMqttClient(RoborockClient, ABC):
     async def async_disconnect(self) -> None:
         async with self._mutex:
             if disconnected_future := self.sync_disconnect():
-                try:
-                    await disconnected_future
-                except VacuumError as err:
-                    raise RoborockException(err) from err
+                # There are no errors set on this future
+                await disconnected_future
+            await self.event_loop.run_in_executor(None, self._mqtt_client.loop_stop)
 
     async def async_connect(self) -> None:
         async with self._mutex:

{python_roborock-2.9.2 → python_roborock-2.9.4}/roborock/roborock_message.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import json
 import math
 import time
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 
 from roborock import RoborockEnum
 from roborock.util import get_next_int
@@ -155,10 +155,10 @@ class MessageRetry:
 class RoborockMessage:
     protocol: RoborockMessageProtocol
     payload: bytes | None = None
-    seq: int = get_next_int(100000, 999999)
+    seq: int = field(default_factory=lambda: get_next_int(100000, 999999))
     version: bytes = b"1.0"
-    random: int = get_next_int(10000, 99999)
-    timestamp: int = math.floor(time.time())
+    random: int = field(default_factory=lambda: get_next_int(10000, 99999))
+    timestamp: int = field(default_factory=lambda: math.floor(time.time()))
     message_retry: MessageRetry | None = None
 
     def get_request_id(self) -> int | None:

{python_roborock-2.9.2 → python_roborock-2.9.4}/roborock/version_1_apis/roborock_client_v1.py

@@ -4,7 +4,7 @@ import json
 import math
 import struct
 import time
-from abc import ABC
+from abc import ABC, abstractmethod
 from collections.abc import Callable, Coroutine
 from typing import Any, TypeVar, final
 
@@ -78,12 +78,15 @@ RT = TypeVar("RT", bound=RoborockBase)
 EVICT_TIME = 60
 
 
+_SendCommandT = Callable[[RoborockCommand | str, list | dict | int | None], Any]
+
+
 class AttributeCache:
-    def __init__(self, attribute: RoborockAttribute, api: RoborockClient):
+    def __init__(self, attribute: RoborockAttribute, loop: asyncio.AbstractEventLoop, send_command: _SendCommandT):
         self.attribute = attribute
-        self.api = api
+        self._send_command = send_command
         self.attribute = attribute
-        self.task = RepeatableTask(self.api.event_loop, self._async_value, EVICT_TIME)
+        self.task = RepeatableTask(loop, self._async_value, EVICT_TIME)
         self._value: Any = None
         self._mutex = asyncio.Lock()
         self.unsupported: bool = False
@@ -96,7 +99,7 @@ class AttributeCache:
         if self.unsupported:
             return None
         try:
-            self._value = await self.api._send_command(self.attribute.get_command)
+            self._value = await self._send_command(self.attribute.get_command, None)
         except UnknownMethodError as err:
             # Limit the amount of times we call unsupported methods
             self.unsupported = True
@@ -115,21 +118,21 @@ class AttributeCache:
     async def update_value(self, params) -> None:
         if self.attribute.set_command is None:
             raise RoborockException(f"{self.attribute.attribute} have no set command")
-        response = await self.api._send_command(self.attribute.set_command, params)
+        response = await self._send_command(self.attribute.set_command, params)
         await self._async_value()
         return response
 
     async def add_value(self, params):
         if self.attribute.add_command is None:
             raise RoborockException(f"{self.attribute.attribute} have no add command")
-        response = await self.api._send_command(self.attribute.add_command, params)
+        response = await self._send_command(self.attribute.add_command, params)
         await self._async_value()
         return response
 
     async def close_value(self, params=None) -> None:
         if self.attribute.close_command is None:
             raise RoborockException(f"{self.attribute.attribute} have no close command")
-        response = await self.api._send_command(self.attribute.close_command, params)
+        response = await self._send_command(self.attribute.close_command, params)
         await self._async_value()
         return response
 
@@ -153,7 +156,8 @@ class RoborockClientV1(RoborockClient, ABC):
         super().__init__(device_info)
         self._status_type: type[Status] = ModelStatus.get(device_info.model, S7MaxVStatus)
         self.cache: dict[CacheableAttribute, AttributeCache] = {
-            cacheable_attribute: AttributeCache(attr, self) for cacheable_attribute, attr in get_cache_map().items()
+            cacheable_attribute: AttributeCache(attr, self.event_loop, self._send_command)
+            for cacheable_attribute, attr in get_cache_map().items()
         }
         if device_info.device.duid not in self._listeners:
             self._listeners[device_info.device.duid] = ListenerModel({}, self.cache)
@@ -364,6 +368,14 @@ class RoborockClientV1(RoborockClient, ABC):
         )
         return request_id, timestamp, payload
 
+    @abstractmethod
+    async def _send_command(
+        self,
+        method: RoborockCommand | str,
+        params: list | dict | int | None = None,
+    ) -> Any:
+        """Send a command to the Roborock device."""
+
     def on_message_received(self, messages: list[RoborockMessage]) -> None:
         try:
             self._last_device_msg_in = time.monotonic()

{python_roborock-2.9.2 → python_roborock-2.9.4}/roborock/version_a01_apis/roborock_client_a01.py

@@ -123,11 +123,13 @@ class RoborockClientA01(RoborockClient, ABC):
                 payload = message.payload
                 try:
                     payload = unpad(payload, AES.block_size)
-                except Exception:
+                except Exception as err:
+                    self._logger.debug("Failed to unpad payload: %s", err)
                     continue
                 payload_json = json.loads(payload.decode())
                 for data_point_number, data_point in payload_json.get("dps").items():
                     data_point_protocol: RoborockDyadDataProtocol | RoborockZeoProtocol
+                    self._logger.debug("received msg with dps, protocol: %s, %s", data_point_number, protocol)
                     entries: dict
                     if self.category == RoborockCategory.WET_DRY_VAC:
                         data_point_protocol = RoborockDyadDataProtocol(int(data_point_number))