python-roborock 2.46.0__tar.gz → 2.47.0__tar.gz

{python_roborock-2.46.0 → python_roborock-2.47.0}/PKG-INFO

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

{python_roborock-2.46.0 → python_roborock-2.47.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-roborock"
-version = "2.46.0"
+version = "2.47.0"
 description = "A package to control Roborock vacuums."
 authors = ["humbertogontijo <humbertogontijo@users.noreply.github.com>"]
 license = "GPL-3.0-only"

{python_roborock-2.46.0 → python_roborock-2.47.0}/roborock/api.py

@@ -18,7 +18,6 @@ from .exceptions import (
 from .roborock_future import RoborockFuture
 from .roborock_message import (
     RoborockMessage,
-    RoborockMessageProtocol,
 )
 from .util import get_next_int
 
@@ -91,9 +90,7 @@ class RoborockClient(ABC):
 
     def _async_response(self, request_id: int, protocol_id: int = 0) -> Any:
         queue = RoborockFuture(protocol_id)
-        if request_id in self._waiting_queue and not (
-            request_id == 2 and protocol_id == RoborockMessageProtocol.PING_REQUEST
-        ):
+        if request_id in self._waiting_queue:
             new_id = get_next_int(10000, 32767)
             self._logger.warning(
                 "Attempting to create a future with an existing id %s (%s)... New id is %s. "

{python_roborock-2.46.0 → python_roborock-2.47.0}/roborock/cli.py

@@ -27,6 +27,7 @@ import functools
 import json
 import logging
 import threading
+from collections.abc import Callable
 from dataclasses import asdict, dataclass
 from pathlib import Path
 from typing import Any, cast
@@ -43,6 +44,8 @@ from roborock.containers import DeviceData, HomeData, NetworkInfo, RoborockBase,
 from roborock.devices.cache import Cache, CacheData
 from roborock.devices.device import RoborockDevice
 from roborock.devices.device_manager import DeviceManager, create_device_manager, create_home_data_api
+from roborock.devices.traits import Trait
+from roborock.devices.traits.v1 import V1TraitMixin
 from roborock.protocol import MessageParser
 from roborock.version_1_apis.roborock_mqtt_client_v1 import RoborockMqttClientV1
 from roborock.web_api import RoborockApiClient
@@ -377,6 +380,22 @@ async def execute_scene(ctx, scene_id):
     await client.execute_scene(cache_data.user_data, scene_id)
 
 
+async def _v1_trait(context: RoborockContext, device_id: str, display_func: Callable[[], V1TraitMixin]) -> Trait:
+    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")
+
+    trait = display_func(device.v1_properties)
+    await trait.refresh()
+    return trait
+
+
+async def _display_v1_trait(context: RoborockContext, device_id: str, display_func: Callable[[], Trait]) -> None:
+    trait = await _v1_trait(context, device_id, display_func)
+    click.echo(dump_json(trait.as_dict()))
+
+
 @session.command()
 @click.option("--device_id", required=True)
 @click.pass_context
@@ -384,16 +403,7 @@ async def execute_scene(ctx, scene_id):
 async def status(ctx, device_id: str):
     """Get device status."""
     context: RoborockContext = ctx.obj
-
-    device_manager = await context.get_device_manager()
-    device = await device_manager.get_device(device_id)
-
-    if not (status_trait := device.traits.get("status")):
-        click.echo(f"Device {device.name} does not have a status trait")
-        return
-
-    status_result = await status_trait.get_status()
-    click.echo(dump_json(status_result.as_dict()))
+    await _display_v1_trait(context, device_id, lambda v1: v1.status)
 
 
 @session.command()
@@ -403,15 +413,7 @@ async def status(ctx, device_id: str):
 async def clean_summary(ctx, device_id: str):
     """Get device clean summary."""
     context: RoborockContext = ctx.obj
-
-    device_manager = await context.get_device_manager()
-    device = await device_manager.get_device(device_id)
-    if not (clean_summary_trait := device.traits.get("clean_summary")):
-        click.echo(f"Device {device.name} does not have a clean summary trait")
-        return
-
-    clean_summary_result = await clean_summary_trait.get_clean_summary()
-    click.echo(dump_json(clean_summary_result.as_dict()))
+    await _display_v1_trait(context, device_id, lambda v1: v1.clean_summary)
 
 
 @session.command()
@@ -421,17 +423,7 @@ async def clean_summary(ctx, device_id: str):
 async def volume(ctx, device_id: str):
     """Get device volume."""
     context: RoborockContext = ctx.obj
-
-    device_manager = await context.get_device_manager()
-    device = await device_manager.get_device(device_id)
-
-    if not (volume_trait := device.traits.get("sound_volume")):
-        click.echo(f"Device {device.name} does not have a volume trait")
-        return
-
-    volume_result = await volume_trait.get_volume()
-    click.echo(f"Device {device_id} volume:")
-    click.echo(volume_result)
+    await _display_v1_trait(context, device_id, lambda v1: v1.sound_volume)
 
 
 @session.command()
@@ -442,14 +434,7 @@ async def volume(ctx, device_id: str):
 async def set_volume(ctx, device_id: str, volume: int):
     """Set the devicevolume."""
     context: RoborockContext = ctx.obj
-
-    device_manager = await context.get_device_manager()
-    device = await device_manager.get_device(device_id)
-
-    if not (volume_trait := device.traits.get("sound_volume")):
-        click.echo(f"Device {device.name} does not have a volume trait")
-        return
-
+    volume_trait = await _v1_trait(context, device_id, lambda v1: v1.sound_volume)
     await volume_trait.set_volume(volume)
     click.echo(f"Set Device {device_id} volume to {volume}")
 

{python_roborock-2.46.0 → python_roborock-2.47.0}/roborock/devices/device.py

@@ -6,14 +6,14 @@ until the API is stable.
 
 import logging
 from abc import ABC
-from collections.abc import Callable, Mapping
-from types import MappingProxyType
+from collections.abc import Callable
 
 from roborock.containers import HomeDataDevice
 from roborock.roborock_message import RoborockMessage
 
 from .channel import Channel
-from .traits.trait import Trait
+from .traits import Trait
+from .traits.traits_mixin import TraitsMixin
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -22,19 +22,23 @@ __all__ = [
 ]
 
 
-class RoborockDevice(ABC):
+class RoborockDevice(ABC, TraitsMixin):
     """A generic channel for establishing a connection with a Roborock device.
 
     Individual channel implementations have their own methods for speaking to
     the device that hide some of the protocol specific complexity, but they
     are still specialized for the device type and protocol.
+
+    Attributes of the device are exposed through traits, which are mixed in
+    through the TraitsMixin class. Traits are optional and may not be present
+    on all devices.
     """
 
     def __init__(
         self,
         device_info: HomeDataDevice,
         channel: Channel,
-        traits: list[Trait],
+        trait: Trait,
     ) -> None:
         """Initialize the RoborockDevice.
 
@@ -42,13 +46,11 @@ class RoborockDevice(ABC):
         Use `connect()` to establish the connection, which will set up the appropriate
         protocol channel. Use `close()` to clean up all connections.
         """
+        TraitsMixin.__init__(self, trait)
         self._duid = device_info.duid
         self._name = device_info.name
         self._channel = channel
         self._unsub: Callable[[], None] | None = None
-        self._trait_map = {trait.name: trait for trait in traits}
-        if len(self._trait_map) != len(traits):
-            raise ValueError("Duplicate trait names found in traits list")
 
     @property
     def duid(self) -> str:
@@ -81,8 +83,3 @@ class RoborockDevice(ABC):
     def _on_message(self, message: RoborockMessage) -> None:
         """Handle incoming messages from the device."""
         _LOGGER.debug("Received message from device: %s", message)
-
-    @property
-    def traits(self) -> Mapping[str, Trait]:
-        """Return the traits of the device."""
-        return MappingProxyType(self._trait_map)

{python_roborock-2.46.0 → python_roborock-2.47.0}/roborock/devices/device_manager.py

@@ -7,7 +7,6 @@ from collections.abc import Awaitable, Callable
 
 import aiohttp
 
-from roborock.code_mappings import RoborockCategory
 from roborock.containers import (
     HomeData,
     HomeDataDevice,
@@ -23,14 +22,7 @@ from roborock.web_api import RoborockApiClient
 from .cache import Cache, NoCache
 from .channel import Channel
 from .mqtt_channel import create_mqtt_channel
-from .traits.b01.props import B01PropsApi
-from .traits.clean_summary import CleanSummaryTrait
-from .traits.dnd import DoNotDisturbTrait
-from .traits.dyad import DyadApi
-from .traits.sound_volume import SoundVolumeTrait
-from .traits.status import StatusTrait
-from .traits.trait import Trait
-from .traits.zeo import ZeoApi
+from .traits import Trait, a01, b01, v1
 from .v1_channel import create_v1_channel
 
 _LOGGER = logging.getLogger(__name__)
@@ -153,30 +145,20 @@ async def create_device_manager(
 
     def device_creator(device: HomeDataDevice, product: HomeDataProduct) -> RoborockDevice:
         channel: Channel
-        traits: list[Trait] = []
-        # TODO: Define a registration mechanism/factory for v1 traits
+        trait: Trait
         match device.pv:
             case DeviceVersion.V1:
                 channel = create_v1_channel(user_data, mqtt_params, mqtt_session, device, cache)
-                traits.append(StatusTrait(product, channel.rpc_channel))
-                traits.append(DoNotDisturbTrait(channel.rpc_channel))
-                traits.append(CleanSummaryTrait(channel.rpc_channel))
-                traits.append(SoundVolumeTrait(channel.rpc_channel))
+                trait = v1.create(product, channel.rpc_channel)
             case DeviceVersion.A01:
-                mqtt_channel = create_mqtt_channel(user_data, mqtt_params, mqtt_session, device)
-                match product.category:
-                    case RoborockCategory.WET_DRY_VAC:
-                        traits.append(DyadApi(mqtt_channel))
-                    case RoborockCategory.WASHING_MACHINE:
-                        traits.append(ZeoApi(mqtt_channel))
-                    case _:
-                        raise NotImplementedError(f"Device {device.name} has unsupported category {product.category}")
+                channel = create_mqtt_channel(user_data, mqtt_params, mqtt_session, device)
+                trait = a01.create(product, channel)
             case DeviceVersion.B01:
                 channel = create_mqtt_channel(user_data, mqtt_params, mqtt_session, device)
-                traits.append(B01PropsApi(channel))
+                trait = b01.create(channel)
             case _:
                 raise NotImplementedError(f"Device {device.name} has unsupported version {device.pv}")
-        return RoborockDevice(device, channel, traits)
+        return RoborockDevice(device, channel, trait)
 
     manager = DeviceManager(home_data_api, device_creator, mqtt_session=mqtt_session, cache=cache)
     await manager.discover_devices()

python_roborock-2.47.0/roborock/devices/traits/__init__.py

@@ -0,0 +1,15 @@
+"""Module for device traits."""
+
+from abc import ABC
+
+__all__ = [
+    "Trait",
+    "traits_mixin",
+    "v1",
+    "a01",
+    "b01",
+]
+
+
+class Trait(ABC):
+    """Base class for all traits."""

python_roborock-2.47.0/roborock/devices/traits/a01/__init__.py

@@ -0,0 +1,61 @@
+from typing import Any
+
+from roborock.containers import HomeDataProduct, RoborockCategory
+from roborock.devices.a01_channel import send_decoded_command
+from roborock.devices.mqtt_channel import MqttChannel
+from roborock.devices.traits import Trait
+from roborock.roborock_message import RoborockDyadDataProtocol, RoborockZeoProtocol
+
+__init__ = [
+    "DyadApi",
+    "ZeoApi",
+]
+
+
+class DyadApi(Trait):
+    """API for interacting with Dyad devices."""
+
+    def __init__(self, channel: MqttChannel) -> None:
+        """Initialize the Dyad API."""
+        self._channel = channel
+
+    async def query_values(self, protocols: list[RoborockDyadDataProtocol]) -> dict[RoborockDyadDataProtocol, Any]:
+        """Query the device for the values of the given Dyad protocols."""
+        params = {RoborockDyadDataProtocol.ID_QUERY: [int(p) for p in protocols]}
+        return await send_decoded_command(self._channel, params)
+
+    async def set_value(self, protocol: RoborockDyadDataProtocol, value: Any) -> dict[RoborockDyadDataProtocol, Any]:
+        """Set a value for a specific protocol on the device."""
+        params = {protocol: value}
+        return await send_decoded_command(self._channel, params)
+
+
+class ZeoApi(Trait):
+    """API for interacting with Zeo devices."""
+
+    name = "zeo"
+
+    def __init__(self, channel: MqttChannel) -> None:
+        """Initialize the Zeo API."""
+        self._channel = channel
+
+    async def query_values(self, protocols: list[RoborockZeoProtocol]) -> dict[RoborockZeoProtocol, Any]:
+        """Query the device for the values of the given protocols."""
+        params = {RoborockZeoProtocol.ID_QUERY: [int(p) for p in protocols]}
+        return await send_decoded_command(self._channel, params)
+
+    async def set_value(self, protocol: RoborockZeoProtocol, value: Any) -> dict[RoborockZeoProtocol, Any]:
+        """Set a value for a specific protocol on the device."""
+        params = {protocol: value}
+        return await send_decoded_command(self._channel, params)
+
+
+def create(product: HomeDataProduct, mqtt_channel: MqttChannel) -> DyadApi | ZeoApi:
+    """Create traits for A01 devices."""
+    match product.category:
+        case RoborockCategory.WET_DRY_VAC:
+            return DyadApi(mqtt_channel)
+        case RoborockCategory.WASHING_MACHINE:
+            return ZeoApi(mqtt_channel)
+        case _:
+            raise NotImplementedError(f"Unsupported category {product.category}")

python_roborock-2.46.0/roborock/devices/traits/b01/props.py → python_roborock-2.47.0/roborock/devices/traits/b01/__init__.py

@@ -1,26 +1,20 @@
-from __future__ import annotations
-
-import logging
+"""Traits for B01 devices."""
 
 from roborock import RoborockB01Methods
+from roborock.devices.b01_channel import send_decoded_command
+from roborock.devices.mqtt_channel import MqttChannel
+from roborock.devices.traits import Trait
 from roborock.roborock_message import RoborockB01Props
 
-from ...b01_channel import send_decoded_command
-from ...mqtt_channel import MqttChannel
-from ..trait import Trait
-
-_LOGGER = logging.getLogger(__name__)
-
-__all__ = [
-    "B01PropsApi",
+__init__ = [
+    "create_b01_traits",
+    "PropertiesApi",
 ]
 
 
-class B01PropsApi(Trait):
+class PropertiesApi(Trait):
     """API for interacting with B01 devices."""
 
-    name = "B01_props"
-
     def __init__(self, channel: MqttChannel) -> None:
         """Initialize the B01Props API."""
         self._channel = channel
@@ -30,3 +24,8 @@ class B01PropsApi(Trait):
         await send_decoded_command(
             self._channel, dps=10000, command=RoborockB01Methods.GET_PROP, params={"property": props}
         )
+
+
+def create(channel: MqttChannel) -> PropertiesApi:
+    """Create traits for B01 devices."""
+    return PropertiesApi(channel)

python_roborock-2.47.0/roborock/devices/traits/traits_mixin.py

@@ -0,0 +1,61 @@
+"""Holds device traits mixin and related code.
+
+This holds the TraitsMixin class, which is used to provide accessors for
+various device traits. Each trait is a class that encapsulates a specific
+set of functionality for a device, such as controlling a vacuum or a mop.
+
+The TraitsMixin holds traits across all protocol types. A trait is supported
+if it is non-None.
+"""
+
+from dataclasses import dataclass, fields
+from typing import get_args, get_origin
+
+from . import Trait, a01, b01, v1
+
+__all__ = [
+    "TraitsMixin",
+]
+
+
+@dataclass(init=False)
+class TraitsMixin:
+    """Mixin to provide trait accessors."""
+
+    v1_properties: v1.PropertiesApi | None = None
+    """V1 properties trait, if supported."""
+
+    dyad: a01.DyadApi | None = None
+    """Dyad API, if supported."""
+
+    zeo: a01.ZeoApi | None = None
+    """Zeo API, if supported."""
+
+    b01_properties: b01.PropertiesApi | None = None
+    """B01 properties trait, if supported."""
+
+    def __init__(self, trait: Trait) -> None:
+        """Initialize the TraitsMixin with the given trait.
+
+        This will populate the appropriate trait attributes based on the types
+        of the traits provided.
+        """
+        for item in fields(self):
+            trait_type = _get_trait_type(item)
+            if trait_type == type(trait):
+                setattr(self, item.name, trait)
+                break
+
+
+def _get_trait_type(item) -> type[Trait]:
+    """Get the trait type from a dataclass field."""
+    if get_origin(item.type) is None:
+        raise ValueError(f"Trait {item.name} is not an optional type")
+    if (args := get_args(item.type)) is None:
+        raise ValueError(f"Trait {item.name} is not an optional type")
+    if len(args) != 2 or args[1] is not type(None):
+        raise ValueError(f"Trait {item.name} is not an optional type")
+    trait_type = args[0]
+    if not issubclass(trait_type, Trait):
+        raise ValueError(f"Trait {item.name} is not a Trait subclass")
+    return trait_type

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

@@ -0,0 +1,57 @@
+"""Create traits for V1 devices."""
+
+from dataclasses import dataclass, field, fields
+
+from roborock.containers import HomeDataProduct
+from roborock.devices.traits import Trait
+from roborock.devices.v1_rpc_channel import V1RpcChannel
+
+from .clean_summary import CleanSummaryTrait
+from .common import V1TraitMixin
+from .do_not_disturb import DoNotDisturbTrait
+from .status import StatusTrait
+from .volume import SoundVolumeTrait
+
+__all__ = [
+    "create",
+    "PropertiesApi",
+    "StatusTrait",
+    "DoNotDisturbTrait",
+    "CleanSummaryTrait",
+    "SoundVolumeTrait",
+]
+
+
+@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
+    dnd: DoNotDisturbTrait
+    clean_summary: CleanSummaryTrait
+    sound_volume: SoundVolumeTrait
+
+    # In the future optional fields can be added below based on supported features
+
+    def __init__(self, product: HomeDataProduct, rpc_channel: V1RpcChannel) -> None:
+        """Initialize the V1TraitProps with None values."""
+        self.status = StatusTrait(product)
+
+        # 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.
+        for item in fields(self):
+            if (trait := getattr(self, item.name, None)) is None:
+                trait = item.type()
+                setattr(self, item.name, trait)
+            trait._rpc_channel = rpc_channel
+
+
+def create(product: HomeDataProduct, rpc_channel: V1RpcChannel) -> PropertiesApi:
+    """Create traits for V1 devices."""
+    return PropertiesApi(product, rpc_channel)

python_roborock-2.47.0/roborock/devices/traits/v1/clean_summary.py

@@ -0,0 +1,29 @@
+from typing import Self
+
+from roborock.containers import CleanSummary
+from roborock.devices.traits.v1 import common
+from roborock.roborock_typing import RoborockCommand
+from roborock.util import unpack_list
+
+
+class CleanSummaryTrait(CleanSummary, common.V1TraitMixin):
+    """Trait for managing the clean summary of Roborock devices."""
+
+    command = RoborockCommand.GET_CLEAN_SUMMARY
+
+    @classmethod
+    def _parse_type_response(cls, response: common.V1ResponseData) -> Self:
+        """Parse the response from the device into a CleanSummary."""
+        if isinstance(response, dict):
+            return cls.from_dict(response)
+        elif isinstance(response, list):
+            clean_time, clean_area, clean_count, records = unpack_list(response, 4)
+            return cls(
+                clean_time=clean_time,
+                clean_area=clean_area,
+                clean_count=clean_count,
+                records=records,
+            )
+        elif isinstance(response, int):
+            return cls(clean_time=response)
+        raise ValueError(f"Unexpected clean summary format: {response!r}")

python_roborock-2.47.0/roborock/devices/traits/v1/common.py

@@ -0,0 +1,115 @@
+"""Module for Roborock V1 devices common trait commands.
+
+This is an internal library and should not be used directly by consumers.
+"""
+
+from abc import ABC
+from dataclasses import asdict, dataclass, fields
+from typing import ClassVar, Self
+
+from roborock.containers import RoborockBase
+from roborock.devices.v1_rpc_channel import V1RpcChannel
+from roborock.roborock_typing import RoborockCommand
+
+V1ResponseData = dict | list | int | str
+
+
+@dataclass
+class V1TraitMixin(ABC):
+    """Base model that supports v1 traits.
+
+    This class provides functioanlity for parsing responses from V1 devices
+    into dataclass instances. It also provides a reference to the V1RpcChannel
+    used to communicate with the device to execute commands.
+
+    Each trait subclass must define a class variable `command` that specifies
+    the RoborockCommand used to fetch the trait data from the device. The
+    `refresh()` method can be called to update the contents of the trait data
+    from the device. A trait can also support additional commands for updating
+    state associated with the trait.
+
+    The traits typically subclass RoborockBase to provide serialization
+    and deserialization functionality, but this is not strictly required.
+    """
+
+    command: ClassVar[RoborockCommand]
+
+    @classmethod
+    def _parse_type_response(cls, response: V1ResponseData) -> Self:
+        """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) -> Self:
+        """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.
+
+        This is called automatically after the dataclass is initialized by the
+        device setup code.
+        """
+        self._rpc_channel = None
+
+    @property
+    def rpc_channel(self) -> V1RpcChannel:
+        """Helper for executing commands, used internally by the trait"""
+        if not self._rpc_channel:
+            raise ValueError("Device trait in invalid state")
+        return self._rpc_channel
+
+    async def refresh(self) -> Self:
+        """Refresh the contents of this trait."""
+        response = await self.rpc_channel.send_command(self.command)
+        new_data = self._parse_response(response)
+        for k, v in asdict(new_data).items():
+            if v is not None:
+                setattr(self, k, v)
+        return self
+
+
+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):
+    """Base class for traits that represent a single value.
+
+    This class is intended to be subclassed by traits that represent a single
+    value, such as volume or brightness. The subclass should define a single
+    field with the metadata `roborock_value=True` to indicate which field
+    represents the main value of the trait.
+    """
+
+    @classmethod
+    def _parse_response(cls, response: V1ResponseData) -> Self:
+        """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})

python_roborock-2.47.0/roborock/devices/traits/v1/do_not_disturb.py

@@ -0,0 +1,17 @@
+from roborock.containers import DnDTimer
+from roborock.devices.traits.v1 import common
+from roborock.roborock_typing import RoborockCommand
+
+
+class DoNotDisturbTrait(DnDTimer, common.V1TraitMixin):
+    """Trait for managing Do Not Disturb (DND) settings on Roborock devices."""
+
+    command = RoborockCommand.GET_DND_TIMER
+
+    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())
+
+    async def clear_dnd_timer(self) -> None:
+        """Clear the Do Not Disturb (DND) timer settings of the device."""
+        await self.rpc_channel.send_command(RoborockCommand.CLOSE_DND_TIMER)