python-roborock 3.0.0__tar.gz → 3.2.0__tar.gz

{python_roborock-3.0.0 → python_roborock-3.2.0}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "python-roborock"
-version = "3.0.0"
+version = "3.2.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"
@@ -44,7 +44,7 @@ dev = [
     "pytest",
     "pre-commit>=3.5,<5.0",
     "mypy",
-    "ruff==0.14.0",
+    "ruff==0.14.1",
     "codespell",
     "pyshark>=0.6,<0.7",
     "aioresponses>=0.7.7,<0.8",
@@ -52,6 +52,8 @@ dev = [
     "pytest-timeout>=2.3.1,<3",
     "syrupy>=4.9.1,<5",
     "pdoc>=15.0.4,<16",
+    "pyyaml>=6.0.3",
+    "pyshark>=0.6",
 ]
 
 [tool.hatch.build.targets.sdist]
@@ -67,7 +69,18 @@ build-backend = "hatchling.build"
 [tool.semantic_release]
 branch = "main"
 version_toml = ["pyproject.toml:project.version"]
-build_command = "pip install uv && uv build"
+build_command = "pip install uv && uv lock --upgrade-package python-roborock && git add uv.lock && uv build"
+changelog_file = 'CHANGELOG.md'
+commit = true
+
+[tool.semantic_release.branches.main]
+match = "main"
+prerelease = false
+
+[tool.semantic_release.branches.temp-main-branch]
+match = "temp-main-branch"
+prerelease = false
+
 
 [tool.semantic_release.commit_parser_options]
 allowed_tags = [
@@ -92,9 +105,3 @@ asyncio_mode = "auto"
 asyncio_default_fixture_loop_scope = "function"
 timeout = 30
 log_format = "%(asctime)s.%(msecs)03d %(levelname)s (%(threadName)s) [%(name)s] %(message)s"
-
-[tool.uv]
-dev-dependencies = [
-    "pyyaml>=6.0.3",
-    "pyshark>=0.6",
-]

{python_roborock-3.0.0 → python_roborock-3.2.0}/roborock/cli.py

@@ -731,6 +731,16 @@ async def home(ctx, device_id: str, refresh: bool):
         click.echo("No maps discovered")
 
 
+@session.command()
+@click.option("--device_id", required=True)
+@click.pass_context
+@async_command
+async def network_info(ctx, device_id: str):
+    """Get device network information."""
+    context: RoborockContext = ctx.obj
+    await _display_v1_trait(context, device_id, lambda v1: v1.network_info)
+
+
 @click.command()
 @click.option("--device_id", required=True)
 @click.option("--cmd", required=True)
@@ -979,6 +989,7 @@ cli.add_command(child_lock)
 cli.add_command(dnd)
 cli.add_command(flow_led_status)
 cli.add_command(led_status)
+cli.add_command(network_info)
 
 
 def main():

{python_roborock-3.0.0 → python_roborock-3.2.0}/roborock/data/v1/v1_containers.py

@@ -156,15 +156,15 @@ class Status(RoborockBase):
 
     @property
     def error_code_name(self) -> str | None:
-        return self.error_code.name if self.error_code else None
+        return self.error_code.name if self.error_code is not None else None
 
     @property
     def state_name(self) -> str | None:
-        return self.state.name if self.state else None
+        return self.state.name if self.state is not None else None
 
     @property
     def water_box_mode_name(self) -> str | None:
-        return self.water_box_mode.name if self.water_box_mode else None
+        return self.water_box_mode.name if self.water_box_mode is not None else None
 
     @property
     def fan_power_options(self) -> list[str]:
@@ -174,11 +174,11 @@ class Status(RoborockBase):
 
     @property
     def fan_power_name(self) -> str | None:
-        return self.fan_power.name if self.fan_power else None
+        return self.fan_power.name if self.fan_power is not None else None
 
     @property
     def mop_mode_name(self) -> str | None:
-        return self.mop_mode.name if self.mop_mode else None
+        return self.mop_mode.name if self.mop_mode is not None else None
 
     def get_fan_speed_code(self, fan_speed: str) -> int:
         if self.fan_power is None:
@@ -449,6 +449,12 @@ class CleanRecord(RoborockBase):
         return _attr_repr(self)
 
 
+class CleanSummaryWithDetail(CleanSummary):
+    """CleanSummary with the last CleanRecord included."""
+
+    last_clean_record: CleanRecord | None = None
+
+
 @dataclass
 class Consumable(RoborockBase):
     main_brush_work_time: int | None = None

{python_roborock-3.0.0 → python_roborock-3.2.0}/roborock/devices/device.py

@@ -6,7 +6,8 @@ until the API is stable.
 
 import logging
 from abc import ABC
-from collections.abc import Callable
+from collections.abc import Callable, Mapping
+from typing import Any, TypeVar, cast
 
 from roborock.data import HomeDataDevice, HomeDataProduct
 from roborock.roborock_message import RoborockMessage
@@ -113,3 +114,41 @@ class RoborockDevice(ABC, TraitsMixin):
     def _on_message(self, message: RoborockMessage) -> None:
         """Handle incoming messages from the device."""
         _LOGGER.debug("Received message from device: %s", message)
+
+    def diagnostic_data(self) -> dict[str, Any]:
+        """Return diagnostics information about the device."""
+        extra: dict[str, Any] = {}
+        if self.v1_properties:
+            extra["traits"] = _redact_data(self.v1_properties.as_dict())
+        return {
+            "device": _redact_data(self.device_info.as_dict()),
+            "product": _redact_data(self.product.as_dict()),
+            **extra,
+        }
+
+
+T = TypeVar("T")
+
+REDACT_KEYS = {"duid", "localKey", "mac", "bssid", "sn", "ip"}
+REDACTED = "**REDACTED**"
+
+
+def _redact_data(data: T) -> 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_data(item) for item in data])
+
+    redacted = {**data}
+
+    for key, value in redacted.items():
+        if key in REDACT_KEYS:
+            redacted[key] = REDACTED
+        elif isinstance(value, dict):
+            redacted[key] = _redact_data(value)
+        elif isinstance(value, list):
+            redacted[key] = [_redact_data(item) for item in value]
+
+    return redacted

{python_roborock-3.0.0 → python_roborock-3.2.0}/roborock/devices/device_manager.py

@@ -157,6 +157,7 @@ async def create_device_manager(
             case DeviceVersion.V1:
                 channel = create_v1_channel(user_data, mqtt_params, mqtt_session, device, cache)
                 trait = v1.create(
+                    device.duid,
                     product,
                     home_data,
                     channel.rpc_channel,

{python_roborock-3.0.0 → python_roborock-3.2.0}/roborock/devices/traits/v1/__init__.py

@@ -34,7 +34,7 @@ import logging
 from dataclasses import dataclass, field, fields
 from typing import Any, get_args
 
-from roborock.data.containers import HomeData, HomeDataProduct
+from roborock.data.containers import HomeData, HomeDataProduct, RoborockBase
 from roborock.data.v1.v1_code_mappings import RoborockDockTypeCode
 from roborock.devices.cache import Cache
 from roborock.devices.traits import Trait
@@ -42,7 +42,6 @@ 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
@@ -55,6 +54,7 @@ from .home import HomeTrait
 from .led_status import LedStatusTrait
 from .map_content import MapContentTrait
 from .maps import MapsTrait
+from .network_info import NetworkInfoTrait
 from .rooms import RoomsTrait
 from .smart_wash_params import SmartWashParamsTrait
 from .status import StatusTrait
@@ -70,7 +70,6 @@ __all__ = [
     "StatusTrait",
     "DoNotDisturbTrait",
     "CleanSummaryTrait",
-    "CleanRecordTrait",
     "SoundVolumeTrait",
     "MapsTrait",
     "MapContentTrait",
@@ -85,6 +84,7 @@ __all__ = [
     "DustCollectionModeTrait",
     "WashTowelModeTrait",
     "SmartWashParamsTrait",
+    "NetworkInfoTrait",
 ]
 
 
@@ -100,7 +100,6 @@ class PropertiesApi(Trait):
     command: CommandTrait
     dnd: DoNotDisturbTrait
     clean_summary: CleanSummaryTrait
-    clean_record: CleanRecordTrait
     sound_volume: SoundVolumeTrait
     rooms: RoomsTrait
     maps: MapsTrait
@@ -108,6 +107,7 @@ class PropertiesApi(Trait):
     consumables: ConsumableTrait
     home: HomeTrait
     device_features: DeviceFeaturesTrait
+    network_info: NetworkInfoTrait
 
     # Optional features that may not be supported on all devices
     child_lock: ChildLockTrait | None = None
@@ -120,6 +120,7 @@ class PropertiesApi(Trait):
 
     def __init__(
         self,
+        device_uid: str,
         product: HomeDataProduct,
         home_data: HomeData,
         rpc_channel: V1RpcChannel,
@@ -129,20 +130,20 @@ class PropertiesApi(Trait):
         map_parser_config: MapParserConfig | None = None,
     ) -> None:
         """Initialize the V1TraitProps."""
+        self._device_uid = device_uid
         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)
+        self.network_info = NetworkInfoTrait(device_uid, cache)
 
         # Dynamically create any traits that need to be populated
         for item in fields(self):
@@ -246,8 +247,21 @@ class PropertiesApi(Trait):
         _LOGGER.debug("Updating cached trait data: %s", cache_data.trait_data)
         await self._cache.set(cache_data)
 
+    def as_dict(self) -> dict[str, Any]:
+        """Return the trait data as a dictionary."""
+        result: dict[str, Any] = {}
+        for item in fields(self):
+            trait = getattr(self, item.name, None)
+            if trait is None or not isinstance(trait, RoborockBase):
+                continue
+            data = trait.as_dict()
+            if data:  # Don't omit unset traits
+                result[item.name] = data
+        return result
+
 
 def create(
+    device_uid: str,
     product: HomeDataProduct,
     home_data: HomeData,
     rpc_channel: V1RpcChannel,
@@ -257,4 +271,13 @@ def create(
     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)
+    return PropertiesApi(
+        device_uid,
+        product,
+        home_data,
+        rpc_channel,
+        mqtt_rpc_channel,
+        map_rpc_channel,
+        cache,
+        map_parser_config,
+    )

python_roborock-3.0.0/roborock/devices/traits/v1/clean_record.py → python_roborock-3.2.0/roborock/devices/traits/v1/clean_summary.py

@@ -1,44 +1,57 @@
-"""Trait for getting the last clean record."""
-
 import logging
 from typing import Self
 
-from roborock.data import CleanRecord
+from roborock.data import CleanRecord, CleanSummaryWithDetail
 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."""
+class CleanSummaryTrait(CleanSummaryWithDetail, common.V1TraitMixin):
+    """Trait for managing the clean summary of Roborock devices."""
 
-    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
+    command = RoborockCommand.GET_CLEAN_SUMMARY
 
     async def refresh(self) -> Self:
-        """Get the last clean record.
+        """Refresh the clean summary data and last clean record.
 
         Assumes that the clean summary has already been fetched.
         """
-        if not self._clean_summary_trait.records:
+        await super().refresh()
+        if not self.records:
             _LOGGER.debug("No clean records available in clean summary.")
+            self.last_clean_record = None
             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)
+        last_record_id = self.records[-1]
+        self.last_clean_record = await self.get_clean_record(last_record_id)
         return self
 
     @classmethod
-    def _parse_type_response(cls, response: common.V1ResponseData) -> CleanRecord:
+    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}")
+
+    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:
         """Parse the response from the device into a CleanRecord."""
         if isinstance(response, dict):
             return CleanRecord.from_dict(response)
@@ -47,7 +60,7 @@ class CleanRecordTrait(CleanRecord, common.V1TraitMixin):
                 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.
+                    # This code is semi-presumptuous - 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

{python_roborock-3.0.0 → python_roborock-3.2.0}/roborock/devices/traits/v1/device_features.py

@@ -1,3 +1,4 @@
+from dataclasses import fields
 from typing import Self
 
 from roborock.data import AppInitStatus, RoborockProductNickname
@@ -16,6 +17,10 @@ class DeviceFeaturesTrait(DeviceFeatures, common.V1TraitMixin):
         """Initialize MapContentTrait."""
         self._nickname = product_nickname
         self._cache = 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)
 
     async def refresh(self) -> Self:
         """Refresh the contents of this trait.

python_roborock-3.2.0/roborock/devices/traits/v1/network_info.py

@@ -0,0 +1,57 @@
+"""Trait for device network information."""
+
+from __future__ import annotations
+
+import logging
+from typing import Self
+
+from roborock.data import NetworkInfo
+from roborock.devices.cache import Cache
+from roborock.devices.traits.v1 import common
+from roborock.roborock_typing import RoborockCommand
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class NetworkInfoTrait(NetworkInfo, common.V1TraitMixin):
+    """Trait for device network information.
+
+    This trait will always prefer reading from the cache if available. This
+    information is usually already fetched when creating the device local
+    connection, so reading from the cache avoids an unnecessary RPC call.
+    However, we have the fallback to reading from the device if the cache is
+    not populated for some reason.
+    """
+
+    command = RoborockCommand.GET_NETWORK_INFO
+
+    def __init__(self, device_uid: str, cache: Cache) -> None:
+        """Initialize the trait."""
+        self._device_uid = device_uid
+        self._cache = cache
+        self.ip = ""
+
+    async def refresh(self) -> Self:
+        """Refresh the network info from the cache."""
+
+        cache_data = await self._cache.get()
+        if cache_data.network_info and (network_info := cache_data.network_info.get(self._device_uid)):
+            _LOGGER.debug("Using cached network info for device %s", self._device_uid)
+            self._update_trait_values(network_info)
+            return self
+
+        # Load from device if not in cache
+        _LOGGER.debug("No cached network info for device %s, fetching from device", self._device_uid)
+        await super().refresh()
+
+        # Update the cache with the new network info
+        cache_data.network_info[self._device_uid] = self
+        await self._cache.set(cache_data)
+
+        return self
+
+    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-3.0.0 → python_roborock-3.2.0}/roborock/version_1_apis/roborock_client_v1.py

@@ -207,7 +207,7 @@ class RoborockClientV1(RoborockClient, ABC):
                 records = [CleanRecord.from_dict(rec) for rec in record]
                 final_record = records[-1]
                 try:
-                    # This code is semi-presumptions - so it is put in a try finally to be safe.
+                    # This code is semi-presumptuous - 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

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

@@ -1,29 +0,0 @@
-from typing import Self
-
-from roborock.data 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}")