deebot-client 7.2.0__tar.gz → 7.3.0__tar.gz

{deebot_client-7.2.0 → deebot_client-7.3.0}/.pre-commit-config.yaml

@@ -11,7 +11,7 @@ default_language_version:
 
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.4.3
+    rev: v0.4.5
     hooks:
       - id: ruff
         args:
@@ -25,7 +25,7 @@ repos:
         args:
           - --py312-plus
   - repo: https://github.com/codespell-project/codespell
-    rev: v2.2.6
+    rev: v2.3.0
     hooks:
       - id: codespell
         args:

{deebot_client-7.2.0 → deebot_client-7.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deebot-client
-Version: 7.2.0
+Version: 7.3.0
 Summary: Deebot client library in python 3
 Author-email: Robert Resch <robert@resch.dev>
 License: GPL-3.0

{deebot_client-7.2.0 → deebot_client-7.3.0}/deebot_client/capabilities.py

@@ -21,6 +21,7 @@ from deebot_client.events import (
     ContinuousCleaningEvent,
     CrossMapBorderWarningEvent,
     CustomCommandEvent,
+    CutDirectionEvent,
     ErrorEvent,
     Event,
     FanSpeedEvent,
@@ -189,6 +190,7 @@ class CapabilitySettings:
     )
     border_switch: CapabilitySetEnable[BorderSwitchEvent] | None = None
     child_lock: CapabilitySetEnable[ChildLockEvent] | None = None
+    cut_direction: CapabilitySet[CutDirectionEvent, int] | None = None
     moveup_warning: CapabilitySetEnable[MoveUpWarningEvent] | None = None
     cross_map_border_warning: CapabilitySetEnable[CrossMapBorderWarningEvent] | None = (
         None

{deebot_client-7.2.0 → deebot_client-7.3.0}/deebot_client/command.py

@@ -8,7 +8,10 @@ from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, final
 
 from deebot_client.events import AvailabilityEvent
-from deebot_client.exceptions import ApiTimeoutError, DeebotError
+from deebot_client.exceptions import (
+    ApiTimeoutError,
+    DeebotError,
+)
 
 from .const import PATH_API_IOT_DEVMANAGER, REQUEST_HEADERS, DataType
 from .logging_filter import get_logger
@@ -41,6 +44,22 @@ class CommandResult(HandlingResult):
         return CommandResult(HandlingState.ANALYSE)
 
 
+@dataclass(frozen=True)
+class DeviceCommandResult:
+    """Device command result object.
+
+    Returns
+    -------
+        device_reached (bool): True if the command was targeting the bot, and it responded in time. False otherwise.
+                               This value is not indicating if the command was executed successfully.
+        raw_response (dict[str, Any]): The command response data.
+
+    """
+
+    device_reached: bool
+    raw_response: dict[str, Any] = field(default_factory=dict)
+
+
 class Command(ABC):
     """Abstract command object."""
 
@@ -73,17 +92,12 @@ class Command(ABC):
         authenticator: Authenticator,
         device_info: ApiDeviceInfo,
         event_bus: EventBus,
-    ) -> bool:
-        """Execute command.
-
-        Returns
-        -------
-            bot_reached (bool): True if the command was targeting the bot, and it responded in time. False otherwise.
-                                This value is not indicating if the command was executed successfully.
-
-        """
+    ) -> DeviceCommandResult:
+        """Execute command."""
         try:
-            result = await self._execute(authenticator, device_info, event_bus)
+            result, response = await self._execute(
+                authenticator, device_info, event_bus
+            )
             if result.state == HandlingState.SUCCESS:
                 # Execute command which are requested by the handler
                 async with asyncio.TaskGroup() as tg:
@@ -94,21 +108,24 @@ class Command(ABC):
                             )
                         )
 
-                return self._targets_bot
+                return DeviceCommandResult(
+                    device_reached=self._targets_bot, raw_response=response
+                )
+
         except Exception:  # pylint: disable=broad-except
             _LOGGER.warning(
                 "Could not execute command %s",
                 self.name,
                 exc_info=True,
             )
-        return False
+        return DeviceCommandResult(device_reached=False)
 
     async def _execute(
         self,
         authenticator: Authenticator,
         device_info: ApiDeviceInfo,
         event_bus: EventBus,
-    ) -> CommandResult:
+    ) -> tuple[CommandResult, dict[str, Any]]:
         """Execute command."""
         try:
             response = await self._execute_api_request(authenticator, device_info)
@@ -117,21 +134,24 @@ class Command(ABC):
                 "Could not execute command %s: Timeout reached",
                 self.name,
             )
-            return CommandResult(HandlingState.ERROR)
+            return CommandResult(HandlingState.ERROR), {}
 
         result = self.__handle_response(event_bus, response)
         if result.state == HandlingState.ANALYSE:
             _LOGGER.debug(
                 "ANALYSE: Could not handle command: %s with %s", self.name, response
             )
-            return CommandResult(
-                HandlingState.ANALYSE_LOGGED,
-                result.args,
-                result.requested_commands,
+            return (
+                CommandResult(
+                    HandlingState.ANALYSE_LOGGED,
+                    result.args,
+                    result.requested_commands,
+                ),
+                response,
             )
         if result.state == HandlingState.ERROR:
             _LOGGER.warning("Could not parse %s: %s", self.name, response)
-        return result
+        return result, response
 
     async def _execute_api_request(
         self, authenticator: Authenticator, device_info: ApiDeviceInfo
@@ -260,6 +280,7 @@ class InitParam:
 
     type_: type
     name: str | None = None
+    optional: bool = field(default=False, kw_only=True)
 
 
 class CommandMqttP2P(Command, ABC):
@@ -283,7 +304,12 @@ class CommandMqttP2P(Command, ABC):
                 # Remove field
                 data.pop(name, None)
             else:
-                values[param.name or name] = _pop_or_raise(name, param.type_, data)
+                try:
+                    values[param.name or name] = _pop_or_raise(name, param.type_, data)
+                except KeyError as err:
+                    if not param.optional:
+                        msg = f'"{name}" is missing in {data}'
+                        raise DeebotError(msg) from err
 
         if data:
             _LOGGER.debug("Following data will be ignored: %s", data)
@@ -292,11 +318,7 @@ class CommandMqttP2P(Command, ABC):
 
 
 def _pop_or_raise(name: str, type_: type, data: dict[str, Any]) -> Any:
-    try:
-        value = data.pop(name)
-    except KeyError as err:
-        msg = f'"{name}" is missing in {data}'
-        raise DeebotError(msg) from err
+    value = data.pop(name)
     try:
         return type_(value)
     except ValueError as err:

{deebot_client-7.2.0 → deebot_client-7.3.0}/deebot_client/commands/json/__init__.py

@@ -20,6 +20,7 @@ from .clean_preference import GetCleanPreference, SetCleanPreference
 from .clear_map import ClearMap
 from .continuous_cleaning import GetContinuousCleaning, SetContinuousCleaning
 from .cross_map_border_warning import GetCrossMapBorderWarning, SetCrossMapBorderWarning
+from .cut_direction import GetCutDirection, SetCutDirection
 from .efficiency import GetEfficiencyMode, SetEfficiencyMode
 from .error import GetError
 from .fan_speed import GetFanSpeed, SetFanSpeed
@@ -77,6 +78,8 @@ __all__ = [
     "GetCleanLogs",
     "GetContinuousCleaning",
     "SetContinuousCleaning",
+    "SetCutDirection",
+    "GetCutDirection",
     "GetCrossMapBorderWarning",
     "SetCrossMapBorderWarning",
     "GetEfficiencyMode",

{deebot_client-7.2.0 → deebot_client-7.3.0}/deebot_client/commands/json/clean.py

@@ -32,7 +32,7 @@ class Clean(ExecuteCommand):
         authenticator: Authenticator,
         device_info: ApiDeviceInfo,
         event_bus: EventBus,
-    ) -> CommandResult:
+    ) -> tuple[CommandResult, dict[str, Any]]:
         """Execute command."""
         state = event_bus.get_last_event(StateEvent)
         if state and isinstance(self._args, dict):

deebot_client-7.3.0/deebot_client/commands/json/cut_direction.py

@@ -0,0 +1,43 @@
+"""Cut direction command module."""
+
+from __future__ import annotations
+
+from types import MappingProxyType
+from typing import TYPE_CHECKING, Any
+
+from deebot_client.command import InitParam
+from deebot_client.events import CutDirectionEvent
+from deebot_client.message import HandlingResult
+
+from .common import JsonGetCommand, JsonSetCommand
+
+if TYPE_CHECKING:
+    from deebot_client.event_bus import EventBus
+
+
+class GetCutDirection(JsonGetCommand):
+    """Get cut direction command."""
+
+    name = "getCutDirection"
+
+    @classmethod
+    def _handle_body_data_dict(
+        cls, event_bus: EventBus, data: dict[str, Any]
+    ) -> HandlingResult:
+        """Handle message->body->data and notify the correct event subscribers.
+
+        :return: A message response
+        """
+        event_bus.notify(CutDirectionEvent(angle=data["angle"]))
+        return HandlingResult.success()
+
+
+class SetCutDirection(JsonSetCommand):
+    """Set cut direction command."""
+
+    name = "setCutDirection"
+    get_command = GetCutDirection
+    _mqtt_params = MappingProxyType({"angle": InitParam(int)})
+
+    def __init__(self, angle: int) -> None:
+        super().__init__({"angle": angle})

{deebot_client-7.2.0 → deebot_client-7.3.0}/deebot_client/commands/json/error.py

@@ -28,16 +28,21 @@ class GetError(JsonCommandWithMessageHandling, MessageBodyDataDict):
 
         :return: A message response
         """
-        codes = data.get("code", [])
+        codes = data.get("code")
+        if not isinstance(codes, list):
+            return HandlingResult.analyse()
+
+        error: int | None = 0
+
         if codes:
             # the last error code
             error = codes[-1]
 
-            if error is not None:
-                description = ERROR_CODES.get(error)
-                if error != 0:
-                    event_bus.notify(StateEvent(State.ERROR))
-                event_bus.notify(ErrorEvent(error, description))
-                return HandlingResult.success()
+        if error is not None:
+            description = ERROR_CODES.get(error)
+            if error != 0:
+                event_bus.notify(StateEvent(State.ERROR))
+            event_bus.notify(ErrorEvent(error, description))
+            return HandlingResult.success()
 
         return HandlingResult.analyse()

{deebot_client-7.2.0 → deebot_client-7.3.0}/deebot_client/commands/json/pos.py

@@ -40,13 +40,17 @@ class GetPos(JsonCommandWithMessageHandling, MessageBodyDataDict):
                         type=PositionType(type_str),
                         x=data_positions["x"],
                         y=data_positions["y"],
+                        a=data_positions.get("a", 0),
                     )
                 )
             else:
                 positions.extend(
                     [
                         Position(
-                            type=PositionType(type_str), x=entry["x"], y=entry["y"]
+                            type=PositionType(type_str),
+                            x=entry["x"],
+                            y=entry["y"],
+                            a=entry.get("a", 0),
                         )
                         for entry in data_positions
                     ]

{deebot_client-7.2.0 → deebot_client-7.3.0}/deebot_client/commands/json/water_info.py

@@ -6,7 +6,7 @@ from types import MappingProxyType
 from typing import TYPE_CHECKING, Any
 
 from deebot_client.command import InitParam
-from deebot_client.events import WaterAmount, WaterInfoEvent
+from deebot_client.events import SweepType, WaterAmount, WaterInfoEvent
 from deebot_client.message import HandlingResult
 from deebot_client.util import get_enum
 
@@ -33,8 +33,15 @@ class GetWaterInfo(JsonGetCommand):
         if mop_attached is not None:
             mop_attached = bool(mop_attached)
 
+        if sweep_type := data.get("sweepType"):
+            sweep_type = SweepType(int(sweep_type))
+
         event_bus.notify(
-            WaterInfoEvent(WaterAmount(int(data["amount"])), mop_attached=mop_attached)
+            WaterInfoEvent(
+                WaterAmount(int(data["amount"])),
+                sweep_type,
+                mop_attached=mop_attached,
+            )
         )
         return HandlingResult.success()
 
@@ -48,10 +55,19 @@ class SetWaterInfo(JsonSetCommand):
         {
             "amount": InitParam(WaterAmount),
             "enable": None,  # Remove it as we don't can set it (App includes it)
+            "sweepType": InitParam(SweepType, "sweep_type", optional=True),
         }
     )
 
-    def __init__(self, amount: WaterAmount | str) -> None:
+    def __init__(
+        self, amount: WaterAmount | str, sweep_type: SweepType | str | None = None
+    ) -> None:
+        params = {}
         if isinstance(amount, str):
             amount = get_enum(WaterAmount, amount)
-        super().__init__({"amount": amount.value})
+        params["amount"] = amount.value
+        if sweep_type:
+            if isinstance(sweep_type, str):
+                sweep_type = get_enum(SweepType, sweep_type)
+            params["sweepType"] = sweep_type.value
+        super().__init__(params)

{deebot_client-7.2.0 → deebot_client-7.3.0}/deebot_client/commands/xml/pos.py

@@ -31,7 +31,10 @@ class GetPos(XmlCommandWithMessageHandling):
 
         if p := xml.attrib.get("p"):
             p_x, p_y = p.split(",", 2)
-            position = Position(type=PositionType.DEEBOT, x=int(p_x), y=int(p_y))
+            p_a = xml.attrib.get("a", 0)
+            position = Position(
+                type=PositionType.DEEBOT, x=int(p_x), y=int(p_y), a=int(p_a)
+            )
             event_bus.notify(PositionsEvent(positions=[position]))
             return HandlingResult.success()
 

{deebot_client-7.2.0 → deebot_client-7.3.0}/deebot_client/const.py

@@ -46,7 +46,9 @@ ERROR_CODES = {
     -2: "Internal error",
     -1: "Host not reachable or communication malfunction",
     0: "NoError: Robot is operational",
+    1: "Request error",
     3: "RequestOAuthError: Authentication error",
+    5: "Access denied",
     7: "log data is not found",
     100: "NoError: Robot is operational",
     101: "BatteryLow: Low battery",
@@ -69,6 +71,11 @@ ERROR_CODES = {
     118: "StrainerBlock:",
     119: "FanError:",
     120: "WaterBoxError:",
+    121: "PlateJammed:",
+    125: "Reservoir malfunction",
+    126: "Reservoir is not installed",
+    128: "Mopping Pad Plates are not both installed",
+    129: "Mopping Pad Plate is tangled",
     201: "AirFilterUninstall:",
     202: "UltrasonicComponentAbnormal",
     203: "SmallWheelError",
@@ -76,9 +83,45 @@ ERROR_CODES = {
     205: "IonSterilizeExhausted",
     206: "IonSterilizeAbnormal",
     207: "IonSterilizeFault",
-    312: "Please replace the Dust Bag.",
+    209: "D-ToF Sensor malfunction",
+    301: "FreshWaterBox empty",
+    302: "WasteWaterBox full",
+    303: "FreshWaterBox missing",
+    304: "WasteWaterBox missing",
+    305: "Dirty Water Tank is full",
+    306: "Cleaning Sink Filter is not installed",
+    307: "Auto-Clean Station malfunction",
+    308: "Communication Malfunction",
+    310: "Lid open",
+    311: "Replace the Dust Bag",
+    312: "TODO: unknown",
+    313: "TODO: unknown",
+    314: "Water Supply Module or Silver Ion Sterilization module is not installed",
+    315: "Water Supply Module is not installed",
+    316: "Clean silk is full",
+    317: "Clean Water Tank refill malfunction",
+    318: "Dirty Water Tank is full",
+    319: "Cleaning solution is running low",
     404: "Recipient unavailable",
     500: "Request Timeout",
     601: "ERROR_ClosedAIVISideAbnormal",
     602: "ClosedAIVIRollAbnormal",
+    1007: "Mop plugged",
+    1021: "Cleaning complete",
+    1024: "Low battery, returning to charge",
+    1027: "Unable de find the charging dock, returning to starting position",
+    1052: "Time to change the mop",
+    1053: "Task interrupted, returning to charge",
+    1061: "Resuming cleaning after position retrieved",
+    1062: "Unable de locate, starting new map",
+    1068: "Failed to find position, returning to charge",
+    1071: "Position updated",
+    1094: "AirDrying mop",
+    1088: "Failed to find position",
+    2036: "Obstacle detected",
+    2079: "TODO: unknown",
+    4200: "Robot not reachable",
+    20003: "Task type not supported",
+    20011: "Handle deal message fail",
+    20012: "Get point count out of range",
 }

{deebot_client-7.2.0 → deebot_client-7.3.0}/deebot_client/device.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+from collections.abc import Callable, Coroutine
 from contextlib import suppress
 from datetime import datetime
 import json
@@ -12,6 +13,7 @@ from deebot_client.events.network import NetworkInfoEvent
 from deebot_client.mqtt_client import MqttClient, SubscriberInfo
 from deebot_client.util import cancel
 
+from .command import Command
 from .event_bus import EventBus
 from .events import (
     AvailabilityEvent,
@@ -30,15 +32,16 @@ from .messages import get_message
 from .models import DeviceCapabilities, DeviceInfo, State
 
 if TYPE_CHECKING:
-    from collections.abc import Callable
-
     from .authentication import Authenticator
-    from .command import Command
+    from .command import DeviceCommandResult
 
 _LOGGER = get_logger(__name__)
 _AVAILABLE_CHECK_INTERVAL = 60
 
 
+DeviceCommandExecute = Callable[[Command], Coroutine[Any, Any, dict[str, Any]]]
+
+
 class Device(Generic[DeviceCapabilities]):
     """Device representation."""
 
@@ -107,9 +110,15 @@ class Device(Generic[DeviceCapabilities]):
 
         self.events.subscribe(NetworkInfoEvent, on_network)
 
-    async def execute_command(self, command: Command) -> None:
-        """Execute given command."""
-        await self._execute_command(command)
+    async def execute_command(self, command: Command) -> dict[str, Any]:
+        """Execute given command.
+
+        Returns
+        -------
+            command_response (dict[str, Any]) The command raw response.
+
+        """
+        return (await self._execute_command(command)).raw_response
 
     async def initialize(self, client: MqttClient) -> None:
         """Initialize vacumm bot, which includes MQTT-subscription and starting the available check."""
@@ -147,7 +156,7 @@ class Device(Generic[DeviceCapabilities]):
                         tasks.add(asyncio.create_task(self._execute_command(command)))
 
                     result = await asyncio.gather(*tasks)
-                    self._set_available(available=all(result))
+                    self._set_available(available=all(r.device_reached for r in result))
                 except Exception:  # pylint: disable=broad-exception-caught
                     _LOGGER.debug(
                         "An exception occurred during the available check",
@@ -156,16 +165,19 @@ class Device(Generic[DeviceCapabilities]):
                     await cancel(tasks)
             await asyncio.sleep(_AVAILABLE_CHECK_INTERVAL)
 
-    async def _execute_command(self, command: Command) -> bool:
+    async def _execute_command(
+        self,
+        command: Command,
+    ) -> DeviceCommandResult:
         """Execute given command."""
         async with self._semaphore:
-            if await command.execute(
+            result = await command.execute(
                 self._authenticator, self.device_info, self.events
-            ):
+            )
+            if result.device_reached:
                 self._set_available(available=True)
-                return True
 
-        return False
+            return result
 
     def _set_available(self, *, available: bool) -> None:
         """Set available."""

{deebot_client-7.2.0 → deebot_client-7.3.0}/deebot_client/event_bus.py

@@ -16,6 +16,7 @@ if TYPE_CHECKING:
     from collections.abc import Callable, Coroutine
 
     from .command import Command
+    from .device import DeviceCommandExecute
 
 _LOGGER = get_logger(__name__)
 
@@ -63,7 +64,7 @@ class EventBus:
 
     def __init__(
         self,
-        execute_command: Callable[[Command], Coroutine[Any, Any, None]],
+        execute_command: DeviceCommandExecute,
         get_refresh_commands: Callable[[type[Event]], list[Command]],
     ) -> None:
         self._event_processing_dict: dict[type[Event], _EventProcessingData[Any]] = {}

{deebot_client-7.2.0 → deebot_client-7.3.0}/deebot_client/events/__init__.py

@@ -24,7 +24,7 @@ from .map import (
     PositionType,
 )
 from .network import NetworkInfoEvent
-from .water_info import WaterAmount, WaterInfoEvent
+from .water_info import SweepType, WaterAmount, WaterInfoEvent
 from .work_mode import WorkMode, WorkModeEvent
 
 if TYPE_CHECKING:
@@ -52,6 +52,7 @@ __all__ = [
     "PositionType",
     "PositionsEvent",
     "SweepModeEvent",
+    "SweepType",
     "WaterAmount",
     "WaterInfoEvent",
     "WorkMode",
@@ -135,6 +136,10 @@ class LifeSpan(str, Enum):
     HUMIDIFY_MAINTENANCE = "wbCare"
     BLADE = "blade"
     LENS_BRUSH = "lensBrush"
+    DUST_BAG = "dustBag"
+    CLEANING_FLUID = "autoWater_cleaningFluid"
+    STRAINER = "strainer"
+    HAND_FILTER = "handFilter"
 
 
 @dataclass(frozen=True)
@@ -283,3 +288,10 @@ class MoveUpWarningEvent(EnableEvent):
 @dataclass(frozen=True)
 class SafeProtectEvent(EnableEvent):
     """Safe protect event."""
+
+
+@dataclass(frozen=True)
+class CutDirectionEvent(Event):
+    """Cut direction event representation."""
+
+    angle: int

{deebot_client-7.2.0 → deebot_client-7.3.0}/deebot_client/events/map.py

@@ -27,6 +27,7 @@ class Position:
     type: PositionType
     x: int
     y: int
+    a: int
 
 
 @dataclass(frozen=True)

{deebot_client-7.2.0 → deebot_client-7.3.0}/deebot_client/events/water_info.py

@@ -18,10 +18,19 @@ class WaterAmount(IntEnum):
     ULTRAHIGH = 4
 
 
+@unique
+class SweepType(IntEnum):
+    """Enum class for all possible sweeping types."""
+
+    STANDARD = 1
+    DEEP = 2
+
+
 @dataclass(frozen=True)
 class WaterInfoEvent(Event):
     """Water info event representation."""
 
     amount: WaterAmount
     # None means no data available
+    sweep_type: SweepType | None = None
     mop_attached: bool | None = field(kw_only=True, default=None)