valetudo-map-parser 0.1.9b42__py3-none-any.whl → 0.1.9b44__py3-none-any.whl

valetudo_map_parser/rand25_handler.py

@@ -2,7 +2,7 @@
 Image Handler Module for Valetudo Re Vacuums.
 It returns the PIL PNG image frame relative to the Map Data extrapolated from the vacuum json.
 It also returns calibration, rooms data to the card and other images information to the camera.
-Version: 0.1.9
+Version: 0.1.9.b42
 """
 
 from __future__ import annotations
@@ -15,9 +15,7 @@ import numpy as np
 from PIL import Image
 
 from .config.auto_crop import AutoCrop
-from .config.drawable import Drawable
-from .config.drawable_elements import DrawableElement, DrawingConfig
-from .config.enhanced_drawable import EnhancedDrawable
+from .config.drawable_elements import DrawableElement
 from .config.types import (
     COLORS,
     DEFAULT_IMAGE_SIZE,
@@ -29,7 +27,17 @@ from .config.types import (
     RoomsProperties,
     RoomStore,
 )
-from .config.utils import BaseHandler, prepare_resize_params
+from .config.utils import (
+    BaseHandler,
+    get_element_at_position,
+    get_room_at_position,
+    handle_room_outline_error,
+    initialize_drawing_config,
+    manage_drawable_elements,
+    prepare_resize_params,
+    async_extract_room_outline,
+    update_element_map_with_robot,
+)
 from .map_data import RandImageData
 from .reimg_draw import ImageDraw
 
@@ -54,8 +62,9 @@ class ReImageHandler(BaseHandler, AutoCrop):
         self.data = RandImageData  # Image Data
 
         # Initialize drawing configuration using the shared utility function
-        from .config.utils import initialize_drawing_config
-        self.drawing_config, self.draw, self.enhanced_draw = initialize_drawing_config(self)
+        self.drawing_config, self.draw, self.enhanced_draw = initialize_drawing_config(
+            self
+        )
         self.element_map = None  # Map of element codes
         self.go_to = None  # Go to position data
         self.img_base_layer = None  # Base image layer
@@ -109,13 +118,14 @@ class ReImageHandler(BaseHandler, AutoCrop):
         num_room_pixels = np.sum(room_mask)
         _LOGGER.debug(
             "%s: Room %s mask has %d pixels",
-            self.file_name, str(room_id_int), int(num_room_pixels)
+            self.file_name,
+            str(room_id_int),
+            int(num_room_pixels),
         )
 
         # Use the shared utility function to extract the room outline
-        from .config.utils import async_extract_room_outline
         return await async_extract_room_outline(
-            room_mask, min_x, min_y, max_x, max_y, self.file_name, room_id_int, _LOGGER
+            room_mask, min_x, min_y, max_x, max_y, self.file_name, room_id_int
         )
 
     async def extract_room_properties(
@@ -140,72 +150,81 @@ class ReImageHandler(BaseHandler, AutoCrop):
             room_id_to_data = {room["id"]: room for room in room_data}
             self.rooms_pos = []
             room_properties = {}
-            if self.outlines:
-                for id_x, room_id in enumerate(unsorted_id):
-                    if room_id in room_id_to_data:
-                        room_info = room_id_to_data[room_id]
-                        name = room_info.get("name")
-                        # Calculate x and y min/max from outlines
-                        x_min = self.outlines[id_x][0][0]
-                        x_max = self.outlines[id_x][1][0]
-                        y_min = self.outlines[id_x][0][1]
-                        y_max = self.outlines[id_x][1][1]
-
-                        # Get rectangular corners as a fallback
-                        corners = self.get_corners(x_max, x_min, y_max, y_min)
-
-                        # Try to extract a more accurate room outline from the element map
-                        try:
-                            # Extract the room outline using the element map
-                            outline = await self.extract_room_outline_from_map(
-                                room_id, self.segment_data[id_x]
-                            )
-                            _LOGGER.debug(
-                                "%s: Traced outline for room %s with %d points",
-                                self.file_name,
-                                room_id,
-                                len(outline),
-                            )
-                        except (ValueError, IndexError, TypeError, ArithmeticError) as e:
-                            from .config.utils import handle_room_outline_error
-                            handle_room_outline_error(self.file_name, room_id, e, _LOGGER)
-                            outline = corners
-
-                        # rand256 vacuums accept int(room_id) or str(name)
-                        # the card will soon support int(room_id) but the camera will send name
-                        # this avoids the manual change of the values in the card.
-                        self.rooms_pos.append(
-                            {
-                                "name": name,
-                                "corners": corners,
-                            }
+            if not self.outlines:
+                # Return empty data if no outlines are available
+                _LOGGER.debug("%s: No outlines available", self.file_name)
+                return None, None, None
+
+            # If we have outlines, proceed with processing
+            for id_x, room_id in enumerate(unsorted_id):
+                if room_id in room_id_to_data:
+                    room_info = room_id_to_data[room_id]
+                    name = room_info.get("name")
+                    # Calculate x and y min/max from outlines
+                    x_min = self.outlines[id_x][0][0]
+                    x_max = self.outlines[id_x][1][0]
+                    y_min = self.outlines[id_x][0][1]
+                    y_max = self.outlines[id_x][1][1]
+
+                    # Get rectangular corners as a fallback
+                    corners = self.get_corners(x_max, x_min, y_max, y_min)
+
+                    # Try to extract a more accurate room outline from the element map
+                    try:
+                        # Extract the room outline using the element map
+                        outline = await self.extract_room_outline_from_map(
+                            room_id, self.segment_data[id_x]
                         )
-                        room_properties[int(room_id)] = {
-                            "number": int(room_id),
-                            "outline": outline,
+                        _LOGGER.debug(
+                            "%s: Traced outline for room %s with %d points",
+                            self.file_name,
+                            room_id,
+                            len(outline),
+                        )
+                    except (
+                        ValueError,
+                        IndexError,
+                        TypeError,
+                        ArithmeticError,
+                    ) as e:
+                        handle_room_outline_error(self.file_name, room_id, e)
+                        outline = corners
+
+                    # rand256 vacuums accept int(room_id) or str(name)
+                    # the card will soon support int(room_id) but the camera will send name
+                    # this avoids the manual change of the values in the card.
+                    self.rooms_pos.append(
+                        {
                             "name": name,
-                            "x": (x_min + x_max) // 2,
-                            "y": (y_min + y_max) // 2,
+                            "corners": corners,
                         }
-                # get the zones and points data
-                zone_properties = await self.async_zone_propriety(zones_data)
-                # get the points data
-                point_properties = await self.async_points_propriety(points_data)
-                if room_properties or zone_properties:
-                    extracted_data = [
-                        f"{len(room_properties)} Rooms" if room_properties else None,
-                        f"{len(zone_properties)} Zones" if zone_properties else None,
-                    ]
-                    extracted_data = ", ".join(filter(None, extracted_data))
-                    _LOGGER.debug("Extracted data: %s", extracted_data)
-                else:
-                    self.rooms_pos = None
-                    _LOGGER.debug(
-                        "%s: Rooms and Zones data not available!", self.file_name
                     )
-                rooms = RoomStore(self.file_name, room_properties)
-                _LOGGER.debug("Rooms Data: %s", rooms.get_rooms())
-                return room_properties, zone_properties, point_properties
+                    room_properties[int(room_id)] = {
+                        "number": int(room_id),
+                        "outline": outline,
+                        "name": name,
+                        "x": (x_min + x_max) // 2,
+                        "y": (y_min + y_max) // 2,
+                    }
+            # get the zones and points data
+            zone_properties = await self.async_zone_propriety(zones_data)
+            # get the points data
+            point_properties = await self.async_points_propriety(points_data)
+            if room_properties or zone_properties:
+                extracted_data = [
+                    f"{len(room_properties)} Rooms" if room_properties else None,
+                    f"{len(zone_properties)} Zones" if zone_properties else None,
+                ]
+                extracted_data = ", ".join(filter(None, extracted_data))
+                _LOGGER.debug("Extracted data: %s", extracted_data)
+            else:
+                self.rooms_pos = None
+                _LOGGER.debug(
+                    "%s: Rooms and Zones data not available!", self.file_name
+                )
+            rooms = RoomStore(self.file_name, room_properties)
+            _LOGGER.debug("Rooms Data: %s", rooms.get_rooms())
+            return room_properties, zone_properties, point_properties
         except (RuntimeError, ValueError) as e:
             _LOGGER.debug(
                 "No rooms Data or Error in extract_room_properties: %s",
@@ -271,6 +290,9 @@ class ReImageHandler(BaseHandler, AutoCrop):
             )
             return None
 
+        # If we reach here without returning, return None
+        return None
+
     async def _setup_robot_and_image(
         self, m_json, size_x, size_y, colors, destinations
     ):
@@ -340,20 +362,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
                 img_np_array, m_json, colors["charger"]
             )
             # Update element map for charger position
-            if self.charger_pos:
-                charger_radius = 15
-                for dy in range(-charger_radius, charger_radius + 1):
-                    for dx in range(-charger_radius, charger_radius + 1):
-                        if dx * dx + dy * dy <= charger_radius * charger_radius:
-                            cx, cy = (
-                                int(self.charger_pos[0] + dx),
-                                int(self.charger_pos[1] + dy),
-                            )
-                            if (
-                                0 <= cy < self.element_map.shape[0]
-                                and 0 <= cx < self.element_map.shape[1]
-                            ):
-                                self.element_map[cy, cx] = DrawableElement.CHARGER
+            self._update_element_map_for_charger()
 
         # Draw zones if enabled
         if self.drawing_config.is_enabled(DrawableElement.RESTRICTED_AREA):
@@ -391,8 +400,9 @@ class ReImageHandler(BaseHandler, AutoCrop):
             )
 
             # Update element map for robot position
-            from .config.utils import update_element_map_with_robot
-            update_element_map_with_robot(self.element_map, robot_position, DrawableElement.ROBOT)
+            update_element_map_with_robot(
+                self.element_map, robot_position, DrawableElement.ROBOT
+            )
         img_np_array = await self.async_auto_trim_and_zoom_image(
             img_np_array,
             detect_colour=colors["background"],
@@ -461,46 +471,57 @@ class ReImageHandler(BaseHandler, AutoCrop):
         _LOGGER.debug("%s Changed room.. searching..", self.file_name)
         room_count = -1
         last_room = None
-        if self.rooms_pos:
-            if self.robot_in_room:
-                last_room = self.robot_in_room
-            for room in self.rooms_pos:
-                corners = room["corners"]
-                room_count += 1
-                self.robot_in_room = {
-                    "id": room_count,
-                    "left": corners[0][0],
-                    "right": corners[2][0],
-                    "up": corners[0][1],
-                    "down": corners[2][1],
-                    "room": room["name"],
-                }
-                # Check if the robot coordinates are inside the room's corners
-                if _check_robot_position(robot_x, robot_y):
-                    temp = {
-                        "x": robot_x,
-                        "y": robot_y,
-                        "angle": angle,
-                        "in_room": self.robot_in_room["room"],
-                    }
-                    _LOGGER.debug(
-                        "%s is in %s", self.file_name, self.robot_in_room["room"]
-                    )
-                    del room, corners, robot_x, robot_y  # free memory.
-                    return temp
-            del room, corners  # free memory.
-            _LOGGER.debug(
-                "%s: Not located within Camera Rooms coordinates.", self.file_name
-            )
-            self.zooming = False
-            self.robot_in_room = last_room
-            temp = {
+
+        # If no rooms data is available, return a default position
+        if not self.rooms_pos:
+            _LOGGER.debug("%s: No rooms data available", self.file_name)
+            return {
                 "x": robot_x,
                 "y": robot_y,
                 "angle": angle,
-                "in_room": self.robot_in_room["room"],
+                "in_room": "unknown"
             }
-            return temp
+
+        # If rooms data is available, search for the room
+        if self.robot_in_room:
+            last_room = self.robot_in_room
+        for room in self.rooms_pos:
+            corners = room["corners"]
+            room_count += 1
+            self.robot_in_room = {
+                "id": room_count,
+                "left": corners[0][0],
+                "right": corners[2][0],
+                "up": corners[0][1],
+                "down": corners[2][1],
+                "room": room["name"],
+            }
+            # Check if the robot coordinates are inside the room's corners
+            if _check_robot_position(robot_x, robot_y):
+                temp = {
+                    "x": robot_x,
+                    "y": robot_y,
+                    "angle": angle,
+                    "in_room": self.robot_in_room["room"],
+                }
+                _LOGGER.debug(
+                    "%s is in %s", self.file_name, self.robot_in_room["room"]
+                )
+                del room, corners, robot_x, robot_y  # free memory.
+                return temp
+        # After checking all rooms and not finding a match
+        _LOGGER.debug(
+            "%s: Not located within Camera Rooms coordinates.", self.file_name
+        )
+        self.zooming = False
+        self.robot_in_room = last_room
+        temp = {
+            "x": robot_x,
+            "y": robot_y,
+            "angle": angle,
+            "in_room": self.robot_in_room["room"] if self.robot_in_room else "unknown",
+        }
+        return temp
 
     def get_calibration_data(self, rotation_angle: int = 0) -> Any:
         """Return the map calibration data."""
@@ -532,27 +553,47 @@ class ReImageHandler(BaseHandler, AutoCrop):
 
     def disable_element(self, element_code: DrawableElement) -> None:
         """Disable drawing of a specific element."""
-        from .config.utils import manage_drawable_elements
         manage_drawable_elements(self, "disable", element_code=element_code)
 
     def set_elements(self, element_codes: list[DrawableElement]) -> None:
         """Enable only the specified elements, disable all others."""
-        from .config.utils import manage_drawable_elements
         manage_drawable_elements(self, "set_elements", element_codes=element_codes)
 
     def set_element_property(
         self, element_code: DrawableElement, property_name: str, value
     ) -> None:
         """Set a drawing property for an element."""
-        from .config.utils import manage_drawable_elements
-        manage_drawable_elements(self, "set_property", element_code=element_code, property_name=property_name, value=value)
+        manage_drawable_elements(
+            self,
+            "set_property",
+            element_code=element_code,
+            property_name=property_name,
+            value=value,
+        )
 
     def get_element_at_position(self, x: int, y: int) -> DrawableElement:
         """Get the element code at a specific position."""
-        from .config.utils import get_element_at_position
         return get_element_at_position(self.element_map, x, y)
 
     def get_room_at_position(self, x: int, y: int) -> int:
         """Get the room ID at a specific position, or None if not a room."""
-        from .config.utils import get_room_at_position
         return get_room_at_position(self.element_map, x, y, DrawableElement.ROOM_1)
+
+    def _update_element_map_for_charger(self):
+        """Helper method to update the element map for the charger position."""
+        if not self.charger_pos or self.element_map is None:
+            return
+
+        charger_radius = 15
+        # Handle both dictionary format {'x': x, 'y': y} and list format [x, y]
+        charger_x = self.charger_pos.get('x') if isinstance(self.charger_pos, dict) else self.charger_pos[0]
+        charger_y = self.charger_pos.get('y') if isinstance(self.charger_pos, dict) else self.charger_pos[1]
+
+        for dy in range(-charger_radius, charger_radius + 1):
+            for dx in range(-charger_radius, charger_radius + 1):
+                # Check if the point is within the circular charger area
+                if dx * dx + dy * dy <= charger_radius * charger_radius:
+                    cx, cy = int(charger_x + dx), int(charger_y + dy)
+                    # Check if the coordinates are within the element map bounds
+                    if (0 <= cy < self.element_map.shape[0] and 0 <= cx < self.element_map.shape[1]):
+                        self.element_map[cy, cx] = DrawableElement.CHARGER

valetudo_map_parser/reimg_draw.py

@@ -1,7 +1,7 @@
 """
 Image Draw Class for Valetudo Rand256 Image Handling.
 This class is used to simplify the ImageHandler class.
-Version: 2024.12.0
+Version: 0.1.9.b42
 """
 
 from __future__ import annotations

valetudo_map_parser/utils/__init__.py

@@ -0,0 +1,5 @@
+"""Utility functions for the Valetudo Map Parser."""
+
+from .color_utils import get_blended_color
+
+__all__ = ["get_blended_color"]

valetudo_map_parser/utils/color_utils.py

@@ -0,0 +1,62 @@
+"""Utility functions for color operations in the map parser."""
+
+from typing import Tuple, Optional
+
+from ..config.colors import ColorsManagment
+from ..config.drawable_elements import ElementMapGenerator, DrawableElement
+
+
+def get_blended_color(
+    element_map_generator: ElementMapGenerator,
+    colors_manager: ColorsManagment,
+    x: int,
+    y: int,
+    new_element: DrawableElement,
+    new_color: Tuple[int, int, int, int]
+) -> Tuple[int, int, int, int]:
+    """
+    Get a blended color for a pixel based on the current element map and the new element to draw.
+    
+    This function:
+    1. Gets the current element at position (x,y) from the element map
+    2. Gets the color for that element from the colors manager
+    3. Blends the new color with the existing color based on alpha values
+    
+    Args:
+        element_map_generator: The element map generator containing the current element map
+        colors_manager: The colors manager to get colors for elements
+        x: X coordinate in the element map
+        y: Y coordinate in the element map
+        new_element: The new element to draw at this position
+        new_color: The RGBA color of the new element
+        
+    Returns:
+        Blended RGBA color to use for drawing
+    """
+    # Get current element at this position
+    current_element = element_map_generator.get_element_at_position(x, y)
+    
+    # If no current element or it's the same as the new element, just return the new color
+    if current_element is None or current_element == new_element:
+        return new_color
+    
+    # Get color for the current element
+    current_color = None
+    
+    # Handle different element types
+    if current_element == DrawableElement.FLOOR:
+        # Floor is the background color
+        current_color = colors_manager.get_colour("color_background")
+    elif current_element == DrawableElement.WALL:
+        # Wall color
+        current_color = colors_manager.get_colour("color_wall")
+    elif DrawableElement.ROOM_1 <= current_element <= DrawableElement.ROOM_15:
+        # Room colors (ROOM_1 = 16, ROOM_2 = 17, etc.)
+        room_index = current_element - DrawableElement.ROOM_1
+        current_color = colors_manager.get_colour(f"color_room_{room_index}")
+    else:
+        # Default for unknown elements
+        current_color = (100, 100, 100, 255)
+    
+    # Blend the colors
+    return colors_manager.blend_colors(current_color, new_color)

{valetudo_map_parser-0.1.9b42.dist-info → valetudo_map_parser-0.1.9b44.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: valetudo-map-parser
-Version: 0.1.9b42
+Version: 0.1.9b44
 Summary: A Python library to parse Valetudo map data returning a PIL Image object.
 License: Apache-2.0
 Author: Sandro Cantarella
@@ -12,6 +12,8 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: Pillow (>=10.3.0)
 Requires-Dist: numpy (>=1.26.4)
+Requires-Dist: scikit-image (>=0.22.0)
+Requires-Dist: scipy (>=1.12.0)
 Project-URL: Bug Tracker, https://github.com/sca075/Python-package-valetudo-map-parser/issues
 Project-URL: Changelog, https://github.com/sca075/Python-package-valetudo-map-parser/releases
 Project-URL: Homepage, https://github.com/sca075/Python-package-valetudo-map-parser

valetudo_map_parser-0.1.9b44.dist-info/RECORD

@@ -0,0 +1,27 @@
+valetudo_map_parser/__init__.py,sha256=INujZn4exaXUjqMN8nZkGJIziDWlW59t65fJ34HJX44,956
+valetudo_map_parser/config/__init__.py,sha256=DQ9plV3ZF_K25Dp5ZQHPDoG-40dQoJNdNi-dfNeR3Zc,48
+valetudo_map_parser/config/auto_crop.py,sha256=6OvRsWzXMXBaSEvgwpaaisNdozDKiDyTmPjknFxoUMc,12624
+valetudo_map_parser/config/colors.py,sha256=C4hZ2bCavNvTUv-TVS6qLWWM9aDPBEEySTHhSOV95Ug,8535
+valetudo_map_parser/config/colors_man.py,sha256=9b5c6XmpMzhEiunwfIjVkOk1lDyV-UFoasACdkGXfbo,7833
+valetudo_map_parser/config/drawable.py,sha256=RYTt38N7BjC09S5hqoubPpW8difz93bQZ9BLjFi51pg,18678
+valetudo_map_parser/config/drawable_elements.py,sha256=oBhmhkx1SpzTtbnpZBB2Hd5U2mOIbo7908J8oM38XiY,40841
+valetudo_map_parser/config/enhanced_drawable.py,sha256=xNgFUNccstP245VgLFEA9gjB3-VvlSAJSjRgSZ3YFL0,16641
+valetudo_map_parser/config/optimized_element_map.py,sha256=XV1xi-oa8uNTrzFUxHWF8MFP2X-jKJw3SV7HU10lWE4,15514
+valetudo_map_parser/config/rand25_parser.py,sha256=kIayyqVZBfQfAMkiArzqrrj9vqZB3pkgT0Y5ufrQmGA,16448
+valetudo_map_parser/config/room_outline.py,sha256=nGpRs1f1vE_63XL1i6DdHtfwJmnC3WayIjVsFgzfOj8,4928
+valetudo_map_parser/config/shared.py,sha256=WSl5rYSiTqE6YGAiwi9RILMZIQdFZRzVS8DwqzTZBbw,11309
+valetudo_map_parser/config/types.py,sha256=uEJY-yYHHJWW3EZjg7hERSFrC2XuKzzRGT3C0z31Aw0,18359
+valetudo_map_parser/config/utils.py,sha256=MP5_s9VFSdDERymujvDuGB8nYCXVuJcqg5tR5H9HCgY,33167
+valetudo_map_parser/hypfer_draw.py,sha256=oL_RbX0LEcPvOlMrfBA38qpJkMqqVwR-oAEbZeHqLWM,19898
+valetudo_map_parser/hypfer_handler.py,sha256=ivMbcfySKk0QH9m-qWvI48TzSkHjuPnxrcTAD6WVCrE,29004
+valetudo_map_parser/map_data.py,sha256=2NfZ0OO20OQPNrzditxaQV-8zSEEJclbD_CtH84HEA0,19121
+valetudo_map_parser/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+valetudo_map_parser/rand25_handler.py,sha256=2n1Eyj3hHeGZNrpqQqSQlKOmVmCVcaSJyARuIzy42g4,24535
+valetudo_map_parser/reimg_draw.py,sha256=1q8LkNTPHEA9Tsapc_JnVw51kpPYNhaBU-KmHkefCQY,12507
+valetudo_map_parser/utils/__init__.py,sha256=r-GKKSPqBkMDd2K-vWe7kAix8OBrGN5HXC1RS2tbDwo,130
+valetudo_map_parser/utils/color_utils.py,sha256=7t-o4oHddE5U0A9ahYBqBKmT0B2VFe_GlQ7cnLs41Us,2425
+valetudo_map_parser-0.1.9b44.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
+valetudo_map_parser-0.1.9b44.dist-info/METADATA,sha256=Y-mTbBw-lK8ejHIHLM0xk-GALE6StvzF1PtJAZz1_2Q,3360
+valetudo_map_parser-0.1.9b44.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
+valetudo_map_parser-0.1.9b44.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+valetudo_map_parser-0.1.9b44.dist-info/RECORD,,

valetudo_map_parser-0.1.9b42.dist-info/RECORD

@@ -1,23 +0,0 @@
-valetudo_map_parser/__init__.py,sha256=INujZn4exaXUjqMN8nZkGJIziDWlW59t65fJ34HJX44,956
-valetudo_map_parser/config/__init__.py,sha256=DQ9plV3ZF_K25Dp5ZQHPDoG-40dQoJNdNi-dfNeR3Zc,48
-valetudo_map_parser/config/auto_crop.py,sha256=6OvRsWzXMXBaSEvgwpaaisNdozDKiDyTmPjknFxoUMc,12624
-valetudo_map_parser/config/colors.py,sha256=IzTT9JvF12YGGJxaTiEJRuwUdCCsFCLzsR9seCDfYWs,6515
-valetudo_map_parser/config/colors_man.py,sha256=9b5c6XmpMzhEiunwfIjVkOk1lDyV-UFoasACdkGXfbo,7833
-valetudo_map_parser/config/drawable.py,sha256=kTqAC6MKvUe5KbncuHpqnILxtkdxkpU_vESPdbAVXVs,18419
-valetudo_map_parser/config/drawable_elements.py,sha256=KzXKxJjsNf06e-cUVatSX5uwsn9OkGEIlOq7Li3n9aA,12119
-valetudo_map_parser/config/enhanced_drawable.py,sha256=ehn0mXdpzHLQEamHE2rBdRv_xXWwfd9gvM5ndgDnoMQ,16825
-valetudo_map_parser/config/rand25_parser.py,sha256=kIayyqVZBfQfAMkiArzqrrj9vqZB3pkgT0Y5ufrQmGA,16448
-valetudo_map_parser/config/shared.py,sha256=GIEMF-M6BVA6SFBrql7chV7TciWNMLJ8geqwHB0NrW8,11253
-valetudo_map_parser/config/types.py,sha256=uEJY-yYHHJWW3EZjg7hERSFrC2XuKzzRGT3C0z31Aw0,18359
-valetudo_map_parser/config/utils.py,sha256=RJ5GI4sSyMJN8JVi1mafDZ3DX2IUBuR2bKjLpH_bNp4,33368
-valetudo_map_parser/hypfer_draw.py,sha256=HymZVqRrvoIUt5MVWYp4jzY5KD9U_U5F8f82SWXoO58,20042
-valetudo_map_parser/hypfer_handler.py,sha256=M-rIoXMcqYYsWw0iGulEeXGDi-a9K8KLUa8IMBxdZ9M,28164
-valetudo_map_parser/map_data.py,sha256=6FbQfgxFB6E4kcOWokReJOVSekVaE1kStyhTQhAhiOg,19469
-valetudo_map_parser/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-valetudo_map_parser/rand25_handler.py,sha256=pb7LOK-lWwMlrVevdwJbYoYhZ66IvBgOvihn9HD58fk,23964
-valetudo_map_parser/reimg_draw.py,sha256=V0JUASavKVnEtAhv7nOV4pjsRxZrNsjIUtctbKO8wvk,12507
-valetudo_map_parser-0.1.9b42.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
-valetudo_map_parser-0.1.9b42.dist-info/METADATA,sha256=fVRZ9WEb6Qnmktvv3jaqfmO2kuLhxJcTfgGFjx2yzxE,3289
-valetudo_map_parser-0.1.9b42.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
-valetudo_map_parser-0.1.9b42.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-valetudo_map_parser-0.1.9b42.dist-info/RECORD,,