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

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,12 +26,13 @@ from .config.types import (
     RobotPosition,
     RoomsProperties,
     RoomStore,
+    WebPBytes,
 )
 from .config.utils import (
     BaseHandler,
-    # async_extract_room_outline,
     initialize_drawing_config,
     manage_drawable_elements,
+    numpy_to_webp_bytes,
     prepare_resize_params,
 )
 from .map_data import RandImageData
@@ -69,39 +70,15 @@ 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
-
-    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)
-
-        # Always return a rectangular outline since element_map is removed
-        return [(min_x, min_y), (max_x, min_y), (max_x, max_y), (min_x, max_y)]
+        self.rooms_handler = RandRoomsHandler(
+            self.file_name, self.drawing_config
+        )  # Room data handler
 
     async def extract_room_properties(
         self, json_data: JsonType, destinations: JsonType
     ) -> RoomsProperties:
         """Extract the room properties."""
-        unsorted_id = RandImageData.get_rrm_segments_ids(json_data)
+        # unsorted_id = RandImageData.get_rrm_segments_ids(json_data)
         size_x, size_y = RandImageData.get_rrm_image_size(json_data)
         top, left = RandImageData.get_rrm_image_position(json_data)
         try:
@@ -124,11 +101,17 @@ class ReImageHandler(BaseHandler, AutoCrop):
 
             # Update self.rooms_pos from room_properties for compatibility with other methods
             self.rooms_pos = []
-            for room_id, props in room_properties.items():
-                self.rooms_pos.append({
-                    "name": props["name"],
-                    "corners": props["outline"],  # Use the enhanced outline
-                })
+            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)
@@ -144,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())
@@ -163,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)
         }
@@ -201,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(
@@ -254,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
@@ -270,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(
@@ -316,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"],
@@ -353,79 +437,196 @@ class ReImageHandler(BaseHandler, AutoCrop):
                 _LOGGER.debug("Got Rooms Attributes.")
         return self.room_propriety
 
+    @staticmethod
+    def point_in_polygon(x: int, y: int, polygon: list) -> bool:
+        """
+        Check if a point is inside a polygon using ray casting algorithm.
+        Enhanced version with better handling of edge cases.
+
+        Args:
+            x: X coordinate of the point
+            y: Y coordinate of the point
+            polygon: List of (x, y) tuples forming the polygon
+
+        Returns:
+            True if the point is inside the polygon, False otherwise
+        """
+        # Ensure we have a valid polygon with at least 3 points
+        if len(polygon) < 3:
+            return False
+
+        # Make sure the polygon is closed (last point equals first point)
+        if polygon[0] != polygon[-1]:
+            polygon = polygon + [polygon[0]]
+
+        # Use winding number algorithm for better accuracy
+        wn = 0  # Winding number counter
+
+        # Loop through all edges of the polygon
+        for i in range(len(polygon) - 1):  # Last vertex is first vertex
+            p1x, p1y = polygon[i]
+            p2x, p2y = polygon[i + 1]
+
+            # Test if a point is left/right/on the edge defined by two vertices
+            if p1y <= y:  # Start y <= P.y
+                if p2y > y:  # End y > P.y (upward crossing)
+                    # Point left of edge
+                    if ((p2x - p1x) * (y - p1y) - (x - p1x) * (p2y - p1y)) > 0:
+                        wn += 1  # Valid up intersect
+            else:  # Start y > P.y
+                if p2y <= y:  # End y <= P.y (downward crossing)
+                    # Point right of edge
+                    if ((p2x - p1x) * (y - p1y) - (x - p1x) * (p2y - p1y)) < 0:
+                        wn -= 1  # Valid down intersect
+
+        # If winding number is not 0, the point is inside the polygon
+        return wn != 0
+
     async def async_get_robot_in_room(
         self, robot_x: int, robot_y: int, angle: float
     ) -> RobotPosition:
         """Get the robot position and return in what room is."""
+        # First check if we already have a cached room and if the robot is still in it
+        if self.robot_in_room:
+            # If we have outline data, use point_in_polygon for accurate detection
+            if "outline" in self.robot_in_room:
+                outline = self.robot_in_room["outline"]
+                if self.point_in_polygon(int(robot_x), int(robot_y), outline):
+                    temp = {
+                        "x": robot_x,
+                        "y": robot_y,
+                        "angle": angle,
+                        "in_room": self.robot_in_room["room"],
+                    }
+                    # Handle active zones
+                    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.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"]):
+                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"]
+                ):
+                    temp = {
+                        "x": robot_x,
+                        "y": robot_y,
+                        "angle": angle,
+                        "in_room": self.robot_in_room["room"],
+                    }
+                    # Handle active zones
+                    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.zooming = bool(self.active_zones[self.robot_in_room["id"]])
+                    else:
+                        self.zooming = False
+                    return temp
+
+        # If we don't have a cached room or the robot is not in it, search all rooms
+        last_room = None
+        room_count = 0
+        if self.robot_in_room:
+            last_room = self.robot_in_room
 
-        def _check_robot_position(x: int, y: int) -> bool:
-            # Check if the robot coordinates are inside the room's corners
-            return (
-                self.robot_in_room["left"] >= x >= self.robot_in_room["right"]
-                and self.robot_in_room["up"] >= y >= self.robot_in_room["down"]
+        # Check if the robot is far outside the normal map boundaries
+        # This helps prevent false positives for points very far from any room
+        map_boundary = 50000  # Typical map size is around 25000-30000 units for Rand25
+        if abs(robot_x) > map_boundary or abs(robot_y) > map_boundary:
+            _LOGGER.debug(
+                "%s robot position (%s, %s) is far outside map boundaries.",
+                self.file_name,
+                robot_x,
+                robot_y,
             )
-
-        # If the robot coordinates are inside the room's
-        if self.robot_in_room and _check_robot_position(robot_x, robot_y):
+            self.robot_in_room = last_room
+            self.zooming = False
             temp = {
                 "x": robot_x,
                 "y": robot_y,
                 "angle": angle,
-                "in_room": self.robot_in_room["room"],
+                "in_room": last_room["room"] if last_room else "unknown",
             }
-            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))
-            ):  # issue #100 Index out of range
-                self.zooming = bool(self.active_zones[self.robot_in_room["id"]])
             return temp
-        # else we need to search and use the async method
-        _LOGGER.debug("%s Changed room.. searching..", self.file_name)
-        room_count = -1
-        last_room = None
 
-        # If no rooms data is available, return a default position
+        # Search through all rooms to find which one contains the robot
         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": "unknown"}
+            _LOGGER.debug(
+                "%s: No rooms data available for robot position detection.",
+                self.file_name,
+            )
+            self.robot_in_room = last_room
+            self.zooming = False
+            temp = {
+                "x": robot_x,
+                "y": robot_y,
+                "angle": angle,
+                "in_room": last_room["room"] if last_room else "unknown",
+            }
+            return temp
 
-        # If rooms data is available, search for the room
-        if self.robot_in_room:
-            last_room = self.robot_in_room
+        _LOGGER.debug("%s: Searching for robot in rooms...", self.file_name)
         for room in self.rooms_pos:
-            corners = room["corners"]
+            # Check if the room has an outline (polygon points)
+            if "outline" in room:
+                outline = room["outline"]
+                # Use point_in_polygon for accurate detection with complex shapes
+                if self.point_in_polygon(int(robot_x), int(robot_y), outline):
+                    # Robot is in this room
+                    self.robot_in_room = {
+                        "id": room_count,
+                        "room": str(room["name"]),
+                        "outline": outline,
+                    }
+                    temp = {
+                        "x": robot_x,
+                        "y": robot_y,
+                        "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,
+                        self.robot_in_room["room"],
+                    )
+                    return temp
             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
+
+        # Robot not found in any room
         _LOGGER.debug(
-            "%s: Not located within Camera Rooms coordinates.", self.file_name
+            "%s not located within any room coordinates.",
+            self.file_name,
         )
-        self.zooming = False
         self.robot_in_room = last_room
+        self.zooming = False
         temp = {
             "x": robot_x,
             "y": robot_y,
             "angle": angle,
-            "in_room": self.robot_in_room["room"] if self.robot_in_room else "unknown",
+            "in_room": last_room["room"] if last_room else "unknown",
         }
         return temp
 

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.9b55.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.9b55
+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,,