python-roborock 3.8.0__tar.gz → 3.8.2__tar.gz

{python_roborock-3.8.0 → python_roborock-3.8.2}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "python-roborock"
-version = "3.8.0"
+version = "3.8.2"
 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.4",
+    "ruff==0.14.6",
     "codespell",
     "pyshark>=0.6,<0.7",
     "aioresponses>=0.7.7,<0.8",

{python_roborock-3.8.0 → python_roborock-3.8.2}/roborock/devices/device.py

@@ -143,8 +143,15 @@ class RoborockDevice(ABC, TraitsMixin):
         """Connect to the device using the appropriate protocol channel."""
         if self._unsub:
             raise ValueError("Already connected to the device")
-        self._unsub = await self._channel.subscribe(self._on_message)
+        unsub = await self._channel.subscribe(self._on_message)
         _LOGGER.info("Connected to V1 device %s", self.name)
+        if self.v1_properties is not None:
+            try:
+                await self.v1_properties.discover_features()
+            except RoborockException:
+                unsub()
+                raise
+        self._unsub = unsub
 
     async def close(self) -> None:
         """Close all connections to the device."""

{python_roborock-3.8.0 → python_roborock-3.8.2}/roborock/devices/local_channel.py

@@ -62,7 +62,14 @@ class LocalChannel(Channel):
             LocalChannelParams(local_key=local_key, connect_nonce=get_next_int(10000, 32767), ack_nonce=None)
         )
 
-    def _update_encoder_decoder(self, params: LocalChannelParams):
+    def _update_encoder_decoder(self, params: LocalChannelParams) -> None:
+        """Update the encoder and decoder with new parameters.
+
+        This is invoked once with an initial set of values used for protocol
+        negotiation. Once negotiation completes, it is updated again to set the
+        correct nonces for the follow up communications and updates the encoder
+        and decoder functions accordingly.
+        """
         self._params = params
         self._encoder = create_local_encoder(
             local_key=params.local_key, connect_nonce=params.connect_nonce, ack_nonce=params.ack_nonce
@@ -71,7 +78,7 @@ class LocalChannel(Channel):
             local_key=params.local_key, connect_nonce=params.connect_nonce, ack_nonce=params.ack_nonce
         )
         # Callback to decode messages and dispatch to subscribers
-        self._data_received: Callable[[bytes], None] = decoder_callback(self._decoder, self._subscribers, _LOGGER)
+        self._dispatch = decoder_callback(self._decoder, self._subscribers, _LOGGER)
 
     async def _do_hello(self, local_protocol_version: LocalProtocolVersion) -> LocalChannelParams | None:
         """Perform the initial handshaking and return encoder params if successful."""
@@ -125,6 +132,13 @@ class LocalChannel(Channel):
 
         raise RoborockException("Failed to connect to device with any known protocol")
 
+    @property
+    def protocol_version(self) -> LocalProtocolVersion:
+        """Return the negotiated local protocol version, or a sensible default."""
+        if self._local_protocol_version is not None:
+            return self._local_protocol_version
+        return LocalProtocolVersion.V1
+
     @property
     def is_connected(self) -> bool:
         """Check if the channel is currently connected."""
@@ -157,6 +171,10 @@ class LocalChannel(Channel):
             self.close()
             raise
 
+    def _data_received(self, data: bytes) -> None:
+        """Invoked when data is received on the stream."""
+        self._dispatch(data)
+
     def close(self) -> None:
         """Disconnect from the device."""
         if self._transport:

{python_roborock-3.8.0 → python_roborock-3.8.2}/roborock/devices/traits/v1/child_lock.py

@@ -19,7 +19,11 @@ class ChildLockTrait(ChildLockStatus, common.V1TraitMixin, common.RoborockSwitch
     async def enable(self) -> None:
         """Enable the child lock."""
         await self.rpc_channel.send_command(RoborockCommand.SET_CHILD_LOCK_STATUS, params={_STATUS_PARAM: 1})
+        # Optimistic update to avoid an extra refresh
+        self.lock_status = 1
 
     async def disable(self) -> None:
         """Disable the child lock."""
         await self.rpc_channel.send_command(RoborockCommand.SET_CHILD_LOCK_STATUS, params={_STATUS_PARAM: 0})
+        # Optimistic update to avoid an extra refresh
+        self.lock_status = 0

{python_roborock-3.8.0 → python_roborock-3.8.2}/roborock/devices/traits/v1/command.py

@@ -16,7 +16,13 @@ class CommandTrait:
         self._rpc_channel = None
 
     async def send(self, command: RoborockCommand | str, params: ParamsType = None) -> Any:
-        """Send a command to the device."""
+        """Send a command to the device.
+
+        Sending a raw command to the device using this method does not update
+        the internal state of any other traits. It is the responsibility of the
+        caller to ensure that any traits affected by the command are refreshed
+        as needed.
+        """
         if not self._rpc_channel:
             raise ValueError("Device trait in invalid state")
         return await self._rpc_channel.send_command(command, params=params)

{python_roborock-3.8.0 → python_roborock-3.8.2}/roborock/devices/traits/v1/common.py

@@ -28,8 +28,14 @@ class V1TraitMixin(ABC):
     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.
+    from the device.
+
+    A trait can also support additional commands for updating state associated
+    with the trait. It is expected that a trait will update its own internal
+    state either reflecting the change optimistically or by refreshing the
+    trait state from the device. In cases where one trait caches data that is
+    also represented in another trait, it is the responsibility of the caller
+    to ensure that both traits are refreshed as needed to keep them in sync.
 
     The traits typically subclass RoborockBase to provide serialization
     and deserialization functionality, but this is not strictly required.

{python_roborock-3.8.0 → python_roborock-3.8.2}/roborock/devices/traits/v1/consumeable.py

@@ -45,3 +45,4 @@ class ConsumableTrait(Consumable, common.V1TraitMixin):
     async def reset_consumable(self, consumable: ConsumableAttribute) -> None:
         """Reset a specific consumable attribute on the device."""
         await self.rpc_channel.send_command(RoborockCommand.RESET_CONSUMABLE, params=[consumable.value])
+        await self.refresh()

{python_roborock-3.8.0 → python_roborock-3.8.2}/roborock/devices/traits/v1/do_not_disturb.py

@@ -18,10 +18,12 @@ class DoNotDisturbTrait(DnDTimer, common.V1TraitMixin, common.RoborockSwitchBase
     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_list())
+        await self.refresh()
 
     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)
+        await self.refresh()
 
     async def enable(self) -> None:
         """Set the Do Not Disturb (DND) timer settings of the device."""
@@ -29,7 +31,11 @@ class DoNotDisturbTrait(DnDTimer, common.V1TraitMixin, common.RoborockSwitchBase
             RoborockCommand.SET_DND_TIMER,
             params=self.as_list(),
         )
+        # Optimistic update to avoid an extra refresh
+        self.enabled = 1
 
     async def disable(self) -> None:
         """Disable the Do Not Disturb (DND) timer settings of the device."""
         await self.rpc_channel.send_command(RoborockCommand.CLOSE_DND_TIMER)
+        # Optimistic update to avoid an extra refresh
+        self.enabled = 0

{python_roborock-3.8.0 → python_roborock-3.8.2}/roborock/devices/traits/v1/flow_led_status.py

@@ -19,7 +19,11 @@ class FlowLedStatusTrait(FlowLedStatus, common.V1TraitMixin, common.RoborockSwit
     async def enable(self) -> None:
         """Enable the Flow LED status."""
         await self.rpc_channel.send_command(RoborockCommand.SET_FLOW_LED_STATUS, params={_STATUS_PARAM: 1})
+        # Optimistic update to avoid an extra refresh
+        self.status = 1
 
     async def disable(self) -> None:
         """Disable the Flow LED status."""
         await self.rpc_channel.send_command(RoborockCommand.SET_FLOW_LED_STATUS, params={_STATUS_PARAM: 0})
+        # Optimistic update to avoid an extra refresh
+        self.status = 0

{python_roborock-3.8.0 → python_roborock-3.8.2}/roborock/devices/traits/v1/led_status.py

@@ -19,10 +19,14 @@ class LedStatusTrait(LedStatus, common.V1TraitMixin, common.RoborockSwitchBase):
     async def enable(self) -> None:
         """Enable the LED status."""
         await self.rpc_channel.send_command(RoborockCommand.SET_LED_STATUS, params=[1])
+        # Optimistic update to avoid an extra refresh
+        self.status = 1
 
     async def disable(self) -> None:
         """Disable the LED status."""
         await self.rpc_channel.send_command(RoborockCommand.SET_LED_STATUS, params=[0])
+        # Optimistic update to avoid an extra refresh
+        self.status = 0
 
     @classmethod
     def _parse_type_response(cls, response: V1ResponseData) -> LedStatus:

{python_roborock-3.8.0 → python_roborock-3.8.2}/roborock/devices/traits/v1/valley_electricity_timer.py

@@ -19,10 +19,12 @@ class ValleyElectricityTimerTrait(ValleyElectricityTimer, common.V1TraitMixin, c
     async def set_timer(self, timer: ValleyElectricityTimer) -> None:
         """Set the Valley Electricity Timer settings of the device."""
         await self.rpc_channel.send_command(RoborockCommand.SET_VALLEY_ELECTRICITY_TIMER, params=timer.as_list())
+        await self.refresh()
 
     async def clear_timer(self) -> None:
         """Clear the Valley Electricity Timer settings of the device."""
         await self.rpc_channel.send_command(RoborockCommand.CLOSE_VALLEY_ELECTRICITY_TIMER)
+        await self.refresh()
 
     async def enable(self) -> None:
         """Enable the Valley Electricity Timer settings of the device."""
@@ -30,9 +32,13 @@ class ValleyElectricityTimerTrait(ValleyElectricityTimer, common.V1TraitMixin, c
             RoborockCommand.SET_VALLEY_ELECTRICITY_TIMER,
             params=self.as_list(),
         )
+        # Optimistic update to avoid an extra refresh
+        self.enabled = 1
 
     async def disable(self) -> None:
         """Disable the Valley Electricity Timer settings of the device."""
         await self.rpc_channel.send_command(
             RoborockCommand.CLOSE_VALLEY_ELECTRICITY_TIMER,
         )
+        # Optimistic update to avoid an extra refresh
+        self.enabled = 0

{python_roborock-3.8.0 → python_roborock-3.8.2}/roborock/devices/traits/v1/volume.py

@@ -24,3 +24,4 @@ class SoundVolumeTrait(SoundVolume, common.V1TraitMixin):
     async def set_volume(self, volume: int) -> None:
         """Set the sound volume of the device."""
         await self.rpc_channel.send_command(RoborockCommand.CHANGE_SOUND_VOLUME, params=[volume])
+        self.volume = volume

{python_roborock-3.8.0 → python_roborock-3.8.2}/roborock/devices/v1_rpc_channel.py

@@ -188,7 +188,7 @@ def create_local_rpc_channel(local_channel: LocalChannel) -> V1RpcChannel:
     return PayloadEncodedV1RpcChannel(
         "local",
         local_channel,
-        lambda x: x.encode_message(RoborockMessageProtocol.GENERAL_REQUEST),
+        lambda x: x.encode_message(RoborockMessageProtocol.GENERAL_REQUEST, version=local_channel.protocol_version),
         decode_rpc_response,
     )
 

{python_roborock-3.8.0 → python_roborock-3.8.2}/roborock/protocols/v1_protocol.py

@@ -73,14 +73,17 @@ class RequestMessage:
     request_id: int = field(default_factory=lambda: get_next_int(10000, 32767))
 
     def encode_message(
-        self, protocol: RoborockMessageProtocol, security_data: SecurityData | None = None, version: str = "1.0"
+        self,
+        protocol: RoborockMessageProtocol,
+        security_data: SecurityData | None = None,
+        version: LocalProtocolVersion = LocalProtocolVersion.V1,
     ) -> RoborockMessage:
         """Convert the request message to a RoborockMessage."""
         return RoborockMessage(
             timestamp=self.timestamp,
             protocol=protocol,
             payload=self._as_payload(security_data=security_data),
-            version=version.encode(),
+            version=version.value.encode(),
         )
 
     def _as_payload(self, security_data: SecurityData | None) -> bytes: