valetudo-map-parser 0.1.9b56__py3-none-any.whl → 0.1.9b58__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,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.9b58.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: valetudo-map-parser
-Version: 0.1.9b56
+Version: 0.1.9b58
 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.9b58.dist-info/RECORD

@@ -0,0 +1,27 @@
+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/rand256_parser.py,sha256=LU3y7XvRRQxVen9iwom0dOaDnJJvhZdg97NqOYRZFas,16279
+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=AY_x8iA4Lzl5m4LCJztahzwHU-fUPcyoJN9C_BeWST8,27894
+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.9b58.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
+valetudo_map_parser-0.1.9b58.dist-info/METADATA,sha256=XyH4mGr38kd2wMDzmm7kfKXTOgRr_MvVM8rIIxKKpDo,3321
+valetudo_map_parser-0.1.9b58.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
+valetudo_map_parser-0.1.9b58.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+valetudo_map_parser-0.1.9b58.dist-info/RECORD,,

valetudo_map_parser/config/room_outline.py

@@ -1,148 +0,0 @@
-"""
-Room Outline Extraction Utilities.
-Uses scipy for efficient room outline extraction.
-Version: 0.1.9
-"""
-
-from __future__ import annotations
-
-import numpy as np
-from scipy import ndimage
-
-from .types import LOGGER
-
-
-async def extract_room_outline_with_scipy(
-    room_mask, min_x, min_y, max_x, max_y, file_name=None, room_id=None
-):
-    """Extract a room outline using scipy for contour finding.
-
-    Args:
-        room_mask: Binary mask of the room (1 for room, 0 for non-room)
-        min_x, min_y, max_x, max_y: Bounding box coordinates
-        file_name: Optional file name for logging
-        room_id: Optional room ID for logging
-
-    Returns:
-        List of points forming the outline of the room
-    """
-    # If the mask is empty, return a rectangular outline
-    if np.sum(room_mask) == 0:
-        LOGGER.warning(
-            "%s: Empty room mask for room %s, using rectangular outline",
-            file_name or "RoomOutline",
-            str(room_id) if room_id is not None else "unknown",
-        )
-        return [(min_x, min_y), (max_x, min_y), (max_x, max_y), (min_x, max_y)]
-
-    # Use scipy to clean up the mask (remove noise, fill holes)
-    # Fill small holes
-    room_mask = ndimage.binary_fill_holes(room_mask).astype(np.uint8)
-
-    # Remove small objects
-    labeled_array, num_features = ndimage.label(room_mask)
-    if num_features > 1:
-        # Find the largest connected component
-        component_sizes = np.bincount(labeled_array.ravel())[1:]
-        largest_component = np.argmax(component_sizes) + 1
-        room_mask = (labeled_array == largest_component).astype(np.uint8)
-
-    # Find the boundary points by tracing the perimeter
-    boundary_points = []
-    height, width = room_mask.shape
-
-    # Scan horizontally (top and bottom edges)
-    for x in range(width):
-        # Top edge
-        for y in range(height):
-            if room_mask[y, x] == 1:
-                boundary_points.append((x + min_x, y + min_y))
-                break
-
-        # Bottom edge
-        for y in range(height - 1, -1, -1):
-            if room_mask[y, x] == 1:
-                boundary_points.append((x + min_x, y + min_y))
-                break
-
-    # Scan vertically (left and right edges)
-    for y in range(height):
-        # Left edge
-        for x in range(width):
-            if room_mask[y, x] == 1:
-                boundary_points.append((x + min_x, y + min_y))
-                break
-
-        # Right edge
-        for x in range(width - 1, -1, -1):
-            if room_mask[y, x] == 1:
-                boundary_points.append((x + min_x, y + min_y))
-                break
-
-    # Remove duplicates while preserving order
-    unique_points = []
-    for point in boundary_points:
-        if point not in unique_points:
-            unique_points.append(point)
-
-    # If we have too few points, return a simple rectangle
-    if len(unique_points) < 4:
-        LOGGER.warning(
-            "%s: Too few boundary points for room %s, using rectangular outline",
-            file_name or "RoomOutline",
-            str(room_id) if room_id is not None else "unknown",
-        )
-        return [(min_x, min_y), (max_x, min_y), (max_x, max_y), (min_x, max_y)]
-
-    # Simplify the outline by keeping only significant points
-    simplified = simplify_outline(unique_points, tolerance=5)
-
-    LOGGER.debug(
-        "%s: Extracted outline for room %s with %d points",
-        file_name or "RoomOutline",
-        str(room_id) if room_id is not None else "unknown",
-        len(simplified),
-    )
-
-    return simplified
-
-
-def simplify_outline(points, tolerance=5):
-    """Simplify an outline by removing points that don't contribute much to the shape."""
-    if len(points) <= 4:
-        return points
-
-    # Start with the first point
-    simplified = [points[0]]
-
-    # Process remaining points
-    for i in range(1, len(points) - 1):
-        # Get previous and next points
-        prev = simplified[-1]
-        current = points[i]
-        next_point = points[i + 1]
-
-        # Calculate vectors
-        v1 = (current[0] - prev[0], current[1] - prev[1])
-        v2 = (next_point[0] - current[0], next_point[1] - current[1])
-
-        # Calculate change in direction
-        dot_product = v1[0] * v2[0] + v1[1] * v2[1]
-        len_v1 = (v1[0] ** 2 + v1[1] ** 2) ** 0.5
-        len_v2 = (v2[0] ** 2 + v2[1] ** 2) ** 0.5
-
-        # Avoid division by zero
-        if len_v1 == 0 or len_v2 == 0:
-            continue
-
-        # Calculate cosine of angle between vectors
-        cos_angle = dot_product / (len_v1 * len_v2)
-
-        # If angle is significant or distance is large, keep the point
-        if abs(cos_angle) < 0.95 or len_v1 > tolerance or len_v2 > tolerance:
-            simplified.append(current)
-
-    # Add the last point
-    simplified.append(points[-1])
-
-    return simplified

valetudo_map_parser-0.1.9b56.dist-info/RECORD

@@ -1,27 +0,0 @@
-valetudo_map_parser/__init__.py,sha256=Fz-gtKf_OlZcDQqVfGlBwIWi5DJAiRucMbBMdQ2tX_U,1060
-valetudo_map_parser/config/__init__.py,sha256=DQ9plV3ZF_K25Dp5ZQHPDoG-40dQoJNdNi-dfNeR3Zc,48
-valetudo_map_parser/config/auto_crop.py,sha256=6xt_wJQqphddWhlrr7MNUkodCi8ZYdRk42qvAaxlYCM,13546
-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/room_outline.py,sha256=D20D-yeyKnlmVbW9lI7bsPtQGn2XkcWow6YNOEPnWVg,4800
-valetudo_map_parser/config/shared.py,sha256=Vr4bicL7aJoRQbwbXyjEpiWhfzZ-cakLlfRqL3LBhpM,10475
-valetudo_map_parser/config/types.py,sha256=TaRKoo7G7WIUw7ljOz2Vn5oYzKaLyQH-7Eb8ZYql8Ls,17464
-valetudo_map_parser/config/utils.py,sha256=CFuuiS5IufEu9aeaZwi7xa1jEF1z6yDZB0mcyVX79Xo,29261
-valetudo_map_parser/hypfer_draw.py,sha256=bwNTYopTJFY0nElrHquQrSfGHgN_-6t5E-8xBxDsRXA,26660
-valetudo_map_parser/hypfer_handler.py,sha256=wvkZt6MsUF0gkHZDAwiUgOOawkdvakRzYBV3NtjxuJQ,19938
-valetudo_map_parser/hypfer_rooms_handler.py,sha256=NkpOA6Gdq-2D3lLAxvtNuuWMvPXHxeMY2TO5RZLSHlU,22652
-valetudo_map_parser/map_data.py,sha256=zQKE8EzWxR0r0qyfD1QQq51T1wFrpcIeXtnpm92-LXQ,17743
-valetudo_map_parser/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-valetudo_map_parser/rand25_handler.py,sha256=GpY9R9EGWM06KYF4VQ1NxYw0idaJ8lZNkkA5wa0cr-c,22292
-valetudo_map_parser/reimg_draw.py,sha256=1q8LkNTPHEA9Tsapc_JnVw51kpPYNhaBU-KmHkefCQY,12507
-valetudo_map_parser/rooms_handler.py,sha256=YP8OLotBH-RXluv398l7TTT2zIBHJp91b8THWxl3NdI,17794
-valetudo_map_parser-0.1.9b56.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
-valetudo_map_parser-0.1.9b56.dist-info/METADATA,sha256=LJXXb676sSJ9W7NGafpcJSF4CRGGhbg_lCyrzcxkge0,3321
-valetudo_map_parser-0.1.9b56.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
-valetudo_map_parser-0.1.9b56.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-valetudo_map_parser-0.1.9b56.dist-info/RECORD,,