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

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/config/drawable.py

@@ -311,6 +311,79 @@ class Drawable:
 
         return layer
 
+    @staticmethod
+    def draw_lines_batch(
+        layer: NumpyArray,
+        line_segments: list,
+        color: Color,
+        width: int = 3,
+    ) -> NumpyArray:
+        """
+        Draw multiple line segments with batch processing for better performance.
+
+        Args:
+            layer: The numpy array to draw on
+            line_segments: List of tuples [(x1, y1, x2, y2), ...]
+            color: Color to draw with
+            width: Width of the lines
+        """
+        if not line_segments:
+            return layer
+
+        # Pre-calculate blended color once for the entire batch
+        # Use the first line segment for color sampling
+        x1, y1, x2, y2 = line_segments[0]
+        blended_color = get_blended_color(x1, y1, x2, y2, layer, color)
+
+        # Fast path for fully opaque colors - skip individual blending
+        if color[3] == 255:
+            blended_color = color
+
+        # Process all line segments with the same blended color
+        for x1, y1, x2, y2 in line_segments:
+            # Ensure coordinates are integers
+            x1, y1, x2, y2 = int(x1), int(y1), int(x2), int(y2)
+
+            # Calculate line length
+            length = max(abs(x2 - x1), abs(y2 - y1))
+            if length == 0:  # Handle case of a single point
+                # Draw a dot with the specified width
+                for i in range(-width // 2, (width + 1) // 2):
+                    for j in range(-width // 2, (width + 1) // 2):
+                        if (
+                            0 <= x1 + i < layer.shape[1]
+                            and 0 <= y1 + j < layer.shape[0]
+                        ):
+                            layer[y1 + j, x1 + i] = blended_color
+                continue
+
+            # Create parametric points along the line
+            t = np.linspace(0, 1, length + 1)  # Reduced from length * 2 to length + 1
+            x_coords = np.round(x1 * (1 - t) + x2 * t).astype(int)
+            y_coords = np.round(y1 * (1 - t) + y2 * t).astype(int)
+
+            # Draw the line with the specified width
+            if width == 1:
+                # Fast path for width=1
+                for x, y in zip(x_coords, y_coords):
+                    if 0 <= x < layer.shape[1] and 0 <= y < layer.shape[0]:
+                        layer[y, x] = blended_color
+            else:
+                # For thicker lines, draw a rectangle at each point
+                half_width = width // 2
+                for x, y in zip(x_coords, y_coords):
+                    for i in range(-half_width, half_width + 1):
+                        for j in range(-half_width, half_width + 1):
+                            if (
+                                i * i + j * j
+                                <= half_width * half_width  # Make it round
+                                and 0 <= x + i < layer.shape[1]
+                                and 0 <= y + j < layer.shape[0]
+                            ):
+                                layer[y + j, x + i] = blended_color
+
+        return layer
+
     @staticmethod
     async def draw_virtual_walls(
         layer: NumpyArray, virtual_walls, color: Color
@@ -329,14 +402,16 @@ class Drawable:
     async def lines(arr: NumpyArray, coords, width: int, color: Color) -> NumpyArray:
         """
         Join the coordinates creating a continuous line (path).
-        Optimized with vectorized operations for better performance.
+        Optimized with batch processing 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):
+        # Collect all line segments for batch processing
+        line_segments = []
+        for coord in coords:
             x0, y0 = coord[0]
             try:
                 x1, y1 = coord[1]
@@ -347,15 +422,16 @@ class Drawable:
             if x0 == x1 and y0 == y1:
                 continue
 
-            # Get blended color for this line segment
-            blended_color = get_blended_color(x0, y0, x1, y1, arr, color)
+            line_segments.append((x0, y0, x1, y1))
 
-            # Use the optimized line drawing method
-            arr = Drawable._line(arr, x0, y0, x1, y1, blended_color, width)
+        # Process all line segments in batches
+        batch_size = 100  # Process 100 lines at a time
+        for i in range(0, len(line_segments), batch_size):
+            batch = line_segments[i : i + batch_size]
+            arr = Drawable.draw_lines_batch(arr, batch, color, width)
 
-            # Yield control every 100 operations to prevent blocking
-            if i % 100 == 0:
-                await asyncio.sleep(0)
+            # Yield control between batches to prevent blocking
+            await asyncio.sleep(0)
 
         return arr
 
@@ -513,7 +589,11 @@ class Drawable:
             # 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))
+                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)
@@ -567,7 +647,9 @@ class Drawable:
                         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
+                        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
@@ -575,7 +657,9 @@ class Drawable:
         return layers
 
     @staticmethod
-    async def _process_single_zone(layers: NumpyArray, zone, color: Color, dot_radius: int, dot_spacing: int) -> NumpyArray:
+    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
 
@@ -613,7 +697,9 @@ class Drawable:
 
                     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
+                        mask = (y_indices - y) ** 2 + (
+                            x_indices - x
+                        ) ** 2 <= dot_radius**2
                         layers[y_min:y_max, x_min:x_max][mask] = blended_color
 
         return layers

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/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/hypfer_draw.py

@@ -337,39 +337,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 +430,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 +605,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/hypfer_handler.py

@@ -301,11 +301,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/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/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.dist-info → valetudo_map_parser-0.1.9b69.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: valetudo-map-parser
-Version: 0.1.9b68
+Version: 0.1.9b69
 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.dist-info → valetudo_map_parser-0.1.9b69.dist-info}/RECORD

@@ -1,27 +1,27 @@
 valetudo_map_parser/__init__.py,sha256=XO_eJwFDyU7hXJ4tAa2zY-n-SM2_kmIGMWDKY3GcauY,1163
 valetudo_map_parser/config/__init__.py,sha256=DQ9plV3ZF_K25Dp5ZQHPDoG-40dQoJNdNi-dfNeR3Zc,48
-valetudo_map_parser/config/async_utils.py,sha256=r96x4rVis2y57KSnWfVxraSGi0cOz0fsOg-njRIggfs,3169
+valetudo_map_parser/config/async_utils.py,sha256=e1j9uTtg4dhPVWvB2_XgqaH4aeSjRAPz-puRMbGoOs8,3204
 valetudo_map_parser/config/auto_crop.py,sha256=Aes7vfv4z8ihYvGaH5Nryj6Y9mHDerZLIeyvePjf9aQ,19259
 valetudo_map_parser/config/color_utils.py,sha256=nXD6WeNmdFdoMxPDW-JFpjnxJSaZR1jX-ouNfrx6zvE,4502
 valetudo_map_parser/config/colors.py,sha256=DG-oPQoN5gsnwDbEsuFr8a0hRCxmbFHObWa4_5pr-70,29910
-valetudo_map_parser/config/drawable.py,sha256=UpmXlCqZX_D7rqepk8IzTrzflgweLQ7n05ZeGIFRur8,37850
+valetudo_map_parser/config/drawable.py,sha256=nAOoPQmNz6LJ4-WN7WF5iHTYEAzT43YVnTpiqzjNva0,41180
 valetudo_map_parser/config/drawable_elements.py,sha256=o-5oiXmfqPwNQLzKIhkEcZD_A47rIU9E0CqKgWipxgc,11516
 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/shared.py,sha256=AQ73878TGCxbHQhgrAxSROLqFE-Zz4fJhTdoi9gBvJo,12736
+valetudo_map_parser/config/shared.py,sha256=98CgGDY0tbc5BSg2TIHbGcDFZZ2acgIYnoPjAwENmBU,12885
 valetudo_map_parser/config/types.py,sha256=saL7pULKAdTRQ_ShR2arT8IV472e9MBC_SohTthlGp8,17567
-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=f9SCphArA-LO2ySrTKpxn6k4htM-JRrbrxKFh3AjnD8,23171
+valetudo_map_parser/config/utils.py,sha256=lRLvQbqCQ44knnIJr-UAlkEOO1d14mFCmHKDor989VE,35468
+valetudo_map_parser/hypfer_draw.py,sha256=vlrfBSDpHNnjh0dRA1BE5_4MsKMMWS_O1QErrd-VRKE,28995
+valetudo_map_parser/hypfer_handler.py,sha256=U452BEi3kmU0O27aNN7BY42J_zrpjhDuebpqxwGxe50,23366
 valetudo_map_parser/hypfer_rooms_handler.py,sha256=NkpOA6Gdq-2D3lLAxvtNuuWMvPXHxeMY2TO5RZLSHlU,22652
-valetudo_map_parser/map_data.py,sha256=Op0LTCakcTJ1Q0rxQhl6BpgSby_6nJenCQS2Y2FHtRk,17243
+valetudo_map_parser/map_data.py,sha256=Flq5t9QQQiD5ylObIniHhPP1VB7VhNoMcMeJrOey3Go,17433
 valetudo_map_parser/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-valetudo_map_parser/rand256_handler.py,sha256=6Qt-xFJ3PITQNSAJTaEo6jl6TdgFms7ay1rnk4vekgk,27653
+valetudo_map_parser/rand256_handler.py,sha256=daaSQ5ktMUYMnYxJkjS75UdBchpXVZ58HIomwHBFivs,27651
 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.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-0.1.9b69.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
+valetudo_map_parser-0.1.9b69.dist-info/METADATA,sha256=Ex2vOq_SjHDzJqk5dNNL78hXqOnkhz9Y7anOUC-XsmE,3353
+valetudo_map_parser-0.1.9b69.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
+valetudo_map_parser-0.1.9b69.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+valetudo_map_parser-0.1.9b69.dist-info/RECORD,,