python-roborock 5.25.0__tar.gz → 5.26.0__tar.gz

{python_roborock-5.25.0 → python_roborock-5.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-roborock
-Version: 5.25.0
+Version: 5.26.0
 Summary: A package to control Roborock vacuums.
 Project-URL: Repository, https://github.com/python-roborock/python-roborock
 Project-URL: Documentation, https://python-roborock.readthedocs.io/

{python_roborock-5.25.0 → python_roborock-5.26.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-roborock"
-version = "5.25.0"
+version = "5.26.0"
 description = "A package to control Roborock vacuums."
 authors = [{ name = "humbertogontijo", email = "humbertogontijo@users.noreply.github.com" }, {name="Lash-L"}, {name="allenporter"}]
 requires-python = ">=3.11, <4"

{python_roborock-5.25.0 → python_roborock-5.26.0}/roborock/data/b01_q10/b01_q10_code_mappings.py

@@ -289,6 +289,70 @@ class YXCarpetCleanType(RoborockModeEnum):
     CROSS = "cross", 3
 
 
+class YXFault(RoborockModeEnum):
+    """Q10 (B01/ss07) ``dpFault`` (90) codes, from the ss07 fault spec.
+
+    ``dpFault`` is *overloaded*: several values are lifecycle/status rather than
+    errors (e.g. 400 = scheduled clean starting, 501 = returning to dock,
+    502 = recharge). A non-zero fault is not necessarily a blocking error.
+    The converse also holds: the device can sit in its error state (``dpStatus``
+    12) with ``dpFault`` still 0 (observed live with the dust-bin module
+    removed), so a ``None``/``NONE`` fault does not imply the absence of an
+    error condition.
+
+    These labels differ from the Q7 ``B01Fault`` for several shared numbers
+    (500, 501, 503, 569, 570) -- so this is a Q10-specific map, not a reuse of
+    ``B01Fault``. Codes marked "hw-confirmed" were observed firing live on a
+    physical ss07 in a context matching the label; the rest are from the spec
+    only, not yet observed live (single device).
+    """
+
+    UNKNOWN = "unknown", -1
+    NONE = "none", 0
+    LIDAR_BLOCKED = "lidar_blocked", 1
+    BUMPER_STUCK = "bumper_stuck", 2  # hw-confirmed (bumper held in during commanded motion)
+    ROBOT_SUSPENDED = "robot_suspended", 3  # hw-confirmed (wheels lifted off the floor mid-task)
+    CLIFF_SENSOR_ERROR = "cliff_sensor_error", 4  # hw-confirmed (one side lifted mid-task)
+    MAIN_BRUSH_STUCK = "main_brush_stuck", 5  # hw-confirmed (two physical brush jams)
+    MAIN_WHEELS_STUCK = "main_wheels_stuck", 7
+    ROBOT_TRAPPED = "robot_trapped", 8  # hw-confirmed
+    CHECK_DUSTBIN_FILTER = "check_dustbin_filter", 9
+    LOW_BATTERY = "low_battery", 12  # hw-confirmed (fired at 14% mid clean)
+    TEMPERATURE_THRESHOLD = "temperature_threshold", 14
+    ROBOT_TILTED = "robot_tilted", 16
+    LIDAR_COVER_OBSTRUCTED = "lidar_cover_obstructed", 21
+    NO_GO_ZONE_DETECTED = "no_go_zone_detected", 24
+    MOPPING_MODULE_STUCK = "mopping_module_stuck", 27
+    CARPET_AVOIDANCE = "carpet_avoidance", 28
+    CANNOT_CROSS_CARPET = "cannot_cross_carpet", 29
+    INSTALL_DUST_BAG = "install_dust_bag", 46  # hw-confirmed (docked with bag removed; fires at dock contact)
+    MOP_MOUNT_FELL_OFF = "mop_mount_fell_off", 54
+    LIDAR_DIRTY = "lidar_dirty", 58
+    FILTER_SERVICE_LIFE = "filter_service_life", 301
+    MAIN_BRUSH_SERVICE_LIFE = "main_brush_service_life", 302
+    SIDE_BRUSH_SERVICE_LIFE = "side_brush_service_life", 303
+    SENSOR_NEEDS_CLEANING = "sensor_needs_cleaning", 304  # hw-confirmed (fired during auto-empty)
+    DUST_BAG_FULL = "dust_bag_full", 310  # inferred from auto-empty context; not hw-confirmed
+    STARTING_SCHEDULED_CLEAN = "starting_scheduled_clean", 400  # hw-confirmed x3; lifecycle, not an error
+    # hw-confirmed (a due scheduled clean fired mid-clean and was ignored); lifecycle, not an error
+    CLEANING_IN_PROGRESS = "cleaning_in_progress", 407
+    EMPTY_DUSTBIN = "empty_dustbin", 500  # ss07 != Q7 B01Fault (lidar_blocked); spec-only
+    # hw-confirmed, fires per completed task; ss07 != Q7 (robot_suspended)
+    CLEANING_COMPLETED_RETURNING = "cleaning_completed_returning", 501
+    LOW_BATTERY_RESUME = "low_battery_resume", 502  # hw-confirmed; lifecycle
+    DOCKING_ERROR = "docking_error", 503  # hw-confirmed; ss07 != Q7 (dustbin_not_installed)
+    POSITIONING_FAILED = "positioning_failed", 556  # hw-confirmed; relocalization
+    # hw-confirmed (3rd auto-empty in ~15 min: dock refuses to run the cycle); ss07 != Q7 (main_wheels_entangled)
+    TOO_FREQUENT_EMPTYING = "too_frequent_emptying", 569
+    CANNOT_REACH_TARGET = "cannot_reach_target", 570  # hw-confirmed; ss07 != Q7 (main_brush_entangled)
+    OFFLINE_WARNING_ASLEEP = "offline_warning_asleep", 588
+    OFFLINE_WARNING_LOW_BATTERY = "offline_warning_low_battery", 589
+    DND_AUTO_TOPUP_DISABLED = "dnd_auto_topup_disabled", 591
+    CLEAN_CARPET_ULTRASONIC_SENSORS = "clean_carpet_ultrasonic_sensors", 707
+    ROBOT_ERROR_RESET = "robot_error_reset", 1002
+    VOICE_PACK_UPDATE_AVAILABLE = "voice_pack_update_available", 3001
+
+
 class RemoteCommand(IntEnum):
     FORWARD = 0
     LEFT = 2

{python_roborock-5.25.0 → python_roborock-5.26.0}/roborock/data/b01_q10/b01_q10_containers.py

@@ -23,6 +23,7 @@ from .b01_q10_code_mappings import (
     YXDeviceDustCollectionFrequency,
     YXDeviceState,
     YXFanLevel,
+    YXFault,
     YXStartMethod,
     YXWaterLevel,
 )
@@ -165,7 +166,7 @@ class Q10Status(RoborockBase):
     clean_task_type: YXDeviceCleanTask | None = field(default=None, metadata={"dps": B01_Q10_DP.CLEAN_TASK_TYPE})
     back_type: YXBackType | None = field(default=None, metadata={"dps": B01_Q10_DP.BACK_TYPE})
     cleaning_progress: int | None = field(default=None, metadata={"dps": B01_Q10_DP.CLEAN_PROGRESS})
-    fault: int | None = field(default=None, metadata={"dps": B01_Q10_DP.FAULT})
+    fault: YXFault | None = field(default=None, metadata={"dps": B01_Q10_DP.FAULT})
 
     # Additional state reported in the device's full status dump.
     clean_line: YXCleanLine | None = field(default=None, metadata={"dps": B01_Q10_DP.CLEAN_LINE})
@@ -203,6 +204,11 @@ class Q10Status(RoborockBase):
     filter_life: int | None = field(default=None, metadata={"dps": B01_Q10_DP.FILTER_LIFE})
     sensor_life: int | None = field(default=None, metadata={"dps": B01_Q10_DP.SENSOR_LIFE})
 
+    @property
+    def fault_name(self) -> str | None:
+        """Returns the name of the current fault."""
+        return self.fault.value if self.fault is not None else None
+
 
 @dataclass
 class SoundVolume(RoborockBase):

{python_roborock-5.25.0 → python_roborock-5.26.0}/roborock/devices/device_manager.py

@@ -26,6 +26,8 @@ from roborock.protocol import create_mqtt_params
 from roborock.web_api import RoborockApiClient, UserWebApiClient
 
 from .cache import Cache, DeviceCache, NoCache
+from .rpc.b01_q7_channel import create_b01_q7_channel
+from .rpc.b01_q10_channel import create_b01_q10_channel
 from .rpc.v1_channel import create_v1_channel
 from .traits import Trait, a01, b01, v1
 from .transport.channel import Channel
@@ -254,13 +256,22 @@ async def create_device_manager(
                 channel = create_mqtt_channel(user_data, mqtt_params, mqtt_session, device)
                 trait = a01.create(product, channel)
             case DeviceVersion.B01:
-                channel = create_mqtt_channel(user_data, mqtt_params, mqtt_session, device)
+                mqtt_channel = create_mqtt_channel(user_data, mqtt_params, mqtt_session, device)
                 model_part = product.model.split(".")[-1]
                 if "ss" in model_part:
+                    b01_q10_channel = create_b01_q10_channel(mqtt_channel)
+                    channel = b01_q10_channel
                     trait = b01.q10.create(channel)
                 elif "sc" in model_part:
                     # Q7 devices start with 'sc' in their model naming.
-                    trait = b01.q7.create(product, device, channel)
+                    b01_q7_channel = create_b01_q7_channel(device, product, mqtt_channel)
+                    channel = b01_q7_channel
+                    trait = b01.q7.create(
+                        product,
+                        device,
+                        rpc_channel=b01_q7_channel,
+                        map_rpc_channel=b01_q7_channel,
+                    )
                 else:
                     raise UnsupportedDeviceError(f"Device {device.name} has unsupported B01 model: {product.model}")
             case _:

{python_roborock-5.25.0 → python_roborock-5.26.0}/roborock/devices/rpc/b01_q10_channel.py

@@ -1,9 +1,11 @@
 """Thin wrapper around the MQTT channel for Roborock B01 Q10 devices."""
 
 import logging
-from collections.abc import AsyncGenerator
+from collections.abc import AsyncGenerator, Callable
+from typing import Protocol
 
 from roborock.data.b01_q10.b01_q10_code_mappings import B01_Q10_DP
+from roborock.devices.transport.channel import Channel
 from roborock.devices.transport.mqtt_channel import MqttChannel
 from roborock.exceptions import RoborockException
 from roborock.protocols.b01_q10_protocol import (
@@ -12,10 +14,53 @@ from roborock.protocols.b01_q10_protocol import (
     decode_message,
     encode_mqtt_payload,
 )
+from roborock.roborock_message import RoborockMessage
 
 _LOGGER = logging.getLogger(__name__)
 
 
+class Q10RpcChannel(Protocol):
+    """Protocol for Q10 RPC channels."""
+
+    async def send_command(
+        self,
+        command: B01_Q10_DP,
+        params: ParamsType = None,
+    ) -> None:
+        """Send a command on the MQTT channel, without waiting for a response."""
+        ...
+
+
+class B01Q10Channel(Channel, Q10RpcChannel):
+    """Unified B01 Q10 channel wrapping MQTT transport."""
+
+    def __init__(self, mqtt_channel: MqttChannel) -> None:
+        self._mqtt_channel = mqtt_channel
+
+    @property
+    def is_connected(self) -> bool:
+        return self._mqtt_channel.is_connected
+
+    @property
+    def is_local_connected(self) -> bool:
+        return False
+
+    async def subscribe(self, callback: Callable[[RoborockMessage], None]) -> Callable[[], None]:
+        return await self._mqtt_channel.subscribe(callback)
+
+    async def subscribe_stream(self) -> AsyncGenerator[Q10Message, None]:
+        """Stream decoded Q10 messages received via MQTT."""
+        async for msg in stream_decoded_messages(self._mqtt_channel):
+            yield msg
+
+    async def send_command(
+        self,
+        command: B01_Q10_DP,
+        params: ParamsType = None,
+    ) -> None:
+        await send_command(self._mqtt_channel, command, params)
+
+
 async def stream_decoded_messages(
     mqtt_channel: MqttChannel,
 ) -> AsyncGenerator[Q10Message, None]:
@@ -59,3 +104,8 @@ async def send_command(
             ex,
         )
         raise
+
+
+def create_b01_q10_channel(mqtt_channel: MqttChannel) -> B01Q10Channel:
+    """Create a B01Q10Channel wrapping MQTT transport."""
+    return B01Q10Channel(mqtt_channel)

{python_roborock-5.25.0 → python_roborock-5.26.0}/roborock/devices/rpc/b01_q7_channel.py

@@ -1,19 +1,23 @@
 """Thin wrapper around the MQTT channel for Roborock B01 Q7 devices."""
 
-from __future__ import annotations
-
 import asyncio
 import json
 import logging
 from collections.abc import Callable
-from typing import TypeAlias, TypeVar
+from typing import Protocol, TypeAlias, TypeVar
 
+from roborock.data import HomeDataDevice, HomeDataProduct
+from roborock.devices.transport.channel import Channel
 from roborock.devices.transport.mqtt_channel import MqttChannel
 from roborock.exceptions import RoborockException
 from roborock.protocols.b01_q7_protocol import (
+    B01_Q7_DPS,
     B01_VERSION,
+    CommandType,
     MapKey,
+    ParamsType,
     Q7RequestMessage,
+    create_map_key,
     decode_map_payload,
     decode_rpc_response,
     encode_mqtt_payload,
@@ -26,6 +30,30 @@ _T = TypeVar("_T")
 DecodedB01Response: TypeAlias = dict[str, object] | str
 
 
+class Q7RpcChannel(Protocol):
+    """Protocol for Q7 RPC channels."""
+
+    async def send_command(
+        self,
+        command: CommandType,
+        params: ParamsType = None,
+    ) -> DecodedB01Response:
+        """Send a command and get a decoded response."""
+        ...
+
+
+class Q7MapRpcChannel(Protocol):
+    """Protocol for Q7 map RPC channels."""
+
+    async def send_map_command(
+        self,
+        command: CommandType,
+        params: ParamsType = None,
+    ) -> bytes:
+        """Send a map command and get decoded bytes."""
+        ...
+
+
 def _matches_map_response(response_message: RoborockMessage, *, version: bytes | None) -> bytes | None:
     """Return raw map payload bytes for matching MAP_RESPONSE messages."""
     if (
@@ -120,39 +148,55 @@ async def send_decoded_command(
         raise RoborockException(f"B01 command timed out after {_TIMEOUT}s ({request_message})") from ex
     except RoborockException as ex:
         _LOGGER.warning(
-            "Error sending B01 decoded command (%ss): %s",
+            "Error sending B01 decoded command (%s): %s",
             request_message,
             ex,
         )
         raise
     except Exception as ex:
         _LOGGER.exception(
-            "Error sending B01 decoded command (%ss): %s",
+            "Error sending B01 decoded command (%s): %s",
             request_message,
             ex,
         )
         raise
 
 
-class MapRpcChannel:
-    """RPC channel for map-related commands on B01/Q7 devices."""
+class B01Q7Channel(Channel, Q7RpcChannel, Q7MapRpcChannel):
+    """Unified B01 Q7 channel wrapping MQTT transport."""
 
     def __init__(self, mqtt_channel: MqttChannel, map_key: MapKey) -> None:
         self._mqtt_channel = mqtt_channel
         self._map_key = map_key
 
-    async def send_map_command(self, request_message: Q7RequestMessage) -> bytes:
-        """Send a map upload command and return decoded SCMap bytes.
-
-        This publishes the request and waits for a matching ``MAP_RESPONSE`` message
-        with the correct protocol version. The raw ``MAP_RESPONSE`` payload bytes are
-        then decoded/inflated via :func:`decode_map_payload` using this channel's
-        ``map_key``, and the resulting SCMap bytes are returned.
-
-        The returned value is the decoded map data bytes suitable for passing to the
-        map parser library, not the raw MQTT ``MAP_RESPONSE`` payload bytes.
-        """
+    @property
+    def is_connected(self) -> bool:
+        return self._mqtt_channel.is_connected
+
+    @property
+    def is_local_connected(self) -> bool:
+        return False
+
+    async def subscribe(self, callback: Callable[[RoborockMessage], None]) -> Callable[[], None]:
+        return await self._mqtt_channel.subscribe(callback)
+
+    async def send_command(
+        self,
+        command: CommandType,
+        params: ParamsType = None,
+    ) -> DecodedB01Response:
+        return await send_decoded_command(
+            self._mqtt_channel,
+            Q7RequestMessage(dps=B01_Q7_DPS, command=command, params=params),
+        )
 
+    async def send_map_command(
+        self,
+        command: CommandType,
+        params: ParamsType = None,
+    ) -> bytes:
+        """Send a map upload command and return decoded SCMap bytes."""
+        request_message = Q7RequestMessage(dps=B01_Q7_DPS, command=command, params=params)
         try:
             raw_payload = await _send_command(
                 self._mqtt_channel,
@@ -163,3 +207,17 @@ class MapRpcChannel:
             raise RoborockException(f"B01 map command timed out after {_TIMEOUT}s ({request_message})") from ex
 
         return decode_map_payload(raw_payload, map_key=self._map_key)
+
+
+def create_b01_q7_channel(
+    device: HomeDataDevice,
+    product: HomeDataProduct,
+    mqtt_channel: MqttChannel,
+) -> B01Q7Channel:
+    """Create a B01Q7Channel for the given device."""
+    if device.sn is None or product.model is None:
+        raise RoborockException(
+            f"Device serial number and product model are required (sn: {device.sn}, model: {product.model})"
+        )
+    map_key = create_map_key(serial=device.sn, model=product.model)
+    return B01Q7Channel(mqtt_channel, map_key)

{python_roborock-5.25.0 → python_roborock-5.26.0}/roborock/devices/traits/b01/q10/__init__.py

@@ -4,9 +4,8 @@ import asyncio
 import logging
 
 from roborock.data.b01_q10.b01_q10_code_mappings import B01_Q10_DP
-from roborock.devices.rpc.b01_q10_channel import stream_decoded_messages
+from roborock.devices.rpc.b01_q10_channel import B01Q10Channel
 from roborock.devices.traits import Trait
-from roborock.devices.transport.mqtt_channel import MqttChannel
 from roborock.map.b01_q10_map_parser import Q10MapPacket, Q10TracePacket
 from roborock.protocols.b01_q10_protocol import Q10DpsUpdate, Q10Message
 
@@ -83,7 +82,7 @@ class Q10PropertiesApi(Trait):
     clean_history: CleanHistoryTrait
     """Trait for fetching the device clean-record history (``dpCleanRecord``)."""
 
-    def __init__(self, channel: MqttChannel) -> None:
+    def __init__(self, channel: B01Q10Channel) -> None:
         """Initialize the B01Props API."""
         self._channel = channel
         self.command = CommandTrait(channel)
@@ -134,7 +133,7 @@ class Q10PropertiesApi(Trait):
 
     async def _subscribe_loop(self) -> None:
         """Persistent loop dispatching decoded messages to the read-model traits."""
-        async for message in stream_decoded_messages(self._channel):
+        async for message in self._channel.subscribe_stream():
             self._handle_message(message)
 
     def _handle_message(self, message: Q10Message) -> None:
@@ -157,6 +156,6 @@ class Q10PropertiesApi(Trait):
                 trait.update_from_dps(message.dps)
 
 
-def create(channel: MqttChannel) -> Q10PropertiesApi:
+def create(channel: B01Q10Channel) -> Q10PropertiesApi:
     """Create traits for B01 devices."""
     return Q10PropertiesApi(channel)

{python_roborock-5.25.0 → python_roborock-5.26.0}/roborock/devices/traits/b01/q10/command.py

@@ -1,8 +1,7 @@
 from typing import Any
 
 from roborock.data.b01_q10.b01_q10_code_mappings import B01_Q10_DP
-from roborock.devices.rpc.b01_q10_channel import send_command
-from roborock.devices.transport.mqtt_channel import MqttChannel
+from roborock.devices.rpc.b01_q10_channel import Q10RpcChannel
 from roborock.protocols.b01_q10_protocol import ParamsType
 
 
@@ -15,9 +14,9 @@ class CommandTrait:
     available.
     """
 
-    def __init__(self, channel: MqttChannel) -> None:
+    def __init__(self, rpc_channel: Q10RpcChannel) -> None:
         """Initialize the CommandTrait."""
-        self._channel = channel
+        self._rpc_channel = rpc_channel
 
     async def send(self, command: B01_Q10_DP, params: ParamsType = None) -> Any:
         """Send a command to the device.
@@ -27,6 +26,6 @@ class CommandTrait:
         caller to ensure that any traits affected by the command are refreshed
         as needed.
         """
-        if not self._channel:
+        if not self._rpc_channel:
             raise ValueError("Device trait in invalid state")
-        return await send_command(self._channel, command, params=params)
+        return await self._rpc_channel.send_command(command, params=params)

{python_roborock-5.25.0 → python_roborock-5.26.0}/roborock/devices/traits/b01/q7/__init__.py

@@ -3,8 +3,6 @@
 Potentially other devices may fall into this category in the future.
 """
 
-from __future__ import annotations
-
 from typing import Any
 
 from roborock import B01Props
@@ -18,11 +16,10 @@ from roborock.data.b01_q7.b01_q7_code_mappings import (
     SCWindMapping,
     WaterLevelMapping,
 )
-from roborock.devices.rpc.b01_q7_channel import MapRpcChannel, send_decoded_command
+from roborock.devices.rpc.b01_q7_channel import Q7MapRpcChannel, Q7RpcChannel
 from roborock.devices.traits import Trait
-from roborock.devices.transport.mqtt_channel import MqttChannel
 from roborock.exceptions import RoborockException
-from roborock.protocols.b01_q7_protocol import B01_Q7_DPS, CommandType, ParamsType, Q7RequestMessage, create_map_key
+from roborock.protocols.b01_q7_protocol import CommandType, ParamsType
 from roborock.roborock_message import RoborockB01Props
 from roborock.roborock_typing import RoborockB01Q7Methods
 
@@ -53,10 +50,14 @@ class Q7PropertiesApi(Trait):
     """Trait for fetching parsed current map content."""
 
     def __init__(
-        self, channel: MqttChannel, map_rpc_channel: MapRpcChannel, device: HomeDataDevice, product: HomeDataProduct
+        self,
+        rpc_channel: Q7RpcChannel,
+        map_rpc_channel: Q7MapRpcChannel,
+        device: HomeDataDevice,
+        product: HomeDataProduct,
     ) -> None:
         """Initialize the Q7 API."""
-        self._channel = channel
+        self._rpc_channel = rpc_channel
         self._map_rpc_channel = map_rpc_channel
         self._device = device
         self._product = product
@@ -64,8 +65,8 @@ class Q7PropertiesApi(Trait):
         if not device.sn or not product.model:
             raise ValueError("B01 Q7 map content requires device serial number and product model metadata")
 
-        self.clean_summary = CleanSummaryTrait(channel)
-        self.map = MapTrait(channel)
+        self.clean_summary = CleanSummaryTrait(rpc_channel)
+        self.map = MapTrait(rpc_channel)
         self.map_content = MapContentTrait(
             self._map_rpc_channel,
             self.map,
@@ -199,17 +200,23 @@ class Q7PropertiesApi(Trait):
 
     async def send(self, command: CommandType, params: ParamsType) -> Any:
         """Send a command to the device."""
-        return await send_decoded_command(
-            self._channel,
-            Q7RequestMessage(dps=B01_Q7_DPS, command=command, params=params),
-        )
+        return await self._rpc_channel.send_command(command, params)
 
 
-def create(product: HomeDataProduct, device: HomeDataDevice, channel: MqttChannel) -> Q7PropertiesApi:
+def create(
+    product: HomeDataProduct,
+    device: HomeDataDevice,
+    rpc_channel: Q7RpcChannel,
+    map_rpc_channel: Q7MapRpcChannel,
+) -> Q7PropertiesApi:
     """Create traits for B01 Q7 devices."""
     if device.sn is None or product.model is None:
         raise RoborockException(
-            f"Device serial number and product model are required (sn:: {device.sn}, model: {product.model})"
+            f"Device serial number and product model are required (sn: {device.sn}, model: {product.model})"
         )
-    map_rpc_channel = MapRpcChannel(channel, map_key=create_map_key(serial=device.sn, model=product.model))
-    return Q7PropertiesApi(channel, device=device, product=product, map_rpc_channel=map_rpc_channel)
+    return Q7PropertiesApi(
+        rpc_channel=rpc_channel,
+        map_rpc_channel=map_rpc_channel,
+        device=device,
+        product=product,
+    )

{python_roborock-5.25.0 → python_roborock-5.26.0}/roborock/devices/traits/b01/q7/clean_summary.py

@@ -7,11 +7,9 @@ and a `record_list` whose items contain a JSON string in `detail`.
 import logging
 
 from roborock import CleanRecordDetail, CleanRecordList, CleanRecordSummary
-from roborock.devices.rpc.b01_q7_channel import send_decoded_command
+from roborock.devices.rpc.b01_q7_channel import Q7RpcChannel
 from roborock.devices.traits import Trait
-from roborock.devices.transport.mqtt_channel import MqttChannel
 from roborock.exceptions import RoborockException
-from roborock.protocols.b01_q7_protocol import B01_Q7_DPS, Q7RequestMessage
 from roborock.roborock_typing import RoborockB01Q7Methods
 
 __all__ = [
@@ -24,11 +22,11 @@ _LOGGER = logging.getLogger(__name__)
 class CleanSummaryTrait(CleanRecordSummary, Trait):
     """B01/Q7 clean summary + clean record access (via record list service)."""
 
-    def __init__(self, channel: MqttChannel) -> None:
+    def __init__(self, channel: Q7RpcChannel) -> None:
         """Initialize the clean summary trait.
 
         Args:
-            channel: MQTT channel used to communicate with the device.
+            channel: RPC channel used to communicate with the device.
         """
         super().__init__()
         self._channel = channel
@@ -46,9 +44,9 @@ class CleanSummaryTrait(CleanRecordSummary, Trait):
 
     async def _get_record_list(self) -> CleanRecordList:
         """Fetch the raw device clean record list (`service.get_record_list`)."""
-        result = await send_decoded_command(
-            self._channel,
-            Q7RequestMessage(dps=B01_Q7_DPS, command=RoborockB01Q7Methods.GET_RECORD_LIST, params={}),
+        result = await self._channel.send_command(
+            command=RoborockB01Q7Methods.GET_RECORD_LIST,
+            params={},
         )
 
         if not isinstance(result, dict):

{python_roborock-5.25.0 → python_roborock-5.26.0}/roborock/devices/traits/b01/q7/map.py

@@ -1,11 +1,9 @@
 """Map trait for B01 Q7 devices."""
 
 from roborock.data import Q7MapList
-from roborock.devices.rpc.b01_q7_channel import send_decoded_command
+from roborock.devices.rpc.b01_q7_channel import Q7RpcChannel
 from roborock.devices.traits import Trait
-from roborock.devices.transport.mqtt_channel import MqttChannel
 from roborock.exceptions import RoborockException
-from roborock.protocols.b01_q7_protocol import B01_Q7_DPS, Q7RequestMessage
 from roborock.roborock_typing import RoborockB01Q7Methods
 
 
@@ -16,15 +14,15 @@ class MapTrait(Q7MapList, Trait):
     current map ID to fetch.
     """
 
-    def __init__(self, channel: MqttChannel) -> None:
+    def __init__(self, channel: Q7RpcChannel) -> None:
         super().__init__()
         self._channel = channel
 
     async def refresh(self) -> None:
         """Refresh cached map list metadata from the device."""
-        response = await send_decoded_command(
-            self._channel,
-            Q7RequestMessage(dps=B01_Q7_DPS, command=RoborockB01Q7Methods.GET_MAP_LIST, params={}),
+        response = await self._channel.send_command(
+            command=RoborockB01Q7Methods.GET_MAP_LIST,
+            params={},
         )
         if not isinstance(response, dict):
             raise RoborockException(

{python_roborock-5.25.0 → python_roborock-5.26.0}/roborock/devices/traits/b01/q7/map_content.py

@@ -14,11 +14,10 @@ from dataclasses import dataclass
 from vacuum_map_parser_base.map_data import MapData
 
 from roborock.data import RoborockBase
-from roborock.devices.rpc.b01_q7_channel import MapRpcChannel
+from roborock.devices.rpc.b01_q7_channel import Q7MapRpcChannel
 from roborock.devices.traits import Trait
 from roborock.exceptions import RoborockException
 from roborock.map.b01_map_parser import B01MapParser, B01MapParserConfig
-from roborock.protocols.b01_q7_protocol import B01_Q7_DPS, Q7RequestMessage
 from roborock.roborock_typing import RoborockB01Q7Methods
 
 from .map import MapTrait
@@ -55,7 +54,7 @@ class MapContentTrait(MapContent, Trait):
 
     def __init__(
         self,
-        map_rpc_channel: MapRpcChannel,
+        map_rpc_channel: Q7MapRpcChannel,
         map_trait: MapTrait,
         *,
         map_parser_config: B01MapParserConfig | None = None,
@@ -77,13 +76,11 @@ class MapContentTrait(MapContent, Trait):
         if (map_id := self._map_trait.current_map_id) is None:
             raise RoborockException("Unable to determine current map ID")
 
-        request = Q7RequestMessage(
-            dps=B01_Q7_DPS,
-            command=RoborockB01Q7Methods.UPLOAD_BY_MAPID,
-            params={"map_id": map_id},
-        )
         async with self._map_command_lock:
-            raw_payload = await self._map_rpc_channel.send_map_command(request)
+            raw_payload = await self._map_rpc_channel.send_map_command(
+                RoborockB01Q7Methods.UPLOAD_BY_MAPID,
+                {"map_id": map_id},
+            )
 
         try:
             parsed_data = self._map_parser.parse(raw_payload)