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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-roborock
-Version: 4.22.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.22.0 → python_roborock-4.23.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-roborock"
-version = "4.22.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.22.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.22.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.22.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.22.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."""

{python_roborock-4.22.0 → python_roborock-4.23.0}/roborock/devices/traits/v1/device_features.py

@@ -8,15 +8,37 @@ from roborock.devices.traits.v1 import common
 from roborock.roborock_typing import RoborockCommand
 
 
+class DeviceTraitsConverter(common.V1TraitDataConverter):
+    """Converter for APP_GET_INIT_STATUS responses into DeviceFeatures."""
+
+    def __init__(self, product: HomeDataProduct) -> None:
+        """Initialize DeviceTraitsConverter."""
+        self._product = product
+
+    def convert(self, response: common.V1ResponseData) -> DeviceFeatures:
+        """Parse an APP_GET_INIT_STATUS response into a DeviceFeatures instance."""
+        if not isinstance(response, list):
+            raise ValueError(f"Unexpected AppInitStatus response format: {type(response)}: {response!r}")
+        app_status = AppInitStatus.from_dict(response[0])
+        return DeviceFeatures.from_feature_flags(
+            new_feature_info=app_status.new_feature_info,
+            new_feature_info_str=app_status.new_feature_info_str,
+            feature_info=app_status.feature_info,
+            product_nickname=self._product.product_nickname,
+        )
+
+
 class DeviceFeaturesTrait(DeviceFeatures, common.V1TraitMixin):
     """Trait for managing supported features on Roborock devices."""
 
     command = RoborockCommand.APP_GET_INIT_STATUS
+    converter: DeviceTraitsConverter
 
     def __init__(self, product: HomeDataProduct, device_cache: DeviceCache) -> None:  # pylint: disable=super-init-not-called
         """Initialize DeviceFeaturesTrait."""
+        common.V1TraitMixin.__init__(self)
+        self.converter = DeviceTraitsConverter(product)
         self._product = product
-        self._nickname = product.product_nickname
         self._device_cache = device_cache
         # All fields of DeviceFeatures are required. Initialize them to False
         # so we have some known state.
@@ -54,21 +76,9 @@ class DeviceFeaturesTrait(DeviceFeatures, common.V1TraitMixin):
         """
         cache_data = await self._device_cache.get()
         if cache_data.device_features is not None:
-            self._update_trait_values(cache_data.device_features)
+            common.merge_trait_values(self, cache_data.device_features)
             return
         # Save cached device features
         await super().refresh()
         cache_data.device_features = self
         await self._device_cache.set(cache_data)
-
-    def _parse_response(self, response: common.V1ResponseData) -> DeviceFeatures:
-        """Parse the response from the device into a MapContentTrait instance."""
-        if not isinstance(response, list):
-            raise ValueError(f"Unexpected AppInitStatus response format: {type(response)}")
-        app_status = AppInitStatus.from_dict(response[0])
-        return DeviceFeatures.from_feature_flags(
-            new_feature_info=app_status.new_feature_info,
-            new_feature_info_str=app_status.new_feature_info_str,
-            feature_info=app_status.feature_info,
-            product_nickname=self._nickname,
-        )

{python_roborock-4.22.0 → python_roborock-4.23.0}/roborock/devices/traits/v1/do_not_disturb.py

@@ -9,6 +9,7 @@ class DoNotDisturbTrait(DnDTimer, common.V1TraitMixin, common.RoborockSwitchBase
     """Trait for managing Do Not Disturb (DND) settings on Roborock devices."""
 
     command = RoborockCommand.GET_DND_TIMER
+    converter = common.DefaultConverter(DnDTimer)
 
     @property
     def is_on(self) -> bool:

{python_roborock-4.22.0 → python_roborock-4.23.0}/roborock/devices/traits/v1/dust_collection_mode.py

@@ -10,4 +10,5 @@ class DustCollectionModeTrait(DustCollectionMode, common.V1TraitMixin):
     """Trait for dust collection mode."""
 
     command = RoborockCommand.GET_DUST_COLLECTION_MODE
+    converter = common.DefaultConverter(DustCollectionMode)
     requires_dock_type = is_valid_dock

{python_roborock-4.22.0 → python_roborock-4.23.0}/roborock/devices/traits/v1/flow_led_status.py

@@ -9,6 +9,7 @@ class FlowLedStatusTrait(FlowLedStatus, common.V1TraitMixin, common.RoborockSwit
     """Trait for controlling the Flow LED status of a Roborock device."""
 
     command = RoborockCommand.GET_FLOW_LED_STATUS
+    converter = common.DefaultConverter(FlowLedStatus)
     requires_feature = "is_flow_led_setting_supported"
 
     @property

{python_roborock-4.22.0 → python_roborock-4.23.0}/roborock/devices/traits/v1/home.py

@@ -18,7 +18,6 @@ the current map's information and room names as needed.
 import asyncio
 import base64
 import logging
-from typing import Self
 
 from roborock.data import CombinedMapInfo, MultiMapsListMapInfo, NamedRoomMapping, RoborockBase
 from roborock.data.v1.v1_code_mappings import RoborockStateCode
@@ -41,6 +40,7 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
     """Trait that represents a full view of the home layout."""
 
     command = RoborockCommand.GET_MAP_V1  # This is not used
+    converter = common.DefaultConverter(RoborockBase)  # Not used
 
     def __init__(
         self,
@@ -93,7 +93,7 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
             self._discovery_completed = True
             try:
                 self._home_map_content = {
-                    k: self._map_content.parse_map_content(base64.b64decode(v))
+                    k: self._map_content.converter.parse_map_content(base64.b64decode(v))
                     for k, v in (device_cache_data.home_map_content_base64 or {}).items()
                 }
             except (ValueError, RoborockException) as ex:
@@ -233,10 +233,6 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
         """Returns the map content for all cached maps."""
         return self._home_map_content
 
-    def _parse_response(self, response: common.V1ResponseData) -> Self:
-        """This trait does not parse responses directly."""
-        raise NotImplementedError("HomeTrait does not support direct command responses")
-
     async def _update_home_cache(
         self, home_map_info: dict[int, CombinedMapInfo], home_map_content: dict[int, MapContent]
     ) -> None:

{python_roborock-4.22.0 → python_roborock-4.23.0}/roborock/devices/traits/v1/led_status.py

@@ -5,10 +5,28 @@ from roborock.roborock_typing import RoborockCommand
 from .common import V1ResponseData
 
 
+class LedStatusConverter(common.V1TraitDataConverter):
+    """Converter for LedStatus."""
+
+    def convert(self, response: V1ResponseData) -> LedStatus:
+        """Parse the response from the device into a a RoborockBase.
+
+        Subclasses should override this method to implement custom parsing
+        logic as needed.
+        """
+        if not isinstance(response, list):
+            raise ValueError(f"Unexpected LedStatus response format: {response!r}")
+        response = response[0]
+        if not isinstance(response, int):
+            raise ValueError(f"Unexpected LedStatus response format: {response!r}")
+        return LedStatus.from_dict({"status": response})
+
+
 class LedStatusTrait(LedStatus, common.V1TraitMixin, common.RoborockSwitchBase):
     """Trait for controlling the LED status of a Roborock device."""
 
     command = RoborockCommand.GET_LED_STATUS
+    converter = LedStatusConverter()
     requires_feature = "is_led_status_switch_supported"
 
     @property
@@ -27,17 +45,3 @@ class LedStatusTrait(LedStatus, common.V1TraitMixin, common.RoborockSwitchBase):
         await self.rpc_channel.send_command(RoborockCommand.SET_LED_STATUS, params=[0])
         # Optimistic update to avoid an extra refresh
         self.status = 0
-
-    @classmethod
-    def _parse_type_response(cls, response: V1ResponseData) -> LedStatus:
-        """Parse the response from the device into a a RoborockBase.
-
-        Subclasses should override this method to implement custom parsing
-        logic as needed.
-        """
-        if not isinstance(response, list):
-            raise ValueError(f"Unexpected {cls} response format: {response!r}")
-        response = response[0]
-        if not isinstance(response, int):
-            raise ValueError(f"Unexpected {cls} response format: {response!r}")
-        return cls.from_dict({"status": response})

{python_roborock-4.22.0 → python_roborock-4.23.0}/roborock/devices/traits/v1/map_content.py

@@ -40,19 +40,15 @@ class MapContent(RoborockBase):
         return f"MapContent(image_content={img!r}, map_data={self.map_data!r})"
 
 
-@common.map_rpc_channel
-class MapContentTrait(MapContent, common.V1TraitMixin):
-    """Trait for fetching the map content."""
-
-    command = RoborockCommand.GET_MAP_V1
+class MapContentConverter(common.V1TraitDataConverter):
+    """Convert map response data to MapContent."""
 
-    def __init__(self, map_parser_config: MapParserConfig | None = None) -> None:
-        """Initialize MapContentTrait."""
-        super().__init__()
-        self._map_parser = MapParser(map_parser_config or MapParserConfig())
+    def __init__(self, map_parser: MapParser) -> None:
+        """Initialize MapContentConverter."""
+        self._map_parser = map_parser
 
-    def _parse_response(self, response: common.V1ResponseData) -> MapContent:
-        """Parse the response from the device into a MapContentTrait instance."""
+    def convert(self, response: common.V1ResponseData) -> MapContent:
+        """Parse the response from the device into a MapContent instance."""
         if not isinstance(response, bytes):
             raise ValueError(f"Unexpected MapContentTrait response format: {type(response)}")
         return self.parse_map_content(response)
@@ -81,3 +77,16 @@ class MapContentTrait(MapContent, common.V1TraitMixin):
             map_data=parsed_data.map_data,
             raw_api_response=response,
         )
+
+
+@common.map_rpc_channel
+class MapContentTrait(MapContent, common.V1TraitMixin):
+    """Trait for fetching the map content."""
+
+    command = RoborockCommand.GET_MAP_V1
+    converter: MapContentConverter
+
+    def __init__(self, map_parser_config: MapParserConfig | None = None) -> None:
+        """Initialize MapContentTrait."""
+        super().__init__()
+        self.converter = MapContentConverter(MapParser(map_parser_config or MapParserConfig()))

{python_roborock-4.22.0 → python_roborock-4.23.0}/roborock/devices/traits/v1/maps.py

@@ -6,7 +6,6 @@ base container datatypes to add additional fields.
 """
 
 import logging
-from typing import Self
 
 from roborock.data import MultiMapsList, MultiMapsListMapInfo
 from roborock.devices.traits.v1 import common
@@ -17,6 +16,24 @@ from .status import StatusTrait
 _LOGGER = logging.getLogger(__name__)
 
 
+class MultiMapsListConverter(common.V1TraitDataConverter):
+    """Converters responses to MultiMapsList."""
+
+    def convert(self, response: common.V1ResponseData) -> MultiMapsList:
+        """Parse the response from the device into a MapsTrait instance.
+
+        This overrides the base implementation to handle the specific
+        response format for the multi maps list. This is needed because we have
+        a custom constructor that requires the StatusTrait.
+        """
+        if not isinstance(response, list):
+            raise ValueError(f"Unexpected MapsTrait response format: {response!r}")
+        response = response[0]
+        if not isinstance(response, dict):
+            raise ValueError(f"Unexpected MapsTrait response format: {response!r}")
+        return MultiMapsList.from_dict(response)
+
+
 @common.mqtt_rpc_channel
 class MapsTrait(MultiMapsList, common.V1TraitMixin):
     """Trait for managing the maps of Roborock devices.
@@ -34,6 +51,7 @@ class MapsTrait(MultiMapsList, common.V1TraitMixin):
     """
 
     command = RoborockCommand.GET_MULTI_MAPS_LIST
+    converter = MultiMapsListConverter()
 
     def __init__(self, status_trait: StatusTrait) -> None:
         """Initialize the MapsTrait.
@@ -64,17 +82,3 @@ class MapsTrait(MultiMapsList, common.V1TraitMixin):
         await self.rpc_channel.send_command(RoborockCommand.LOAD_MULTI_MAP, params=[map_flag])
         # Refresh our status to make sure it reflects the new map
         await self._status_trait.refresh()
-
-    def _parse_response(self, response: common.V1ResponseData) -> Self:
-        """Parse the response from the device into a MapsTrait instance.
-
-        This overrides the base implementation to handle the specific
-        response format for the multi maps list. This is needed because we have
-        a custom constructor that requires the StatusTrait.
-        """
-        if not isinstance(response, list):
-            raise ValueError(f"Unexpected MapsTrait response format: {response!r}")
-        response = response[0]
-        if not isinstance(response, dict):
-            raise ValueError(f"Unexpected MapsTrait response format: {response!r}")
-        return MultiMapsList.from_dict(response)

{python_roborock-4.22.0 → python_roborock-4.23.0}/roborock/devices/traits/v1/network_info.py

@@ -12,6 +12,16 @@ from roborock.roborock_typing import RoborockCommand
 _LOGGER = logging.getLogger(__name__)
 
 
+class NetworkInfoConverter(common.V1TraitDataConverter):
+    """Converter for NetworkInfo objects."""
+
+    def convert(self, response: common.V1ResponseData) -> NetworkInfo:
+        """Parse the response from the device into a NetworkInfoConverter instance."""
+        if not isinstance(response, dict):
+            raise ValueError(f"Unexpected NetworkInfoTrait response format: {response!r}")
+        return NetworkInfo.from_dict(response)
+
+
 class NetworkInfoTrait(NetworkInfo, common.V1TraitMixin):
     """Trait for device network information.
 
@@ -23,6 +33,7 @@ class NetworkInfoTrait(NetworkInfo, common.V1TraitMixin):
     """
 
     command = RoborockCommand.GET_NETWORK_INFO
+    converter = NetworkInfoConverter()
 
     def __init__(self, device_uid: str, device_cache: DeviceCache) -> None:  # pylint: disable=super-init-not-called
         """Initialize the trait."""
@@ -36,7 +47,7 @@ class NetworkInfoTrait(NetworkInfo, common.V1TraitMixin):
         device_cache_data = await self._device_cache.get()
         if device_cache_data.network_info:
             _LOGGER.debug("Using cached network info for device %s", self._device_uid)
-            self._update_trait_values(device_cache_data.network_info)
+            common.merge_trait_values(self, device_cache_data.network_info)
             return
 
         # Load from device if not in cache
@@ -47,9 +58,3 @@ class NetworkInfoTrait(NetworkInfo, common.V1TraitMixin):
         device_cache_data = await self._device_cache.get()
         device_cache_data.network_info = self
         await self._device_cache.set(device_cache_data)
-
-    def _parse_response(self, response: common.V1ResponseData) -> NetworkInfo:
-        """Parse the response from the device into a NetworkInfo."""
-        if not isinstance(response, dict):
-            raise ValueError(f"Unexpected NetworkInfoTrait response format: {response!r}")
-        return NetworkInfo.from_dict(response)

{python_roborock-4.22.0 → python_roborock-4.23.0}/roborock/devices/traits/v1/rooms.py

@@ -25,11 +25,63 @@ class Rooms(RoborockBase):
             return {}
         return {room.segment_id: room for room in self.rooms}
 
+    def with_room_names(self, name_map: dict[str, str]) -> "Rooms":
+        """Create a new Rooms object with updated room names."""
+        return Rooms(
+            rooms=[
+                NamedRoomMapping(
+                    segment_id=room.segment_id,
+                    iot_id=room.iot_id,
+                    raw_name=name_map.get(room.iot_id),
+                )
+                for room in self.rooms or []
+            ]
+        )
+
+
+class RoomsConverter(common.V1TraitDataConverter):
+    """Converts response objects to Rooms."""
+
+    def convert(self, response: common.V1ResponseData) -> Rooms:
+        """Parse the response from the device into a list of NamedRoomMapping."""
+        if not isinstance(response, list):
+            raise ValueError(f"Unexpected RoomsTrait response format: {response!r}")
+        segment_map = self.extract_segment_map(response)
+        return Rooms(
+            rooms=[NamedRoomMapping(segment_id=segment_id, iot_id=iot_id) for segment_id, iot_id in segment_map.items()]
+        )
+
+    @staticmethod
+    def extract_segment_map(response: list) -> dict[int, str]:
+        """Extract a segment_id -> iot_id mapping from the response.
+
+        The response format can be either a flat list of [segment_id, iot_id] or a
+        list of lists, where each inner list is a pair of [segment_id, iot_id]. This
+        function normalizes the response into a dict of segment_id to iot_id.
+
+        NOTE: We currently only partial samples of the room mapping formats, so
+        improving test coverage with samples from a real device with this format
+        would be helpful.
+        """
+        if len(response) == 2 and not isinstance(response[0], list):
+            segment_id, iot_id = response[0], response[1]
+            return {segment_id: str(iot_id)}
+
+        segment_map: dict[int, str] = {}
+        for part in response:
+            if not isinstance(part, list) or len(part) < 2:
+                _LOGGER.warning("Unexpected room mapping entry format: %r", part)
+                continue
+            segment_id, iot_id = part[0], part[1]
+            segment_map[segment_id] = str(iot_id)
+        return segment_map
+
 
 class RoomsTrait(Rooms, common.V1TraitMixin):
     """Trait for managing the room mappings of Roborock devices."""
 
     command = RoborockCommand.GET_ROOM_MAPPING
+    converter = RoomsConverter()
 
     def __init__(self, home_data: HomeData, web_api: UserWebApiClient) -> None:
         """Initialize the RoomsTrait."""
@@ -44,7 +96,7 @@ class RoomsTrait(Rooms, common.V1TraitMixin):
         if not isinstance(response, list):
             raise ValueError(f"Unexpected RoomsTrait response format: {response!r}")
 
-        segment_map = _extract_segment_map(response)
+        segment_map = RoomsConverter.extract_segment_map(response)
         # Track all iot ids seen before. Refresh the room list when new ids are found.
         new_iot_ids = set(segment_map.values()) - set(self._home_data.rooms_map.keys())
         if new_iot_ids - self._discovered_iot_ids:
@@ -54,22 +106,9 @@ class RoomsTrait(Rooms, common.V1TraitMixin):
                 self._home_data.rooms = updated_rooms
             self._discovered_iot_ids.update(new_iot_ids)
 
-        new_data = self._parse_rooms(segment_map, self._home_data.rooms_name_map)
-        self._update_trait_values(new_data)
-        _LOGGER.debug("Refreshed %s: %s", self.__class__.__name__, new_data)
-
-    @staticmethod
-    def _parse_rooms(
-        segment_map: dict[int, str],
-        name_map: dict[str, str],
-    ) -> Rooms:
-        """Parse the response from the device into a list of NamedRoomMapping."""
-        return Rooms(
-            rooms=[
-                NamedRoomMapping(segment_id=segment_id, iot_id=iot_id, raw_name=name_map.get(iot_id))
-                for segment_id, iot_id in segment_map.items()
-            ]
-        )
+        rooms = self.converter.convert(response)
+        rooms = rooms.with_room_names(self._home_data.rooms_name_map)
+        common.merge_trait_values(self, rooms)
 
     async def _refresh_rooms(self) -> list[HomeDataRoom]:
         """Fetch the latest rooms from the web API."""
@@ -78,28 +117,3 @@ class RoomsTrait(Rooms, common.V1TraitMixin):
         except Exception:
             _LOGGER.debug("Failed to fetch rooms from web API", exc_info=True)
             return []
-
-
-def _extract_segment_map(response: list) -> dict[int, str]:
-    """Extract a segment_id -> iot_id mapping from the response.
-
-    The response format can be either a flat list of [segment_id, iot_id] or a
-    list of lists, where each inner list is a pair of [segment_id, iot_id]. This
-    function normalizes the response into a dict of segment_id to iot_id.
-
-    NOTE: We currently only partial samples of the room mapping formats, so
-    improving test coverage with samples from a real device with this format
-    would be helpful.
-    """
-    if len(response) == 2 and not isinstance(response[0], list):
-        segment_id, iot_id = response[0], response[1]
-        return {segment_id: str(iot_id)}
-
-    segment_map: dict[int, str] = {}
-    for part in response:
-        if not isinstance(part, list) or len(part) < 2:
-            _LOGGER.warning("Unexpected room mapping entry format: %r", part)
-            continue
-        segment_id, iot_id = part[0], part[1]
-        segment_map[segment_id] = str(iot_id)
-    return segment_map

{python_roborock-4.22.0 → python_roborock-4.23.0}/roborock/devices/traits/v1/smart_wash_params.py

@@ -10,4 +10,5 @@ class SmartWashParamsTrait(SmartWashParams, common.V1TraitMixin):
     """Trait for smart wash parameters."""
 
     command = RoborockCommand.GET_SMART_WASH_PARAMS
+    converter = common.DefaultConverter(SmartWashParams)
     requires_dock_type = is_wash_n_fill_dock

{python_roborock-4.22.0 → python_roborock-4.23.0}/roborock/devices/traits/v1/status.py

@@ -1,5 +1,4 @@
 from functools import cached_property
-from typing import Self
 
 from roborock import (
     CleanRoutes,
@@ -43,6 +42,7 @@ class StatusTrait(StatusV2, common.V1TraitMixin):
     """
 
     command = RoborockCommand.GET_STATUS
+    converter = common.DefaultConverter(StatusV2)
 
     def __init__(self, device_feature_trait: DeviceFeaturesTrait, region: str | None = None) -> None:
         """Initialize the StatusTrait."""
@@ -91,11 +91,3 @@ class StatusTrait(StatusV2, common.V1TraitMixin):
         if self.mop_mode is None:
             return None
         return self.mop_route_mapping.get(self.mop_mode)
-
-    def _parse_response(self, response: common.V1ResponseData) -> Self:
-        """Parse the response from the device into a StatusV2-based status object."""
-        if isinstance(response, list):
-            response = response[0]
-        if isinstance(response, dict):
-            return StatusV2.from_dict(response)
-        raise ValueError(f"Unexpected status format: {response!r}")

{python_roborock-4.22.0 → python_roborock-4.23.0}/roborock/devices/traits/v1/valley_electricity_timer.py

@@ -9,6 +9,7 @@ class ValleyElectricityTimerTrait(ValleyElectricityTimer, common.V1TraitMixin, c
     """Trait for managing Valley Electricity Timer settings on Roborock devices."""
 
     command = RoborockCommand.GET_VALLEY_ELECTRICITY_TIMER
+    converter = common.DefaultConverter(ValleyElectricityTimer)
     requires_feature = "is_supported_valley_electricity"
 
     @property

{python_roborock-4.22.0 → python_roborock-4.23.0}/roborock/devices/traits/v1/volume.py

@@ -1,18 +1,15 @@
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 
+from roborock.data.containers import RoborockBase
 from roborock.devices.traits.v1 import common
 from roborock.roborock_typing import RoborockCommand
 
-# TODO: This is currently the pattern for holding all the commands that hold a
-# single value, but it still seems too verbose. Maybe we can generate these
-# dynamically or somehow make them less code.
-
 
 @dataclass
-class SoundVolume(common.RoborockValueBase):
+class SoundVolume(RoborockBase):
     """Dataclass for sound volume."""
 
-    volume: int | None = field(default=None, metadata={"roborock_value": True})
+    volume: int | None = None
     """Sound volume level (0-100)."""
 
 
@@ -20,6 +17,7 @@ class SoundVolumeTrait(SoundVolume, common.V1TraitMixin):
     """Trait for controlling the sound volume of a Roborock device."""
 
     command = RoborockCommand.GET_SOUND_VOLUME
+    converter = common.SingleValueConverter(SoundVolume, "volume")
 
     async def set_volume(self, volume: int) -> None:
         """Set the sound volume of the device."""

{python_roborock-4.22.0 → python_roborock-4.23.0}/roborock/devices/traits/v1/wash_towel_mode.py

@@ -14,6 +14,7 @@ class WashTowelModeTrait(WashTowelMode, common.V1TraitMixin):
     """Trait for wash towel mode."""
 
     command = RoborockCommand.GET_WASH_TOWEL_MODE
+    converter = common.DefaultConverter(WashTowelMode)
     requires_dock_type = is_wash_n_fill_dock
 
     def __init__(