Add additional sensors and settings to Roborock vacuums

miio/device.py

@@ -1,12 +1,14 @@
 import logging
 from enum import Enum
+from inspect import getmembers
 from typing import Any, Dict, List, Optional, Union  # noqa: F401
 
 import click
 
 from .click_common import DeviceGroupMeta, LiteralParamType, command, format_output
 from .descriptors import (
     ButtonDescriptor,
+    EnumSettingDescriptor,
     SensorDescriptor,
     SettingDescriptor,
     SwitchDescriptor,
@@ -54,6 +56,8 @@ def __init__(
         self.token: Optional[str] = token
         self._model: Optional[str] = model
         self._info: Optional[DeviceInfo] = None
+        self._status: Optional[DeviceStatus] = None
+        self._buttons: Optional[List[ButtonDescriptor]] = None
         timeout = timeout if timeout is not None else self.timeout
         self._protocol = MiIOProtocol(
             ip, token, start_id, debug, lazy_discover, timeout
@@ -238,13 +242,32 @@ def status(self) -> DeviceStatus:
         """Return device status."""
         raise NotImplementedError()
 
+    def cached_status(self) -> DeviceStatus:
+        """Return device status from cache."""
+        if self._status is None:
+            self._status = self.status()
+
+        return self._status
+
     def buttons(self) -> List[ButtonDescriptor]:
         """Return a list of button-like, clickable actions of the device."""
-        return []
+        if self._buttons is None:
+            self._buttons = []
+            for button_tuple in getmembers(self, lambda o: hasattr(o, "_button")):
+                method_name, method = button_tuple
+                button = method._button
+                button.method = method  # bind the method
+                self._buttons.append(button)
 
-    def settings(self) -> Dict[str, SettingDescriptor]:
+        return self._buttons
+
+    def settings(
+        self,
+    ) -> Dict[str, SettingDescriptor]:
         """Return list of settings."""
-        settings = self.status().settings()
+        settings = (
+            self.cached_status().settings()
+        )  # NOTE that this already does IO so schould be run in executer job in HA
         for setting in settings.values():
             # TODO: Bind setter methods, this should probably done only once during init.
             if setting.setter is None:
@@ -255,18 +278,23 @@ def settings(self) -> Dict[str, SettingDescriptor]:
                     )
 
                 setting.setter = getattr(self, setting.setter_name)
+            if (
+                isinstance(setting, EnumSettingDescriptor)
+                and setting.choices_attribute is not None
+            ):
+                retrieve_choices_function = getattr(self, setting.choices_attribute)
+                setting.choices = retrieve_choices_function()  # This can do IO
 
         return settings
 
     def sensors(self) -> Dict[str, SensorDescriptor]:
         """Return sensors."""
-        # TODO: the latest status should be cached and re-used by all meta information getters
-        sensors = self.status().sensors()
+        sensors = self.cached_status().sensors()
         return sensors
 
     def switches(self) -> Dict[str, SwitchDescriptor]:
         """Return toggleable switches."""
-        switches = self.status().switches()
+        switches = self.cached_status().switches()
         for switch in switches.values():
             # TODO: Bind setter methods, this should probably done only once during init.
             if switch.setter is None:

miio/devicestatus.py

@@ -2,18 +2,10 @@
 import logging
 import warnings
 from enum import Enum
-from typing import (
-    Callable,
-    Dict,
-    Optional,
-    Type,
-    Union,
-    get_args,
-    get_origin,
-    get_type_hints,
-)
+from typing import Dict, Optional, Type, Union, get_args, get_origin, get_type_hints
 
 from .descriptors import (
+    ButtonDescriptor,
     EnumSettingDescriptor,
     NumberSettingDescriptor,
     SensorDescriptor,
@@ -100,7 +92,9 @@ def switches(self) -> Dict[str, SwitchDescriptor]:
         """
         return self._switches  # type: ignore[attr-defined]
 
-    def settings(self) -> Dict[str, SettingDescriptor]:
+    def settings(
+        self,
+    ) -> Dict[str, SettingDescriptor]:
         """Return the dict of settings exposed by the status container.
 
         You can use @setting decorator to define sensors inside your status class.
@@ -143,7 +137,7 @@ def __getattribute__(self, item):
         return getattr(self._embedded[embed], prop)
 
 
-def sensor(name: str, *, unit: str = "", **kwargs):
+def sensor(name: str, *, unit: Optional[str] = None, **kwargs):
     """Syntactic sugar to create SensorDescriptor objects.
 
     The information can be used by users of the library to programmatically find out what
@@ -155,7 +149,8 @@ def sensor(name: str, *, unit: str = "", **kwargs):
     """
 
     def decorator_sensor(func):
-        property_name = func.__name__
+        property_name = str(func.__name__)
+        qualified_name = str(func.__qualname__)
 
         def _sensor_type_for_return_type(func):
             rtype = get_type_hints(func).get("return")
@@ -169,8 +164,8 @@ def _sensor_type_for_return_type(func):
 
         sensor_type = _sensor_type_for_return_type(func)
         descriptor = SensorDescriptor(
-            id=str(property_name),
-            property=str(property_name),
+            id=qualified_name,
+            property=property_name,
             name=name,
             unit=unit,
             type=sensor_type,
@@ -194,12 +189,13 @@ def switch(name: str, *, setter_name: str, **kwargs):
     and can be interpreted downstream users as they wish.
     """
 
-    def decorator_sensor(func):
-        property_name = func.__name__
+    def decorator_switch(func):
+        property_name = str(func.__name__)
+        qualified_name = str(func.__qualname__)
 
         descriptor = SwitchDescriptor(
-            id=str(property_name),
-            property=str(property_name),
+            id=qualified_name,
+            property=property_name,
             name=name,
             setter_name=setter_name,
             extras=kwargs,
@@ -208,13 +204,12 @@ def decorator_sensor(func):
 
         return func
 
-    return decorator_sensor
+    return decorator_switch
 
 
 def setting(
     name: str,
     *,
-    setter: Optional[Callable] = None,
     setter_name: Optional[str] = None,
     unit: Optional[str] = None,
     min_value: Optional[int] = None,
@@ -235,35 +230,32 @@ def setting(
     """
 
     def decorator_setting(func):
-        property_name = func.__name__
+        property_name = str(func.__name__)
+        qualified_name = str(func.__qualname__)
 
-        if setter is None and setter_name is None:
-            raise Exception("Either setter or setter_name needs to be defined")
+        if setter_name is None:
+            raise Exception("Setter_name needs to be defined")
 
         if min_value or max_value:
             descriptor = NumberSettingDescriptor(
-                id=str(property_name),
-                property=str(property_name),
+                id=qualified_name,
+                property=property_name,
                 name=name,
                 unit=unit,
-                setter=setter,
+                setter=None,
                 setter_name=setter_name,
                 min_value=min_value or 0,
                 max_value=max_value,
                 step=step or 1,
                 extras=kwargs,
             )
         elif choices or choices_attribute:
-            if choices_attribute is not None:
-                # TODO: adding choices from attribute is a bit more complex, as it requires a way to
-                # construct enums pointed by the attribute
-                raise NotImplementedError("choices_attribute is not yet implemented")
             descriptor = EnumSettingDescriptor(
-                id=str(property_name),
-                property=str(property_name),
+                id=qualified_name,
+                property=property_name,
                 name=name,
                 unit=unit,
-                setter=setter,
+                setter=None,
                 setter_name=setter_name,
                 choices=choices,
                 choices_attribute=choices_attribute,
@@ -279,3 +271,32 @@ def decorator_setting(func):
         return func
 
     return decorator_setting
+
+
+def button(name: str, **kwargs):
+    """Syntactic sugar to create ButtonDescriptor objects.
+
+    The information can be used by users of the library to programmatically find out what
+    types of sensors are available for the device.
+
+    The interface is kept minimal, but you can pass any extra keyword arguments.
+    These extras are made accessible over :attr:`~miio.descriptors.ButtonDescriptor.extras`,
+    and can be interpreted downstream users as they wish.
+    """
+
+    def decorator_button(func):
+        property_name = str(func.__name__)
+        qualified_name = str(func.__qualname__)
+
+        descriptor = ButtonDescriptor(
+            id=qualified_name,
+            name=name,
+            method_name=property_name,
+            method=None,
+            extras=kwargs,
+        )
+        func._button = descriptor
+
+        return func
+
+    return decorator_button

miio/integrations/vacuum/roborock/tests/test_vacuum.py

@@ -68,6 +68,45 @@ def __init__(self, *args, **kwargs):
                 1487548800,
             ],
         ]
+        self.dummies["dnd_timer"] = [
+            {
+                "enabled": 1,
+                "start_minute": 0,
+                "end_minute": 0,
+                "start_hour": 22,
+                "end_hour": 8,
+            }
+        ]
+        self.dummies["multi_maps"] = [
+            {
+                "max_multi_map": 4,
+                "max_bak_map": 1,
+                "multi_map_count": 3,
+                "map_info": [
+                    {
+                        "mapFlag": 0,
+                        "add_time": 1664448893,
+                        "length": 10,
+                        "name": "Downstairs",
+                        "bak_maps": [{"mapFlag": 4, "add_time": 1663577737}],
+                    },
+                    {
+                        "mapFlag": 1,
+                        "add_time": 1663580330,
+                        "length": 8,
+                        "name": "Upstairs",
+                        "bak_maps": [{"mapFlag": 5, "add_time": 1663577752}],
+                    },
+                    {
+                        "mapFlag": 2,
+                        "add_time": 1663580384,
+                        "length": 5,
+                        "name": "Attic",
+                        "bak_maps": [{"mapFlag": 6, "add_time": 1663577765}],
+                    },
+                ],
+            }
+        ]
 
         self.return_values = {
             "get_status": lambda x: [self.state],
@@ -81,8 +120,16 @@ def __init__(self, *args, **kwargs):
             "app_zoned_clean": lambda x: self.change_mode("zoned clean"),
             "app_charge": lambda x: self.change_mode("charge"),
             "miIO.info": "dummy info",
+            "get_clean_record": lambda x: [[1488347071, 1488347123, 16, 0, 0, 0]],
+            "get_dnd_timer": lambda x: self.dummies["dnd_timer"],
+            "get_multi_maps_list": lambda x: self.dummies["multi_maps"],
         }
 
+        self._multi_maps = None
+
+        self._floor_clean_details = {}
+        self._searched_clean_id = None
+
         super().__init__(args, kwargs)
 
     def change_mode(self, new_mode):