Add classes to convert standard enums into XML values (#907)

Co-authored-by: Robert Resch <robert@resch.dev>

Author: nanomad

deebot_client/events/__init__.py

@@ -3,8 +3,10 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from enum import IntEnum, StrEnum, unique
-from typing import TYPE_CHECKING, Any, Self
+from enum import IntEnum, unique
+from typing import TYPE_CHECKING, Any
+
+from deebot_client.util.enum import StrEnumWithXml
 
 from . import auto_empty, station
 from .auto_empty import AutoEmptyEvent
@@ -126,27 +128,9 @@ class ErrorEvent(Event):
 
 
 @unique
-class LifeSpan(StrEnum):
+class LifeSpan(StrEnumWithXml):
     """Enum class for all possible life span components."""
 
-    xml_value: str
-
-    def __new__(cls, value: str, xml_value: str = "") -> Self:
-        obj = str.__new__(cls, value)
-        obj._value_ = value
-        obj.xml_value = xml_value
-        return obj
-
-    @classmethod
-    def from_xml(cls, value: str) -> LifeSpan:
-        """Get LifeSpan from xml value."""
-        for life_span in LifeSpan:
-            if life_span.xml_value == value:
-                return life_span
-
-        msg = f"{value} is not a valid {cls.__name__}"
-        raise ValueError(msg)
-
     BRUSH = "brush", "Brush"
     FILTER = "heap", "Heap"
     SIDE_BRUSH = "sideBrush", "SideBrush"

deebot_client/events/fan_speed.py

@@ -3,19 +3,21 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from enum import IntEnum, unique
+from enum import unique
+
+from deebot_client.util.enum import IntEnumWithXml
 
 from .base import Event
 
 
 @unique
-class FanSpeedLevel(IntEnum):
+class FanSpeedLevel(IntEnumWithXml):
     """Enum class for all possible fan speed levels."""
 
     # Values should be sort from low to high on their meanings
     QUIET = 1000
-    NORMAL = 0
-    MAX = 1
+    NORMAL = 0, "standard"
+    MAX = 1, "strong"
     MAX_PLUS = 2
 
 

deebot_client/models.py

@@ -3,10 +3,12 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from enum import IntEnum, StrEnum, unique
+from enum import IntEnum, unique
 from pathlib import Path
 from typing import TYPE_CHECKING, Required, TypedDict
 
+from deebot_client.util.enum import StrEnumWithXml
+
 if TYPE_CHECKING:
     from deebot_client.capabilities import Capabilities
     from deebot_client.const import DataType
@@ -64,22 +66,22 @@ class State(IntEnum):
 
 
 @unique
-class CleanAction(StrEnum):
+class CleanAction(StrEnumWithXml):
     """Enum class for all possible clean actions."""
 
-    START = "start"
-    PAUSE = "pause"
-    RESUME = "resume"
-    STOP = "stop"
+    START = "start", "s"
+    PAUSE = "pause", "p"
+    RESUME = "resume", "r"
+    STOP = "stop", "h"
 
 
 @unique
-class CleanMode(StrEnum):
+class CleanMode(StrEnumWithXml):
     """Enum class for all possible clean modes."""
 
-    AUTO = "auto"
-    SPOT_AREA = "spotArea"
-    CUSTOM_AREA = "customArea"
+    AUTO = "auto", "auto"
+    SPOT_AREA = "spotArea", "SpotArea"
+    CUSTOM_AREA = "customArea", "spot"
 
 
 @dataclass(frozen=True)

deebot_client/util/enum.py

@@ -0,0 +1,54 @@
+"""Enum util."""
+
+from __future__ import annotations
+
+from enum import IntEnum, StrEnum
+from typing import Self
+
+
+class StrEnumWithXml(StrEnum):
+    """String enum with xml value."""
+
+    xml_value: str | None
+
+    def __new__(cls, value: str, xml_value: str | None = None) -> Self:
+        """Create new StrEnumWithXml."""
+        obj = str.__new__(cls, value)
+        obj._value_ = value
+        obj.xml_value = xml_value
+        return obj
+
+    @classmethod
+    def from_xml(cls, value: str | None) -> Self:
+        """Convert from xml value."""
+        if value:
+            for member in cls:
+                if member.xml_value == value:
+                    return member
+
+        msg = f"{value} is not a valid {cls.__name__}"
+        raise ValueError(msg)
+
+
+class IntEnumWithXml(IntEnum):
+    """Int enum with xml value."""
+
+    xml_value: str | None
+
+    def __new__(cls, value: int, xml_value: str | None = None) -> Self:
+        """Create new StrEnumWithXml."""
+        obj = int.__new__(cls, value)
+        obj._value_ = value
+        obj.xml_value = xml_value
+        return obj
+
+    @classmethod
+    def from_xml(cls, value: str | None) -> Self:
+        """Convert from xml value."""
+        if value:
+            for member in cls:
+                if member.xml_value == value:
+                    return member
+
+        msg = f"{value} is not a valid {cls.__name__}"
+        raise ValueError(msg)

tests/events/test_events.py

@@ -2,10 +2,22 @@
 
 from __future__ import annotations
 
+import pytest
+
 from deebot_client.events import LifeSpan
 
 
 def test_life_span() -> None:
     """Test life span events."""
-    assert LifeSpan.BRUSH != LifeSpan.FILTER
+    assert LifeSpan.BRUSH != LifeSpan.FILTER  # type: ignore[comparison-overlap]
     assert LifeSpan.FILTER not in {LifeSpan.BLADE, LifeSpan.BRUSH, LifeSpan.SIDE_BRUSH}
+
+
+@pytest.mark.parametrize("value", list(LifeSpan))
+def test_life_span_xml_conversion(value: LifeSpan) -> None:
+    assert LifeSpan.from_xml(value.xml_value) == value
+
+
+@pytest.mark.parametrize("value", list(LifeSpan))
+def test_life_span_conversion(value: LifeSpan) -> None:
+    assert LifeSpan(value.value) == value

tests/events/test_fan_speed.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+import pytest
+
+from deebot_client.events import FanSpeedLevel
+
+
+@pytest.mark.parametrize("value", [level for level in FanSpeedLevel if level.xml_value])
+def test_clean_action_xml_conversion(value: FanSpeedLevel) -> None:
+    assert FanSpeedLevel.from_xml(value.xml_value) == value
+
+
+@pytest.mark.parametrize("value", list(FanSpeedLevel))
+def test_clean_action_conversion(value: FanSpeedLevel) -> None:
+    assert FanSpeedLevel(value.value) == value

tests/test_models.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+import pytest
+
+from deebot_client.models import CleanAction, CleanMode
+
+
+@pytest.mark.parametrize("value", list(CleanAction))
+def test_clean_action_xml_conversion(value: CleanAction) -> None:
+    assert CleanAction.from_xml(value.xml_value) == value
+
+
+@pytest.mark.parametrize("value", list(CleanAction))
+def test_clean_action_conversion(value: CleanAction) -> None:
+    assert CleanAction(value.value) == value
+
+
+@pytest.mark.parametrize("value", list(CleanMode))
+def test_clean_mode_xml_conversion(value: CleanMode) -> None:
+    assert CleanMode.from_xml(value.xml_value) == value
+
+
+@pytest.mark.parametrize("value", list(CleanMode))
+def test_clean_mode_conversion(value: CleanMode) -> None:
+    assert CleanMode(value.value) == value

tests/util/test_enum.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from typing import TypeVar
+
+import pytest
+
+from deebot_client.util.enum import IntEnumWithXml, StrEnumWithXml
+
+
+class _TestStrEnumWithXml(StrEnumWithXml):
+    ENUM1 = "value1", "xmlvalue1"
+    ENUM2 = "value2", "xmlvalue2"
+
+    def assert_self_conversion(self) -> None:
+        assert self == _TestStrEnumWithXml(self.value)
+        assert self == _TestStrEnumWithXml.from_xml(self.xml_value)
+
+
+class _TestIntEnumWithXml(IntEnumWithXml):
+    ENUM1 = 1, "xmlvalue1"
+    ENUM2 = 2, "xmlvalue2"
+
+    def assert_self_conversion(self) -> None:
+        assert self == _TestIntEnumWithXml(self.value)
+        assert self == _TestIntEnumWithXml.from_xml(self.xml_value)
+
+
+T = TypeVar("T", _TestStrEnumWithXml, _TestIntEnumWithXml)
+
+
+@pytest.mark.parametrize(
+    "test_enum", list(_TestStrEnumWithXml) + list(_TestIntEnumWithXml)
+)
+def test_EnumWithXml_conversion(
+    test_enum: T,
+) -> None:
+    test_enum.assert_self_conversion()
+
+
+@pytest.mark.parametrize(
+    ("test_enum_cls", "invalid_value"),
+    [
+        (_TestStrEnumWithXml, "this_is_invalid"),
+        (_TestStrEnumWithXml, None),
+        (_TestIntEnumWithXml, "this_is_invalid"),
+        (_TestIntEnumWithXml, None),
+    ],
+)
+def test_EnumWithXml_invalid_value(
+    test_enum_cls: type[T], invalid_value: str | None
+) -> None:
+    with pytest.raises(ValueError, match=str(invalid_value)):
+        test_enum_cls.from_xml(invalid_value)