python-roborock 2.9.0rc1__tar.gz → 2.9.2__tar.gz

{python_roborock-2.9.0rc1 → python_roborock-2.9.2}/PKG-INFO

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: python-roborock
-Version: 2.9.0rc1
+Version: 2.9.2
 Summary: A package to control Roborock vacuums.
-Home-page: https://github.com/humbertogontijo/python-roborock
 License: GPL-3.0-only
 Keywords: roborock,vacuum,homeassistant
 Author: humbertogontijo
@@ -22,7 +21,6 @@ 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: dacite (>=1.8.0,<2.0.0)
 Requires-Dist: paho-mqtt (>=1.6.1,<2.0.0)
 Requires-Dist: pycryptodome (>=3.18,<4.0)
 Requires-Dist: pycryptodomex (>=3.18,<4.0) ; sys_platform == "darwin"
@@ -53,6 +51,50 @@ Install this via pip (or your favourite package manager):
 
 You can see all of the commands supported [here]("https://python-roborock.readthedocs.io/en/latest/api_commands.html")
 
+## Sending Commands
+
+Here is an example that requires no manual intervention and can be done all automatically. You can skip some steps by
+caching values or looking at them and grabbing them manually.
+```python
+import asyncio
+
+from roborock import HomeDataProduct, DeviceData, RoborockCommand
+from roborock.version_1_apis import RoborockMqttClientV1, RoborockLocalClientV1
+from roborock.web_api import RoborockApiClient
+
+async def main():
+    web_api = RoborockApiClient(username="youremailhere")
+    # Login via your password
+    user_data = await web_api.pass_login(password="pass_here")
+    # Or login via a code
+    await web_api.request_code()
+    code = input("What is the code?")
+    user_data = await web_api.code_login(code)
+
+    # Get home data
+    home_data = await web_api.get_home_data_v2(user_data)
+
+    # Get the device you want
+    device = home_data.devices[0]
+
+    # Get product ids:
+    product_info: dict[str, HomeDataProduct] = {
+            product.id: product for product in home_data.products
+        }
+    # Create the Mqtt(aka cloud required) Client
+    device_data = DeviceData(device, product_info[device.product_id].model)
+    mqtt_client = RoborockMqttClientV1(user_data, device_data)
+    networking = await mqtt_client.get_networking()
+    local_device_data = DeviceData(device, product_info[device.product_id].model, networking.ip)
+    local_client = RoborockLocalClientV1(local_device_data)
+    # You can use the send_command to send any command to the device
+    status = await local_client.send_command(RoborockCommand.GET_STATUS)
+    # Or use existing functions that will give you data classes
+    status = await local_client.get_status()
+
+asyncio.run(main())
+```
+
 ## Supported devices
 
 You can find what devices are supported

python_roborock-2.9.2/README.md

@@ -0,0 +1,76 @@
+# Roborock
+
+<p align="center">
+  <a href="https://pypi.org/project/python-roborock/">
+    <img src="https://img.shields.io/pypi/v/python-roborock.svg?logo=python&logoColor=fff&style=flat-square" alt="PyPI Version">
+  </a>
+  <img src="https://img.shields.io/pypi/pyversions/python-roborock.svg?style=flat-square&logo=python&amp;logoColor=fff" alt="Supported Python versions">
+  <img src="https://img.shields.io/pypi/l/python-roborock.svg?style=flat-square" alt="License">
+</p>
+
+Roborock library for online and offline control of your vacuums.
+
+## Installation
+
+Install this via pip (or your favourite package manager):
+
+`pip install python-roborock`
+
+## Functionality
+
+You can see all of the commands supported [here]("https://python-roborock.readthedocs.io/en/latest/api_commands.html")
+
+## Sending Commands
+
+Here is an example that requires no manual intervention and can be done all automatically. You can skip some steps by
+caching values or looking at them and grabbing them manually.
+```python
+import asyncio
+
+from roborock import HomeDataProduct, DeviceData, RoborockCommand
+from roborock.version_1_apis import RoborockMqttClientV1, RoborockLocalClientV1
+from roborock.web_api import RoborockApiClient
+
+async def main():
+    web_api = RoborockApiClient(username="youremailhere")
+    # Login via your password
+    user_data = await web_api.pass_login(password="pass_here")
+    # Or login via a code
+    await web_api.request_code()
+    code = input("What is the code?")
+    user_data = await web_api.code_login(code)
+
+    # Get home data
+    home_data = await web_api.get_home_data_v2(user_data)
+
+    # Get the device you want
+    device = home_data.devices[0]
+
+    # Get product ids:
+    product_info: dict[str, HomeDataProduct] = {
+            product.id: product for product in home_data.products
+        }
+    # Create the Mqtt(aka cloud required) Client
+    device_data = DeviceData(device, product_info[device.product_id].model)
+    mqtt_client = RoborockMqttClientV1(user_data, device_data)
+    networking = await mqtt_client.get_networking()
+    local_device_data = DeviceData(device, product_info[device.product_id].model, networking.ip)
+    local_client = RoborockLocalClientV1(local_device_data)
+    # You can use the send_command to send any command to the device
+    status = await local_client.send_command(RoborockCommand.GET_STATUS)
+    # Or use existing functions that will give you data classes
+    status = await local_client.get_status()
+
+asyncio.run(main())
+```
+
+## Supported devices
+
+You can find what devices are supported
+[here]("https://python-roborock.readthedocs.io/en/latest/supported_devices.html").
+Please note this may not immediately contain the latest devices.
+
+
+## Credits
+
+Thanks @rovo89 for https://gist.github.com/rovo89/dff47ed19fca0dfdda77503e66c2b7c7 And thanks @PiotrMachowski for https://github.com/PiotrMachowski/Home-Assistant-custom-components-Xiaomi-Cloud-Map-Extractor

{python_roborock-2.9.0rc1 → python_roborock-2.9.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-roborock"
-version = "2.9.0-rc.1"
+version = "2.9.2"
 description = "A package to control Roborock vacuums."
 authors = ["humbertogontijo <humbertogontijo@users.noreply.github.com>"]
 license = "GPL-3.0-only"
@@ -28,7 +28,6 @@ async-timeout = "*"
 pycryptodome = "^3.18"
 pycryptodomex = {version = "^3.18", markers = "sys_platform == 'darwin'"}
 paho-mqtt = "^1.6.1"
-dacite = "^1.8.0"
 construct = "^2.10.57"
 vacuum-map-parser-roborock = "*"
 
@@ -40,25 +39,17 @@ build-backend = "poetry.core.masonry.api"
 [tool.poetry.group.dev.dependencies]
 pytest-asyncio = "*"
 pytest = "*"
-pre-commit = "^3.5.0"
+pre-commit = ">=3.5,<5.0"
 mypy = "*"
 ruff = "*"
 codespell = "*"
 pyshark = "^0.6"
+aioresponses = "^0.7.7"
 
 [tool.semantic_release]
+branch = "main"
 version_toml = ["pyproject.toml:tool.poetry.version"]
 build_command = "pip install poetry && poetry build"
-
-[semantic_release.branches.main]
-match = "release"
-prerelease = false
-
-[tool.semantic_release.branches.other]
-match = ".*"
-prerelease_token = "rc"
-prerelease = true
-
 [tool.semantic_release.commit_parser_options]
 allowed_tags = [
     "chore",
@@ -76,3 +67,6 @@ select=["E", "F", "UP", "I"]
 
 [tool.ruff.lint.per-file-ignores]
 "*/__init__.py" = ["F401"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

{python_roborock-2.9.0rc1 → python_roborock-2.9.2}/roborock/api.py

@@ -7,7 +7,7 @@ import base64
 import logging
 import secrets
 import time
-from collections.abc import Callable, Coroutine
+from abc import ABC, abstractmethod
 from typing import Any
 
 from .containers import (
@@ -16,33 +16,35 @@ from .containers import (
 from .exceptions import (
     RoborockTimeout,
     UnknownMethodError,
-    VacuumError,
 )
 from .roborock_future import RoborockFuture
 from .roborock_message import (
     RoborockMessage,
 )
 from .roborock_typing import RoborockCommand
-from .util import RoborockLoggerAdapter, get_next_int, get_running_loop_or_create_one
+from .util import get_next_int, get_running_loop_or_create_one
 
 _LOGGER = logging.getLogger(__name__)
 KEEPALIVE = 60
 
 
-class RoborockClient:
-    def __init__(self, endpoint: str, device_info: DeviceData, queue_timeout: int = 4) -> None:
+class RoborockClient(ABC):
+    """Roborock client base class."""
+
+    _logger: logging.LoggerAdapter
+
+    def __init__(self, device_info: DeviceData, queue_timeout: int = 4) -> None:
+        """Initialize RoborockClient."""
         self.event_loop = get_running_loop_or_create_one()
         self.device_info = device_info
-        self._endpoint = endpoint
         self._nonce = secrets.token_bytes(16)
         self._waiting_queue: dict[int, RoborockFuture] = {}
-        self._last_device_msg_in = self.time_func()
-        self._last_disconnection = self.time_func()
+        self._last_device_msg_in = time.monotonic()
+        self._last_disconnection = time.monotonic()
         self.keep_alive = KEEPALIVE
         self._diagnostic_data: dict[str, dict[str, Any]] = {
             "misc_info": {"Nonce": base64.b64encode(self._nonce).decode("utf-8")}
         }
-        self._logger = RoborockLoggerAdapter(device_info.device.name, _LOGGER)
         self.is_available: bool = True
         self.queue_timeout = queue_timeout
 
@@ -59,35 +61,30 @@ class RoborockClient:
     def diagnostic_data(self) -> dict:
         return self._diagnostic_data
 
-    @property
-    def time_func(self) -> Callable[[], float]:
-        try:
-            # Use monotonic clock if available
-            time_func = time.monotonic
-        except AttributeError:
-            time_func = time.time
-        return time_func
-
+    @abstractmethod
     async def async_connect(self):
-        raise NotImplementedError
+        """Connect to the Roborock device."""
 
+    @abstractmethod
     def sync_disconnect(self) -> Any:
-        raise NotImplementedError
+        """Disconnect from the Roborock device."""
 
+    @abstractmethod
     async def async_disconnect(self) -> Any:
-        raise NotImplementedError
+        """Disconnect from the Roborock device."""
 
+    @abstractmethod
     def on_message_received(self, messages: list[RoborockMessage]) -> None:
-        raise NotImplementedError
+        """Handle received incoming messages from the device."""
 
     def on_connection_lost(self, exc: Exception | None) -> None:
-        self._last_disconnection = self.time_func()
+        self._last_disconnection = time.monotonic()
         self._logger.info("Roborock client disconnected")
         if exc is not None:
             self._logger.warning(exc)
 
     def should_keepalive(self) -> bool:
-        now = self.time_func()
+        now = time.monotonic()
         # noinspection PyUnresolvedReferences
         if now - self._last_disconnection > self.keep_alive**2 and now - self._last_device_msg_in > self.keep_alive:
             return False
@@ -98,37 +95,40 @@ class RoborockClient:
             await self.async_disconnect()
         await self.async_connect()
 
-    async def _wait_response(self, request_id: int, queue: RoborockFuture) -> tuple[Any, VacuumError | None]:
+    async def _wait_response(self, request_id: int, queue: RoborockFuture) -> Any:
         try:
-            (response, err) = await queue.async_get(self.queue_timeout)
+            response = await queue.async_get(self.queue_timeout)
             if response == "unknown_method":
                 raise UnknownMethodError("Unknown method")
-            return response, err
+            return response
         except (asyncio.TimeoutError, asyncio.CancelledError):
             raise RoborockTimeout(f"id={request_id} Timeout after {self.queue_timeout} seconds") from None
         finally:
             self._waiting_queue.pop(request_id, None)
 
-    def _async_response(
-        self, request_id: int, protocol_id: int = 0
-    ) -> Coroutine[Any, Any, tuple[Any, VacuumError | None]]:
+    def _async_response(self, request_id: int, protocol_id: int = 0) -> Any:
         queue = RoborockFuture(protocol_id)
         if request_id in self._waiting_queue:
             new_id = get_next_int(10000, 32767)
-            _LOGGER.warning(
-                f"Attempting to create a future with an existing request_id... New id is {new_id}. "
-                f"Code may not function properly."
+            self._logger.warning(
+                "Attempting to create a future with an existing id %s (%s)... New id is %s. "
+                "Code may not function properly.",
+                request_id,
+                protocol_id,
+                new_id,
             )
             request_id = new_id
         self._waiting_queue[request_id] = queue
-        return self._wait_response(request_id, queue)
+        return asyncio.ensure_future(self._wait_response(request_id, queue))
 
+    @abstractmethod
     async def send_message(self, roborock_message: RoborockMessage):
-        raise NotImplementedError
+        """Send a message to the Roborock device."""
 
+    @abstractmethod
     async def _send_command(
         self,
         method: RoborockCommand | str,
         params: list | dict | int | None = None,
     ):
-        raise NotImplementedError
+        """Send a command to the Roborock device."""

{python_roborock-2.9.0rc1 → python_roborock-2.9.2}/roborock/cloud_api.py

@@ -1,12 +1,10 @@
 from __future__ import annotations
 
-import asyncio
-import base64
 import logging
 import threading
-import typing
 import uuid
-from asyncio import Lock, Task
+from abc import ABC
+from asyncio import Lock
 from typing import Any
 from urllib.parse import urlparse
 
@@ -15,31 +13,52 @@ import paho.mqtt.client as mqtt
 from .api import KEEPALIVE, RoborockClient
 from .containers import DeviceData, UserData
 from .exceptions import RoborockException, VacuumError
-from .protocol import MessageParser, Utils, md5hex
+from .protocol import MessageParser, md5hex
 from .roborock_future import RoborockFuture
-from .roborock_message import RoborockMessage
-from .roborock_typing import RoborockCommand
-from .util import RoborockLoggerAdapter
 
-if typing.TYPE_CHECKING:
-    pass
 _LOGGER = logging.getLogger(__name__)
 CONNECT_REQUEST_ID = 0
 DISCONNECT_REQUEST_ID = 1
 
 
-class RoborockMqttClient(RoborockClient, mqtt.Client):
+class _Mqtt(mqtt.Client):
+    """Internal MQTT client.
+
+    This is a subclass of the Paho MQTT client that adds some additional functionality
+    for error cases where things get stuck.
+    """
+
     _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."""
+        if not self._thread or not self._thread.is_alive():
+            if self._thread:
+                _LOGGER.info("Stopping mqtt loop")
+                super().loop_stop()
+            _LOGGER.info("Starting mqtt loop")
+            super().loop_start()
+
+
+class RoborockMqttClient(RoborockClient, ABC):
+    """Roborock MQTT client base class."""
+
     def __init__(self, user_data: UserData, device_info: DeviceData, queue_timeout: int = 10) -> None:
+        """Initialize the Roborock MQTT client."""
         rriot = user_data.rriot
         if rriot is None:
             raise RoborockException("Got no rriot data from user_data")
-        endpoint = base64.b64encode(Utils.md5(rriot.k.encode())[8:14]).decode()
-        RoborockClient.__init__(self, endpoint, device_info, queue_timeout)
-        mqtt.Client.__init__(self, protocol=mqtt.MQTTv5)
-        self._logger = RoborockLoggerAdapter(device_info.device.name, _LOGGER)
+        RoborockClient.__init__(self, device_info, queue_timeout)
         self._mqtt_user = rriot.u
         self._hashed_user = md5hex(self._mqtt_user + ":" + rriot.k)[2:10]
         url = urlparse(rriot.r.m)
@@ -48,39 +67,43 @@ class RoborockMqttClient(RoborockClient, mqtt.Client):
         self._mqtt_host = str(url.hostname)
         self._mqtt_port = url.port
         self._mqtt_ssl = url.scheme == "ssl"
+
+        self._mqtt_client = _Mqtt()
+        self._mqtt_client.on_connect = self._mqtt_on_connect
+        self._mqtt_client.on_message = self._mqtt_on_message
+        self._mqtt_client.on_disconnect = self._mqtt_on_disconnect
         if self._mqtt_ssl:
-            super().tls_set()
+            self._mqtt_client.tls_set()
+
         self._mqtt_password = rriot.s
         self._hashed_password = md5hex(self._mqtt_password + ":" + rriot.k)[16:]
-        super().username_pw_set(self._hashed_user, self._hashed_password)
-        self._endpoint = base64.b64encode(Utils.md5(rriot.k.encode())[8:14]).decode()
+        self._mqtt_client.username_pw_set(self._hashed_user, self._hashed_password)
         self._waiting_queue: dict[int, RoborockFuture] = {}
         self._mutex = Lock()
-        self.update_client_id()
 
-    def on_connect(self, *args, **kwargs):
+    def _mqtt_on_connect(self, *args, **kwargs):
         _, __, ___, rc, ____ = args
         connection_queue = self._waiting_queue.get(CONNECT_REQUEST_ID)
         if rc != mqtt.MQTT_ERR_SUCCESS:
             message = f"Failed to connect ({mqtt.error_string(rc)})"
             self._logger.error(message)
             if connection_queue:
-                connection_queue.resolve((None, VacuumError(message)))
+                connection_queue.set_exception(VacuumError(message))
             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}"
-        (result, mid) = self.subscribe(topic)
+        (result, mid) = self._mqtt_client.subscribe(topic)
         if result != 0:
             message = f"Failed to subscribe ({mqtt.error_string(rc)})"
             self._logger.error(message)
             if connection_queue:
-                connection_queue.resolve((None, VacuumError(message)))
+                connection_queue.set_exception(VacuumError(message))
             return
         self._logger.info(f"Subscribed to topic {topic}")
         if connection_queue:
-            connection_queue.resolve((True, None))
+            connection_queue.set_result(True)
 
-    def on_message(self, *args, **kwargs):
+    def _mqtt_on_message(self, *args, **kwargs):
         client, __, msg = args
         try:
             messages, _ = MessageParser.parse(msg.payload, local_key=self.device_info.device.local_key)
@@ -88,93 +111,74 @@ class RoborockMqttClient(RoborockClient, mqtt.Client):
         except Exception as ex:
             self._logger.exception(ex)
 
-    def on_disconnect(self, *args, **kwargs):
+    def _mqtt_on_disconnect(self, *args, **kwargs):
         _, __, rc, ___ = args
         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.update_client_id()
+                self._mqtt_client.reset_client_id()
             connection_queue = self._waiting_queue.get(DISCONNECT_REQUEST_ID)
             if connection_queue:
-                connection_queue.resolve((True, None))
+                connection_queue.set_result(True)
         except Exception as ex:
             self._logger.exception(ex)
 
-    def update_client_id(self):
-        self._client_id = mqtt.base62(uuid.uuid4().int, padding=22)
-
-    def sync_stop_loop(self) -> None:
-        if self._thread:
-            self._logger.info("Stopping mqtt loop")
-            super().loop_stop()
-
-    def sync_start_loop(self) -> None:
-        if not self._thread or not self._thread.is_alive():
-            self.sync_stop_loop()
-            self._logger.info("Starting mqtt loop")
-            super().loop_start()
+    def is_connected(self) -> bool:
+        """Check if the mqtt client is connected."""
+        return self._mqtt_client.is_connected()
 
-    def sync_disconnect(self) -> tuple[bool, Task[tuple[Any, VacuumError | None]] | None]:
+    def sync_disconnect(self) -> Any:
         if not self.is_connected():
-            return False, None
+            return None
 
         self._logger.info("Disconnecting from mqtt")
-        disconnected_future = asyncio.ensure_future(self._async_response(DISCONNECT_REQUEST_ID))
-        rc = super().disconnect()
+        disconnected_future = self._async_response(DISCONNECT_REQUEST_ID)
+        rc = self._mqtt_client.disconnect()
 
         if rc == mqtt.MQTT_ERR_NO_CONN:
             disconnected_future.cancel()
-            return False, None
+            return None
 
         if rc != mqtt.MQTT_ERR_SUCCESS:
             disconnected_future.cancel()
             raise RoborockException(f"Failed to disconnect ({mqtt.error_string(rc)})")
 
-        return True, disconnected_future
+        return disconnected_future
 
-    def sync_connect(self) -> tuple[bool, Task[tuple[Any, VacuumError | None]] | None]:
+    def sync_connect(self) -> Any:
         if self.is_connected():
-            self.sync_start_loop()
-            return False, None
+            self._mqtt_client.maybe_restart_loop()
+            return None
 
         if self._mqtt_port is None or self._mqtt_host is None:
             raise RoborockException("Mqtt information was not entered. Cannot connect.")
 
         self._logger.debug("Connecting to mqtt")
-        connected_future = asyncio.ensure_future(self._async_response(CONNECT_REQUEST_ID))
-        super().connect(host=self._mqtt_host, port=self._mqtt_port, keepalive=KEEPALIVE)
-
-        self.sync_start_loop()
-        return True, connected_future
+        connected_future = self._async_response(CONNECT_REQUEST_ID)
+        self._mqtt_client.connect(host=self._mqtt_host, port=self._mqtt_port, keepalive=KEEPALIVE)
+        self._mqtt_client.maybe_restart_loop()
+        return connected_future
 
     async def async_disconnect(self) -> None:
         async with self._mutex:
-            (disconnecting, disconnected_future) = self.sync_disconnect()
-            if disconnecting and disconnected_future:
-                (_, err) = await disconnected_future
-                if err:
+            if disconnected_future := self.sync_disconnect():
+                try:
+                    await disconnected_future
+                except VacuumError as err:
                     raise RoborockException(err) from err
 
     async def async_connect(self) -> None:
         async with self._mutex:
-            (connecting, connected_future) = self.sync_connect()
-            if connecting and connected_future:
-                (_, err) = await connected_future
-                if err:
+            if connected_future := self.sync_connect():
+                try:
+                    await connected_future
+                except VacuumError as err:
                     raise RoborockException(err) from err
 
     def _send_msg_raw(self, msg: bytes) -> None:
-        info = self.publish(f"rr/m/i/{self._mqtt_user}/{self._hashed_user}/{self.device_info.device.duid}", msg)
+        info = self._mqtt_client.publish(
+            f"rr/m/i/{self._mqtt_user}/{self._hashed_user}/{self.device_info.device.duid}", msg
+        )
         if info.rc != mqtt.MQTT_ERR_SUCCESS:
             raise RoborockException(f"Failed to publish ({mqtt.error_string(info.rc)})")
-
-    async def send_message(self, roborock_message: RoborockMessage):
-        raise NotImplementedError
-
-    async def _send_command(
-        self,
-        method: RoborockCommand | str,
-        params: list | dict | int | None = None,
-    ):
-        raise NotImplementedError