valetudo-map-parser 0.1.9b56__py3-none-any.whl → 0.1.9b57__py3-none-any.whl

valetudo_map_parser/hypfer_handler.py

@@ -21,11 +21,13 @@ from .config.types import (
     Colors,
     RoomsProperties,
     RoomStore,
+    WebPBytes,
 )
 from .config.utils import (
     BaseHandler,
     initialize_drawing_config,
     manage_drawable_elements,
+    numpy_to_webp_bytes,
     prepare_resize_params,
 )
 from .hypfer_draw import ImageDraw as ImDraw
@@ -81,7 +83,11 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
             self.rooms_pos = []
             for room_id, room_data in room_properties.items():
                 self.rooms_pos.append(
-                    {"name": room_data["name"], "outline": room_data["outline"]}
+                    {
+                        "id": room_id,
+                        "name": room_data["name"],
+                        "outline": room_data["outline"],
+                    }
                 )
         else:
             LOGGER.debug("%s: Rooms data not available!", self.file_name)
@@ -92,12 +98,14 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
     async def async_get_image_from_json(
         self,
         m_json: json | None,
-    ) -> Image.Image | None:
+        return_webp: bool = False,
+    ) -> WebPBytes | Image.Image | None:
         """Get the image from the JSON data.
         It uses the ImageDraw class to draw some of the elements of the image.
         The robot itself will be drawn in this function as per some of the values are needed for other tasks.
         @param m_json: The JSON data to use to draw the image.
-        @return Image.Image: The image to display.
+        @param return_webp: If True, return WebP bytes; if False, return PIL Image (default).
+        @return WebPBytes | Image.Image: WebP bytes or PIL Image depending on return_webp parameter.
         """
         # Initialize the colors.
         colors: Colors = {
@@ -131,6 +139,8 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                 # Get the pixels size and layers from the JSON data
                 pixel_size = int(m_json["pixelSize"])
                 layers, active = self.data.find_layers(m_json["layers"], {}, [])
+                # Populate active_zones from the JSON data
+                self.active_zones = active
                 new_frame_hash = await self.calculate_array_hash(layers, active)
                 if self.frame_number == 0:
                     self.img_hash = new_frame_hash
@@ -240,20 +250,30 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
 
                     # Draw obstacles if enabled
                     if self.drawing_config.is_enabled(DrawableElement.OBSTACLE):
-                        img_np_array = await self.imd.async_draw_obstacle(
-                            img_np_array, entity_dict, colors["no_go"]
-                        )
+                        self.shared.obstacles_pos = self.data.get_obstacles(entity_dict)
+                        if self.shared.obstacles_pos:
+                            img_np_array = await self.imd.async_draw_obstacle(
+                                img_np_array, self.shared.obstacles_pos, colors["no_go"]
+                            )
                     # Robot and rooms position
                     if (room_id > 0) and not self.room_propriety:
                         self.room_propriety = await self.async_extract_room_properties(
                             self.json_data
                         )
-                        if self.rooms_pos and robot_position and robot_position_angle:
-                            self.robot_pos = await self.imd.async_get_robot_in_room(
-                                robot_x=(robot_position[0]),
-                                robot_y=(robot_position[1]),
-                                angle=robot_position_angle,
-                            )
+
+                    # Ensure room data is available for robot room detection (even if not extracted above)
+                    if not self.rooms_pos and not self.room_propriety:
+                        self.room_propriety = await self.async_extract_room_properties(
+                            self.json_data
+                        )
+
+                    # Always check robot position for zooming (moved outside the condition)
+                    if self.rooms_pos and robot_position and robot_position_angle:
+                        self.robot_pos = await self.imd.async_get_robot_in_room(
+                            robot_x=(robot_position[0]),
+                            robot_y=(robot_position[1]),
+                            angle=robot_position_angle,
+                        )
                     LOGGER.info("%s: Completed base Layers", self.file_name)
                     # Copy the new array in base layer.
                     self.img_base_layer = await self.async_copy_array(img_np_array)
@@ -332,6 +352,9 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                             robot_position,
                             DrawableElement.ROBOT,
                         )
+                # Synchronize zooming state from ImageDraw to handler before auto-crop
+                self.zooming = self.imd.img_h.zooming
+
                 # Resize the image
                 img_np_array = await self.async_auto_trim_and_zoom_image(
                     img_np_array,
@@ -345,16 +368,43 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                 LOGGER.warning("%s: Image array is None.", self.file_name)
                 return None
 
-            # Convert the numpy array to a PIL image
-            pil_img = Image.fromarray(img_np_array, mode="RGBA")
-            del img_np_array
-            # reduce the image size if the zoomed image is bigger then the original.
+            # Handle resizing if needed, then return based on format preference
             if self.check_zoom_and_aspect_ratio():
+                # Convert to PIL for resizing
+                pil_img = Image.fromarray(img_np_array, mode="RGBA")
+                del img_np_array
                 resize_params = prepare_resize_params(self, pil_img, False)
                 resized_image = await self.async_resize_images(resize_params)
-                return resized_image
-            LOGGER.debug("%s: Frame Completed.", self.file_name)
-            return pil_img
+
+                # Return WebP bytes or PIL Image based on parameter
+                if return_webp:
+                    from .config.utils import pil_to_webp_bytes
+                    webp_bytes = await pil_to_webp_bytes(
+                        resized_image,
+                        quality=90,
+                        lossless=False
+                    )
+                    return webp_bytes
+                else:
+                    return resized_image
+            else:
+                # Return WebP bytes or PIL Image based on parameter
+                if return_webp:
+                    # Convert directly from NumPy to WebP for better performance
+                    webp_bytes = await numpy_to_webp_bytes(
+                        img_np_array,
+                        quality=90,
+                        lossless=False
+                    )
+                    del img_np_array
+                    LOGGER.debug("%s: Frame Completed.", self.file_name)
+                    return webp_bytes
+                else:
+                    # Convert to PIL Image (original behavior)
+                    pil_img = Image.fromarray(img_np_array, mode="RGBA")
+                    del img_np_array
+                    LOGGER.debug("%s: Frame Completed.", self.file_name)
+                    return pil_img
         except (RuntimeError, RuntimeWarning) as e:
             LOGGER.warning(
                 "%s: Error %s during image creation.",

valetudo_map_parser/map_data.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 
 import numpy as np
 
-from .config.types import Colors, ImageSize, JsonType, NumpyArray
+from .config.types import ImageSize, JsonType
 
 
 class ImageData:
@@ -34,6 +34,30 @@ class ImageData:
     # list the specific Layers, Paths, Zones and Pints in the
     # Vacuums Json in parallel.
 
+    @staticmethod
+    def get_obstacles(entity_dict: dict) -> list:
+        """Get the obstacles positions from the entity data."""
+        try:
+            obstacle_data = entity_dict.get("obstacle")
+        except KeyError:
+            return []
+        obstacle_positions = []
+        if obstacle_data:
+            for obstacle in obstacle_data:
+                label = obstacle.get("metaData", {}).get("label")
+                points = obstacle.get("points", [])
+                image_id = obstacle.get("metaData", {}).get("id")
+
+                if label and points:
+                    obstacle_pos = {
+                        "label": label,
+                        "points": {"x": points[0], "y": points[1]},
+                        "id": image_id,
+                    }
+                    obstacle_positions.append(obstacle_pos)
+            return obstacle_positions
+        return []
+
     @staticmethod
     def find_layers(
         json_obj: JsonType, layer_dict: dict, active_list: list
@@ -284,7 +308,7 @@ class RandImageData:
         Return the calculated angle and original angle.
         """
         angle_c = round(json_data.get("robot_angle", 0))
-        angle = (360 - angle_c + 80) if angle_c < 0 else (180 - angle_c - 80)
+        angle = (360 - angle_c + 95) if angle_c < 0 else (180 - angle_c - 85)
         return angle % 360, json_data.get("robot_angle", 0)
 
     @staticmethod

valetudo_map_parser/{rand25_handler.py → rand256_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.b42
+Version: 0.1.9.a6
 """
 
 from __future__ import annotations
@@ -26,11 +26,13 @@ from .config.types import (
     RobotPosition,
     RoomsProperties,
     RoomStore,
+    WebPBytes,
 )
 from .config.utils import (
     BaseHandler,
     initialize_drawing_config,
     manage_drawable_elements,
+    numpy_to_webp_bytes,
     prepare_resize_params,
 )
 from .map_data import RandImageData
@@ -68,7 +70,9 @@ class ReImageHandler(BaseHandler, AutoCrop):
         self.active_zones = None  # Active zones
         self.file_name = self.shared.file_name  # File name
         self.imd = ImageDraw(self)  # Image Draw
-        self.rooms_handler = RandRoomsHandler(self.file_name, self.drawing_config)  # Room data handler
+        self.rooms_handler = RandRoomsHandler(
+            self.file_name, self.drawing_config
+        )  # Room data handler
 
     async def extract_room_properties(
         self, json_data: JsonType, destinations: JsonType
@@ -97,10 +101,17 @@ class ReImageHandler(BaseHandler, AutoCrop):
 
             # Update self.rooms_pos from room_properties for compatibility with other methods
             self.rooms_pos = []
+            room_ids = []  # Collect room IDs for shared.map_rooms
             for room_id, room_data in room_properties.items():
                 self.rooms_pos.append(
                     {"name": room_data["name"], "outline": room_data["outline"]}
                 )
+                # Store the room number (segment ID) for MQTT active zone mapping
+                room_ids.append(room_data["number"])
+
+            # Update shared.map_rooms with the room IDs for MQTT active zone mapping
+            self.shared.map_rooms = room_ids
+            _LOGGER.debug("Updated shared.map_rooms with room IDs: %s", room_ids)
 
             # get the zones and points data
             zone_properties = await self.async_zone_propriety(zones_data)
@@ -116,9 +127,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
                 _LOGGER.debug("Extracted data: %s", extracted_data)
             else:
                 self.rooms_pos = None
-                _LOGGER.debug(
-                    "%s: Rooms and Zones data not available!", self.file_name
-                )
+                _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())
@@ -135,8 +144,14 @@ class ReImageHandler(BaseHandler, AutoCrop):
         self,
         m_json: JsonType,  # json data
         destinations: None = None,  # MQTT destinations for labels
-    ) -> PilPNG or None:
-        """Generate Images from the json data."""
+        return_webp: bool = False,
+    ) -> WebPBytes | Image.Image | None:
+        """Generate Images from the json data.
+        @param m_json: The JSON data to use to draw the image.
+        @param destinations: MQTT destinations for labels (unused).
+        @param return_webp: If True, return WebP bytes; if False, return PIL Image (default).
+        @return WebPBytes | Image.Image: WebP bytes or PIL Image depending on return_webp parameter.
+        """
         colors: Colors = {
             name: self.shared.user_colors[idx] for idx, name in enumerate(COLORS)
         }
@@ -173,11 +188,21 @@ class ReImageHandler(BaseHandler, AutoCrop):
                     img_np_array, m_json, colors, robot_position, robot_position_angle
                 )
 
-                # Final adjustments
-                pil_img = Image.fromarray(img_np_array, mode="RGBA")
-                del img_np_array  # free memory
-
-                return await self._finalize_image(pil_img)
+                # Return WebP bytes or PIL Image based on parameter
+                if return_webp:
+                    # Convert directly to WebP bytes for better performance
+                    webp_bytes = await numpy_to_webp_bytes(
+                        img_np_array,
+                        quality=90,  # High quality for vacuum maps
+                        lossless=False  # Use lossy compression for smaller size
+                    )
+                    del img_np_array  # free memory
+                    return webp_bytes
+                else:
+                    # Convert to PIL Image (original behavior)
+                    pil_img = Image.fromarray(img_np_array, mode="RGBA")
+                    del img_np_array  # free memory
+                    return await self._finalize_image(pil_img)
 
         except (RuntimeError, RuntimeWarning) as e:
             _LOGGER.warning(
@@ -226,12 +251,18 @@ class ReImageHandler(BaseHandler, AutoCrop):
 
                 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,
-                        )
+
+                # Ensure room data is available for robot room detection (even if not extracted above)
+                if not self.rooms_pos and not self.room_propriety:
+                    self.room_propriety = await self.get_rooms_attributes(destinations)
+
+                # Always check robot position for zooming (fallback)
+                if self.rooms_pos and robot_position and not hasattr(self, "robot_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
@@ -242,6 +273,60 @@ class ReImageHandler(BaseHandler, AutoCrop):
                     size_x, size_y, background_color
                 )
                 self.img_base_layer = await self.async_copy_array(img_np_array)
+
+        # Check active zones BEFORE auto-crop to enable proper zoom functionality
+        # This needs to run on every frame, not just frame 0
+        if (
+            self.shared.image_auto_zoom
+            and self.shared.vacuum_state == "cleaning"
+            and robot_position
+            and destinations  # Check if we have destinations data for room extraction
+        ):
+            # Extract room data early if we have destinations
+            try:
+                temp_room_properties = (
+                    await self.rooms_handler.async_extract_room_properties(
+                        m_json, destinations
+                    )
+                )
+                if temp_room_properties:
+                    # Create temporary rooms_pos for robot room detection
+                    temp_rooms_pos = []
+                    for room_id, room_data in temp_room_properties.items():
+                        temp_rooms_pos.append(
+                            {"name": room_data["name"], "outline": room_data["outline"]}
+                        )
+
+                    # Store original rooms_pos and temporarily use the new one
+                    original_rooms_pos = self.rooms_pos
+                    self.rooms_pos = temp_rooms_pos
+
+                    # Perform robot room detection to check active zones
+                    robot_room_result = await self.async_get_robot_in_room(
+                        robot_position[0], robot_position[1], robot_position_angle
+                    )
+
+                    # Restore original rooms_pos
+                    self.rooms_pos = original_rooms_pos
+
+            except Exception as e:
+                _LOGGER.debug(
+                    "%s: Early room extraction failed: %s, falling back to robot-position zoom",
+                    self.file_name,
+                    e,
+                )
+                # Fallback to robot-position-based zoom if room extraction fails
+                if (
+                    self.shared.image_auto_zoom
+                    and self.shared.vacuum_state == "cleaning"
+                    and robot_position
+                ):
+                    self.zooming = True
+                    _LOGGER.debug(
+                        "%s: Enabling fallback robot-position-based zoom",
+                        self.file_name,
+                    )
+
         return self.img_base_layer, robot_position, robot_position_angle
 
     async def _draw_map_elements(
@@ -288,6 +373,33 @@ class ReImageHandler(BaseHandler, AutoCrop):
                 img_np_array, robot_position, robot_position_angle, robot_color
             )
 
+        # Store robot position for potential zoom function use
+        if robot_position:
+            self.robot_position = robot_position
+
+        # Check if Zoom should be enabled based on active zones
+        if (
+            self.shared.image_auto_zoom
+            and self.shared.vacuum_state == "cleaning"
+            and robot_position
+        ):
+            # For Rand256, we need to check active zones differently since room data is not available yet
+            # Use a simplified approach: enable zoom if any active zones are set
+            active_zones = self.shared.rand256_active_zone
+            if active_zones and any(zone for zone in active_zones):
+                self.zooming = True
+                _LOGGER.debug(
+                    "%s: Enabling zoom for Rand256 - active zones detected: %s",
+                    self.file_name,
+                    active_zones,
+                )
+            else:
+                self.zooming = False
+                _LOGGER.debug(
+                    "%s: Zoom disabled for Rand256 - no active zones set",
+                    self.file_name,
+                )
+
         img_np_array = await self.async_auto_trim_and_zoom_image(
             img_np_array,
             detect_colour=colors["background"],
@@ -390,22 +502,22 @@ class ReImageHandler(BaseHandler, AutoCrop):
                     self.active_zones = self.shared.rand256_active_zone
                     self.zooming = False
                     if self.active_zones and (
-                        self.robot_in_room["id"]
-                        in range(len(self.active_zones))
+                        self.robot_in_room["id"] in range(len(self.active_zones))
                     ):
-                        self.zooming = bool(
-                            self.active_zones[self.robot_in_room["id"]]
-                        )
+                        self.zooming = bool(self.active_zones[self.robot_in_room["id"]])
                     else:
                         self.zooming = False
                     return temp
             # Fallback to bounding box check if no outline data
-            elif all(
-                k in self.robot_in_room for k in ["left", "right", "up", "down"]
-            ):
+            elif all(k in self.robot_in_room for k in ["left", "right", "up", "down"]):
                 if (
-                    (self.robot_in_room["right"] <= int(robot_x) <= self.robot_in_room["left"])
-                    and (self.robot_in_room["up"] <= int(robot_y) <= self.robot_in_room["down"])
+                    self.robot_in_room["right"]
+                    <= int(robot_x)
+                    <= self.robot_in_room["left"]
+                ) and (
+                    self.robot_in_room["up"]
+                    <= int(robot_y)
+                    <= self.robot_in_room["down"]
                 ):
                     temp = {
                         "x": robot_x,
@@ -417,12 +529,9 @@ class ReImageHandler(BaseHandler, AutoCrop):
                     self.active_zones = self.shared.rand256_active_zone
                     self.zooming = False
                     if self.active_zones and (
-                        self.robot_in_room["id"]
-                        in range(len(self.active_zones))
+                        self.robot_in_room["id"] in range(len(self.active_zones))
                     ):
-                        self.zooming = bool(
-                            self.active_zones[self.robot_in_room["id"]]
-                        )
+                        self.zooming = bool(self.active_zones[self.robot_in_room["id"]])
                     else:
                         self.zooming = False
                     return temp
@@ -488,6 +597,16 @@ class ReImageHandler(BaseHandler, AutoCrop):
                         "angle": angle,
                         "in_room": self.robot_in_room["room"],
                     }
+
+                    # Handle active zones - Set zooming based on active zones
+                    self.active_zones = self.shared.rand256_active_zone
+                    if self.active_zones and (
+                        self.robot_in_room["id"] in range(len(self.active_zones))
+                    ):
+                        self.zooming = bool(self.active_zones[self.robot_in_room["id"]])
+                    else:
+                        self.zooming = False
+
                     _LOGGER.debug(
                         "%s is in %s room (polygon detection).",
                         self.file_name,

valetudo_map_parser/rooms_handler.py

@@ -19,6 +19,7 @@ from .config.types import LOGGER, RoomsProperties
 
 from .map_data import RandImageData, ImageData
 
+
 class RoomsHandler:
     """
     Handler for extracting and managing room data from Hipfer vacuum maps.
@@ -225,6 +226,7 @@ class RoomsHandler:
         LOGGER.debug("Room extraction Total time: %.3fs", total_time)
         return room_properties
 
+
 class RandRoomsHandler:
     """
     Handler for extracting and managing room data from Rand25 vacuum maps.
@@ -247,7 +249,9 @@ class RandRoomsHandler:
         """
         self.vacuum_id = vacuum_id
         self.drawing_config = drawing_config
-        self.current_json_data = None  # Will store the current JSON data being processed
+        self.current_json_data = (
+            None  # Will store the current JSON data being processed
+        )
         self.segment_data = None  # Segment data
         self.outlines = None  # Outlines data
 
@@ -467,4 +471,4 @@ class RandRoomsHandler:
         total_time = time.time() - start_total
         LOGGER.debug("Room extraction Total time: %.3fs", total_time)
 
-        return room_properties
+        return room_properties

{valetudo_map_parser-0.1.9b56.dist-info → valetudo_map_parser-0.1.9b57.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: valetudo-map-parser
-Version: 0.1.9b56
+Version: 0.1.9b57
 Summary: A Python library to parse Valetudo map data returning a PIL Image object.
 License: Apache-2.0
 Author: Sandro Cantarella

valetudo_map_parser-0.1.9b57.dist-info/RECORD

@@ -0,0 +1,26 @@
+valetudo_map_parser/__init__.py,sha256=XO_eJwFDyU7hXJ4tAa2zY-n-SM2_kmIGMWDKY3GcauY,1163
+valetudo_map_parser/config/__init__.py,sha256=DQ9plV3ZF_K25Dp5ZQHPDoG-40dQoJNdNi-dfNeR3Zc,48
+valetudo_map_parser/config/auto_crop.py,sha256=1TGjUSbVHV15_sx1iFsEBWwD5BnWHPjgGIuPAJB6aiY,19142
+valetudo_map_parser/config/color_utils.py,sha256=nXD6WeNmdFdoMxPDW-JFpjnxJSaZR1jX-ouNfrx6zvE,4502
+valetudo_map_parser/config/colors.py,sha256=DG-oPQoN5gsnwDbEsuFr8a0hRCxmbFHObWa4_5pr-70,29910
+valetudo_map_parser/config/drawable.py,sha256=2MeVHXqZuVuJk3eerMJYGwo25rVetHx3xB_vxecEFOQ,34168
+valetudo_map_parser/config/drawable_elements.py,sha256=o-5oiXmfqPwNQLzKIhkEcZD_A47rIU9E0CqKgWipxgc,11516
+valetudo_map_parser/config/enhanced_drawable.py,sha256=QlGxlUMVgECUXPtFwIslyjubWxQuhIixsRymWV3lEvk,12586
+valetudo_map_parser/config/optimized_element_map.py,sha256=52BCnkvVv9bre52LeVIfT8nhnEIpc0TuWTv1xcNu0Rk,15744
+valetudo_map_parser/config/rand25_parser.py,sha256=kIayyqVZBfQfAMkiArzqrrj9vqZB3pkgT0Y5ufrQmGA,16448
+valetudo_map_parser/config/shared.py,sha256=ogXR5qC2HuLJ3KgYc9KDozXzDQptd8nhvNc-CepN6S0,12301
+valetudo_map_parser/config/types.py,sha256=HO5fowAjbGmS2rEOFbFe7eFljvpfBr0fsvhcVRTByhI,17540
+valetudo_map_parser/config/utils.py,sha256=w8r53KcCgYNq7CoIziQ3ktJu8ESFit5TYza-7g8ndhE,31203
+valetudo_map_parser/hypfer_draw.py,sha256=Bi03FiYdxw2Kp8BwkggAkdKABNoNf-j7v7J-rER8tnQ,28953
+valetudo_map_parser/hypfer_handler.py,sha256=-tMYd1lMH6_l8ufQH1A95uAgbt2P-1YYTfNkl9NXAc8,22269
+valetudo_map_parser/hypfer_rooms_handler.py,sha256=NkpOA6Gdq-2D3lLAxvtNuuWMvPXHxeMY2TO5RZLSHlU,22652
+valetudo_map_parser/map_data.py,sha256=5DDT5ABJCMSaWd8YrMY9SG4uhD3Rga_F0DEBNNNPipc,18618
+valetudo_map_parser/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+valetudo_map_parser/rand256_handler.py,sha256=kLurqSQvmrweCrOpLT9oIuVKkQ_SmCXcRuSL4dDddO8,27893
+valetudo_map_parser/reimg_draw.py,sha256=1q8LkNTPHEA9Tsapc_JnVw51kpPYNhaBU-KmHkefCQY,12507
+valetudo_map_parser/rooms_handler.py,sha256=ovqQtAjauAqwUNPR0aX27P2zhheQmqfaFhDE3_AwYWk,17821
+valetudo_map_parser-0.1.9b57.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
+valetudo_map_parser-0.1.9b57.dist-info/METADATA,sha256=f2DJy0uFpMdGp1e0gsdG2OdpGzkB1A429ZKf2c49MOE,3321
+valetudo_map_parser-0.1.9b57.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
+valetudo_map_parser-0.1.9b57.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+valetudo_map_parser-0.1.9b57.dist-info/RECORD,,