python-roborock 4.2.1__tar.gz → 4.3.0__tar.gz

{python_roborock-4.2.1 → python_roborock-4.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-roborock
-Version: 4.2.1
+Version: 4.3.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.2.1 → python_roborock-4.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-roborock"
-version = "4.2.1"
+version = "4.3.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.2.1 → python_roborock-4.3.0}/roborock/data/containers.py

@@ -232,6 +232,13 @@ class HomeDataProduct(RoborockBase):
         """Return a string with key product information for logging purposes."""
         return f"{self.name} (model={self.model}, category={self.category})"
 
+    @cached_property
+    def supported_schema_codes(self) -> set[str]:
+        """Return a set of fields that are supported by the device."""
+        if self.schema is None:
+            return set()
+        return {schema.code for schema in self.schema if schema.code is not None}
+
 
 @dataclass
 class HomeDataDevice(RoborockBase):

{python_roborock-4.2.1 → python_roborock-4.3.0}/roborock/data/v1/v1_containers.py

@@ -1,6 +1,7 @@
 import datetime
 import logging
-from dataclasses import dataclass
+from dataclasses import dataclass, field
+from enum import StrEnum
 from typing import Any
 
 from roborock.const import (
@@ -91,12 +92,39 @@ from .v1_code_mappings import (
 _LOGGER = logging.getLogger(__name__)
 
 
+class FieldNameBase(StrEnum):
+    """A base enum class that represents a field name in a RoborockBase dataclass."""
+
+
+class StatusField(FieldNameBase):
+    """An enum that represents a field in the `Status` class.
+
+    This is used with `roborock.devices.traits.v1.status.DeviceFeaturesTrait`
+    to understand if a feature is supported by the device using `is_field_supported`.
+
+    The enum values are names of fields in the `Status` class. Each field is
+    annotated with `requires_schema_code` metadata to map the field to a schema
+    code in the product schema, which may have a different name than the field/attribute name.
+    """
+
+    STATE = "state"
+    BATTERY = "battery"
+    FAN_POWER = "fan_power"
+    WATER_BOX_MODE = "water_box_mode"
+    CHARGE_STATUS = "charge_status"
+    DRY_STATUS = "dry_status"
+
+
+def _requires_schema_code(requires_schema_code: str, default=None) -> Any:
+    return field(metadata={"requires_schema_code": requires_schema_code}, default=default)
+
+
 @dataclass
 class Status(RoborockBase):
     msg_ver: int | None = None
     msg_seq: int | None = None
-    state: RoborockStateCode | None = None
-    battery: int | None = None
+    state: RoborockStateCode | None = _requires_schema_code("state", default=None)
+    battery: int | None = _requires_schema_code("battery", default=None)
     clean_time: int | None = None
     clean_area: int | None = None
     error_code: RoborockErrorCode | None = None
@@ -109,12 +137,12 @@ class Status(RoborockBase):
     back_type: int | None = None
     wash_phase: int | None = None
     wash_ready: int | None = None
-    fan_power: RoborockFanPowerCode | None = None
+    fan_power: RoborockFanPowerCode | None = _requires_schema_code("fan_power", default=None)
     dnd_enabled: int | None = None
     map_status: int | None = None
     is_locating: int | None = None
     lock_status: int | None = None
-    water_box_mode: RoborockMopIntensityCode | None = None
+    water_box_mode: RoborockMopIntensityCode | None = _requires_schema_code("water_box_mode", default=None)
     water_box_carriage_status: int | None = None
     mop_forbidden_enable: int | None = None
     camera_status: int | None = None
@@ -132,13 +160,13 @@ class Status(RoborockBase):
     collision_avoid_status: int | None = None
     switch_map_mode: int | None = None
     dock_error_status: RoborockDockErrorCode | None = None
-    charge_status: int | None = None
+    charge_status: int | None = _requires_schema_code("charge_status", default=None)
     unsave_map_reason: int | None = None
     unsave_map_flag: int | None = None
     wash_status: int | None = None
     distance_off: int | None = None
     in_warmup: int | None = None
-    dry_status: int | None = None
+    dry_status: int | None = _requires_schema_code("drying_status", default=None)
     rdt: int | None = None
     clean_percent: int | None = None
     rss: int | None = None

{python_roborock-4.2.1 → python_roborock-4.3.0}/roborock/devices/device.py

@@ -226,9 +226,11 @@ class RoborockDevice(ABC, TraitsMixin):
         """Return diagnostics information about the device."""
         extra: dict[str, Any] = {}
         if self.v1_properties:
-            extra["traits"] = redact_device_data(self.v1_properties.as_dict())
-        return {
-            "device": redact_device_data(self.device_info.as_dict()),
-            "product": redact_device_data(self.product.as_dict()),
-            **extra,
-        }
+            extra["traits"] = self.v1_properties.as_dict()
+        return redact_device_data(
+            {
+                "device": self.device_info.as_dict(),
+                "product": self.product.as_dict(),
+                **extra,
+            }
+        )

{python_roborock-4.2.1 → python_roborock-4.3.0}/roborock/devices/device_manager.py

@@ -16,7 +16,7 @@ from roborock.data import (
     UserData,
 )
 from roborock.devices.device import DeviceReadyCallback, RoborockDevice
-from roborock.diagnostics import Diagnostics
+from roborock.diagnostics import Diagnostics, redact_device_data
 from roborock.exceptions import RoborockException
 from roborock.map.map_parser import MapParserConfig
 from roborock.mqtt.roborock_session import create_lazy_mqtt_session
@@ -76,6 +76,7 @@ class DeviceManager:
         self._devices: dict[str, RoborockDevice] = {}
         self._mqtt_session = mqtt_session
         self._diagnostics = diagnostics
+        self._home_data: HomeData | None = None
 
     async def discover_devices(self, prefer_cache: bool = True) -> list[RoborockDevice]:
         """Discover all devices for the logged-in user."""
@@ -91,9 +92,9 @@ class DeviceManager:
                     raise
                 _LOGGER.debug("Failed to fetch home data, using cached data: %s", ex)
             await self._cache.set(cache_data)
-        home_data = cache_data.home_data
+        self._home_data = cache_data.home_data
 
-        device_products = home_data.device_products
+        device_products = self._home_data.device_products
         _LOGGER.debug("Discovered %d devices", len(device_products))
 
         # These are connected serially to avoid overwhelming the MQTT broker
@@ -106,7 +107,7 @@ class DeviceManager:
             if duid in self._devices:
                 continue
             try:
-                new_device = self._device_creator(home_data, device, product)
+                new_device = self._device_creator(self._home_data, device, product)
             except UnsupportedDeviceError:
                 _LOGGER.info("Skipping unsupported device %s %s", product.summary_info(), device.summary_info())
                 unsupported_devices_counter.increment(device.pv or "unknown")
@@ -136,7 +137,11 @@ class DeviceManager:
 
     def diagnostic_data(self) -> Mapping[str, Any]:
         """Return diagnostics information about the device manager."""
-        return self._diagnostics.as_dict()
+        return {
+            "home_data": redact_device_data(self._home_data.as_dict()) if self._home_data else None,
+            "devices": [device.diagnostic_data() for device in self._devices.values()],
+            "diagnostics": self._diagnostics.as_dict(),
+        }
 
 
 @dataclass

{python_roborock-4.2.1 → python_roborock-4.3.0}/roborock/devices/traits/v1/__init__.py

@@ -44,6 +44,12 @@ optional traits:
         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.
+
+Additionally, DeviceFeaturesTrait has a method `is_field_supported` that is used to
+check individual trait field values. This is a more fine grained version to allow
+optional fields in a dataclass, vs the above feature checks that apply to an entire
+trait. The `requires_schema_code` field metadata attribute is a string of the schema
+code in HomeDataProduct Schema that is required for the field to be supported.
 """
 
 import logging
@@ -189,7 +195,7 @@ class PropertiesApi(Trait):
         self.maps = MapsTrait(self.status)
         self.map_content = MapContentTrait(map_parser_config)
         self.home = HomeTrait(self.status, self.maps, self.map_content, self.rooms, self._device_cache)
-        self.device_features = DeviceFeaturesTrait(product.product_nickname, self._device_cache)
+        self.device_features = DeviceFeaturesTrait(product, self._device_cache)
         self.network_info = NetworkInfoTrait(device_uid, self._device_cache)
         self.routines = RoutinesTrait(device_uid, web_api)
 

{python_roborock-4.2.1 → python_roborock-4.3.0}/roborock/devices/traits/v1/device_features.py

@@ -1,6 +1,7 @@
-from dataclasses import fields
+from dataclasses import Field, fields
 
-from roborock.data import AppInitStatus, RoborockProductNickname
+from roborock.data import AppInitStatus, HomeDataProduct, RoborockBase
+from roborock.data.v1.v1_containers import FieldNameBase
 from roborock.device_features import DeviceFeatures
 from roborock.devices.cache import DeviceCache
 from roborock.devices.traits.v1 import common
@@ -8,19 +9,42 @@ from roborock.roborock_typing import RoborockCommand
 
 
 class DeviceFeaturesTrait(DeviceFeatures, common.V1TraitMixin):
-    """Trait for managing Do Not Disturb (DND) settings on Roborock devices."""
+    """Trait for managing supported features on Roborock devices."""
 
     command = RoborockCommand.APP_GET_INIT_STATUS
 
-    def __init__(self, product_nickname: RoborockProductNickname, device_cache: DeviceCache) -> None:  # pylint: disable=super-init-not-called
-        """Initialize MapContentTrait."""
-        self._nickname = product_nickname
+    def __init__(self, product: HomeDataProduct, device_cache: DeviceCache) -> None:  # pylint: disable=super-init-not-called
+        """Initialize DeviceFeaturesTrait."""
+        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.
         for field in fields(self):
             setattr(self, field.name, False)
 
+    def is_field_supported(self, cls: type[RoborockBase], field_name: FieldNameBase) -> bool:
+        """Determines if the specified field is supported by this device.
+
+        We use dataclass attributes on the field to specify the schema code that is required
+        for the field to be supported and it is compared against the list of
+        supported schema codes for the device returned in the product information.
+        """
+        dataclass_field: Field | None = None
+        for field in fields(cls):
+            if field.name == field_name:
+                dataclass_field = field
+                break
+        if dataclass_field is None:
+            raise ValueError(f"Field {field_name} not found in {cls}")
+
+        requires_schema_code = dataclass_field.metadata.get("requires_schema_code", None)
+        if requires_schema_code is None:
+            # We assume the field is supported
+            return True
+        # If the field requires a protocol that is not supported, we return False
+        return requires_schema_code in self._product.supported_schema_codes
+
     async def refresh(self) -> None:
         """Refresh the contents of this trait.
 

{python_roborock-4.2.1 → python_roborock-4.3.0}/roborock/diagnostics.py

@@ -101,30 +101,50 @@ REDACT_KEYS = {
     "imageContent",
     "mapData",
     "rawApiResponse",
+    # Home data
+    "id",  # We want to redact home_data.id but keep some other ids, see below
+    "name",
+    "productId",
+    "ipAddress",
+    "wifiName",
+    "lat",
+    "long",
+}
+KEEP_KEYS = {
+    # Product information not unique per user
+    "product.id",
+    "product.schema.id",
+    "product.schema.name",
+    # Room ids are likely unique per user, but don't seem too sensitive and are
+    # useful for debugging
+    "rooms.id",
 }
 DEVICE_UID = "duid"
 REDACTED = "**REDACTED**"
 
 
-def redact_device_data(data: T) -> T | dict[str, Any]:
+def redact_device_data(data: T, path: str = "") -> T | dict[str, Any]:
     """Redact sensitive data in a dict."""
     if not isinstance(data, (Mapping, list)):
         return data
 
     if isinstance(data, list):
-        return cast(T, [redact_device_data(item) for item in data])
+        return cast(T, [redact_device_data(item, path) for item in data])
 
     redacted = {**data}
 
     for key, value in redacted.items():
-        if key in REDACT_KEYS:
+        curr_path = f"{path}.{key}" if path else key
+        if key in KEEP_KEYS or curr_path in KEEP_KEYS:
+            continue
+        if key in REDACT_KEYS or curr_path in REDACT_KEYS:
             redacted[key] = REDACTED
         elif key == DEVICE_UID and isinstance(value, str):
             redacted[key] = redact_device_uid(value)
         elif isinstance(value, dict):
-            redacted[key] = redact_device_data(value)
+            redacted[key] = redact_device_data(value, curr_path)
         elif isinstance(value, list):
-            redacted[key] = [redact_device_data(item) for item in value]
+            redacted[key] = [redact_device_data(item, curr_path) for item in value]
 
     return redacted
 

{python_roborock-4.2.1 → python_roborock-4.3.0}/roborock/web_api.py

@@ -57,8 +57,8 @@ class RoborockApiClient:
     ]
     _HOME_DATA_RATES = [
         Rate(1, Duration.SECOND),
-        Rate(5, Duration.MINUTE),
-        Rate(15, Duration.HOUR),
+        Rate(3, Duration.MINUTE),
+        Rate(5, Duration.HOUR),
         Rate(40, Duration.DAY),
     ]