python-roborock 2.59.0__tar.gz → 2.61.0__tar.gz

{python_roborock-2.59.0 → python_roborock-2.61.0}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "python-roborock"
-version = "2.59.0"
+version = "2.61.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"
@@ -66,8 +66,8 @@ build-backend = "hatchling.build"
 
 [tool.semantic_release]
 branch = "main"
-version_toml = ["pyproject.toml:tool.poetry.version"]
-build_command = "pip install poetry && poetry build"
+version_toml = ["pyproject.toml:project.version"]
+build_command = "pip install uv && uv build"
 
 [tool.semantic_release.commit_parser_options]
 allowed_tags = [

{python_roborock-2.59.0 → python_roborock-2.61.0}/roborock/cli.py

@@ -119,6 +119,7 @@ class ConnectionCache(RoborockBase):
     home_data: HomeData | None = None
     network_info: dict[str, NetworkInfo] | None = None
     home_cache: dict[int, CombinedMapInfo] | None = None
+    trait_data: dict[str, Any] | None = None
 
 
 class DeviceConnectionManager:
@@ -267,6 +268,7 @@ class RoborockContext(Cache):
             home_data=connection_cache.home_data,
             network_info=connection_cache.network_info or {},
             home_cache=connection_cache.home_cache,
+            trait_data=connection_cache.trait_data or {},
         )
 
     async def set(self, value: CacheData) -> None:
@@ -276,6 +278,7 @@ class RoborockContext(Cache):
         connection_cache.home_data = value.home_data
         connection_cache.network_info = value.network_info
         connection_cache.home_cache = value.home_cache
+        connection_cache.trait_data = value.trait_data
         self.update(connection_cache)
 
 
@@ -401,9 +404,11 @@ async def _v1_trait(context: RoborockContext, device_id: str, display_func: Call
     device_manager = await context.get_device_manager()
     device = await device_manager.get_device(device_id)
     if device.v1_properties is None:
-        raise RoborockException(f"Device {device.name} does not support V1 protocol")
+        raise RoborockUnsupportedFeature(f"Device {device.name} does not support V1 protocol")
     await device.v1_properties.discover_features()
     trait = display_func(device.v1_properties)
+    if trait is None:
+        raise RoborockUnsupportedFeature("Trait not supported by device")
     await trait.refresh()
     return trait
 
@@ -440,6 +445,26 @@ async def clean_summary(ctx, device_id: str):
     await _display_v1_trait(context, device_id, lambda v1: v1.clean_summary)
 
 
+@session.command()
+@click.option("--device_id", required=True)
+@click.pass_context
+@async_command
+async def clean_record(ctx, device_id: str):
+    """Get device last clean record."""
+    context: RoborockContext = ctx.obj
+    await _display_v1_trait(context, device_id, lambda v1: v1.clean_record)
+
+
+@session.command()
+@click.option("--device_id", required=True)
+@click.pass_context
+@async_command
+async def dock_summary(ctx, device_id: str):
+    """Get device dock summary."""
+    context: RoborockContext = ctx.obj
+    await _display_v1_trait(context, device_id, lambda v1: v1.dock_summary)
+
+
 @session.command()
 @click.option("--device_id", required=True)
 @click.pass_context
@@ -938,6 +963,8 @@ cli.add_command(session)
 cli.add_command(get_device_info)
 cli.add_command(update_docs)
 cli.add_command(clean_summary)
+cli.add_command(clean_record)
+cli.add_command(dock_summary)
 cli.add_command(volume)
 cli.add_command(set_volume)
 cli.add_command(maps)

{python_roborock-2.59.0 → python_roborock-2.61.0}/roborock/device_features.py

@@ -4,7 +4,7 @@ from dataclasses import dataclass, field, fields
 from enum import IntEnum, StrEnum
 from typing import Any
 
-from .code_mappings import RoborockProductNickname
+from .code_mappings import RoborockDockTypeCode, RoborockProductNickname
 from .containers import RoborockBase
 
 
@@ -630,3 +630,25 @@ class DeviceFeatures(RoborockBase):
     def get_supported_features(self) -> list[str]:
         """Returns a list of supported features (Primarily used for logging purposes)."""
         return [k for k, v in vars(self).items() if v]
+
+
+WASH_N_FILL_DOCK_TYPES = [
+    RoborockDockTypeCode.empty_wash_fill_dock,
+    RoborockDockTypeCode.s8_dock,
+    RoborockDockTypeCode.p10_dock,
+    RoborockDockTypeCode.p10_pro_dock,
+    RoborockDockTypeCode.s8_maxv_ultra_dock,
+    RoborockDockTypeCode.qrevo_s_dock,
+    RoborockDockTypeCode.saros_r10_dock,
+    RoborockDockTypeCode.qrevo_curv_dock,
+]
+
+
+def is_wash_n_fill_dock(dock_type: RoborockDockTypeCode) -> bool:
+    """Check if the dock type is a wash and fill dock."""
+    return dock_type in WASH_N_FILL_DOCK_TYPES
+
+
+def is_valid_dock(dock_type: RoborockDockTypeCode) -> bool:
+    """Check if device supports a dock."""
+    return dock_type != RoborockDockTypeCode.no_dock

{python_roborock-2.59.0 → python_roborock-2.61.0}/roborock/devices/cache.py

@@ -6,7 +6,7 @@ this interface to provide their own caching mechanism.
 """
 
 from dataclasses import dataclass, field
-from typing import Protocol
+from typing import Any, Protocol
 
 from roborock.containers import CombinedMapInfo, HomeData, NetworkInfo
 from roborock.device_features import DeviceFeatures
@@ -28,6 +28,9 @@ class CacheData:
     device_features: DeviceFeatures | None = None
     """Device features information."""
 
+    trait_data: dict[str, Any] | None = None
+    """Trait-specific cached data used internally for caching device features."""
+
 
 class Cache(Protocol):
     """Protocol for a cache that can store and retrieve values."""

python_roborock-2.61.0/roborock/devices/traits/v1/__init__.py

@@ -0,0 +1,260 @@
+"""Create traits for V1 devices.
+
+Traits are modular components that encapsulate specific features of a Roborock
+device. This module provides a factory function to create and initialize the
+appropriate traits for V1 devices based on their capabilities. They can also
+be considered groups of commands and parsing logic for that command.
+
+Traits have a `refresh()` method that can be called to update their state
+from the device. Some traits may also provide additional methods for modifying
+the device state.
+
+The most common pattern for a trait is to subclass `V1TraitMixin` and a `RoborockBase`
+dataclass, and define a `command` class variable that specifies the `RoborockCommand`
+used to fetch the trait data from the device. See `common.py` for more details
+on common patterns used across traits.
+
+There are some additional decorators in `common.py` that can be used to specify which
+RPC channel to use for the trait (standard, MQTT/cloud, or map-specific).
+
+  - `@common.mqtt_rpc_channel` - Use the MQTT RPC channel for this trait.
+  - `@common.map_rpc_channel` - Use the map RPC channel for this trait.
+
+There are also some attributes that specify device feature dependencies for
+optional traits:
+
+    - `requires_feature` - The string name of the device feature that must be supported
+        for this trait to be enabled. See `DeviceFeaturesTrait` for a list of
+        available features.
+    - `requires_dock_type` - If set, this is a function that accepts a `RoborockDockTypeCode`
+        and returns a boolean indicating whether the trait is supported for that dock type.
+"""
+
+import logging
+from dataclasses import dataclass, field, fields
+from typing import Any, get_args
+
+from roborock.code_mappings import RoborockDockTypeCode
+from roborock.containers import HomeData, HomeDataProduct
+from roborock.devices.cache import Cache
+from roborock.devices.traits import Trait
+from roborock.devices.v1_rpc_channel import V1RpcChannel
+from roborock.map.map_parser import MapParserConfig
+
+from .child_lock import ChildLockTrait
+from .clean_record import CleanRecordTrait
+from .clean_summary import CleanSummaryTrait
+from .command import CommandTrait
+from .common import V1TraitMixin
+from .consumeable import ConsumableTrait
+from .device_features import DeviceFeaturesTrait
+from .do_not_disturb import DoNotDisturbTrait
+from .dust_collection_mode import DustCollectionModeTrait
+from .flow_led_status import FlowLedStatusTrait
+from .home import HomeTrait
+from .led_status import LedStatusTrait
+from .map_content import MapContentTrait
+from .maps import MapsTrait
+from .rooms import RoomsTrait
+from .smart_wash_params import SmartWashParamsTrait
+from .status import StatusTrait
+from .valley_electricity_timer import ValleyElectricityTimerTrait
+from .volume import SoundVolumeTrait
+from .wash_towel_mode import WashTowelModeTrait
+
+_LOGGER = logging.getLogger(__name__)
+
+__all__ = [
+    "create",
+    "PropertiesApi",
+    "StatusTrait",
+    "DoNotDisturbTrait",
+    "CleanSummaryTrait",
+    "CleanRecordTrait",
+    "SoundVolumeTrait",
+    "MapsTrait",
+    "MapContentTrait",
+    "ConsumableTrait",
+    "HomeTrait",
+    "DeviceFeaturesTrait",
+    "CommandTrait",
+    "ChildLockTrait",
+    "FlowLedStatusTrait",
+    "LedStatusTrait",
+    "ValleyElectricityTimerTrait",
+    "DustCollectionModeTrait",
+    "WashTowelModeTrait",
+    "SmartWashParamsTrait",
+]
+
+
+@dataclass
+class PropertiesApi(Trait):
+    """Common properties for V1 devices.
+
+    This class holds all the traits that are common across all V1 devices.
+    """
+
+    # All v1 devices have these traits
+    status: StatusTrait
+    command: CommandTrait
+    dnd: DoNotDisturbTrait
+    clean_summary: CleanSummaryTrait
+    clean_record: CleanRecordTrait
+    sound_volume: SoundVolumeTrait
+    rooms: RoomsTrait
+    maps: MapsTrait
+    map_content: MapContentTrait
+    consumables: ConsumableTrait
+    home: HomeTrait
+    device_features: DeviceFeaturesTrait
+
+    # Optional features that may not be supported on all devices
+    child_lock: ChildLockTrait | None = None
+    led_status: LedStatusTrait | None = None
+    flow_led_status: FlowLedStatusTrait | None = None
+    valley_electricity_timer: ValleyElectricityTimerTrait | None = None
+    dust_collection_mode: DustCollectionModeTrait | None = None
+    wash_towel_mode: WashTowelModeTrait | None = None
+    smart_wash_params: SmartWashParamsTrait | None = None
+
+    def __init__(
+        self,
+        product: HomeDataProduct,
+        home_data: HomeData,
+        rpc_channel: V1RpcChannel,
+        mqtt_rpc_channel: V1RpcChannel,
+        map_rpc_channel: V1RpcChannel,
+        cache: Cache,
+        map_parser_config: MapParserConfig | None = None,
+    ) -> None:
+        """Initialize the V1TraitProps."""
+        self._rpc_channel = rpc_channel
+        self._mqtt_rpc_channel = mqtt_rpc_channel
+        self._map_rpc_channel = map_rpc_channel
+        self._cache = cache
+
+        self.status = StatusTrait(product)
+        self.clean_summary = CleanSummaryTrait()
+        self.clean_record = CleanRecordTrait(self.clean_summary)
+        self.consumables = ConsumableTrait()
+        self.rooms = RoomsTrait(home_data)
+        self.maps = MapsTrait(self.status)
+        self.map_content = MapContentTrait(map_parser_config)
+        self.home = HomeTrait(self.status, self.maps, self.rooms, cache)
+        self.device_features = DeviceFeaturesTrait(product.product_nickname, cache)
+
+        # Dynamically create any traits that need to be populated
+        for item in fields(self):
+            if (trait := getattr(self, item.name, None)) is None:
+                # We exclude optional features and them via discover_features
+                if (union_args := get_args(item.type)) is None or len(union_args) > 0:
+                    continue
+                _LOGGER.debug("Trait '%s' is supported, initializing", item.name)
+                trait = item.type()
+                setattr(self, item.name, trait)
+            # This is a hack to allow setting the rpc_channel on all traits. This is
+            # used so we can preserve the dataclass behavior when the values in the
+            # traits are updated, but still want to allow them to have a reference
+            # to the rpc channel for sending commands.
+            trait._rpc_channel = self._get_rpc_channel(trait)
+
+    def _get_rpc_channel(self, trait: V1TraitMixin) -> V1RpcChannel:
+        # The decorator `@common.mqtt_rpc_channel` means that the trait needs
+        # to use the mqtt_rpc_channel (cloud only) instead of the rpc_channel (adaptive)
+        if hasattr(trait, "mqtt_rpc_channel"):
+            return self._mqtt_rpc_channel
+        elif hasattr(trait, "map_rpc_channel"):
+            return self._map_rpc_channel
+        else:
+            return self._rpc_channel
+
+    async def discover_features(self) -> None:
+        """Populate any supported traits that were not initialized in __init__."""
+        _LOGGER.debug("Starting optional trait discovery")
+        await self.device_features.refresh()
+        # Dock type also acts like a device feature for some traits.
+        dock_type = await self._dock_type()
+
+        # Dynamically create any traits that need to be populated
+        for item in fields(self):
+            if (trait := getattr(self, item.name, None)) is not None:
+                continue
+            if (union_args := get_args(item.type)) is None:
+                raise ValueError(f"Unexpected non-union type for trait {item.name}: {item.type}")
+            if len(union_args) != 2 or type(None) not in union_args:
+                raise ValueError(f"Unexpected non-optional type for trait {item.name}: {item.type}")
+
+            # Union args may not be in declared order
+            item_type = union_args[0] if union_args[1] is type(None) else union_args[1]
+            if not self._is_supported(item_type, item.name, dock_type):
+                _LOGGER.debug("Trait '%s' not supported, skipping", item.name)
+                continue
+            _LOGGER.debug("Trait '%s' is supported, initializing", item.name)
+            trait = item_type()
+            setattr(self, item.name, trait)
+            trait._rpc_channel = self._get_rpc_channel(trait)
+
+    def _is_supported(self, trait_type: type[V1TraitMixin], name: str, dock_type: RoborockDockTypeCode) -> bool:
+        """Check if a trait is supported by the device."""
+
+        if (requires_dock_type := getattr(trait_type, "requires_dock_type", None)) is not None:
+            return requires_dock_type(dock_type)
+
+        if (feature_name := getattr(trait_type, "requires_feature", None)) is None:
+            _LOGGER.debug("Optional trait missing 'requires_feature' attribute %s, skipping", name)
+            return False
+        if (is_supported := getattr(self.device_features, feature_name)) is None:
+            raise ValueError(f"Device feature '{feature_name}' on trait '{name}' is unknown")
+        return is_supported
+
+    async def _dock_type(self) -> RoborockDockTypeCode:
+        """Get the dock type from the status trait or cache."""
+        dock_type = await self._get_cached_trait_data("dock_type")
+        if dock_type is not None:
+            _LOGGER.debug("Using cached dock type: %s", dock_type)
+            try:
+                return RoborockDockTypeCode(dock_type)
+            except ValueError:
+                _LOGGER.debug("Cached dock type %s is invalid, refreshing", dock_type)
+
+        _LOGGER.debug("Starting dock type discovery")
+        await self.status.refresh()
+        _LOGGER.debug("Fetched dock type: %s", self.status.dock_type)
+        if self.status.dock_type is None:
+            # Explicitly set so we reuse cached value next type
+            dock_type = RoborockDockTypeCode.no_dock
+        else:
+            dock_type = self.status.dock_type
+        await self._set_cached_trait_data("dock_type", dock_type)
+        return dock_type
+
+    async def _get_cached_trait_data(self, name: str) -> Any:
+        """Get the dock type from the status trait or cache."""
+        cache_data = await self._cache.get()
+        if cache_data.trait_data is None:
+            cache_data.trait_data = {}
+        _LOGGER.debug("Cached trait data: %s", cache_data.trait_data)
+        return cache_data.trait_data.get(name)
+
+    async def _set_cached_trait_data(self, name: str, value: Any) -> None:
+        """Set trait-specific cached data."""
+        cache_data = await self._cache.get()
+        if cache_data.trait_data is None:
+            cache_data.trait_data = {}
+        cache_data.trait_data[name] = value
+        _LOGGER.debug("Updating cached trait data: %s", cache_data.trait_data)
+        await self._cache.set(cache_data)
+
+
+def create(
+    product: HomeDataProduct,
+    home_data: HomeData,
+    rpc_channel: V1RpcChannel,
+    mqtt_rpc_channel: V1RpcChannel,
+    map_rpc_channel: V1RpcChannel,
+    cache: Cache,
+    map_parser_config: MapParserConfig | None = None,
+) -> PropertiesApi:
+    """Create traits for V1 devices."""
+    return PropertiesApi(product, home_data, rpc_channel, mqtt_rpc_channel, map_rpc_channel, cache, map_parser_config)

{python_roborock-2.59.0 → python_roborock-2.61.0}/roborock/devices/traits/v1/child_lock.py

@@ -5,12 +5,17 @@ from roborock.roborock_typing import RoborockCommand
 _STATUS_PARAM = "lock_status"
 
 
-class ChildLockTrait(ChildLockStatus, common.V1TraitMixin):
+class ChildLockTrait(ChildLockStatus, common.V1TraitMixin, common.RoborockSwitchBase):
     """Trait for controlling the child lock of a Roborock device."""
 
     command = RoborockCommand.GET_CHILD_LOCK_STATUS
     requires_feature = "is_set_child_supported"
 
+    @property
+    def is_on(self) -> bool:
+        """Return whether the child lock is enabled."""
+        return self.lock_status == 1
+
     async def enable(self) -> None:
         """Enable the child lock."""
         await self.rpc_channel.send_command(RoborockCommand.SET_CHILD_LOCK_STATUS, params={_STATUS_PARAM: 1})

python_roborock-2.61.0/roborock/devices/traits/v1/clean_record.py

@@ -0,0 +1,69 @@
+"""Trait for getting the last clean record."""
+
+import logging
+from typing import Self
+
+from roborock.containers import CleanRecord
+from roborock.devices.traits.v1 import common
+from roborock.roborock_typing import RoborockCommand
+from roborock.util import unpack_list
+
+from .clean_summary import CleanSummaryTrait
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class CleanRecordTrait(CleanRecord, common.V1TraitMixin):
+    """Trait for getting the last clean record."""
+
+    command = RoborockCommand.GET_CLEAN_RECORD
+
+    def __init__(self, clean_summary_trait: CleanSummaryTrait) -> None:
+        """Initialize the clean record trait."""
+        super().__init__()
+        self._clean_summary_trait = clean_summary_trait
+
+    async def refresh(self) -> Self:
+        """Get the last clean record.
+
+        Assumes that the clean summary has already been fetched.
+        """
+        if not self._clean_summary_trait.records:
+            _LOGGER.debug("No clean records available in clean summary.")
+            return self
+        last_record_id = self._clean_summary_trait.records[-1]
+        response = await self.rpc_channel.send_command(self.command, params=[last_record_id])
+        new_self = self._parse_response(response)
+        self._update_trait_values(new_self)
+        return self
+
+    @classmethod
+    def _parse_type_response(cls, response: common.V1ResponseData) -> CleanRecord:
+        """Parse the response from the device into a CleanRecord."""
+        if isinstance(response, dict):
+            return CleanRecord.from_dict(response)
+        if isinstance(response, list):
+            if isinstance(response[-1], dict):
+                records = [CleanRecord.from_dict(rec) for rec in response]
+                final_record = records[-1]
+                try:
+                    # This code is semi-presumptions - so it is put in a try finally to be safe.
+                    final_record.begin = records[0].begin
+                    final_record.begin_datetime = records[0].begin_datetime
+                    final_record.start_type = records[0].start_type
+                    for rec in records[0:-1]:
+                        final_record.duration = (final_record.duration or 0) + (rec.duration or 0)
+                        final_record.area = (final_record.area or 0) + (rec.area or 0)
+                        final_record.avoid_count = (final_record.avoid_count or 0) + (rec.avoid_count or 0)
+                        final_record.wash_count = (final_record.wash_count or 0) + (rec.wash_count or 0)
+                        final_record.square_meter_area = (final_record.square_meter_area or 0) + (
+                            rec.square_meter_area or 0
+                        )
+                    return final_record
+                except Exception:
+                    # Return final record when an exception occurred
+                    return final_record
+            # There are still a few unknown variables in this.
+            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}")

{python_roborock-2.59.0 → python_roborock-2.61.0}/roborock/devices/traits/v1/common.py

@@ -4,7 +4,7 @@ This is an internal library and should not be used directly by consumers.
 """
 
 import logging
-from abc import ABC
+from abc import ABC, abstractmethod
 from dataclasses import dataclass, fields
 from typing import ClassVar, Self
 
@@ -82,6 +82,7 @@ class V1TraitMixin(ABC):
         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)
         return self
 
@@ -124,6 +125,23 @@ class RoborockValueBase(V1TraitMixin, RoborockBase):
         return cls(**{value_field: response})
 
 
+class RoborockSwitchBase(ABC):
+    """Base class for traits that represent a boolean switch."""
+
+    @property
+    @abstractmethod
+    def is_on(self) -> bool:
+        """Return whether the switch is on."""
+
+    @abstractmethod
+    async def enable(self) -> None:
+        """Enable the switch."""
+
+    @abstractmethod
+    async def disable(self) -> None:
+        """Disable the switch."""
+
+
 def mqtt_rpc_channel(cls):
     """Decorator to mark a function as cloud only.
 

{python_roborock-2.59.0 → python_roborock-2.61.0}/roborock/devices/traits/v1/do_not_disturb.py

@@ -5,11 +5,16 @@ from roborock.roborock_typing import RoborockCommand
 _ENABLED_PARAM = "enabled"
 
 
-class DoNotDisturbTrait(DnDTimer, common.V1TraitMixin):
+class DoNotDisturbTrait(DnDTimer, common.V1TraitMixin, common.RoborockSwitchBase):
     """Trait for managing Do Not Disturb (DND) settings on Roborock devices."""
 
     command = RoborockCommand.GET_DND_TIMER
 
+    @property
+    def is_on(self) -> bool:
+        """Return whether the Do Not Disturb (DND) timer is enabled."""
+        return self.enabled == 1
+
     async def set_dnd_timer(self, dnd_timer: DnDTimer) -> None:
         """Set the Do Not Disturb (DND) timer settings of the device."""
         await self.rpc_channel.send_command(RoborockCommand.SET_DND_TIMER, params=dnd_timer.as_dict())

python_roborock-2.61.0/roborock/devices/traits/v1/dust_collection_mode.py

@@ -0,0 +1,13 @@
+"""Trait for dust collection mode."""
+
+from roborock.containers import DustCollectionMode
+from roborock.device_features import is_valid_dock
+from roborock.devices.traits.v1 import common
+from roborock.roborock_typing import RoborockCommand
+
+
+class DustCollectionModeTrait(DustCollectionMode, common.V1TraitMixin):
+    """Trait for dust collection mode."""
+
+    command = RoborockCommand.GET_DUST_COLLECTION_MODE
+    requires_dock_type = is_valid_dock

{python_roborock-2.59.0 → python_roborock-2.61.0}/roborock/devices/traits/v1/flow_led_status.py

@@ -5,12 +5,17 @@ from roborock.roborock_typing import RoborockCommand
 _STATUS_PARAM = "status"
 
 
-class FlowLedStatusTrait(FlowLedStatus, common.V1TraitMixin):
+class FlowLedStatusTrait(FlowLedStatus, common.V1TraitMixin, common.RoborockSwitchBase):
     """Trait for controlling the Flow LED status of a Roborock device."""
 
     command = RoborockCommand.GET_FLOW_LED_STATUS
     requires_feature = "is_flow_led_setting_supported"
 
+    @property
+    def is_on(self) -> bool:
+        """Return whether the Flow LED status is enabled."""
+        return self.status == 1
+
     async def enable(self) -> None:
         """Enable the Flow LED status."""
         await self.rpc_channel.send_command(RoborockCommand.SET_FLOW_LED_STATUS, params={_STATUS_PARAM: 1})

{python_roborock-2.59.0 → python_roborock-2.61.0}/roborock/devices/traits/v1/led_status.py

@@ -5,12 +5,17 @@ from roborock.roborock_typing import RoborockCommand
 from .common import V1ResponseData
 
 
-class LedStatusTrait(LedStatus, common.V1TraitMixin):
+class LedStatusTrait(LedStatus, common.V1TraitMixin, common.RoborockSwitchBase):
     """Trait for controlling the LED status of a Roborock device."""
 
     command = RoborockCommand.GET_LED_STATUS
     requires_feature = "is_led_status_switch_supported"
 
+    @property
+    def is_on(self) -> bool:
+        """Return whether the LED status is enabled."""
+        return self.status == 1
+
     async def enable(self) -> None:
         """Enable the LED status."""
         await self.rpc_channel.send_command(RoborockCommand.SET_LED_STATUS, params=[1])

python_roborock-2.61.0/roborock/devices/traits/v1/smart_wash_params.py

@@ -0,0 +1,13 @@
+"""Trait for smart wash parameters."""
+
+from roborock.containers import SmartWashParams
+from roborock.device_features import is_wash_n_fill_dock
+from roborock.devices.traits.v1 import common
+from roborock.roborock_typing import RoborockCommand
+
+
+class SmartWashParamsTrait(SmartWashParams, common.V1TraitMixin):
+    """Trait for smart wash parameters."""
+
+    command = RoborockCommand.GET_SMART_WASH_PARAMS
+    requires_dock_type = is_wash_n_fill_dock

{python_roborock-2.59.0 → python_roborock-2.61.0}/roborock/devices/traits/v1/valley_electricity_timer.py

@@ -11,6 +11,11 @@ class ValleyElectricityTimerTrait(ValleyElectricityTimer, common.V1TraitMixin):
     command = RoborockCommand.GET_VALLEY_ELECTRICITY_TIMER
     requires_feature = "is_supported_valley_electricity"
 
+    @property
+    def is_on(self) -> bool:
+        """Return whether the Valley Electricity Timer is enabled."""
+        return self.enabled == 1
+
     async def set_timer(self, timer: ValleyElectricityTimer) -> None:
         """Set the Valley Electricity Timer settings of the device."""
         await self.rpc_channel.send_command(RoborockCommand.SET_VALLEY_ELECTRICITY_TIMER, params=timer.as_dict())

python_roborock-2.61.0/roborock/devices/traits/v1/wash_towel_mode.py

@@ -0,0 +1,13 @@
+"""Trait for wash towel mode."""
+
+from roborock.containers import WashTowelMode
+from roborock.device_features import is_wash_n_fill_dock
+from roborock.devices.traits.v1 import common
+from roborock.roborock_typing import RoborockCommand
+
+
+class WashTowelModeTrait(WashTowelMode, common.V1TraitMixin):
+    """Trait for wash towel mode."""
+
+    command = RoborockCommand.GET_WASH_TOWEL_MODE
+    requires_dock_type = is_wash_n_fill_dock

{python_roborock-2.59.0 → python_roborock-2.61.0}/roborock/devices/v1_channel.py

@@ -123,10 +123,18 @@ class V1Channel(Channel):
     async def subscribe(self, callback: Callable[[RoborockMessage], None]) -> Callable[[], None]:
         """Subscribe to all messages from the device.
 
-        This will establish MQTT connection first, and also attempt to set up
-        local connection if possible. Any failures to subscribe to MQTT will raise
-        a RoborockException. A local connection failure will not raise an exception,
-        since the local connection is optional.
+        This will first attempt to establish a local connection to the device
+        using cached network information if available. If that fails, it will
+        fall back to using the MQTT connection.
+
+        A background task will be started to monitor and maintain the local
+        connection, attempting to reconnect as needed.
+
+        Args:
+            callback: Callback to invoke for each received message.
+
+        Returns:
+            Unsubscribe function to stop receiving messages and clean up resources.
         """
         if self._callback is not None:
             raise ValueError("Only one subscription allowed at a time")

{python_roborock-2.59.0 → python_roborock-2.61.0}/roborock/version_1_apis/roborock_client_v1.py

@@ -45,6 +45,7 @@ from roborock.containers import (
     ValleyElectricityTimer,
     WashTowelMode,
 )
+from roborock.device_features import WASH_N_FILL_DOCK_TYPES
 from roborock.protocols.v1_protocol import MapResponse, SecurityData, create_map_response_decoder
 from roborock.roborock_message import (
     ROBOROCK_DATA_CONSUMABLE_PROTOCOL,
@@ -64,16 +65,6 @@ COMMANDS_SECURED = {
 
 CLOUD_REQUIRED = COMMANDS_SECURED.union(CUSTOM_COMMANDS)
 
-WASH_N_FILL_DOCK = [
-    RoborockDockTypeCode.empty_wash_fill_dock,
-    RoborockDockTypeCode.s8_dock,
-    RoborockDockTypeCode.p10_dock,
-    RoborockDockTypeCode.p10_pro_dock,
-    RoborockDockTypeCode.s8_maxv_ultra_dock,
-    RoborockDockTypeCode.qrevo_s_dock,
-    RoborockDockTypeCode.saros_r10_dock,
-    RoborockDockTypeCode.qrevo_curv_dock,
-]
 RT = TypeVar("RT", bound=RoborockBase)
 EVICT_TIME = 60
 
@@ -264,7 +255,7 @@ class RoborockClientV1(RoborockClient, ABC):
                 DustCollectionMode | WashTowelMode | SmartWashParams | None,
             ]
         ] = [self.get_dust_collection_mode()]
-        if dock_type in WASH_N_FILL_DOCK:
+        if dock_type in WASH_N_FILL_DOCK_TYPES:
             commands += [
                 self.get_wash_towel_mode(),
                 self.get_smart_wash_params(),

python_roborock-2.59.0/roborock/devices/traits/v1/__init__.py

@@ -1,163 +0,0 @@
-"""Create traits for V1 devices."""
-
-import logging
-from dataclasses import dataclass, field, fields
-from typing import get_args
-
-from roborock.containers import HomeData, HomeDataProduct
-from roborock.devices.cache import Cache
-from roborock.devices.traits import Trait
-from roborock.devices.v1_rpc_channel import V1RpcChannel
-from roborock.map.map_parser import MapParserConfig
-
-from .child_lock import ChildLockTrait
-from .clean_summary import CleanSummaryTrait
-from .command import CommandTrait
-from .common import V1TraitMixin
-from .consumeable import ConsumableTrait
-from .device_features import DeviceFeaturesTrait
-from .do_not_disturb import DoNotDisturbTrait
-from .flow_led_status import FlowLedStatusTrait
-from .home import HomeTrait
-from .led_status import LedStatusTrait
-from .map_content import MapContentTrait
-from .maps import MapsTrait
-from .rooms import RoomsTrait
-from .status import StatusTrait
-from .volume import SoundVolumeTrait
-
-_LOGGER = logging.getLogger(__name__)
-
-__all__ = [
-    "create",
-    "PropertiesApi",
-    "StatusTrait",
-    "DoNotDisturbTrait",
-    "CleanSummaryTrait",
-    "SoundVolumeTrait",
-    "MapsTrait",
-    "MapContentTrait",
-    "ConsumableTrait",
-    "HomeTrait",
-    "DeviceFeaturesTrait",
-    "CommandTrait",
-    "ChildLockTrait",
-    "FlowLedStatusTrait",
-    "LedStatusTrait",
-]
-
-
-@dataclass
-class PropertiesApi(Trait):
-    """Common properties for V1 devices.
-
-    This class holds all the traits that are common across all V1 devices.
-    """
-
-    # All v1 devices have these traits
-    status: StatusTrait
-    command: CommandTrait
-    dnd: DoNotDisturbTrait
-    clean_summary: CleanSummaryTrait
-    sound_volume: SoundVolumeTrait
-    rooms: RoomsTrait
-    maps: MapsTrait
-    map_content: MapContentTrait
-    consumables: ConsumableTrait
-    home: HomeTrait
-    device_features: DeviceFeaturesTrait
-
-    # Optional features that may not be supported on all devices
-    child_lock: ChildLockTrait | None = None
-    led_status: LedStatusTrait | None = None
-    flow_led_status: FlowLedStatusTrait | None = None
-
-    def __init__(
-        self,
-        product: HomeDataProduct,
-        home_data: HomeData,
-        rpc_channel: V1RpcChannel,
-        mqtt_rpc_channel: V1RpcChannel,
-        map_rpc_channel: V1RpcChannel,
-        cache: Cache,
-        map_parser_config: MapParserConfig | None = None,
-    ) -> None:
-        """Initialize the V1TraitProps."""
-        self._rpc_channel = rpc_channel
-        self._mqtt_rpc_channel = mqtt_rpc_channel
-        self._map_rpc_channel = map_rpc_channel
-
-        self.status = StatusTrait(product)
-        self.rooms = RoomsTrait(home_data)
-        self.maps = MapsTrait(self.status)
-        self.map_content = MapContentTrait(map_parser_config)
-        self.home = HomeTrait(self.status, self.maps, self.rooms, cache)
-        self.device_features = DeviceFeaturesTrait(product.product_nickname, cache)
-
-        # Dynamically create any traits that need to be populated
-        for item in fields(self):
-            if (trait := getattr(self, item.name, None)) is None:
-                # We exclude optional features and them via discover_features
-                if (union_args := get_args(item.type)) is None or len(union_args) > 0:
-                    continue
-                _LOGGER.debug("Initializing trait %s", item.name)
-                trait = item.type()
-                setattr(self, item.name, trait)
-            # This is a hack to allow setting the rpc_channel on all traits. This is
-            # used so we can preserve the dataclass behavior when the values in the
-            # traits are updated, but still want to allow them to have a reference
-            # to the rpc channel for sending commands.
-            trait._rpc_channel = self._get_rpc_channel(trait)
-
-    def _get_rpc_channel(self, trait: V1TraitMixin) -> V1RpcChannel:
-        # The decorator `@common.mqtt_rpc_channel` means that the trait needs
-        # to use the mqtt_rpc_channel (cloud only) instead of the rpc_channel (adaptive)
-        if hasattr(trait, "mqtt_rpc_channel"):
-            return self._mqtt_rpc_channel
-        elif hasattr(trait, "map_rpc_channel"):
-            return self._map_rpc_channel
-        else:
-            return self._rpc_channel
-
-    async def discover_features(self) -> None:
-        """Populate any supported traits that were not initialized in __init__."""
-        await self.device_features.refresh()
-
-        for item in fields(self):
-            if (trait := getattr(self, item.name, None)) is not None:
-                continue
-            if (union_args := get_args(item.type)) is None:
-                raise ValueError(f"Unexpected non-union type for trait {item.name}: {item.type}")
-            if len(union_args) != 2 or type(None) not in union_args:
-                raise ValueError(f"Unexpected non-optional type for trait {item.name}: {item.type}")
-
-            # Union args may not be in declared order
-            item_type = union_args[0] if union_args[1] is type(None) else union_args[1]
-            trait = item_type()
-            if not hasattr(trait, "requires_feature"):
-                _LOGGER.debug("Trait missing required feature %s", item.name)
-                continue
-            _LOGGER.debug("Checking for feature %s", trait.requires_feature)
-            is_supported = getattr(self.device_features, trait.requires_feature)
-            # _LOGGER.debug("Device features: %s", self.device_features)
-            if is_supported is None:
-                raise ValueError(f"Device feature '{trait.requires_feature}' on trait '{item.name}' is unknown")
-            if not is_supported:
-                _LOGGER.debug("Disabling optional feature trait %s", item.name)
-                continue
-            _LOGGER.debug("Enabling optional feature trait %s", item.name)
-            setattr(self, item.name, trait)
-            trait._rpc_channel = self._get_rpc_channel(trait)
-
-
-def create(
-    product: HomeDataProduct,
-    home_data: HomeData,
-    rpc_channel: V1RpcChannel,
-    mqtt_rpc_channel: V1RpcChannel,
-    map_rpc_channel: V1RpcChannel,
-    cache: Cache,
-    map_parser_config: MapParserConfig | None = None,
-) -> PropertiesApi:
-    """Create traits for V1 devices."""
-    return PropertiesApi(product, home_data, rpc_channel, mqtt_rpc_channel, map_rpc_channel, cache, map_parser_config)