valetudo-map-parser 0.1.9b68__tar.gz → 0.1.9b70__tar.gz

{valetudo_map_parser-0.1.9b68 → valetudo_map_parser-0.1.9b70}/PKG-INFO

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

@@ -23,7 +23,9 @@ class AsyncNumPy:
         return await make_async(np.copy, array)
 
     @staticmethod
-    async def async_full(shape: tuple, fill_value: Any, dtype: np.dtype = None) -> np.ndarray:
+    async def async_full(
+        shape: tuple, fill_value: Any, dtype: np.dtype = None
+    ) -> np.ndarray:
         """Async array creation with fill value."""
         return await make_async(np.full, shape, fill_value, dtype=dtype)
 
@@ -42,20 +44,25 @@ class AsyncPIL:
         return await make_async(Image.fromarray, array, mode)
 
     @staticmethod
-    async def async_resize(image: Image.Image, size: tuple, resample: int = None) -> Image.Image:
+    async def async_resize(
+        image: Image.Image, size: tuple, resample: int = None
+    ) -> Image.Image:
         """Async image resizing."""
         if resample is None:
             resample = Image.LANCZOS
         return await make_async(image.resize, size, resample)
 
     @staticmethod
-    async def async_save_to_bytes(image: Image.Image, format_type: str = "WEBP", **kwargs) -> bytes:
+    async def async_save_to_bytes(
+        image: Image.Image, format_type: str = "WEBP", **kwargs
+    ) -> bytes:
         """Async image saving to bytes."""
+
         def save_to_bytes():
             buffer = io.BytesIO()
             image.save(buffer, format=format_type, **kwargs)
             return buffer.getvalue()
-        
+
         return await make_async(save_to_bytes)
 
 

{valetudo_map_parser-0.1.9b68 → valetudo_map_parser-0.1.9b70}/SCR/valetudo_map_parser/config/drawable.py

@@ -12,8 +12,6 @@ from __future__ import annotations
 
 import logging
 import math
-import asyncio
-import inspect
 
 import numpy as np
 from PIL import ImageDraw, ImageFont
@@ -46,12 +44,8 @@ class Drawable:
         width: int, height: int, background_color: Color
     ) -> NumpyArray:
         """Create the empty background image NumPy array.
-        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
+        Background color is specified as an RGBA tuple."""
+        return np.full((height, width, 4), background_color, dtype=np.uint8)
 
     @staticmethod
     async def from_json_to_image(
@@ -158,8 +152,6 @@ class Drawable:
         It uses the rotation angle of the image to orient the flag.
         Includes color blending for better visual integration.
         """
-        await asyncio.sleep(0)  # Yield control
-
         # Check if coordinates are within bounds
         height, width = layer.shape[:2]
         x, y = center
@@ -331,12 +323,7 @@ class Drawable:
         Join the coordinates creating a continuous line (path).
         Optimized with vectorized operations for better performance.
         """
-
-        # Handle case where arr might be a coroutine (shouldn't happen but let's be safe)
-        if inspect.iscoroutine(arr):
-            arr = await arr
-
-        for i, coord in enumerate(coords):
+        for coord in coords:
             x0, y0 = coord[0]
             try:
                 x1, y1 = coord[1]
@@ -353,10 +340,6 @@ class Drawable:
             # Use the optimized line drawing method
             arr = Drawable._line(arr, x0, y0, x1, y1, blended_color, width)
 
-            # Yield control every 100 operations to prevent blocking
-            if i % 100 == 0:
-                await asyncio.sleep(0)
-
         return arr
 
     @staticmethod
@@ -501,120 +484,56 @@ class Drawable:
     async def zones(layers: NumpyArray, coordinates, color: Color) -> NumpyArray:
         """
         Draw the zones on the input layer with color blending.
-        Optimized with parallel processing for better performance.
+        Optimized with NumPy vectorized operations for better performance.
         """
-        await asyncio.sleep(0)  # Yield control
-
         dot_radius = 1  # Number of pixels for the dot
         dot_spacing = 4  # Space between dots
 
-        # Process zones in parallel if there are multiple zones
-        if len(coordinates) > 1:
-            # Create tasks for parallel zone processing
-            zone_tasks = []
-            for zone in coordinates:
-                zone_tasks.append(Drawable._process_single_zone(layers.copy(), zone, color, dot_radius, dot_spacing))
-
-            # Execute all zone processing tasks in parallel
-            zone_results = await asyncio.gather(*zone_tasks, return_exceptions=True)
-
-            # Merge results back into the main layer
-            for result in zone_results:
-                if not isinstance(result, Exception):
-                    # Simple overlay - pixels that are different from original get updated
-                    mask = result != layers
-                    layers[mask] = result[mask]
-        else:
-            # Single zone - process directly
-            for zone in coordinates:
-                points = zone["points"]
-                min_x = max(0, min(points[::2]))
-                max_x = min(layers.shape[1] - 1, max(points[::2]))
-                min_y = max(0, min(points[1::2]))
-                max_y = min(layers.shape[0] - 1, max(points[1::2]))
-
-                # Skip if zone is outside the image
-                if min_x >= max_x or min_y >= max_y:
-                    continue
-
-                # Sample a point from the zone to get the background color
-                # Use the center of the zone for sampling
-                sample_x = (min_x + max_x) // 2
-                sample_y = (min_y + max_y) // 2
-
-                # Blend the color with the background color at the sample point
-                if 0 <= sample_y < layers.shape[0] and 0 <= sample_x < layers.shape[1]:
-                    blended_color = ColorsManagement.sample_and_blend_color(
-                        layers, sample_x, sample_y, color
-                    )
-                else:
-                    blended_color = color
-
-                # Create a grid of dot centers
-                x_centers = np.arange(min_x, max_x, dot_spacing)
-                y_centers = np.arange(min_y, max_y, dot_spacing)
-
-                # Draw dots at each grid point
-                for y in y_centers:
-                    for x in x_centers:
-                        # Create a small mask for the dot
-                        y_min = max(0, y - dot_radius)
-                        y_max = min(layers.shape[0], y + dot_radius + 1)
-                        x_min = max(0, x - dot_radius)
-                        x_max = min(layers.shape[1], x + dot_radius + 1)
+        for zone in coordinates:
+            points = zone["points"]
+            min_x = max(0, min(points[::2]))
+            max_x = min(layers.shape[1] - 1, max(points[::2]))
+            min_y = max(0, min(points[1::2]))
+            max_y = min(layers.shape[0] - 1, max(points[1::2]))
 
-                        # Create coordinate arrays for the dot
-                        y_indices, x_indices = np.ogrid[y_min:y_max, x_min:x_max]
-
-                        # Create a circular mask
-                        mask = (y_indices - y) ** 2 + (x_indices - x) ** 2 <= dot_radius**2
-
-                        # Apply the color to the masked region
-                        layers[y_min:y_max, x_min:x_max][mask] = blended_color
-
-        return layers
+            # Skip if zone is outside the image
+            if min_x >= max_x or min_y >= max_y:
+                continue
 
-    @staticmethod
-    async def _process_single_zone(layers: NumpyArray, zone, color: Color, dot_radius: int, dot_spacing: int) -> NumpyArray:
-        """Process a single zone for parallel execution."""
-        await asyncio.sleep(0)  # Yield control
-
-        points = zone["points"]
-        min_x = max(0, min(points[::2]))
-        max_x = min(layers.shape[1] - 1, max(points[::2]))
-        min_y = max(0, min(points[1::2]))
-        max_y = min(layers.shape[0] - 1, max(points[1::2]))
-
-        # Skip if zone is outside the image
-        if min_x >= max_x or min_y >= max_y:
-            return layers
+            # Sample a point from the zone to get the background color
+            # Use the center of the zone for sampling
+            sample_x = (min_x + max_x) // 2
+            sample_y = (min_y + max_y) // 2
 
-        # Sample a point from the zone to get the background color
-        sample_x = (min_x + max_x) // 2
-        sample_y = (min_y + max_y) // 2
+            # Blend the color with the background color at the sample point
+            if 0 <= sample_y < layers.shape[0] and 0 <= sample_x < layers.shape[1]:
+                blended_color = ColorsManagement.sample_and_blend_color(
+                    layers, sample_x, sample_y, color
+                )
+            else:
+                blended_color = color
 
-        # Blend the color with the background color at the sample point
-        if 0 <= sample_y < layers.shape[0] and 0 <= sample_x < layers.shape[1]:
-            blended_color = ColorsManagement.sample_and_blend_color(
-                layers, sample_x, sample_y, color
-            )
-        else:
-            blended_color = color
+            # Create a grid of dot centers
+            x_centers = np.arange(min_x, max_x, dot_spacing)
+            y_centers = np.arange(min_y, max_y, dot_spacing)
 
-        # Create a dotted pattern within the zone
-        for y in range(min_y, max_y + 1, dot_spacing):
-            for x in range(min_x, max_x + 1, dot_spacing):
-                if Drawable.point_inside(x, y, points):
-                    # Draw a small filled circle (dot) using vectorized operations
+            # Draw dots at each grid point
+            for y in y_centers:
+                for x in x_centers:
+                    # Create a small mask for the dot
                     y_min = max(0, y - dot_radius)
                     y_max = min(layers.shape[0], y + dot_radius + 1)
                     x_min = max(0, x - dot_radius)
                     x_max = min(layers.shape[1], x + dot_radius + 1)
 
-                    if y_min < y_max and x_min < x_max:
-                        y_indices, x_indices = np.ogrid[y_min:y_max, x_min:x_max]
-                        mask = (y_indices - y) ** 2 + (x_indices - x) ** 2 <= dot_radius**2
-                        layers[y_min:y_max, x_min:x_max][mask] = blended_color
+                    # Create coordinate arrays for the dot
+                    y_indices, x_indices = np.ogrid[y_min:y_max, x_min:x_max]
+
+                    # Create a circular mask
+                    mask = (y_indices - y) ** 2 + (x_indices - x) ** 2 <= dot_radius**2
+
+                    # Apply the color to the masked region
+                    layers[y_min:y_max, x_min:x_max][mask] = blended_color
 
         return layers
 

{valetudo_map_parser-0.1.9b68 → valetudo_map_parser-0.1.9b70}/SCR/valetudo_map_parser/config/shared.py

@@ -1,12 +1,13 @@
 """
 Class Camera Shared.
 Keep the data between the modules.
-Version: v2024.12.0
+Version: v0.1.9
 """
 
 import asyncio
 import logging
 from typing import List
+from PIL import Image
 
 from .types import (
     ATTR_CALIBRATION_POINTS,
@@ -59,7 +60,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 = PilPNG | None  # Last image received
+        # Initialize last_image with default gray image (250x150 minimum)
+        self.last_image = Image.new(
+            "RGBA", (250, 150), (128, 128, 128, 255)
+        )  # Gray default image
         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
@@ -115,8 +119,6 @@ class CameraShared:
         self.skip_room_ids: List[str] = []
         self.device_info = None  # Store the device_info
 
-
-
     def vacuum_bat_charged(self) -> bool:
         """Check if the vacuum is charging."""
         return (self.vacuum_state == "docked") and (int(self.vacuum_battery) < 100)

{valetudo_map_parser-0.1.9b68 → valetudo_map_parser-0.1.9b70}/SCR/valetudo_map_parser/config/utils.py

@@ -11,7 +11,7 @@ import numpy as np
 from PIL import Image, ImageOps
 
 from .drawable import Drawable
-from .drawable_elements import DrawableElement, DrawingConfig
+from .drawable_elements import DrawingConfig
 from .enhanced_drawable import EnhancedDrawable
 from .types import (
     LOGGER,
@@ -80,10 +80,11 @@ class BaseHandler:
         """Return the robot position."""
         return self.robot_pos
 
-    async def async_get_pil_image(
+    async def async_get_image(
         self,
         m_json: dict | None,
         destinations: list | None = None,
+        bytes_format: bool = False,
     ) -> PilPNG | None:
         """
         Unified async function to get PIL image from JSON data for both Hypfer and Rand256 handlers.
@@ -96,50 +97,89 @@ class BaseHandler:
 
         @param m_json: The JSON data to use to draw the image
         @param destinations: MQTT destinations for labels (used by Rand256)
+        @param bytes_format: If True, also convert to PNG bytes and store in shared.binary_image
         @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:
+            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'):
+            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
+                    return_webp=False,  # Always return PIL Image
                 )
-            elif hasattr(self, 'async_get_image_from_json'):
+            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
+                    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
+                LOGGER.warning(
+                    "%s: Handler type not recognized for async_get_image",
+                    self.file_name,
+                )
+                return (
+                    self.shared.last_image
+                    if hasattr(self.shared, "last_image")
+                    else None
+                )
 
             # Store the new image in shared data
             if new_image is not None:
                 self.shared.new_image = new_image
+
+                # Convert to binary (PNG bytes) if requested
+                if bytes_format:
+                    try:
+                        png_buffer = io.BytesIO()
+                        new_image.save(png_buffer, format="PNG")
+                        self.shared.binary_image = png_buffer.getvalue()
+                        png_buffer.close()
+                        LOGGER.debug(
+                            "%s: Binary image conversion completed", self.file_name
+                        )
+                    except Exception as e:
+                        LOGGER.warning(
+                            "%s: Failed to convert image to binary: %s",
+                            self.file_name,
+                            str(e),
+                        )
+                        self.shared.binary_image = None
+                else:
+                    self.shared.binary_image = None
+
                 # 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)
+                LOGGER.debug(
+                    "%s: Image processed and stored in shared data", self.file_name
+                )
+                return new_image
             else:
-                LOGGER.warning("%s: Failed to generate image from JSON data", self.file_name)
-
-            return new_image
+                LOGGER.warning(
+                    "%s: Failed to generate image from JSON data", self.file_name
+                )
+                return (
+                    self.shared.last_image
+                    if hasattr(self.shared, "last_image")
+                    else None
+                )
 
         except Exception as e:
             LOGGER.error(
-                "%s: Error in async_get_pil_image: %s",
+                "%s: Error in async_get_image: %s",
                 self.file_name,
                 str(e),
-                exc_info=True
+                exc_info=True,
+            )
+            return (
+                self.shared.last_image if hasattr(self.shared, "last_image") else None
             )
-            return None
 
     def get_charger_position(self) -> ChargerPosition | None:
         """Return the charger position."""

{valetudo_map_parser-0.1.9b68 → valetudo_map_parser-0.1.9b70}/SCR/valetudo_map_parser/hypfer_draw.py

@@ -1,12 +1,11 @@
 """
 Image Draw Class for Valetudo Hypfer Image Handling.
 This class is used to simplify the ImageHandler class.
-Version: 2024.07.2
+Version: 0.1.9
 """
 
 from __future__ import annotations
 
-import asyncio
 import logging
 
 from .config.drawable_elements import DrawableElement
@@ -337,39 +336,30 @@ class ImageDraw:
             _LOGGER.info("%s: Got zones.", self.file_name)
 
         if zone_clean:
-            # Prepare zone drawing tasks for parallel execution
-            zone_tasks = []
+            # Process zones sequentially to avoid memory-intensive array copies
+            # This is more memory-efficient than parallel processing with copies
 
             # Active zones
             zones_active = zone_clean.get("active_zone")
             if zones_active:
-                zone_tasks.append(
-                    self.img_h.draw.zones(np_array.copy(), zones_active, color_zone_clean)
+                np_array = await self.img_h.draw.zones(
+                    np_array, zones_active, color_zone_clean
                 )
 
             # No-go zones
             no_go_zones = zone_clean.get("no_go_area")
             if no_go_zones:
-                zone_tasks.append(
-                    self.img_h.draw.zones(np_array.copy(), no_go_zones, color_no_go)
+                np_array = await self.img_h.draw.zones(
+                    np_array, no_go_zones, color_no_go
                 )
 
             # No-mop zones
             no_mop_zones = zone_clean.get("no_mop_area")
             if no_mop_zones:
-                zone_tasks.append(
-                    self.img_h.draw.zones(np_array.copy(), no_mop_zones, color_no_go)
+                np_array = await self.img_h.draw.zones(
+                    np_array, no_mop_zones, color_no_go
                 )
 
-            # Execute all zone drawing tasks in parallel
-            if zone_tasks:
-                zone_results = await asyncio.gather(*zone_tasks)
-                # Merge results back into the main array
-                for result in zone_results:
-                    # Simple overlay - in practice you might want more sophisticated blending
-                    mask = result != np_array
-                    np_array[mask] = result[mask]
-
         return np_array
 
     async def async_draw_virtual_walls(
@@ -439,7 +429,6 @@ class ImageDraw:
     def _check_active_zone_and_set_zooming(self) -> None:
         """Helper function to check active zones and set zooming state."""
         if self.img_h.active_zones and self.img_h.robot_in_room:
-
             segment_id = str(self.img_h.robot_in_room["id"])
             room_store = RoomStore(self.file_name)
             room_keys = list(room_store.get_rooms().keys())
@@ -615,7 +604,6 @@ class ImageDraw:
 
                     # Handle active zones - Map segment ID to active_zones position
                     if self.img_h.active_zones:
-
                         segment_id = str(self.img_h.robot_in_room["id"])
                         room_store = RoomStore(self.file_name)
                         room_keys = list(room_store.get_rooms().keys())

{valetudo_map_parser-0.1.9b68 → valetudo_map_parser-0.1.9b70}/SCR/valetudo_map_parser/hypfer_handler.py

@@ -8,6 +8,7 @@ Version: 0.1.9
 from __future__ import annotations
 
 import asyncio
+import numpy as np
 
 from PIL import Image
 
@@ -58,6 +59,7 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
         self.go_to = None  # vacuum go to data
         self.img_hash = None  # hash of the image calculated to check differences.
         self.img_base_layer = None  # numpy array store the map base layer.
+        self.img_work_layer = None  # persistent working buffer to avoid per-frame allocations
         self.active_zones = None  # vacuum active zones.
         self.svg_wait = False  # SVG image creation wait.
         self.imd = ImDraw(self)  # Image Draw class.
@@ -210,14 +212,12 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                                         ) % 16  # Increment room_id even if we skip
                                         continue
 
-                            # Check if this is a wall layer and if walls are enabled
+                            # Draw the layer ONLY if enabled
                             is_wall_layer = layer_type == "wall"
                             if is_wall_layer:
-                                if not self.drawing_config.is_enabled(
-                                    DrawableElement.WALL
-                                ):
-                                    pass
-
+                                # Skip walls entirely if disabled
+                                if not self.drawing_config.is_enabled(DrawableElement.WALL):
+                                    continue
                             # Draw the layer
                             (
                                 room_id,
@@ -273,6 +273,8 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                     LOGGER.info("%s: Completed base Layers", self.file_name)
                     # Copy the new array in base layer.
                     self.img_base_layer = await self.async_copy_array(img_np_array)
+
+
                 self.shared.frame_number = self.frame_number
                 self.frame_number += 1
                 if (self.frame_number >= self.max_frames) or (
@@ -285,8 +287,17 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                     str(self.json_id),
                     str(self.frame_number),
                 )
-                # Copy the base layer to the new image.
-                img_np_array = await self.async_copy_array(self.img_base_layer)
+                # Ensure persistent working buffer exists and matches base (allocate only when needed)
+                if (
+                    self.img_work_layer is None
+                    or self.img_work_layer.shape != self.img_base_layer.shape
+                    or self.img_work_layer.dtype != self.img_base_layer.dtype
+                ):
+                    self.img_work_layer = np.empty_like(self.img_base_layer)
+
+                # Copy the base layer into the persistent working buffer (no new allocation per frame)
+                np.copyto(self.img_work_layer, self.img_base_layer)
+                img_np_array = self.img_work_layer
 
                 # Prepare parallel data extraction tasks
                 data_tasks = []
@@ -301,11 +312,17 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
 
                 # Prepare path data extraction
                 path_enabled = self.drawing_config.is_enabled(DrawableElement.PATH)
-                LOGGER.info("%s: PATH element enabled: %s", self.file_name, path_enabled)
+                LOGGER.info(
+                    "%s: PATH element enabled: %s", self.file_name, path_enabled
+                )
                 if path_enabled:
                     LOGGER.info("%s: Drawing path", self.file_name)
                     data_tasks.append(self._prepare_path_data(m_json))
 
+                # Await all data preparation tasks if any were created
+                if data_tasks:
+                    await asyncio.gather(*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):

{valetudo_map_parser-0.1.9b68 → valetudo_map_parser-0.1.9b70}/SCR/valetudo_map_parser/map_data.py

@@ -19,14 +19,14 @@ class ImageData:
     @staticmethod
     def sublist(lst, n):
         """Split a list into n chunks of specified size."""
-        return [lst[i: i + n] for i in range(0, len(lst), n)]
+        return [lst[i : i + n] for i in range(0, len(lst), n)]
 
     @staticmethod
     def sublist_join(lst, n):
         """Join the lists in a unique list of n elements."""
         arr = np.array(lst)
         num_windows = len(lst) - n + 1
-        result = [arr[i: i + n].tolist() for i in range(num_windows)]
+        result = [arr[i : i + n].tolist() for i in range(num_windows)]
         return result
 
     @staticmethod
@@ -39,15 +39,19 @@ class ImageData:
             points = obstacle.get("points", [])
             image_id = obstacle.get("metaData", {}).get("id")
             if label and points:
-                obstacle_positions.append({
-                    "label": label,
-                    "points": {"x": points[0], "y": points[1]},
-                    "id": image_id,
-                })
+                obstacle_positions.append(
+                    {
+                        "label": label,
+                        "points": {"x": points[0], "y": points[1]},
+                        "id": image_id,
+                    }
+                )
         return obstacle_positions
 
     @staticmethod
-    def find_layers(json_obj: JsonType, layer_dict: dict, active_list: list) -> tuple[dict, list]:
+    def find_layers(
+        json_obj: JsonType, layer_dict: dict, active_list: list
+    ) -> tuple[dict, list]:
         """Find the layers in the json object."""
         layer_dict = {} if layer_dict is None else layer_dict
         active_list = [] if active_list is None else active_list
@@ -56,7 +60,9 @@ class ImageData:
                 layer_type = json_obj.get("type")
                 active_type = json_obj.get("metaData")
                 if layer_type:
-                    layer_dict.setdefault(layer_type, []).append(json_obj.get("compressedPixels", []))
+                    layer_dict.setdefault(layer_type, []).append(
+                        json_obj.get("compressedPixels", [])
+                    )
                 if layer_type == "segment":
                     active_list.append(int(active_type.get("active", 0)))
             for value in json_obj.values():
@@ -121,7 +127,10 @@ class ImageData:
 
         def _recursive(obj):
             if isinstance(obj, dict):
-                if obj.get("__class") == "LineMapEntity" and obj.get("type") == "virtual_wall":
+                if (
+                    obj.get("__class") == "LineMapEntity"
+                    and obj.get("type") == "virtual_wall"
+                ):
                     walls.append(obj["points"])
                 for value in obj.values():
                     _recursive(value)
@@ -133,7 +142,9 @@ class ImageData:
         return walls
 
     @staticmethod
-    async def async_get_rooms_coordinates(pixels: list, pixel_size: int = 5, rand: bool = False) -> tuple:
+    async def async_get_rooms_coordinates(
+        pixels: list, pixel_size: int = 5, rand: bool = False
+    ) -> tuple:
         """Extract the room coordinates from the vacuum pixels data."""
         df = pd.DataFrame(pixels, columns=["x", "y", "length"])
         if rand:

{valetudo_map_parser-0.1.9b68 → valetudo_map_parser-0.1.9b70}/SCR/valetudo_map_parser/rand256_handler.py

@@ -672,5 +672,3 @@ class ReImageHandler(BaseHandler, AutoCrop):
     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.9b68 → valetudo_map_parser-0.1.9b70}/pyproject.toml

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