python-roborock 2.32.0__tar.gz → 2.34.0__tar.gz

{python_roborock-2.32.0 → python_roborock-2.34.0}/PKG-INFO

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

{python_roborock-2.32.0 → python_roborock-2.34.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-roborock"
-version = "2.32.0"
+version = "2.34.0"
 description = "A package to control Roborock vacuums."
 authors = ["humbertogontijo <humbertogontijo@users.noreply.github.com>"]
 license = "GPL-3.0-only"
@@ -39,7 +39,7 @@ requires = ["poetry-core==1.8.0"]
 build-backend = "poetry.core.masonry.api"
 
 [tool.poetry.group.dev.dependencies]
-pytest-asyncio = "*"
+pytest-asyncio = ">=1.1.0"
 pytest = "*"
 pre-commit = ">=3.5,<5.0"
 mypy = "*"

{python_roborock-2.32.0 → python_roborock-2.34.0}/roborock/cli.py

@@ -12,6 +12,7 @@ from pyshark.packet.packet import Packet  # type: ignore
 
 from roborock import RoborockException
 from roborock.containers import DeviceData, HomeData, HomeDataProduct, LoginData, 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.protocol import MessageParser
 from roborock.util import run_sync
@@ -39,7 +40,7 @@ class ConnectionCache(RoborockBase):
     network_info: dict[str, NetworkInfo] | None = None
 
 
-class RoborockContext:
+class RoborockContext(Cache):
     roborock_file = Path("~/.roborock").expanduser()
     _cache_data: ConnectionCache | None = None
 
@@ -68,6 +69,18 @@ class RoborockContext:
         self.validate()
         return self._cache_data
 
+    async def get(self) -> CacheData:
+        """Get cached value."""
+        connection_cache = self.cache_data()
+        return CacheData(home_data=connection_cache.home_data, network_info=connection_cache.network_info or {})
+
+    async def set(self, value: CacheData) -> None:
+        """Set value in the cache."""
+        connection_cache = self.cache_data()
+        connection_cache.home_data = value.home_data
+        connection_cache.network_info = value.network_info
+        self.update(connection_cache)
+
 
 @click.option("-d", "--debug", default=False, count=True)
 @click.version_option(package_name="python-roborock")
@@ -119,14 +132,8 @@ async def session(ctx, duration: int):
 
     home_data_api = create_home_data_api(cache_data.email, cache_data.user_data)
 
-    async def home_data_cache() -> HomeData:
-        if cache_data.home_data is None:
-            cache_data.home_data = await home_data_api()
-            context.update(cache_data)
-        return cache_data.home_data
-
     # Create device manager
-    device_manager = await create_device_manager(cache_data.user_data, home_data_cache)
+    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])}")
@@ -156,7 +163,7 @@ async def _discover(ctx):
     if not cache_data:
         raise Exception("You need to login first")
     client = RoborockApiClient(cache_data.email)
-    home_data = await client.get_home_data(cache_data.user_data)
+    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()])}")

{python_roborock-2.32.0 → python_roborock-2.34.0}/roborock/devices/__init__.py

@@ -3,4 +3,5 @@
 __all__ = [
     "device",
     "device_manager",
+    "cache",
 ]

python_roborock-2.34.0/roborock/devices/b01_channel.py

@@ -0,0 +1,30 @@
+"""Thin wrapper around the MQTT channel for Roborock B01 devices."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from roborock.protocols.b01_protocol import (
+    CommandType,
+    ParamsType,
+    decode_rpc_response,
+    encode_mqtt_payload,
+)
+
+from .mqtt_channel import MqttChannel
+
+_LOGGER = logging.getLogger(__name__)
+
+
+async def send_decoded_command(
+    mqtt_channel: MqttChannel,
+    dps: int,
+    command: CommandType,
+    params: ParamsType,
+) -> dict[int, Any]:
+    """Send a command on the MQTT channel and get a decoded response."""
+    _LOGGER.debug("Sending MQTT command: %s", params)
+    roborock_message = encode_mqtt_payload(dps, command, params)
+    response = await mqtt_channel.send_message(roborock_message)
+    return decode_rpc_response(response)  # type: ignore[return-value]

python_roborock-2.34.0/roborock/devices/cache.py

@@ -0,0 +1,57 @@
+"""This module provides caching functionality for the Roborock device management system.
+
+This module defines a cache interface that you may use to cache device
+information to avoid unnecessary API calls. Callers may implement
+this interface to provide their own caching mechanism.
+"""
+
+from dataclasses import dataclass, field
+from typing import Protocol
+
+from roborock.containers import HomeData, NetworkInfo
+
+
+@dataclass
+class CacheData:
+    """Data structure for caching device information."""
+
+    home_data: HomeData | None = None
+    """Home data containing device and product information."""
+
+    network_info: dict[str, NetworkInfo] = field(default_factory=dict)
+    """Network information indexed by device DUID."""
+
+
+class Cache(Protocol):
+    """Protocol for a cache that can store and retrieve values."""
+
+    async def get(self) -> CacheData:
+        """Get cached value."""
+        ...
+
+    async def set(self, value: CacheData) -> None:
+        """Set value in the cache."""
+        ...
+
+
+class InMemoryCache(Cache):
+    """In-memory cache implementation."""
+
+    def __init__(self):
+        self._data = CacheData()
+
+    async def get(self) -> CacheData:
+        return self._data
+
+    async def set(self, value: CacheData) -> None:
+        self._data = value
+
+
+class NoCache(Cache):
+    """No-op cache implementation."""
+
+    async def get(self) -> CacheData:
+        return CacheData()
+
+    async def set(self, value: CacheData) -> None:
+        pass

{python_roborock-2.32.0 → python_roborock-2.34.0}/roborock/devices/device_manager.py

@@ -18,8 +18,10 @@ from roborock.mqtt.session import MqttSession
 from roborock.protocol import create_mqtt_params
 from roborock.web_api import RoborockApiClient
 
+from .cache import Cache, NoCache
 from .channel import Channel
 from .mqtt_channel import create_mqtt_channel
+from .traits.b01.props import B01PropsApi
 from .traits.dyad import DyadApi
 from .traits.status import StatusTrait
 from .traits.trait import Trait
@@ -32,8 +34,6 @@ __all__ = [
     "create_device_manager",
     "create_home_data_api",
     "DeviceManager",
-    "HomeDataApi",
-    "DeviceCreator",
 ]
 
 
@@ -46,6 +46,7 @@ class DeviceVersion(enum.StrEnum):
 
     V1 = "1.0"
     A01 = "A01"
+    B01 = "B01"
     UNKNOWN = "unknown"
 
 
@@ -57,19 +58,27 @@ class DeviceManager:
         home_data_api: HomeDataApi,
         device_creator: DeviceCreator,
         mqtt_session: MqttSession,
+        cache: Cache,
     ) -> None:
         """Initialize the DeviceManager with user data and optional cache storage.
 
         This takes ownership of the MQTT session and will close it when the manager is closed.
         """
         self._home_data_api = home_data_api
+        self._cache = cache
         self._device_creator = device_creator
         self._devices: dict[str, RoborockDevice] = {}
         self._mqtt_session = mqtt_session
 
     async def discover_devices(self) -> list[RoborockDevice]:
         """Discover all devices for the logged-in user."""
-        home_data = await self._home_data_api()
+        cache_data = await self._cache.get()
+        if not cache_data.home_data:
+            _LOGGER.debug("No cached home data found, fetching from API")
+            cache_data.home_data = await self._home_data_api()
+            await self._cache.set(cache_data)
+        home_data = cache_data.home_data
+
         device_products = home_data.device_products
         _LOGGER.debug("Discovered %d devices %s", len(device_products), home_data)
 
@@ -113,18 +122,24 @@ def create_home_data_api(email: str, user_data: UserData) -> HomeDataApi:
     client = RoborockApiClient(email)
 
     async def home_data_api() -> HomeData:
-        return await client.get_home_data(user_data)
+        return await client.get_home_data_v3(user_data)
 
     return home_data_api
 
 
-async def create_device_manager(user_data: UserData, home_data_api: HomeDataApi) -> DeviceManager:
+async def create_device_manager(
+    user_data: UserData,
+    home_data_api: HomeDataApi,
+    cache: Cache | None = None,
+) -> DeviceManager:
     """Convenience function to create and initialize a DeviceManager.
 
     The Home Data is fetched using the provided home_data_api callable which
     is exposed this way to allow for swapping out other implementations to
     include caching or other optimizations.
     """
+    if cache is None:
+        cache = NoCache()
 
     mqtt_params = create_mqtt_params(user_data.rriot)
     mqtt_session = await create_mqtt_session(mqtt_params)
@@ -135,7 +150,7 @@ async def create_device_manager(user_data: UserData, home_data_api: HomeDataApi)
         # TODO: Define a registration mechanism/factory for v1 traits
         match device.pv:
             case DeviceVersion.V1:
-                channel = create_v1_channel(user_data, mqtt_params, mqtt_session, device)
+                channel = create_v1_channel(user_data, mqtt_params, mqtt_session, device, cache)
                 traits.append(StatusTrait(product, channel.rpc_channel))
             case DeviceVersion.A01:
                 mqtt_channel = create_mqtt_channel(user_data, mqtt_params, mqtt_session, device)
@@ -146,10 +161,13 @@ async def create_device_manager(user_data: UserData, home_data_api: HomeDataApi)
                         traits.append(ZeoApi(mqtt_channel))
                     case _:
                         raise NotImplementedError(f"Device {device.name} has unsupported category {product.category}")
+            case DeviceVersion.B01:
+                mqtt_channel = create_mqtt_channel(user_data, mqtt_params, mqtt_session, device)
+                traits.append(B01PropsApi(mqtt_channel))
             case _:
                 raise NotImplementedError(f"Device {device.name} has unsupported version {device.pv}")
         return RoborockDevice(device, channel, traits)
 
-    manager = DeviceManager(home_data_api, device_creator, mqtt_session=mqtt_session)
+    manager = DeviceManager(home_data_api, device_creator, mqtt_session=mqtt_session, cache=cache)
     await manager.discover_devices()
     return manager

python_roborock-2.34.0/roborock/devices/traits/b01/props.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from roborock import RoborockB01Methods
+from roborock.roborock_message import RoborockB01Props
+
+from ...b01_channel import send_decoded_command
+from ...mqtt_channel import MqttChannel
+from ..trait import Trait
+
+_LOGGER = logging.getLogger(__name__)
+
+__all__ = [
+    "B01PropsApi",
+]
+
+
+class B01PropsApi(Trait):
+    """API for interacting with B01 devices."""
+
+    name = "B01_props"
+
+    def __init__(self, channel: MqttChannel) -> None:
+        """Initialize the B01Props API."""
+        self._channel = channel
+
+    async def query_values(self, props: list[RoborockB01Props]) -> dict[int, Any]:
+        """Query the device for the values of the given Dyad protocols."""
+        return await send_decoded_command(self._channel, dps=10000, command=RoborockB01Methods.GET_PROP, params=props)

{python_roborock-2.32.0 → python_roborock-2.34.0}/roborock/devices/v1_channel.py

@@ -18,6 +18,7 @@ from roborock.protocols.v1_protocol import (
 from roborock.roborock_message import RoborockMessage
 from roborock.roborock_typing import RoborockCommand
 
+from .cache import Cache
 from .channel import Channel
 from .local_channel import LocalChannel, LocalSession, create_local_session
 from .mqtt_channel import MqttChannel
@@ -46,6 +47,7 @@ class V1Channel(Channel):
         security_data: SecurityData,
         mqtt_channel: MqttChannel,
         local_session: LocalSession,
+        cache: Cache,
     ) -> None:
         """Initialize the V1Channel.
 
@@ -62,7 +64,7 @@ class V1Channel(Channel):
         self._mqtt_unsub: Callable[[], None] | None = None
         self._local_unsub: Callable[[], None] | None = None
         self._callback: Callable[[RoborockMessage], None] | None = None
-        self._networking_info: NetworkInfo | None = None
+        self._cache = cache
 
     @property
     def is_connected(self) -> bool:
@@ -131,19 +133,26 @@ class V1Channel(Channel):
 
         This is a cloud only command used to get the local device's IP address.
         """
+        cache_data = await self._cache.get()
+        if cache_data.network_info and (network_info := cache_data.network_info.get(self._device_uid)):
+            _LOGGER.debug("Using cached network info for device %s", self._device_uid)
+            return network_info
         try:
-            return await self._mqtt_rpc_channel.send_command(
+            network_info = await self._mqtt_rpc_channel.send_command(
                 RoborockCommand.GET_NETWORK_INFO, response_type=NetworkInfo
             )
         except RoborockException as e:
             raise RoborockException(f"Network info failed for device {self._device_uid}") from e
+        _LOGGER.debug("Network info for device %s: %s", self._device_uid, network_info)
+        cache_data.network_info[self._device_uid] = network_info
+        await self._cache.set(cache_data)
+        return network_info
 
     async def _local_connect(self) -> Callable[[], None]:
         """Set up local connection if possible."""
         _LOGGER.debug("Attempting to connect to local channel for device %s", self._device_uid)
-        if self._networking_info is None:
-            self._networking_info = await self._get_networking_info()
-        host = self._networking_info.ip
+        networking_info = await self._get_networking_info()
+        host = networking_info.ip
         _LOGGER.debug("Connecting to local channel at %s", host)
         self._local_channel = self._local_session(host)
         try:
@@ -168,10 +177,14 @@ class V1Channel(Channel):
 
 
 def create_v1_channel(
-    user_data: UserData, mqtt_params: MqttParams, mqtt_session: MqttSession, device: HomeDataDevice
+    user_data: UserData,
+    mqtt_params: MqttParams,
+    mqtt_session: MqttSession,
+    device: HomeDataDevice,
+    cache: Cache,
 ) -> V1Channel:
     """Create a V1Channel for the given device."""
     security_data = create_security_data(user_data.rriot)
     mqtt_channel = MqttChannel(mqtt_session, device.duid, device.local_key, user_data.rriot, mqtt_params)
     local_session = create_local_session(device.local_key)
-    return V1Channel(device.duid, security_data, mqtt_channel, local_session=local_session)
+    return V1Channel(device.duid, security_data, mqtt_channel, local_session=local_session, cache=cache)

{python_roborock-2.32.0 → python_roborock-2.34.0}/roborock/mqtt/roborock_session.py

@@ -49,6 +49,7 @@ class RoborockMqttSession(MqttSession):
         self._params = params
         self._background_task: asyncio.Task[None] | None = None
         self._healthy = False
+        self._stop = False
         self._backoff = MIN_BACKOFF_INTERVAL
         self._client: aiomqtt.Client | None = None
         self._client_lock = asyncio.Lock()
@@ -81,6 +82,7 @@ class RoborockMqttSession(MqttSession):
 
     async def close(self) -> None:
         """Cancels the MQTT loop and shutdown the client library."""
+        self._stop = True
         if self._background_task:
             self._background_task.cancel()
             try:
@@ -125,16 +127,19 @@ class RoborockMqttSession(MqttSession):
             except Exception as err:
                 # This error is thrown when the MQTT loop is cancelled
                 # and the generator is not stopped.
-                if "generator didn't stop" in str(err):
+                if "generator didn't stop" in str(err) or "generator didn't yield" in str(err):
                     _LOGGER.debug("MQTT loop was cancelled")
                     return
                 if start_future:
                     _LOGGER.error("Uncaught error starting MQTT session: %s", err)
                     start_future.set_exception(err)
                     return
-                _LOGGER.error("Uncaught error during MQTT session: %s", err)
+                _LOGGER.exception("Uncaught error during MQTT session: %s", err)
 
             self._healthy = False
+            if self._stop:
+                _LOGGER.debug("MQTT session closed, stopping retry loop")
+                return
             _LOGGER.info("MQTT session disconnected, retrying in %s seconds", self._backoff.total_seconds())
             await asyncio.sleep(self._backoff.total_seconds())
             self._backoff = min(self._backoff * BACKOFF_MULTIPLIER, MAX_BACKOFF_INTERVAL)
@@ -180,7 +185,7 @@ class RoborockMqttSession(MqttSession):
                 except asyncio.CancelledError:
                     raise
                 except Exception as e:
-                    _LOGGER.error("Uncaught exception in subscriber callback: %s", e)
+                    _LOGGER.exception("Uncaught exception in subscriber callback: %s", e)
 
     async def subscribe(self, topic: str, callback: Callable[[bytes], None]) -> Callable[[], None]:
         """Subscribe to messages on the specified topic and invoke the callback for new messages.

{python_roborock-2.32.0 → python_roborock-2.34.0}/roborock/protocol.py

@@ -39,6 +39,7 @@ from roborock.roborock_message import RoborockMessage
 _LOGGER = logging.getLogger(__name__)
 SALT = b"TXdfu$jyZ#TZHsg4"
 A01_HASH = "726f626f726f636b2d67a6d6da"
+B01_HASH = "5wwh9ikChRjASpMU8cxg7o1d2E"
 BROADCAST_TOKEN = b"qWKYcdQWrbm9hPqe"
 AP_CONFIG = 1
 SOCK_DISCOVERY = 2
@@ -213,6 +214,10 @@ class EncryptionAdapter(Construct):
             decipher = AES.new(bytes(context.search("local_key"), "utf-8"), AES.MODE_CBC, bytes(iv, "utf-8"))
             f = decipher.encrypt(obj)
             return f
+        elif context.version == b"B01":
+            iv = md5hex(f"{context.random:08x}" + B01_HASH)[9:25]
+            decipher = AES.new(bytes(context.search("local_key"), "utf-8"), AES.MODE_CBC, bytes(iv, "utf-8"))
+            return decipher.encrypt(obj)
         token = self.token_func(context)
         encrypted = Utils.encrypt_ecb(obj, token)
         return encrypted
@@ -224,6 +229,10 @@ class EncryptionAdapter(Construct):
             decipher = AES.new(bytes(context.search("local_key"), "utf-8"), AES.MODE_CBC, bytes(iv, "utf-8"))
             f = decipher.decrypt(obj)
             return f
+        elif context.version == b"B01":
+            iv = md5hex(f"{context.random:08x}" + B01_HASH)[9:25]
+            decipher = AES.new(bytes(context.search("local_key"), "utf-8"), AES.MODE_CBC, bytes(iv, "utf-8"))
+            return decipher.decrypt(obj)
         token = self.token_func(context)
         decrypted = Utils.decrypt_ecb(obj, token)
         return decrypted
@@ -248,7 +257,7 @@ class PrefixedStruct(Struct):
     def _parse(self, stream, context, path):
         subcon1 = Peek(Optional(Bytes(3)))
         peek_version = subcon1.parse_stream(stream, **context)
-        if peek_version not in (b"1.0", b"A01"):
+        if peek_version not in (b"1.0", b"A01", b"B01"):
             subcon2 = Bytes(4)
             subcon2.parse_stream(stream, **context)
         return super()._parse(stream, context, path)

python_roborock-2.34.0/roborock/protocols/b01_protocol.py

@@ -0,0 +1,55 @@
+"""Roborock B01 Protocol encoding and decoding."""
+
+import json
+import logging
+from typing import Any
+
+from Crypto.Cipher import AES
+from Crypto.Util.Padding import pad, unpad
+
+from roborock import RoborockB01Methods
+from roborock.exceptions import RoborockException
+from roborock.roborock_message import (
+    RoborockMessage,
+    RoborockMessageProtocol,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+B01_VERSION = b"B01"
+CommandType = RoborockB01Methods | str
+ParamsType = list | dict | int | None
+
+
+def encode_mqtt_payload(dps: int, command: CommandType, params: ParamsType) -> RoborockMessage:
+    """Encode payload for B01 commands over MQTT."""
+    dps_data = {"dps": {dps: {"method": command, "params": params or []}}}
+    payload = pad(json.dumps(dps_data).encode("utf-8"), AES.block_size)
+    return RoborockMessage(
+        protocol=RoborockMessageProtocol.RPC_REQUEST,
+        version=B01_VERSION,
+        payload=payload,
+    )
+
+
+def decode_rpc_response(message: RoborockMessage) -> dict[int, Any]:
+    """Decode a B01 RPC_RESPONSE message."""
+    if not message.payload:
+        raise RoborockException("Invalid B01 message format: missing payload")
+    try:
+        unpadded = unpad(message.payload, AES.block_size)
+    except ValueError as err:
+        raise RoborockException(f"Unable to unpad B01 payload: {err}")
+
+    try:
+        payload = json.loads(unpadded.decode())
+    except (json.JSONDecodeError, TypeError) as e:
+        raise RoborockException(f"Invalid B01 message payload: {e} for {message.payload!r}") from e
+
+    datapoints = payload.get("dps", {})
+    if not isinstance(datapoints, dict):
+        raise RoborockException(f"Invalid B01 message format: 'dps' should be a dictionary for {message.payload!r}")
+    try:
+        return {int(key): value for key, value in datapoints.items()}
+    except ValueError:
+        raise RoborockException(f"Invalid B01 message format: 'dps' key should be an integer for {message.payload!r}")

{python_roborock-2.32.0 → python_roborock-2.34.0}/roborock/roborock_message.py

@@ -4,6 +4,7 @@ import json
 import math
 import time
 from dataclasses import dataclass, field
+from enum import StrEnum
 
 from roborock import RoborockEnum
 from roborock.util import get_next_int
@@ -130,6 +131,98 @@ class RoborockZeoProtocol(RoborockEnum):
     RPC_RESp = 10102
 
 
+class RoborockB01Protocol(RoborockEnum):
+    RPC_REQUEST = 101
+    RPC_RESPONSE = 102
+    ERROR_CODE = 120
+    STATE = 121
+    BATTERY = 122
+    FAN_POWER = 123
+    WATER_BOX_MODE = 124
+    MAIN_BRUSH_LIFE = 125
+    SIDE_BRUSH_LIFE = 126
+    FILTER_LIFE = 127
+    OFFLINE_STATUS = 135
+    CLEAN_TIMES = 136
+    CLEANING_PREFERENCE = 137
+    CLEAN_TASK_TYPE = 138
+    BACK_TYPE = 139
+    DOCK_TASK_TYPE = 140
+    CLEANING_PROGRESS = 141
+    FC_STATE = 142
+    START_CLEAN_TASK = 201
+    START_BACK_DOCK_TASK = 202
+    START_DOCK_TASK = 203
+    PAUSE = 204
+    RESUME = 205
+    STOP = 206
+    CEIP = 207
+
+
+class RoborockB01Props(StrEnum):
+    """Properties requested by the Roborock B01 model."""
+
+    STATUS = "status"
+    FAULT = "fault"
+    WIND = "wind"
+    WATER = "water"
+    MODE = "mode"
+    QUANTITY = "quantity"
+    ALARM = "alarm"
+    VOLUME = "volume"
+    HYPA = "hypa"
+    MAIN_BRUSH = "main_brush"
+    SIDE_BRUSH = "side_brush"
+    MOP_LIFE = "mop_life"
+    MAIN_SENSOR = "main_sensor"
+    NET_STATUS = "net_status"
+    REPEAT_STATE = "repeat_state"
+    TANK_STATE = "tank_state"
+    SWEEP_TYPE = "sweep_type"
+    CLEAN_PATH_PREFERENCE = "clean_path_preference"
+    CLOTH_STATE = "cloth_state"
+    TIME_ZONE = "time_zone"
+    TIME_ZONE_INFO = "time_zone_info"
+    LANGUAGE = "language"
+    CLEANING_TIME = "cleaning_time"
+    REAL_CLEAN_TIME = "real_clean_time"
+    CLEANING_AREA = "cleaning_area"
+    CUSTOM_TYPE = "custom_type"
+    SOUND = "sound"
+    WORK_MODE = "work_mode"
+    STATION_ACT = "station_act"
+    CHARGE_STATE = "charge_state"
+    CURRENT_MAP_ID = "current_map_id"
+    MAP_NUM = "map_num"
+    DUST_ACTION = "dust_action"
+    QUIET_IS_OPEN = "quiet_is_open"
+    QUIET_BEGIN_TIME = "quiet_begin_time"
+    QUIET_END_TIME = "quiet_end_time"
+    CLEAN_FINISH = "clean_finish"
+    VOICE_TYPE = "voice_type"
+    VOICE_TYPE_VERSION = "voice_type_version"
+    ORDER_TOTAL = "order_total"
+    BUILD_MAP = "build_map"
+    PRIVACY = "privacy"
+    DUST_AUTO_STATE = "dust_auto_state"
+    DUST_FREQUENCY = "dust_frequency"
+    CHILD_LOCK = "child_lock"
+    MULTI_FLOOR = "multi_floor"
+    MAP_SAVE = "map_save"
+    LIGHT_MODE = "light_mode"
+    GREEN_LASER = "green_laser"
+    DUST_BAG_USED = "dust_bag_used"
+    ORDER_SAVE_MODE = "order_save_mode"
+    MANUFACTURER = "manufacturer"
+    BACK_TO_WASH = "back_to_wash"
+    CHARGE_STATION_TYPE = "charge_station_type"
+    PV_CUT_CHARGE = "pv_cut_charge"
+    PV_CHARGING = "pv_charging"
+    SERIAL_NUMBER = "serial_number"
+    RECOMMEND = "recommend"
+    ADD_SWEEP_STATUS = "add_sweep_status"
+
+
 ROBOROCK_DATA_STATUS_PROTOCOL = [
     RoborockDataProtocol.ERROR_CODE,
     RoborockDataProtocol.STATE,

{python_roborock-2.32.0 → python_roborock-2.34.0}/roborock/roborock_typing.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from enum import Enum
+from enum import Enum, StrEnum
 
 from .containers import (
     CleanRecord,
@@ -271,6 +271,20 @@ class RoborockCommand(str, Enum):
     APP_GET_ROBOT_SETTING = "app_get_robot_setting"
 
 
+class RoborockB01Methods(StrEnum):
+    """Methods used by the Roborock B01 model."""
+
+    GET_PROP = "prop.get"
+    GET_MAP_LIST = "service.get_map_list"
+    UPLOAD_BY_MAPTYPE = "service.upload_by_maptype"
+    SET_PROP = "prop.set"
+    GET_PREFERENCE = "service.get_preference"
+    GET_RECORD_LIST = "service.get_record_list"
+    GET_ORDER = "service.get_order"
+    EVENT_ORDER_LIST_POST = "event.order_list.post"
+    POST_PROP = "prop.post"
+
+
 @dataclass
 class DockSummary(RoborockBase):
     dust_collection_mode: DustCollectionMode | None = None