valetudo-map-parser 0.1.9b64__tar.gz → 0.1.9b67__tar.gz

{valetudo_map_parser-0.1.9b64 → valetudo_map_parser-0.1.9b67}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: valetudo-map-parser
-Version: 0.1.9b64
+Version: 0.1.9b67
 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.9b64 → valetudo_map_parser-0.1.9b67}/SCR/valetudo_map_parser/config/async_utils.py

@@ -11,10 +11,7 @@ from PIL import Image
 
 async def make_async(func: Callable, *args, **kwargs) -> Any:
     """Convert a synchronous function to async by yielding control to the event loop."""
-    await asyncio.sleep(0)
-    result = func(*args, **kwargs)
-    await asyncio.sleep(0)
-    return result
+    return await asyncio.to_thread(func, *args, **kwargs)
 
 
 class AsyncNumPy:

{valetudo_map_parser-0.1.9b64 → valetudo_map_parser-0.1.9b67}/SCR/valetudo_map_parser/config/drawable.py

@@ -14,6 +14,7 @@ import logging
 import math
 import asyncio
 import inspect
+import threading
 
 import numpy as np
 from PIL import ImageDraw, ImageFont
@@ -26,6 +27,72 @@ from .types import Color, NumpyArray, PilPNG, Point, Tuple, Union
 _LOGGER = logging.getLogger(__name__)
 
 
+class ImageArrayPool:
+    """Thread-safe memory pool for reusing image arrays to reduce allocation overhead."""
+
+    def __init__(self, max_arrays_per_size: int = 3):
+        self._pools = {}  # {(width, height): [array1, array2, ...]}
+        self._lock = threading.Lock()
+        self._max_arrays_per_size = max_arrays_per_size
+
+    def get_array(self, width: int, height: int, background_color: Color) -> NumpyArray:
+        """Get a reusable array or create a new one if none available."""
+        key = (width, height)
+
+        with self._lock:
+            if key in self._pools and self._pools[key]:
+                # Reuse existing array
+                array = self._pools[key].pop()
+                _LOGGER.debug("Reused array from pool for size %dx%d", width, height)
+            else:
+                # Create new array
+                array = np.empty((height, width, 4), dtype=np.uint8)
+                _LOGGER.debug("Created new array for size %dx%d", width, height)
+
+        # Fill with background color (outside lock for better performance)
+        array[:] = background_color
+        return array
+
+    def return_array(self, array: NumpyArray) -> None:
+        """Return an array to the pool for reuse."""
+        if array is None:
+            return
+
+        height, width = array.shape[:2]
+        key = (width, height)
+
+        with self._lock:
+            if key not in self._pools:
+                self._pools[key] = []
+
+            # Only keep up to max_arrays_per_size arrays per size
+            if len(self._pools[key]) < self._max_arrays_per_size:
+                self._pools[key].append(array)
+                _LOGGER.debug("Returned array to pool for size %dx%d (pool size: %d)",
+                             width, height, len(self._pools[key]))
+            else:
+                _LOGGER.debug("Pool full for size %dx%d, discarding array", width, height)
+
+    def clear_pool(self) -> None:
+        """Clear all arrays from the pool."""
+        with self._lock:
+            total_arrays = sum(len(arrays) for arrays in self._pools.values())
+            self._pools.clear()
+            _LOGGER.debug("Cleared image array pool (%d arrays freed)", total_arrays)
+
+    def get_pool_stats(self) -> dict:
+        """Get statistics about the current pool state."""
+        with self._lock:
+            stats = {}
+            for (width, height), arrays in self._pools.items():
+                stats[f"{width}x{height}"] = len(arrays)
+            return stats
+
+
+# Global shared pool instance for both Hypfer and Rand256 handlers
+_image_pool = ImageArrayPool()
+
+
 class Drawable:
     """
     Collection of drawing utility functions for the image handlers.
@@ -45,13 +112,27 @@ class Drawable:
     async def create_empty_image(
         width: int, height: int, background_color: Color
     ) -> NumpyArray:
-        """Create the empty background image NumPy array.
+        """Create the empty background image NumPy array using memory pool for better performance.
         Background color is specified as an RGBA tuple.
-        Optimized: Uses np.empty + broadcast instead of np.full for better performance."""
-        # Use np.empty + broadcast instead of np.full (avoids double initialization)
-        img_array = np.empty((height, width, 4), dtype=np.uint8)
-        img_array[:] = background_color  # Broadcast color to all pixels efficiently
-        return img_array
+        Optimized: Uses shared memory pool to reuse arrays and reduce allocation overhead."""
+        # Get array from shared pool (reuses memory when possible)
+        return _image_pool.get_array(width, height, background_color)
+
+    @staticmethod
+    def return_image_to_pool(image_array: NumpyArray) -> None:
+        """Return an image array to the memory pool for reuse.
+        Call this when you're done with an image array to enable memory reuse."""
+        _image_pool.return_array(image_array)
+
+    @staticmethod
+    def get_pool_stats() -> dict:
+        """Get statistics about the current memory pool state."""
+        return _image_pool.get_pool_stats()
+
+    @staticmethod
+    def clear_image_pool() -> None:
+        """Clear all arrays from the memory pool."""
+        _image_pool.clear_pool()
 
     @staticmethod
     async def from_json_to_image(

{valetudo_map_parser-0.1.9b64 → valetudo_map_parser-0.1.9b67}/SCR/valetudo_map_parser/hypfer_handler.py

@@ -390,7 +390,9 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
             if self.check_zoom_and_aspect_ratio():
                 # Convert to PIL for resizing
                 pil_img = await AsyncPIL.async_fromarray(img_np_array, mode="RGBA")
-                del img_np_array
+                # Return array to pool for reuse instead of just deleting
+                from .config.drawable import Drawable
+                Drawable.return_image_to_pool(img_np_array)
                 resize_params = prepare_resize_params(self, pil_img, False)
                 resized_image = await self.async_resize_images(resize_params)
 
@@ -405,13 +407,17 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                 if return_webp:
                     # Convert directly from NumPy to WebP for better performance
                     webp_bytes = await numpy_to_webp_bytes(img_np_array)
-                    del img_np_array
+                    # Return array to pool for reuse instead of just deleting
+                    from .config.drawable import Drawable
+                    Drawable.return_image_to_pool(img_np_array)
                     LOGGER.debug("%s: Frame Completed.", self.file_name)
                     return webp_bytes
                 else:
                     # Convert to PIL Image (original behavior)
                     pil_img = await AsyncPIL.async_fromarray(img_np_array, mode="RGBA")
-                    del img_np_array
+                    # Return array to pool for reuse instead of just deleting
+                    from .config.drawable import Drawable
+                    Drawable.return_image_to_pool(img_np_array)
                     LOGGER.debug("%s: Frame Completed.", self.file_name)
                     return pil_img
         except (RuntimeError, RuntimeWarning) as e:

{valetudo_map_parser-0.1.9b64 → valetudo_map_parser-0.1.9b67}/SCR/valetudo_map_parser/rand256_handler.py

@@ -7,6 +7,7 @@ Version: 0.1.9.a6
 
 from __future__ import annotations
 
+import asyncio
 import logging
 import uuid
 from typing import Any
@@ -14,6 +15,7 @@ from typing import Any
 import numpy as np
 from PIL import Image
 
+from .config.async_utils import AsyncNumPy, AsyncPIL, AsyncParallel
 from .config.auto_crop import AutoCrop
 from .config.drawable_elements import DrawableElement
 from .config.types import (
@@ -166,6 +168,14 @@ class ReImageHandler(BaseHandler, AutoCrop):
                 self.json_id = str(uuid.uuid4())  # image id
                 _LOGGER.info("Vacuum Data ID: %s", self.json_id)
 
+                # Prepare parallel data extraction tasks
+                data_tasks = []
+                data_tasks.append(self._prepare_zone_data(m_json))
+                data_tasks.append(self._prepare_path_data(m_json))
+
+                # Execute data preparation tasks in parallel
+                zone_data, path_data = await asyncio.gather(*data_tasks, return_exceptions=True)
+
                 (
                     img_np_array,
                     robot_position,
@@ -192,12 +202,16 @@ class ReImageHandler(BaseHandler, AutoCrop):
                 if return_webp:
                     # Convert directly to WebP bytes for better performance
                     webp_bytes = await numpy_to_webp_bytes(img_np_array)
-                    del img_np_array  # free memory
+                    # Return array to pool for reuse instead of just deleting
+                    from .config.drawable import Drawable
+                    Drawable.return_image_to_pool(img_np_array)
                     return webp_bytes
                 else:
-                    # Convert to PIL Image (original behavior)
-                    pil_img = Image.fromarray(img_np_array, mode="RGBA")
-                    del img_np_array  # free memory
+                    # Convert to PIL Image using async utilities
+                    pil_img = await AsyncPIL.async_fromarray(img_np_array, mode="RGBA")
+                    # Return array to pool for reuse instead of just deleting
+                    from .config.drawable import Drawable
+                    Drawable.return_image_to_pool(img_np_array)
                     return await self._finalize_image(pil_img)
 
         except (RuntimeError, RuntimeWarning) as e:
@@ -673,3 +687,25 @@ 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)
+
+    async def _prepare_zone_data(self, m_json):
+        """Prepare zone data for parallel processing."""
+        await asyncio.sleep(0)  # Yield control
+        try:
+            return self.data.find_zone_entities(m_json)
+        except (ValueError, KeyError):
+            return None
+
+    async def _prepare_path_data(self, m_json):
+        """Prepare path data for parallel processing."""
+        await asyncio.sleep(0)  # Yield control
+        try:
+            return self.data.find_path_entities(m_json)
+        except (ValueError, KeyError):
+            return None
+
+

{valetudo_map_parser-0.1.9b64 → valetudo_map_parser-0.1.9b67}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "valetudo-map-parser"
-version = "0.1.9b64"
+version = "0.1.9b67"
 description = "A Python library to parse Valetudo map data returning a PIL Image object."
 authors = ["Sandro Cantarella <gsca075@gmail.com>"]
 license = "Apache-2.0"

valetudo_map_parser-0.1.9b64/SCR/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]