roborock-cli 0.1.1__py3-none-any.whl

roborock_cli/_vendor/roborock/devices/traits/v1/consumeable.py

@@ -0,0 +1,48 @@
+"""Trait for managing consumable attributes.
+
+A consumable attribute is one that is expected to be replaced or refilled
+periodically, such as filters, brushes, etc.
+"""
+
+from enum import StrEnum
+from typing import Self
+
+from roborock_cli._vendor.roborock.data import Consumable
+from roborock_cli._vendor.roborock.devices.traits.v1 import common
+from roborock_cli._vendor.roborock.roborock_typing import RoborockCommand
+
+__all__ = [
+    "ConsumableTrait",
+]
+
+
+class ConsumableAttribute(StrEnum):
+    """Enum for consumable attributes."""
+
+    SENSOR_DIRTY_TIME = "sensor_dirty_time"
+    FILTER_WORK_TIME = "filter_work_time"
+    SIDE_BRUSH_WORK_TIME = "side_brush_work_time"
+    MAIN_BRUSH_WORK_TIME = "main_brush_work_time"
+
+    @classmethod
+    def from_str(cls, value: str) -> Self:
+        """Create a ConsumableAttribute from a string value."""
+        for member in cls:
+            if member.value == value:
+                return member
+        raise ValueError(f"Unknown ConsumableAttribute: {value}")
+
+
+class ConsumableTrait(Consumable, common.V1TraitMixin):
+    """Trait for managing consumable attributes on Roborock devices.
+
+    After the first refresh, you can tell what consumables are supported by
+    checking which attributes are not None.
+    """
+
+    command = RoborockCommand.GET_CONSUMABLE
+
+    async def reset_consumable(self, consumable: ConsumableAttribute) -> None:
+        """Reset a specific consumable attribute on the device."""
+        await self.rpc_channel.send_command(RoborockCommand.RESET_CONSUMABLE, params=[consumable.value])
+        await self.refresh()

roborock_cli/_vendor/roborock/devices/traits/v1/device_features.py

@@ -0,0 +1,74 @@
+from dataclasses import Field, fields
+
+from roborock_cli._vendor.roborock.data import AppInitStatus, HomeDataProduct, RoborockBase
+from roborock_cli._vendor.roborock.data.v1.v1_containers import FieldNameBase
+from roborock_cli._vendor.roborock.device_features import DeviceFeatures
+from roborock_cli._vendor.roborock.devices.cache import DeviceCache
+from roborock_cli._vendor.roborock.devices.traits.v1 import common
+from roborock_cli._vendor.roborock.roborock_typing import RoborockCommand
+
+
+class DeviceFeaturesTrait(DeviceFeatures, common.V1TraitMixin):
+    """Trait for managing supported features on Roborock devices."""
+
+    command = RoborockCommand.APP_GET_INIT_STATUS
+
+    def __init__(self, product: HomeDataProduct, device_cache: DeviceCache) -> None:  # pylint: disable=super-init-not-called
+        """Initialize DeviceFeaturesTrait."""
+        self._product = product
+        self._nickname = product.product_nickname
+        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):
+            setattr(self, field.name, False)
+
+    def is_field_supported(self, cls: type[RoborockBase], field_name: FieldNameBase) -> bool:
+        """Determines if the specified field is supported by this device.
+
+        We use dataclass attributes on the field to specify the schema code that is required
+        for the field to be supported and it is compared against the list of
+        supported schema codes for the device returned in the product information.
+        """
+        dataclass_field: Field | None = None
+        for field in fields(cls):
+            if field.name == field_name:
+                dataclass_field = field
+                break
+        if dataclass_field is None:
+            raise ValueError(f"Field {field_name} not found in {cls}")
+
+        requires_schema_code = dataclass_field.metadata.get("requires_schema_code", None)
+        if requires_schema_code is None:
+            # We assume the field is supported
+            return True
+        # If the field requires a protocol that is not supported, we return False
+        return requires_schema_code in self._product.supported_schema_codes
+
+    async def refresh(self) -> None:
+        """Refresh the contents of this trait.
+
+        This will use cached device features if available since they do not
+        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._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._device_cache.set(cache_data)
+
+    def _parse_response(self, response: common.V1ResponseData) -> DeviceFeatures:
+        """Parse the response from the device into a MapContentTrait instance."""
+        if not isinstance(response, list):
+            raise ValueError(f"Unexpected AppInitStatus response format: {type(response)}")
+        app_status = AppInitStatus.from_dict(response[0])
+        return DeviceFeatures.from_feature_flags(
+            new_feature_info=app_status.new_feature_info,
+            new_feature_info_str=app_status.new_feature_info_str,
+            feature_info=app_status.feature_info,
+            product_nickname=self._nickname,
+        )

roborock_cli/_vendor/roborock/devices/traits/v1/do_not_disturb.py

@@ -0,0 +1,41 @@
+from roborock_cli._vendor.roborock.data import DnDTimer
+from roborock_cli._vendor.roborock.devices.traits.v1 import common
+from roborock_cli._vendor.roborock.roborock_typing import RoborockCommand
+
+_ENABLED_PARAM = "enabled"
+
+
+class DoNotDisturbTrait(DnDTimer, common.V1TraitMixin, common.RoborockSwitchBase):
+    """Trait for managing Do Not Disturb (DND) settings on Roborock devices."""
+
+    command = RoborockCommand.GET_DND_TIMER
+
+    @property
+    def is_on(self) -> bool:
+        """Return whether the Do Not Disturb (DND) timer is enabled."""
+        return self.enabled == 1
+
+    async def set_dnd_timer(self, dnd_timer: DnDTimer) -> None:
+        """Set the Do Not Disturb (DND) timer settings of the device."""
+        await self.rpc_channel.send_command(RoborockCommand.SET_DND_TIMER, params=dnd_timer.as_list())
+        await self.refresh()
+
+    async def clear_dnd_timer(self) -> None:
+        """Clear the Do Not Disturb (DND) timer settings of the device."""
+        await self.rpc_channel.send_command(RoborockCommand.CLOSE_DND_TIMER)
+        await self.refresh()
+
+    async def enable(self) -> None:
+        """Set the Do Not Disturb (DND) timer settings of the device."""
+        await self.rpc_channel.send_command(
+            RoborockCommand.SET_DND_TIMER,
+            params=self.as_list(),
+        )
+        # Optimistic update to avoid an extra refresh
+        self.enabled = 1
+
+    async def disable(self) -> None:
+        """Disable the Do Not Disturb (DND) timer settings of the device."""
+        await self.rpc_channel.send_command(RoborockCommand.CLOSE_DND_TIMER)
+        # Optimistic update to avoid an extra refresh
+        self.enabled = 0

roborock_cli/_vendor/roborock/devices/traits/v1/dust_collection_mode.py

@@ -0,0 +1,13 @@
+"""Trait for dust collection mode."""
+
+from roborock_cli._vendor.roborock.data import DustCollectionMode
+from roborock_cli._vendor.roborock.device_features import is_valid_dock
+from roborock_cli._vendor.roborock.devices.traits.v1 import common
+from roborock_cli._vendor.roborock.roborock_typing import RoborockCommand
+
+
+class DustCollectionModeTrait(DustCollectionMode, common.V1TraitMixin):
+    """Trait for dust collection mode."""
+
+    command = RoborockCommand.GET_DUST_COLLECTION_MODE
+    requires_dock_type = is_valid_dock

roborock_cli/_vendor/roborock/devices/traits/v1/flow_led_status.py

@@ -0,0 +1,29 @@
+from roborock_cli._vendor.roborock.data import FlowLedStatus
+from roborock_cli._vendor.roborock.devices.traits.v1 import common
+from roborock_cli._vendor.roborock.roborock_typing import RoborockCommand
+
+_STATUS_PARAM = "status"
+
+
+class FlowLedStatusTrait(FlowLedStatus, common.V1TraitMixin, common.RoborockSwitchBase):
+    """Trait for controlling the Flow LED status of a Roborock device."""
+
+    command = RoborockCommand.GET_FLOW_LED_STATUS
+    requires_feature = "is_flow_led_setting_supported"
+
+    @property
+    def is_on(self) -> bool:
+        """Return whether the Flow LED status is enabled."""
+        return self.status == 1
+
+    async def enable(self) -> None:
+        """Enable the Flow LED status."""
+        await self.rpc_channel.send_command(RoborockCommand.SET_FLOW_LED_STATUS, params={_STATUS_PARAM: 1})
+        # Optimistic update to avoid an extra refresh
+        self.status = 1
+
+    async def disable(self) -> None:
+        """Disable the Flow LED status."""
+        await self.rpc_channel.send_command(RoborockCommand.SET_FLOW_LED_STATUS, params={_STATUS_PARAM: 0})
+        # Optimistic update to avoid an extra refresh
+        self.status = 0

roborock_cli/_vendor/roborock/devices/traits/v1/home.py

@@ -0,0 +1,285 @@
+"""Trait that represents a full view of the home layout.
+
+This trait combines information about maps and rooms to provide a comprehensive
+view of the home layout, including room names and their corresponding segment
+on the map. It also makes it straight forward to fetch the map image and data.
+
+This trait depends on the MapsTrait and RoomsTrait to gather the necessary
+information. It provides properties to access the current map, the list of
+rooms with names, and the map image and data.
+
+Callers may first call `discover_home()` to populate the home layout cache by
+iterating through all available maps on the device. This will cache the map
+information and room names for all maps to minimize map switching and improve
+performance. After the initial discovery, callers can call `refresh()` to update
+the current map's information and room names as needed.
+"""
+
+import asyncio
+import base64
+import logging
+from typing import Self
+
+from roborock_cli._vendor.roborock.data import CombinedMapInfo, MultiMapsListMapInfo, NamedRoomMapping, RoborockBase
+from roborock_cli._vendor.roborock.data.v1.v1_code_mappings import RoborockStateCode
+from roborock_cli._vendor.roborock.devices.cache import DeviceCache
+from roborock_cli._vendor.roborock.devices.traits.v1 import common
+from roborock_cli._vendor.roborock.exceptions import RoborockDeviceBusy, RoborockException, RoborockInvalidStatus
+from roborock_cli._vendor.roborock.roborock_typing import RoborockCommand
+
+from .map_content import MapContent, MapContentTrait
+from .maps import MapsTrait
+from .rooms import RoomsTrait
+from .status import StatusTrait
+
+_LOGGER = logging.getLogger(__name__)
+
+MAP_SLEEP = 3
+
+
+class HomeTrait(RoborockBase, common.V1TraitMixin):
+    """Trait that represents a full view of the home layout."""
+
+    command = RoborockCommand.GET_MAP_V1  # This is not used
+
+    def __init__(
+        self,
+        status_trait: StatusTrait,
+        maps_trait: MapsTrait,
+        map_content: MapContentTrait,
+        rooms_trait: RoomsTrait,
+        device_cache: DeviceCache,
+    ) -> None:
+        """Initialize the HomeTrait.
+
+        We keep track of the MapsTrait and RoomsTrait to provide a comprehensive
+        view of the home layout. This also depends on the StatusTrait to determine
+        the current map. See comments in MapsTrait for details on that dependency.
+
+        The cache is used to store discovered home data to minimize map switching
+        and improve performance. The cache should be persisted by the caller to
+        ensure data is retained across restarts.
+
+        After initial discovery, only information for the current map is refreshed
+        to keep data up to date without excessive map switching. However, as
+        users switch rooms, the current map's data will be updated to ensure
+        accuracy.
+        """
+        super().__init__()
+        self._status_trait = status_trait
+        self._maps_trait = maps_trait
+        self._map_content = map_content
+        self._rooms_trait = rooms_trait
+        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
+
+    async def discover_home(self) -> None:
+        """Iterate through all maps to discover rooms and cache them.
+
+        This will be a no-op if the home cache is already populated.
+
+        This cannot be called while the device is cleaning, as that would interrupt the
+        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_map_info` property.
+        """
+        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 = device_cache_data.home_map_info
+            self._discovery_completed = True
+            try:
+                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 = {}
+            else:
+                return
+
+        if self._status_trait.state == RoborockStateCode.cleaning:
+            raise RoborockDeviceBusy("Cannot perform home discovery while the device is cleaning")
+
+        await self._maps_trait.refresh()
+        if self._maps_trait.current_map_info is None:
+            raise RoborockException("Cannot perform home discovery without current map info")
+
+        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))
+        self._discovery_completed = True
+        await self._update_home_cache(home_map_info, home_map_content)
+
+    async def _refresh_map_info(self, map_info: MultiMapsListMapInfo) -> CombinedMapInfo:
+        """Collect room data for a specific map and return CombinedMapInfo."""
+        await self._rooms_trait.refresh()
+
+        # We have room names from multiple sources:
+        # - The map_info.rooms which we just received from the MultiMapsList
+        # - RoomsTrait rooms come from the GET_ROOM_MAPPING command for the current device (only)
+        # - RoomsTrait rooms that are pulled from the cloud API
+        # We always prefer the RoomsTrait room names since they are always newer and
+        # just refreshed above.
+        rooms_map: dict[int, NamedRoomMapping] = {
+            **map_info.rooms_map,
+            **{room.segment_id: room for room in self._rooms_trait.rooms or ()},
+        }
+        return CombinedMapInfo(
+            map_flag=map_info.map_flag,
+            name=map_info.name,
+            rooms=list(rooms_map.values()),
+        )
+
+    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
+        # we load the original map last.
+        sorted_map_infos = sorted(
+            self._maps_trait.map_info or [],
+            key=lambda mi: mi.map_flag == self._maps_trait.current_map,
+            reverse=False,
+        )
+        _LOGGER.debug("Building home cache for maps: %s", [mi.map_flag for mi in sorted_map_infos])
+        for map_info in sorted_map_infos:
+            # We need to load each map to get its room data
+            if len(sorted_map_infos) > 1:
+                _LOGGER.debug("Loading map %s", map_info.map_flag)
+                try:
+                    await self._maps_trait.set_current_map(map_info.map_flag)
+                except RoborockInvalidStatus as ex:
+                    # Device is in a state that forbids map switching. Translate to
+                    # "busy" so callers can fall back to refreshing the current map only.
+                    raise RoborockDeviceBusy("Cannot switch maps right now (device action locked)") from ex
+                await asyncio.sleep(MAP_SLEEP)
+
+            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) -> None:
+        """Refresh current map's underlying map and room data, updating cache as needed.
+
+        This will only refresh the current map's data and will not populate non
+        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 not self._discovery_completed:
+            # Running initial discovery also populates all of the same information
+            # as below so we can just call that method. If the device is busy
+            # then we'll fall through below to refresh the current map only.
+            try:
+                await self.discover_home()
+                return
+            except RoborockDeviceBusy:
+                _LOGGER.debug("Cannot refresh home data while device is busy cleaning")
+
+        # Refresh the list of map names/info
+        await self._maps_trait.refresh()
+        if (current_map_info := self._maps_trait.current_map_info) is None or (
+            map_flag := self._maps_trait.current_map
+        ) 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
+        combined_map_info = await self._refresh_map_info(current_map_info)
+        await self._update_current_map(
+            map_flag, combined_map_info, new_map_content, update_cache=self._discovery_completed
+        )
+
+    @property
+    def home_map_info(self) -> dict[int, CombinedMapInfo] | None:
+        """Returns the map information for all cached maps."""
+        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_map_info is None:
+            return None
+        return self._home_map_info.get(current_map_flag)
+
+    @property
+    def current_rooms(self) -> list[NamedRoomMapping]:
+        """Returns the room names for the current map."""
+        if self.current_map_data is None:
+            return []
+        return self.current_map_data.rooms
+
+    @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_map_info: dict[int, CombinedMapInfo], home_map_content: dict[int, MapContent]
+    ) -> None:
+        """Update the entire home cache with new map info and content."""
+        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
+        }
+        await self._device_cache.set(device_cache_data)
+        self._home_map_info = home_map_info
+        self._home_map_content = home_map_content
+
+    async def _update_current_map(
+        self,
+        map_flag: int,
+        map_info: CombinedMapInfo,
+        map_content: MapContent,
+        update_cache: bool,
+    ) -> None:
+        """Update the cache for the current map only."""
+        # Update the persistent cache if requested e.g. home discovery has
+        # completed and we want to keep it fresh. Otherwise just update the
+        # in memory map below.
+        if update_cache:
+            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 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 = {}
+        self._home_map_info[map_flag] = map_info
+
+        if self._home_map_content is None:
+            self._home_map_content = {}
+        self._home_map_content[map_flag] = map_content

roborock_cli/_vendor/roborock/devices/traits/v1/led_status.py

@@ -0,0 +1,43 @@
+from roborock_cli._vendor.roborock.data import LedStatus
+from roborock_cli._vendor.roborock.devices.traits.v1 import common
+from roborock_cli._vendor.roborock.roborock_typing import RoborockCommand
+
+from .common import V1ResponseData
+
+
+class LedStatusTrait(LedStatus, common.V1TraitMixin, common.RoborockSwitchBase):
+    """Trait for controlling the LED status of a Roborock device."""
+
+    command = RoborockCommand.GET_LED_STATUS
+    requires_feature = "is_led_status_switch_supported"
+
+    @property
+    def is_on(self) -> bool:
+        """Return whether the LED status is enabled."""
+        return self.status == 1
+
+    async def enable(self) -> None:
+        """Enable the LED status."""
+        await self.rpc_channel.send_command(RoborockCommand.SET_LED_STATUS, params=[1])
+        # Optimistic update to avoid an extra refresh
+        self.status = 1
+
+    async def disable(self) -> None:
+        """Disable the LED status."""
+        await self.rpc_channel.send_command(RoborockCommand.SET_LED_STATUS, params=[0])
+        # Optimistic update to avoid an extra refresh
+        self.status = 0
+
+    @classmethod
+    def _parse_type_response(cls, response: V1ResponseData) -> LedStatus:
+        """Parse the response from the device into a a RoborockBase.
+
+        Subclasses should override this method to implement custom parsing
+        logic as needed.
+        """
+        if not isinstance(response, list):
+            raise ValueError(f"Unexpected {cls} response format: {response!r}")
+        response = response[0]
+        if not isinstance(response, int):
+            raise ValueError(f"Unexpected {cls} response format: {response!r}")
+        return cls.from_dict({"status": response})

roborock_cli/_vendor/roborock/devices/traits/v1/map_content.py

@@ -0,0 +1,83 @@
+"""Trait for fetching the map content from Roborock devices."""
+
+import logging
+from dataclasses import dataclass
+
+from vacuum_map_parser_base.map_data import MapData
+
+from roborock_cli._vendor.roborock.data import RoborockBase
+from roborock_cli._vendor.roborock.devices.traits.v1 import common
+from roborock_cli._vendor.roborock.map.map_parser import MapParser, MapParserConfig
+from roborock_cli._vendor.roborock.roborock_typing import RoborockCommand
+
+_LOGGER = logging.getLogger(__name__)
+
+_TRUNCATE_LENGTH = 20
+
+
+@dataclass
+class MapContent(RoborockBase):
+    """Dataclass representing map content."""
+
+    image_content: bytes | None = None
+    """The rendered image of the map in PNG format."""
+
+    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
+        if self.image_content and len(self.image_content) > _TRUNCATE_LENGTH:
+            img = self.image_content[: _TRUNCATE_LENGTH - 3] + b"..."
+        return f"MapContent(image_content={img!r}, map_data={self.map_data!r})"
+
+
+@common.map_rpc_channel
+class MapContentTrait(MapContent, common.V1TraitMixin):
+    """Trait for fetching the map content."""
+
+    command = RoborockCommand.GET_MAP_V1
+
+    def __init__(self, map_parser_config: MapParserConfig | None = None) -> None:
+        """Initialize MapContentTrait."""
+        super().__init__()
+        self._map_parser = MapParser(map_parser_config or MapParserConfig())
+
+    def _parse_response(self, response: common.V1ResponseData) -> MapContent:
+        """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")
+
+        return MapContent(
+            image_content=parsed_data.image_content,
+            map_data=parsed_data.map_data,
+            raw_api_response=response,
+        )