python-roborock 0.41.0__tar.gz → 2.0.0__tar.gz

{python_roborock-0.41.0 → python_roborock-2.0.0}/PKG-INFO

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

{python_roborock-0.41.0 → python_roborock-2.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-roborock"
-version = "0.41.0"
+version = "2.0.0"
 description = "A package to control Roborock vacuums."
 authors = ["humbertogontijo <humbertogontijo@users.noreply.github.com>"]
 license = "GPL-3.0-only"
@@ -49,8 +49,20 @@ pyshark = "^0.6"
 branch = "main"
 version_toml = "pyproject.toml:tool.poetry.version"
 build_command = "pip install poetry && poetry build"
+[tool.semantic_release.commit_parser_options]
+allowed_tags = [
+    "chore",
+    "docs",
+    "feat",
+    "fix",
+    "refactor"
+]
+major_tags= ["refactor"]
 
 [tool.ruff]
 ignore = ["F403", "E741"]
 line-length = 120
 select=["E", "F", "UP", "I"]
+
+[tool.ruff.lint.per-file-ignores]
+"*/__init__.py" = ["F401"]

python_roborock-2.0.0/roborock/api.py

@@ -0,0 +1,127 @@
+"""The Roborock api."""
+
+from __future__ import annotations
+
+import asyncio
+import base64
+import logging
+import secrets
+import time
+from collections.abc import Callable, Coroutine
+from typing import Any
+
+from .containers import (
+    DeviceData,
+)
+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_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:
+        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.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
+
+    def __del__(self) -> None:
+        self.release()
+
+    def release(self):
+        self.sync_disconnect()
+
+    async def async_release(self):
+        await self.async_disconnect()
+
+    @property
+    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
+
+    async def async_connect(self):
+        raise NotImplementedError
+
+    def sync_disconnect(self) -> Any:
+        raise NotImplementedError
+
+    async def async_disconnect(self) -> Any:
+        raise NotImplementedError
+
+    def on_message_received(self, messages: list[RoborockMessage]) -> None:
+        raise NotImplementedError
+
+    def on_connection_lost(self, exc: Exception | None) -> None:
+        self._last_disconnection = self.time_func()
+        self._logger.info("Roborock client disconnected")
+        if exc is not None:
+            self._logger.warning(exc)
+
+    def should_keepalive(self) -> bool:
+        now = self.time_func()
+        # noinspection PyUnresolvedReferences
+        if now - self._last_disconnection > self.keep_alive**2 and now - self._last_device_msg_in > self.keep_alive:
+            return False
+        return True
+
+    async def validate_connection(self) -> None:
+        if not self.should_keepalive():
+            await self.async_disconnect()
+        await self.async_connect()
+
+    async def _wait_response(self, request_id: int, queue: RoborockFuture) -> tuple[Any, VacuumError | None]:
+        try:
+            (response, err) = await queue.async_get(self.queue_timeout)
+            if response == "unknown_method":
+                raise UnknownMethodError("Unknown method")
+            return response, err
+        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]]:
+        queue = RoborockFuture(protocol_id)
+        self._waiting_queue[request_id] = queue
+        return self._wait_response(request_id, queue)
+
+    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

{python_roborock-0.41.0 → python_roborock-2.0.0}/roborock/cloud_api.py

@@ -4,6 +4,7 @@ import asyncio
 import base64
 import logging
 import threading
+import typing
 import uuid
 from asyncio import Lock, Task
 from typing import Any
@@ -11,15 +12,17 @@ from urllib.parse import urlparse
 
 import paho.mqtt.client as mqtt
 
-from .api import KEEPALIVE, RoborockClient, md5hex
+from .api import KEEPALIVE, RoborockClient
 from .containers import DeviceData, UserData
 from .exceptions import RoborockException, VacuumError
-from .protocol import MessageParser, Utils
+from .protocol import MessageParser, Utils, 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
@@ -78,7 +81,7 @@ class RoborockMqttClient(RoborockClient, mqtt.Client):
             connection_queue.resolve((True, None))
 
     def on_message(self, *args, **kwargs):
-        _, __, msg = args
+        client, __, msg = args
         try:
             messages, _ = MessageParser.parse(msg.payload, local_key=self.device_info.device.local_key)
             super().on_message_received(messages)

{python_roborock-0.41.0 → python_roborock-2.0.0}/roborock/code_mappings.py

@@ -98,8 +98,8 @@ class RoborockDyadStateCode(RoborockEnum):
     self_clean_deep_cleaning = 6
     self_clean_rinsing = 7
     self_clean_dehydrating = 8
-    drying = 10
-    ventilating = 11  # drying
+    drying = 9
+    ventilating = 10  # drying
     reserving = 12
     mop_washing_paused = 13
     dusting_mode = 14
@@ -369,3 +369,219 @@ class RoborockCategory(Enum):
     def __missing__(self, key):
         _LOGGER.warning("Missing key %s from category", key)
         return RoborockCategory.UNKNOWN
+
+
+class DyadSelfCleanMode(RoborockEnum):
+    self_clean = 1
+    self_clean_and_dry = 2
+    dry = 3
+    ventilation = 4
+
+
+class DyadSelfCleanLevel(RoborockEnum):
+    normal = 1
+    deep = 2
+
+
+class DyadWarmLevel(RoborockEnum):
+    normal = 1
+    deep = 2
+
+
+class DyadMode(RoborockEnum):
+    wash = 1
+    wash_and_dry = 2
+    dry = 3
+
+
+class DyadCleanMode(RoborockEnum):
+    auto = 1
+    max = 2
+    dehydration = 3
+    power_saving = 4
+
+
+class DyadSuction(RoborockEnum):
+    l1 = 1
+    l2 = 2
+    l3 = 3
+    l4 = 4
+    l5 = 5
+    l6 = 6
+
+
+class DyadWaterLevel(RoborockEnum):
+    l1 = 1
+    l2 = 2
+    l3 = 3
+    l4 = 4
+
+
+class DyadBrushSpeed(RoborockEnum):
+    l1 = 1
+    l2 = 2
+
+
+class DyadCleanser(RoborockEnum):
+    none = 0
+    normal = 1
+    deep = 2
+    max = 3
+
+
+class DyadError(RoborockEnum):
+    none = 0
+    dirty_tank_full = 20000  # Dirty tank full. Empty it
+    water_level_sensor_stuck = 20001  # Water level sensor is stuck. Clean it.
+    clean_tank_empty = 20002  # Clean tank empty. Refill now
+    clean_head_entangled = 20003  # Check if the cleaning head is entangled with foreign objects.
+    clean_head_too_hot = 20004  # Cleaning head temperature protection. Wait for the temperature to return to normal.
+    fan_protection_e5 = 10005  # Fan protection (E5). Restart the vacuum cleaner.
+    cleaning_head_blocked = 20005  # Remove blockages from the cleaning head and pipes.
+    temperature_protection = 20006  # Temperature protection. Wait for the temperature to return to normal
+    fan_protection_e4 = 10004  # Fan protection (E4). Restart the vacuum cleaner.
+    fan_protection_e9 = 10009  # Fan protection (E9). Restart the vacuum cleaner.
+    battery_temperature_protection_e0 = 10000
+    battery_temperature_protection = (
+        20007  # Battery temperature protection. Wait for the temperature to return to a normal range.
+    )
+    battery_temperature_protection_2 = 20008
+    power_adapter_error = 20009  # Check if the power adapter is working properly.
+    dirty_charging_contacts = 10007  # Disconnection between the device and dock. Wipe charging contacts.
+    low_battery = 20017  # Low battery level. Charge before starting self-cleaning.
+    battery_under_10 = 20018  # Charge until the battery level exceeds 10% before manually starting self-cleaning.
+
+
+class ZeoMode(RoborockEnum):
+    wash = 1
+    wash_and_dry = 2
+    dry = 3
+
+
+class ZeoState(RoborockEnum):
+    standby = 1
+    weighing = 2
+    soaking = 3
+    washing = 4
+    rinsing = 5
+    spinning = 6
+    drying = 7
+    cooling = 8
+    under_delay_start = 9
+    done = 10
+
+
+class ZeoProgram(RoborockEnum):
+    standard = 1
+    quick = 2
+    sanitize = 3
+    wool = 4
+    air_refresh = 5
+    custom = 6
+    bedding = 7
+    down = 8
+    silk = 9
+    rinse_and_spin = 10
+    spin = 11
+    down_clean = 12
+    baby_care = 13
+    anti_allergen = 14
+    sportswear = 15
+    night = 16
+    new_clothes = 17
+    shirts = 18
+    synthetics = 19
+    underwear = 20
+    gentle = 21
+    intensive = 22
+    cotton_linen = 23
+    season = 24
+    warming = 25
+    bra = 26
+    panties = 27
+    boiling_wash = 28
+    socks = 30
+    towels = 31
+    anti_mite = 32
+    exo_40_60 = 33
+    twenty_c = 34
+    t_shirts = 35
+    stain_removal = 36
+
+
+class ZeoSoak(RoborockEnum):
+    normal = 0
+    low = 1
+    medium = 2
+    high = 3
+    max = 4
+
+
+class ZeoTemperature(RoborockEnum):
+    normal = 1
+    low = 2
+    medium = 3
+    high = 4
+    max = 5
+    twenty_c = 6
+
+
+class ZeoRinse(RoborockEnum):
+    none = 0
+    min = 1
+    low = 2
+    mid = 3
+    high = 4
+    max = 5
+
+
+class ZeoSpin(RoborockEnum):
+    none = 1
+    very_low = 2
+    low = 3
+    mid = 4
+    high = 5
+    very_high = 6
+    max = 7
+
+
+class ZeoDryingMode(RoborockEnum):
+    none = 0
+    quick = 1
+    iron = 2
+    store = 3
+
+
+class ZeoDetergentType(RoborockEnum):
+    empty = 0
+    low = 1
+    medium = 2
+    high = 3
+
+
+class ZeoSoftenerType(RoborockEnum):
+    empty = 0
+    low = 1
+    medium = 2
+    high = 3
+
+
+class ZeoError(RoborockEnum):
+    none = 0
+    refill_error = 1
+    drain_error = 2
+    door_lock_error = 3
+    water_level_error = 4
+    inverter_error = 5
+    heating_error = 6
+    temperature_error = 7
+    communication_error = 10
+    drying_error = 11
+    drying_error_e_12 = 12
+    drying_error_e_13 = 13
+    drying_error_e_14 = 14
+    drying_error_e_15 = 15
+    drying_error_e_16 = 16
+    drying_error_water_flow = 17  # Check for normal water flow
+    drying_error_restart = 18  # Restart the washer and try again
+    spin_error = 19  # re-arrange clothes

{python_roborock-0.41.0 → python_roborock-2.0.0}/roborock/containers.py

@@ -829,3 +829,28 @@ class RoborockCategoryDetail(RoborockBase):
 @dataclass
 class ProductResponse(RoborockBase):
     category_detail_list: list[RoborockCategoryDetail]
+
+
+@dataclass
+class DyadProductInfo(RoborockBase):
+    sn: str
+    ssid: str
+    timezone: str
+    posix_timezone: str
+    ip: str
+    mac: str
+    oba: dict
+
+
+@dataclass
+class DyadSndState(RoborockBase):
+    sid_in_use: int
+    sid_version: int
+    location: str
+    bom: str
+    language: str
+
+
+@dataclass
+class DyadOtaNfo(RoborockBase):
+    mqttOtaData: dict

{python_roborock-0.41.0 → python_roborock-2.0.0}/roborock/local_api.py

@@ -8,7 +8,7 @@ import async_timeout
 
 from . import DeviceData
 from .api import RoborockClient
-from .exceptions import CommandVacuumError, RoborockConnectionException, RoborockException
+from .exceptions import RoborockConnectionException, RoborockException
 from .protocol import MessageParser
 from .roborock_message import RoborockMessage, RoborockMessageProtocol
 from .roborock_typing import RoborockCommand
@@ -121,40 +121,3 @@ class RoborockLocalClient(RoborockClient, asyncio.Protocol):
             self.transport.write(data)
         except Exception as e:
             raise RoborockException(e) from e
-
-    async def send_message(self, roborock_message: RoborockMessage):
-        await self.validate_connection()
-        method = roborock_message.get_method()
-        params = roborock_message.get_params()
-        request_id: int | None
-        if not method or not method.startswith("get"):
-            request_id = roborock_message.seq
-            response_protocol = request_id + 1
-        else:
-            request_id = roborock_message.get_request_id()
-            response_protocol = RoborockMessageProtocol.GENERAL_REQUEST
-        if request_id is None:
-            raise RoborockException(f"Failed build message {roborock_message}")
-        local_key = self.device_info.device.local_key
-        msg = MessageParser.build(roborock_message, local_key=local_key)
-        if method:
-            self._logger.debug(f"id={request_id} Requesting method {method} with {params}")
-        # Send the command to the Roborock device
-        async_response = asyncio.ensure_future(self._async_response(request_id, response_protocol))
-        self._send_msg_raw(msg)
-        (response, err) = await async_response
-        self._diagnostic_data[method if method is not None else "unknown"] = {
-            "params": roborock_message.get_params(),
-            "response": response,
-            "error": err,
-        }
-        if err:
-            raise CommandVacuumError(method, err) from err
-        if roborock_message.protocol == RoborockMessageProtocol.GENERAL_REQUEST:
-            self._logger.debug(f"id={request_id} Response from method {roborock_message.get_method()}: {response}")
-        if response == "retry":
-            retry_id = roborock_message.get_retry_id()
-            return self.send_command(
-                RoborockCommand.RETRY_REQUEST, {"retry_id": retry_id, "retry_count": 8, "method": method}
-            )
-        return response

{python_roborock-0.41.0 → python_roborock-2.0.0}/roborock/protocol.py

@@ -13,7 +13,6 @@ from construct import (  # type: ignore
     Bytes,
     Checksum,
     ChecksumError,
-    Const,
     Construct,
     Container,
     GreedyBytes,
@@ -36,11 +35,18 @@ from roborock.roborock_message import RoborockMessage
 
 _LOGGER = logging.getLogger(__name__)
 SALT = b"TXdfu$jyZ#TZHsg4"
+A01_HASH = "726f626f726f636b2d67a6d6da"
 BROADCAST_TOKEN = b"qWKYcdQWrbm9hPqe"
 AP_CONFIG = 1
 SOCK_DISCOVERY = 2
 
 
+def md5hex(message: str) -> str:
+    md5 = hashlib.md5()
+    md5.update(message.encode())
+    return md5.hexdigest()
+
+
 class RoborockProtocol(asyncio.DatagramProtocol):
     def __init__(self, timeout: int = 5):
         self.timeout = timeout
@@ -199,12 +205,22 @@ class EncryptionAdapter(Construct):
 
         :param obj: JSON object to encrypt
         """
+        if context.version == b"A01":
+            iv = md5hex(format(context.random, "08x") + A01_HASH)[8:24]
+            decipher = AES.new(bytes(context.search("local_key"), "utf-8"), AES.MODE_CBC, bytes(iv, "utf-8"))
+            f = decipher.encrypt(obj)
+            return f
         token = self.token_func(context)
         encrypted = Utils.encrypt_ecb(obj, token)
         return encrypted
 
     def _decode(self, obj, context, _):
         """Decrypts the given payload with the token stored in the context."""
+        if context.version == b"A01":
+            iv = md5hex(format(context.random, "08x") + A01_HASH)[8:24]
+            decipher = AES.new(bytes(context.search("local_key"), "utf-8"), AES.MODE_CBC, bytes(iv, "utf-8"))
+            f = decipher.decrypt(obj)
+            return f
         token = self.token_func(context)
         decrypted = Utils.decrypt_ecb(obj, token)
         return decrypted
@@ -227,9 +243,9 @@ class OptionalChecksum(Checksum):
 
 class PrefixedStruct(Struct):
     def _parse(self, stream, context, path):
-        subcon1 = Peek(Optional(Const(b"1.0")))
+        subcon1 = Peek(Optional(Bytes(3)))
         peek_version = subcon1.parse_stream(stream, **context)
-        if peek_version is None:
+        if peek_version not in (b"1.0", b"A01"):
             subcon2 = Bytes(4)
             subcon2.parse_stream(stream, **context)
         return super()._parse(stream, context, path)
@@ -251,7 +267,7 @@ class PrefixedStruct(Struct):
 
 _Message = RawCopy(
     Struct(
-        "version" / Const(b"1.0"),
+        "version" / Bytes(3),
         "seq" / Int32ub,
         "random" / Int32ub,
         "timestamp" / Int32ub,
@@ -280,7 +296,7 @@ _BroadcastMessage = Struct(
     "message"
     / RawCopy(
         Struct(
-            "version" / Const(b"1.0"),
+            "version" / Bytes(3),
             "seq" / Int32ub,
             "protocol" / Int16ub,
             "payload" / EncryptionAdapter(lambda ctx: BROADCAST_TOKEN),

{python_roborock-0.41.0 → python_roborock-2.0.0}/roborock/roborock_message.py

@@ -57,7 +57,7 @@ class RoborockDyadDataProtocol(RoborockEnum):
     COUNTDOWN_TIME = 210
     AUTO_SELF_CLEAN_SET = 212
     AUTO_DRY = 213
-    MESH_LEF = 214
+    MESH_LEFT = 214
     BRUSH_LEFT = 215
     ERROR = 216
     MESH_RESET = 218
@@ -70,7 +70,7 @@ class RoborockDyadDataProtocol(RoborockEnum):
     SILENT_MODE = 226
     SILENT_MODE_START_TIME = 227
     SILENT_MODE_END_TIME = 228
-    RECENT_RUN_TIMe = 229
+    RECENT_RUN_TIME = 229
     TOTAL_RUN_TIME = 230
     FEATURE_INFO = 235
     RECOVER_SETTINGS = 236
@@ -87,6 +87,48 @@ class RoborockDyadDataProtocol(RoborockEnum):
     RPC_RESPONSE = 10102
 
 
+class RoborockZeoProtocol(RoborockEnum):
+    START = 200  # rw
+    PAUSE = 201  # rw
+    SHUTDOWN = 202  # rw
+    STATE = 203  # ro
+    MODE = 204  # rw
+    PROGRAM = 205  # rw
+    CHILD_LOCK = 206  # rw
+    TEMP = 207  # rw
+    RINSE_TIMES = 208  # rw
+    SPIN_LEVEL = 209  # rw
+    DRYING_MODE = 210  # rw
+    DETERGENT_SET = 211  # rw
+    SOFTENER_SET = 212  # rw
+    DETERGENT_TYPE = 213  # rw
+    SOFTENER_TYPE = 214  # rw
+    COUNTDOWN = 217  # rw
+    WASHING_LEFT = 218  # ro
+    DOORLOCK_STATE = 219  # ro
+    ERROR = 220  # ro
+    CUSTOM_PARAM_SAVE = 221  # rw
+    CUSTOM_PARAM_GET = 222  # ro
+    SOUND_SET = 223  # rw
+    TIMES_AFTER_CLEAN = 224  # ro
+    DEFAULT_SETTING = 225  # rw
+    DETERGENT_EMPTY = 226  # ro
+    SOFTENER_EMPTY = 227  # ro
+    LIGHT_SETTING = 229  # rw
+    DETERGENT_VOLUME = 230  # rw
+    SOFTENER_VOLUME = 231  # rw
+    APP_AUTHORIZATION = 232  # rw
+    ID_QUERY = 10000
+    F_C = 10001
+    SND_STATE = 10004
+    PRODUCT_INFO = 10005
+    PRIVACY_INFO = 10006
+    OTA_NFO = 10007
+    WASHING_LOG = 10008
+    RPC_REQ = 10101
+    RPC_RESp = 10102
+
+
 ROBOROCK_DATA_STATUS_PROTOCOL = [
     RoborockDataProtocol.ERROR_CODE,
     RoborockDataProtocol.STATE,

python_roborock-2.0.0/roborock/version_1_apis/__init__.py

@@ -0,0 +1,3 @@
+from .roborock_client_v1 import AttributeCache, RoborockClientV1
+from .roborock_local_client_v1 import RoborockLocalClientV1
+from .roborock_mqtt_client_v1 import RoborockMqttClientV1