Add classes to convert standard enums into XML values

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,20 +3,22 @@
 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
-    MAX_PLUS = 2
+    QUIET = 1000, ""
+    NORMAL = 0, "standard"
+    MAX = 1, "strong"
+    MAX_PLUS = 2, ""
 
 
 @dataclass(frozen=True)

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,52 @@
+"""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
+
+    def __new__(cls, value: str, xml_value: str = "") -> 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) -> Self:
+        """Convert from xml 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
+
+    def __new__(cls, value: int, xml_value: str = "") -> 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) -> Self:
+        """Convert from xml 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,17 @@
+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,59 @@
+from __future__ import annotations
+
+import pytest
+
+from deebot_client.util.enum import IntEnumWithXml, StrEnumWithXml
+
+
+class _TestStrEnumWithXml(StrEnumWithXml):
+    """Simple Enum for testing."""
+
+    ENUM1 = "value1", "xmlvalue1"
+    ENUM2 = "value2", "xmlvalue2"
+
+
+class _TestIntEnumWithXml(IntEnumWithXml):
+    ENUM1 = 1, "xmlvalue1"
+    ENUM2 = 2, "xmlvalue2"
+
+
+@pytest.mark.parametrize(
+    ("test_enum", "test_value", "test_xml_value"),
+    [
+        (_TestStrEnumWithXml.ENUM1, "value1", "xmlvalue1"),
+        (_TestStrEnumWithXml.ENUM2, "value2", "xmlvalue2"),
+    ],
+)
+def test_StrEnumWithXml_values(
+    test_enum: _TestStrEnumWithXml, test_value: str, test_xml_value: str
+) -> None:
+    assert test_enum.value == test_value
+    assert test_enum.xml_value == test_xml_value
+    assert test_value == _TestStrEnumWithXml.from_xml(test_xml_value).value
+    assert test_xml_value == _TestStrEnumWithXml(test_value).xml_value
+
+
+def test_StrEnumWithXml_invalid_value() -> None:
+    with pytest.raises(ValueError, match="this_is_invalid"):
+        _TestStrEnumWithXml.from_xml("this_is_invalid")
+
+
+@pytest.mark.parametrize(
+    ("test_enum", "test_value", "test_xml_value"),
+    [
+        (_TestIntEnumWithXml.ENUM1, 1, "xmlvalue1"),
+        (_TestIntEnumWithXml.ENUM2, 2, "xmlvalue2"),
+    ],
+)
+def test_IntEnumWithXml_values(
+    test_enum: _TestIntEnumWithXml, test_value: int, test_xml_value: str
+) -> None:
+    assert test_enum.value == test_value
+    assert test_enum.xml_value == test_xml_value
+    assert test_value == _TestIntEnumWithXml.from_xml(test_xml_value).value
+    assert test_xml_value == _TestIntEnumWithXml(test_value).xml_value
+
+
+def test_IntEnumWithXml_invalid_value() -> None:
+    with pytest.raises(ValueError, match="this_is_invalid"):
+        _TestIntEnumWithXml.from_xml("this_is_invalid")