valetudo-map-parser 0.1.9b41__py3-none-any.whl → 0.1.9b43__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
@@ -11,9 +11,13 @@ import logging
 import uuid
 from typing import Any
 
+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.types import (
     COLORS,
     DEFAULT_IMAGE_SIZE,
@@ -48,6 +52,11 @@ class ReImageHandler(BaseHandler, AutoCrop):
         self.outlines = None  # Outlines data
         self.calibration_data = None  # Calibration data
         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.element_map = None  # Map of element codes
         self.go_to = None  # Go to position data
         self.img_base_layer = None  # Base image layer
         self.img_rotate = shared_data.image_rotate  # Image rotation
@@ -56,6 +65,59 @@ class ReImageHandler(BaseHandler, AutoCrop):
         self.file_name = self.shared.file_name  # File name
         self.imd = ImageDraw(self)  # Image Draw
 
+    async def extract_room_outline_from_map(self, room_id_int, pixels):
+        """Extract the outline of a room using the pixel data and element map.
+
+        Args:
+            room_id_int: The room ID as an integer
+            pixels: List of pixel coordinates in the format [[x, y, z], ...]
+
+        Returns:
+            List of points forming the outline of the room
+        """
+        # Calculate x and y min/max from compressed pixels for rectangular fallback
+        x_values = []
+        y_values = []
+        for x, y, _ in pixels:
+            x_values.append(x)
+            y_values.append(y)
+
+        if not x_values or not y_values:
+            return []
+
+        min_x, max_x = min(x_values), max(x_values)
+        min_y, max_y = min(y_values), max(y_values)
+
+        # If we don't have an element map, return a rectangular outline
+        if not hasattr(self, "element_map") or self.element_map is None:
+            # Return rectangular outline
+            return [(min_x, min_y), (max_x, min_y), (max_x, max_y), (min_x, max_y)]
+
+        # Create a binary mask for this room using the pixel data
+        # This is more reliable than using the element_map since we're directly using the pixel data
+        height, width = self.element_map.shape
+        room_mask = np.zeros((height, width), dtype=np.uint8)
+
+        # Fill the mask with room pixels using the pixel data
+        for x, y, _ in pixels:  # Using _ instead of z since z is unused
+            # Make sure we're within bounds
+            if 0 <= y < height and 0 <= x < width:
+                # Mark a pixel at this position
+                room_mask[y, x] = 1
+
+        # Debug log to check if we have any room pixels
+        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)
+        )
+
+        # 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
+        )
+
     async def extract_room_properties(
         self, json_data: JsonType, destinations: JsonType
     ) -> RoomsProperties:
@@ -88,7 +150,27 @@ class ReImageHandler(BaseHandler, AutoCrop):
                         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.
@@ -100,7 +182,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
                         )
                         room_properties[int(room_id)] = {
                             "number": int(room_id),
-                            "outline": corners,
+                            "outline": outline,
                             "name": name,
                             "x": (x_min + x_max) // 2,
                             "y": (y_min + y_max) // 2,
@@ -197,49 +279,120 @@ class ReImageHandler(BaseHandler, AutoCrop):
             robot_position,
             robot_position_angle,
         ) = await self.imd.async_get_robot_position(m_json)
+
         if self.frame_number == 0:
-            room_id, img_np_array = await self.imd.async_draw_base_layer(
-                m_json,
-                size_x,
-                size_y,
-                colors["wall"],
-                colors["zone_clean"],
-                colors["background"],
-                DEFAULT_PIXEL_SIZE,
-            )
-            _LOGGER.info("%s: Completed base Layers", self.file_name)
-            if (room_id > 0) and not self.room_propriety:
-                self.room_propriety = await self.get_rooms_attributes(destinations)
-                if self.rooms_pos:
-                    self.robot_pos = await self.async_get_robot_in_room(
-                        (robot_position[0] * 10),
-                        (robot_position[1] * 10),
-                        robot_position_angle,
-                    )
-            self.img_base_layer = await self.async_copy_array(img_np_array)
+            # Create element map for tracking what's drawn where
+            self.element_map = np.zeros((size_y, size_x), dtype=np.int32)
+            self.element_map[:] = DrawableElement.FLOOR
+
+            # Draw base layer if floor is enabled
+            if self.drawing_config.is_enabled(DrawableElement.FLOOR):
+                room_id, img_np_array = await self.imd.async_draw_base_layer(
+                    m_json,
+                    size_x,
+                    size_y,
+                    colors["wall"],
+                    colors["zone_clean"],
+                    colors["background"],
+                    DEFAULT_PIXEL_SIZE,
+                )
+                _LOGGER.info("%s: Completed base Layers", self.file_name)
+
+                # Update element map for rooms
+                if 0 < room_id <= 15:
+                    # This is a simplification - in a real implementation we would
+                    # need to identify the exact pixels that belong to each room
+                    pass
+
+                if room_id > 0 and not self.room_propriety:
+                    self.room_propriety = await self.get_rooms_attributes(destinations)
+                    if self.rooms_pos:
+                        self.robot_pos = await self.async_get_robot_in_room(
+                            (robot_position[0] * 10),
+                            (robot_position[1] * 10),
+                            robot_position_angle,
+                        )
+                self.img_base_layer = await self.async_copy_array(img_np_array)
+            else:
+                # If floor is disabled, create an empty image
+                background_color = self.drawing_config.get_property(
+                    DrawableElement.FLOOR, "color", colors["background"]
+                )
+                img_np_array = await self.draw.create_empty_image(
+                    size_x, size_y, background_color
+                )
+                self.img_base_layer = await self.async_copy_array(img_np_array)
         return self.img_base_layer, robot_position, robot_position_angle
 
     async def _draw_map_elements(
         self, img_np_array, m_json, colors, robot_position, robot_position_angle
     ):
-        img_np_array, self.charger_pos = await self.imd.async_draw_charger(
-            img_np_array, m_json, colors["charger"]
-        )
-        img_np_array = await self.imd.async_draw_zones(
-            m_json, img_np_array, colors["zone_clean"]
-        )
-        img_np_array = await self.imd.async_draw_virtual_restrictions(
-            m_json, img_np_array, colors["no_go"]
-        )
-        img_np_array = await self.imd.async_draw_path(
-            img_np_array, m_json, colors["move"]
-        )
-        img_np_array = await self.imd.async_draw_go_to_flag(
-            img_np_array, m_json, colors["go_to"]
-        )
-        img_np_array = await self.imd.async_draw_robot_on_map(
-            img_np_array, robot_position, robot_position_angle, colors["robot"]
-        )
+        # Create element map for tracking what's drawn where if it doesn't exist
+        if self.element_map is None:
+            self.element_map = np.zeros(
+                (img_np_array.shape[0], img_np_array.shape[1]), dtype=np.int32
+            )
+            self.element_map[:] = DrawableElement.FLOOR
+
+        # Draw charger if enabled
+        if self.drawing_config.is_enabled(DrawableElement.CHARGER):
+            img_np_array, self.charger_pos = await self.imd.async_draw_charger(
+                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
+
+        # Draw zones if enabled
+        if self.drawing_config.is_enabled(DrawableElement.RESTRICTED_AREA):
+            img_np_array = await self.imd.async_draw_zones(
+                m_json, img_np_array, colors["zone_clean"]
+            )
+
+        # Draw virtual restrictions if enabled
+        if self.drawing_config.is_enabled(DrawableElement.VIRTUAL_WALL):
+            img_np_array = await self.imd.async_draw_virtual_restrictions(
+                m_json, img_np_array, colors["no_go"]
+            )
+
+        # Draw path if enabled
+        if self.drawing_config.is_enabled(DrawableElement.PATH):
+            img_np_array = await self.imd.async_draw_path(
+                img_np_array, m_json, colors["move"]
+            )
+
+        # Draw go-to flag if enabled
+        if self.drawing_config.is_enabled(DrawableElement.GO_TO_TARGET):
+            img_np_array = await self.imd.async_draw_go_to_flag(
+                img_np_array, m_json, colors["go_to"]
+            )
+
+        # Draw robot if enabled
+        if robot_position and self.drawing_config.is_enabled(DrawableElement.ROBOT):
+            # Get robot color (allows for customization)
+            robot_color = self.drawing_config.get_property(
+                DrawableElement.ROBOT, "color", colors["robot"]
+            )
+
+            img_np_array = await self.imd.async_draw_robot_on_map(
+                img_np_array, robot_position, robot_position_angle, robot_color
+            )
+
+            # 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)
         img_np_array = await self.async_auto_trim_and_zoom_image(
             img_np_array,
             detect_colour=colors["background"],
@@ -371,3 +524,35 @@ class ReImageHandler(BaseHandler, AutoCrop):
                 self.calibration_data.append(calibration_point)
 
         return self.calibration_data
+
+    # Element selection methods
+    def enable_element(self, element_code: DrawableElement) -> None:
+        """Enable drawing of a specific element."""
+        self.drawing_config.enable_element(element_code)
+
+    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)
+
+    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)

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-0.1.9b43.dist-info/METADATA

@@ -0,0 +1,92 @@
+Metadata-Version: 2.3
+Name: valetudo-map-parser
+Version: 0.1.9b43
+Summary: A Python library to parse Valetudo map data returning a PIL Image object.
+License: Apache-2.0
+Author: Sandro Cantarella
+Author-email: gsca075@gmail.com
+Requires-Python: >=3.12
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: Pillow (>=10.3.0)
+Requires-Dist: numpy (>=1.26.4)
+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
+Project-URL: Repository, https://github.com/sca075/Python-package-valetudo-map-parser
+Description-Content-Type: text/markdown
+
+# Python-package-valetudo-map-parser
+
+---
+### What is it:
+❗This is an _unofficial_ project and is not created, maintained, or in any sense linked to [valetudo.cloud](https://valetudo.cloud)
+
+A Python library that converts Valetudo vacuum JSON map data into PIL (Python Imaging Library) images. This package is primarily developed for and used in the [MQTT Vacuum Camera](https://github.com/sca075/mqtt_vacuum_camera) project.
+
+---
+
+### Features:
+- Processes map data from Valetudo-compatible robot vacuums
+- Supports both Hypfer and Rand256 vacuum data formats
+- Renders comprehensive map visualizations including:
+  - Walls and obstacles
+  - Robot position and cleaning path
+  - Room segments and boundaries
+  - Cleaning zones
+  - Virtual restrictions
+  - LiDAR data
+- Provides auto-cropping and dynamic zooming
+- Supports image rotation and aspect ratio management
+- Enables custom color schemes
+- Handles multilingual labels
+- Implements thread-safe data sharing
+
+### Installation:
+```bash
+pip install valetudo_map_parser
+```
+
+### Requirements:
+- Python 3.12 or higher
+- Dependencies:
+  - Pillow (PIL) for image processing
+  - NumPy for array operations
+
+### Usage:
+The library is configured using a dictionary format. See our [sample code](https://github.com/sca075/Python-package-valetudo-map-parser/blob/main/tests/test.py) for implementation examples.
+
+Key functionalities:
+- Decodes raw data from Rand256 format
+- Processes JSON data from compatible vacuums
+- Returns Pillow PNG images
+- Provides calibration and room property extraction
+- Supports asynchronous operations
+
+### Development Status:
+Current version: 0.1.9.b41
+- Full functionality available in versions >= 0.1.9
+- Actively maintained and enhanced
+- Uses Poetry for dependency management
+- Implements comprehensive testing
+- Enforces code quality through ruff, isort, and pylint
+
+### Contributing:
+Contributions are welcome! You can help by:
+- Submitting code improvements
+- Enhancing documentation
+- Reporting issues
+- Suggesting new features
+
+### Disclaimer:
+This project is provided "as is" without warranty of any kind. Users assume all risks associated with its use.
+
+### License:
+Apache-2.0
+
+---
+For more information about Valetudo, visit [valetudo.cloud](https://valetudo.cloud)
+Integration with Home Assistant: [MQTT Vacuum Camera](https://github.com/sca075/mqtt_vacuum_camera)
+

valetudo_map_parser-0.1.9b43.dist-info/RECORD

@@ -0,0 +1,23 @@
+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,,

{valetudo_map_parser-0.1.9b41.dist-info → valetudo_map_parser-0.1.9b43.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.1
+Generator: poetry-core 2.1.2
 Root-Is-Purelib: true
 Tag: py3-none-any

valetudo_map_parser-0.1.9b41.dist-info/METADATA

@@ -1,47 +0,0 @@
-Metadata-Version: 2.3
-Name: valetudo-map-parser
-Version: 0.1.9b41
-Summary: A Python library to parse Valetudo map data returning a PIL Image object.
-License: Apache-2.0
-Author: Sandro Cantarella
-Author-email: gsca075@gmail.com
-Requires-Python: >=3.12
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: Pillow (>=10.3.0)
-Requires-Dist: numpy (>=1.26.4)
-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
-Project-URL: Repository, https://github.com/sca075/Python-package-valetudo-map-parser
-Description-Content-Type: text/markdown
-
-# Python-package-valetudo-map-parser
-#
-
----
-### What is it:
-❗This is an _unofficial_ project and is not created, maintained, or in any sense linked to [valetudo.cloud](https://valetudo.cloud)
-
-Library to Covert Valetudo's Vacuums Json data in a PIL image.
-
----
-
-It is developed and used in the [MQTT Vacuum Camera](https://github.com/sca075/mqtt_vacuum_camera).
-As python package this code relay on Pythons base and popular pakages such Pillow and Numpy.
-
-This library can be import by simply using ```pip install valetudo_map_parser```.
-
-- It is configured with a dictionary format (on GitHub repo test [sample code](https://github.com/sca075/Python-package-valetudo-map-parser/blob/main/tests/test.py)). 
-- It decodes Raw data provided from Rand256.
-- It provides functions to decode the json data provided from the vacuums.
-- It returns a Pillow PNG image.
-
-
-We are still working on the final release at current this library will be fully functional with >= v0.1.9. 
-
-Anyone can contribute to make this code batter, with code, docs or simply creating issues if any faced.
-In any cases please be aware that "as it is" of course apply if you decide to use it. 
-

valetudo_map_parser-0.1.9b41.dist-info/RECORD

@@ -1,21 +0,0 @@
-valetudo_map_parser/__init__.py,sha256=Wmd20bdI1btzMq-0x8NxGYWskTjdUmD-Fem9MTfziwU,810
-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=CNuNBn1LNWaL2N30tS4jNaJhD5zV4wfGxXOhu0uaMZk,17788
-valetudo_map_parser/config/rand25_parser.py,sha256=kIayyqVZBfQfAMkiArzqrrj9vqZB3pkgT0Y5ufrQmGA,16448
-valetudo_map_parser/config/shared.py,sha256=-3HPvFDu-31P14NLXxjZP1eaN1k-l7oYWWNHlRL7IeM,10142
-valetudo_map_parser/config/types.py,sha256=TAqFjELB7eZTFXq7kYvcgVqOcjprutRsuoQWPj54Rjc,18358
-valetudo_map_parser/config/utils.py,sha256=yPutV-FEQlDB2z3LhOOFznoprHCApF-zrQMiOtkcO-k,19198
-valetudo_map_parser/hypfer_draw.py,sha256=akeaReXXQJX2Xp4deC8fQoWpWmcKKPPBsFRNToEyZyc,14944
-valetudo_map_parser/hypfer_handler.py,sha256=f_1oG69BA94sjcZ8O9Y6A1H-YyEutbvERzqnwgremvg,13001
-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=UGRy-2IIgxZ880LlD95-vGrVdUREvM2iC1vbKhlh2eY,15249
-valetudo_map_parser/reimg_draw.py,sha256=V0JUASavKVnEtAhv7nOV4pjsRxZrNsjIUtctbKO8wvk,12507
-valetudo_map_parser-0.1.9b41.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
-valetudo_map_parser-0.1.9b41.dist-info/METADATA,sha256=GFf-n6q6CxlHAC7FctF6MumKEJjXFXQKUtgGQWN5FVQ,2093
-valetudo_map_parser-0.1.9b41.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
-valetudo_map_parser-0.1.9b41.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-valetudo_map_parser-0.1.9b41.dist-info/RECORD,,