python-roborock 4.21.0__tar.gz → 4.23.0__tar.gz

{python_roborock-4.21.0 → python_roborock-4.23.0}/PKG-INFO

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

{python_roborock-4.21.0 → python_roborock-4.23.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-roborock"
-version = "4.21.0"
+version = "4.23.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-4.21.0 → python_roborock-4.23.0}/roborock/data/b01_q7/b01_q7_containers.py

@@ -75,6 +75,33 @@ class Recommend(RoborockBase):
     room_id: list[int] = field(default_factory=list)
 
 
+@dataclass
+class Q7MapListEntry(RoborockBase):
+    """Single map list entry returned by `service.get_map_list`."""
+
+    id: int | None = None
+    cur: bool | None = None
+
+
+@dataclass
+class Q7MapList(RoborockBase):
+    """Map list response returned by `service.get_map_list`."""
+
+    map_list: list[Q7MapListEntry] = field(default_factory=list)
+
+    @property
+    def current_map_id(self) -> int | None:
+        """Current map id, preferring the entry marked current."""
+        if not self.map_list:
+            return None
+
+        ordered = sorted(self.map_list, key=lambda entry: entry.cur or False, reverse=True)
+        first = next(iter(ordered), None)
+        if first is None or not isinstance(first.id, int):
+            return None
+        return first.id
+
+
 @dataclass
 class B01Props(RoborockBase):
     """

{python_roborock-4.21.0 → python_roborock-4.23.0}/roborock/devices/rpc/b01_q7_channel.py

@@ -5,31 +5,67 @@ from __future__ import annotations
 import asyncio
 import json
 import logging
-from typing import Any
+from collections.abc import Callable
+from typing import Any, TypeVar
 
 from roborock.devices.transport.mqtt_channel import MqttChannel
 from roborock.exceptions import RoborockException
-from roborock.protocols.b01_q7_protocol import (
-    Q7RequestMessage,
-    decode_rpc_response,
-    encode_mqtt_payload,
-)
-from roborock.roborock_message import RoborockMessage
+from roborock.protocols.b01_q7_protocol import B01_VERSION, Q7RequestMessage, decode_rpc_response, encode_mqtt_payload
+from roborock.roborock_message import RoborockMessage, RoborockMessageProtocol
 
 _LOGGER = logging.getLogger(__name__)
 _TIMEOUT = 10.0
+_T = TypeVar("_T")
+
+
+def _matches_map_response(response_message: RoborockMessage, *, version: bytes | None) -> bytes | None:
+    """Return raw map payload bytes for matching MAP_RESPONSE messages."""
+    if (
+        response_message.protocol == RoborockMessageProtocol.MAP_RESPONSE
+        and response_message.payload
+        and response_message.version == version
+    ):
+        return response_message.payload
+    return None
+
+
+async def _send_command(
+    mqtt_channel: MqttChannel,
+    request_message: Q7RequestMessage,
+    *,
+    response_matcher: Callable[[RoborockMessage], _T | None],
+) -> _T:
+    """Publish a B01 command and resolve on the first matching response."""
+    roborock_message = encode_mqtt_payload(request_message)
+    future: asyncio.Future[_T] = asyncio.get_running_loop().create_future()
+
+    def on_message(response_message: RoborockMessage) -> None:
+        if future.done():
+            return
+        try:
+            response = response_matcher(response_message)
+        except Exception as ex:
+            future.set_exception(ex)
+            return
+        if response is not None:
+            future.set_result(response)
+
+    unsub = await mqtt_channel.subscribe(on_message)
+    try:
+        await mqtt_channel.publish(roborock_message)
+        return await asyncio.wait_for(future, timeout=_TIMEOUT)
+    finally:
+        unsub()
 
 
 async def send_decoded_command(
     mqtt_channel: MqttChannel,
     request_message: Q7RequestMessage,
-) -> dict[str, Any] | None:
+) -> Any:
     """Send a command on the MQTT channel and get a decoded response."""
     _LOGGER.debug("Sending B01 MQTT command: %s", request_message)
-    roborock_message = encode_mqtt_payload(request_message)
-    future: asyncio.Future[Any] = asyncio.get_running_loop().create_future()
 
-    def find_response(response_message: RoborockMessage) -> None:
+    def find_response(response_message: RoborockMessage) -> Any | None:
         """Handle incoming messages and resolve the future."""
         try:
             decoded_dps = decode_rpc_response(response_message)
@@ -41,7 +77,7 @@ async def send_decoded_command(
                 response_message,
                 ex,
             )
-            return
+            return None
         for dps_value in decoded_dps.values():
             # valid responses are JSON strings wrapped in the dps value
             if not isinstance(dps_value, str):
@@ -55,31 +91,23 @@ async def send_decoded_command(
                 continue
             if isinstance(inner, dict) and inner.get("msgId") == str(request_message.msg_id):
                 _LOGGER.debug("Received query response: %s", inner)
-                # Check for error code (0 = success, non-zero = error)
                 code = inner.get("code", 0)
                 if code != 0:
                     error_msg = f"B01 command failed with code {code} ({request_message})"
                     _LOGGER.debug("B01 error response: %s", error_msg)
-                    if not future.done():
-                        future.set_exception(RoborockException(error_msg))
-                    return
+                    raise RoborockException(error_msg)
                 data = inner.get("data")
-                # All get commands should be dicts
-                if request_message.command.endswith(".get") and not isinstance(data, dict):
-                    if not future.done():
-                        future.set_exception(
-                            RoborockException(f"Unexpected data type for response {data} ({request_message})")
-                        )
-                    return
-                if not future.done():
-                    future.set_result(data)
-
-    unsub = await mqtt_channel.subscribe(find_response)
-
-    _LOGGER.debug("Sending MQTT message: %s", roborock_message)
+                if request_message.command == "prop.get" and not isinstance(data, dict):
+                    raise RoborockException(f"Unexpected data type for response {data} ({request_message})")
+                return data
+        return None
+
     try:
-        await mqtt_channel.publish(roborock_message)
-        return await asyncio.wait_for(future, timeout=_TIMEOUT)
+        return await _send_command(
+            mqtt_channel,
+            request_message,
+            response_matcher=find_response,
+        )
     except TimeoutError as ex:
         raise RoborockException(f"B01 command timed out after {_TIMEOUT}s ({request_message})") from ex
     except RoborockException as ex:
@@ -89,7 +117,6 @@ async def send_decoded_command(
             ex,
         )
         raise
-
     except Exception as ex:
         _LOGGER.exception(
             "Error sending B01 decoded command (%ss): %s",
@@ -97,5 +124,20 @@ async def send_decoded_command(
             ex,
         )
         raise
-    finally:
-        unsub()
+
+
+async def send_map_command(mqtt_channel: MqttChannel, request_message: Q7RequestMessage) -> bytes:
+    """Send map upload command and wait for MAP_RESPONSE payload bytes.
+
+    This stays separate from ``send_decoded_command()`` because map uploads arrive as
+    raw ``MAP_RESPONSE`` payload bytes instead of a decoded RPC ``data`` payload.
+    """
+
+    try:
+        return await _send_command(
+            mqtt_channel,
+            request_message,
+            response_matcher=lambda response_message: _matches_map_response(response_message, version=B01_VERSION),
+        )
+    except TimeoutError as ex:
+        raise RoborockException(f"B01 map command timed out after {_TIMEOUT}s ({request_message})") from ex

{python_roborock-4.21.0 → python_roborock-4.23.0}/roborock/devices/traits/b01/q7/__init__.py

@@ -4,6 +4,7 @@ Potentially other devices may fall into this category in the future."""
 from typing import Any
 
 from roborock import B01Props
+from roborock.data import Q7MapList, Q7MapListEntry
 from roborock.data.b01_q7.b01_q7_code_mappings import (
     CleanPathPreferenceMapping,
     CleanRepeatMapping,
@@ -16,15 +17,19 @@ from roborock.data.b01_q7.b01_q7_code_mappings import (
 from roborock.devices.rpc.b01_q7_channel import send_decoded_command
 from roborock.devices.traits import Trait
 from roborock.devices.transport.mqtt_channel import MqttChannel
-from roborock.protocols.b01_q7_protocol import CommandType, ParamsType, Q7RequestMessage
+from roborock.protocols.b01_q7_protocol import B01_Q7_DPS, CommandType, ParamsType, Q7RequestMessage
 from roborock.roborock_message import RoborockB01Props
 from roborock.roborock_typing import RoborockB01Q7Methods
 
 from .clean_summary import CleanSummaryTrait
+from .map import MapTrait
 
 __all__ = [
     "Q7PropertiesApi",
     "CleanSummaryTrait",
+    "MapTrait",
+    "Q7MapList",
+    "Q7MapListEntry",
 ]
 
 
@@ -34,10 +39,14 @@ class Q7PropertiesApi(Trait):
     clean_summary: CleanSummaryTrait
     """Trait for clean records / clean summary (Q7 `service.get_record_list`)."""
 
+    map: MapTrait
+    """Trait for map list metadata + raw map payload retrieval."""
+
     def __init__(self, channel: MqttChannel) -> None:
         """Initialize the B01Props API."""
         self._channel = channel
         self.clean_summary = CleanSummaryTrait(channel)
+        self.map = MapTrait(channel)
 
     async def query_values(self, props: list[RoborockB01Props]) -> B01Props | None:
         """Query the device for the values of the given Q7 properties."""
@@ -87,6 +96,17 @@ class Q7PropertiesApi(Trait):
             },
         )
 
+    async def clean_segments(self, segment_ids: list[int]) -> None:
+        """Start segment cleaning for the given ids (Q7 uses room ids)."""
+        await self.send(
+            command=RoborockB01Q7Methods.SET_ROOM_CLEAN,
+            params={
+                "clean_type": CleanTaskTypeMapping.ROOM.code,
+                "ctrl_value": SCDeviceCleanParam.START.code,
+                "room_ids": segment_ids,
+            },
+        )
+
     async def pause_clean(self) -> None:
         """Pause cleaning."""
         await self.send(
@@ -127,7 +147,7 @@ class Q7PropertiesApi(Trait):
         """Send a command to the device."""
         return await send_decoded_command(
             self._channel,
-            Q7RequestMessage(dps=10000, command=command, params=params),
+            Q7RequestMessage(dps=B01_Q7_DPS, command=command, params=params),
         )
 
 

{python_roborock-4.21.0 → python_roborock-4.23.0}/roborock/devices/traits/b01/q7/clean_summary.py

@@ -13,7 +13,7 @@ from roborock.devices.rpc.b01_q7_channel import send_decoded_command
 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 Q7RequestMessage
+from roborock.protocols.b01_q7_protocol import B01_Q7_DPS, Q7RequestMessage
 from roborock.roborock_typing import RoborockB01Q7Methods
 
 __all__ = [
@@ -50,7 +50,7 @@ class CleanSummaryTrait(CleanRecordSummary, Trait):
         """Fetch the raw device clean record list (`service.get_record_list`)."""
         result = await send_decoded_command(
             self._channel,
-            Q7RequestMessage(dps=10000, command=RoborockB01Q7Methods.GET_RECORD_LIST, params={}),
+            Q7RequestMessage(dps=B01_Q7_DPS, command=RoborockB01Q7Methods.GET_RECORD_LIST, params={}),
         )
 
         if not isinstance(result, dict):

python_roborock-4.23.0/roborock/devices/traits/b01/q7/map.py

@@ -0,0 +1,59 @@
+"""Map trait for B01 Q7 devices."""
+
+import asyncio
+
+from roborock.data import Q7MapList
+from roborock.devices.rpc.b01_q7_channel import send_decoded_command, send_map_command
+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
+
+
+class MapTrait(Q7MapList, Trait):
+    """Map retrieval + map metadata helpers for Q7 devices."""
+
+    def __init__(self, channel: MqttChannel) -> None:
+        super().__init__()
+        self._channel = channel
+        # Map uploads are serialized per-device to avoid response cross-wiring.
+        self._map_command_lock = asyncio.Lock()
+        self._loaded = False
+
+    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={}),
+        )
+        if not isinstance(response, dict):
+            raise RoborockException(
+                f"Unexpected response type for GET_MAP_LIST: {type(response).__name__}: {response!r}"
+            )
+
+        if (parsed := Q7MapList.from_dict(response)) is None:
+            raise RoborockException(f"Failed to decode map list response: {response!r}")
+
+        self.map_list = parsed.map_list
+        self._loaded = True
+
+    async def _get_map_payload(self, *, map_id: int) -> bytes:
+        """Fetch raw map payload bytes for the given map id."""
+        request = Q7RequestMessage(
+            dps=B01_Q7_DPS,
+            command=RoborockB01Q7Methods.UPLOAD_BY_MAPID,
+            params={"map_id": map_id},
+        )
+        async with self._map_command_lock:
+            return await send_map_command(self._channel, request)
+
+    async def get_current_map_payload(self) -> bytes:
+        """Fetch raw map payload bytes for the currently selected map."""
+        if not self._loaded:
+            await self.refresh()
+
+        map_id = self.current_map_id
+        if map_id is None:
+            raise RoborockException(f"Unable to determine map_id from map list response: {self!r}")
+        return await self._get_map_payload(map_id=map_id)

{python_roborock-4.21.0 → python_roborock-4.23.0}/roborock/devices/traits/v1/child_lock.py

@@ -9,6 +9,7 @@ class ChildLockTrait(ChildLockStatus, common.V1TraitMixin, common.RoborockSwitch
     """Trait for controlling the child lock of a Roborock device."""
 
     command = RoborockCommand.GET_CHILD_LOCK_STATUS
+    converter = common.DefaultConverter(ChildLockStatus)
     requires_feature = "is_set_child_supported"
 
     @property

{python_roborock-4.21.0 → python_roborock-4.23.0}/roborock/devices/traits/v1/clean_summary.py

@@ -1,7 +1,6 @@
 import logging
-from typing import Self
 
-from roborock.data import CleanRecord, CleanSummaryWithDetail
+from roborock.data import CleanRecord, CleanSummaryWithDetail, RoborockBase
 from roborock.devices.traits.v1 import common
 from roborock.roborock_typing import RoborockCommand
 from roborock.util import unpack_list
@@ -9,48 +8,30 @@ from roborock.util import unpack_list
 _LOGGER = logging.getLogger(__name__)
 
 
-class CleanSummaryTrait(CleanSummaryWithDetail, common.V1TraitMixin):
-    """Trait for managing the clean summary of Roborock devices."""
-
-    command = RoborockCommand.GET_CLEAN_SUMMARY
-
-    async def refresh(self) -> None:
-        """Refresh the clean summary data and last clean record.
-
-        Assumes that the clean summary has already been fetched.
-        """
-        await super().refresh()
-        if not self.records:
-            _LOGGER.debug("No clean records available in clean summary.")
-            self.last_clean_record = None
-            return
-        last_record_id = self.records[0]
-        self.last_clean_record = await self.get_clean_record(last_record_id)
+class CleanSummaryConverter(common.V1TraitDataConverter):
+    """Converter for CleanSummaryWithDetail objects."""
 
-    @classmethod
-    def _parse_type_response(cls, response: common.V1ResponseData) -> Self:
+    def convert(self, response: common.V1ResponseData) -> RoborockBase:
         """Parse the response from the device into a CleanSummary."""
         if isinstance(response, dict):
-            return cls.from_dict(response)
+            return CleanSummaryWithDetail.from_dict(response)
         elif isinstance(response, list):
             clean_time, clean_area, clean_count, records = unpack_list(response, 4)
-            return cls(
+            return CleanSummaryWithDetail(
                 clean_time=clean_time,
                 clean_area=clean_area,
                 clean_count=clean_count,
                 records=records,
             )
         elif isinstance(response, int):
-            return cls(clean_time=response)
+            return CleanSummaryWithDetail(clean_time=response)
         raise ValueError(f"Unexpected clean summary format: {response!r}")
 
-    async def get_clean_record(self, record_id: int) -> CleanRecord:
-        """Load a specific clean record by ID."""
-        response = await self.rpc_channel.send_command(RoborockCommand.GET_CLEAN_RECORD, params=[record_id])
-        return self._parse_clean_record_response(response)
 
-    @classmethod
-    def _parse_clean_record_response(cls, response: common.V1ResponseData) -> CleanRecord:
+class CleanRecordConverter(common.V1TraitDataConverter):
+    """Convert server responses to a CleanRecord."""
+
+    def convert(self, response: common.V1ResponseData) -> CleanRecord:
         """Parse the response from the device into a CleanRecord."""
         if isinstance(response, list) and len(response) == 1:
             response = response[0]
@@ -81,3 +62,29 @@ class CleanSummaryTrait(CleanSummaryWithDetail, common.V1TraitMixin):
             begin, end, duration, area = unpack_list(response, 4)
             return CleanRecord(begin=begin, end=end, duration=duration, area=area)
         raise ValueError(f"Unexpected clean record format: {response!r}")
+
+
+class CleanSummaryTrait(CleanSummaryWithDetail, common.V1TraitMixin):
+    """Trait for managing the clean summary of Roborock devices."""
+
+    command = RoborockCommand.GET_CLEAN_SUMMARY
+    converter = CleanSummaryConverter()
+    clean_record_converter = CleanRecordConverter()
+
+    async def refresh(self) -> None:
+        """Refresh the clean summary data and last clean record.
+
+        Assumes that the clean summary has already been fetched.
+        """
+        await super().refresh()
+        if not self.records:
+            _LOGGER.debug("No clean records available in clean summary.")
+            self.last_clean_record = None
+            return
+        last_record_id = self.records[0]
+        self.last_clean_record = await self.get_clean_record(last_record_id)
+
+    async def get_clean_record(self, record_id: int) -> CleanRecord:
+        """Load a specific clean record by ID."""
+        response = await self.rpc_channel.send_command(RoborockCommand.GET_CLEAN_RECORD, params=[record_id])
+        return self.clean_record_converter.convert(response)

{python_roborock-4.21.0 → python_roborock-4.23.0}/roborock/devices/traits/v1/common.py

@@ -5,8 +5,8 @@ This is an internal library and should not be used directly by consumers.
 
 import logging
 from abc import ABC, abstractmethod
-from dataclasses import dataclass, fields
-from typing import ClassVar, Self
+from dataclasses import fields
+from typing import ClassVar
 
 from roborock.data import RoborockBase
 from roborock.protocols.v1_protocol import V1RpcChannel
@@ -14,10 +14,24 @@ from roborock.roborock_typing import RoborockCommand
 
 _LOGGER = logging.getLogger(__name__)
 
+
 V1ResponseData = dict | list | int | str
 
 
-@dataclass
+class V1TraitDataConverter(ABC):
+    """Converts responses to RoborockBase objects.
+
+    This is an internal class and should not be used directly by consumers.
+    """
+
+    @abstractmethod
+    def convert(self, response: V1ResponseData) -> RoborockBase:
+        """Convert the values to a dict that can be parsed as a RoborockBase."""
+
+    def __repr__(self) -> str:
+        return self.__class__.__name__
+
+
 class V1TraitMixin(ABC):
     """Base model that supports v1 traits.
 
@@ -42,37 +56,13 @@ class V1TraitMixin(ABC):
     """
 
     command: ClassVar[RoborockCommand]
+    """The RoborockCommand used to fetch the trait data from the device (internal only)."""
 
-    @classmethod
-    def _parse_type_response(cls, response: V1ResponseData) -> RoborockBase:
-        """Parse the response from the device into a a RoborockBase.
-
-        Subclasses should override this method to implement custom parsing
-        logic as needed.
-        """
-        if not issubclass(cls, RoborockBase):
-            raise NotImplementedError(f"Trait {cls} does not implement RoborockBase")
-        # Subclasses can override to implement custom parsing logic
-        if isinstance(response, list):
-            response = response[0]
-        if not isinstance(response, dict):
-            raise ValueError(f"Unexpected {cls} response format: {response!r}")
-        return cls.from_dict(response)
-
-    def _parse_response(self, response: V1ResponseData) -> RoborockBase:
-        """Parse the response from the device into a a RoborockBase.
-
-        This is used by subclasses that want to override the class
-        behavior with instance-specific data.
-        """
-        return self._parse_type_response(response)
-
-    def __post_init__(self) -> None:
-        """Post-initialization to set up the RPC channel.
+    converter: V1TraitDataConverter
+    """The converter used to parse the response from the device (internal only)."""
 
-        This is called automatically after the dataclass is initialized by the
-        device setup code.
-        """
+    def __init__(self) -> None:
+        """Initialize the V1TraitMixin."""
         self._rpc_channel = None
 
     @property
@@ -85,32 +75,42 @@ class V1TraitMixin(ABC):
     async def refresh(self) -> None:
         """Refresh the contents of this trait."""
         response = await self.rpc_channel.send_command(self.command)
-        new_data = self._parse_response(response)
-        if not isinstance(new_data, RoborockBase):
-            raise ValueError(f"Internal error, unexpected response type: {new_data!r}")
-        _LOGGER.debug("Refreshed %s: %s", self.__class__.__name__, new_data)
-        self._update_trait_values(new_data)
-
-    def _update_trait_values(self, new_data: RoborockBase) -> None:
-        """Update the values of this trait from another instance."""
-        for field in fields(new_data):
-            new_value = getattr(new_data, field.name, None)
-            setattr(self, field.name, new_value)
-
-
-def _get_value_field(clazz: type[V1TraitMixin]) -> str:
-    """Get the name of the field marked as the main value of the RoborockValueBase."""
-    value_fields = [field.name for field in fields(clazz) if field.metadata.get("roborock_value", False)]
-    if len(value_fields) != 1:
-        raise ValueError(
-            f"RoborockValueBase subclass {clazz} must have exactly one field marked as roborock_value, "
-            f" but found: {value_fields}"
-        )
-    return value_fields[0]
-
-
-@dataclass(init=False, kw_only=True)
-class RoborockValueBase(V1TraitMixin, RoborockBase):
+        new_data = self.converter.convert(response)
+        merge_trait_values(self, new_data)  # type: ignore[arg-type]
+
+
+def merge_trait_values(target: RoborockBase, new_object: RoborockBase) -> bool:
+    """Update the target object with set fields in new_object."""
+    updated = False
+    for field in fields(new_object):
+        old_value = getattr(target, field.name, None)
+        new_value = getattr(new_object, field.name, None)
+        if new_value != old_value:
+            setattr(target, field.name, new_value)
+            updated = True
+    return updated
+
+
+class DefaultConverter(V1TraitDataConverter):
+    """Converts responses to RoborockBase objects."""
+
+    def __init__(self, dataclass_type: type[RoborockBase]) -> None:
+        """Initialize the converter."""
+        self._dataclass_type = dataclass_type
+
+    def convert(self, response: V1ResponseData) -> RoborockBase:
+        """Convert the values to a dict that can be parsed as a RoborockBase.
+
+        Subclasses can override to implement custom parsing logic
+        """
+        if isinstance(response, list):
+            response = response[0]
+        if not isinstance(response, dict):
+            raise ValueError(f"Unexpected {self._dataclass_type.__name__} response format: {response!r}")
+        return self._dataclass_type.from_dict(response)
+
+
+class SingleValueConverter(DefaultConverter):
     """Base class for traits that represent a single value.
 
     This class is intended to be subclassed by traits that represent a single
@@ -119,15 +119,18 @@ class RoborockValueBase(V1TraitMixin, RoborockBase):
     represents the main value of the trait.
     """
 
-    @classmethod
-    def _parse_response(cls, response: V1ResponseData) -> Self:
+    def __init__(self, dataclass_type: type[RoborockBase], value_field: str) -> None:
+        """Initialize the converter."""
+        super().__init__(dataclass_type)
+        self._value_field = value_field
+
+    def convert(self, response: V1ResponseData) -> RoborockBase:
         """Parse the response from the device into a RoborockValueBase."""
         if isinstance(response, list):
             response = response[0]
         if not isinstance(response, int):
             raise ValueError(f"Unexpected response format: {response!r}")
-        value_field = _get_value_field(cls)
-        return cls(**{value_field: response})
+        return super().convert({self._value_field: response})
 
 
 class RoborockSwitchBase(ABC):

{python_roborock-4.21.0 → python_roborock-4.23.0}/roborock/devices/traits/v1/consumeable.py

@@ -41,6 +41,7 @@ class ConsumableTrait(Consumable, common.V1TraitMixin):
     """
 
     command = RoborockCommand.GET_CONSUMABLE
+    converter = common.DefaultConverter(Consumable)
 
     async def reset_consumable(self, consumable: ConsumableAttribute) -> None:
         """Reset a specific consumable attribute on the device."""