feat: Make CacheData serializable (#613)

* feat: Make CacheData serializable

Update the CacheData class with serialization methods so that clients can use it for persistence. This provides an API for Home Assistant to use for serialization so it doesn't need to make its own.

* fix: set default arugments to store/load value functions

* chore: remove unncessary logging

* chore: remove unnecessary snapshot files

* chore: remove unused import

Author: allenporter

roborock/devices/cache.py

@@ -8,12 +8,12 @@
 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

roborock/devices/file_cache.py

@@ -17,18 +17,25 @@
 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,28 +50,28 @@ async def flush(self) -> None:
         """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:
         if not file_path.exists():
             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)