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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-roborock
-Version: 3.8.5
+Version: 3.9.0
 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.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-roborock"
-version = "3.8.5"
+version = "3.9.0"
 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.0}/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.0}/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)