valetudo-map-parser 0.1.11b2__py3-none-any.whl → 0.1.12b0__py3-none-any.whl

valetudo_map_parser/rand256_handler.py

@@ -15,10 +15,8 @@ from mvcrender.autocrop import AutoCrop
 
 from .config.async_utils import AsyncPIL
 from .config.drawable_elements import DrawableElement
+from .const import COLORS, DEFAULT_IMAGE_SIZE, DEFAULT_PIXEL_SIZE
 from .config.types import (
-    COLORS,
-    DEFAULT_IMAGE_SIZE,
-    DEFAULT_PIXEL_SIZE,
     LOGGER,
     Colors,
     Destinations,
@@ -50,6 +48,8 @@ class ReImageHandler(BaseHandler, AutoCrop):
         AutoCrop.__init__(self, self)
         self.auto_crop = None  # Auto crop flag
         self.segment_data = None  # Segment data
+        self.element_map = None  # Element map for tracking drawable elements
+        self.robot_position = None  # Robot position for zoom functionality
         self.outlines = None  # Outlines data
         self.calibration_data = None  # Calibration data
         self.data = RandImageData  # Image Data
@@ -86,7 +86,6 @@ class ReImageHandler(BaseHandler, AutoCrop):
                     json_data, size_x, size_y, top, left, True
                 )
 
-
             dest_json = destinations if destinations else {}
             zones_data = dest_json.get("zones", [])
             points_data = dest_json.get("spots", [])
@@ -98,7 +97,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
 
             # Update self.rooms_pos from room_properties for compatibility with other methods
             self.rooms_pos = []
-            for room_id, room_data in room_properties.items():
+            for _, room_data in room_properties.items():
                 self.rooms_pos.append(
                     {"name": room_data["name"], "outline": room_data["outline"]}
                 )
@@ -197,6 +196,94 @@ class ReImageHandler(BaseHandler, AutoCrop):
         # If we reach here without returning, return None
         return None
 
+    async def _initialize_base_layer(
+        self,
+        m_json,
+        size_x,
+        size_y,
+        colors,
+        destinations,
+        robot_position,
+        robot_position_angle,
+    ):
+        """Initialize the base layer on first frame."""
+        self.element_map = np.zeros((size_y, size_x), dtype=np.int32)
+        self.element_map[:] = DrawableElement.FLOOR
+
+        if self.drawing_config.is_enabled(DrawableElement.FLOOR):
+            room_id, img_np_array = await self.imd.async_draw_base_layer(
+                m_json,
+                size_x,
+                size_y,
+                colors["wall"],
+                colors["zone_clean"],
+                colors["background"],
+                DEFAULT_PIXEL_SIZE,
+            )
+            LOGGER.info("%s: Completed base Layers", self.file_name)
+
+            if room_id > 0 and not self.room_propriety:
+                self.room_propriety = await self.get_rooms_attributes(destinations)
+
+            if not self.rooms_pos and not self.room_propriety:
+                self.room_propriety = await self.get_rooms_attributes(destinations)
+
+            if (
+                self.rooms_pos
+                and robot_position
+                and (self.robot_pos is None or "in_room" not in self.robot_pos)
+            ):
+                self.robot_pos = await self.async_get_robot_in_room(
+                    (robot_position[0] * 10),
+                    (robot_position[1] * 10),
+                    robot_position_angle,
+                )
+        else:
+            background_color = self.drawing_config.get_property(
+                DrawableElement.FLOOR, "color", colors["background"]
+            )
+            img_np_array = await self.draw.create_empty_image(
+                size_x, size_y, background_color
+            )
+
+        if self.img_base_layer is not None:
+            del self.img_base_layer
+        self.img_base_layer = await self.async_copy_array(img_np_array)
+        del img_np_array
+
+    async def _check_zoom_conditions(self, m_json, robot_position, destinations):
+        """Check and set zoom conditions based on active zones."""
+        if not (
+            self.shared.image_auto_zoom
+            and self.shared.vacuum_state == "cleaning"
+            and robot_position
+            and destinations
+        ):
+            return
+
+        try:
+            temp_room_properties = (
+                await self.rooms_handler.async_extract_room_properties(
+                    m_json, destinations
+                )
+            )
+            if temp_room_properties:
+                temp_rooms_pos = []
+                for _, room_data in temp_room_properties.items():
+                    temp_rooms_pos.append(
+                        {"name": room_data["name"], "outline": room_data["outline"]}
+                    )
+                original_rooms_pos = self.rooms_pos
+                self.rooms_pos = temp_rooms_pos
+                self.rooms_pos = original_rooms_pos
+        except (ValueError, KeyError, TypeError):
+            if (
+                self.shared.image_auto_zoom
+                and self.shared.vacuum_state == "cleaning"
+                and robot_position
+            ):
+                self.zooming = True
+
     async def _setup_robot_and_image(
         self, m_json, size_x, size_y, colors, destinations
     ):
@@ -208,100 +295,17 @@ class ReImageHandler(BaseHandler, AutoCrop):
         ) = await self.imd.async_get_robot_position(m_json)
 
         if self.frame_number == 0:
-            # Create element map for tracking what's drawn where
-            self.element_map = np.zeros((size_y, size_x), dtype=np.int32)
-            self.element_map[:] = DrawableElement.FLOOR
-
-            # Draw base layer if floor is enabled
-            if self.drawing_config.is_enabled(DrawableElement.FLOOR):
-                room_id, img_np_array = await self.imd.async_draw_base_layer(
-                    m_json,
-                    size_x,
-                    size_y,
-                    colors["wall"],
-                    colors["zone_clean"],
-                    colors["background"],
-                    DEFAULT_PIXEL_SIZE,
-                )
-                LOGGER.info("%s: Completed base Layers", self.file_name)
-
-                if room_id > 0 and not self.room_propriety:
-                    self.room_propriety = await self.get_rooms_attributes(destinations)
+            await self._initialize_base_layer(
+                m_json,
+                size_x,
+                size_y,
+                colors,
+                destinations,
+                robot_position,
+                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 (update if room info is missing)
-                if (
-                    self.rooms_pos
-                    and robot_position
-                    and (self.robot_pos is None or "in_room" not in self.robot_pos)
-                ):
-                    self.robot_pos = await self.async_get_robot_in_room(
-                        (robot_position[0] * 10),
-                        (robot_position[1] * 10),
-                        robot_position_angle,
-                    )
-                # Delete old base layer before creating new one to free memory
-                if self.img_base_layer is not None:
-                    del self.img_base_layer
-                self.img_base_layer = await self.async_copy_array(img_np_array)
-                # Delete source array after copying to free memory
-                del img_np_array
-            else:
-                # If floor is disabled, create an empty image
-                background_color = self.drawing_config.get_property(
-                    DrawableElement.FLOOR, "color", colors["background"]
-                )
-                img_np_array = await self.draw.create_empty_image(
-                    size_x, size_y, background_color
-                )
-                # Delete old base layer before creating new one to free memory
-                if self.img_base_layer is not None:
-                    del self.img_base_layer
-                self.img_base_layer = await self.async_copy_array(img_np_array)
-                # Delete source array after copying to free memory
-                del 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
-
-                    # Restore original rooms_pos
-                    self.rooms_pos = original_rooms_pos
-
-            except (ValueError, KeyError, TypeError):
-                # 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
+        await self._check_zoom_conditions(m_json, robot_position, destinations)
 
         return self.img_base_layer, robot_position, robot_position_angle
 
@@ -403,139 +407,124 @@ class ReImageHandler(BaseHandler, AutoCrop):
             )
         return self.room_propriety
 
+    def _create_robot_position_dict(
+        self, robot_x: int, robot_y: int, angle: float, room_name: str
+    ) -> RobotPosition:
+        """Create a robot position dictionary."""
+        return {
+            "x": robot_x,
+            "y": robot_y,
+            "angle": angle,
+            "in_room": room_name,
+        }
+
+    def _set_zooming_from_active_zones(self) -> None:
+        """Set zooming based on 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"]])
+
+    def _check_cached_room_outline_rand(
+        self, robot_x: int, robot_y: int, angle: float
+    ) -> RobotPosition | None:
+        """Check if robot is still in cached room using outline."""
+        if "outline" in self.robot_in_room:
+            outline = self.robot_in_room["outline"]
+            if point_in_polygon(int(robot_x), int(robot_y), outline):
+                self._set_zooming_from_active_zones()
+                LOGGER.debug(
+                    "%s: Robot is in %s room (polygon detection). %s",
+                    self.file_name,
+                    self.robot_in_room["room"],
+                    self.active_zones,
+                )
+                return self._create_robot_position_dict(
+                    robot_x, robot_y, angle, self.robot_in_room["room"]
+                )
+        return None
+
+    def _check_cached_room_bbox_rand(
+        self, robot_x: int, robot_y: int, angle: float
+    ) -> RobotPosition | None:
+        """Check if robot is still in cached room using bounding box."""
+        if 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._set_zooming_from_active_zones()
+                return self._create_robot_position_dict(
+                    robot_x, robot_y, angle, self.robot_in_room["room"]
+                )
+        return None
+
+    def _check_room_with_outline_rand(
+        self, room: dict, room_count: int, robot_x: int, robot_y: int, angle: float
+    ) -> RobotPosition | None:
+        """Check if robot is in room using outline polygon."""
+        outline = room["outline"]
+        if point_in_polygon(int(robot_x), int(robot_y), outline):
+            self.robot_in_room = {
+                "id": room_count,
+                "room": str(room["name"]),
+                "outline": outline,
+            }
+            self._set_zooming_from_active_zones()
+            return self._create_robot_position_dict(
+                robot_x, robot_y, angle, self.robot_in_room["room"]
+            )
+        return None
+
     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 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
-                    LOGGER.debug(
-                        "%s: Robot is in %s room (polygon detection). %s",
-                        self.file_name,
-                        self.robot_in_room["room"],
-                        self.active_zones,
-                    )
-                    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
+        # Check cached room first
         if self.robot_in_room:
-            last_room = self.robot_in_room
-
-        # 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:
-            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
-
-        # Search through all rooms to find which one contains the robot
-        if not self.rooms_pos:
+            result = self._check_cached_room_outline_rand(robot_x, robot_y, angle)
+            if result:
+                return result
+            result = self._check_cached_room_bbox_rand(robot_x, robot_y, angle)
+            if result:
+                return result
+
+        # Prepare for room search
+        last_room = self.robot_in_room
+        map_boundary = 50000
+
+        # Check boundary conditions or missing room data
+        if (
+            abs(robot_x) > map_boundary
+            or abs(robot_y) > map_boundary
+            or not self.rooms_pos
+        ):
             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
+            return self._create_robot_position_dict(
+                robot_x, robot_y, angle, last_room["room"] if last_room else "unknown"
+            )
 
-        for room in self.rooms_pos:
-            # Check if the room has an outline (polygon points)
+        # Search through all rooms
+        for room_count, room in enumerate(self.rooms_pos):
             if "outline" in room:
-                outline = room["outline"]
-                # Use point_in_polygon for accurate detection with complex shapes
-                if 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
-
-                    return temp
-            room_count += 1
+                result = self._check_room_with_outline_rand(
+                    room, room_count, robot_x, robot_y, angle
+                )
+                if result:
+                    return result
 
         # Robot not found in any room
         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
+        return self._create_robot_position_dict(
+            robot_x, robot_y, angle, last_room["room"] if last_room else "unknown"
+        )
 
     def get_calibration_data(self, rotation_angle: int = 0) -> Any:
         """Return the map calibration data."""

valetudo_map_parser/rooms_handler.py

@@ -11,7 +11,7 @@ from typing import Any, Dict, List, Optional, Tuple
 
 import numpy as np
 from scipy.ndimage import binary_dilation, binary_erosion
-from scipy.spatial import ConvexHull
+from scipy.spatial import ConvexHull  # pylint: disable=no-name-in-module
 
 from .config.drawable_elements import DrawableElement, DrawingConfig
 from .config.types import LOGGER, RoomsProperties
@@ -83,7 +83,7 @@ class RoomsHandler:
         """
         meta_data = layer.get("metaData", {})
         segment_id = meta_data.get("segmentId")
-        name = meta_data.get("name", "Room {}".format(segment_id))
+        name = meta_data.get("name", f"Room {segment_id}")
         compressed_pixels = layer.get("compressedPixels", [])
         pixels = self.sublist(compressed_pixels, 3)
 
@@ -296,8 +296,8 @@ class RandRoomsHandler:
 
             return hull_points
 
-        except Exception as e:
-            LOGGER.warning(f"Error calculating convex hull: {e}")
+        except (ValueError, RuntimeError) as e:
+            LOGGER.warning("Error calculating convex hull: %s", e)
 
             # Fallback to bounding box if convex hull fails
             x_min, y_min = np.min(points_array, axis=0)
@@ -342,7 +342,6 @@ class RandRoomsHandler:
             except (ValueError, TypeError):
                 # If segment_id is not a valid integer, we can't map it to a room element
                 # In this case, we'll include the room (fail open)
-                pass
                 LOGGER.debug(
                     "Could not convert segment_id %s to room element", segment_id
                 )

{valetudo_map_parser-0.1.11b2.dist-info → valetudo_map_parser-0.1.12b0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: valetudo-map-parser
-Version: 0.1.11b2
+Version: 0.1.12b0
 Summary: A Python library to parse Valetudo map data returning a PIL Image object.
 License: Apache-2.0
 License-File: LICENSE

valetudo_map_parser-0.1.12b0.dist-info/RECORD

@@ -0,0 +1,34 @@
+valetudo_map_parser/__init__.py,sha256=hyQGLItlggmWjeUCey8pDm5EthPtRd8NBu7A3z5NJ-o,4297
+valetudo_map_parser/config/__init__.py,sha256=DQ9plV3ZF_K25Dp5ZQHPDoG-40dQoJNdNi-dfNeR3Zc,48
+valetudo_map_parser/config/async_utils.py,sha256=j1QnPvNQ3IkAeHRqDmbfibhminztWUvf5CW_d44P0mE,3215
+valetudo_map_parser/config/colors.py,sha256=XDjLRbbp9wbIB_9keRZ8x1KJVdmq724x1IpLFhIP9Jc,13589
+valetudo_map_parser/config/drawable.py,sha256=WbXvpHj713mQtuT3ZUS53sZip83j9jP9AtiGo31QUaI,21510
+valetudo_map_parser/config/drawable_elements.py,sha256=_iHdAuzbAoIOeT8JEZrvSu5fVojIdhAyH5ABUVi-x3Y,11496
+valetudo_map_parser/config/fonts/FiraSans.ttf,sha256=Pavz1Iv0WZ-Vz_2S-Z6kJqAU1TEfUqXrXsOvJl6XzZc,440984
+valetudo_map_parser/config/fonts/Inter-VF.ttf,sha256=zzy0OwNm4txt9g4RMrHJpMFXd_DNjlpT4MFRJAA-ntQ,804612
+valetudo_map_parser/config/fonts/Lato-Regular.ttf,sha256=6CVCrtgpP0n8g8Sq6lZrH2tPx6mrXaEeb7m8CXO1Mks,75152
+valetudo_map_parser/config/fonts/MPLUSRegular.ttf,sha256=IGdcNSRP4dDxQskbE3Ybuwz7T0flhCBuzwfhLMcPt9s,3380812
+valetudo_map_parser/config/fonts/NotoKufiArabic-VF.ttf,sha256=NaIy40eLx7d3ts0kuenp0GjWd-YN24J6DpSvX2L3vLA,433800
+valetudo_map_parser/config/fonts/NotoSansCJKhk-VF.ttf,sha256=xIXXLKCJzmWoPEg8HdvxeRgotMjjxF6l6ugGP-IWRJU,36135040
+valetudo_map_parser/config/fonts/NotoSansKhojki.ttf,sha256=XJWzSmpN-Ql6jTfTvFojP_JkCHOztQvixQc1_7hPWrc,107388
+valetudo_map_parser/config/optimized_element_map.py,sha256=52BCnkvVv9bre52LeVIfT8nhnEIpc0TuWTv1xcNu0Rk,15744
+valetudo_map_parser/config/rand256_parser.py,sha256=u9JmYa3_ZJXhHV_vPNRLcR1myGHW132oMwhNkb633t8,21099
+valetudo_map_parser/config/shared.py,sha256=6r0s0jOuz1LBjgMVicI17IE6wA8pEnNQl3jdFHS-_lM,12542
+valetudo_map_parser/config/status_text/__init__.py,sha256=iG45LWQ5HCkQOT56eG_S4Eii_DAnQB-CqhYc66eN-BU,164
+valetudo_map_parser/config/status_text/status_text.py,sha256=2ZGTPWL4Dc9TVAE8dVrPkqAgFSVoa7BD55DdewzEO_Q,4920
+valetudo_map_parser/config/status_text/translations.py,sha256=mmPbJkl_2A59w49wnesQf3ocXqwZxBsrqNX-yt5FSCQ,9132
+valetudo_map_parser/config/types.py,sha256=BSHCVXYXCDS6WkKXeJgmFJ2aXppgABqZKAc9-DgkwOU,10158
+valetudo_map_parser/config/utils.py,sha256=_SKSJZQC4uE5UlHrfKfaKUwsk2nSe_fI6zSbOooL2tY,36381
+valetudo_map_parser/const.py,sha256=-0jl5ZLMgjgU6sHmPkWJE2pYgj_z0LbWE91hQ-aW5Sk,7798
+valetudo_map_parser/hypfer_draw.py,sha256=ngt4p46XbfhciDQpeB1sShXrrjyJpeKMf0McnIsqfY0,20755
+valetudo_map_parser/hypfer_handler.py,sha256=EdOuXnq6ZSJMtWEM2R6CbGuXyPZW-QmFTItlXLuHR8k,18979
+valetudo_map_parser/map_data.py,sha256=MrQ1uSFz6g9trn_NHsLu1INxvaE6NOXhpdeYM-U4p0c,28393
+valetudo_map_parser/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+valetudo_map_parser/rand256_handler.py,sha256=ayq8MLMo59_sQuXKakhlyQd98ww2GudVTBLrdS-uWYo,21270
+valetudo_map_parser/reimg_draw.py,sha256=Pwm_QUHiJd4o657qr-mlsWQ_TtGCBB-ucsA84t-IwOg,12474
+valetudo_map_parser/rooms_handler.py,sha256=8xd2W5Q_Na3ei9vozm_V-NANOYuytYJBGDHRhb8OSZw,17390
+valetudo_map_parser-0.1.12b0.dist-info/METADATA,sha256=IGtbKi15q5nncHNOx71CT-SKGu2wMkuDtb7JkiBaSYQ,3403
+valetudo_map_parser-0.1.12b0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+valetudo_map_parser-0.1.12b0.dist-info/licenses/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
+valetudo_map_parser-0.1.12b0.dist-info/licenses/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
+valetudo_map_parser-0.1.12b0.dist-info/RECORD,,

valetudo_map_parser-0.1.11b2.dist-info/RECORD

@@ -1,32 +0,0 @@
-valetudo_map_parser/__init__.py,sha256=l_O2iyvj49KkUtuW7lMIZJcEaV_6_-YFaVZkiVeSh9g,1743
-valetudo_map_parser/config/__init__.py,sha256=DQ9plV3ZF_K25Dp5ZQHPDoG-40dQoJNdNi-dfNeR3Zc,48
-valetudo_map_parser/config/async_utils.py,sha256=e1j9uTtg4dhPVWvB2_XgqaH4aeSjRAPz-puRMbGoOs8,3204
-valetudo_map_parser/config/colors.py,sha256=DMY5aHDS-alW2CZ2j8U7QVGHK_H8M0fBDX2OGuryirc,29914
-valetudo_map_parser/config/drawable.py,sha256=s0bA3yeIXgultFbDD_BXDbzDPMpkGVHzq5IyXnH_sW8,23984
-valetudo_map_parser/config/drawable_elements.py,sha256=_iHdAuzbAoIOeT8JEZrvSu5fVojIdhAyH5ABUVi-x3Y,11496
-valetudo_map_parser/config/fonts/FiraSans.ttf,sha256=Pavz1Iv0WZ-Vz_2S-Z6kJqAU1TEfUqXrXsOvJl6XzZc,440984
-valetudo_map_parser/config/fonts/Inter-VF.ttf,sha256=zzy0OwNm4txt9g4RMrHJpMFXd_DNjlpT4MFRJAA-ntQ,804612
-valetudo_map_parser/config/fonts/Lato-Regular.ttf,sha256=6CVCrtgpP0n8g8Sq6lZrH2tPx6mrXaEeb7m8CXO1Mks,75152
-valetudo_map_parser/config/fonts/MPLUSRegular.ttf,sha256=IGdcNSRP4dDxQskbE3Ybuwz7T0flhCBuzwfhLMcPt9s,3380812
-valetudo_map_parser/config/fonts/NotoKufiArabic-VF.ttf,sha256=NaIy40eLx7d3ts0kuenp0GjWd-YN24J6DpSvX2L3vLA,433800
-valetudo_map_parser/config/fonts/NotoSansCJKhk-VF.ttf,sha256=xIXXLKCJzmWoPEg8HdvxeRgotMjjxF6l6ugGP-IWRJU,36135040
-valetudo_map_parser/config/fonts/NotoSansKhojki.ttf,sha256=XJWzSmpN-Ql6jTfTvFojP_JkCHOztQvixQc1_7hPWrc,107388
-valetudo_map_parser/config/optimized_element_map.py,sha256=52BCnkvVv9bre52LeVIfT8nhnEIpc0TuWTv1xcNu0Rk,15744
-valetudo_map_parser/config/rand256_parser.py,sha256=UZ0UlcNIjDhMpImA_2jSei0HeLftpb9fLDwzliJJpz8,21161
-valetudo_map_parser/config/shared.py,sha256=JbCxW7ZKneHUbCfpaQbxeechv90qNmsl4nudFx9yTwc,12619
-valetudo_map_parser/config/status_text/status_text.py,sha256=29E8b3adl_Rr_BH8-J35ia2cOS716sPzVk_cezFiWQ4,4053
-valetudo_map_parser/config/status_text/translations.py,sha256=mmPbJkl_2A59w49wnesQf3ocXqwZxBsrqNX-yt5FSCQ,9132
-valetudo_map_parser/config/types.py,sha256=rYdqOsUX9dtre8M7s8o1S5Ag8Ixvab13Stpk3Hfw_54,18027
-valetudo_map_parser/config/utils.py,sha256=VIrZHnBzP1U0k_atWKpa1baujIXox1tevc44X_95jbk,35571
-valetudo_map_parser/hypfer_draw.py,sha256=0-ZBCZw9H7G5Mu2cukTdOfbu83tZPL2cTdzPjRXzZsQ,22422
-valetudo_map_parser/hypfer_handler.py,sha256=O2eR4nNbmEkcDc-5EcWCKHLMOQGeQBMAdpClEM1fGnI,20446
-valetudo_map_parser/map_data.py,sha256=1-kxE82o8BfaJojYrD0LXoUAgCNpD6d50yLGc4w7ZWc,27433
-valetudo_map_parser/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-valetudo_map_parser/rand256_handler.py,sha256=z7ofWheIy7UvC120rvhP1nNjWdW9JqCIqnGV3T5OoNs,23048
-valetudo_map_parser/reimg_draw.py,sha256=Pwm_QUHiJd4o657qr-mlsWQ_TtGCBB-ucsA84t-IwOg,12474
-valetudo_map_parser/rooms_handler.py,sha256=ZbSdxG-uwoskYBbzN5zzAqK_lTtrNrcpjZmCVmxFWpw,17364
-valetudo_map_parser-0.1.11b2.dist-info/METADATA,sha256=cZwOtk_YoUwND904B25Zc_Beei4wrsCEDBAy_eHT9vQ,3403
-valetudo_map_parser-0.1.11b2.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-valetudo_map_parser-0.1.11b2.dist-info/licenses/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
-valetudo_map_parser-0.1.11b2.dist-info/licenses/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
-valetudo_map_parser-0.1.11b2.dist-info/RECORD,,