valetudo-map-parser 0.1.9b65__py3-none-any.whl → 0.1.9b68__py3-none-any.whl

valetudo_map_parser/config/shared.py

@@ -39,6 +39,7 @@ from .types import (
     CameraModes,
     Colors,
     TrimsData,
+    PilPNG,
 )
 
 
@@ -58,9 +59,10 @@ class CameraShared:
         self.rand256_active_zone: list = []  # Active zone for rand256
         self.is_rand: bool = False  # MQTT rand data
         self._new_mqtt_message = False  # New MQTT message
-        self.last_image = None  # Last image received
-        self.current_image = None  # Current image
-        self.binary_image = None  # Current image in binary format
+        self.last_image = PilPNG | None  # Last image received
+        self.new_image: PilPNG | None = None  # New image received
+        self.binary_image: bytes | None = None  # Current image in binary format
+        self.image_last_updated: float = 0.0  # Last image update time
         self.image_format = "image/pil"  # Image format
         self.image_size = None  # Image size
         self.image_auto_zoom: bool = False  # Auto zoom image
@@ -115,7 +117,7 @@ class CameraShared:
 
 
 
-    def _state_charging(self) -> bool:
+    def vacuum_bat_charged(self) -> bool:
         """Check if the vacuum is charging."""
         return (self.vacuum_state == "docked") and (int(self.vacuum_battery) < 100)
 
@@ -193,7 +195,7 @@ class CameraShared:
         attrs = {
             ATTR_CAMERA_MODE: self.camera_mode,
             ATTR_VACUUM_BATTERY: f"{self.vacuum_battery}%",
-            ATTR_VACUUM_CHARGING: self._state_charging(),
+            ATTR_VACUUM_CHARGING: self.vacuum_bat_charged,
             ATTR_VACUUM_POSITION: self.current_room,
             ATTR_VACUUM_STATUS: self.vacuum_state,
             ATTR_VACUUM_JSON_ID: self.vac_json_id,
@@ -228,12 +230,13 @@ class CameraShared:
 class CameraSharedManager:
     """Camera Shared Manager class."""
 
-    def __init__(self, file_name, device_info):
+    def __init__(self, file_name: str, device_info: dict = None):
         self._instances = {}
         self._lock = asyncio.Lock()
         self.file_name = file_name
-        self.device_info = device_info
-        self.update_shared_data(device_info)
+        if device_info:
+            self.device_info = device_info
+            self.update_shared_data(device_info)
 
         # Automatically initialize shared data for the instance
         # self._init_shared_data(device_info)

valetudo_map_parser/config/utils.py

@@ -1,5 +1,6 @@
 """Utility code for the valetudo map parser."""
 
+import datetime
 import hashlib
 import json
 from dataclasses import dataclass
@@ -79,6 +80,67 @@ class BaseHandler:
         """Return the robot position."""
         return self.robot_pos
 
+    async def async_get_pil_image(
+        self,
+        m_json: dict | None,
+        destinations: list | None = None,
+    ) -> PilPNG | None:
+        """
+        Unified async function to get PIL image from JSON data for both Hypfer and Rand256 handlers.
+
+        This function:
+        1. Calls the appropriate async_get_image_from_json method
+        2. Stores the processed data in shared.new_image
+        3. Backs up previous data to shared.last_image
+        4. Updates shared.image_last_updated with current datetime
+
+        @param m_json: The JSON data to use to draw the image
+        @param destinations: MQTT destinations for labels (used by Rand256)
+        @return: PIL Image or None
+        """
+        try:
+            # Backup current image to last_image before processing new one
+            if hasattr(self.shared, 'new_image') and self.shared.new_image is not None:
+                self.shared.last_image = self.shared.new_image
+
+            # Call the appropriate handler method based on handler type
+            if hasattr(self, 'get_image_from_rrm'):
+                # This is a Rand256 handler
+                new_image = await self.get_image_from_rrm(
+                    m_json=m_json,
+                    destinations=destinations,
+                    return_webp=False  # Always return PIL Image
+                )
+            elif hasattr(self, 'async_get_image_from_json'):
+                # This is a Hypfer handler
+                new_image = await self.async_get_image_from_json(
+                    m_json=m_json,
+                    return_webp=False  # Always return PIL Image
+                )
+            else:
+                LOGGER.warning("%s: Handler type not recognized for async_get_pil_image", self.file_name)
+                return None
+
+            # Store the new image in shared data
+            if new_image is not None:
+                self.shared.new_image = new_image
+                # Update the timestamp with current datetime
+                self.shared.image_last_updated = datetime.datetime.now().timestamp()
+                LOGGER.debug("%s: Image processed and stored in shared data", self.file_name)
+            else:
+                LOGGER.warning("%s: Failed to generate image from JSON data", self.file_name)
+
+            return new_image
+
+        except Exception as e:
+            LOGGER.error(
+                "%s: Error in async_get_pil_image: %s",
+                self.file_name,
+                str(e),
+                exc_info=True
+            )
+            return None
+
     def get_charger_position(self) -> ChargerPosition | None:
         """Return the charger position."""
         return self.charger_pos

valetudo_map_parser/hypfer_handler.py

@@ -8,11 +8,10 @@ Version: 0.1.9
 from __future__ import annotations
 
 import asyncio
-import json
 
 from PIL import Image
 
-from .config.async_utils import AsyncNumPy, AsyncPIL, AsyncParallel
+from .config.async_utils import AsyncNumPy, AsyncPIL
 from .config.auto_crop import AutoCrop
 from .config.drawable_elements import DrawableElement
 from .config.shared import CameraShared
@@ -25,6 +24,7 @@ from .config.types import (
     RoomsProperties,
     RoomStore,
     WebPBytes,
+    JsonType,
 )
 from .config.utils import (
     BaseHandler,
@@ -100,7 +100,7 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
     # noinspection PyUnresolvedReferences,PyUnboundLocalVariable
     async def async_get_image_from_json(
         self,
-        m_json: json | None,
+        m_json: JsonType | None,
         return_webp: bool = False,
     ) -> WebPBytes | Image.Image | None:
         """Get the image from the JSON data.
@@ -232,13 +232,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                                 disabled_rooms if layer_type == "wall" else None,
                             )
 
-                            # Update element map for this layer
-                            if is_room_layer and 0 < room_id <= 15:
-                                # Mark the room in the element map
-                                room_element = getattr(
-                                    DrawableElement, f"ROOM_{room_id}", None
-                                )
-
                     # Draw the virtual walls if enabled
                     if self.drawing_config.is_enabled(DrawableElement.VIRTUAL_WALL):
                         img_np_array = await self.imd.async_draw_virtual_walls(
@@ -313,10 +306,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                     LOGGER.info("%s: Drawing path", self.file_name)
                     data_tasks.append(self._prepare_path_data(m_json))
 
-                # Execute data preparation in parallel if we have tasks
-                if data_tasks:
-                    prepared_data = await AsyncParallel.parallel_data_preparation(*data_tasks)
-
                 # Process drawing operations sequentially (since they modify the same array)
                 # Draw zones if enabled
                 if self.drawing_config.is_enabled(DrawableElement.RESTRICTED_AREA):
@@ -500,7 +489,8 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
         except (ValueError, KeyError):
             return None
 
-    async def _prepare_goto_data(self, entity_dict):
+    @staticmethod
+    async def _prepare_goto_data(entity_dict):
         """Prepare go-to flag data for parallel processing."""
         await asyncio.sleep(0)  # Yield control
         # Extract go-to target data from entity_dict
@@ -510,6 +500,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
         """Prepare path data for parallel processing."""
         await asyncio.sleep(0)  # Yield control
         try:
-            return self.data.find_path_entities(m_json)
+            return self.data.find_paths_entities(m_json)
         except (ValueError, KeyError):
             return None

valetudo_map_parser/rand256_handler.py

@@ -12,8 +12,8 @@ import uuid
 from typing import Any
 
 import numpy as np
-from PIL import Image
 
+from .config.async_utils import AsyncNumPy, AsyncPIL
 from .config.auto_crop import AutoCrop
 from .config.drawable_elements import DrawableElement
 from .config.types import (
@@ -145,7 +145,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
         m_json: JsonType,  # json data
         destinations: None = None,  # MQTT destinations for labels
         return_webp: bool = False,
-    ) -> WebPBytes | Image.Image | None:
+    ) -> WebPBytes | PilPNG | None:
         """Generate Images from the json data.
         @param m_json: The JSON data to use to draw the image.
         @param destinations: MQTT destinations for labels (unused).
@@ -195,8 +195,8 @@ class ReImageHandler(BaseHandler, AutoCrop):
                     del img_np_array  # free memory
                     return webp_bytes
                 else:
-                    # Convert to PIL Image (original behavior)
-                    pil_img = Image.fromarray(img_np_array, mode="RGBA")
+                    # Convert to PIL Image using async utilities
+                    pil_img = await AsyncPIL.async_fromarray(img_np_array, mode="RGBA")
                     del img_np_array  # free memory
                     return await self._finalize_image(pil_img)
 
@@ -297,11 +297,6 @@ class ReImageHandler(BaseHandler, AutoCrop):
                     original_rooms_pos = self.rooms_pos
                     self.rooms_pos = temp_rooms_pos
 
-                    # Perform robot room detection to check active zones
-                    robot_room_result = await self.async_get_robot_in_room(
-                        robot_position[0], robot_position[1], robot_position_angle
-                    )
-
                     # Restore original rooms_pos
                     self.rooms_pos = original_rooms_pos
 
@@ -673,3 +668,9 @@ class ReImageHandler(BaseHandler, AutoCrop):
             property_name=property_name,
             value=value,
         )
+
+    async def async_copy_array(self, original_array):
+        """Copy the array using async utilities."""
+        return await AsyncNumPy.async_copy(original_array)
+
+

{valetudo_map_parser-0.1.9b65.dist-info → valetudo_map_parser-0.1.9b68.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: valetudo-map-parser
-Version: 0.1.9b65
+Version: 0.1.9b68
 Summary: A Python library to parse Valetudo map data returning a PIL Image object.
 License: Apache-2.0
 Author: Sandro Cantarella

{valetudo_map_parser-0.1.9b65.dist-info → valetudo_map_parser-0.1.9b68.dist-info}/RECORD

@@ -9,20 +9,19 @@ valetudo_map_parser/config/drawable_elements.py,sha256=o-5oiXmfqPwNQLzKIhkEcZD_A
 valetudo_map_parser/config/enhanced_drawable.py,sha256=QlGxlUMVgECUXPtFwIslyjubWxQuhIixsRymWV3lEvk,12586
 valetudo_map_parser/config/optimized_element_map.py,sha256=52BCnkvVv9bre52LeVIfT8nhnEIpc0TuWTv1xcNu0Rk,15744
 valetudo_map_parser/config/rand256_parser.py,sha256=LU3y7XvRRQxVen9iwom0dOaDnJJvhZdg97NqOYRZFas,16279
-valetudo_map_parser/config/rand25_parser.py,sha256=kIayyqVZBfQfAMkiArzqrrj9vqZB3pkgT0Y5ufrQmGA,16448
-valetudo_map_parser/config/shared.py,sha256=J_66BuhgqRJUjXKBwKh8qih1iyiTq9ZiaZwduIROYmE,12560
+valetudo_map_parser/config/shared.py,sha256=AQ73878TGCxbHQhgrAxSROLqFE-Zz4fJhTdoi9gBvJo,12736
 valetudo_map_parser/config/types.py,sha256=saL7pULKAdTRQ_ShR2arT8IV472e9MBC_SohTthlGp8,17567
-valetudo_map_parser/config/utils.py,sha256=fnzzNywE0Z1qw968hUa_yGslq3YhOP7daFj21miuhjI,31354
+valetudo_map_parser/config/utils.py,sha256=MR1UIOwHWYJ8lFrPYhfyi9IV7C08S-DqCyIPppsB2tM,33913
 valetudo_map_parser/hypfer_draw.py,sha256=ZK_WybvukHd8nNk2mq5icrOu1Ue3SVCIC6_Hc9bTg0Q,29396
-valetudo_map_parser/hypfer_handler.py,sha256=5RphiGaLFmlaajcmR0RKfkTevEpjXVylD1fn12rmzw4,23733
+valetudo_map_parser/hypfer_handler.py,sha256=f9SCphArA-LO2ySrTKpxn6k4htM-JRrbrxKFh3AjnD8,23171
 valetudo_map_parser/hypfer_rooms_handler.py,sha256=NkpOA6Gdq-2D3lLAxvtNuuWMvPXHxeMY2TO5RZLSHlU,22652
 valetudo_map_parser/map_data.py,sha256=Op0LTCakcTJ1Q0rxQhl6BpgSby_6nJenCQS2Y2FHtRk,17243
 valetudo_map_parser/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-valetudo_map_parser/rand256_handler.py,sha256=8X26-ApkwzfsbuXcdvt-sHWC0ibzjp3VbK0ZRCT77QE,27697
+valetudo_map_parser/rand256_handler.py,sha256=6Qt-xFJ3PITQNSAJTaEo6jl6TdgFms7ay1rnk4vekgk,27653
 valetudo_map_parser/reimg_draw.py,sha256=1q8LkNTPHEA9Tsapc_JnVw51kpPYNhaBU-KmHkefCQY,12507
 valetudo_map_parser/rooms_handler.py,sha256=ovqQtAjauAqwUNPR0aX27P2zhheQmqfaFhDE3_AwYWk,17821
-valetudo_map_parser-0.1.9b65.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
-valetudo_map_parser-0.1.9b65.dist-info/METADATA,sha256=oTnaDNVUpi4QHTCyIkIqSrAY3ATiPdwLjr0U2c-juVc,3353
-valetudo_map_parser-0.1.9b65.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
-valetudo_map_parser-0.1.9b65.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-valetudo_map_parser-0.1.9b65.dist-info/RECORD,,
+valetudo_map_parser-0.1.9b68.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
+valetudo_map_parser-0.1.9b68.dist-info/METADATA,sha256=hBV8Inc5QpIw-TcGWC-sLqhRb60TlFq1OVkMmm1iBek,3353
+valetudo_map_parser-0.1.9b68.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
+valetudo_map_parser-0.1.9b68.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+valetudo_map_parser-0.1.9b68.dist-info/RECORD,,

valetudo_map_parser/config/rand25_parser.py

@@ -1,412 +0,0 @@
-"""
-Version: v2024.08.2
-- This parser is the python version of @rand256 valetudo_mapper.
-- This class is extracting the vacuum binary map_data.
-- Additional functions are to get in our image_handler the images datas.
-"""
-
-import math
-import struct
-from enum import Enum
-from typing import Any, Callable, Dict, List, Optional, TypeVar
-
-
-_CallableT = TypeVar("_CallableT", bound=Callable[..., Any])
-
-
-def callback(func: _CallableT) -> _CallableT:
-    """Annotation to mark method as safe to call from within the event loop."""
-    setattr(func, "_hass_callback", True)  # Attach a custom attribute to the function
-    return func  # Return the function without modifying its behavior
-
-
-# noinspection PyTypeChecker
-class RRMapParser:
-    """Parse the map data from the Rand256 vacuum."""
-
-    def __init__(self):
-        self.map_data = None
-
-    class Tools:
-        """Tools for the RRMapParser."""
-
-        DIMENSION_PIXELS = 1024
-        DIMENSION_MM = 50 * 1024
-
-    class Types(Enum):
-        """Types of blocks in the RRMapParser."""
-
-        CHARGER_LOCATION = 1
-        IMAGE = 2
-        PATH = 3
-        GOTO_PATH = 4
-        GOTO_PREDICTED_PATH = 5
-        CURRENTLY_CLEANED_ZONES = 6
-        GOTO_TARGET = 7
-        ROBOT_POSITION = 8
-        FORBIDDEN_ZONES = 9
-        VIRTUAL_WALLS = 10
-        CURRENTLY_CLEANED_BLOCKS = 11
-        FORBIDDEN_MOP_ZONES = 12
-        DIGEST = 1024
-
-    @staticmethod
-    def parse_block(
-        buf: bytes,
-        offset: int,
-        result: Optional[Dict[int, Any]] = None,
-        pixels: bool = False,
-    ) -> Dict[int, Any]:
-        """Parse a block of data from the map data."""
-        result = result or {}
-        if len(buf) <= offset:
-            return result
-
-        type_ = struct.unpack("<H", buf[offset : offset + 2])[0]
-        hlength = struct.unpack("<H", buf[offset + 2 : offset + 4])[0]
-        length = struct.unpack("<I", buf[offset + 4 : offset + 8])[0]
-
-        if type_ in (
-            RRMapParser.Types.ROBOT_POSITION.value,
-            RRMapParser.Types.CHARGER_LOCATION.value,
-        ):
-            result[type_] = {
-                "position": [
-                    int.from_bytes(buf[offset + 8 : offset + 10], byteorder="little"),
-                    int.from_bytes(buf[offset + 12 : offset + 14], byteorder="little"),
-                ],
-                "angle": (
-                    struct.unpack("<i", buf[offset + 16 : offset + 20])[0]
-                    if length >= 12
-                    else 0
-                ),
-            }
-        elif type_ == RRMapParser.Types.IMAGE.value:
-            RRMapParser._parse_image_block(buf, offset, length, hlength, result, pixels)
-        elif type_ in (
-            RRMapParser.Types.PATH.value,
-            RRMapParser.Types.GOTO_PATH.value,
-            RRMapParser.Types.GOTO_PREDICTED_PATH.value,
-        ):
-            result[type_] = RRMapParser._parse_path_block(buf, offset, length)
-        elif type_ == RRMapParser.Types.GOTO_TARGET.value:
-            result[type_] = {
-                "position": [
-                    struct.unpack("<H", buf[offset + 8 : offset + 10])[0],
-                    struct.unpack("<H", buf[offset + 10 : offset + 12])[0],
-                ]
-            }
-        elif type_ == RRMapParser.Types.CURRENTLY_CLEANED_ZONES.value:
-            result[type_] = RRMapParser._parse_cleaned_zones(buf, offset, length)
-        elif type_ in (
-            RRMapParser.Types.FORBIDDEN_ZONES.value,
-            RRMapParser.Types.FORBIDDEN_MOP_ZONES.value,
-            RRMapParser.Types.VIRTUAL_WALLS.value,
-        ):
-            result[type_] = RRMapParser._parse_forbidden_zones(buf, offset, length)
-        return RRMapParser.parse_block(buf, offset + length + hlength, result, pixels)
-
-    @staticmethod
-    def _parse_image_block(
-        buf: bytes,
-        offset: int,
-        length: int,
-        hlength: int,
-        result: Dict[int, Any],
-        pixels: bool,
-    ) -> None:
-        """Parse the image block of the map data."""
-        g3offset = 4 if hlength > 24 else 0
-        parameters = {
-            "segments": {
-                "count": (
-                    struct.unpack("<i", buf[offset + 8 : offset + 12])[0]
-                    if g3offset
-                    else 0
-                ),
-                "id": [],
-            },
-            "position": {
-                "top": struct.unpack(
-                    "<i", buf[offset + 8 + g3offset : offset + 12 + g3offset]
-                )[0],
-                "left": struct.unpack(
-                    "<i", buf[offset + 12 + g3offset : offset + 16 + g3offset]
-                )[0],
-            },
-            "dimensions": {
-                "height": struct.unpack(
-                    "<i", buf[offset + 16 + g3offset : offset + 20 + g3offset]
-                )[0],
-                "width": struct.unpack(
-                    "<i", buf[offset + 20 + g3offset : offset + 24 + g3offset]
-                )[0],
-            },
-            "pixels": {"floor": [], "walls": [], "segments": {}},
-        }
-        parameters["position"]["top"] = (
-            RRMapParser.Tools.DIMENSION_PIXELS
-            - parameters["position"]["top"]
-            - parameters["dimensions"]["height"]
-        )
-        if (
-            parameters["dimensions"]["height"] > 0
-            and parameters["dimensions"]["width"] > 0
-        ):
-            for i in range(length):
-                segment_type = (
-                    struct.unpack(
-                        "<B",
-                        buf[offset + 24 + g3offset + i : offset + 25 + g3offset + i],
-                    )[0]
-                    & 0x07
-                )
-                if segment_type == 0:
-                    continue
-                if segment_type == 1 and pixels:
-                    parameters["pixels"]["walls"].append(i)
-                else:
-                    s = (
-                        struct.unpack(
-                            "<B",
-                            buf[
-                                offset + 24 + g3offset + i : offset + 25 + g3offset + i
-                            ],
-                        )[0]
-                        >> 3
-                    )
-                    if s == 0 and pixels:
-                        parameters["pixels"]["floor"].append(i)
-                    elif s != 0:
-                        if s not in parameters["segments"]["id"]:
-                            parameters["segments"]["id"].append(s)
-                            parameters["segments"]["pixels_seg_" + str(s)] = []
-                        if pixels:
-                            parameters["segments"]["pixels_seg_" + str(s)].append(i)
-        result[RRMapParser.Types.IMAGE.value] = parameters
-
-    @staticmethod
-    def _parse_path_block(buf: bytes, offset: int, length: int) -> Dict[str, Any]:
-        """Parse a path block of the map data."""
-        points = [
-            [
-                struct.unpack("<H", buf[offset + 20 + i : offset + 22 + i])[0],
-                struct.unpack("<H", buf[offset + 22 + i : offset + 24 + i])[0],
-            ]
-            for i in range(0, length, 4)
-        ]
-        return {
-            "current_angle": struct.unpack("<I", buf[offset + 16 : offset + 20])[0],
-            "points": points,
-        }
-
-    @staticmethod
-    def _parse_cleaned_zones(buf: bytes, offset: int, length: int) -> List[List[int]]:
-        """Parse the cleaned zones block of the map data."""
-        zone_count = struct.unpack("<I", buf[offset + 8 : offset + 12])[0]
-        return (
-            [
-                [
-                    struct.unpack("<H", buf[offset + 12 + i : offset + 14 + i])[0],
-                    struct.unpack("<H", buf[offset + 14 + i : offset + 16 + i])[0],
-                    struct.unpack("<H", buf[offset + 16 + i : offset + 18 + i])[0],
-                    struct.unpack("<H", buf[offset + 18 + i : offset + 20 + i])[0],
-                ]
-                for i in range(0, length, 8)
-            ]
-            if zone_count > 0
-            else []
-        )
-
-    @staticmethod
-    def _parse_forbidden_zones(buf: bytes, offset: int, length: int) -> List[List[int]]:
-        """Parse the forbidden zones block of the map data."""
-        zone_count = struct.unpack("<I", buf[offset + 8 : offset + 12])[0]
-        return (
-            [
-                [
-                    struct.unpack("<H", buf[offset + 12 + i : offset + 14 + i])[0],
-                    struct.unpack("<H", buf[offset + 14 + i : offset + 16 + i])[0],
-                    struct.unpack("<H", buf[offset + 16 + i : offset + 18 + i])[0],
-                    struct.unpack("<H", buf[offset + 18 + i : offset + 20 + i])[0],
-                    struct.unpack("<H", buf[offset + 20 + i : offset + 22 + i])[0],
-                    struct.unpack("<H", buf[offset + 22 + i : offset + 24 + i])[0],
-                    struct.unpack("<H", buf[offset + 24 + i : offset + 26 + i])[0],
-                    struct.unpack("<H", buf[offset + 26 + i : offset + 28 + i])[0],
-                ]
-                for i in range(0, length, 16)
-            ]
-            if zone_count > 0
-            else []
-        )
-
-    @callback
-    def parse(self, map_buf: bytes) -> Dict[str, Any]:
-        """Parse the map data."""
-        if map_buf[0:2] == b"rr":
-            return {
-                "header_length": struct.unpack("<H", map_buf[2:4])[0],
-                "data_length": struct.unpack("<H", map_buf[4:6])[0],
-                "version": {
-                    "major": struct.unpack("<H", map_buf[8:10])[0],
-                    "minor": struct.unpack("<H", map_buf[10:12])[0],
-                },
-                "map_index": struct.unpack("<H", map_buf[12:14])[0],
-                "map_sequence": struct.unpack("<H", map_buf[16:18])[0],
-            }
-        return {}
-
-    @callback
-    def parse_rrm_data(
-        self, map_buf: bytes, pixels: bool = False
-    ) -> Optional[Dict[str, Any]]:
-        """Parse the complete map data."""
-        if not self.parse(map_buf).get("map_index"):
-            return None
-
-        parsed_map_data = {}
-        blocks = self.parse_block(map_buf, 0x14, None, pixels)
-
-        self._parse_image_data(parsed_map_data, blocks)
-        self._parse_charger_data(parsed_map_data, blocks)
-        self._parse_robot_data(parsed_map_data, blocks)
-        self._parse_zones_data(parsed_map_data, blocks)
-        self._parse_virtual_walls_data(parsed_map_data, blocks)
-        self._parse_misc_data(parsed_map_data, blocks)
-
-        return parsed_map_data
-
-    @staticmethod
-    def _parse_image_data(parsed_map_data: Dict[str, Any], blocks: Dict[int, Any]):
-        """Parse image-related data."""
-        if RRMapParser.Types.IMAGE.value in blocks:
-            parsed_map_data["image"] = blocks[RRMapParser.Types.IMAGE.value]
-            for item in [
-                {"type": RRMapParser.Types.PATH.value, "path": "path"},
-                {
-                    "type": RRMapParser.Types.GOTO_PREDICTED_PATH.value,
-                    "path": "goto_predicted_path",
-                },
-            ]:
-                if item["type"] in blocks:
-                    parsed_map_data[item["path"]] = blocks[item["type"]]
-                    parsed_map_data[item["path"]]["points"] = [
-                        [point[0], RRMapParser.Tools.DIMENSION_MM - point[1]]
-                        for point in parsed_map_data[item["path"]]["points"]
-                    ]
-                    if len(parsed_map_data[item["path"]]["points"]) >= 2:
-                        parsed_map_data[item["path"]]["current_angle"] = math.degrees(
-                            math.atan2(
-                                parsed_map_data[item["path"]]["points"][-1][1]
-                                - parsed_map_data[item["path"]]["points"][-2][1],
-                                parsed_map_data[item["path"]]["points"][-1][0]
-                                - parsed_map_data[item["path"]]["points"][-2][0],
-                            )
-                        )
-
-    @staticmethod
-    def _parse_charger_data(parsed_map_data: Dict[str, Any], blocks: Dict[int, Any]):
-        """Parse charger location data."""
-        if RRMapParser.Types.CHARGER_LOCATION.value in blocks:
-            charger = blocks[RRMapParser.Types.CHARGER_LOCATION.value]["position"]
-            parsed_map_data["charger"] = charger
-
-    @staticmethod
-    def _parse_robot_data(parsed_map_data: Dict[str, Any], blocks: Dict[int, Any]):
-        """Parse robot position data."""
-        if RRMapParser.Types.ROBOT_POSITION.value in blocks:
-            robot = blocks[RRMapParser.Types.ROBOT_POSITION.value]["position"]
-            rob_angle = blocks[RRMapParser.Types.ROBOT_POSITION.value]["angle"]
-            parsed_map_data["robot"] = robot
-            parsed_map_data["robot_angle"] = rob_angle
-
-    @staticmethod
-    def _parse_zones_data(parsed_map_data: Dict[str, Any], blocks: Dict[int, Any]):
-        """Parse zones and forbidden zones data."""
-        if RRMapParser.Types.CURRENTLY_CLEANED_ZONES.value in blocks:
-            parsed_map_data["currently_cleaned_zones"] = [
-                [
-                    zone[0],
-                    RRMapParser.Tools.DIMENSION_MM - zone[1],
-                    zone[2],
-                    RRMapParser.Tools.DIMENSION_MM - zone[3],
-                ]
-                for zone in blocks[RRMapParser.Types.CURRENTLY_CLEANED_ZONES.value]
-            ]
-
-        if RRMapParser.Types.FORBIDDEN_ZONES.value in blocks:
-            parsed_map_data["forbidden_zones"] = [
-                [
-                    zone[0],
-                    RRMapParser.Tools.DIMENSION_MM - zone[1],
-                    zone[2],
-                    RRMapParser.Tools.DIMENSION_MM - zone[3],
-                    zone[4],
-                    RRMapParser.Tools.DIMENSION_MM - zone[5],
-                    zone[6],
-                    RRMapParser.Tools.DIMENSION_MM - zone[7],
-                ]
-                for zone in blocks[RRMapParser.Types.FORBIDDEN_ZONES.value]
-            ]
-
-    @staticmethod
-    def _parse_virtual_walls_data(
-        parsed_map_data: Dict[str, Any], blocks: Dict[int, Any]
-    ):
-        """Parse virtual walls data."""
-        if RRMapParser.Types.VIRTUAL_WALLS.value in blocks:
-            parsed_map_data["virtual_walls"] = [
-                [
-                    wall[0],
-                    RRMapParser.Tools.DIMENSION_MM - wall[1],
-                    wall[2],
-                    RRMapParser.Tools.DIMENSION_MM - wall[3],
-                ]
-                for wall in blocks[RRMapParser.Types.VIRTUAL_WALLS.value]
-            ]
-
-    @staticmethod
-    def _parse_misc_data(parsed_map_data: Dict[str, Any], blocks: Dict[int, Any]):
-        """Parse miscellaneous data like cleaned blocks and mop zones."""
-        if RRMapParser.Types.CURRENTLY_CLEANED_BLOCKS.value in blocks:
-            parsed_map_data["currently_cleaned_blocks"] = blocks[
-                RRMapParser.Types.CURRENTLY_CLEANED_BLOCKS.value
-            ]
-
-        if RRMapParser.Types.FORBIDDEN_MOP_ZONES.value in blocks:
-            parsed_map_data["forbidden_mop_zones"] = [
-                [
-                    zone[0],
-                    RRMapParser.Tools.DIMENSION_MM - zone[1],
-                    zone[2],
-                    RRMapParser.Tools.DIMENSION_MM - zone[3],
-                    zone[4],
-                    RRMapParser.Tools.DIMENSION_MM - zone[5],
-                    zone[6],
-                    RRMapParser.Tools.DIMENSION_MM - zone[7],
-                ]
-                for zone in blocks[RRMapParser.Types.FORBIDDEN_MOP_ZONES.value]
-            ]
-
-        if RRMapParser.Types.GOTO_TARGET.value in blocks:
-            parsed_map_data["goto_target"] = blocks[
-                RRMapParser.Types.GOTO_TARGET.value
-            ]["position"]
-
-    def parse_data(
-        self, payload: Optional[bytes] = None, pixels: bool = False
-    ) -> Optional[Dict[str, Any]]:
-        """Get the map data from MQTT and return the json."""
-        if payload:
-            self.map_data = self.parse(payload)
-            self.map_data.update(self.parse_rrm_data(payload, pixels) or {})
-        return self.map_data
-
-    def get_image(self) -> Dict[str, Any]:
-        """Get the image data from the map data."""
-        return self.map_data.get("image", {})
-
-    @staticmethod
-    def get_int32(data: bytes, address: int) -> int:
-        """Get a 32-bit integer from the data."""
-        return struct.unpack_from("<i", data, address)[0]