python-roborock 3.3.2__tar.gz → 3.7.1__tar.gz

{python_roborock-3.3.2 → python_roborock-3.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-roborock
-Version: 3.3.2
+Version: 3.7.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.3.2 → python_roborock-3.7.1}/pyproject.toml

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

@@ -46,7 +46,7 @@ from roborock.data import CombinedMapInfo, DeviceData, HomeData, NetworkInfo, Ro
 from roborock.device_features import DeviceFeatures
 from roborock.devices.cache import Cache, CacheData
 from roborock.devices.device import RoborockDevice
-from roborock.devices.device_manager import DeviceManager, create_device_manager, create_home_data_api
+from roborock.devices.device_manager import DeviceManager, UserParams, create_device_manager
 from roborock.devices.traits import Trait
 from roborock.devices.traits.v1 import V1TraitMixin
 from roborock.devices.traits.v1.consumeable import ConsumableAttribute
@@ -118,7 +118,7 @@ class ConnectionCache(RoborockBase):
     email: str
     home_data: HomeData | None = None
     network_info: dict[str, NetworkInfo] | None = None
-    home_cache: dict[int, CombinedMapInfo] | None = None
+    home_map_info: dict[int, CombinedMapInfo] | None = None
     trait_data: dict[str, Any] | None = None
 
 
@@ -135,8 +135,11 @@ class DeviceConnectionManager:
         """Ensure device manager is initialized."""
         if self.device_manager is None:
             cache_data = self.context.cache_data()
-            home_data_api = create_home_data_api(cache_data.email, cache_data.user_data)
-            self.device_manager = await create_device_manager(cache_data.user_data, home_data_api, self.context)
+            user_params = UserParams(
+                username=cache_data.email,
+                user_data=cache_data.user_data,
+            )
+            self.device_manager = await create_device_manager(user_params, cache=self.context)
             # Cache devices for quick lookup
             devices = await self.device_manager.get_devices()
             self._devices = {device.duid: device for device in devices}
@@ -267,7 +270,7 @@ class RoborockContext(Cache):
         return CacheData(
             home_data=connection_cache.home_data,
             network_info=connection_cache.network_info or {},
-            home_cache=connection_cache.home_cache,
+            home_map_info=connection_cache.home_map_info,
             trait_data=connection_cache.trait_data or {},
         )
 
@@ -277,7 +280,7 @@ class RoborockContext(Cache):
         connection_cache = self.cache_data()
         connection_cache.home_data = value.home_data
         connection_cache.network_info = value.network_info
-        connection_cache.home_cache = value.home_cache
+        connection_cache.home_map_info = value.home_map_info
         connection_cache.trait_data = value.trait_data
         self.update(connection_cache)
 
@@ -717,14 +720,14 @@ async def home(ctx, device_id: str, refresh: bool):
         await home_trait.refresh()
 
     # Display the discovered home cache
-    if home_trait.home_cache:
+    if home_trait.home_map_info:
         cache_summary = {
             map_flag: {
                 "name": map_data.name,
                 "room_count": len(map_data.rooms),
                 "rooms": [{"segment_id": room.segment_id, "name": room.name} for room in map_data.rooms],
             }
-            for map_flag, map_data in home_trait.home_cache.items()
+            for map_flag, map_data in home_trait.home_map_info.items()
         }
         click.echo(dump_json(cache_summary))
     else:

{python_roborock-3.3.2 → python_roborock-3.7.1}/roborock/devices/cache.py

@@ -22,8 +22,11 @@ class CacheData:
     network_info: dict[str, NetworkInfo] = field(default_factory=dict)
     """Network information indexed by device DUID."""
 
-    home_cache: dict[int, CombinedMapInfo] = field(default_factory=dict)
-    """Home cache information indexed by map_flag."""
+    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."""
 
     device_features: DeviceFeatures | None = None
     """Device features information."""

{python_roborock-3.3.2 → python_roborock-3.7.1}/roborock/devices/device_manager.py

@@ -3,7 +3,8 @@
 import asyncio
 import enum
 import logging
-from collections.abc import Awaitable, Callable
+from collections.abc import Callable
+from dataclasses import dataclass
 
 import aiohttp
 
@@ -18,7 +19,7 @@ from roborock.map.map_parser import MapParserConfig
 from roborock.mqtt.roborock_session import create_lazy_mqtt_session
 from roborock.mqtt.session import MqttSession
 from roborock.protocol import create_mqtt_params
-from roborock.web_api import RoborockApiClient
+from roborock.web_api import RoborockApiClient, UserWebApiClient
 
 from .cache import Cache, NoCache
 from .channel import Channel
@@ -30,12 +31,11 @@ _LOGGER = logging.getLogger(__name__)
 
 __all__ = [
     "create_device_manager",
-    "create_home_data_api",
+    "UserParams",
     "DeviceManager",
 ]
 
 
-HomeDataApi = Callable[[], Awaitable[HomeData]]
 DeviceCreator = Callable[[HomeData, HomeDataDevice, HomeDataProduct], RoborockDevice]
 
 
@@ -53,7 +53,7 @@ class DeviceManager:
 
     def __init__(
         self,
-        home_data_api: HomeDataApi,
+        web_api: UserWebApiClient,
         device_creator: DeviceCreator,
         mqtt_session: MqttSession,
         cache: Cache,
@@ -62,7 +62,7 @@ class DeviceManager:
 
         This takes ownership of the MQTT session and will close it when the manager is closed.
         """
-        self._home_data_api = home_data_api
+        self._web_api = web_api
         self._cache = cache
         self._device_creator = device_creator
         self._devices: dict[str, RoborockDevice] = {}
@@ -73,7 +73,7 @@ class DeviceManager:
         cache_data = await self._cache.get()
         if not cache_data.home_data:
             _LOGGER.debug("No cached home data found, fetching from API")
-            cache_data.home_data = await self._home_data_api()
+            cache_data.home_data = await self._web_api.get_home_data()
             await self._cache.set(cache_data)
         home_data = cache_data.home_data
 
@@ -108,45 +108,69 @@ class DeviceManager:
         await asyncio.gather(*tasks)
 
 
-def create_home_data_api(
-    email: str, user_data: UserData, base_url: str | None = None, session: aiohttp.ClientSession | None = None
-) -> HomeDataApi:
-    """Create a home data API wrapper.
+@dataclass
+class UserParams:
+    """Parameters for creating a new session with Roborock devices.
 
-    This function creates a wrapper around the Roborock API client to fetch
-    home data for the user.
+    These parameters include the username, user data for authentication,
+    and an optional base URL for the Roborock API. The `user_data` and `base_url`
+    parameters are obtained from `RoborockApiClient` during the login process.
     """
-    # Note: This will auto discover the API base URL. This can be improved
-    # by caching this next to `UserData` if needed to avoid unnecessary API calls.
-    client = RoborockApiClient(username=email, base_url=base_url, session=session)
 
-    return create_home_data_from_api_client(client, user_data)
+    username: str
+    """The username (email) used for logging in."""
+
+    user_data: UserData
+    """This is the user data containing authentication information."""
+
+    base_url: str | None = None
+    """Optional base URL for the Roborock API.
+
+    This is used to speed up connection times by avoiding the need to
+    discover the API base URL each time. If not provided, the API client
+    will attempt to discover it automatically which may take multiple requests.
+    """
 
 
-def create_home_data_from_api_client(client: RoborockApiClient, user_data: UserData) -> HomeDataApi:
+def create_web_api_wrapper(
+    user_params: UserParams,
+    *,
+    cache: Cache | None = None,
+    session: aiohttp.ClientSession | None = None,
+) -> UserWebApiClient:
     """Create a home data API wrapper from an existing API client."""
 
-    async def home_data_api() -> HomeData:
-        return await client.get_home_data_v3(user_data)
+    # Note: This will auto discover the API base URL. This can be improved
+    # by caching this next to `UserData` if needed to avoid unnecessary API calls.
+    client = RoborockApiClient(username=user_params.username, base_url=user_params.base_url, session=session)
 
-    return home_data_api
+    return UserWebApiClient(client, user_params.user_data)
 
 
 async def create_device_manager(
-    user_data: UserData,
-    home_data_api: HomeDataApi,
+    user_params: UserParams,
+    *,
     cache: Cache | None = None,
     map_parser_config: MapParserConfig | None = None,
+    session: aiohttp.ClientSession | None = None,
 ) -> DeviceManager:
     """Convenience function to create and initialize a DeviceManager.
 
-    The Home Data is fetched using the provided home_data_api callable which
-    is exposed this way to allow for swapping out other implementations to
-    include caching or other optimizations.
+    Args:
+        user_params: Parameters for creating the user session.
+        cache: Optional cache implementation to use for caching device data.
+        map_parser_config: Optional configuration for parsing maps.
+        session: Optional aiohttp ClientSession to use for HTTP requests.
+
+    Returns:
+        An initialized DeviceManager with discovered devices.
     """
     if cache is None:
         cache = NoCache()
 
+    web_api = create_web_api_wrapper(user_params, session=session, cache=cache)
+    user_data = user_params.user_data
+
     mqtt_params = create_mqtt_params(user_data.rriot)
     mqtt_session = await create_lazy_mqtt_session(mqtt_params)
 
@@ -163,6 +187,7 @@ async def create_device_manager(
                     channel.rpc_channel,
                     channel.mqtt_rpc_channel,
                     channel.map_rpc_channel,
+                    web_api,
                     cache,
                     map_parser_config=map_parser_config,
                 )
@@ -176,6 +201,6 @@ async def create_device_manager(
                 raise NotImplementedError(f"Device {device.name} has unsupported version {device.pv}")
         return RoborockDevice(device, product, channel, trait)
 
-    manager = DeviceManager(home_data_api, device_creator, mqtt_session=mqtt_session, cache=cache)
+    manager = DeviceManager(web_api, device_creator, mqtt_session=mqtt_session, cache=cache)
     await manager.discover_devices()
     return manager

{python_roborock-3.3.2 → python_roborock-3.7.1}/roborock/devices/traits/v1/__init__.py

@@ -40,6 +40,7 @@ from roborock.devices.cache import Cache
 from roborock.devices.traits import Trait
 from roborock.devices.v1_rpc_channel import V1RpcChannel
 from roborock.map.map_parser import MapParserConfig
+from roborock.web_api import UserWebApiClient
 
 from .child_lock import ChildLockTrait
 from .clean_summary import CleanSummaryTrait
@@ -56,6 +57,7 @@ from .map_content import MapContentTrait
 from .maps import MapsTrait
 from .network_info import NetworkInfoTrait
 from .rooms import RoomsTrait
+from .routines import RoutinesTrait
 from .smart_wash_params import SmartWashParamsTrait
 from .status import StatusTrait
 from .valley_electricity_timer import ValleyElectricityTimerTrait
@@ -85,6 +87,7 @@ __all__ = [
     "WashTowelModeTrait",
     "SmartWashParamsTrait",
     "NetworkInfoTrait",
+    "RoutinesTrait",
 ]
 
 
@@ -108,6 +111,7 @@ class PropertiesApi(Trait):
     home: HomeTrait
     device_features: DeviceFeaturesTrait
     network_info: NetworkInfoTrait
+    routines: RoutinesTrait
 
     # Optional features that may not be supported on all devices
     child_lock: ChildLockTrait | None = None
@@ -126,6 +130,7 @@ class PropertiesApi(Trait):
         rpc_channel: V1RpcChannel,
         mqtt_rpc_channel: V1RpcChannel,
         map_rpc_channel: V1RpcChannel,
+        web_api: UserWebApiClient,
         cache: Cache,
         map_parser_config: MapParserConfig | None = None,
     ) -> None:
@@ -134,6 +139,7 @@ class PropertiesApi(Trait):
         self._rpc_channel = rpc_channel
         self._mqtt_rpc_channel = mqtt_rpc_channel
         self._map_rpc_channel = map_rpc_channel
+        self._web_api = web_api
         self._cache = cache
 
         self.status = StatusTrait(product)
@@ -141,9 +147,10 @@ class PropertiesApi(Trait):
         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.rooms, cache)
+        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.routines = RoutinesTrait(device_uid, web_api)
 
         # Dynamically create any traits that need to be populated
         for item in fields(self):
@@ -267,6 +274,7 @@ def create(
     rpc_channel: V1RpcChannel,
     mqtt_rpc_channel: V1RpcChannel,
     map_rpc_channel: V1RpcChannel,
+    web_api: UserWebApiClient,
     cache: Cache,
     map_parser_config: MapParserConfig | None = None,
 ) -> PropertiesApi:
@@ -278,6 +286,7 @@ def create(
         rpc_channel,
         mqtt_rpc_channel,
         map_rpc_channel,
+        web_api,
         cache,
         map_parser_config,
     )

{python_roborock-3.3.2 → python_roborock-3.7.1}/roborock/devices/traits/v1/clean_summary.py

@@ -53,6 +53,8 @@ class CleanSummaryTrait(CleanSummaryWithDetail, common.V1TraitMixin):
     @classmethod
     def _parse_clean_record_response(cls, response: common.V1ResponseData) -> CleanRecord:
         """Parse the response from the device into a CleanRecord."""
+        if isinstance(response, list) and len(response) == 1:
+            response = response[0]
         if isinstance(response, dict):
             return CleanRecord.from_dict(response)
         if isinstance(response, list):

{python_roborock-3.3.2 → python_roborock-3.7.1}/roborock/devices/traits/v1/command.py

@@ -1,6 +1,7 @@
 from typing import Any
 
 from roborock import RoborockCommand
+from roborock.protocols.v1_protocol import ParamsType
 
 
 class CommandTrait:
@@ -14,7 +15,7 @@ class CommandTrait:
         """
         self._rpc_channel = None
 
-    async def send(self, command: RoborockCommand | str, params: dict[str, Any] | None = None) -> Any:
+    async def send(self, command: RoborockCommand | str, params: ParamsType = None) -> Any:
         """Send a command to the device."""
         if not self._rpc_channel:
             raise ValueError("Device trait in invalid state")

{python_roborock-3.3.2 → python_roborock-3.7.1}/roborock/devices/traits/v1/home.py

@@ -20,6 +20,7 @@ from roborock.devices.traits.v1 import common
 from roborock.exceptions import RoborockDeviceBusy, RoborockException
 from roborock.roborock_typing import RoborockCommand
 
+from .map_content import MapContent, MapContentTrait
 from .maps import MapsTrait
 from .rooms import RoomsTrait
 from .status import StatusTrait
@@ -38,6 +39,7 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
         self,
         status_trait: StatusTrait,
         maps_trait: MapsTrait,
+        map_content: MapContentTrait,
         rooms_trait: RoomsTrait,
         cache: Cache,
     ) -> None:
@@ -59,9 +61,11 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
         super().__init__()
         self._status_trait = status_trait
         self._maps_trait = maps_trait
+        self._map_content = map_content
         self._rooms_trait = rooms_trait
         self._cache = cache
-        self._home_cache: dict[int, CombinedMapInfo] | None = None
+        self._home_map_info: dict[int, CombinedMapInfo] | None = None
+        self._home_map_content: dict[int, MapContent] | None = None
 
     async def discover_home(self) -> None:
         """Iterate through all maps to discover rooms and cache them.
@@ -72,13 +76,21 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
         cleaning process. This will raise `RoborockDeviceBusy` if the device is
         currently cleaning.
 
-        After discovery, the home cache will be populated and can be accessed via the `home_cache` property.
+        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_cache:
+        if cache_data.home_map_info and cache_data.home_map_content:
             _LOGGER.debug("Home cache already populated, skipping discovery")
-            self._home_cache = cache_data.home_cache
-            return
+            self._home_map_info = cache_data.home_map_info
+            try:
+                self._home_map_content = {
+                    k: self._map_content.parse_map_content(v) for k, v in cache_data.home_map_content.items()
+                }
+            except (ValueError, RoborockException) as ex:
+                _LOGGER.warning("Failed to parse cached home map content, will re-discover: %s", ex)
+                self._home_map_content = {}
+            else:
+                return
 
         if self._status_trait.state == RoborockStateCode.cleaning:
             raise RoborockDeviceBusy("Cannot perform home discovery while the device is cleaning")
@@ -87,11 +99,11 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
         if self._maps_trait.current_map_info is None:
             raise RoborockException("Cannot perform home discovery without current map info")
 
-        home_cache = await self._build_home_cache()
-        _LOGGER.debug("Home discovery complete, caching data for %d maps", len(home_cache))
-        await self._update_home_cache(home_cache)
+        home_map_info, home_map_content = await self._build_home_map_info()
+        _LOGGER.debug("Home discovery complete, caching data for %d maps", len(home_map_info))
+        await self._update_home_cache(home_map_info, home_map_content)
 
-    async def _refresh_map_data(self, map_info) -> CombinedMapInfo:
+    async def _refresh_map_info(self, map_info) -> CombinedMapInfo:
         """Collect room data for a specific map and return CombinedMapInfo."""
         await self._rooms_trait.refresh()
         return CombinedMapInfo(
@@ -100,9 +112,19 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
             rooms=self._rooms_trait.rooms or [],
         )
 
-    async def _build_home_cache(self) -> dict[int, CombinedMapInfo]:
-        """Perform the actual discovery and caching of home data."""
-        home_cache: dict[int, CombinedMapInfo] = {}
+    async def _refresh_map_content(self) -> MapContent:
+        """Refresh the map content trait to get the latest map data."""
+        await self._map_content.refresh()
+        return MapContent(
+            image_content=self._map_content.image_content,
+            map_data=self._map_content.map_data,
+            raw_api_response=self._map_content.raw_api_response,
+        )
+
+    async def _build_home_map_info(self) -> tuple[dict[int, CombinedMapInfo], dict[int, MapContent]]:
+        """Perform the actual discovery and caching of home map info and content."""
+        home_map_info: dict[int, CombinedMapInfo] = {}
+        home_map_content: dict[int, MapContent] = {}
 
         # Sort map_info to process the current map last, reducing map switching.
         # False (non-original maps) sorts before True (original map). We ensure
@@ -120,9 +142,12 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
                 await self._maps_trait.set_current_map(map_info.map_flag)
                 await asyncio.sleep(MAP_SLEEP)
 
-            map_data = await self._refresh_map_data(map_info)
-            home_cache[map_info.map_flag] = map_data
-        return home_cache
+            map_content = await self._refresh_map_content()
+            home_map_content[map_info.map_flag] = map_content
+
+            combined_map_info = await self._refresh_map_info(map_info)
+            home_map_info[map_info.map_flag] = combined_map_info
+        return home_map_info, home_map_content
 
     async def refresh(self) -> Self:
         """Refresh current map's underlying map and room data, updating cache as needed.
@@ -131,7 +156,7 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
         active maps or re-discover the home. It is expected that this will keep
         information up to date for the current map as users switch to that map.
         """
-        if self._home_cache is None:
+        if self._home_map_info is None:
             raise RoborockException("Cannot refresh home data without home cache, did you call discover_home()?")
 
         # Refresh the list of map names/info
@@ -141,34 +166,56 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
         ) is None:
             raise RoborockException("Cannot refresh home data without current map info")
 
+        # Refresh the map content to ensure we have the latest image and object positions
+        new_map_content = await self._refresh_map_content()
         # Refresh the current map's room data
-        current_map_data = self._home_cache.get(map_flag)
-        if current_map_data:
-            map_data = await self._refresh_map_data(current_map_info)
-            if map_data != current_map_data:
-                await self._update_home_cache({**self._home_cache, map_flag: map_data})
-
+        combined_map_info = await self._refresh_map_info(current_map_info)
+        await self._update_current_map_cache(map_flag, combined_map_info, new_map_content)
         return self
 
     @property
-    def home_cache(self) -> dict[int, CombinedMapInfo] | None:
+    def home_map_info(self) -> dict[int, CombinedMapInfo] | None:
         """Returns the map information for all cached maps."""
-        return self._home_cache
+        return self._home_map_info
 
     @property
     def current_map_data(self) -> CombinedMapInfo | None:
         """Returns the map data for the current map."""
         current_map_flag = self._maps_trait.current_map
-        if current_map_flag is None or self._home_cache is None:
+        if current_map_flag is None or self._home_map_info is None:
             return None
-        return self._home_cache.get(current_map_flag)
+        return self._home_map_info.get(current_map_flag)
+
+    @property
+    def home_map_content(self) -> dict[int, MapContent] | None:
+        """Returns the map content for all cached maps."""
+        return self._home_map_content
 
     def _parse_response(self, response: common.V1ResponseData) -> Self:
         """This trait does not parse responses directly."""
         raise NotImplementedError("HomeTrait does not support direct command responses")
 
-    async def _update_home_cache(self, home_cache: dict[int, CombinedMapInfo]) -> None:
+    async def _update_home_cache(
+        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 = {k: v.raw_api_response for k, v in home_map_content.items() if v.raw_api_response}
+        await self._cache.set(cache_data)
+        self._home_map_info = home_map_info
+        self._home_map_content = home_map_content
+
+    async def _update_current_map_cache(
+        self, map_flag: int, map_info: CombinedMapInfo, map_content: MapContent
+    ) -> None:
+        """Update the cache for the current map only."""
         cache_data = await self._cache.get()
-        cache_data.home_cache = home_cache
+        cache_data.home_map_info[map_flag] = map_info
+        if map_content.raw_api_response:
+            cache_data.home_map_content[map_flag] = map_content.raw_api_response
         await self._cache.set(cache_data)
-        self._home_cache = home_cache
+        if self._home_map_info is None or self._home_map_content is None:
+            raise RoborockException("Home cache is not initialized, cannot update current map cache")
+        self._home_map_info[map_flag] = map_info
+        self._home_map_content[map_flag] = map_content

{python_roborock-3.3.2 → python_roborock-3.7.1}/roborock/devices/traits/v1/map_content.py

@@ -25,6 +25,13 @@ class MapContent(RoborockBase):
     map_data: MapData | None = None
     """The parsed map data which contains metadata for points on the map."""
 
+    raw_api_response: bytes | None = None
+    """The raw bytes of the map data from the API for caching for future use.
+
+    This should be treated as an opaque blob used only internally by this library
+    to re-parse the map data when needed.
+    """
+
     def __repr__(self) -> str:
         """Return a string representation of the MapContent."""
         img = self.image_content
@@ -48,7 +55,23 @@ class MapContentTrait(MapContent, common.V1TraitMixin):
         """Parse the response from the device into a MapContentTrait instance."""
         if not isinstance(response, bytes):
             raise ValueError(f"Unexpected MapContentTrait response format: {type(response)}")
+        return self.parse_map_content(response)
+
+    def parse_map_content(self, response: bytes) -> MapContent:
+        """Parse the map content from raw bytes.
+
+        This method is exposed so that cached map data can be parsed without
+        needing to go through the RPC channel.
+
+        Args:
+            response: The raw bytes of the map data from the API.
+
+        Returns:
+            MapContent: The parsed map content.
 
+        Raises:
+            RoborockException: If the map data cannot be parsed.
+        """
         parsed_data = self._map_parser.parse(response)
         if parsed_data is None:
             raise ValueError("Failed to parse map data")
@@ -56,4 +79,5 @@ class MapContentTrait(MapContent, common.V1TraitMixin):
         return MapContent(
             image_content=parsed_data.image_content,
             map_data=parsed_data.map_data,
+            raw_api_response=response,
         )

python_roborock-3.7.1/roborock/devices/traits/v1/routines.py

@@ -0,0 +1,26 @@
+"""Routines trait for V1 devices."""
+
+from roborock.data.containers import HomeDataScene
+from roborock.web_api import UserWebApiClient
+
+
+class RoutinesTrait:
+    """Trait for interacting with routines."""
+
+    def __init__(self, device_id: str, web_api: UserWebApiClient) -> None:
+        """Initialize the routines trait."""
+        self._device_id = device_id
+        self._web_api = web_api
+
+    async def get_routines(self) -> list[HomeDataScene]:
+        """Get available routines."""
+        return await self._web_api.get_routines(self._device_id)
+
+    async def execute_routine(self, routine_id: int) -> None:
+        """Execute a routine by its ID.
+
+        Technically, routines are per-device, but the API does not
+        require the device ID to execute them. This can execute a
+        routine for any device but it is exposed here for convenience.
+        """
+        await self._web_api.execute_routine(routine_id)

{python_roborock-3.3.2 → python_roborock-3.7.1}/roborock/devices/traits/v1/valley_electricity_timer.py

@@ -5,7 +5,7 @@ from roborock.roborock_typing import RoborockCommand
 _ENABLED_PARAM = "enabled"
 
 
-class ValleyElectricityTimerTrait(ValleyElectricityTimer, common.V1TraitMixin):
+class ValleyElectricityTimerTrait(ValleyElectricityTimer, common.V1TraitMixin, common.RoborockSwitchBase):
     """Trait for managing Valley Electricity Timer settings on Roborock devices."""
 
     command = RoborockCommand.GET_VALLEY_ELECTRICITY_TIMER

{python_roborock-3.3.2 → python_roborock-3.7.1}/roborock/web_api.py

@@ -707,3 +707,29 @@ def _get_hawk_authentication(rriot: RRiot, url: str, formdata: dict | None = Non
     )
     mac = base64.b64encode(hmac.new(rriot.h.encode(), prestr.encode(), hashlib.sha256).digest()).decode()
     return f'Hawk id="{rriot.u}",s="{rriot.s}",ts="{timestamp}",nonce="{nonce}",mac="{mac}"'
+
+
+class UserWebApiClient:
+    """Wrapper around RoborockApiClient to provide information for a specific user.
+
+    This binds a RoborockApiClient to a specific user context with the
+    provided UserData. This allows for easier access to user-specific data,
+    to avoid needing to pass UserData around and mock out the web API.
+    """
+
+    def __init__(self, web_api: RoborockApiClient, user_data: UserData) -> None:
+        """Initialize the wrapper with the API client and user data."""
+        self._web_api = web_api
+        self._user_data = user_data
+
+    async def get_home_data(self) -> HomeData:
+        """Fetch home data using the API client."""
+        return await self._web_api.get_home_data_v3(self._user_data)
+
+    async def get_routines(self, device_id: str) -> list[HomeDataScene]:
+        """Fetch routines (scenes) for a specific device."""
+        return await self._web_api.get_scenes(self._user_data, device_id)
+
+    async def execute_routine(self, scene_id: int) -> None:
+        """Execute a specific routine (scene) by its ID."""
+        await self._web_api.execute_scene(self._user_data, scene_id)

{python_roborock-3.3.2 → python_roborock-3.7.1}/roborock/version_1_apis/roborock_local_client_v1.py

@@ -210,6 +210,7 @@ class RoborockLocalClientV1(RoborockClientV1, RoborockClient):
             version=self.local_protocol_version,
         )
         self._logger.debug("Building message id %s for method %s", request_message.request_id, method)
+        await self._validate_connection()
         return await self._send_message(
             roborock_message,
             request_id=request_message.request_id,
@@ -226,7 +227,6 @@ class RoborockLocalClientV1(RoborockClientV1, RoborockClient):
         method: str | None = None,
         params: list | dict | int | None = None,
     ) -> RoborockMessage:
-        await self._validate_connection()
         msg = self._encoder(roborock_message)
         if method:
             self._logger.debug(f"id={request_id} Requesting method {method} with {params}")