python-roborock 7.2.3__tar.gz → 7.4.0__tar.gz

{python_roborock-7.2.3 → python_roborock-7.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: python-roborock
-Version: 7.2.3
+Version: 7.4.0
 Summary: A package to control Roborock vacuums.
 Project-URL: Repository, https://github.com/python-roborock/python-roborock
 Project-URL: Documentation, https://python-roborock.readthedocs.io/

{python_roborock-7.2.3 → python_roborock-7.4.0}/pyproject.toml

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

@@ -348,6 +348,24 @@ class HomeDataScene(RoborockBase):
     name: str
 
 
+@dataclass
+class FirmwareInfo(RoborockBase):
+    """Firmware/OTA info from the cloud (`ota/firmware/{duid}/updatev2`)."""
+
+    version: str | None = None
+    """Latest available firmware version."""
+    current_version: str | None = None
+    """Currently installed firmware version."""
+    updatable: bool | None = None
+    """Whether a newer firmware is available to install."""
+    desc: str | None = None
+    """Release notes / description."""
+    release_time: str | None = None
+    """Release date of the available firmware as an ISO-8601 date (``YYYY-MM-DD``)."""
+    force_update: bool | None = None
+    """Whether the update is mandatory (cannot be skipped)."""
+
+
 @dataclass
 class HomeDataSchedule(RoborockBase):
     id: int

{python_roborock-7.2.3 → python_roborock-7.4.0}/roborock/devices/device.py

@@ -206,6 +206,8 @@ class RoborockDevice(ABC, TraitsMixin):
                 await self.b01_q7_properties.start()
             elif self.zeo is not None:
                 await self.zeo.start()
+            elif self.dyad is not None:
+                await self.dyad.start()
         except RoborockException:
             # Expected: start() can fail transiently. Unsubscribe before propagating
             # so the retry by connect_loop() gets a clean channel.
@@ -238,6 +240,8 @@ class RoborockDevice(ABC, TraitsMixin):
             await self.b01_q7_properties.close()
         if self.zeo is not None:
             self.zeo.close()
+        if self.dyad is not None:
+            self.dyad.close()
         if self._unsub:
             self._unsub()
             self._unsub = None

{python_roborock-7.2.3 → python_roborock-7.4.0}/roborock/devices/device_manager.py

@@ -255,7 +255,7 @@ async def create_device_manager(
                 )
             case DeviceVersion.A01:
                 channel = create_mqtt_channel(user_data, mqtt_params, mqtt_session, device)
-                trait = a01.create(product, channel)
+                trait = a01.create(product, channel, device_status=device.device_status)
             case DeviceVersion.B01:
                 mqtt_channel = create_mqtt_channel(user_data, mqtt_params, mqtt_session, device)
                 model_part = product.model.split(".")[-1]

{python_roborock-7.2.3 → python_roborock-7.4.0}/roborock/devices/traits/a01/__init__.py

@@ -6,7 +6,7 @@ Dyad (Wet/Dry Vacuums) and Zeo (Washing Machines).
 Using A01 APIs
 --------------
 A01 devices expose a single API object that handles all device interactions. This API is
-available on the device instance (typically via `device.a01_properties`).
+available on the device instance (`device.dyad` or `device.zeo`).
 
 The API provides these methods:
 1.  **query_values(protocols)**: Fetches current state for specific data points.
@@ -14,18 +14,22 @@ The API provides these methods:
     `RoborockZeoProtocol`) to request specific data.
 2.  **set_value(protocol, value)**: Sends a command to the device to change a setting
     or perform an action.
-3.  **add_listener(callback)**: Subscribes to state the device pushes on its own (for
-    example when its state changes), invoking the callback with decoded values.
-
-Note that these APIs fetch data directly from the device upon request and do not
-cache state internally.
+3.  **values**: The latest known state, merged from query responses and unsolicited
+    pushes in arrival order.
+4.  **add_update_listener(callback)**: Registers a callback invoked whenever `values`
+    changes; read `values` from the callback to get the updated state.
+
+The device pushes only the data points that changed, so `values` is the merged view
+of everything seen so far. State tracking is active once the device is connected
+(the device calls `start()` on the API, which subscribes to the MQTT topic).
 """
 
 import json
 import logging
+from abc import abstractmethod
 from collections.abc import Callable
-from datetime import time
-from typing import Any
+from datetime import UTC, datetime, time
+from typing import Any, Generic, TypeVar
 
 from roborock.data import DyadProductInfo, DyadSndState, HomeDataProduct, RoborockCategory
 from roborock.data.dyad.dyad_code_mappings import (
@@ -73,6 +77,7 @@ from roborock.roborock_message import (
 _LOGGER = logging.getLogger(__name__)
 
 __all__ = [
+    "A01Api",
     "DyadApi",
     "ZeoApi",
 ]
@@ -155,14 +160,121 @@ def convert_zeo_value(protocol_value: RoborockZeoProtocol, value: Any) -> Any:
 
 
 _DYAD_PROTOCOL_VALUES = frozenset(protocol.value for protocol in RoborockDyadDataProtocol)
+_ZEO_PROTOCOL_VALUES = frozenset(protocol.value for protocol in RoborockZeoProtocol)
 
+_P = TypeVar("_P", RoborockDyadDataProtocol, RoborockZeoProtocol)
 
-class DyadApi(Trait):
-    """API for interacting with Dyad devices."""
 
-    def __init__(self, channel: MqttChannel) -> None:
-        """Initialize the Dyad API."""
+class A01Api(Trait, TraitUpdateListener, Generic[_P]):
+    """Base class for A01 device APIs with device state tracking.
+
+    Query responses and unsolicited pushes both arrive on the same MQTT topic,
+    so a single subscription merges every decoded message into `values` in
+    arrival order. Update listeners are notified whenever a value changes.
+    """
+
+    def __init__(self, channel: MqttChannel, initial_status: dict[int, Any] | None = None) -> None:
+        """Initialize the A01 API, optionally seeding `values` from a cloud status snapshot."""
+        TraitUpdateListener.__init__(self, _LOGGER)
         self._channel = channel
+        self._values: dict[_P, Any] = {}
+        self._unsub: Callable[[], None] | None = None
+        self._last_message_time: datetime | None = None
+        if initial_status:
+            self._merge_values(self._decode_datapoints(initial_status))
+
+    @property
+    def values(self) -> dict[_P, Any]:
+        """Latest known device state, merged from query responses and pushes.
+
+        The device pushes only the data points that changed, so this is the
+        merged view of everything seen so far. A protocol the device has not
+        reported yet is absent from the dictionary.
+        """
+        return dict(self._values)
+
+    @property
+    def last_message_time(self) -> datetime | None:
+        """Time the last message was received from the device.
+
+        Updated on every decoded message, even when no value changed: idle
+        devices push an identical heartbeat, so this is the liveness signal
+        even when `values` stays the same and update listeners stay silent.
+        The initial cloud status snapshot does not count as a message.
+        """
+        return self._last_message_time
+
+    async def start(self) -> None:
+        """Subscribe to the device state topic and start tracking `values`."""
+        await self._ensure_subscribed()
+
+    def close(self) -> None:
+        """Unsubscribe from MQTT push and release resources."""
+        if self._unsub is not None:
+            self._unsub()
+            self._unsub = None
+
+    async def _ensure_subscribed(self) -> None:
+        """Subscribe to MQTT DPS push (idempotent)."""
+        if self._unsub is not None:
+            return
+        self._unsub = await self._channel.subscribe(self._on_message)
+
+    @abstractmethod
+    def _decode_datapoints(self, datapoints: dict[int, Any]) -> dict[_P, Any]:
+        """Convert raw datapoints to typed values, skipping unknown codes."""
+
+    def _on_message(self, message: RoborockMessage) -> None:
+        """Handle a message on the device topic (query response or push)."""
+        if message.protocol != RoborockMessageProtocol.RPC_RESPONSE:
+            return
+        try:
+            datapoints = decode_rpc_response(message)
+        except RoborockException:
+            _LOGGER.debug("Dropped malformed push message", exc_info=True)
+            return
+        self._last_message_time = datetime.now(UTC)
+        self._merge_values(self._decode_datapoints(datapoints))
+
+    def _merge_query_response(self, values: dict[_P, Any]) -> None:
+        """Record a successful query response when there is no subscription.
+
+        When subscribed, the response was already merged in arrival order and
+        timestamped by `_on_message`; merging again here could overwrite a
+        push that arrived after it.
+        """
+        if self._unsub is not None:
+            return
+        self._last_message_time = datetime.now(UTC)
+        self._merge_values(values)
+
+    def _merge_values(self, values: dict[_P, Any]) -> None:
+        """Merge decoded values into the cache and notify on change."""
+        changed = False
+        for protocol, value in values.items():
+            if value is None:
+                continue
+            if protocol not in self._values or self._values[protocol] != value:
+                self._values[protocol] = value
+                changed = True
+        if changed:
+            self._notify_update()
+
+
+class DyadApi(A01Api[RoborockDyadDataProtocol]):
+    """API for interacting with Dyad devices."""
+
+    name = "dyad"
+
+    def _decode_datapoints(self, datapoints: dict[int, Any]) -> dict[RoborockDyadDataProtocol, Any]:
+        """Convert raw datapoints to typed values, skipping unknown codes."""
+        values: dict[RoborockDyadDataProtocol, Any] = {}
+        for code, value in datapoints.items():
+            if code not in _DYAD_PROTOCOL_VALUES:
+                continue
+            protocol = RoborockDyadDataProtocol(code)
+            values[protocol] = convert_dyad_value(protocol, value)
+        return values
 
     async def query_values(self, protocols: list[RoborockDyadDataProtocol]) -> dict[RoborockDyadDataProtocol, Any]:
         """Query the device for the values of the given Dyad protocols."""
@@ -171,7 +283,9 @@ class DyadApi(Trait):
             {RoborockDyadDataProtocol.ID_QUERY: protocols},
             value_encoder=json.dumps,
         )
-        return {protocol: convert_dyad_value(protocol, response.get(protocol)) for protocol in protocols}
+        values = {protocol: convert_dyad_value(protocol, response.get(protocol)) for protocol in protocols}
+        self._merge_query_response(values)
+        return values
 
     async def set_value(self, protocol: RoborockDyadDataProtocol, value: Any) -> dict[RoborockDyadDataProtocol, Any]:
         """Set a value for a specific protocol on the device."""
@@ -184,6 +298,9 @@ class DyadApi(Trait):
         The callback is invoked with decoded values whenever the device sends a
         message, including unsolicited pushes when its state changes. Only known
         protocols are delivered. Returns a callable to remove the listener.
+
+        Prefer `add_update_listener` together with `values`, which handle the
+        merging of partial pushes for you.
         """
 
         def on_message(message: RoborockMessage) -> None:
@@ -191,31 +308,24 @@ class DyadApi(Trait):
                 datapoints = decode_rpc_response(message)
             except RoborockException:
                 return
-            values: dict[RoborockDyadDataProtocol, Any] = {}
-            for code, value in datapoints.items():
-                if code not in _DYAD_PROTOCOL_VALUES:
-                    continue
-                protocol = RoborockDyadDataProtocol(code)
-                values[protocol] = convert_dyad_value(protocol, value)
-            if values:
+            if values := self._decode_datapoints(datapoints):
                 callback(values)
 
         return await self._channel.subscribe(on_message)
 
 
-class ZeoApi(Trait, TraitUpdateListener):
+class ZeoApi(A01Api[RoborockZeoProtocol]):
     """API for interacting with Zeo devices."""
 
     name = "zeo"
 
-    def __init__(self, channel: MqttChannel, model: str | None = None) -> None:
+    def __init__(
+        self, channel: MqttChannel, model: str | None = None, initial_status: dict[int, Any] | None = None
+    ) -> None:
         """Initialize the Zeo API."""
-        TraitUpdateListener.__init__(self, _LOGGER)
-        self._channel = channel
-        self._dps_cache: dict[int, Any] = {}
-        self._dps_unsub: Callable[[], None] | None = None
         self._feature_bits: int = 0
         self._model = model
+        super().__init__(channel, initial_status)
 
     async def start(self) -> None:
         """Subscribe to MQTT push and trigger a full state sync.
@@ -230,17 +340,15 @@ class ZeoApi(Trait, TraitUpdateListener):
         await self._force_load()
         await self._load_feature_dps()
 
-    def close(self) -> None:
-        """Unsubscribe from MQTT push and release resources."""
-        if self._dps_unsub is not None:
-            self._dps_unsub()
-            self._dps_unsub = None
-
-    async def _ensure_subscribed(self) -> None:
-        """Subscribe to MQTT DPS push (idempotent)."""
-        if self._dps_unsub is not None:
-            return
-        self._dps_unsub = await self._channel.subscribe(self._on_dps_message)
+    def _decode_datapoints(self, datapoints: dict[int, Any]) -> dict[RoborockZeoProtocol, Any]:
+        """Convert raw datapoints to typed values, skipping unknown codes."""
+        values: dict[RoborockZeoProtocol, Any] = {}
+        for code, value in datapoints.items():
+            if code not in _ZEO_PROTOCOL_VALUES:
+                continue
+            protocol = RoborockZeoProtocol(code)
+            values[protocol] = convert_zeo_value(protocol, value)
+        return values
 
     async def _force_load(self) -> None:
         """Send ID_QUERY with the base DP list to trigger a full state push.
@@ -279,18 +387,6 @@ class ZeoApi(Trait, TraitUpdateListener):
         """Check whether the device supports a given feature bit."""
         return bool(self._feature_bits & (1 << feature.value))
 
-    def _on_dps_message(self, message: RoborockMessage) -> None:
-        """Handle unsolicited MQTT push (protocol 102 — RPC_RESPONSE)."""
-        if message.protocol != RoborockMessageProtocol.RPC_RESPONSE:
-            return
-        try:
-            decoded = decode_rpc_response(message)
-        except RoborockException:
-            _LOGGER.debug("Dropped malformed push message", exc_info=True)
-            return
-        self._dps_cache.update(decoded)
-        self._notify_update()
-
     async def query_values(self, protocols: list[RoborockZeoProtocol]) -> dict[RoborockZeoProtocol, Any]:
         """Query the device for the values of the given protocols."""
         response = await send_decoded_command(
@@ -298,7 +394,9 @@ class ZeoApi(Trait, TraitUpdateListener):
             {RoborockZeoProtocol.ID_QUERY: protocols},
             value_encoder=json.dumps,
         )
-        return {protocol: convert_zeo_value(protocol, response.get(protocol)) for protocol in protocols}
+        values = {protocol: convert_zeo_value(protocol, response.get(protocol)) for protocol in protocols}
+        self._merge_query_response(values)
+        return values
 
     async def set_value(self, protocol: RoborockZeoProtocol, value: Any) -> dict[RoborockZeoProtocol, Any]:
         """Set a value for a specific protocol on the device."""
@@ -306,12 +404,28 @@ class ZeoApi(Trait, TraitUpdateListener):
         return await send_decoded_command(self._channel, params, value_encoder=lambda x: x)
 
 
-def create(product: HomeDataProduct, mqtt_channel: MqttChannel) -> DyadApi | ZeoApi:
-    """Create traits for A01 devices."""
+def _parse_device_status(device_status: dict | None) -> dict[int, Any] | None:
+    """Normalize the cloud home data status snapshot to integer datapoint codes."""
+    if not device_status:
+        return None
+    try:
+        return {int(code): value for code, value in device_status.items()}
+    except (TypeError, ValueError):
+        _LOGGER.debug("Ignoring malformed device status snapshot: %s", device_status)
+        return None
+
+
+def create(product: HomeDataProduct, mqtt_channel: MqttChannel, device_status: dict | None = None) -> DyadApi | ZeoApi:
+    """Create traits for A01 devices.
+
+    The optional `device_status` is the cloud home data status snapshot, used
+    to seed `values` so state is available before the first device round trip.
+    """
+    initial_status = _parse_device_status(device_status)
     match product.category:
         case RoborockCategory.WET_DRY_VAC:
-            return DyadApi(mqtt_channel)
+            return DyadApi(mqtt_channel, initial_status=initial_status)
         case RoborockCategory.WASHING_MACHINE:
-            return ZeoApi(mqtt_channel, model=product.model)
+            return ZeoApi(mqtt_channel, model=product.model, initial_status=initial_status)
         case _:
             raise NotImplementedError(f"Unsupported category {product.category}")

{python_roborock-7.2.3 → python_roborock-7.4.0}/roborock/web_api.py

@@ -15,7 +15,7 @@ from aiohttp import ContentTypeError, FormData
 from pyrate_limiter import Duration, Limiter, Rate
 
 from roborock import HomeDataSchedule
-from roborock.data import HomeData, HomeDataRoom, HomeDataScene, ProductResponse, RRiot, UserData
+from roborock.data import FirmwareInfo, HomeData, HomeDataRoom, HomeDataScene, ProductResponse, RRiot, UserData
 from roborock.exceptions import (
     RoborockAccountDoesNotExist,
     RoborockException,
@@ -608,6 +608,73 @@ class RoborockApiClient:
         else:
             raise RoborockException("scene_response result was an unexpected type")
 
+    async def get_firmware_info(self, user_data: UserData, device_id: str) -> FirmwareInfo:
+        """Get firmware/OTA info for a device (latest version + updatable flag)."""
+        rriot = user_data.rriot
+        if rriot is None:
+            raise RoborockException("rriot is none")
+        if rriot.r.a is None:
+            raise RoborockException("Missing field 'a' in rriot reference")
+        path = f"/ota/firmware/{device_id}/updatev2"
+        params = {"lang": "en"}
+        firmware_request = PreparedRequest(
+            rriot.r.a,
+            self.session,
+            {
+                "Authorization": _get_hawk_authentication(rriot, path, params=params),
+            },
+        )
+        firmware_response = await firmware_request.request("get", path, params=params)
+        if not firmware_response or not firmware_response.get("success"):
+            raise RoborockException(firmware_response)
+        return FirmwareInfo.from_dict(firmware_response.get("result") or {})
+
+    async def start_firmware_update(self, user_data: UserData, device_id: str) -> None:
+        """Trigger the (irreversible) firmware update for a device.
+
+        The device downloads and flashes the latest firmware reported by
+        :meth:`get_firmware_info`.
+        """
+        rriot = user_data.rriot
+        if rriot is None:
+            raise RoborockException("rriot is none")
+        if rriot.r.a is None:
+            raise RoborockException("Missing field 'a' in rriot reference")
+        path = f"/ota/device/{device_id}/upgrade"
+        upgrade_request = PreparedRequest(
+            rriot.r.a,
+            self.session,
+            {
+                "Authorization": _get_hawk_authentication(rriot, path),
+            },
+        )
+        upgrade_response = await upgrade_request.request("post", path)
+        if not upgrade_response or not upgrade_response.get("success"):
+            raise RoborockException(upgrade_response)
+
+    async def set_silent_ota(self, user_data: UserData, device_id: str, enabled: bool) -> None:
+        """Enable/disable automatic (silent) firmware updates for a device.
+
+        The current value is reported as ``silent_ota_switch`` on the home-data device.
+        """
+        rriot = user_data.rriot
+        if rriot is None:
+            raise RoborockException("rriot is none")
+        if rriot.r.a is None:
+            raise RoborockException("Missing field 'a' in rriot reference")
+        path = f"/user/devices/{device_id}"
+        formdata = {"silentOtaSwitch": "true" if enabled else "false"}
+        silent_ota_request = PreparedRequest(
+            rriot.r.a,
+            self.session,
+            {
+                "Authorization": _get_hawk_authentication(rriot, path, formdata=formdata),
+            },
+        )
+        silent_ota_response = await silent_ota_request.request("put", path, data=formdata)
+        if not silent_ota_response or not silent_ota_response.get("success"):
+            raise RoborockException(silent_ota_response)
+
     async def execute_scene(self, user_data: UserData, scene_id: int) -> None:
         rriot = user_data.rriot
         if rriot is None: