valetudo-map-parser 0.1.9b49__py3-none-any.whl → 0.1.9b51__py3-none-any.whl

valetudo_map_parser/hypfer_rooms_handler.py

@@ -0,0 +1,406 @@
+"""
+Hipfer Rooms Handler Module.
+Handles room data extraction and processing for Valetudo Hipfer vacuum maps.
+Provides async methods for room outline extraction and properties management.
+Version: 0.1.9
+"""
+
+from __future__ import annotations
+
+from math import sqrt
+from typing import Any, Dict, Optional, List, Tuple
+
+import numpy as np
+
+from .config.drawable_elements import DrawableElement, DrawingConfig
+from .config.types import LOGGER, RoomsProperties, RoomStore
+
+
+class HypferRoomsHandler:
+    """
+    Handler for extracting and managing room data from Hipfer vacuum maps.
+
+    This class provides methods to:
+    - Extract room outlines using the Ramer-Douglas-Peucker algorithm
+    - Process room properties from JSON data
+    - Generate room masks and extract contours
+
+    All methods are async for better integration with the rest of the codebase.
+    """
+
+    def __init__(self, vacuum_id: str, drawing_config: Optional[DrawingConfig] = None):
+        """
+        Initialize the HipferRoomsHandler.
+
+        Args:
+            vacuum_id: Identifier for the vacuum
+            drawing_config: Configuration for which elements to draw (optional)
+        """
+        self.vacuum_id = vacuum_id
+        self.drawing_config = drawing_config
+
+    @staticmethod
+    def sublist(data: list, chunk_size: int) -> list:
+        return [data[i : i + chunk_size] for i in range(0, len(data), chunk_size)]
+
+    @staticmethod
+    def perpendicular_distance(
+        point: tuple[int, int], line_start: tuple[int, int], line_end: tuple[int, int]
+    ) -> float:
+        """Calculate the perpendicular distance from a point to a line."""
+        if line_start == line_end:
+            return sqrt(
+                (point[0] - line_start[0]) ** 2 + (point[1] - line_start[1]) ** 2
+            )
+
+        x, y = point
+        x1, y1 = line_start
+        x2, y2 = line_end
+
+        # Calculate the line length
+        line_length = sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
+        if line_length == 0:
+            return 0
+
+        # Calculate the distance from the point to the line
+        return abs((y2 - y1) * x - (x2 - x1) * y + x2 * y1 - y2 * x1) / line_length
+
+    async def rdp(
+        self, points: List[Tuple[int, int]], epsilon: float
+    ) -> List[Tuple[int, int]]:
+        """Ramer-Douglas-Peucker algorithm for simplifying a curve."""
+        if len(points) <= 2:
+            return points
+
+        # Find the point with the maximum distance
+        dmax = 0
+        index = 0
+        for i in range(1, len(points) - 1):
+            d = self.perpendicular_distance(points[i], points[0], points[-1])
+            if d > dmax:
+                index = i
+                dmax = d
+
+        # If max distance is greater than epsilon, recursively simplify
+        if dmax > epsilon:
+            # Recursive call
+            first_segment = await self.rdp(points[: index + 1], epsilon)
+            second_segment = await self.rdp(points[index:], epsilon)
+
+            # Build the result list (avoiding duplicating the common point)
+            return first_segment[:-1] + second_segment
+        else:
+            return [points[0], points[-1]]
+
+    async def async_get_corners(
+        self, mask: np.ndarray, epsilon_factor: float = 0.05
+    ) -> List[Tuple[int, int]]:
+        """
+        Get the corners of a room shape as a list of (x, y) tuples.
+        Uses contour detection and Douglas-Peucker algorithm to simplify the contour.
+
+        Args:
+            mask: Binary mask of the room (1 for room, 0 for background)
+            epsilon_factor: Controls the level of simplification (higher = fewer points)
+
+        Returns:
+            List of (x, y) tuples representing the corners of the room
+        """
+        # Find contours in the mask
+        contour = await self.async_moore_neighbor_trace(mask)
+
+        if not contour:
+            # Fallback to bounding box if contour detection fails
+            y_indices, x_indices = np.where(mask > 0)
+            if len(x_indices) == 0 or len(y_indices) == 0:
+                return []
+
+            x_min, x_max = np.min(x_indices), np.max(x_indices)
+            y_min, y_max = np.min(y_indices), np.max(y_indices)
+
+            return [
+                (x_min, y_min),  # Top-left
+                (x_max, y_min),  # Top-right
+                (x_max, y_max),  # Bottom-right
+                (x_min, y_max),  # Bottom-left
+                (x_min, y_min),  # Back to top-left to close the polygon
+            ]
+
+        # Calculate the perimeter of the contour
+        perimeter = 0
+        for i in range(len(contour) - 1):
+            x1, y1 = contour[i]
+            x2, y2 = contour[i + 1]
+            perimeter += np.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
+
+        # Apply Douglas-Peucker algorithm to simplify the contour
+        epsilon = epsilon_factor * perimeter
+        simplified_contour = await self.rdp(contour, epsilon=epsilon)
+
+        # Ensure the contour has at least 3 points to form a polygon
+        if len(simplified_contour) < 3:
+            # Fallback to bounding box
+            y_indices, x_indices = np.where(mask > 0)
+            x_min, x_max = int(np.min(x_indices)), int(np.max(x_indices))
+            y_min, y_max = int(np.min(y_indices)), int(np.max(y_indices))
+
+            LOGGER.debug(
+                f"{self.vacuum_id}: Too few points in contour, using bounding box"
+            )
+            return [
+                (x_min, y_min),  # Top-left
+                (x_max, y_min),  # Top-right
+                (x_max, y_max),  # Bottom-right
+                (x_min, y_max),  # Bottom-left
+                (x_min, y_min),  # Back to top-left to close the polygon
+            ]
+
+        # Ensure the contour is closed
+        if simplified_contour[0] != simplified_contour[-1]:
+            simplified_contour.append(simplified_contour[0])
+
+        return simplified_contour
+
+    @staticmethod
+    async def async_moore_neighbor_trace(mask: np.ndarray) -> List[Tuple[int, int]]:
+        """
+        Trace the contour of a binary mask using an optimized Moore-Neighbor tracing.
+
+        Args:
+            mask: Binary mask of the room (1 for room, 0 for background)
+
+        Returns:
+            List of (x, y) tuples representing the contour
+        """
+        # Convert to uint8 and pad
+        padded = np.pad(mask.astype(np.uint8), 1, mode="constant")
+        height, width = padded.shape
+
+        # Find the first non-zero point efficiently (scan row by row)
+        # This is much faster than np.argwhere() for large arrays
+        start = None
+        for y in range(height):
+            # Use NumPy's any() to quickly check if there are any 1s in this row
+            if np.any(padded[y]):
+                # Find the first 1 in this row
+                x = np.where(padded[y] == 1)[0][0]
+                start = (int(x), int(y))
+                break
+
+        if start is None:
+            return []
+
+        # Pre-compute directions
+        directions = [
+            (-1, -1),
+            (-1, 0),
+            (-1, 1),
+            (0, 1),
+            (1, 1),
+            (1, 0),
+            (1, -1),
+            (0, -1),
+        ]
+
+        # Use a 2D array for visited tracking (faster than set)
+        visited = np.zeros((height, width), dtype=bool)
+
+        # Initialize contour
+        contour = []
+        contour.append((int(start[0] - 1), int(start[1] - 1)))  # Adjust for padding
+
+        current = start
+        prev_dir = 7
+        visited[current[1], current[0]] = True
+
+        # Main tracing loop
+        while True:
+            found = False
+
+            # Check all 8 directions
+            for i in range(8):
+                dir_idx = (prev_dir + i) % 8
+                dx, dy = directions[dir_idx]
+                nx, ny = current[0] + dx, current[1] + dy
+
+                # Bounds check and value check
+                if (
+                    0 <= ny < height
+                    and 0 <= nx < width
+                    and padded[ny, nx] == 1
+                    and not visited[ny, nx]
+                ):
+                    current = (nx, ny)
+                    visited[ny, nx] = True
+                    contour.append(
+                        (int(nx - 1), int(ny - 1))
+                    )  # Adjust for padding and convert to int
+                    prev_dir = (dir_idx + 5) % 8
+                    found = True
+                    break
+
+            # Check termination conditions
+            if not found or (
+                len(contour) > 3
+                and (int(current[0] - 1), int(current[1] - 1)) == contour[0]
+            ):
+                break
+
+        return contour
+
+    async def async_extract_room_properties(
+        self, json_data: Dict[str, Any]
+    ) -> RoomsProperties:
+        """
+        Extract room properties from the JSON data.
+
+        Args:
+            json_data: JSON data from the vacuum
+
+        Returns:
+            Dictionary of room properties
+        """
+        room_properties = {}
+        pixel_size = json_data.get("pixelSize", 5)
+        height = json_data["size"]["y"]
+        width = json_data["size"]["x"]
+        vacuum_id = self.vacuum_id
+        room_id_counter = 0
+
+        for layer in json_data.get("layers", []):
+            if layer.get("__class") == "MapLayer" and layer.get("type") == "segment":
+                meta_data = layer.get("metaData", {})
+                segment_id = meta_data.get("segmentId")
+                name = meta_data.get("name", f"Room {segment_id}")
+
+                # Check if this room is disabled in the drawing configuration
+                # The room_id_counter is 0-based, but DrawableElement.ROOM_X is 1-based
+                current_room_id = room_id_counter + 1
+                room_id_counter = (
+                    room_id_counter + 1
+                ) % 16  # Cycle room_id back to 0 after 15
+
+                if 1 <= current_room_id <= 15 and self.drawing_config is not None:
+                    room_element = getattr(
+                        DrawableElement, f"ROOM_{current_room_id}", None
+                    )
+                    if room_element and not self.drawing_config.is_enabled(
+                        room_element
+                    ):
+                        LOGGER.debug(
+                            "%s: Room %d is disabled and will be skipped",
+                            self.vacuum_id,
+                            current_room_id,
+                        )
+                        continue
+
+                compressed_pixels = layer.get("compressedPixels", [])
+                pixels = self.sublist(compressed_pixels, 3)
+
+                # Create a binary mask for the room
+                if not pixels:
+                    LOGGER.warning(f"Skipping segment {segment_id}: no pixels found")
+                    continue
+
+                mask = np.zeros((height, width), dtype=np.uint8)
+                for x, y, length in pixels:
+                    if 0 <= y < height and 0 <= x < width and x + length <= width:
+                        mask[y, x : x + length] = 1
+
+                # Find the room outline using the improved get_corners function
+                # Adjust epsilon_factor to control the level of simplification (higher = fewer points)
+                outline = await self.async_get_corners(mask, epsilon_factor=0.05)
+
+                if not outline:
+                    LOGGER.warning(
+                        f"Skipping segment {segment_id}: failed to generate outline"
+                    )
+                    continue
+
+                # Calculate the center of the room
+                xs, ys = zip(*outline)
+                x_min, x_max = min(xs), max(xs)
+                y_min, y_max = min(ys), max(ys)
+
+                # Scale coordinates by pixel_size
+                scaled_outline = [(x * pixel_size, y * pixel_size) for x, y in outline]
+
+                room_id = str(segment_id)
+                room_properties[room_id] = {
+                    "number": segment_id,
+                    "outline": scaled_outline,  # Already includes the closing point
+                    "name": name,
+                    "x": ((x_min + x_max) * pixel_size) // 2,
+                    "y": ((y_min + y_max) * pixel_size) // 2,
+                }
+
+        RoomStore(vacuum_id, room_properties)
+        return room_properties
+
+    async def get_room_at_position(
+        self, x: int, y: int, room_properties: Optional[RoomsProperties] = None
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Get the room at a specific position.
+
+        Args:
+            x: X coordinate
+            y: Y coordinate
+            room_properties: Room properties dictionary (optional)
+
+        Returns:
+            Room data dictionary or None if no room at position
+        """
+        if room_properties is None:
+            room_store = RoomStore(self.vacuum_id)
+            room_properties = room_store.get_rooms()
+
+        if not room_properties:
+            return None
+
+        for room_id, room_data in room_properties.items():
+            outline = room_data.get("outline", [])
+            if not outline or len(outline) < 3:
+                continue
+
+            # Check if point is inside the polygon
+            if self.point_in_polygon(x, y, outline):
+                return {
+                    "id": room_id,
+                    "name": room_data.get("name", f"Room {room_id}"),
+                    "x": room_data.get("x", 0),
+                    "y": room_data.get("y", 0),
+                }
+
+        return None
+
+    @staticmethod
+    def point_in_polygon(x: int, y: int, polygon: List[Tuple[int, int]]) -> bool:
+        """
+        Check if a point is inside a polygon using ray casting algorithm.
+
+        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
+        """
+        n = len(polygon)
+        inside = False
+
+        p1x, p1y = polygon[0]
+        xinters = None  # Initialize with default value
+        for i in range(1, n + 1):
+            p2x, p2y = polygon[i % n]
+            if y > min(p1y, p2y):
+                if y <= max(p1y, p2y):
+                    if x <= max(p1x, p2x):
+                        if p1y != p2y:
+                            xinters = (y - p1y) * (p2x - p1x) / (p2y - p1y) + p1x
+                        if p1x == p2x or x <= xinters:
+                            inside = not inside
+            p1x, p1y = p2x, p2y
+
+        return inside

valetudo_map_parser/map_data.py

@@ -16,36 +16,6 @@ from .config.types import Colors, ImageSize, JsonType, NumpyArray
 class ImageData:
     """Class to handle the image data."""
 
-    @staticmethod
-    async def async_extract_color_coordinates(
-        source_array: NumpyArray, search_for_colours_list: Colors
-    ) -> list:
-        """Search for specific colors in an image array and return their coordinates."""
-        # Initialize an empty list to store color and coordinates tuples
-        color_coordinates_list = []
-
-        # Iterate over the search_for_colours_list
-        for color_to_search in search_for_colours_list:
-            # Initialize an empty list to store coordinates for the current color
-            color_coordinates = []
-
-            # Iterate over the image array
-            for y in range(source_array.shape[0]):
-                for x in range(source_array.shape[1]):
-                    # Extract the pixel color at the current coordinates
-                    pixel_color = source_array[y, x]
-
-                    # Check if the current pixel color matches the color_to_search
-                    if np.all(pixel_color == color_to_search):
-                        # Record the coordinates for the current color
-                        color_coordinates.append((x, y))
-
-            # Append the color and its coordinates to the final list
-            color_coordinates_list.append((color_to_search, color_coordinates))
-
-        # Return the final list of color and coordinates tuples
-        return color_coordinates_list
-
     @staticmethod
     def sublist(lst, n):
         """Sub lists of specific n number of elements"""

valetudo_map_parser/rand25_handler.py

@@ -29,13 +29,10 @@ from .config.types import (
 )
 from .config.utils import (
     BaseHandler,
-    get_element_at_position,
-    get_room_at_position,
     initialize_drawing_config,
     manage_drawable_elements,
     prepare_resize_params,
     async_extract_room_outline,
-    update_element_map_with_robot,
 )
 from .map_data import RandImageData
 from .reimg_draw import ImageDraw
@@ -64,7 +61,6 @@ class ReImageHandler(BaseHandler, AutoCrop):
         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
@@ -96,36 +92,8 @@ class ReImageHandler(BaseHandler, AutoCrop):
         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
-        return await async_extract_room_outline(
-            room_mask, min_x, min_y, max_x, max_y, self.file_name, room_id_int
-        )
+        # 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)]
 
     async def extract_room_properties(
         self, json_data: JsonType, destinations: JsonType
@@ -322,20 +290,11 @@ class ReImageHandler(BaseHandler, AutoCrop):
     async def _draw_map_elements(
         self, img_np_array, m_json, colors, robot_position, robot_position_angle
     ):
-        # 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
-            self._update_element_map_for_charger()
 
         # Draw zones if enabled
         if self.drawing_config.is_enabled(DrawableElement.RESTRICTED_AREA):
@@ -372,10 +331,6 @@ class ReImageHandler(BaseHandler, AutoCrop):
                 img_np_array, robot_position, robot_position_angle, robot_color
             )
 
-            # Update element map for robot position
-            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"],
@@ -536,40 +491,3 @@ class ReImageHandler(BaseHandler, AutoCrop):
             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."""
-        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."""
-        return get_room_at_position(self.element_map, x, y, DrawableElement.ROOM_1)
-
-    def _update_element_map_for_charger(self):
-        """Helper method to update the element map for the charger position."""
-        if not self.charger_pos or self.element_map is None:
-            return
-
-        charger_radius = 15
-        # Handle both dictionary format {'x': x, 'y': y} and list format [x, y]
-        charger_x = (
-            self.charger_pos.get("x")
-            if isinstance(self.charger_pos, dict)
-            else self.charger_pos[0]
-        )
-        charger_y = (
-            self.charger_pos.get("y")
-            if isinstance(self.charger_pos, dict)
-            else self.charger_pos[1]
-        )
-
-        for dy in range(-charger_radius, charger_radius + 1):
-            for dx in range(-charger_radius, charger_radius + 1):
-                # Check if the point is within the circular charger area
-                if dx * dx + dy * dy <= charger_radius * charger_radius:
-                    cx, cy = int(charger_x + dx), int(charger_y + dy)
-                    # Check if the coordinates are within the element map bounds
-                    if (0 <= cy < self.element_map.shape[0]) and (
-                        0 <= cx < self.element_map.shape[1]
-                    ):
-                        self.element_map[cy, cx] = DrawableElement.CHARGER

{valetudo_map_parser-0.1.9b49.dist-info → valetudo_map_parser-0.1.9b51.dist-info}/METADATA

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

@@ -0,0 +1,26 @@
+valetudo_map_parser/__init__.py,sha256=cewtLadNSOg3X2Ts2SuG8mTJqo0ncsFRg_sQ4VkM4ow,1037
+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/color_utils.py,sha256=D4NXRhuPdQ7UDKM3vLNYR0HnACl9AB75EnfCp5tGliI,4502
+valetudo_map_parser/config/colors.py,sha256=5nk8QbNomv_WeE2rOLIswroGsxV4RZMd0slXrPlt-MY,29297
+valetudo_map_parser/config/drawable.py,sha256=VhaNK62EBCxcQdNg7-dyUNepsYX6IFzej3raOt7_rVU,34268
+valetudo_map_parser/config/drawable_elements.py,sha256=bkEwdbx1upt9vaPaqE_VR1rtwRsaiH-IVKc3mHNa8IY,12065
+valetudo_map_parser/config/enhanced_drawable.py,sha256=T6HCUNcXpnPH3mbjzi-pq5bbPOhebj7jLNS-qyDh0HM,12646
+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=GIEMF-M6BVA6SFBrql7chV7TciWNMLJ8geqwHB0NrW8,11253
+valetudo_map_parser/config/types.py,sha256=e-eZSwbPm3m5JfCDaKhnUFspmcRFSv74huxegkSBDXM,17566
+valetudo_map_parser/config/utils.py,sha256=RsMjpjVqNbkI502yhLiRaB0GjCADqmRRcz-TkC6zklQ,31073
+valetudo_map_parser/hypfer_draw.py,sha256=P8CrKysLaBb63ZArfqxN2Og6JCU6sPHPFHOte5noCGg,26654
+valetudo_map_parser/hypfer_handler.py,sha256=WYFrp-q5wBsy0cTcVQUCXXVGTtW30z2W2dYvjKz2el8,23292
+valetudo_map_parser/hypfer_rooms_handler.py,sha256=3QL8QZc6aMXxYn_L6gv1iL204I0rAzutWPVzc_4MfJ4,14505
+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=eLFX_gmGLaWQwvp8hVj8CgcNOfLsYNIdE1OLRcQy_yM,19988
+valetudo_map_parser/reimg_draw.py,sha256=1q8LkNTPHEA9Tsapc_JnVw51kpPYNhaBU-KmHkefCQY,12507
+valetudo_map_parser-0.1.9b51.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
+valetudo_map_parser-0.1.9b51.dist-info/METADATA,sha256=Nkc-krdlK7Kl1FdGVmWgZjfaEDSpidfKtWfW17G9M6s,3321
+valetudo_map_parser-0.1.9b51.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
+valetudo_map_parser-0.1.9b51.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+valetudo_map_parser-0.1.9b51.dist-info/RECORD,,

valetudo_map_parser-0.1.9b49.dist-info/RECORD

@@ -1,25 +0,0 @@
-valetudo_map_parser/__init__.py,sha256=SOxmq7LkS7eMa2N4atW7ZBbqhGEL7fpj6MsyXZpCMsk,958
-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/color_utils.py,sha256=pJ9Frx5aZ1W2XPJxNToBLIwSYNTIm4Tw_NMMfFrZSaM,1691
-valetudo_map_parser/config/colors.py,sha256=zF-6CGe6XA9wtnrWY8hBmqsMNOcL1x5tZY1G6evniQ0,30278
-valetudo_map_parser/config/drawable.py,sha256=9-7FBlzWDfr7d_yIeRWXlAxlRxRfKflxi4fTnC3hqjk,33785
-valetudo_map_parser/config/drawable_elements.py,sha256=Ulfgf8B4LuLCfx-FfmC7LrP8o9ll_Sncg9mR774_3KE,43140
-valetudo_map_parser/config/enhanced_drawable.py,sha256=xNgFUNccstP245VgLFEA9gjB3-VvlSAJSjRgSZ3YFL0,16641
-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=WSl5rYSiTqE6YGAiwi9RILMZIQdFZRzVS8DwqzTZBbw,11309
-valetudo_map_parser/config/types.py,sha256=uEJY-yYHHJWW3EZjg7hERSFrC2XuKzzRGT3C0z31Aw0,18359
-valetudo_map_parser/config/utils.py,sha256=MP5_s9VFSdDERymujvDuGB8nYCXVuJcqg5tR5H9HCgY,33167
-valetudo_map_parser/hypfer_draw.py,sha256=oL_RbX0LEcPvOlMrfBA38qpJkMqqVwR-oAEbZeHqLWM,19898
-valetudo_map_parser/hypfer_handler.py,sha256=-nwGlfd-fqmNAHEeQFgCarr1t5v8gJTvb2ngDz_8PbM,27616
-valetudo_map_parser/map_data.py,sha256=lSKD-CG-RENOcNUDnUIIpqh74DuGnLmrH46IF1_EjwQ,19117
-valetudo_map_parser/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-valetudo_map_parser/rand25_handler.py,sha256=F9o1J6JZRV3CZTS4CG3AHNHZweKRM0nzd4HLmdPZe4w,23617
-valetudo_map_parser/reimg_draw.py,sha256=1q8LkNTPHEA9Tsapc_JnVw51kpPYNhaBU-KmHkefCQY,12507
-valetudo_map_parser-0.1.9b49.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
-valetudo_map_parser-0.1.9b49.dist-info/METADATA,sha256=PjAsrik0PogFM7_ZKRYgwCBQl1-uOlc2nd5buY7WuOo,3321
-valetudo_map_parser-0.1.9b49.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
-valetudo_map_parser-0.1.9b49.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-valetudo_map_parser-0.1.9b49.dist-info/RECORD,,