python-roborock 2.43.0__tar.gz → 2.44.1__tar.gz

{python_roborock-2.43.0 → python_roborock-2.44.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-roborock
-Version: 2.43.0
+Version: 2.44.1
 Summary: A package to control Roborock vacuums.
 Home-page: https://github.com/humbertogontijo/python-roborock
 License: GPL-3.0-only

{python_roborock-2.43.0 → python_roborock-2.44.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-roborock"
-version = "2.43.0"
+version = "2.44.1"
 description = "A package to control Roborock vacuums."
 authors = ["humbertogontijo <humbertogontijo@users.noreply.github.com>"]
 license = "GPL-3.0-only"

{python_roborock-2.43.0 → python_roborock-2.44.1}/roborock/cli.py

@@ -382,7 +382,7 @@ async def execute_scene(ctx, scene_id):
 @click.pass_context
 @async_command
 async def status(ctx, device_id: str):
-    """Get device status - unified implementation for both modes."""
+    """Get device status."""
     context: RoborockContext = ctx.obj
 
     device_manager = await context.get_device_manager()
@@ -414,6 +414,46 @@ async def clean_summary(ctx, device_id: str):
     click.echo(dump_json(clean_summary_result.as_dict()))
 
 
+@session.command()
+@click.option("--device_id", required=True)
+@click.pass_context
+@async_command
+async def volume(ctx, device_id: str):
+    """Get device volume."""
+    context: RoborockContext = ctx.obj
+
+    device_manager = await context.get_device_manager()
+    device = await device_manager.get_device(device_id)
+
+    if not (volume_trait := device.traits.get("sound_volume")):
+        click.echo(f"Device {device.name} does not have a volume trait")
+        return
+
+    volume_result = await volume_trait.get_volume()
+    click.echo(f"Device {device_id} volume:")
+    click.echo(volume_result)
+
+
+@session.command()
+@click.option("--device_id", required=True)
+@click.option("--volume", required=True, type=int)
+@click.pass_context
+@async_command
+async def set_volume(ctx, device_id: str, volume: int):
+    """Set the devicevolume."""
+    context: RoborockContext = ctx.obj
+
+    device_manager = await context.get_device_manager()
+    device = await device_manager.get_device(device_id)
+
+    if not (volume_trait := device.traits.get("sound_volume")):
+        click.echo(f"Device {device.name} does not have a volume trait")
+        return
+
+    await volume_trait.set_volume(volume)
+    click.echo(f"Set Device {device_id} volume to {volume}")
+
+
 @click.command()
 @click.option("--device_id", required=True)
 @click.option("--cmd", required=True)
@@ -653,6 +693,8 @@ cli.add_command(session)
 cli.add_command(get_device_info)
 cli.add_command(update_docs)
 cli.add_command(clean_summary)
+cli.add_command(volume)
+cli.add_command(set_volume)
 
 
 def main():

{python_roborock-2.43.0 → python_roborock-2.44.1}/roborock/devices/device_manager.py

@@ -5,6 +5,8 @@ import enum
 import logging
 from collections.abc import Awaitable, Callable
 
+import aiohttp
+
 from roborock.code_mappings import RoborockCategory
 from roborock.containers import (
     HomeData,
@@ -25,6 +27,7 @@ from .traits.b01.props import B01PropsApi
 from .traits.clean_summary import CleanSummaryTrait
 from .traits.dnd import DoNotDisturbTrait
 from .traits.dyad import DyadApi
+from .traits.sound_volume import SoundVolumeTrait
 from .traits.status import StatusTrait
 from .traits.trait import Trait
 from .traits.zeo import ZeoApi
@@ -112,7 +115,9 @@ class DeviceManager:
         await asyncio.gather(*tasks)
 
 
-def create_home_data_api(email: str, user_data: UserData) -> HomeDataApi:
+def create_home_data_api(
+    email: str, user_data: UserData, base_url: str | None = None, session: aiohttp.ClientSession | None = None
+) -> HomeDataApi:
     """Create a home data API wrapper.
 
     This function creates a wrapper around the Roborock API client to fetch
@@ -121,7 +126,7 @@ def create_home_data_api(email: str, user_data: UserData) -> HomeDataApi:
 
     # Note: This will auto discover the API base URL. This can be improved
     # by caching this next to `UserData` if needed to avoid unnecessary API calls.
-    client = RoborockApiClient(email)
+    client = RoborockApiClient(username=email, base_url=base_url, session=session)
 
     async def home_data_api() -> HomeData:
         return await client.get_home_data_v3(user_data)
@@ -156,6 +161,7 @@ async def create_device_manager(
                 traits.append(StatusTrait(product, channel.rpc_channel))
                 traits.append(DoNotDisturbTrait(channel.rpc_channel))
                 traits.append(CleanSummaryTrait(channel.rpc_channel))
+                traits.append(SoundVolumeTrait(channel.rpc_channel))
             case DeviceVersion.A01:
                 mqtt_channel = create_mqtt_channel(user_data, mqtt_params, mqtt_session, device)
                 match product.category:

python_roborock-2.44.1/roborock/devices/traits/sound_volume.py

@@ -0,0 +1,31 @@
+"""Module for controlling the sound volume of Roborock devices."""
+
+from roborock.devices.traits.trait import Trait
+from roborock.devices.v1_rpc_channel import V1RpcChannel
+from roborock.exceptions import RoborockException
+from roborock.roborock_typing import RoborockCommand
+
+__all__ = [
+    "SoundVolumeTrait",
+]
+
+
+class SoundVolumeTrait(Trait):
+    """Trait for controlling the sound volume of a Roborock device."""
+
+    name = "sound_volume"
+
+    def __init__(self, rpc_channel: V1RpcChannel) -> None:
+        """Initialize the SoundVolumeTrait."""
+        self._rpc_channel = rpc_channel
+
+    async def get_volume(self) -> int:
+        """Get the current sound volume of the device."""
+        response = await self._rpc_channel.send_command(RoborockCommand.GET_SOUND_VOLUME)
+        if not isinstance(response, list) or not response:
+            raise RoborockException(f"Unexpected volume format: {response!r}")
+        return int(response[0])
+
+    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])

{python_roborock-2.43.0 → python_roborock-2.44.1}/roborock/devices/v1_rpc_channel.py

@@ -149,7 +149,10 @@ class PayloadEncodedV1RpcChannel(BaseV1RpcChannel):
                 return
             _LOGGER.debug("Received response (request_id=%s): %s", self._name, decoded.request_id)
             if decoded.request_id == request_message.request_id:
-                future.set_result(decoded.data)
+                if decoded.api_error:
+                    future.set_exception(decoded.api_error)
+                else:
+                    future.set_result(decoded.data)
 
         unsub = await self._channel.subscribe(find_response)
         try:

{python_roborock-2.43.0 → python_roborock-2.44.1}/roborock/protocols/v1_protocol.py

@@ -108,9 +108,18 @@ class ResponseMessage:
     data: ResponseData
     """The data of the response, where the type depends on the command."""
 
+    api_error: RoborockException | None = None
+    """The API error message of the response if any."""
+
 
 def decode_rpc_response(message: RoborockMessage) -> ResponseMessage:
-    """Decode a V1 RPC_RESPONSE message."""
+    """Decode a V1 RPC_RESPONSE message.
+
+    This will raise a RoborockException if the message cannot be parsed. A
+    response object will be returned even if there is an error in the
+    response, as long as we can extract the request ID. This is so we can
+    associate an API response with a request even if there was an error.
+    """
     if not message.payload:
         return ResponseMessage(request_id=message.seq, data={})
     try:
@@ -136,19 +145,26 @@ def decode_rpc_response(message: RoborockMessage) -> ResponseMessage:
         ) from e
 
     request_id: int | None = data_point_response.get("id")
+    exc: RoborockException | None = None
     if error := data_point_response.get("error"):
-        raise RoborockException(f"Error in message: {error}")
-
+        exc = RoborockException(error)
     if not (result := data_point_response.get("result")):
-        raise RoborockException(f"Invalid V1 message format: missing 'result' in data point for {message.payload!r}")
-    _LOGGER.debug("Decoded V1 message result: %s", result)
-    if isinstance(result, str) and result == "ok":
-        result = {}
-    if not isinstance(result, (dict, list, int)):
-        raise RoborockException(
-            f"Invalid V1 message format: 'result' was unexpected type {type(result)}. {message.payload!r}"
-        )
-    return ResponseMessage(request_id=request_id, data=result)
+        exc = RoborockException(f"Invalid V1 message format: missing 'result' in data point for {message.payload!r}")
+    else:
+        _LOGGER.debug("Decoded V1 message result: %s", result)
+        if isinstance(result, str):
+            if result == "unknown_method":
+                exc = RoborockException("The method called is not recognized by the device.")
+            elif result != "ok":
+                exc = RoborockException(f"Unexpected API Result: {result}")
+            result = {}
+        if not isinstance(result, (dict, list, int)):
+            raise RoborockException(
+                f"Invalid V1 message format: 'result' was unexpected type {type(result)}. {message.payload!r}"
+            )
+    if not request_id and exc:
+        raise exc
+    return ResponseMessage(request_id=request_id, data=result, api_error=exc)
 
 
 @dataclass