valetudo-map-parser 0.1.9b40__py3-none-any.whl → 0.1.9b41__py3-none-any.whl

valetudo_map_parser/config/auto_crop.py

@@ -118,7 +118,7 @@ class AutoCrop:
         """Initialize the auto crop data."""
         _LOGGER.debug("Auto Crop Init data: %s", str(self.auto_crop))
         _LOGGER.debug(
-            "Auto Crop Init trims data: %s", self.handler.shared.trims.to_dict()
+            "Auto Crop Init trims data: %r", self.handler.shared.trims.to_dict()
         )
         if not self.auto_crop:  # and self.handler.shared.vacuum_state == "docked":
             self.auto_crop = await self._async_auto_crop_data(self.handler.shared.trims)

valetudo_map_parser/config/drawable.py

@@ -4,48 +4,54 @@ Drawable is part of the Image_Handler
 used functions to draw the elements on the Numpy Array
 that is actually our camera frame.
 Version: v2024.12.0
+Refactored for clarity, consistency, and optimized parameter usage.
 """
 
 from __future__ import annotations
 
+import asyncio
 import math
 
 import numpy as np
 from PIL import ImageDraw, ImageFont
 
-from .types import Color, NumpyArray, PilPNG, Point, Union
+from .types import Color, NumpyArray, PilPNG, Point, Tuple, Union
 
 
 class Drawable:
     """
     Collection of drawing utility functions for the image handlers.
-    This class contains static methods to draw various elements on the Numpy Arrays (images).
-    We cant use openCV because it is not supported by the Home Assistant OS.
+    This class contains static methods to draw various elements on NumPy arrays (images).
+    We can't use OpenCV because it is not supported by the Home Assistant OS.
     """
 
-    ERROR_OUTLINE = (0, 0, 0, 255)  # Red color for error messages
-    ERROR_COLOR = (255, 0, 0, 191)  # Red color with lower opacity for error outlines
+    ERROR_OUTLINE: Color = (0, 0, 0, 255)  # Red color for error messages
+    ERROR_COLOR: Color = (
+        255,
+        0,
+        0,
+        191,
+    )  # Red color with lower opacity for error outlines
 
     @staticmethod
     async def create_empty_image(
         width: int, height: int, background_color: Color
     ) -> NumpyArray:
-        """Create the empty background image numpy array.
-        Background color is specified as RGBA tuple."""
-        image_array = np.full((height, width, 4), background_color, dtype=np.uint8)
-        return image_array
+        """Create the empty background image NumPy array.
+        Background color is specified as an RGBA tuple."""
+        return np.full((height, width, 4), background_color, dtype=np.uint8)
 
     @staticmethod
     async def from_json_to_image(
         layer: NumpyArray, pixels: Union[dict, list], pixel_size: int, color: Color
     ) -> NumpyArray:
-        """Drawing the layers (rooms) from the vacuum json data."""
+        """Draw the layers (rooms) from the vacuum JSON data onto the image array."""
         image_array = layer
         # Loop through pixels to find min and max coordinates
         for x, y, z in pixels:
             col = x * pixel_size
             row = y * pixel_size
-            # Draw pixels
+            # Draw pixels as blocks
             for i in range(z):
                 image_array[
                     row : row + pixel_size,
@@ -60,12 +66,10 @@ class Drawable:
         """Draw the battery charger on the input layer."""
         charger_width = 10
         charger_height = 20
-        # Get the starting and ending indices of the charger rectangle
         start_row = y - charger_height // 2
         end_row = start_row + charger_height
         start_col = x - charger_width // 2
         end_col = start_col + charger_width
-        # Fill in the charger rectangle with the specified color
         layers[start_row:end_row, start_col:end_col] = color
         return layers
 
@@ -74,13 +78,10 @@ class Drawable:
         layer: NumpyArray, center: Point, rotation_angle: int, flag_color: Color
     ) -> NumpyArray:
         """
-        It is draw a flag on centered at specified coordinates on
-        the input layer. It uses the rotation angle of the image
-        to orientate the flag on the given layer.
+        Draw a flag centered at specified coordinates on the input layer.
+        It uses the rotation angle of the image to orient the flag.
         """
-        # Define flag color
-        pole_color = (0, 0, 255, 255)  # RGBA color (blue)
-        # Define flag size and position
+        pole_color: Color = (0, 0, 255, 255)  # Blue for the pole
         flag_size = 50
         pole_width = 6
         # Adjust flag coordinates based on rotation angle
@@ -91,23 +92,16 @@ class Drawable:
             y2 = y1 + (flag_size // 2)
             x3 = center[0] + (flag_size // 2)
             y3 = center[1] - (pole_width // 2)
-            # Define pole end position
-            xp1 = center[0]
-            yp1 = center[1] - (pole_width // 2)
-            xp2 = center[0] + flag_size
-            yp2 = center[1] - (pole_width // 2)
+            xp1, yp1 = center[0], center[1] - (pole_width // 2)
+            xp2, yp2 = center[0] + flag_size, center[1] - (pole_width // 2)
         elif rotation_angle == 180:
             x1 = center[0]
             y1 = center[1] - (flag_size // 2)
             x2 = center[0] - (flag_size // 2)
             y2 = y1 + (flag_size // 4)
-            x3 = center[0]
-            y3 = center[1]
-            # Define pole end position
-            xp1 = center[0] + (pole_width // 2)
-            yp1 = center[1] - flag_size
-            xp2 = center[0] + (pole_width // 2)
-            yp2 = y3
+            x3, y3 = center[0], center[1]
+            xp1, yp1 = center[0] + (pole_width // 2), center[1] - flag_size
+            xp2, yp2 = center[0] + (pole_width // 2), y3
         elif rotation_angle == 270:
             x1 = center[0] - flag_size
             y1 = center[1] + (pole_width // 2)
@@ -115,61 +109,40 @@ class Drawable:
             y2 = y1 - (flag_size // 2)
             x3 = center[0] - (flag_size // 2)
             y3 = center[1] + (pole_width // 2)
-            # Define pole end position
-            xp1 = center[0] - flag_size
-            yp1 = center[1] + (pole_width // 2)
-            xp2 = center[0]
-            yp2 = center[1] + (pole_width // 2)
-        else:
-            # rotation_angle == 0 (no rotation)
-            x1 = center[0]
-            y1 = center[1]
-            x2 = center[0] + (flag_size // 2)
-            y2 = y1 + (flag_size // 4)
-            x3 = center[0]
-            y3 = center[1] + flag_size // 2
-            # Define pole end position
-            xp1 = center[0] - (pole_width // 2)
-            yp1 = y1
-            xp2 = center[0] - (pole_width // 2)
-            yp2 = center[1] + flag_size
+            xp1, yp1 = center[0] - flag_size, center[1] + (pole_width // 2)
+            xp2, yp2 = center[0], center[1] + (pole_width // 2)
+        else:  # rotation_angle == 0 (no rotation)
+            x1, y1 = center[0], center[1]
+            x2, y2 = center[0] + (flag_size // 2), center[1] + (flag_size // 4)
+            x3, y3 = center[0], center[1] + flag_size // 2
+            xp1, yp1 = center[0] - (pole_width // 2), y1
+            xp2, yp2 = center[0] - (pole_width // 2), center[1] + flag_size
 
         # Draw flag outline using _polygon_outline
         points = [(x1, y1), (x2, y2), (x3, y3)]
         layer = Drawable._polygon_outline(layer, points, 1, flag_color, flag_color)
-
         # Draw pole using _line
         layer = Drawable._line(layer, xp1, yp1, xp2, yp2, pole_color, pole_width)
-
         return layer
 
     @staticmethod
-    def point_inside(x: int, y: int, points) -> bool:
+    def point_inside(x: int, y: int, points: list[Tuple[int, int]]) -> bool:
         """
         Check if a point (x, y) is inside a polygon defined by a list of points.
-        Utility to establish the fill point of the geometry.
-        Parameters:
-        - x, y: Coordinates of the point to check.
-        - points: List of (x, y) coordinates defining the polygon.
-
-        Returns:
-        - True if the point is inside the polygon, False otherwise.
         """
         n = len(points)
         inside = False
-        xinters = 0
+        xinters = 0.0
         p1x, p1y = points[0]
         for i in range(1, n + 1):
             p2x, p2y = points[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
+                if y <= max(p1y, p2y) and 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
 
     @staticmethod
@@ -183,47 +156,29 @@ class Drawable:
         width: int = 3,
     ) -> NumpyArray:
         """
-        Draw a line on a NumPy array (layer) from point A to B.
-        Parameters:
-        - layer: NumPy array representing the image.
-        - x1, y1: Starting coordinates of the line.
-        - x2, y2: Ending coordinates of the line.
-        - color: Color of the line (e.g., [R, G, B] or [R, G, B, A] for RGBA).
-        - width: Width of the line (default is 3).
-
-        Returns:
-        - Modified layer with the line drawn.
+        Draw a line on a NumPy array (layer) from point A to B using Bresenham's algorithm.
         """
-        # Ensure the coordinates are integers
         x1, y1, x2, y2 = int(x1), int(y1), int(x2), int(y2)
-
-        # Use Bresenham's line algorithm to get the coordinates of the line pixels
         dx = abs(x2 - x1)
         dy = abs(y2 - y1)
         sx = 1 if x1 < x2 else -1
         sy = 1 if y1 < y2 else -1
         err = dx - dy
-
         while True:
-            # Draw a rectangle with the specified width at the current coordinates
+            # Draw a rectangle at the current coordinates with the specified width
             for i in range(-width // 2, (width + 1) // 2):
                 for j in range(-width // 2, (width + 1) // 2):
                     if 0 <= x1 + i < layer.shape[1] and 0 <= y1 + j < layer.shape[0]:
                         layer[y1 + j, x1 + i] = color
-
             if x1 == x2 and y1 == y2:
                 break
-
             e2 = 2 * err
-
             if e2 > -dy:
                 err -= dy
                 x1 += sx
-
             if e2 < dx:
                 err += dx
                 y1 += sy
-
         return layer
 
     @staticmethod
@@ -243,23 +198,20 @@ class Drawable:
     @staticmethod
     async def lines(arr: NumpyArray, coords, width: int, color: Color) -> NumpyArray:
         """
-        it joins the coordinates creating a continues line.
-        the result is our path.
+        Join the coordinates creating a continuous line (path).
         """
         for coord in coords:
-            # Use Bresenham's line algorithm to get the coordinates of the line pixels
             x0, y0 = coord[0]
             try:
                 x1, y1 = coord[1]
             except IndexError:
-                x1 = x0
-                y1 = y0
+                x1, y1 = x0, y0
             dx = abs(x1 - x0)
             dy = abs(y1 - y0)
             sx = 1 if x0 < x1 else -1
             sy = 1 if y0 < y1 else -1
             err = dx - dy
-            line_pixels = []
+            line_pixels: list[Tuple[int, int]] = []
             while True:
                 line_pixels.append((x0, y0))
                 if x0 == x1 and y0 == y1:
@@ -271,14 +223,13 @@ class Drawable:
                 if e2 < dx:
                     err += dx
                     y0 += sy
-
-            # Iterate over the line pixels and draw filled rectangles with the specified width
+            # Draw filled rectangles for each pixel in the line
             for pixel in line_pixels:
                 x, y = pixel
                 for i in range(width):
                     for j in range(width):
-                        if 0 <= x + i < arr.shape[0] and 0 <= y + j < arr.shape[1]:
-                            arr[y + i, x + j] = color
+                        if 0 <= x + i < arr.shape[1] and 0 <= y + j < arr.shape[0]:
+                            arr[y + j, x + i] = color
         return arr
 
     @staticmethod
@@ -292,30 +243,47 @@ class Drawable:
     ) -> NumpyArray:
         """
         Draw a filled circle on the image using NumPy.
-
-        Parameters:
-        - image: NumPy array representing the image.
-        - center: Center coordinates of the circle (x, y).
-        - radius: Radius of the circle.
-        - color: Color of the circle (e.g., [R, G, B] or [R, G, B, A] for RGBA).
-
-        Returns:
-        - Modified image with the filled circle drawn.
         """
         y, x = center
         rr, cc = np.ogrid[: image.shape[0], : image.shape[1]]
         circle = (rr - x) ** 2 + (cc - y) ** 2 <= radius**2
         image[circle] = color
         if outline_width > 0:
-            # Create a mask for the outer circle
             outer_circle = (rr - x) ** 2 + (cc - y) ** 2 <= (
                 radius + outline_width
             ) ** 2
-            # Create a mask for the outline by subtracting the inner circle mask from the outer circle mask
             outline_mask = outer_circle & ~circle
-            # Fill the outline with the outline color
             image[outline_mask] = outline_color
+        return image
 
+    @staticmethod
+    def _filled_circle_optimized(
+        image: np.ndarray,
+        center: Tuple[int, int],
+        radius: int,
+        color: Color,
+        outline_color: Color = None,
+        outline_width: int = 0,
+    ) -> np.ndarray:
+        """
+        Optimized _filled_circle ensuring dtype compatibility with uint8.
+        """
+        x, y = center
+        h, w = image.shape[:2]
+        color_np = np.array(color, dtype=image.dtype)
+        outline_color_np = (
+            np.array(outline_color, dtype=image.dtype)
+            if outline_color is not None
+            else None
+        )
+        y_indices, x_indices = np.meshgrid(np.arange(h), np.arange(w), indexing="ij")
+        dist_sq = (y_indices - y) ** 2 + (x_indices - x) ** 2
+        circle_mask = dist_sq <= radius**2
+        image[circle_mask] = color_np
+        if outline_width > 0 and outline_color_np is not None:
+            outer_mask = dist_sq <= (radius + outline_width) ** 2
+            outline_mask = outer_mask & ~circle_mask
+            image[outline_mask] = outline_color_np
         return image
 
     @staticmethod
@@ -325,32 +293,26 @@ class Drawable:
         """
         Draw an ellipse on the image using NumPy.
         """
-        # Create a copy of the image to avoid modifying the original
-        result_image = image
-        # Calculate the coordinates of the ellipse's bounding box
         x, y = center
         x1, y1 = x - radius, y - radius
         x2, y2 = x + radius, y + radius
-        # Draw the filled ellipse
-        result_image[y1:y2, x1:x2] = color
-        return result_image
+        image[y1:y2, x1:x2] = color
+        return image
 
     @staticmethod
     def _polygon_outline(
         arr: NumpyArray,
-        points,
+        points: list[Tuple[int, int]],
         width: int,
         outline_color: Color,
         fill_color: Color = None,
     ) -> NumpyArray:
         """
-        Draw the outline of a filled polygon on the array using _line.
+        Draw the outline of a polygon on the array using _line, and optionally fill it.
         """
-        for i, point in enumerate(points):
-            # Get the current and next points to draw a line between them
+        for i, _ in enumerate(points):
             current_point = points[i]
-            next_point = points[(i + 1) % len(points)]  # Wrap around to the first point
-            # Use the _line function to draw a line between the current and next points
+            next_point = points[(i + 1) % len(points)]
             arr = Drawable._line(
                 arr,
                 current_point[0],
@@ -360,13 +322,11 @@ class Drawable:
                 outline_color,
                 width,
             )
-            # Fill the polygon area with the specified fill color
             if fill_color is not None:
-                min_x = min(point[0] for point in points)
-                max_x = max(point[0] for point in points)
-                min_y = min(point[1] for point in points)
-                max_y = max(point[1] for point in points)
-                # check if we are inside the area and set the color
+                min_x = min(p[0] for p in points)
+                max_x = max(p[0] for p in points)
+                min_y = min(p[1] for p in points)
+                max_y = max(p[1] for p in points)
                 for x in range(min_x, max_x + 1):
                     for y in range(min_y, max_y + 1):
                         if Drawable.point_inside(x, y, points):
@@ -378,17 +338,14 @@ class Drawable:
         """
         Draw the zones on the input layer.
         """
-        dot_radius = 1  # number of pixels the dot should be
-        dot_spacing = 4  # space between dots.
-        # Iterate over zones
+        dot_radius = 1  # Number of pixels for the dot
+        dot_spacing = 4  # Space between dots
         for zone in coordinates:
             points = zone["points"]
-            # determinate the points to cover.
             min_x = min(points[::2])
             max_x = max(points[::2])
             min_y = min(points[1::2])
             max_y = max(points[1::2])
-            # Draw ellipses (dots)
             for y in range(min_y, max_y, dot_spacing):
                 for x in range(min_x, max_x, dot_spacing):
                     for _ in range(dot_radius):
@@ -405,40 +362,29 @@ class Drawable:
         robot_state: str | None = None,
     ) -> NumpyArray:
         """
-        We Draw the robot with in a smaller array
-        this helps numpy to work faster and at lower
-        memory cost.
+        Draw the robot on a smaller array to reduce memory cost.
         """
-        # Create a 52*52 empty image numpy array of the background
         top_left_x = x - 26
         top_left_y = y - 26
         bottom_right_x = top_left_x + 52
         bottom_right_y = top_left_y + 52
         tmp_layer = layers[top_left_y:bottom_right_y, top_left_x:bottom_right_x].copy()
-        # centre of the above array is used from the rest of the code.
-        # to draw the robot.
         tmp_x, tmp_y = 26, 26
-        # Draw Robot
-        radius = 25  # Radius of the vacuum constant
-        r_scaled = radius // 11  # Offset scale for placement of the objects.
-        r_cover = r_scaled * 12  # Scale factor for cover
-        lidar_angle = np.deg2rad(
-            angle + 90
-        )  # Convert angle to radians and adjust for LIDAR orientation
-        r_lidar = r_scaled * 3  # Scale factor for the lidar
-        r_button = r_scaled * 1  # scale factor of the button
-        # Outline colour from fill colour
+        radius = 25
+        r_scaled = radius // 11
+        r_cover = r_scaled * 12
+        lidar_angle = np.deg2rad(angle + 90)
+        r_lidar = r_scaled * 3
+        r_button = r_scaled * 1
         if robot_state == "error":
             outline = Drawable.ERROR_OUTLINE
             fill = Drawable.ERROR_COLOR
         else:
             outline = (fill[0] // 2, fill[1] // 2, fill[2] // 2, fill[3])
-        # Draw the robot outline
         tmp_layer = Drawable._filled_circle(
             tmp_layer, (tmp_x, tmp_y), radius, fill, outline, 1
         )
-        # Draw bin cover
-        angle -= 90  # we remove 90 for the cover orientation
+        angle -= 90
         a1 = ((angle + 90) - 80) / 180 * math.pi
         a2 = ((angle + 90) + 80) / 180 * math.pi
         x1 = int(tmp_x - r_cover * math.sin(a1))
@@ -446,25 +392,17 @@ class Drawable:
         x2 = int(tmp_x - r_cover * math.sin(a2))
         y2 = int(tmp_y + r_cover * math.cos(a2))
         tmp_layer = Drawable._line(tmp_layer, x1, y1, x2, y2, outline, width=1)
-        # Draw Lidar
-        lidar_x = int(tmp_x + 15 * np.cos(lidar_angle))  # Calculate LIDAR x-coordinate
-        lidar_y = int(tmp_y + 15 * np.sin(lidar_angle))  # Calculate LIDAR y-coordinate
+        lidar_x = int(tmp_x + 15 * np.cos(lidar_angle))
+        lidar_y = int(tmp_y + 15 * np.sin(lidar_angle))
         tmp_layer = Drawable._filled_circle(
             tmp_layer, (lidar_x, lidar_y), r_lidar, outline
         )
-        # Draw Button
-        butt_x = int(
-            tmp_x - 20 * np.cos(lidar_angle)
-        )  # Calculate the button x-coordinate
-        butt_y = int(
-            tmp_y - 20 * np.sin(lidar_angle)
-        )  # Calculate the button y-coordinate
+        butt_x = int(tmp_x - 20 * np.cos(lidar_angle))
+        butt_y = int(tmp_y - 20 * np.sin(lidar_angle))
         tmp_layer = Drawable._filled_circle(
             tmp_layer, (butt_x, butt_y), r_button, outline
         )
-        # at last overlay the new robot image to the layer in input.
         layers = Drawable.overlay_robot(layers, tmp_layer, x, y)
-        # return the new layer as np array.
         return layers
 
     @staticmethod
@@ -473,50 +411,55 @@ class Drawable:
     ) -> NumpyArray:
         """
         Overlay the robot image on the background image at the specified coordinates.
-        @param background_image:
-        @param robot_image:
-        @param robot x:
-        @param robot y:
-        @return: robot image overlaid on the background image.
         """
-        # Calculate the dimensions of the robot image
         robot_height, robot_width, _ = robot_image.shape
-        # Calculate the center of the robot image (in case const changes)
         robot_center_x = robot_width // 2
         robot_center_y = robot_height // 2
-        # Calculate the position to overlay the robot on the background image
         top_left_x = x - robot_center_x
         top_left_y = y - robot_center_y
         bottom_right_x = top_left_x + robot_width
         bottom_right_y = top_left_y + robot_height
-        # Overlay the robot on the background image
         background_image[top_left_y:bottom_right_y, top_left_x:bottom_right_x] = (
             robot_image
         )
         return background_image
 
     @staticmethod
-    def draw_obstacles(
-        image: NumpyArray, obstacle_info_list, color: Color
-    ) -> NumpyArray:
+    def draw_filled_circle(
+        image: np.ndarray,
+        centers: Tuple[int, int],
+        radius: int,
+        color: Tuple[int, int, int, int],
+    ) -> np.ndarray:
         """
-        Draw filled circles for obstacles on the image.
-        Parameters:
-        - image: NumPy array representing the image.
-        - obstacle_info_list: List of dictionaries containing obstacle information.
-        Returns:
-        - Modified image with filled circles for obstacles.
+        Draw multiple filled circles at once using a single NumPy mask.
         """
-        for obstacle_info in obstacle_info_list:
-            enter = obstacle_info.get("points", {})
-            # label = obstacle_info.get("label", {})
-            center = (enter["x"], enter["y"])
+        h, w = image.shape[:2]
+        y_indices, x_indices = np.ogrid[:h, :w]  # Precompute coordinate grids
+        mask = np.zeros((h, w), dtype=bool)
+        for cx, cy in centers:
+            mask |= (x_indices - cx) ** 2 + (y_indices - cy) ** 2 <= radius**2
+        image[mask] = color
+        return image
 
-            radius = 6
+    @staticmethod
+    async def async_draw_obstacles(
+        image: np.ndarray, obstacle_info_list, color: Tuple[int, int, int, int]
+    ) -> np.ndarray:
+        """
+        Optimized async version of draw_obstacles using asyncio.gather().
+        """
 
-            # Draw filled circle
-            image = Drawable._filled_circle(image, center, radius, color)
+        def extract_centers(obs_list) -> np.ndarray:
+            return np.array(
+                [[obs["points"]["x"], obs["points"]["y"]] for obs in obs_list],
+                dtype=np.int32,
+            )
 
+        centers = await asyncio.get_running_loop().run_in_executor(
+            None, extract_centers, obstacle_info_list
+        )
+        Drawable.draw_filled_circle(image, centers, 6, color)
         return image
 
     @staticmethod
@@ -528,32 +471,24 @@ class Drawable:
         path_font: str,
         position: bool,
     ) -> None:
-        """Draw the Status Test on the image."""
-        # Load a fonts
+        """Draw the status text on the image."""
         path_default_font = (
             "custom_components/mqtt_vacuum_camera/utils/fonts/FiraSans.ttf"
         )
         default_font = ImageFont.truetype(path_default_font, size)
         user_font = ImageFont.truetype(path_font, size)
-        # Define the text and position
         if position:
             x, y = 10, 10
         else:
             x, y = 10, image.height - 20 - size
-        # Create a drawing object
         draw = ImageDraw.Draw(image)
-        # Draw the text
         for text in status:
             if "\u2211" in text or "\u03de" in text:
                 font = default_font
                 width = None
             else:
                 font = user_font
-                is_variable = path_font.endswith("VT.ttf")
-                if is_variable:
-                    width = 2
-                else:
-                    width = None
+                width = 2 if path_font.endswith("VT.ttf") else None
             if width:
                 draw.text((x, y), text, font=font, fill=color, stroke_width=width)
             else:

valetudo_map_parser/config/shared.py

@@ -125,7 +125,8 @@ class CameraShared:
 
     def reset_trims(self) -> dict:
         """Reset the trims."""
-        return self.trims.clear()
+        self.trims = TrimsData.from_dict(DEFAULT_VALUES["trims_data"])
+        return self.trims
 
     async def batch_update(self, **kwargs):
         """Batch update multiple attributes."""

valetudo_map_parser/config/types.py

@@ -613,20 +613,22 @@ class CameraModes:
 class TrimsData:
     """Dataclass to store and manage trims data."""
 
-    trim_left: int = 0
+    floor: str = ""
     trim_up: int = 0
-    trim_right: int = 0
+    trim_left: int = 0
     trim_down: int = 0
+    trim_right: int = 0
 
     @classmethod
     def from_json(cls, json_data: str):
         """Create a TrimsConfig instance from a JSON string."""
         data = json.loads(json_data)
         return cls(
-            trim_left=data.get("trim_left", 0),
+            floor=data.get("floor", ""),
             trim_up=data.get("trim_up", 0),
-            trim_right=data.get("trim_right", 0),
+            trim_left=data.get("trim_left", 0),
             trim_down=data.get("trim_down", 0),
+            trim_right=data.get("trim_right", 0),
         )
 
     def to_json(self) -> str:
@@ -644,8 +646,13 @@ class TrimsData:
 
     def clear(self) -> dict:
         """Clear all the trims."""
-        self.trim_left = 0
+        self.floor = ""
         self.trim_up = 0
-        self.trim_right = 0
+        self.trim_left = 0
         self.trim_down = 0
+        self.trim_right = 0
         return asdict(self)
+
+    def self_instance(self):
+        """Return self instance."""
+        return self.self_instance()

valetudo_map_parser/hypfer_draw.py

@@ -135,7 +135,7 @@ class ImageDraw:
             # List of dictionaries containing label and points for each obstacle
             # and draw obstacles on the map
             if obstacle_positions:
-                self.img_h.draw.draw_obstacles(
+                await self.img_h.draw.async_draw_obstacles(
                     np_array, obstacle_positions, color_no_go
                 )
             return np_array

valetudo_map_parser-0.1.9b41.dist-info/METADATA

@@ -0,0 +1,47 @@
+Metadata-Version: 2.3
+Name: valetudo-map-parser
+Version: 0.1.9b41
+Summary: A Python library to parse Valetudo map data returning a PIL Image object.
+License: Apache-2.0
+Author: Sandro Cantarella
+Author-email: gsca075@gmail.com
+Requires-Python: >=3.12
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: Pillow (>=10.3.0)
+Requires-Dist: numpy (>=1.26.4)
+Project-URL: Bug Tracker, https://github.com/sca075/Python-package-valetudo-map-parser/issues
+Project-URL: Changelog, https://github.com/sca075/Python-package-valetudo-map-parser/releases
+Project-URL: Homepage, https://github.com/sca075/Python-package-valetudo-map-parser
+Project-URL: Repository, https://github.com/sca075/Python-package-valetudo-map-parser
+Description-Content-Type: text/markdown
+
+# Python-package-valetudo-map-parser
+#
+
+---
+### What is it:
+❗This is an _unofficial_ project and is not created, maintained, or in any sense linked to [valetudo.cloud](https://valetudo.cloud)
+
+Library to Covert Valetudo's Vacuums Json data in a PIL image.
+
+---
+
+It is developed and used in the [MQTT Vacuum Camera](https://github.com/sca075/mqtt_vacuum_camera).
+As python package this code relay on Pythons base and popular pakages such Pillow and Numpy.
+
+This library can be import by simply using ```pip install valetudo_map_parser```.
+
+- It is configured with a dictionary format (on GitHub repo test [sample code](https://github.com/sca075/Python-package-valetudo-map-parser/blob/main/tests/test.py)). 
+- It decodes Raw data provided from Rand256.
+- It provides functions to decode the json data provided from the vacuums.
+- It returns a Pillow PNG image.
+
+
+We are still working on the final release at current this library will be fully functional with >= v0.1.9. 
+
+Anyone can contribute to make this code batter, with code, docs or simply creating issues if any faced.
+In any cases please be aware that "as it is" of course apply if you decide to use it. 
+

{valetudo_map_parser-0.1.9b40.dist-info → valetudo_map_parser-0.1.9b41.dist-info}/RECORD

@@ -1,21 +1,21 @@
 valetudo_map_parser/__init__.py,sha256=Wmd20bdI1btzMq-0x8NxGYWskTjdUmD-Fem9MTfziwU,810
 valetudo_map_parser/config/__init__.py,sha256=DQ9plV3ZF_K25Dp5ZQHPDoG-40dQoJNdNi-dfNeR3Zc,48
-valetudo_map_parser/config/auto_crop.py,sha256=Wyjk3RCwp289R3HH-5PdLWYSimlaJcq4Xc1S_ca40l4,12624
+valetudo_map_parser/config/auto_crop.py,sha256=6OvRsWzXMXBaSEvgwpaaisNdozDKiDyTmPjknFxoUMc,12624
 valetudo_map_parser/config/colors.py,sha256=IzTT9JvF12YGGJxaTiEJRuwUdCCsFCLzsR9seCDfYWs,6515
 valetudo_map_parser/config/colors_man.py,sha256=9b5c6XmpMzhEiunwfIjVkOk1lDyV-UFoasACdkGXfbo,7833
-valetudo_map_parser/config/drawable.py,sha256=hsrEJCMVOrjs5sJfr26SeqJD0VNlYWwxcVkkHeaxx7U,20356
+valetudo_map_parser/config/drawable.py,sha256=CNuNBn1LNWaL2N30tS4jNaJhD5zV4wfGxXOhu0uaMZk,17788
 valetudo_map_parser/config/rand25_parser.py,sha256=kIayyqVZBfQfAMkiArzqrrj9vqZB3pkgT0Y5ufrQmGA,16448
-valetudo_map_parser/config/shared.py,sha256=LMjLixH4vcPb-uQPeza3CTWk0RpZdsfxEIJMaF_Dis0,10079
-valetudo_map_parser/config/types.py,sha256=qSstrRNnXzxfNjeR5XKKQi1qE3T10x4x8Id2_kOuZzM,18171
+valetudo_map_parser/config/shared.py,sha256=-3HPvFDu-31P14NLXxjZP1eaN1k-l7oYWWNHlRL7IeM,10142
+valetudo_map_parser/config/types.py,sha256=TAqFjELB7eZTFXq7kYvcgVqOcjprutRsuoQWPj54Rjc,18358
 valetudo_map_parser/config/utils.py,sha256=yPutV-FEQlDB2z3LhOOFznoprHCApF-zrQMiOtkcO-k,19198
-valetudo_map_parser/hypfer_draw.py,sha256=1trtil-CQcDSiAMBWPBmuP5L9MWHGTp5OlY7MX8FgDg,14932
+valetudo_map_parser/hypfer_draw.py,sha256=akeaReXXQJX2Xp4deC8fQoWpWmcKKPPBsFRNToEyZyc,14944
 valetudo_map_parser/hypfer_handler.py,sha256=f_1oG69BA94sjcZ8O9Y6A1H-YyEutbvERzqnwgremvg,13001
 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=UGRy-2IIgxZ880LlD95-vGrVdUREvM2iC1vbKhlh2eY,15249
 valetudo_map_parser/reimg_draw.py,sha256=V0JUASavKVnEtAhv7nOV4pjsRxZrNsjIUtctbKO8wvk,12507
-valetudo_map_parser-0.1.9b40.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
-valetudo_map_parser-0.1.9b40.dist-info/METADATA,sha256=cxuX6MhnWkss3yv_Y8GmQTreYGxyHO52cbH4iWzh9c4,1029
-valetudo_map_parser-0.1.9b40.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
-valetudo_map_parser-0.1.9b40.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-valetudo_map_parser-0.1.9b40.dist-info/RECORD,,
+valetudo_map_parser-0.1.9b41.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
+valetudo_map_parser-0.1.9b41.dist-info/METADATA,sha256=GFf-n6q6CxlHAC7FctF6MumKEJjXFXQKUtgGQWN5FVQ,2093
+valetudo_map_parser-0.1.9b41.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
+valetudo_map_parser-0.1.9b41.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+valetudo_map_parser-0.1.9b41.dist-info/RECORD,,

valetudo_map_parser-0.1.9b40.dist-info/METADATA

@@ -1,23 +0,0 @@
-Metadata-Version: 2.3
-Name: valetudo-map-parser
-Version: 0.1.9b40
-Summary: A Python library to parse Valetudo map data returning a PIL Image object.
-License: Apache-2.0
-Author: Sandro Cantarella
-Author-email: gsca075@gmail.com
-Requires-Python: >=3.12
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: Pillow (>=10.3.0)
-Requires-Dist: numpy (>=1.26.4)
-Project-URL: Bug Tracker, https://github.com/sca075/Python-package-valetudo-map-parser/issues
-Project-URL: Changelog, https://github.com/sca075/Python-package-valetudo-map-parser/releases
-Project-URL: Homepage, https://github.com/sca075/Python-package-valetudo-map-parser
-Project-URL: Repository, https://github.com/sca075/Python-package-valetudo-map-parser
-Description-Content-Type: text/markdown
-
-# Python-package-valetudo-map-parser
-Library to Covert Valetudo's Vacuums Json data in a PIL image.
-