fix: Fix DeviceFeatures so that it can be serialized and deserialized properly. (#615)

Adds tests for the desired output.

Author: allenporter

SUPPORTED_FEATURES.md

@@ -38,7 +38,7 @@
 | `is_carpet_shape_type_supported` |  |  |  |
 | `is_carpet_show_on_map` |  | X |  |
 | `is_carpet_supported` | X | X |  |
-| `is_ces2022_supported` |  |  |  |
+| `is_ces_2022_supported` |  |  |  |
 | `is_clean_count_setting_supported` |  | X |  |
 | `is_clean_direct_status_supported` |  |  |  |
 | `is_clean_efficiency_supported` |  |  |  |

roborock/data/containers.py

@@ -1,5 +1,6 @@
 import dataclasses
 import datetime
+import inspect
 import json
 import logging
 import re
@@ -27,7 +28,11 @@ def _camelize(s: str):
 
 
 def _decamelize(s: str):
-    return re.sub("([A-Z]+)", "_\\1", s).lower()
+    # Split before uppercase letters not at the start, and before numbers
+    s = re.sub(r"(?<=[a-z0-9])([A-Z])", r"_\1", s)
+    s = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", s)  # Split acronyms followed by normal camelCase
+    s = re.sub(r"([a-zA-Z])([0-9]+)", r"\1_\2", s)
+    return s.lower()
 
 
 def _attr_repr(obj: Any) -> str:
@@ -64,11 +69,12 @@ def _convert_to_class_obj(class_type: type, value):
         if get_origin(class_type) is dict:
             _, value_type = get_args(class_type)  # assume keys are only basic types
             return {k: RoborockBase._convert_to_class_obj(value_type, v) for k, v in value.items()}
-        if issubclass(class_type, RoborockBase):
-            return class_type.from_dict(value)
-        if issubclass(class_type, RoborockModeEnum):
-            return class_type.from_code(value)
-        if class_type is Any:
+        if inspect.isclass(class_type):
+            if issubclass(class_type, RoborockBase):
+                return class_type.from_dict(value)
+            if issubclass(class_type, RoborockModeEnum):
+                return class_type.from_code(value)
+        if class_type is Any or type(class_type) is str:
             return value
         return class_type(value)  # type: ignore[call-arg]
 

roborock/device_features.py

@@ -313,7 +313,7 @@ class DeviceFeatures(RoborockBase):
     is_support_incremental_map: bool = field(metadata={"new_feature_str_mask": (4194304, 8)})
     is_offline_map_supported: bool = field(metadata={"new_feature_str_mask": (16384, 8)})
     is_super_deep_wash_supported: bool = field(metadata={"new_feature_str_mask": (32768, 8)})
-    is_ces2022_supported: bool = field(metadata={"new_feature_str_mask": (65536, 8)})
+    is_ces_2022_supported: bool = field(metadata={"new_feature_str_mask": (65536, 8)})
     is_dss_believable: bool = field(metadata={"new_feature_str_mask": (131072, 8)})
     is_main_brush_up_down_supported_from_str: bool = field(metadata={"new_feature_str_mask": (262144, 8)})
     is_goto_pure_clean_path_supported: bool = field(metadata={"new_feature_str_mask": (524288, 8)})

tests/test_containers.py

@@ -1,8 +1,10 @@
 """Test cases for the containers module."""
 
+import dataclasses
 from dataclasses import dataclass
 from typing import Any
 
+import pytest
 from syrupy import SnapshotAssertion
 
 from roborock import CleanRecord, CleanSummary, Consumable, DnDTimer, HomeData, S7MaxVStatus, UserData
@@ -13,6 +15,7 @@
     SCWindMapping,
     WorkStatusMapping,
 )
+from roborock.data.containers import _camelize, _decamelize
 from roborock.data.v1 import (
     MultiMapsList,
     RoborockDockErrorCode,
@@ -58,6 +61,15 @@ class ComplexObject(RoborockBase):
     any: Any | None = None
 
 
+@dataclass
+class BoolFeatures(RoborockBase):
+    """Complex object for testing serialization."""
+
+    my_flag_supported: bool | None = None
+    my_flag_2_supported: bool | None = None
+    is_ces_2022_supported: bool | None = None
+
+
 def test_simple_object() -> None:
     """Test serialization and deserialization of a simple object."""
 
@@ -494,3 +506,37 @@ def test_accurate_map_flag() -> None:
         }
     )
     assert s.current_map is None
+
+
+def test_boolean_features() -> None:
+    """Test serialization and deserialization of BoolFeatures."""
+    obj = BoolFeatures(my_flag_supported=True, my_flag_2_supported=False, is_ces_2022_supported=True)
+    serialized = obj.as_dict()
+    assert serialized == {
+        "myFlagSupported": True,
+        "myFlag2Supported": False,
+        "isCes2022Supported": True,
+    }
+    deserialized = BoolFeatures.from_dict(serialized)
+    assert dataclasses.asdict(deserialized) == {
+        "my_flag_supported": True,
+        "my_flag_2_supported": False,
+        "is_ces_2022_supported": True,
+    }
+
+
+@pytest.mark.parametrize(
+    "input_str,expected",
+    [
+        ("simpleTest", "simple_test"),
+        ("testValue", "test_value"),
+        ("anotherExampleHere", "another_example_here"),
+        ("isCes2022Supported", "is_ces_2022_supported"),
+        ("isThreeDMappingInnerTestSupported", "is_three_d_mapping_inner_test_supported"),
+    ],
+)
+def test_decamelize_function(input_str: str, expected: str) -> None:
+    """Test the _decamelize function."""
+
+    assert _decamelize(input_str) == expected
+    assert _camelize(expected) == input_str

tests/test_supported_features.py

@@ -1,4 +1,7 @@
+from syrupy import SnapshotAssertion
+
 from roborock import SHORT_MODEL_TO_ENUM
+from roborock.data.code_mappings import RoborockProductNickname
 from roborock.device_features import DeviceFeatures
 
 
@@ -43,3 +46,16 @@ def test_supported_features_s7():
     assert not device_features.is_hot_wash_towel_supported
     num_true = sum(vars(device_features).values())
     assert num_true != 0
+
+
+def test_device_feature_serialization(snapshot: SnapshotAssertion) -> None:
+    """Test serialization and deserialization of DeviceFeatures."""
+    device_features = DeviceFeatures.from_feature_flags(
+        new_feature_info=636084721975295,
+        new_feature_info_str="0000000000002000",
+        feature_info=[111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 122, 123, 124, 125],
+        product_nickname=RoborockProductNickname.TANOSS,
+    )
+    serialized = device_features.as_dict()
+    deserialized = DeviceFeatures.from_dict(serialized)
+    assert deserialized == device_features