valetudo-map-parser 0.1.9b43__py3-none-any.whl → 0.1.9b45__py3-none-any.whl

valetudo_map_parser/rand25_handler.py

@@ -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,18 +118,19 @@ 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(
         self, json_data: JsonType, destinations: JsonType
-    ) -> RoomsProperties:
+    ) -> tuple[RoomsProperties, Any, Any]:
         """Extract the room properties."""
         unsorted_id = RandImageData.get_rrm_segments_ids(json_data)
         size_x, size_y = RandImageData.get_rrm_image_size(json_data)
@@ -140,79 +150,88 @@ 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  # Return empty data for all three return values
+
+            # 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",
                 e,
                 exc_info=True,
             )
-            return None, None, None
+            return None, None, None  # Return empty data in case of error
 
     async def get_image_from_rrm(
         self,
@@ -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"],
@@ -417,7 +427,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
 
     async def get_rooms_attributes(
         self, destinations: JsonType = None
-    ) -> RoomsProperties:
+    ) -> tuple[RoomsProperties, Any, Any]:
         """Return the rooms attributes."""
         if self.room_propriety:
             return self.room_propriety
@@ -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/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.9b43.dist-info → valetudo_map_parser-0.1.9b45.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: valetudo-map-parser
-Version: 0.1.9b43
+Version: 0.1.9b45
 Summary: A Python library to parse Valetudo map data returning a PIL Image object.
 License: Apache-2.0
 Author: Sandro Cantarella
@@ -12,6 +12,7 @@ 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: 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.9b45.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=ARSijOKRY5M_o_Pm1gHODJn2WOj7QL8C2cUNR-0EKc0,9566
+valetudo_map_parser/config/colors_man.py,sha256=9b5c6XmpMzhEiunwfIjVkOk1lDyV-UFoasACdkGXfbo,7833
+valetudo_map_parser/config/drawable.py,sha256=gKh9hSHMxqAb4phoehR_X4lembbRrTfiMuQ0wWq_AsI,21800
+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=H4-vzv9cTJctq4RXin5V6L1uXy2rZYIQkd8gO4265NU,27260
+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=d5NXK4TH4mlkZ5dNmhqWHgL4FauEUmDFz2L8XeHsKhk,24656
+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.9b45.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
+valetudo_map_parser-0.1.9b45.dist-info/METADATA,sha256=9jDQzZXjZiha6PUbwpH9AUthH4SuY9PPXOm6mIGwSOY,3321
+valetudo_map_parser-0.1.9b45.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
+valetudo_map_parser-0.1.9b45.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+valetudo_map_parser-0.1.9b45.dist-info/RECORD,,

valetudo_map_parser-0.1.9b43.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=zRKa5r_mV67m_APWBN6VAtdi8D5aBwFthEgKeoFBa9w,19473
-valetudo_map_parser/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-valetudo_map_parser/rand25_handler.py,sha256=ia-cwVHUwkV8OMm36mvFJRBa7bsKFM9T7NrcpmILhYM,23968
-valetudo_map_parser/reimg_draw.py,sha256=1q8LkNTPHEA9Tsapc_JnVw51kpPYNhaBU-KmHkefCQY,12507
-valetudo_map_parser-0.1.9b43.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
-valetudo_map_parser-0.1.9b43.dist-info/METADATA,sha256=laAJsOpHGG3LppeMizLNoljVOfAnHXzbCdaXjr0NQYc,3289
-valetudo_map_parser-0.1.9b43.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
-valetudo_map_parser-0.1.9b43.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-valetudo_map_parser-0.1.9b43.dist-info/RECORD,,