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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-roborock
-Version: 2.41.0
+Version: 2.42.0
 Summary: A package to control Roborock vacuums.
 Home-page: https://github.com/humbertogontijo/python-roborock
 License: GPL-3.0-only
@@ -21,6 +21,7 @@ Requires-Dist: aiohttp (>=3.8.2,<4.0.0)
 Requires-Dist: aiomqtt (>=2.3.2,<3.0.0)
 Requires-Dist: async-timeout
 Requires-Dist: click (>=8)
+Requires-Dist: click-shell (>=2.1,<3.0)
 Requires-Dist: construct (>=2.10.57,<3.0.0)
 Requires-Dist: paho-mqtt (>=1.6.1,<3.0.0)
 Requires-Dist: pycryptodome (>=3.18,<4.0)

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-roborock"
-version = "2.41.0"
+version = "2.42.0"
 description = "A package to control Roborock vacuums."
 authors = ["humbertogontijo <humbertogontijo@users.noreply.github.com>"]
 license = "GPL-3.0-only"
@@ -32,6 +32,7 @@ construct = "^2.10.57"
 vacuum-map-parser-roborock = "*"
 pyrate-limiter = "^3.7.0"
 aiomqtt = "^2.3.2"
+click-shell = "^2.1"
 
 
 [build-system]

{python_roborock-2.41.0 → python_roborock-2.42.0}/roborock/cli.py

@@ -1,29 +1,96 @@
+"""Command line interface for python-roborock.
+
+The CLI supports both one-off commands and an interactive session mode. In session
+mode, an asyncio event loop is created in a separate thread, allowing users to
+interactively run commands that require async operations.
+
+Typical CLI usage:
+```
+$ roborock login --email <email> [--password <password>]
+$ roborock discover
+$ roborock list-devices
+$ roborock status --device_id <device_id>
+```
+...
+
+Session mode usage:
+```
+$ roborock session
+roborock> list-devices
+...
+roborock> status --device_id <device_id>
+```
+"""
 import asyncio
+import datetime
+import functools
 import json
 import logging
+import threading
 from dataclasses import asdict, dataclass
 from pathlib import Path
-from typing import Any
+from typing import Any, cast
 
 import click
+import click_shell
 import yaml
 from pyshark import FileCapture  # type: ignore
 from pyshark.capture.live_capture import LiveCapture, UnknownInterfaceException  # type: ignore
 from pyshark.packet.packet import Packet  # type: ignore
 
 from roborock import SHORT_MODEL_TO_ENUM, DeviceFeatures, RoborockCommand, RoborockException
-from roborock.containers import DeviceData, HomeData, HomeDataProduct, LoginData, NetworkInfo, RoborockBase, UserData
+from roborock.containers import DeviceData, HomeData, NetworkInfo, RoborockBase, UserData
 from roborock.devices.cache import Cache, CacheData
-from roborock.devices.device_manager import create_device_manager, create_home_data_api
+from roborock.devices.device import RoborockDevice
+from roborock.devices.device_manager import DeviceManager, create_device_manager, create_home_data_api
 from roborock.protocol import MessageParser
-from roborock.util import run_sync
-from roborock.version_1_apis.roborock_local_client_v1 import RoborockLocalClientV1
 from roborock.version_1_apis.roborock_mqtt_client_v1 import RoborockMqttClientV1
 from roborock.web_api import RoborockApiClient
 
 _LOGGER = logging.getLogger(__name__)
 
 
+def dump_json(obj: Any) -> Any:
+    """Dump an object as JSON."""
+
+    def custom_json_serializer(obj):
+        if isinstance(obj, datetime.time):
+            return obj.isoformat()
+        raise TypeError(f"Object of type {obj.__class__.__name__} is not JSON serializable")
+
+    return json.dumps(obj, default=custom_json_serializer)
+
+
+def async_command(func):
+    """Decorator for async commands that work in both CLI and session modes.
+
+    The CLI supports two execution modes:
+    1. CLI mode: One-off commands that create their own event loop
+    2. Session mode: Interactive shell with a persistent background event loop
+
+    This decorator ensures async commands work correctly in both modes:
+    - CLI mode: Uses asyncio.run() to create a new event loop
+    - Session mode: Uses the existing session event loop via run_in_session()
+    """
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        ctx = args[0]
+        context: RoborockContext = ctx.obj
+
+        async def run():
+            return await func(*args, **kwargs)
+
+        if context.is_session_mode():
+            # Session mode - run in the persistent loop
+            return context.run_in_session(run())
+        else:
+            # CLI mode - just run normally (asyncio.run handles loop creation)
+            return asyncio.run(run())
+
+    return wrapper
+
+
 @dataclass
 class ConnectionCache(RoborockBase):
     """Cache for Roborock data.
@@ -41,12 +108,52 @@ class ConnectionCache(RoborockBase):
     network_info: dict[str, NetworkInfo] | None = None
 
 
+class DeviceConnectionManager:
+    """Manages device connections for both CLI and session modes."""
+
+    def __init__(self, context: "RoborockContext", loop: asyncio.AbstractEventLoop | None = None):
+        self.context = context
+        self.loop = loop
+        self.device_manager: DeviceManager | None = None
+        self._devices: dict[str, RoborockDevice] = {}
+
+    async def ensure_device_manager(self) -> DeviceManager:
+        """Ensure device manager is initialized."""
+        if self.device_manager is None:
+            cache_data = self.context.cache_data()
+            home_data_api = create_home_data_api(cache_data.email, cache_data.user_data)
+            self.device_manager = await create_device_manager(cache_data.user_data, home_data_api, self.context)
+            # Cache devices for quick lookup
+            devices = await self.device_manager.get_devices()
+            self._devices = {device.duid: device for device in devices}
+        return self.device_manager
+
+    async def get_device(self, device_id: str) -> RoborockDevice:
+        """Get a device by ID, creating connections if needed."""
+        await self.ensure_device_manager()
+        if device_id not in self._devices:
+            raise RoborockException(f"Device {device_id} not found")
+        return self._devices[device_id]
+
+    async def close(self):
+        """Close device manager connections."""
+        if self.device_manager:
+            await self.device_manager.close()
+            self.device_manager = None
+            self._devices = {}
+
+
 class RoborockContext(Cache):
+    """Context that handles both CLI and session modes internally."""
+
     roborock_file = Path("~/.roborock").expanduser()
     _cache_data: ConnectionCache | None = None
 
     def __init__(self):
         self.reload()
+        self._session_loop: asyncio.AbstractEventLoop | None = None
+        self._session_thread: threading.Thread | None = None
+        self._device_manager: DeviceConnectionManager | None = None
 
     def reload(self):
         if self.roborock_file.is_file():
@@ -68,7 +175,76 @@ class RoborockContext(Cache):
     def cache_data(self) -> ConnectionCache:
         """Get the cache data."""
         self.validate()
-        return self._cache_data
+        return cast(ConnectionCache, self._cache_data)
+
+    def start_session_mode(self):
+        """Start session mode with a background event loop."""
+        if self._session_loop is not None:
+            return  # Already started
+
+        self._session_loop = asyncio.new_event_loop()
+        self._session_thread = threading.Thread(target=self._run_session_loop)
+        self._session_thread.daemon = True
+        self._session_thread.start()
+
+    def _run_session_loop(self):
+        """Run the session event loop in a background thread."""
+        assert self._session_loop is not None  # guaranteed by start_session_mode
+        asyncio.set_event_loop(self._session_loop)
+        self._session_loop.run_forever()
+
+    def is_session_mode(self) -> bool:
+        return self._session_loop is not None
+
+    def run_in_session(self, coro):
+        """Run a coroutine in the session loop (session mode only)."""
+        if not self._session_loop:
+            raise RoborockException("Not in session mode")
+        future = asyncio.run_coroutine_threadsafe(coro, self._session_loop)
+        return future.result()
+
+    async def get_device_manager(self) -> DeviceConnectionManager:
+        """Get device manager, creating if needed."""
+        await self.get_devices()
+        if self._device_manager is None:
+            self._device_manager = DeviceConnectionManager(self, self._session_loop)
+        return self._device_manager
+
+    async def refresh_devices(self) -> ConnectionCache:
+        """Refresh device data from server (always fetches fresh data)."""
+        cache_data = self.cache_data()
+        client = RoborockApiClient(cache_data.email)
+        home_data = await client.get_home_data_v3(cache_data.user_data)
+        cache_data.home_data = home_data
+        self.update(cache_data)
+        return cache_data
+
+    async def get_devices(self) -> ConnectionCache:
+        """Get device data (uses cache if available, fetches if needed)."""
+        cache_data = self.cache_data()
+        if not cache_data.home_data:
+            cache_data = await self.refresh_devices()
+        return cache_data
+
+    async def cleanup(self):
+        """Clean up resources (mainly for session mode)."""
+        if self._device_manager:
+            await self._device_manager.close()
+            self._device_manager = None
+
+        # Stop session loop if running
+        if self._session_loop:
+            self._session_loop.call_soon_threadsafe(self._session_loop.stop)
+            if self._session_thread:
+                self._session_thread.join(timeout=5.0)
+            self._session_loop = None
+            self._session_thread = None
+
+    def finish_session(self) -> None:
+        """Finish the session and clean up resources."""
+        if self._session_loop:
+            future = asyncio.run_coroutine_threadsafe(self.cleanup(), self._session_loop)
+            future.result(timeout=5.0)
 
     async def get(self) -> CacheData:
         """Get cached value."""
@@ -101,7 +277,7 @@ def cli(ctx, debug: int):
     help="Password for the Roborock account. If not provided, an email code will be requested.",
 )
 @click.pass_context
-@run_sync()
+@async_command
 async def login(ctx, email, password):
     """Login to Roborock account."""
     context: RoborockContext = ctx.obj
@@ -120,91 +296,67 @@ async def login(ctx, email, password):
         code = click.prompt("A code has been sent to your email, please enter the code", type=str)
         user_data = await client.code_login(code)
         print("Login successful")
-    context.update(LoginData(user_data=user_data, email=email))
+    context.update(ConnectionCache(user_data=user_data, email=email))
 
 
-@click.command()
-@click.pass_context
-@click.option("--duration", default=10, help="Duration to run the MQTT session in seconds")
-@run_sync()
-async def session(ctx, duration: int):
+def _shell_session_finished(ctx):
+    """Callback for when shell session finishes."""
     context: RoborockContext = ctx.obj
-    cache_data = context.cache_data()
-
-    home_data_api = create_home_data_api(cache_data.email, cache_data.user_data)
-
-    # Create device manager
-    device_manager = await create_device_manager(cache_data.user_data, home_data_api, context)
-
-    devices = await device_manager.get_devices()
-    click.echo(f"Discovered devices: {', '.join([device.name for device in devices])}")
-
-    click.echo("MQTT session started. Querying devices...")
-    for device in devices:
-        if not (status_trait := device.traits.get("status")):
-            click.echo(f"Device {device.name} does not have a status trait")
-            continue
-        try:
-            status = await status_trait.get_status()
-        except RoborockException as e:
-            click.echo(f"Failed to get status for {device.name}: {e}")
-        else:
-            click.echo(f"Device {device.name} status: {status.as_dict()}")
-
-    click.echo("Listening for messages.")
-    await asyncio.sleep(duration)
-
-    # Close the device manager (this will close all devices and MQTT session)
-    await device_manager.close()
-
-
-async def _discover(ctx):
-    context: RoborockContext = ctx.obj
-    cache_data = context.cache_data()
-    if not cache_data:
-        raise Exception("You need to login first")
-    client = RoborockApiClient(cache_data.email)
-    home_data = await client.get_home_data_v3(cache_data.user_data)
-    cache_data.home_data = home_data
-    context.update(cache_data)
-    click.echo(f"Discovered devices {', '.join([device.name for device in home_data.get_all_devices()])}")
+    try:
+        context.finish_session()
+    except Exception as e:
+        click.echo(f"Error during cleanup: {e}", err=True)
+    click.echo("Session finished")
 
 
-async def _load_and_discover(ctx) -> RoborockContext:
-    """Discover devices if home data is not available."""
+@click_shell.shell(
+    prompt="roborock> ",
+    on_finished=_shell_session_finished,
+)
+@click.pass_context
+def session(ctx):
+    """Start an interactive session."""
     context: RoborockContext = ctx.obj
-    cache_data = context.cache_data()
-    if not cache_data.home_data:
-        await _discover(ctx)
-        cache_data = context.cache_data()
-    return context
+    # Start session mode with background loop
+    context.start_session_mode()
+    context.run_in_session(context.get_device_manager())
+    click.echo("OK")
 
 
-@click.command()
+@session.command()
 @click.pass_context
-@run_sync()
+@async_command
 async def discover(ctx):
-    await _discover(ctx)
+    """Discover devices."""
+    context: RoborockContext = ctx.obj
+    # Use the explicit refresh method for the discover command
+    cache_data = await context.refresh_devices()
 
+    home_data = cache_data.home_data
+    click.echo(f"Discovered devices {', '.join([device.name for device in home_data.get_all_devices()])}")
 
-@click.command()
+
+@session.command()
 @click.pass_context
-@run_sync()
+@async_command
 async def list_devices(ctx):
-    context: RoborockContext = await _load_and_discover(ctx)
-    cache_data = context.cache_data()
+    context: RoborockContext = ctx.obj
+    cache_data = await context.get_devices()
+
     home_data = cache_data.home_data
-    device_name_id = {device.name: device.duid for device in home_data.devices + home_data.received_devices}
+
+    device_name_id = {device.name: device.duid for device in home_data.get_all_devices()}
     click.echo(json.dumps(device_name_id, indent=4))
 
 
 @click.command()
 @click.option("--device_id", required=True)
 @click.pass_context
-@run_sync()
+@async_command
 async def list_scenes(ctx, device_id):
-    context: RoborockContext = await _load_and_discover(ctx)
-    cache_data = context.cache_data()
+    context: RoborockContext = ctx.obj
+    cache_data = await context.get_devices()
+
     client = RoborockApiClient(cache_data.email)
     scenes = await client.get_scenes(cache_data.user_data, device_id)
     output_list = []
@@ -216,40 +368,34 @@ async def list_scenes(ctx, device_id):
 @click.command()
 @click.option("--scene_id", required=True)
 @click.pass_context
-@run_sync()
+@async_command
 async def execute_scene(ctx, scene_id):
-    context: RoborockContext = await _load_and_discover(ctx)
-    cache_data = context.cache_data()
+    context: RoborockContext = ctx.obj
+    cache_data = await context.get_devices()
+
     client = RoborockApiClient(cache_data.email)
     await client.execute_scene(cache_data.user_data, scene_id)
 
 
-@click.command()
+@session.command()
 @click.option("--device_id", required=True)
 @click.pass_context
-@run_sync()
-async def status(ctx, device_id):
-    context: RoborockContext = await _load_and_discover(ctx)
-    cache_data = context.cache_data()
+@async_command
+async def status(ctx, device_id: str):
+    """Get device status - unified implementation for both modes."""
+    context: RoborockContext = ctx.obj
 
-    home_data = cache_data.home_data
-    devices = home_data.devices + home_data.received_devices
-    device = next(device for device in devices if device.duid == device_id)
-    product_info: dict[str, HomeDataProduct] = {product.id: product for product in home_data.products}
-    device_data = DeviceData(device, product_info[device.product_id].model)
-
-    mqtt_client = RoborockMqttClientV1(cache_data.user_data, device_data)
-    if not (networking := cache_data.network_info.get(device.duid)):
-        networking = await mqtt_client.get_networking()
-        cache_data.network_info[device.duid] = networking
-        context.update(cache_data)
-    else:
-        _LOGGER.debug("Using cached networking info for device %s: %s", device.duid, networking)
+    device_manager = await context.get_device_manager()
+    device = await device_manager.get_device(device_id)
 
-    local_device_data = DeviceData(device, product_info[device.product_id].model, networking.ip)
-    local_client = RoborockLocalClientV1(local_device_data)
-    status = await local_client.get_status()
-    click.echo(json.dumps(status.as_dict(), indent=4))
+    click.echo(f"Getting status for device {device_id}")
+    if not (status_trait := device.traits.get("status")):
+        click.echo(f"Device {device.name} does not have a status trait")
+        return
+
+    status_result = await status_trait.get_status()
+    click.echo(f"Device {device_id} status:")
+    click.echo(dump_json(status_result.as_dict()))
 
 
 @click.command()
@@ -257,13 +403,13 @@ async def status(ctx, device_id):
 @click.option("--cmd", required=True)
 @click.option("--params", required=False)
 @click.pass_context
-@run_sync()
+@async_command
 async def command(ctx, cmd, device_id, params):
-    context: RoborockContext = await _load_and_discover(ctx)
-    cache_data = context.cache_data()
+    context: RoborockContext = ctx.obj
+    cache_data = await context.get_devices()
 
     home_data = cache_data.home_data
-    devices = home_data.devices + home_data.received_devices
+    devices = home_data.get_all_devices()
     device = next(device for device in devices if device.duid == device_id)
     model = next(
         (product.model for product in home_data.products if device is not None and product.id == device.product_id),
@@ -282,7 +428,7 @@ async def command(ctx, cmd, device_id, params):
 @click.option("--device_ip", required=True)
 @click.option("--file", required=False)
 @click.pass_context
-@run_sync()
+@async_command
 async def parser(_, local_key, device_ip, file):
     file_provided = file is not None
     if file_provided:
@@ -328,18 +474,18 @@ async def parser(_, local_key, device_ip, file):
 
 @click.command()
 @click.pass_context
-@run_sync()
+@async_command
 async def get_device_info(ctx: click.Context):
     """
     Connects to devices and prints their feature information in YAML format.
     """
     click.echo("Discovering devices...")
-    context: RoborockContext = await _load_and_discover(ctx)
-    cache_data = context.cache_data()
+    context: RoborockContext = ctx.obj
+    cache_data = await context.get_devices()
 
     home_data = cache_data.home_data
 
-    all_devices = home_data.devices + home_data.received_devices
+    all_devices = home_data.get_all_devices()
     if not all_devices:
         click.echo("No devices found.")
         return

{python_roborock-2.41.0 → python_roborock-2.42.0}/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.41.0 → python_roborock-2.42.0}/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):
@@ -170,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.41.0 → python_roborock-2.42.0}/roborock/protocol.py

@@ -149,6 +149,86 @@ class Utils:
             return unpad(decipher.decrypt(ciphertext), AES.block_size)
         return ciphertext
 
+    @staticmethod
+    def _l01_key(local_key: str, timestamp: int) -> bytes:
+        """Derive key for L01 protocol."""
+        hash_input = Utils.encode_timestamp(timestamp) + Utils.ensure_bytes(local_key) + SALT
+        return hashlib.sha256(hash_input).digest()
+
+    @staticmethod
+    def _l01_iv(timestamp: int, nonce: int, sequence: int) -> bytes:
+        """Derive IV for L01 protocol."""
+        digest_input = sequence.to_bytes(4, "big") + nonce.to_bytes(4, "big") + timestamp.to_bytes(4, "big")
+        digest = hashlib.sha256(digest_input).digest()
+        return digest[:12]
+
+    @staticmethod
+    def _l01_aad(timestamp: int, nonce: int, sequence: int, connect_nonce: int, ack_nonce: int) -> bytes:
+        """Derive AAD for L01 protocol."""
+        return (
+            sequence.to_bytes(4, "big")
+            + connect_nonce.to_bytes(4, "big")
+            + ack_nonce.to_bytes(4, "big")
+            + nonce.to_bytes(4, "big")
+            + timestamp.to_bytes(4, "big")
+        )
+
+    @staticmethod
+    def encrypt_gcm_l01(
+        plaintext: bytes,
+        local_key: str,
+        timestamp: int,
+        sequence: int,
+        nonce: int,
+        connect_nonce: int,
+        ack_nonce: int,
+    ) -> bytes:
+        """Encrypt plaintext for L01 protocol using AES-256-GCM."""
+        if not isinstance(plaintext, bytes):
+            raise TypeError("plaintext requires bytes")
+
+        key = Utils._l01_key(local_key, timestamp)
+        iv = Utils._l01_iv(timestamp, nonce, sequence)
+        aad = Utils._l01_aad(timestamp, nonce, sequence, connect_nonce, ack_nonce)
+
+        cipher = AES.new(key, AES.MODE_GCM, nonce=iv)
+        cipher.update(aad)
+        ciphertext, tag = cipher.encrypt_and_digest(plaintext)
+
+        return ciphertext + tag
+
+    @staticmethod
+    def decrypt_gcm_l01(
+        payload: bytes,
+        local_key: str,
+        timestamp: int,
+        sequence: int,
+        nonce: int,
+        connect_nonce: int,
+        ack_nonce: int,
+    ) -> bytes:
+        """Decrypt payload for L01 protocol using AES-256-GCM."""
+        if not isinstance(payload, bytes):
+            raise TypeError("payload requires bytes")
+
+        key = Utils._l01_key(local_key, timestamp)
+        iv = Utils._l01_iv(timestamp, nonce, sequence)
+        aad = Utils._l01_aad(timestamp, nonce, sequence, connect_nonce, ack_nonce)
+
+        if len(payload) < 16:
+            raise ValueError("Invalid payload length for GCM decryption")
+
+        tag = payload[-16:]
+        ciphertext = payload[:-16]
+
+        cipher = AES.new(key, AES.MODE_GCM, nonce=iv)
+        cipher.update(aad)
+
+        try:
+            return cipher.decrypt_and_verify(ciphertext, tag)
+        except ValueError as e:
+            raise RoborockException("GCM tag verification failed") from e
+
     @staticmethod
     def crc(data: bytes) -> int:
         """Gather bytes for checksum calculation."""

{python_roborock-2.41.0 → python_roborock-2.42.0}/roborock/util.py

@@ -2,9 +2,8 @@ from __future__ import annotations
 
 import asyncio
 import datetime
-import functools
 import logging
-from asyncio import AbstractEventLoop, TimerHandle
+from asyncio import TimerHandle
 from collections.abc import Callable, Coroutine, MutableMapping
 from typing import Any, TypeVar
 
@@ -18,15 +17,6 @@ def unpack_list(value: list[T], size: int) -> list[T | None]:
     return (value + [None] * size)[:size]  # type: ignore
 
 
-def get_running_loop_or_create_one() -> AbstractEventLoop:
-    try:
-        loop = asyncio.get_event_loop()
-    except RuntimeError:
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-    return loop
-
-
 def parse_datetime_to_roborock_datetime(
     start_datetime: datetime.datetime, end_datetime: datetime.datetime
 ) -> tuple[datetime.datetime, datetime.datetime]:
@@ -60,19 +50,6 @@ def parse_time_to_datetime(
     return parse_datetime_to_roborock_datetime(start_datetime, end_datetime)
 
 
-def run_sync():
-    loop = get_running_loop_or_create_one()
-
-    def decorator(func):
-        @functools.wraps(func)
-        def wrapped(*args, **kwargs):
-            return loop.run_until_complete(func(*args, **kwargs))
-
-        return wrapped
-
-    return decorator
-
-
 class RepeatableTask:
     def __init__(self, callback: Callable[[], Coroutine], interval: int):
         self.callback = callback