valetudo-map-parser 0.1.9b4__py3-none-any.whl → 0.1.9b6__py3-none-any.whl

valetudo_map_parser/hypfer_handler.py

@@ -13,53 +13,34 @@ import logging
 from PIL import Image
 
 from .config.auto_crop import AutoCrop
-from .config.colors import ColorsManagment, SupportedColor
 from .config.drawable import Drawable
 from .config.shared import CameraShared
-from .config.types import (
-    CalibrationPoints,
-    ChargerPosition,
-    ImageSize,
-    RobotPosition,
-    RoomsProperties,
-)
+from .config.types import COLORS, CalibrationPoints, Colors, RoomsProperties
+from .config.utils import BaseHandler
 from .hypfer_draw import ImageDraw as ImDraw
-from .images_utils import ImageUtils as ImUtils
-from .images_utils import resize_to_aspect_ratio
 from .map_data import ImageData
 
 _LOGGER = logging.getLogger(__name__)
 
 
-class HypferMapImageHandler:
+class HypferMapImageHandler(BaseHandler):
     """Map Image Handler Class.
     This class is used to handle the image data and the drawing of the map."""
 
     def __init__(self, shared_data: CameraShared):
         """Initialize the Map Image Handler."""
+        super().__init__()
         self.shared = shared_data  # camera shared data
-        self.file_name = self.shared.file_name  # file name of the vacuum.
         self.auto_crop = None  # auto crop data to be calculate once.
         self.calibration_data = None  # camera shared data.
-        self.charger_pos = None  # vacuum data charger position.
         self.crop_area = None  # module shared for calibration data.
-        self.crop_img_size = None  # size of the image cropped calibration data.
         self.data = ImageData  # imported Image Data Module.
         self.draw = Drawable  # imported Drawing utilities
         self.go_to = None  # vacuum go to data
         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.img_size = None  # size of the created image
-        self.json_data = None  # local stored and shared json data.
-        self.json_id = None  # grabbed data of the vacuum image id.
-        self.path_pixels = None  # vacuum path datas.
-        self.robot_in_room = None  # vacuum room position.
-        self.robot_pos = None  # vacuum coordinates.
-        self.room_propriety = None  # vacuum segments data.
-        self.rooms_pos = None  # vacuum room coordinates / name list.
         self.active_zones = None  # vacuum active zones.
         self.frame_number = 0  # frame number of the image.
-        self.max_frames = 1024
         self.zooming = False  # zooming the image.
         self.svg_wait = False  # SVG image creation wait.
         self.trim_down = 0  # memory stored trims calculated once.
@@ -70,14 +51,10 @@ class HypferMapImageHandler:
         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.offset_x = 0  # offset x for the aspect ratio.
-        self.offset_y = 0  # offset y for the aspect ratio.
         self.imd = ImDraw(self)
-        self.imu = ImUtils(self)
         self.ac = AutoCrop(self)
-        self.colors_manager = ColorsManagment({})
-        self.rooms_colors = self.colors_manager.get_rooms_colors()
         self.color_grey = (128, 128, 128, 255)
+        self.file_name = self.shared.file_name  # file name of the vacuum.
 
     async def async_extract_room_properties(self, json_data) -> RoomsProperties:
         """Extract room properties from the JSON data."""
@@ -128,23 +105,6 @@ class HypferMapImageHandler:
             self.rooms_pos = None
         return room_properties
 
-    async def _async_initialize_colors(self):
-        """Initialize and return all required colors."""
-        return {
-            "color_wall": self.colors_manager.get_colour(SupportedColor.WALLS),
-            "color_no_go": self.colors_manager.get_colour(SupportedColor.NO_GO),
-            "color_go_to": self.colors_manager.get_colour(SupportedColor.GO_TO),
-            "color_robot": self.colors_manager.get_colour(SupportedColor.ROBOT),
-            "color_charger": self.colors_manager.get_colour(SupportedColor.CHARGER),
-            "color_move": self.colors_manager.get_colour(SupportedColor.PATH),
-            "color_background": self.colors_manager.get_colour(
-                SupportedColor.MAP_BACKGROUND
-            ),
-            "color_zone_clean": self.colors_manager.get_colour(
-                SupportedColor.ZONE_CLEAN
-            ),
-        }
-
     # noinspection PyUnresolvedReferences,PyUnboundLocalVariable
     async def async_get_image_from_json(
         self,
@@ -157,7 +117,9 @@ class HypferMapImageHandler:
         @return Image.Image: The image to display.
         """
         # Initialize the colors.
-        colors = await self._async_initialize_colors()
+        colors: Colors = {
+            name: self.shared.user_colors[idx] for idx, name in enumerate(COLORS)
+        }
         # Check if the JSON data is not None else process the image.
         try:
             if m_json is not None:
@@ -186,12 +148,12 @@ class HypferMapImageHandler:
                 # Get the pixels size and layers from the JSON data
                 pixel_size = int(m_json["pixelSize"])
                 layers, active = self.data.find_layers(m_json["layers"], {}, [])
-                new_frame_hash = await self.imd.calculate_array_hash(layers, active)
+                new_frame_hash = await self.calculate_array_hash(layers, active)
                 if self.frame_number == 0:
                     self.img_hash = new_frame_hash
                     # empty image
                     img_np_array = await self.draw.create_empty_image(
-                        size_x, size_y, colors["color_background"]
+                        size_x, size_y, colors["background"]
                     )
                     # overlapping layers and segments
                     for layer_type, compressed_pixels_list in layers.items():
@@ -199,21 +161,21 @@ class HypferMapImageHandler:
                             img_np_array,
                             compressed_pixels_list,
                             layer_type,
-                            colors["color_wall"],
-                            colors["color_zone_clean"],
+                            colors["wall"],
+                            colors["zone_clean"],
                             pixel_size,
                         )
                     # Draw the virtual walls if any.
                     img_np_array = await self.imd.async_draw_virtual_walls(
-                        m_json, img_np_array, colors["color_no_go"]
+                        m_json, img_np_array, colors["no_go"]
                     )
                     # Draw charger.
                     img_np_array = await self.imd.async_draw_charger(
-                        img_np_array, entity_dict, colors["color_charger"]
+                        img_np_array, entity_dict, colors["charger"]
                     )
                     # Draw obstacles if any.
                     img_np_array = await self.imd.async_draw_obstacle(
-                        img_np_array, entity_dict, colors["color_no_go"]
+                        img_np_array, entity_dict, colors["no_go"]
                     )
                     # Robot and rooms position
                     if (room_id > 0) and not self.room_propriety:
@@ -228,7 +190,7 @@ class HypferMapImageHandler:
                             )
                     _LOGGER.info("%s: Completed base Layers", self.file_name)
                     # Copy the new array in base layer.
-                    self.img_base_layer = await self.imd.async_copy_array(img_np_array)
+                    self.img_base_layer = await self.async_copy_array(img_np_array)
                 self.shared.frame_number = self.frame_number
                 self.frame_number += 1
                 if (self.frame_number >= self.max_frames) or (
@@ -242,18 +204,18 @@ class HypferMapImageHandler:
                     str(self.frame_number),
                 )
                 # Copy the base layer to the new image.
-                img_np_array = await self.imd.async_copy_array(self.img_base_layer)
+                img_np_array = await self.async_copy_array(self.img_base_layer)
                 # All below will be drawn at each frame.
                 # Draw zones if any.
-                img_np_array = await self.imd.async_draw_zones(
+                img_np_array = await self.async_draw_zones(
                     m_json,
                     img_np_array,
-                    colors["color_zone_clean"],
-                    colors["color_no_go"],
+                    colors["zone_clean"],
+                    colors["no_go"],
                 )
                 # Draw the go_to target flag.
                 img_np_array = await self.imd.draw_go_to_flag(
-                    img_np_array, entity_dict, colors["color_go_to"]
+                    img_np_array, entity_dict, colors["go_to"]
                 )
                 # Draw path prediction and paths.
                 img_np_array = await self.imd.async_draw_paths(
@@ -300,15 +262,8 @@ class HypferMapImageHandler:
             ):
                 width = self.shared.image_ref_width
                 height = self.shared.image_ref_height
-                (
-                    resized_image,
-                    self.crop_img_size,
-                ) = await resize_to_aspect_ratio(
-                    pil_img,
-                    width,
-                    height,
-                    self.shared.image_aspect_ratio,
-                    self.async_map_coordinates_offset,
+                resized_image = await self.async_resize_image(
+                    pil_img, width, height, self.shared.image_aspect_ratio
                 )
                 return resized_image
             _LOGGER.debug("%s: Frame Completed.", self.file_name)
@@ -322,26 +277,6 @@ class HypferMapImageHandler:
             )
             return None
 
-    def get_frame_number(self) -> int:
-        """Return the frame number of the image."""
-        return self.frame_number
-
-    def get_robot_position(self) -> RobotPosition | None:
-        """Return the robot position."""
-        return self.robot_pos
-
-    def get_charger_position(self) -> ChargerPosition | None:
-        """Return the charger position."""
-        return self.charger_pos
-
-    def get_img_size(self) -> ImageSize | None:
-        """Return the size of the image."""
-        return self.img_size
-
-    def get_json_id(self) -> str | None:
-        """Return the JSON ID from the image."""
-        return self.json_id
-
     async def async_get_rooms_attributes(self) -> RoomsProperties:
         """Get the rooms attributes from the JSON data.
         :return: The rooms attribute's."""
@@ -364,17 +299,9 @@ class HypferMapImageHandler:
         _LOGGER.info("Getting %s Calibrations points.", self.file_name)
 
         # Define the map points (fixed)
-        map_points = [
-            {"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
-        ]
+        map_points = self.get_map_points()
         # Calculate the calibration points in the vacuum coordinate system
-        vacuum_points = self.imu.get_vacuum_points(rotation_angle)
+        vacuum_points = self.get_vacuum_points(rotation_angle)
 
         # Create the calibration data for each point
         for vacuum_point, map_point in zip(vacuum_points, map_points):
@@ -382,33 +309,3 @@ class HypferMapImageHandler:
             calibration_data.append(calibration_point)
         del vacuum_points, map_points, calibration_point, rotation_angle  # free memory.
         return calibration_data
-
-    async def async_map_coordinates_offset(
-        self, wsf: int, hsf: int, width: int, height: int
-    ) -> tuple[int, int]:
-        """
-        Offset the coordinates to the map.
-        :param wsf: Width scale factor.
-        :param hsf: Height scale factor.
-        :param width: Width of the image.
-        :param height: Height of the image.
-        :return: A tuple containing the adjusted (width, height) values
-        :raises ValueError: If any input parameters are negative
-        """
-
-        if any(x < 0 for x in (wsf, hsf, width, height)):
-            raise ValueError("All parameters must be positive integers")
-
-        if wsf == 1 and hsf == 1:
-            self.imu.set_image_offset_ratio_1_1(width, height)
-        elif wsf == 2 and hsf == 1:
-            self.imu.set_image_offset_ratio_2_1(width, height)
-        elif wsf == 3 and hsf == 2:
-            self.imu.set_image_offset_ratio_3_2(width, height)
-        elif wsf == 5 and hsf == 4:
-            self.imu.set_image_offset_ratio_5_4(width, height)
-        elif wsf == 9 and hsf == 16:
-            self.imu.set_image_offset_ratio_9_16(width, height)
-        elif wsf == 16 and hsf == 9:
-            self.imu.set_image_offset_ratio_16_9(width, height)
-        return width, height

valetudo_map_parser/rand25_handler.py

@@ -11,7 +11,7 @@ import logging
 import uuid
 from typing import Any
 
-from PIL import Image, ImageOps
+from PIL import Image
 
 from .config.auto_crop import AutoCrop
 from .config.types import (
@@ -24,7 +24,7 @@ from .config.types import (
     RobotPosition,
     RoomsProperties,
 )
-from .images_utils import ImageUtils as ImUtils
+from .config.utils import BaseHandler
 from .map_data import RandImageData
 from .reimg_draw import ImageDraw
 
@@ -32,33 +32,23 @@ _LOGGER = logging.getLogger(__name__)
 
 
 # noinspection PyTypeChecker
-class ReImageHandler:
+class ReImageHandler(BaseHandler):
     """
     Image Handler for Valetudo Re Vacuums.
     """
 
     def __init__(self, camera_shared):
+        super().__init__()
         self.auto_crop = None  # Auto crop flag
         self.segment_data = None  # Segment data
         self.outlines = None  # Outlines data
         self.calibration_data = None  # Calibration data
-        self.charger_pos = None  # Charger position
         self.crop_area = None  # Crop area
-        self.crop_img_size = []  # Crop image size
         self.data = RandImageData  # Image Data
-        self.frame_number = 0  # Image Frame number
-        self.max_frames = 1024
         self.go_to = None  # Go to position data
         self.img_base_layer = None  # Base image layer
         self.img_rotate = camera_shared.image_rotate  # Image rotation
-        self.img_size = None  # Image size
-        self.json_data = None  # Json data
-        self.json_id = None  # Json id
-        self.path_pixels = None  # Path pixels data
-        self.robot_in_room = None  # Robot in room data
-        self.robot_pos = None  # Robot position
         self.room_propriety = None  # Room propriety data
-        self.rooms_pos = None  # Rooms position data
         self.shared = camera_shared  # Shared data
         self.active_zones = None  # Active zones
         self.trim_down = None  # Trim down
@@ -67,14 +57,11 @@ class ReImageHandler:
         self.trim_up = None  # Trim up
         self.zooming = False  # Zooming flag
         self.file_name = self.shared.file_name  # File name
-        self.offset_x = 0  # offset x for the aspect ratio.
-        self.offset_y = 0  # offset y for the aspect ratio.
         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.imu = ImUtils(self)  # Image Utils
         self.ac = AutoCrop(self)
 
     async def extract_room_properties(
@@ -132,9 +119,9 @@ class ReImageHandler:
                             "y": (y_min + y_max) // 2,
                         }
                 # get the zones and points data
-                zone_properties = await self.imu.async_zone_propriety(zones_data)
+                zone_properties = await self.async_zone_propriety(zones_data)
                 # get the points data
-                point_properties = await self.imu.async_points_propriety(points_data)
+                point_properties = await self.async_points_propriety(points_data)
                 if room_properties or zone_properties:
                     extracted_data = [
                         f"{len(room_properties)} Rooms" if room_properties else None,
@@ -186,7 +173,7 @@ class ReImageHandler:
 
                 # Increment frame number
                 self.frame_number += 1
-                img_np_array = await self.imd.async_copy_array(self.img_base_layer)
+                img_np_array = await self.async_copy_array(self.img_base_layer)
                 _LOGGER.debug(
                     "%s: Frame number %s", self.file_name, str(self.frame_number)
                 )
@@ -240,7 +227,7 @@ class ReImageHandler:
                         (robot_position[1] * 10),
                         robot_position_angle,
                     )
-            self.img_base_layer = await self.imd.async_copy_array(img_np_array)
+            self.img_base_layer = await self.async_copy_array(img_np_array)
         return self.img_base_layer, robot_position, robot_position_angle
 
     async def _draw_map_elements(
@@ -285,59 +272,12 @@ class ReImageHandler:
             width = self.shared.image_ref_width
             height = self.shared.image_ref_height
             if self.shared.image_aspect_ratio != "None":
-                wsf, hsf = [int(x) for x in self.shared.image_aspect_ratio.split(",")]
-                _LOGGER.debug("Aspect Ratio: %s, %s", str(wsf), str(hsf))
-                if wsf == 0 or hsf == 0:
-                    return pil_img
-                new_aspect_ratio = wsf / hsf
-                aspect_ratio = width / height
-                if aspect_ratio > 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)
-
-                resized = ImageOps.pad(pil_img, (new_width, new_height))
-                (
-                    self.crop_img_size[0],
-                    self.crop_img_size[1],
-                ) = await self.async_map_coordinates_offset(
-                    wsf, hsf, new_width, new_height
+                pil_img = await self.async_resize_image(
+                    pil_img, width, height, self.shared.image_aspect_ratio, True
                 )
-                _LOGGER.debug(
-                    "%s: Image Aspect Ratio: %s, %s",
-                    self.file_name,
-                    str(wsf),
-                    str(hsf),
-                )
-                _LOGGER.debug("%s: Resized Frame Completed.", self.file_name)
-                return resized
-            _LOGGER.debug("%s: Padded Frame Completed.", self.file_name)
-            return ImageOps.pad(pil_img, (width, height))
         _LOGGER.debug("%s: Frame Completed.", self.file_name)
         return pil_img
 
-    def get_frame_number(self) -> int:
-        """Return the frame number."""
-        return self.frame_number
-
-    def get_robot_position(self) -> Any:
-        """Return the robot position."""
-        return self.robot_pos
-
-    def get_charger_position(self) -> Any:
-        """Return the charger position."""
-        return self.charger_pos
-
-    def get_img_size(self) -> Any:
-        """Return the image size."""
-        return self.img_size
-
-    def get_json_id(self) -> str:
-        """Return the json id."""
-        return self.json_id
-
     async def get_rooms_attributes(
         self, destinations: JsonType = None
     ) -> RoomsProperties:
@@ -436,18 +376,10 @@ class ReImageHandler:
             )
 
             # Define the map points (fixed)
-            map_points = [
-                {"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
-            ]
+            map_points = self.get_map_points()
 
             # Valetudo Re version need corrections of the coordinates and are implemented with *10
-            vacuum_points = self.imu.re_get_vacuum_points(rotation_angle)
+            vacuum_points = self.re_get_vacuum_points(rotation_angle)
 
             # Create the calibration data for each point
             for vacuum_point, map_point in zip(vacuum_points, map_points):
@@ -455,24 +387,3 @@ class ReImageHandler:
                 self.calibration_data.append(calibration_point)
 
         return self.calibration_data
-
-    async def async_map_coordinates_offset(
-        self, wsf: int, hsf: int, width: int, height: int
-    ) -> tuple[int, int]:
-        """
-        Offset the coordinates to the map.
-        """
-
-        if wsf == 1 and hsf == 1:
-            self.imu.set_image_offset_ratio_1_1(width, height, rand256=True)
-        elif wsf == 2 and hsf == 1:
-            self.imu.set_image_offset_ratio_2_1(width, height, rand256=True)
-        elif wsf == 3 and hsf == 2:
-            self.imu.set_image_offset_ratio_3_2(width, height, rand256=True)
-        elif wsf == 5 and hsf == 4:
-            self.imu.set_image_offset_ratio_5_4(width, height, rand256=True)
-        elif wsf == 9 and hsf == 16:
-            self.imu.set_image_offset_ratio_9_16(width, height, rand256=True)
-        elif wsf == 16 and hsf == 9:
-            self.imu.set_image_offset_ratio_16_9(width, height, rand256=True)
-        return width, height

valetudo_map_parser/reimg_draw.py

@@ -6,8 +6,6 @@ Version: 2024.12.0
 
 from __future__ import annotations
 
-import hashlib
-import json
 import logging
 
 from .config.drawable import Drawable
@@ -299,25 +297,6 @@ class ImageDraw:
             _LOGGER.info("%s: Got the points in the json.", self.file_name)
         return entity_dict
 
-    @staticmethod
-    async def async_copy_array(original_array: NumpyArray) -> NumpyArray:
-        """Copy the array."""
-        return NumpyArray.copy(original_array)
-
-    async def calculate_array_hash(self, layers: dict, active: list[int] = None) -> str:
-        """Calculate the hash of the image based on the layers and active segments walls."""
-        self.img_h.active_zones = active
-        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)
-            hash_value = hashlib.sha256(data_json.encode()).hexdigest()
-        else:
-            hash_value = None
-        return hash_value
-
     async def async_get_robot_position(self, m_json: JsonType) -> tuple | None:
         """Get the robot position from the entity data."""
         robot_pos = None

{valetudo_map_parser-0.1.9b4.dist-info → valetudo_map_parser-0.1.9b6.dist-info}/METADATA

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

@@ -6,15 +6,15 @@ valetudo_map_parser/config/drawable.py,sha256=hsrEJCMVOrjs5sJfr26SeqJD0VNlYWwxcV
 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/hypfer_draw.py,sha256=YuxkAUfWphnyHLyUyTlMTvQlxRtfkTZalzV3cQkiqDs,15752
-valetudo_map_parser/hypfer_handler.py,sha256=LpC2ez-XEioURzbOYlg89BKC7N21txKDe835rxBxcJs,18456
-valetudo_map_parser/images_utils.py,sha256=0Baq48oncJy6Z_HxaRhMuknt3TMhBxl92BGDGhw-HYo,15262
+valetudo_map_parser/config/utils.py,sha256=W4meKptsRCAmfNLGPktFy1GiBM1F6tLLZW750VCwCJ8,16717
+valetudo_map_parser/hypfer_draw.py,sha256=JFiWb-06WI1Gt0TrIl2ieBVLHe1_zxh4h9N7V5dXtaM,14951
+valetudo_map_parser/hypfer_handler.py,sha256=SAQFg0VUEA5tDdvnAqDOD6oM_1v5EMRFHwuUcyBmN9g,14087
 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=gHVoD5SrgViXVoUQTKb0AImdh2kWfzaRPFtco1kt3_0,19566
-valetudo_map_parser/reimg_draw.py,sha256=RpqPEjVOF0W2Ug7QhqB2ZI3KI_GBs9Sbo_7A7E9Lt_4,13307
-valetudo_map_parser-0.1.9b4.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
-valetudo_map_parser-0.1.9b4.dist-info/METADATA,sha256=zqs2g9pQpNfMw2veVYffGtMc5r2v0Alb4AS7LXZYInM,1028
-valetudo_map_parser-0.1.9b4.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
-valetudo_map_parser-0.1.9b4.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-valetudo_map_parser-0.1.9b4.dist-info/RECORD,,
+valetudo_map_parser/rand25_handler.py,sha256=vph1BCO0g77kTi18y6sqqJfyJfT5033l9CoxJIDO1Ak,15827
+valetudo_map_parser/reimg_draw.py,sha256=dtdbYKKxmQnbOaHBHayWEF07OdSnTKo2CPSOW0qpgH0,12506
+valetudo_map_parser-0.1.9b6.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
+valetudo_map_parser-0.1.9b6.dist-info/METADATA,sha256=khbAEjQwo2HSh1P9JHBa3OX1tei2MtdgvA2_mWTvvJM,1028
+valetudo_map_parser-0.1.9b6.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
+valetudo_map_parser-0.1.9b6.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+valetudo_map_parser-0.1.9b6.dist-info/RECORD,,