Allow decoding of XML Enums via P2P

Author: nanomad

deebot_client/command.py

@@ -307,7 +307,9 @@ def _create_from_mqtt(cls, data: dict[str, Any]) -> CommandMqttP2P:
                 data.pop(name, None)
             else:
                 try:
-                    values[param.name or name] = _pop_or_raise(name, param.type_, data)
+                    values[param.name or name] = cls._pop_or_raise(
+                        name, param.type_, data
+                    )
                 except KeyError as err:
                     if not param.optional:
                         msg = f'"{name}" is missing in {data}'
@@ -318,14 +320,18 @@ def _create_from_mqtt(cls, data: dict[str, Any]) -> CommandMqttP2P:
 
         return cls(**values)
 
+    @classmethod
+    def _pop_or_raise(cls, name: str, type_: type, data: dict[str, Any]) -> Any:
+        value = data.pop(name)
+        try:
+            return cls._decode(type_, value)
+        except ValueError as err:
+            msg = f'Could not convert "{value}" of {name} into {type_}'
+            raise DeebotError(msg) from err
 
-def _pop_or_raise(name: str, type_: type, data: dict[str, Any]) -> Any:
-    value = data.pop(name)
-    try:
+    @classmethod
+    def _decode(cls, type_: type, value: Any) -> Any:
         return type_(value)
-    except ValueError as err:
-        msg = f'Could not convert "{value}" of {name} into {type_}'
-        raise DeebotError(msg) from err
 
 
 class GetCommand(CommandWithMessageHandling, ABC):

deebot_client/commands/xml/common.py

@@ -116,6 +116,12 @@ def handle_mqtt_p2p(
 
         self._handle_mqtt_p2p(event_bus, data)
 
+    @classmethod
+    def _decode(cls, type_: type, value: Any) -> Any:
+        if hasattr(type_, "from_xml"):
+            return type_.from_xml(value)
+        return type_(value)
+
     @abstractmethod
     def _handle_mqtt_p2p(
         self, event_bus: EventBus, response: dict[str, Any] | str

deebot_client/commands/xml/life_span.py

@@ -58,7 +58,7 @@ class ResetLifeSpan(ExecuteCommand, XmlCommandMqttP2P):
     """ResetLifeSpan command."""
 
     NAME = "ResetLifeSpan"
-    _mqtt_params = MappingProxyType({"type": InitParam(str, "life_span")})
+    _mqtt_params = MappingProxyType({"type": InitParam(LifeSpan, "life_span")})
 
     def __init__(self, life_span: LifeSpan | str) -> None:
         xml_value = (

tests/commands/xml/test_common.py

@@ -1,11 +1,15 @@
 from __future__ import annotations
 
+from types import MappingProxyType
+from typing import Any
 from unittest.mock import Mock, patch
 
 import pytest
 
+from deebot_client.command import CommandResult, InitParam
 from deebot_client.commands.xml.common import XmlCommandMqttP2P
 from deebot_client.event_bus import EventBus
+from deebot_client.events import LifeSpan
 
 
 @pytest.mark.parametrize(
@@ -38,3 +42,38 @@ def test_XmlCommandMqttP2P_invalid_decoding() -> None:
         pytest.raises(TypeError),
     ):
         command.handle_mqtt_p2p(event_bus, {})  # type: ignore[arg-type]
+
+
+@pytest.mark.parametrize(
+    ("command_payload", "payload_type", "expected_argument"),
+    [
+        ("test", str, "test"),
+        (LifeSpan.BRUSH.xml_value, LifeSpan, LifeSpan.BRUSH),
+    ],
+    ids=["native", "with xml_value"],
+)
+def test_XmlCommandMqttP2P_create_from_mqtt(
+    command_payload: str, payload_type: type, expected_argument: type
+) -> None:
+    class Sut(XmlCommandMqttP2P):
+        _mqtt_params = MappingProxyType({"payload": InitParam(payload_type)})
+        NAME = "Sut"
+
+        def __init__(self, payload: Any) -> None:
+            super().__init__(args={"payload": payload})
+
+        def _handle_mqtt_p2p(
+            self, _event_bus: EventBus, _response: dict[str, Any] | str
+        ) -> None:
+            pass
+
+        def _handle_response(
+            self, _event_bus: EventBus, _response: dict[str, Any]
+        ) -> CommandResult:
+            return CommandResult.analyse()
+
+    xml_message = f"<ctl ret='ok' payload='{command_payload}'/>"
+
+    sut = Sut.create_from_mqtt(xml_message)
+
+    assert sut._args == {"payload": expected_argument}