python-roborock 3.8.5__tar.gz → 3.9.1__tar.gz

{python_roborock-3.8.5 → python_roborock-3.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-roborock
-Version: 3.8.5
+Version: 3.9.1
 Summary: A package to control Roborock vacuums.
 Project-URL: Repository, https://github.com/humbertogontijo/python-roborock
 Project-URL: Documentation, https://python-roborock.readthedocs.io/

{python_roborock-3.8.5 → python_roborock-3.9.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-roborock"
-version = "3.8.5"
+version = "3.9.1"
 description = "A package to control Roborock vacuums."
 authors = [{ name = "humbertogontijo", email = "humbertogontijo@users.noreply.github.com" }, {name="Lash-L"}, {name="allenporter"}]
 requires-python = ">=3.11, <4"

{python_roborock-3.8.5 → python_roborock-3.9.1}/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 @@ class RoborockBase:
         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]
 

{python_roborock-3.8.5 → python_roborock-3.9.1}/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)})

{python_roborock-3.8.5 → python_roborock-3.9.1}/roborock/devices/cache.py

@@ -8,12 +8,12 @@ this interface to provide their own caching mechanism.
 from dataclasses import dataclass, field
 from typing import Any, Protocol
 
-from roborock.data import CombinedMapInfo, HomeData, NetworkInfo
+from roborock.data import CombinedMapInfo, HomeData, NetworkInfo, RoborockBase
 from roborock.device_features import DeviceFeatures
 
 
 @dataclass
-class CacheData:
+class CacheData(RoborockBase):
     """Data structure for caching device information."""
 
     home_data: HomeData | None = None

{python_roborock-3.8.5 → python_roborock-3.9.1}/roborock/devices/file_cache.py

@@ -17,18 +17,25 @@ from .cache import Cache, CacheData
 class FileCache(Cache):
     """File backed cache implementation."""
 
-    def __init__(self, file_path: pathlib.Path, init_fn: Callable[[], CacheData] = CacheData) -> None:
+    def __init__(
+        self,
+        file_path: pathlib.Path,
+        init_fn: Callable[[], CacheData] = CacheData,
+        serialize_fn: Callable[[Any], bytes] = pickle.dumps,
+        deserialize_fn: Callable[[bytes], Any] = pickle.loads,
+    ) -> None:
         """Initialize the file cache with the given file path."""
         self._init_fn = init_fn
         self._file_path = file_path
         self._cache_data: CacheData | None = None
+        self._serialize_fn = serialize_fn
+        self._deserialize_fn = deserialize_fn
 
     async def get(self) -> CacheData:
         """Get cached value."""
         if self._cache_data is not None:
             return self._cache_data
-
-        data = await load_value(self._file_path)
+        data = await load_value(self._file_path, self._deserialize_fn)
         if data is not None and not isinstance(data, CacheData):
             raise TypeError(f"Invalid cache data loaded from {self._file_path}")
 
@@ -43,21 +50,21 @@ class FileCache(Cache):
         """Flush the cache to disk."""
         if self._cache_data is None:
             return
-        await store_value(self._file_path, self._cache_data)
+        await store_value(self._file_path, self._cache_data, self._serialize_fn)
 
 
-async def store_value(file_path: pathlib.Path, value: Any) -> None:
+async def store_value(file_path: pathlib.Path, value: Any, serialize_fn: Callable[[Any], bytes] = pickle.dumps) -> None:
     """Store a value to the given file path."""
 
     def _store_to_disk(file_path: pathlib.Path, value: Any) -> None:
         with open(file_path, "wb") as f:
-            data = pickle.dumps(value)
+            data = serialize_fn(value)
             f.write(data)
 
     await asyncio.to_thread(_store_to_disk, file_path, value)
 
 
-async def load_value(file_path: pathlib.Path) -> Any | None:
+async def load_value(file_path: pathlib.Path, deserialize_fn: Callable[[bytes], Any] = pickle.loads) -> Any | None:
     """Load a value from the given file path."""
 
     def _load_from_disk(file_path: pathlib.Path) -> Any | None:
@@ -65,6 +72,6 @@ async def load_value(file_path: pathlib.Path) -> Any | None:
             return None
         with open(file_path, "rb") as f:
             data = f.read()
-            return pickle.loads(data)
+            return deserialize_fn(data)
 
     return await asyncio.to_thread(_load_from_disk, file_path)