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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "python-roborock"
-version = "3.9.0"
+version = "3.9.2"
 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.9.0 → python_roborock-3.9.2}/roborock/cli.py

@@ -42,7 +42,7 @@ from pyshark.capture.live_capture import LiveCapture, UnknownInterfaceException
 from pyshark.packet.packet import Packet  # type: ignore
 
 from roborock import SHORT_MODEL_TO_ENUM, RoborockCommand
-from roborock.data import CombinedMapInfo, DeviceData, HomeData, NetworkInfo, RoborockBase, UserData
+from roborock.data import DeviceData, RoborockBase, UserData
 from roborock.device_features import DeviceFeatures
 from roborock.devices.cache import Cache, CacheData
 from roborock.devices.device import RoborockDevice
@@ -116,10 +116,8 @@ class ConnectionCache(RoborockBase):
 
     user_data: UserData
     email: str
-    home_data: HomeData | None = None
-    network_info: dict[str, NetworkInfo] | None = None
-    home_map_info: dict[int, CombinedMapInfo] | None = None
-    trait_data: dict[str, Any] | None = None
+    # TODO: Used new APIs for cache file storage
+    cache_data: CacheData | None = None
 
 
 class DeviceConnectionManager:
@@ -134,10 +132,10 @@ class DeviceConnectionManager:
     async def ensure_device_manager(self) -> DeviceManager:
         """Ensure device manager is initialized."""
         if self.device_manager is None:
-            cache_data = self.context.cache_data()
+            connection_cache = self.context.connection_cache()
             user_params = UserParams(
-                username=cache_data.email,
-                user_data=cache_data.user_data,
+                username=connection_cache.email,
+                user_data=connection_cache.user_data,
             )
             self.device_manager = await create_device_manager(user_params, cache=self.context)
             # Cache devices for quick lookup
@@ -164,7 +162,8 @@ class RoborockContext(Cache):
     """Context that handles both CLI and session modes internally."""
 
     roborock_file = Path("~/.roborock").expanduser()
-    _cache_data: ConnectionCache | None = None
+    roborock_cache_file = Path("~/.roborock.cache").expanduser()
+    _connection_cache: ConnectionCache | None = None
 
     def __init__(self):
         self.reload()
@@ -177,22 +176,22 @@ class RoborockContext(Cache):
             with open(self.roborock_file) as f:
                 data = json.load(f)
                 if data:
-                    self._cache_data = ConnectionCache.from_dict(data)
+                    self._connection_cache = ConnectionCache.from_dict(data)
 
-    def update(self, cache_data: ConnectionCache):
-        data = json.dumps(cache_data.as_dict(), default=vars, indent=4)
+    def update(self, connection_cache: ConnectionCache):
+        data = json.dumps(connection_cache.as_dict(), default=vars, indent=4)
         with open(self.roborock_file, "w") as f:
             f.write(data)
         self.reload()
 
     def validate(self):
-        if self._cache_data is None:
+        if self._connection_cache is None:
             raise RoborockException("You must login first")
 
-    def cache_data(self) -> ConnectionCache:
+    def connection_cache(self) -> ConnectionCache:
         """Get the cache data."""
         self.validate()
-        return cast(ConnectionCache, self._cache_data)
+        return cast(ConnectionCache, self._connection_cache)
 
     def start_session_mode(self):
         """Start session mode with a background event loop."""
@@ -229,19 +228,21 @@ class RoborockContext(Cache):
 
     async def refresh_devices(self) -> ConnectionCache:
         """Refresh device data from server (always fetches fresh data)."""
-        cache_data = self.cache_data()
-        client = RoborockApiClient(cache_data.email)
-        home_data = await client.get_home_data_v3(cache_data.user_data)
-        cache_data.home_data = home_data
-        self.update(cache_data)
-        return cache_data
+        connection_cache = self.connection_cache()
+        client = RoborockApiClient(connection_cache.email)
+        home_data = await client.get_home_data_v3(connection_cache.user_data)
+        if connection_cache.cache_data is None:
+            connection_cache.cache_data = CacheData()
+        connection_cache.cache_data.home_data = home_data
+        self.update(connection_cache)
+        return connection_cache
 
     async def get_devices(self) -> ConnectionCache:
         """Get device data (uses cache if available, fetches if needed)."""
-        cache_data = self.cache_data()
-        if not cache_data.home_data:
-            cache_data = await self.refresh_devices()
-        return cache_data
+        connection_cache = self.connection_cache()
+        if (connection_cache.cache_data is None) or (connection_cache.cache_data.home_data is None):
+            connection_cache = await self.refresh_devices()
+        return connection_cache
 
     async def cleanup(self):
         """Clean up resources (mainly for session mode)."""
@@ -266,22 +267,16 @@ class RoborockContext(Cache):
     async def get(self) -> CacheData:
         """Get cached value."""
         _LOGGER.debug("Getting cache data")
-        connection_cache = self.cache_data()
-        return CacheData(
-            home_data=connection_cache.home_data,
-            network_info=connection_cache.network_info or {},
-            home_map_info=connection_cache.home_map_info,
-            trait_data=connection_cache.trait_data or {},
-        )
+        connection_cache = self.connection_cache()
+        if connection_cache.cache_data is not None:
+            return connection_cache.cache_data
+        return CacheData()
 
     async def set(self, value: CacheData) -> None:
         """Set value in the cache."""
         _LOGGER.debug("Setting cache data")
-        connection_cache = self.cache_data()
-        connection_cache.home_data = value.home_data
-        connection_cache.network_info = value.network_info
-        connection_cache.home_map_info = value.home_map_info
-        connection_cache.trait_data = value.trait_data
+        connection_cache = self.connection_cache()
+        connection_cache.cache_data = value
         self.update(connection_cache)
 
 
@@ -367,9 +362,9 @@ async def discover(ctx):
 @async_command
 async def list_devices(ctx):
     context: RoborockContext = ctx.obj
-    cache_data = await context.get_devices()
+    connection_cache = await context.get_devices()
 
-    home_data = cache_data.home_data
+    home_data = connection_cache.cache_data.home_data
 
     device_name_id = {device.name: device.duid for device in home_data.get_all_devices()}
     click.echo(json.dumps(device_name_id, indent=4))

{python_roborock-3.9.0 → python_roborock-3.9.2}/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.9.0 → python_roborock-3.9.2}/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.9.2/roborock/devices/cache.py

@@ -0,0 +1,143 @@
+"""This module provides caching functionality for the Roborock device management system.
+
+This module defines a cache interface that you may use to cache device
+information to avoid unnecessary API calls. Callers may implement
+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, RoborockBase
+from roborock.device_features import DeviceFeatures
+
+
+@dataclass
+class DeviceCacheData(RoborockBase):
+    """Data structure for caching device information."""
+
+    network_info: NetworkInfo | None = None
+    """Network information for the device"""
+
+    home_map_info: dict[int, CombinedMapInfo] | None = None
+    """Home map information for the device by map_flag."""
+
+    home_map_content_base64: dict[int, str] | None = None
+    """Home cache content for the device (encoded base64) by map_flag."""
+
+    device_features: DeviceFeatures | None = None
+    """Device features information."""
+
+    trait_data: dict[str, Any] | None = None
+    """Trait-specific cached data used internally for caching device features."""
+
+
+@dataclass
+class CacheData(RoborockBase):
+    """Data structure for caching device information."""
+
+    home_data: HomeData | None = None
+    """Home data containing device and product information."""
+
+    device_info: dict[str, DeviceCacheData] = field(default_factory=dict)
+    """Per-device cached information indexed by device DUID."""
+
+    network_info: dict[str, NetworkInfo] = field(default_factory=dict)
+    """Network information indexed by device DUID.
+
+    This is deprecated. Use the per-device `network_info` field instead.
+    """
+
+    home_map_info: dict[int, CombinedMapInfo] = field(default_factory=dict)
+    """Home map information indexed by map_flag.
+
+    This is deprecated. Use the per-device `home_map_info` field instead.
+    """
+
+    home_map_content: dict[int, bytes] = field(default_factory=dict)
+    """Home cache content for each map data indexed by map_flag.
+
+    This is deprecated. Use the per-device `home_map_content_base64` field instead.
+    """
+
+    home_map_content_base64: dict[int, str] = field(default_factory=dict)
+    """Home cache content for each map data (encoded base64) indexed by map_flag.
+
+    This is deprecated. Use the per-device `home_map_content_base64` field instead.
+    """
+
+    device_features: DeviceFeatures | None = None
+    """Device features information.
+
+    This is deprecated. Use the per-device `device_features` field instead.
+    """
+
+    trait_data: dict[str, Any] | None = None
+    """Trait-specific cached data used internally for caching device features.
+
+    This is deprecated. Use the per-device `trait_data` field instead.
+    """
+
+
+class Cache(Protocol):
+    """Protocol for a cache that can store and retrieve values."""
+
+    async def get(self) -> CacheData:
+        """Get cached value."""
+        ...
+
+    async def set(self, value: CacheData) -> None:
+        """Set value in the cache."""
+        ...
+
+
+@dataclass
+class DeviceCache(RoborockBase):
+    """Provides a cache interface for a specific device.
+
+    This is a convenience wrapper around a general Cache implementation to
+    provide device-specific caching functionality.
+    """
+
+    def __init__(self, duid: str, cache: Cache) -> None:
+        """Initialize the device cache with the given cache implementation."""
+        self._duid = duid
+        self._cache = cache
+
+    async def get(self) -> DeviceCacheData:
+        """Get cached device-specific information."""
+        cache_data = await self._cache.get()
+        if self._duid not in cache_data.device_info:
+            cache_data.device_info[self._duid] = DeviceCacheData()
+            await self._cache.set(cache_data)
+        return cache_data.device_info[self._duid]
+
+    async def set(self, device_cache_data: DeviceCacheData) -> None:
+        """Set cached device-specific information."""
+        cache_data = await self._cache.get()
+        cache_data.device_info[self._duid] = device_cache_data
+        await self._cache.set(cache_data)
+
+
+class InMemoryCache(Cache):
+    """In-memory cache implementation."""
+
+    def __init__(self) -> None:
+        """Initialize the in-memory cache."""
+        self._data = CacheData()
+
+    async def get(self) -> CacheData:
+        return self._data
+
+    async def set(self, value: CacheData) -> None:
+        self._data = value
+
+
+class NoCache(Cache):
+    """No-op cache implementation."""
+
+    async def get(self) -> CacheData:
+        return CacheData()
+
+    async def set(self, value: CacheData) -> None:
+        pass

{python_roborock-3.9.0 → python_roborock-3.9.2}/roborock/devices/device_manager.py

@@ -21,7 +21,7 @@ from roborock.mqtt.session import MqttSession
 from roborock.protocol import create_mqtt_params
 from roborock.web_api import RoborockApiClient, UserWebApiClient
 
-from .cache import Cache, NoCache
+from .cache import Cache, DeviceCache, NoCache
 from .channel import Channel
 from .mqtt_channel import create_mqtt_channel
 from .traits import Trait, a01, b01, v1
@@ -177,9 +177,10 @@ async def create_device_manager(
     def device_creator(home_data: HomeData, device: HomeDataDevice, product: HomeDataProduct) -> RoborockDevice:
         channel: Channel
         trait: Trait
+        device_cache: DeviceCache = DeviceCache(device.duid, cache)
         match device.pv:
             case DeviceVersion.V1:
-                channel = create_v1_channel(user_data, mqtt_params, mqtt_session, device, cache)
+                channel = create_v1_channel(user_data, mqtt_params, mqtt_session, device, device_cache)
                 trait = v1.create(
                     device.duid,
                     product,
@@ -188,7 +189,7 @@ async def create_device_manager(
                     channel.mqtt_rpc_channel,
                     channel.map_rpc_channel,
                     web_api,
-                    cache,
+                    device_cache=device_cache,
                     map_parser_config=map_parser_config,
                 )
             case DeviceVersion.A01:

{python_roborock-3.9.0 → python_roborock-3.9.2}/roborock/devices/traits/v1/__init__.py

@@ -32,11 +32,12 @@ optional traits:
 
 import logging
 from dataclasses import dataclass, field, fields
+from functools import cache
 from typing import Any, get_args
 
 from roborock.data.containers import HomeData, HomeDataProduct, RoborockBase
 from roborock.data.v1.v1_code_mappings import RoborockDockTypeCode
-from roborock.devices.cache import Cache
+from roborock.devices.cache import DeviceCache
 from roborock.devices.traits import Trait
 from roborock.map.map_parser import MapParserConfig
 from roborock.protocols.v1_protocol import V1RpcChannel
@@ -131,7 +132,7 @@ class PropertiesApi(Trait):
         mqtt_rpc_channel: V1RpcChannel,
         map_rpc_channel: V1RpcChannel,
         web_api: UserWebApiClient,
-        cache: Cache,
+        device_cache: DeviceCache,
         map_parser_config: MapParserConfig | None = None,
     ) -> None:
         """Initialize the V1TraitProps."""
@@ -140,16 +141,16 @@ class PropertiesApi(Trait):
         self._mqtt_rpc_channel = mqtt_rpc_channel
         self._map_rpc_channel = map_rpc_channel
         self._web_api = web_api
-        self._cache = cache
+        self._device_cache = device_cache
 
         self.status = StatusTrait(product)
         self.consumables = ConsumableTrait()
         self.rooms = RoomsTrait(home_data)
         self.maps = MapsTrait(self.status)
         self.map_content = MapContentTrait(map_parser_config)
-        self.home = HomeTrait(self.status, self.maps, self.map_content, self.rooms, cache)
-        self.device_features = DeviceFeaturesTrait(product.product_nickname, cache)
-        self.network_info = NetworkInfoTrait(device_uid, cache)
+        self.home = HomeTrait(self.status, self.maps, self.map_content, self.rooms, self._device_cache)
+        self.device_features = DeviceFeaturesTrait(product.product_nickname, self._device_cache)
+        self.network_info = NetworkInfoTrait(device_uid, self._device_cache)
         self.routines = RoutinesTrait(device_uid, web_api)
 
         # Dynamically create any traits that need to be populated
@@ -239,7 +240,7 @@ class PropertiesApi(Trait):
 
     async def _get_cached_trait_data(self, name: str) -> Any:
         """Get the dock type from the status trait or cache."""
-        cache_data = await self._cache.get()
+        cache_data = await self._device_cache.get()
         if cache_data.trait_data is None:
             cache_data.trait_data = {}
         _LOGGER.debug("Cached trait data: %s", cache_data.trait_data)
@@ -247,12 +248,12 @@ class PropertiesApi(Trait):
 
     async def _set_cached_trait_data(self, name: str, value: Any) -> None:
         """Set trait-specific cached data."""
-        cache_data = await self._cache.get()
+        cache_data = await self._device_cache.get()
         if cache_data.trait_data is None:
             cache_data.trait_data = {}
         cache_data.trait_data[name] = value
         _LOGGER.debug("Updating cached trait data: %s", cache_data.trait_data)
-        await self._cache.set(cache_data)
+        await self._device_cache.set(cache_data)
 
     def as_dict(self) -> dict[str, Any]:
         """Return the trait data as a dictionary."""
@@ -275,7 +276,7 @@ def create(
     mqtt_rpc_channel: V1RpcChannel,
     map_rpc_channel: V1RpcChannel,
     web_api: UserWebApiClient,
-    cache: Cache,
+    device_cache: DeviceCache,
     map_parser_config: MapParserConfig | None = None,
 ) -> PropertiesApi:
     """Create traits for V1 devices."""
@@ -287,6 +288,6 @@ def create(
         mqtt_rpc_channel,
         map_rpc_channel,
         web_api,
-        cache,
+        device_cache,
         map_parser_config,
     )

{python_roborock-3.9.0 → python_roborock-3.9.2}/roborock/devices/traits/v1/device_features.py

@@ -2,7 +2,7 @@ from dataclasses import fields
 
 from roborock.data import AppInitStatus, RoborockProductNickname
 from roborock.device_features import DeviceFeatures
-from roborock.devices.cache import Cache
+from roborock.devices.cache import DeviceCache
 from roborock.devices.traits.v1 import common
 from roborock.roborock_typing import RoborockCommand
 
@@ -12,10 +12,10 @@ class DeviceFeaturesTrait(DeviceFeatures, common.V1TraitMixin):
 
     command = RoborockCommand.APP_GET_INIT_STATUS
 
-    def __init__(self, product_nickname: RoborockProductNickname, cache: Cache) -> None:  # pylint: disable=super-init-not-called
+    def __init__(self, product_nickname: RoborockProductNickname, device_cache: DeviceCache) -> None:  # pylint: disable=super-init-not-called
         """Initialize MapContentTrait."""
         self._nickname = product_nickname
-        self._cache = cache
+        self._device_cache = device_cache
         # All fields of DeviceFeatures are required. Initialize them to False
         # so we have some known state.
         for field in fields(self):
@@ -28,14 +28,14 @@ class DeviceFeaturesTrait(DeviceFeatures, common.V1TraitMixin):
         change often and this avoids unnecessary RPC calls. This would only
         ever change with a firmware update, so caching is appropriate.
         """
-        cache_data = await self._cache.get()
+        cache_data = await self._device_cache.get()
         if cache_data.device_features is not None:
             self._update_trait_values(cache_data.device_features)
             return
         # Save cached device features
         await super().refresh()
         cache_data.device_features = self
-        await self._cache.set(cache_data)
+        await self._device_cache.set(cache_data)
 
     def _parse_response(self, response: common.V1ResponseData) -> DeviceFeatures:
         """Parse the response from the device into a MapContentTrait instance."""

{python_roborock-3.9.0 → python_roborock-3.9.2}/roborock/devices/traits/v1/home.py

@@ -22,7 +22,7 @@ from typing import Self
 
 from roborock.data import CombinedMapInfo, RoborockBase
 from roborock.data.v1.v1_code_mappings import RoborockStateCode
-from roborock.devices.cache import Cache
+from roborock.devices.cache import DeviceCache
 from roborock.devices.traits.v1 import common
 from roborock.exceptions import RoborockDeviceBusy, RoborockException
 from roborock.roborock_typing import RoborockCommand
@@ -48,7 +48,7 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
         maps_trait: MapsTrait,
         map_content: MapContentTrait,
         rooms_trait: RoomsTrait,
-        cache: Cache,
+        device_cache: DeviceCache,
     ) -> None:
         """Initialize the HomeTrait.
 
@@ -70,7 +70,7 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
         self._maps_trait = maps_trait
         self._map_content = map_content
         self._rooms_trait = rooms_trait
-        self._cache = cache
+        self._device_cache = device_cache
         self._discovery_completed = False
         self._home_map_info: dict[int, CombinedMapInfo] | None = None
         self._home_map_content: dict[int, MapContent] | None = None
@@ -86,21 +86,16 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
 
         After discovery, the home cache will be populated and can be accessed via the `home_map_info` property.
         """
-        cache_data = await self._cache.get()
-        if cache_data.home_map_info and (cache_data.home_map_content or cache_data.home_map_content_base64):
+        device_cache_data = await self._device_cache.get()
+        if device_cache_data and device_cache_data.home_map_info:
             _LOGGER.debug("Home cache already populated, skipping discovery")
-            self._home_map_info = cache_data.home_map_info
+            self._home_map_info = device_cache_data.home_map_info
             self._discovery_completed = True
             try:
-                if cache_data.home_map_content_base64:
-                    self._home_map_content = {
-                        k: self._map_content.parse_map_content(base64.b64decode(v))
-                        for k, v in cache_data.home_map_content_base64.items()
-                    }
-                else:
-                    self._home_map_content = {
-                        k: self._map_content.parse_map_content(v) for k, v in cache_data.home_map_content.items()
-                    }
+                self._home_map_content = {
+                    k: self._map_content.parse_map_content(base64.b64decode(v))
+                    for k, v in (device_cache_data.home_map_content_base64 or {}).items()
+                }
             except (ValueError, RoborockException) as ex:
                 _LOGGER.warning("Failed to parse cached home map content, will re-discover: %s", ex)
                 self._home_map_content = {}
@@ -223,15 +218,14 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
         self, home_map_info: dict[int, CombinedMapInfo], home_map_content: dict[int, MapContent]
     ) -> None:
         """Update the entire home cache with new map info and content."""
-        cache_data = await self._cache.get()
-        cache_data.home_map_info = home_map_info
-        cache_data.home_map_content_base64 = {
+        device_cache_data = await self._device_cache.get()
+        device_cache_data.home_map_info = home_map_info
+        device_cache_data.home_map_content_base64 = {
             k: base64.b64encode(v.raw_api_response).decode("utf-8")
             for k, v in home_map_content.items()
             if v.raw_api_response
         }
-        cache_data.home_map_content = {}
-        await self._cache.set(cache_data)
+        await self._device_cache.set(device_cache_data)
         self._home_map_info = home_map_info
         self._home_map_content = home_map_content
 
@@ -247,21 +241,17 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
         # completed and we want to keep it fresh. Otherwise just update the
         # in memory map below.
         if update_cache:
-            cache_data = await self._cache.get()
-            cache_data.home_map_info[map_flag] = map_info
-            # Migrate existing cached content to base64 if needed
-            if cache_data.home_map_content and not cache_data.home_map_content_base64:
-                cache_data.home_map_content_base64 = {
-                    k: base64.b64encode(v).decode("utf-8") for k, v in cache_data.home_map_content.items()
-                }
-                cache_data.home_map_content = {}
+            device_cache_data = await self._device_cache.get()
+            if device_cache_data.home_map_info is None:
+                device_cache_data.home_map_info = {}
+            device_cache_data.home_map_info[map_flag] = map_info
             if map_content.raw_api_response:
-                if cache_data.home_map_content_base64 is None:
-                    cache_data.home_map_content_base64 = {}
-                cache_data.home_map_content_base64[map_flag] = base64.b64encode(map_content.raw_api_response).decode(
-                    "utf-8"
-                )
-            await self._cache.set(cache_data)
+                if device_cache_data.home_map_content_base64 is None:
+                    device_cache_data.home_map_content_base64 = {}
+                device_cache_data.home_map_content_base64[map_flag] = base64.b64encode(
+                    map_content.raw_api_response
+                ).decode("utf-8")
+            await self._device_cache.set(device_cache_data)
 
         if self._home_map_info is None:
             self._home_map_info = {}

{python_roborock-3.9.0 → python_roborock-3.9.2}/roborock/devices/traits/v1/network_info.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import logging
 
 from roborock.data import NetworkInfo
-from roborock.devices.cache import Cache
+from roborock.devices.cache import DeviceCache
 from roborock.devices.traits.v1 import common
 from roborock.roborock_typing import RoborockCommand
 
@@ -24,19 +24,19 @@ class NetworkInfoTrait(NetworkInfo, common.V1TraitMixin):
 
     command = RoborockCommand.GET_NETWORK_INFO
 
-    def __init__(self, device_uid: str, cache: Cache) -> None:  # pylint: disable=super-init-not-called
+    def __init__(self, device_uid: str, device_cache: DeviceCache) -> None:  # pylint: disable=super-init-not-called
         """Initialize the trait."""
         self._device_uid = device_uid
-        self._cache = cache
+        self._device_cache = device_cache
         self.ip = ""
 
     async def refresh(self) -> None:
         """Refresh the network info from the cache."""
 
-        cache_data = await self._cache.get()
-        if cache_data.network_info and (network_info := cache_data.network_info.get(self._device_uid)):
+        device_cache_data = await self._device_cache.get()
+        if device_cache_data.network_info:
             _LOGGER.debug("Using cached network info for device %s", self._device_uid)
-            self._update_trait_values(network_info)
+            self._update_trait_values(device_cache_data.network_info)
             return
 
         # Load from device if not in cache
@@ -44,8 +44,9 @@ class NetworkInfoTrait(NetworkInfo, common.V1TraitMixin):
         await super().refresh()
 
         # Update the cache with the new network info
-        cache_data.network_info[self._device_uid] = self
-        await self._cache.set(cache_data)
+        device_cache_data = await self._device_cache.get()
+        device_cache_data.network_info = self
+        await self._device_cache.set(device_cache_data)
 
     def _parse_response(self, response: common.V1ResponseData) -> NetworkInfo:
         """Parse the response from the device into a NetworkInfo."""

{python_roborock-3.9.0 → python_roborock-3.9.2}/roborock/devices/v1_channel.py

@@ -31,7 +31,7 @@ from roborock.protocols.v1_protocol import (
 from roborock.roborock_message import RoborockMessage, RoborockMessageProtocol
 from roborock.roborock_typing import RoborockCommand
 
-from .cache import Cache
+from .cache import DeviceCache
 from .channel import Channel
 from .local_channel import LocalChannel, LocalSession, create_local_session
 from .mqtt_channel import MqttChannel
@@ -170,7 +170,7 @@ class V1Channel(Channel):
         security_data: SecurityData,
         mqtt_channel: MqttChannel,
         local_session: LocalSession,
-        cache: Cache,
+        device_cache: DeviceCache,
     ) -> None:
         """Initialize the V1Channel."""
         self._device_uid = device_uid
@@ -182,7 +182,7 @@ class V1Channel(Channel):
         self._mqtt_unsub: Callable[[], None] | None = None
         self._local_unsub: Callable[[], None] | None = None
         self._callback: Callable[[RoborockMessage], None] | None = None
-        self._cache = cache
+        self._device_cache = device_cache
         self._reconnect_task: asyncio.Task[None] | None = None
         self._last_network_info_refresh: datetime.datetime | None = None
 
@@ -318,24 +318,27 @@ class V1Channel(Channel):
 
         This is a cloud only command used to get the local device's IP address.
         """
-        cache_data = await self._cache.get()
-        if prefer_cache and cache_data.network_info and (network_info := cache_data.network_info.get(self._device_uid)):
+        device_cache_data = await self._device_cache.get()
+
+        if prefer_cache and device_cache_data.network_info:
             _LOGGER.debug("Using cached network info for device %s", self._device_uid)
-            return network_info
+            return device_cache_data.network_info
         try:
             network_info = await self.mqtt_rpc_channel.send_command(
                 RoborockCommand.GET_NETWORK_INFO, response_type=NetworkInfo
             )
         except RoborockException as e:
             _LOGGER.debug("Error fetching network info for device %s", self._device_uid)
-            if cache_data.network_info and (network_info := cache_data.network_info.get(self._device_uid)):
+            if device_cache_data.network_info:
                 _LOGGER.debug("Falling back to cached network info for device %s after error", self._device_uid)
-                return network_info
+                return device_cache_data.network_info
             raise RoborockException(f"Network info failed for device {self._device_uid}") from e
         _LOGGER.debug("Network info for device %s: %s", self._device_uid, network_info)
         self._last_network_info_refresh = datetime.datetime.now(datetime.UTC)
-        cache_data.network_info[self._device_uid] = network_info
-        await self._cache.set(cache_data)
+
+        device_cache_data = await self._device_cache.get()
+        device_cache_data.network_info = network_info
+        await self._device_cache.set(device_cache_data)
         return network_info
 
     async def _local_connect(self, *, prefer_cache: bool = True) -> None:
@@ -425,10 +428,16 @@ def create_v1_channel(
     mqtt_params: MqttParams,
     mqtt_session: MqttSession,
     device: HomeDataDevice,
-    cache: Cache,
+    device_cache: DeviceCache,
 ) -> V1Channel:
     """Create a V1Channel for the given device."""
     security_data = create_security_data(user_data.rriot)
     mqtt_channel = MqttChannel(mqtt_session, device.duid, device.local_key, user_data.rriot, mqtt_params)
     local_session = create_local_session(device.local_key)
-    return V1Channel(device.duid, security_data, mqtt_channel, local_session=local_session, cache=cache)
+    return V1Channel(
+        device.duid,
+        security_data,
+        mqtt_channel,
+        local_session=local_session,
+        device_cache=device_cache,
+    )

python_roborock-3.9.0/roborock/devices/cache.py

@@ -1,77 +0,0 @@
-"""This module provides caching functionality for the Roborock device management system.
-
-This module defines a cache interface that you may use to cache device
-information to avoid unnecessary API calls. Callers may implement
-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, RoborockBase
-from roborock.device_features import DeviceFeatures
-
-
-@dataclass
-class CacheData(RoborockBase):
-    """Data structure for caching device information."""
-
-    home_data: HomeData | None = None
-    """Home data containing device and product information."""
-
-    network_info: dict[str, NetworkInfo] = field(default_factory=dict)
-    """Network information indexed by device DUID."""
-
-    home_map_info: dict[int, CombinedMapInfo] = field(default_factory=dict)
-    """Home map information indexed by map_flag."""
-
-    home_map_content: dict[int, bytes] = field(default_factory=dict)
-    """Home cache content for each map data indexed by map_flag.
-
-    This is deprecated in favor of `home_map_content_base64`.
-    """
-
-    home_map_content_base64: dict[int, str] = field(default_factory=dict)
-    """Home cache content for each map data (encoded base64) indexed by map_flag."""
-
-    device_features: DeviceFeatures | None = None
-    """Device features information."""
-
-    trait_data: dict[str, Any] | None = None
-    """Trait-specific cached data used internally for caching device features."""
-
-
-class Cache(Protocol):
-    """Protocol for a cache that can store and retrieve values."""
-
-    async def get(self) -> CacheData:
-        """Get cached value."""
-        ...
-
-    async def set(self, value: CacheData) -> None:
-        """Set value in the cache."""
-        ...
-
-
-class InMemoryCache(Cache):
-    """In-memory cache implementation."""
-
-    def __init__(self) -> None:
-        """Initialize the in-memory cache."""
-        self._data = CacheData()
-
-    async def get(self) -> CacheData:
-        return self._data
-
-    async def set(self, value: CacheData) -> None:
-        self._data = value
-
-
-class NoCache(Cache):
-    """No-op cache implementation."""
-
-    async def get(self) -> CacheData:
-        return CacheData()
-
-    async def set(self, value: CacheData) -> None:
-        pass