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

valetudo_map_parser/rand25_handler.py

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

@@ -0,0 +1,92 @@
+Metadata-Version: 2.3
+Name: valetudo-map-parser
+Version: 0.1.9b42
+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.9b42.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=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,,

{valetudo_map_parser-0.1.9b41.dist-info → valetudo_map_parser-0.1.9b42.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,,