valetudo-map-parser 0.1.9b8__py3-none-any.whl → 0.1.9b10__py3-none-any.whl

valetudo_map_parser/config/types.py

@@ -203,7 +203,6 @@ class SnapshotStore:
 
 
 CAMERA_STORAGE = "valetudo_camera"
-DEFAULT_ROOMS = 1  # 15 is the maximum number of rooms.
 ATTR_ROTATE = "rotate_image"
 ATTR_CROP = "crop_image"
 ATTR_MARGINS = "margins"

valetudo_map_parser/config/utils.py

@@ -1,16 +1,43 @@
 """Utility code for the valetudo map parser."""
 
+from dataclasses import dataclass
+from functools import partial
 import hashlib
 import json
 from logging import getLogger
 
-from PIL import ImageOps
+from PIL import ImageOps, Image
 
 from .types import ChargerPosition, ImageSize, NumpyArray, RobotPosition
+from .shared import CameraShared
 
 _LOGGER = getLogger(__name__)
 
 
+@dataclass
+class ResizeParams:
+    """Resize the image to the given dimensions and aspect ratio."""
+
+    pil_img: Image  # PIL image object
+    width: int
+    height: int
+    aspect_ratio: str = None
+    crop_size: list = None
+    is_rand: bool = False
+    offset_func: callable = None  # Function reference for offset calculation
+
+
+@dataclass
+class OffsetParams:
+    """Map parameters."""
+
+    wsf: int
+    hsf: int
+    width: int
+    height: int
+    rand256: bool = False
+
+
 class BaseHandler:
     """Avoid Code duplication"""
 
@@ -30,8 +57,16 @@ class BaseHandler:
         self.crop_img_size = [0, 0]
         self.offset_x = 0
         self.offset_y = 0
-        self.shared = None
+        self.shared = CameraShared(self.file_name)
         self.crop_area = [0, 0, 0, 0]
+        self.zooming = False
+        self.async_resize_image = partial(
+            async_resize_image,
+            width=self.shared.image_ref_width,
+            height=self.shared.image_ref_height,
+            crop_size=self.crop_img_size,
+            offset_func=self.async_map_coordinates_offset,
+        )
 
     def get_frame_number(self) -> int:
         """Return the frame number of the image."""
@@ -53,88 +88,18 @@ class BaseHandler:
         """Return the JSON ID from the image."""
         return self.json_id
 
-    async def async_resize_image(
-        self, pil_img, width, height, aspect_ratio=None, is_rand=False
-    ):
-        """Resize the image to the given dimensions and aspect ratio."""
-        if aspect_ratio:
-            wsf, hsf = [int(x) for x in aspect_ratio.split(",")]
-            if wsf == 0 or hsf == 0:
-                return pil_img
-            new_aspect_ratio = wsf / hsf
-            if width / height > new_aspect_ratio:
-                new_width = int(pil_img.height * new_aspect_ratio)
-                new_height = pil_img.height
-            else:
-                new_width = pil_img.width
-                new_height = int(pil_img.width / new_aspect_ratio)
-                _LOGGER.debug(
-                    "%s: Image Aspect Ratio: %s, %s",
-                    self.file_name,
-                    str(wsf),
-                    str(hsf),
-                )
-                (
-                    self.crop_img_size[0],
-                    self.crop_img_size[1],
-                ) = await self.async_map_coordinates_offset(
-                    wsf, hsf, new_width, new_height, is_rand
-                )
-            return ImageOps.pad(pil_img, (new_width, new_height))
-        return ImageOps.pad(pil_img, (width, height))
-
-    async def async_map_coordinates_offset(
-        self, wsf: int, hsf: int, width: int, height: int, rand256: bool = False
-    ) -> tuple[int, int]:
-        """
-        Offset the coordinates to the map.
-        """
-
-        if wsf == 1 and hsf == 1:
-            self.set_image_offset_ratio_1_1(width, height, rand256)
-        elif wsf == 2 and hsf == 1:
-            self.set_image_offset_ratio_2_1(width, height, rand256)
-        elif wsf == 3 and hsf == 2:
-            self.set_image_offset_ratio_3_2(width, height, rand256)
-        elif wsf == 5 and hsf == 4:
-            self.set_image_offset_ratio_5_4(width, height, rand256)
-        elif wsf == 9 and hsf == 16:
-            self.set_image_offset_ratio_9_16(width, height, rand256)
-        elif wsf == 16 and hsf == 9:
-            self.set_image_offset_ratio_16_9(width, height, rand256)
-        return width, height
-
-    @staticmethod
-    async def calculate_array_hash(layers: dict, active: list[int] = None) -> str:
-        """Calculate the hash of the image based on layers and active zones."""
-        if layers and active:
-            data_to_hash = {
-                "layers": len(layers["wall"][0]),
-                "active_segments": tuple(active),
-            }
-            data_json = json.dumps(data_to_hash, sort_keys=True)
-            return hashlib.sha256(data_json.encode()).hexdigest()
-        return None
-
-    @staticmethod
-    async def async_copy_array(original_array: NumpyArray) -> NumpyArray:
-        """Copy the array."""
-        return NumpyArray.copy(original_array)
-
-    def get_map_points(self) -> dict:
-        """Return the map points."""
-        return [
-            {"x": 0, "y": 0},  # Top-left corner 0
-            {"x": self.crop_img_size[0], "y": 0},  # Top-right corner 1
-            {
-                "x": self.crop_img_size[0],
-                "y": self.crop_img_size[1],
-            },  # Bottom-right corner 2
-            {"x": 0, "y": self.crop_img_size[1]},  # Bottom-left corner (optional) 3
-        ]
+    def check_zoom_and_aspect_ratio(self) -> bool:
+        """Check if the image is zoomed and has an aspect ratio."""
+        return (
+            self.shared.image_auto_zoom
+            and self.shared.vacuum_state == "cleaning"
+            and self.zooming
+            and self.shared.image_zoom_lock_ratio
+            or self.shared.image_aspect_ratio != "None"
+        )
 
-    def set_image_offset_ratio_1_1(
-            self, width: int, height: int, rand256: bool = False
+    def _set_image_offset_ratio_1_1(
+        self, width: int, height: int, rand256: bool = False
     ) -> None:
         """Set the image offset ratio to 1:1."""
 
@@ -160,8 +125,8 @@ class BaseHandler:
             self.offset_y,
         )
 
-    def set_image_offset_ratio_2_1(
-            self, width: int, height: int, rand256: bool = False
+    def _set_image_offset_ratio_2_1(
+        self, width: int, height: int, rand256: bool = False
     ) -> None:
         """Set the image offset ratio to 2:1."""
 
@@ -188,8 +153,8 @@ class BaseHandler:
             self.offset_y,
         )
 
-    def set_image_offset_ratio_3_2(
-            self, width: int, height: int, rand256: bool = False
+    def _set_image_offset_ratio_3_2(
+        self, width: int, height: int, rand256: bool = False
     ) -> None:
         """Set the image offset ratio to 3:2."""
 
@@ -199,13 +164,11 @@ class BaseHandler:
             if rotation in [0, 180]:
                 self.offset_y = width - self.crop_img_size[0]
                 self.offset_x = ((height - self.crop_img_size[1]) // 2) - (
-                        self.crop_img_size[1] // 10
+                    self.crop_img_size[1] // 10
                 )
             elif rotation in [90, 270]:
                 self.offset_y = (self.crop_img_size[0] - width) // 2
-                self.offset_x = (self.crop_img_size[1] - height) + (
-                        (height // 10) // 2
-                )
+                self.offset_x = (self.crop_img_size[1] - height) + ((height // 10) // 2)
         else:
             if rotation in [0, 180]:
                 self.offset_x = (width - self.crop_img_size[0]) // 2
@@ -221,8 +184,8 @@ class BaseHandler:
             self.offset_y,
         )
 
-    def set_image_offset_ratio_5_4(
-            self, width: int, height: int, rand256: bool = False
+    def _set_image_offset_ratio_5_4(
+        self, width: int, height: int, rand256: bool = False
     ) -> None:
         """Set the image offset ratio to 5:4."""
 
@@ -230,16 +193,14 @@ class BaseHandler:
         if not rand256:
             if rotation in [0, 180]:
                 self.offset_x = ((width - self.crop_img_size[0]) // 2) - (
-                        self.crop_img_size[0] // 2
+                    self.crop_img_size[0] // 2
                 )
                 self.offset_y = (self.crop_img_size[1] - height) - (
-                        self.crop_img_size[1] // 2
+                    self.crop_img_size[1] // 2
                 )
             elif rotation in [90, 270]:
                 self.offset_y = ((self.crop_img_size[0] - width) // 2) - 10
-                self.offset_x = (self.crop_img_size[1] - height) + (
-                        height // 10
-                )
+                self.offset_x = (self.crop_img_size[1] - height) + (height // 10)
         else:
             if rotation in [0, 180]:
                 self.offset_y = (width - self.crop_img_size[0]) // 2
@@ -255,8 +216,8 @@ class BaseHandler:
             self.offset_y,
         )
 
-    def set_image_offset_ratio_9_16(
-            self, width: int, height: int, rand256: bool = False
+    def _set_image_offset_ratio_9_16(
+        self, width: int, height: int, rand256: bool = False
     ) -> None:
         """Set the image offset ratio to 9:16."""
 
@@ -283,8 +244,8 @@ class BaseHandler:
             self.offset_y,
         )
 
-    def set_image_offset_ratio_16_9(
-            self, width: int, height: int, rand256: bool = False
+    def _set_image_offset_ratio_16_9(
+        self, width: int, height: int, rand256: bool = False
     ) -> None:
         """Set the image offset ratio to 16:9."""
 
@@ -311,6 +272,71 @@ class BaseHandler:
             self.offset_y,
         )
 
+    async def async_map_coordinates_offset(
+        self, params: OffsetParams
+    ) -> tuple[int, int]:
+        """
+        Offset the coordinates to the map.
+        """
+        if params.wsf == 1 and params.hsf == 1:
+            self._set_image_offset_ratio_1_1(
+                params.width, params.height, params.rand256
+            )
+        elif params.wsf == 2 and params.hsf == 1:
+            self._set_image_offset_ratio_2_1(
+                params.width, params.height, params.rand256
+            )
+        elif params.wsf == 3 and params.hsf == 2:
+            self._set_image_offset_ratio_3_2(
+                params.width, params.height, params.rand256
+            )
+        elif params.wsf == 5 and params.hsf == 4:
+            self._set_image_offset_ratio_5_4(
+                params.width, params.height, params.rand256
+            )
+        elif params.wsf == 9 and params.hsf == 16:
+            self._set_image_offset_ratio_9_16(
+                params.width, params.height, params.rand256
+            )
+        elif params.wsf == 16 and params.hsf == 9:
+            self._set_image_offset_ratio_16_9(
+                params.width, params.height, params.rand256
+            )
+        return params.width, params.height
+
+    @staticmethod
+    async def calculate_array_hash(
+        layers: dict, active: list[int] = None
+    ) -> str or None:
+        """Calculate the hash of the image based on layers and active zones."""
+        if layers and active:
+            data_to_hash = {
+                "layers": len(layers["wall"][0]),
+                "active_segments": tuple(active),
+            }
+            data_json = json.dumps(data_to_hash, sort_keys=True)
+            return hashlib.sha256(data_json.encode()).hexdigest()
+        return None
+
+    @staticmethod
+    async def async_copy_array(original_array: NumpyArray) -> NumpyArray:
+        """Copy the array."""
+        return NumpyArray.copy(original_array)
+
+    def get_map_points(
+        self,
+    ) -> list[dict[str, int] | dict[str, int] | dict[str, int] | dict[str, int]]:
+        """Return the map points."""
+        return [
+            {"x": 0, "y": 0},  # Top-left corner 0
+            {"x": self.crop_img_size[0], "y": 0},  # Top-right corner 1
+            {
+                "x": self.crop_img_size[0],
+                "y": self.crop_img_size[1],
+            },  # Bottom-right corner 2
+            {"x": 0, "y": self.crop_img_size[1]},  # Bottom-left corner (optional) 3
+        ]
+
     def get_vacuum_points(self, rotation_angle: int) -> list[dict[str, int]]:
         """Calculate the calibration points based on the rotation angle."""
 
@@ -446,4 +472,50 @@ class BaseHandler:
                 id_count += 1
             if id_count > 1:
                 _LOGGER.debug("%s: Point Properties updated.", self.file_name)
-        return point_properties
+        return point_properties
+
+    @staticmethod
+    def get_corners(
+        x_max: int, x_min: int, y_max: int, y_min: int
+    ) -> list[tuple[int, int]]:
+        """Return the corners of the image."""
+        return [
+            (x_min, y_min),
+            (x_max, y_min),
+            (x_max, y_max),
+            (x_min, y_max),
+        ]
+
+
+async def async_resize_image(params: ResizeParams):
+    """Resize the image to the given dimensions and aspect ratio."""
+    if params.aspect_ratio:
+        wsf, hsf = [int(x) for x in params.aspect_ratio.split(",")]
+        if wsf == 0 or hsf == 0:
+            return params.pil_img
+        new_aspect_ratio = wsf / hsf
+        if params.width / params.height > new_aspect_ratio:
+            new_width = int(params.pil_img.height * new_aspect_ratio)
+            new_height = params.pil_img.height
+        else:
+            new_width = params.pil_img.width
+            new_height = int(params.pil_img.width / new_aspect_ratio)
+
+        _LOGGER.debug(
+            "Image Aspect Ratio: %s, %s",
+            str(wsf),
+            str(hsf),
+        )
+
+        if params.crop_size is not None:
+            params.crop_size[0], params.crop_size[1] = await params.offset_func(
+                wsf=wsf,
+                hsf=hsf,
+                width=new_width,
+                height=new_height,
+                rand256=params.is_rand,
+            )
+
+        return ImageOps.pad(params.pil_img, (new_width, new_height))
+
+    return ImageOps.pad(params.pil_img, (params.width, params.height))

valetudo_map_parser/hypfer_draw.py

@@ -262,9 +262,9 @@ class ImageDraw:
             for path in path_pixels:
                 # Get the points from the current path and extend multiple paths.
                 points = path.get("points", [])
-                sublists = self.img_h.data.sublist(points, 2)
+                sublist = self.img_h.data.sublist(points, 2)
                 self.img_h.shared.map_new_path = self.img_h.data.sublist_join(
-                    sublists, 2
+                    sublist, 2
                 )
                 np_array = await self.img_h.draw.lines(
                     np_array, self.img_h.shared.map_new_path, 5, color_move
@@ -276,9 +276,8 @@ class ImageDraw:
         try:
             entity_dict = self.img_h.data.find_points_entities(m_json)
         except (ValueError, KeyError):
-            entity_dict = None
-        else:
-            _LOGGER.info("%s: Got the points in the json.", self.file_name)
+            return None
+        _LOGGER.info("%s: Got the points in the json.", self.file_name)
         return entity_dict
 
     async def async_get_robot_in_room(

valetudo_map_parser/hypfer_handler.py

@@ -40,8 +40,6 @@ class HypferMapImageHandler(BaseHandler):
         self.img_hash = None  # hash of the image calculated to check differences.
         self.img_base_layer = None  # numpy array store the map base layer.
         self.active_zones = None  # vacuum active zones.
-        self.frame_number = 0  # frame number of the image.
-        self.zooming = False  # zooming the image.
         self.svg_wait = False  # SVG image creation wait.
         self.trim_down = 0  # memory stored trims calculated once.
         self.trim_left = 0  # memory stored trims calculated once.
@@ -78,12 +76,7 @@ class HypferMapImageHandler(BaseHandler):
                         x_max,
                         y_max,
                     ) = await self.data.async_get_rooms_coordinates(pixels, pixel_size)
-                    corners = [
-                        (x_min, y_min),
-                        (x_max, y_min),
-                        (x_max, y_max),
-                        (x_min, y_max),
-                    ]
+                    corners = self.get_corners(x_max, x_min, y_max, y_min)
                     room_id = str(segment_id)
                     self.rooms_pos.append(
                         {
@@ -253,17 +246,9 @@ class HypferMapImageHandler(BaseHandler):
             pil_img = Image.fromarray(img_np_array, mode="RGBA")
             del img_np_array
             # reduce the image size if the zoomed image is bigger then the original.
-            if (
-                self.shared.image_auto_zoom
-                and self.shared.vacuum_state == "cleaning"
-                and self.zooming
-                and self.shared.image_zoom_lock_ratio
-                or self.shared.image_aspect_ratio != "None"
-            ):
-                width = self.shared.image_ref_width
-                height = self.shared.image_ref_height
+            if self.check_zoom_and_aspect_ratio():
                 resized_image = await self.async_resize_image(
-                    pil_img, width, height, self.shared.image_aspect_ratio
+                    pil_img, self.shared.image_aspect_ratio
                 )
                 return resized_image
             _LOGGER.debug("%s: Frame Completed.", self.file_name)

valetudo_map_parser/map_data.py

@@ -239,7 +239,7 @@ class RandImageData:
         return compressed_pixels
 
     @staticmethod
-    def calculate_max_x_y(coord_array):
+    def _calculate_max_x_y(coord_array):
         """Calculate the max and min x and y coordinates."""
         max_x = -float("inf")
         max_y = -float("inf")
@@ -334,18 +334,18 @@ class RandImageData:
     def get_rrm_currently_cleaned_zones(json_data: JsonType) -> dict:
         """Get the currently cleaned zones from the json."""
         re_zones = json_data.get("currently_cleaned_zones", [])
-        formatted_zones = RandImageData.rrm_valetudo_format_zone(re_zones)
+        formatted_zones = RandImageData._rrm_valetudo_format_zone(re_zones)
         return formatted_zones
 
     @staticmethod
     def get_rrm_forbidden_zones(json_data: JsonType) -> dict:
         """Get the forbidden zones from the json."""
         re_zones = json_data.get("forbidden_zones", [])
-        formatted_zones = RandImageData.rrm_valetudo_format_zone(re_zones)
+        formatted_zones = RandImageData._rrm_valetudo_format_zone(re_zones)
         return formatted_zones
 
     @staticmethod
-    def rrm_valetudo_format_zone(coordinates: list) -> any:
+    def _rrm_valetudo_format_zone(coordinates: list) -> any:
         """Format the zones from RRM to Valetudo."""
         formatted_zones = []
         for zone_data in coordinates:
@@ -387,7 +387,7 @@ class RandImageData:
         return formatted_zones
 
     @staticmethod
-    def rrm_valetudo_lines(coordinates: list) -> list:
+    def _rrm_valetudo_lines(coordinates: list) -> list:
         """Format the lines from RRM to Valetudo."""
         formatted_lines = []
         for lines in coordinates:
@@ -402,7 +402,7 @@ class RandImageData:
             tmp_data = json_data.get("virtual_walls", [])
         except KeyError:
             return None
-        virtual_walls = RandImageData.rrm_valetudo_lines(tmp_data)
+        virtual_walls = RandImageData._rrm_valetudo_lines(tmp_data)
         return virtual_walls
 
     @staticmethod
@@ -495,11 +495,11 @@ class RandImageData:
             return None
         return seg_ids
 
-    @staticmethod
-    def convert_negative_angle(angle: int) -> int:
-        """Convert negative angle to positive."""
-        angle_c = angle % 360  # Ensure angle is within 0-359
-        if angle_c < 0:
-            angle_c += 360  # Convert negative angle to positive
-        angle = angle_c + 180  # add offset
-        return angle
+    # @staticmethod
+    # def convert_negative_angle(angle: int) -> int:
+    #     """Convert negative angle to positive."""
+    #     angle_c = angle % 360  # Ensure angle is within 0-359
+    #     if angle_c < 0:
+    #         angle_c += 360  # Convert negative angle to positive
+    #     angle = angle_c + 180  # add offset
+    #     return angle

valetudo_map_parser/rand25_handler.py

@@ -55,14 +55,13 @@ class ReImageHandler(BaseHandler):
         self.trim_left = None  # Trim left
         self.trim_right = None  # Trim right
         self.trim_up = None  # Trim up
-        self.zooming = False  # Zooming flag
         self.file_name = self.shared.file_name  # File name
         self.offset_top = self.shared.offset_top  # offset top
         self.offset_bottom = self.shared.offset_down  # offset bottom
         self.offset_left = self.shared.offset_left  # offset left
         self.offset_right = self.shared.offset_right  # offset right
         self.imd = ImageDraw(self)  # Image Draw
-        self.ac = AutoCrop(self)
+        self.crop = AutoCrop(self)
 
     async def extract_room_properties(
         self, json_data: JsonType, destinations: JsonType
@@ -96,12 +95,7 @@ class ReImageHandler(BaseHandler):
                         x_max = self.outlines[id_x][1][0]
                         y_min = self.outlines[id_x][0][1]
                         y_max = self.outlines[id_x][1][1]
-                        corners = [
-                            (x_min, y_min),
-                            (x_max, y_min),
-                            (x_max, y_max),
-                            (x_min, y_max),
-                        ]
+                        corners = self.get_corners(x_max, x_min, y_max, y_min)
                         # rand256 vacuums accept int(room_id) or str(name)
                         # the card will soon support int(room_id) but the camera will send name
                         # this avoids the manual change of the values in the card.
@@ -251,30 +245,21 @@ class ReImageHandler(BaseHandler):
         img_np_array = await self.imd.async_draw_robot_on_map(
             img_np_array, robot_position, robot_position_angle, colors["robot"]
         )
-        img_np_array = await self.ac.async_auto_trim_and_zoom_image(
+        img_np_array = await self.crop.async_auto_trim_and_zoom_image(
             img_np_array,
-            colors["background"],
-            int(self.shared.margins),
-            int(self.shared.image_rotate),
-            self.zooming,
+            detect_colour=colors["background"],
+            margin_size=int(self.shared.margins),
+            rotate=int(self.shared.image_rotate),
+            zoom=self.zooming,
             rand256=True,
         )
         return img_np_array
 
     async def _finalize_image(self, pil_img):
-        if (
-            self.shared.image_auto_zoom
-            and self.shared.vacuum_state == "cleaning"
-            and self.zooming
-            and self.shared.image_zoom_lock_ratio
-            or self.shared.image_aspect_ratio != "None"
-        ):
-            width = self.shared.image_ref_width
-            height = self.shared.image_ref_height
-            if self.shared.image_aspect_ratio != "None":
-                pil_img = await self.async_resize_image(
-                    pil_img, width, height, self.shared.image_aspect_ratio, True
-                )
+        if self.check_zoom_and_aspect_ratio():
+            pil_img = await self.async_resize_image(
+                pil_img, self.shared.image_aspect_ratio, True
+            )
         _LOGGER.debug("%s: Frame Completed.", self.file_name)
         return pil_img
 

{valetudo_map_parser-0.1.9b8.dist-info → valetudo_map_parser-0.1.9b10.dist-info}/METADATA

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

@@ -0,0 +1,20 @@
+valetudo_map_parser/__init__.py,sha256=pWRSVGM2OtPKTzdpPTEgLrNYjZ9P2duwaDLI_KN-iLY,809
+valetudo_map_parser/config/__init__.py,sha256=DQ9plV3ZF_K25Dp5ZQHPDoG-40dQoJNdNi-dfNeR3Zc,48
+valetudo_map_parser/config/auto_crop.py,sha256=z97Yqoe96ZiWmgaKTFv7sODb9UD6doRduTeQXMYWXVA,11018
+valetudo_map_parser/config/colors.py,sha256=0sTI_x0ZMchSDPTsEivdTXDn58nEbyE4REXIp0IpWdg,6514
+valetudo_map_parser/config/drawable.py,sha256=hsrEJCMVOrjs5sJfr26SeqJD0VNlYWwxcVkkHeaxx7U,20356
+valetudo_map_parser/config/rand25_parser.py,sha256=fehyF18hRWRWbXbojocQCIaIch21Lbh1wtl2XdKRSl0,16447
+valetudo_map_parser/config/shared.py,sha256=LQV5K8tbVhEKUkby9ssjEmh_T4Ai-Euzsbag_HWYVRc,9448
+valetudo_map_parser/config/types.py,sha256=sdjqhcxpRSxNFLVHIyCg-RDL9JIjtQHoR2C2WpocWBc,16107
+valetudo_map_parser/config/utils.py,sha256=mCmTRxiy5REBPvm3S8_b3nCce4pFAjRyCUnAvz3omLw,18536
+valetudo_map_parser/hypfer_draw.py,sha256=s58ak9IBYLjJyoddfDC99PfQ12HTjkSfJYXqCi4vZKs,14931
+valetudo_map_parser/hypfer_handler.py,sha256=lA9rC4gO0cNas4ValRikw4X6Uc0sqo2-Roj7EQi1MBA,13471
+valetudo_map_parser/map_data.py,sha256=6FbQfgxFB6E4kcOWokReJOVSekVaE1kStyhTQhAhiOg,19469
+valetudo_map_parser/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+valetudo_map_parser/rand25_handler.py,sha256=u3N-_qjpYQM3WO4cnhqHIPa7TMquJ9XYqhoUYFKoc8I,15276
+valetudo_map_parser/reimg_draw.py,sha256=dtdbYKKxmQnbOaHBHayWEF07OdSnTKo2CPSOW0qpgH0,12506
+valetudo_map_parser-0.1.9b10.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
+valetudo_map_parser-0.1.9b10.dist-info/METADATA,sha256=ha_vys80z9E1XW1dDtgbHMigATO4vb2w-7gDRqJ1_mM,1029
+valetudo_map_parser-0.1.9b10.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
+valetudo_map_parser-0.1.9b10.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+valetudo_map_parser-0.1.9b10.dist-info/RECORD,,

valetudo_map_parser-0.1.9b8.dist-info/RECORD

@@ -1,20 +0,0 @@
-valetudo_map_parser/__init__.py,sha256=pWRSVGM2OtPKTzdpPTEgLrNYjZ9P2duwaDLI_KN-iLY,809
-valetudo_map_parser/config/__init__.py,sha256=DQ9plV3ZF_K25Dp5ZQHPDoG-40dQoJNdNi-dfNeR3Zc,48
-valetudo_map_parser/config/auto_crop.py,sha256=z97Yqoe96ZiWmgaKTFv7sODb9UD6doRduTeQXMYWXVA,11018
-valetudo_map_parser/config/colors.py,sha256=0sTI_x0ZMchSDPTsEivdTXDn58nEbyE4REXIp0IpWdg,6514
-valetudo_map_parser/config/drawable.py,sha256=hsrEJCMVOrjs5sJfr26SeqJD0VNlYWwxcVkkHeaxx7U,20356
-valetudo_map_parser/config/rand25_parser.py,sha256=fehyF18hRWRWbXbojocQCIaIch21Lbh1wtl2XdKRSl0,16447
-valetudo_map_parser/config/shared.py,sha256=LQV5K8tbVhEKUkby9ssjEmh_T4Ai-Euzsbag_HWYVRc,9448
-valetudo_map_parser/config/types.py,sha256=-8F1WwCH5hKSih83-WPjYbGdQyKmNqkDmSKvlyz6qPg,16163
-valetudo_map_parser/config/utils.py,sha256=V_GmVL10hLaGWRltv8FvxEEohRfswWDmmnp6HA0vsn8,16627
-valetudo_map_parser/hypfer_draw.py,sha256=46bYtbcaZHDYDtOie4byM3Z8CcXw-vl7uQfwN7KdZOk,14958
-valetudo_map_parser/hypfer_handler.py,sha256=hBYy6trd1hmFkyOPJmm1T-y4byi-xGqS8yN_Xwhl0E0,14073
-valetudo_map_parser/map_data.py,sha256=qm1Zlfex0JrfhQsAKUOzsceZL0X92oAyGJ5Wvsq6YhA,19447
-valetudo_map_parser/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-valetudo_map_parser/rand25_handler.py,sha256=vph1BCO0g77kTi18y6sqqJfyJfT5033l9CoxJIDO1Ak,15827
-valetudo_map_parser/reimg_draw.py,sha256=dtdbYKKxmQnbOaHBHayWEF07OdSnTKo2CPSOW0qpgH0,12506
-valetudo_map_parser-0.1.9b8.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
-valetudo_map_parser-0.1.9b8.dist-info/METADATA,sha256=uoqN0vHYxk79Tfy0Sq4D9aiHjbjwm2gzqUxQbxD3WPU,1028
-valetudo_map_parser-0.1.9b8.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
-valetudo_map_parser-0.1.9b8.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-valetudo_map_parser-0.1.9b8.dist-info/RECORD,,