valetudo-map-parser 0.1.10b6__tar.gz → 0.1.10rc2__tar.gz

{valetudo_map_parser-0.1.10b6 → valetudo_map_parser-0.1.10rc2}/PKG-INFO

@@ -1,16 +1,19 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: valetudo-map-parser
-Version: 0.1.10b6
+Version: 0.1.10rc2
 Summary: A Python library to parse Valetudo map data returning a PIL Image object.
 License: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE.txt
 Author: Sandro Cantarella
 Author-email: gsca075@gmail.com
-Requires-Python: >=3.12
+Requires-Python: >=3.13
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: Pillow (>=10.3.0)
+Requires-Dist: mvcrender (>=0.0.2)
 Requires-Dist: numpy (>=1.26.4)
 Requires-Dist: scipy (>=1.12.0)
 Project-URL: Bug Tracker, https://github.com/sca075/Python-package-valetudo-map-parser/issues

{valetudo_map_parser-0.1.10b6 → valetudo_map_parser-0.1.10rc2}/SCR/valetudo_map_parser/config/auto_crop.py

@@ -6,10 +6,9 @@ from __future__ import annotations
 import logging
 
 import numpy as np
-from numpy import rot90
 from scipy import ndimage
 
-from .async_utils import AsyncNumPy, make_async
+from .async_utils import AsyncNumPy
 from .types import Color, NumpyArray, TrimCropData, TrimsData
 from .utils import BaseHandler
 
@@ -91,7 +90,6 @@ class AutoCrop:
 
     async def _async_auto_crop_data(self, tdata: TrimsData):  # , tdata=None
         """Load the auto crop data from the Camera config."""
-        _LOGGER.debug("Auto Crop init data: %s, %s", str(tdata), str(self.auto_crop))
         if not self.auto_crop:
             trims_data = TrimCropData.from_dict(dict(tdata.to_dict())).to_list()
             (
@@ -100,7 +98,6 @@ class AutoCrop:
                 self.trim_right,
                 self.trim_down,
             ) = trims_data
-            _LOGGER.debug("Auto Crop trims data: %s", trims_data)
             if trims_data != [0, 0, 0, 0]:
                 self._calculate_trimmed_dimensions()
             else:
@@ -118,10 +115,6 @@ class AutoCrop:
 
     async def _init_auto_crop(self):
         """Initialize the auto crop data."""
-        _LOGGER.debug("Auto Crop Init data: %s", str(self.auto_crop))
-        _LOGGER.debug(
-            "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)
             if self.auto_crop:
@@ -131,7 +124,6 @@ class AutoCrop:
 
         # Fallback: Ensure auto_crop is valid
         if not self.auto_crop or any(v < 0 for v in self.auto_crop):
-            _LOGGER.debug("Auto-crop data unavailable. Scanning full image.")
             self.auto_crop = None
 
         return self.auto_crop
@@ -164,14 +156,6 @@ class AutoCrop:
         min_y, max_y = y_slice.start, y_slice.stop - 1
         min_x, max_x = x_slice.start, x_slice.stop - 1
 
-        _LOGGER.debug(
-            "%s: Found trims max and min values (y,x) (%s, %s) (%s, %s)...",
-            self.handler.file_name,
-            int(max_y),
-            int(max_x),
-            int(min_y),
-            int(min_x),
-        )
         return min_y, min_x, max_x, max_y
 
     async def async_get_room_bounding_box(
@@ -247,7 +231,7 @@ class AutoCrop:
             return None
 
         except Exception as e:
-            _LOGGER.error(
+            _LOGGER.warning(
                 "%s: Error calculating room bounding box for '%s': %s",
                 self.handler.file_name,
                 room_name,
@@ -403,7 +387,6 @@ class AutoCrop:
         try:
             self.auto_crop = await self._init_auto_crop()
             if (self.auto_crop is None) or (self.auto_crop == [0, 0, 0, 0]):
-                _LOGGER.debug("%s: Calculating auto trim box", self.handler.file_name)
                 # Find the coordinates of the first occurrence of a non-background color
                 min_y, min_x, max_x, max_y = await self.async_image_margins(
                     image_array, detect_colour
@@ -456,15 +439,7 @@ class AutoCrop:
             # Rotate the cropped image based on the given angle
             rotated = await self.async_rotate_the_image(trimmed, rotate)
             del trimmed  # Free memory.
-            _LOGGER.debug(
-                "%s: Auto Trim Box data: %s", self.handler.file_name, self.crop_area
-            )
             self.handler.crop_img_size = [rotated.shape[1], rotated.shape[0]]
-            _LOGGER.debug(
-                "%s: Auto Trimmed image size: %s",
-                self.handler.file_name,
-                self.handler.crop_img_size,
-            )
 
         except RuntimeError as e:
             _LOGGER.warning(

{valetudo_map_parser-0.1.10b6 → valetudo_map_parser-0.1.10rc2}/SCR/valetudo_map_parser/config/colors.py

@@ -250,7 +250,7 @@ class ColorsManagement:
             List[Tuple[int, int, int, int]]: List of RGBA colors with alpha channel added.
         """
         if len(alpha_channels) != len(rgb_colors):
-            LOGGER.error("Input lists must have the same length.")
+            LOGGER.warning("Input lists must have the same length.")
             return []
 
         # Fast path for empty lists
@@ -357,7 +357,7 @@ class ColorsManagement:
             self.color_cache.clear()
 
         except (ValueError, IndexError, UnboundLocalError) as e:
-            LOGGER.error("Error while populating colors: %s", e)
+            LOGGER.warning("Error while populating colors: %s", e)
 
     def initialize_user_colors(self, device_info: dict) -> List[Color]:
         """

{valetudo_map_parser-0.1.10b6 → valetudo_map_parser-0.1.10rc2}/SCR/valetudo_map_parser/config/drawable.py

@@ -877,13 +877,23 @@ class Drawable:
         """Draw the status text on the image."""
         module_dir = Path(__file__).resolve().parent
         default_font_path = module_dir / "fonts" / "FiraSans.ttf"
-        default_font = ImageFont.truetype(str(default_font_path), size)
+        # Load default font with safety fallback to PIL's built-in if missing
+        try:
+            default_font = ImageFont.truetype(str(default_font_path), size)
+        except OSError:
+            _LOGGER.warning(
+                "Default font not found at %s; using PIL default font",
+                default_font_path,
+            )
+            default_font = ImageFont.load_default()
 
-        user_font_path = Path(path_font)
-        if not user_font_path.is_absolute():
-            repo_root = module_dir.parents[2]
-            user_font_path = (repo_root / user_font_path).resolve()
-        user_font = ImageFont.truetype(str(user_font_path), size)
+        # Use provided font directly if available; else fall back to default
+        user_font = default_font
+        if path_font:
+            try:
+                user_font = ImageFont.truetype(str(path_font), size)
+            except OSError:
+                user_font = default_font
         if position:
             x, y = 10, 10
         else:

{valetudo_map_parser-0.1.10b6 → valetudo_map_parser-0.1.10rc2}/SCR/valetudo_map_parser/config/shared.py

@@ -205,7 +205,6 @@ class CameraShared:
             ATTR_CALIBRATION_POINTS: self.attr_calibration_points,
         }
         if self.obstacles_pos and self.vacuum_ips:
-            _LOGGER.debug("Generating obstacle links from: %s", self.obstacles_pos)
             self.obstacles_data = self._compose_obstacle_links(
                 self.vacuum_ips, self.obstacles_pos
             )
@@ -303,21 +302,20 @@ class CameraSharedManager:
             )
             # Ensure trims are updated correctly
             trim_data = device_info.get("trims_data", DEFAULT_VALUES["trims_data"])
-            _LOGGER.debug(
-                "%s: Updating shared trims with: %s", instance.file_name, trim_data
-            )
             instance.trims = TrimsData.from_dict(trim_data)
             # Robot size
             instance.robot_size = device_info.get("robot_size", 25)
 
         except TypeError as ex:
-            _LOGGER.error("Shared data can't be initialized due to a TypeError! %s", ex)
+            _LOGGER.warning(
+                "Shared data can't be initialized due to a TypeError! %s", ex
+            )
         except AttributeError as ex:
-            _LOGGER.error(
+            _LOGGER.warning(
                 "Shared data can't be initialized due to an AttributeError! %s", ex
             )
         except RuntimeError as ex:
-            _LOGGER.error(
+            _LOGGER.warning(
                 "An unexpected error occurred while initializing shared data %s:", ex
             )
 

{valetudo_map_parser-0.1.10b6 → valetudo_map_parser-0.1.10rc2}/SCR/valetudo_map_parser/config/status_text/status_text.py

@@ -6,8 +6,8 @@ Class to handle the status text of the vacuum cleaners.
 
 from __future__ import annotations
 
-from SCR.valetudo_map_parser.config.types import LOGGER, PilPNG
-from SCR.valetudo_map_parser.config.status_text.translations import translations
+from ..types import LOGGER, PilPNG
+from .translations import translations
 
 LOGGER.propagate = True
 

{valetudo_map_parser-0.1.10b6 → valetudo_map_parser-0.1.10rc2}/SCR/valetudo_map_parser/config/utils.py

@@ -71,7 +71,7 @@ class BaseHandler:
         self.crop_img_size = [0, 0]
         self.offset_x = 0
         self.offset_y = 0
-        self.crop_area = None
+        self.crop_area = [0, 0, 0, 0]
         self.zooming = False
         self.async_resize_images = async_resize_image
 
@@ -142,7 +142,6 @@ class BaseHandler:
                 if self.shared.show_vacuum_state:
                     text_editor = StatusText(self.shared)
                     img_text = await text_editor.get_status_text(new_image)
-                    print(img_text)
                     Drawable.status_text(
                         new_image,
                         img_text[1],
@@ -156,16 +155,10 @@ class BaseHandler:
                     with io.BytesIO() as buf:
                         new_image.save(buf, format="PNG", compress_level=1)
                         self.shared.binary_image = buf.getvalue()
-                    LOGGER.debug(
-                        "%s: Binary image conversion completed", self.file_name
-                    )
                 else:
                     self.shared.binary_image = None
                 # Update the timestamp with current datetime
                 self.shared.image_last_updated = datetime.datetime.fromtimestamp(time())
-                LOGGER.debug(
-                    "%s: Image processed and stored in shared data", self.file_name
-                )
                 return new_image
             else:
                 LOGGER.warning(
@@ -178,7 +171,7 @@ class BaseHandler:
                 )
 
         except Exception as e:
-            LOGGER.error(
+            LOGGER.warning(
                 "%s: Error in async_get_image: %s",
                 self.file_name,
                 str(e),
@@ -230,12 +223,6 @@ class BaseHandler:
             elif rotation in [90, 270]:
                 self.offset_y = (self.crop_img_size[0] - width) // 2
                 self.offset_x = self.crop_img_size[1] - height
-        LOGGER.debug(
-            "%s Image Coordinates Offsets (x,y): %s. %s",
-            self.file_name,
-            self.offset_x,
-            self.offset_y,
-        )
 
     def _set_image_offset_ratio_2_1(
         self, width: int, height: int, rand256: Optional[bool] = False
@@ -258,13 +245,6 @@ class BaseHandler:
                 self.offset_x = width - self.crop_img_size[0]
                 self.offset_y = height - self.crop_img_size[1]
 
-        LOGGER.debug(
-            "%s Image Coordinates Offsets (x,y): %s. %s",
-            self.file_name,
-            self.offset_x,
-            self.offset_y,
-        )
-
     def _set_image_offset_ratio_3_2(
         self, width: int, height: int, rand256: Optional[bool] = False
     ) -> None:
@@ -289,13 +269,6 @@ class BaseHandler:
                 self.offset_y = (self.crop_img_size[0] - width) // 2
                 self.offset_x = self.crop_img_size[1] - height
 
-        LOGGER.debug(
-            "%s Image Coordinates Offsets (x,y): %s. %s",
-            self.file_name,
-            self.offset_x,
-            self.offset_y,
-        )
-
     def _set_image_offset_ratio_5_4(
         self, width: int, height: int, rand256: Optional[bool] = False
     ) -> None:
@@ -321,13 +294,6 @@ class BaseHandler:
                 self.offset_y = (self.crop_img_size[0] - width) // 2
                 self.offset_x = self.crop_img_size[1] - height
 
-        LOGGER.debug(
-            "%s Image Coordinates Offsets (x,y): %s. %s",
-            self.file_name,
-            self.offset_x,
-            self.offset_y,
-        )
-
     def _set_image_offset_ratio_9_16(
         self, width: int, height: int, rand256: Optional[bool] = False
     ) -> None:
@@ -349,13 +315,6 @@ class BaseHandler:
                 self.offset_x = width - self.crop_img_size[0]
                 self.offset_y = height - self.crop_img_size[1]
 
-        LOGGER.debug(
-            "%s Image Coordinates Offsets (x,y): %s. %s",
-            self.file_name,
-            self.offset_x,
-            self.offset_y,
-        )
-
     def _set_image_offset_ratio_16_9(
         self, width: int, height: int, rand256: Optional[bool] = False
     ) -> None:
@@ -377,13 +336,6 @@ class BaseHandler:
                 self.offset_x = width - self.crop_img_size[0]
                 self.offset_y = height - self.crop_img_size[1]
 
-        LOGGER.debug(
-            "%s Image Coordinates Offsets (x,y): %s. %s",
-            self.file_name,
-            self.offset_x,
-            self.offset_y,
-        )
-
     async def async_map_coordinates_offset(
         self, params: OffsetParams
     ) -> tuple[int, int]:
@@ -439,6 +391,8 @@ class BaseHandler:
         self,
     ) -> list[dict[str, int] | dict[str, int] | dict[str, int] | dict[str, int]]:
         """Return the map points."""
+        if not self.crop_img_size:
+            return ["crop_img_size is not set"]
         return [
             {"x": 0, "y": 0},  # Top-left corner 0
             {"x": self.crop_img_size[0], "y": 0},  # Top-right corner 1
@@ -451,7 +405,8 @@ class BaseHandler:
 
     def get_vacuum_points(self, rotation_angle: int) -> list[dict[str, int]]:
         """Calculate the calibration points based on the rotation angle."""
-
+        if not self.crop_area:
+            return ["crop_area is not set"]
         # get_calibration_data
         vacuum_points = [
             {
@@ -562,7 +517,7 @@ class BaseHandler:
                 }
                 id_count += 1
             if id_count > 1:
-                LOGGER.debug("%s: Zones Properties updated.", self.file_name)
+                pass
         return zone_properties
 
     async def async_points_propriety(self, points_data) -> dict:
@@ -583,7 +538,7 @@ class BaseHandler:
                 }
                 id_count += 1
             if id_count > 1:
-                LOGGER.debug("%s: Point Properties updated.", self.file_name)
+                pass
         return point_properties
 
     @staticmethod
@@ -601,9 +556,15 @@ class BaseHandler:
 
 async def async_resize_image(params: ResizeParams):
     """Resize the image to the given dimensions and aspect ratio."""
-    if params.aspect_ratio:
+    LOGGER.debug("Resizing image to aspect ratio: %s", params.aspect_ratio)
+    LOGGER.debug("Original image size: %s x %s", params.width, params.height)
+    LOGGER.debug("Image crop size: %s", params.crop_size)
+    if params.aspect_ratio == "None":
+        return params.pil_img
+    if params.aspect_ratio != "None":
         wsf, hsf = [int(x) for x in params.aspect_ratio.split(",")]
 
+
         if wsf == 0 or hsf == 0 or params.width <= 0 or params.height <= 0:
             LOGGER.warning(
                 "Invalid aspect ratio parameters: width=%s, height=%s, wsf=%s, hsf=%s. Returning original image.",
@@ -625,24 +586,21 @@ async def async_resize_image(params: ResizeParams):
             new_width = params.pil_img.width
             new_height = int(params.pil_img.width / new_aspect_ratio)
 
-        LOGGER.debug("Resizing image to aspect ratio: %s, %s", wsf, hsf)
-        LOGGER.debug("New image size: %s x %s", new_width, new_height)
-
         if (params.crop_size is not None) and (params.offset_func is not None):
             offset = OffsetParams(wsf, hsf, new_width, new_height, params.is_rand)
             params.crop_size[0], params.crop_size[1] = await params.offset_func(offset)
-
+        LOGGER.debug("New image size: %r * %r", new_width, new_height)
         return ImageOps.pad(params.pil_img, (new_width, new_height))
 
-    return ImageOps.pad(params.pil_img, (params.width, params.height))
+    return params.pil_img
 
 
 def prepare_resize_params(handler, pil_img, rand):
     """Prepare resize parameters for image resizing."""
     return ResizeParams(
         pil_img=pil_img,
-        width=handler.shared.image_ref_width,
-        height=handler.shared.image_ref_height,
+        width=handler.shared.image_ref_width, #pil_img.width,
+        height=handler.shared.image_ref_height, # pil_img.height,
         aspect_ratio=handler.shared.image_aspect_ratio,
         crop_size=handler.crop_img_size,
         offset_func=handler.async_map_coordinates_offset,

{valetudo_map_parser-0.1.10b6 → valetudo_map_parser-0.1.10rc2}/SCR/valetudo_map_parser/hypfer_draw.py

@@ -191,8 +191,7 @@ class ImageDraw:
         Returns:
             The updated image array
         """
-        # Log the wall color to verify alpha is being passed correctly
-        _LOGGER.debug("%s: Drawing walls with color %s", self.file_name, color_wall)
+        # Draw walls
 
         # If there are no disabled rooms, draw all walls
         if not disabled_rooms:
@@ -202,9 +201,6 @@ class ImageDraw:
 
         # If there are disabled rooms, we need to check each wall pixel
         # to see if it belongs to a disabled room
-        _LOGGER.debug(
-            "%s: Filtering walls for disabled rooms: %s", self.file_name, disabled_rooms
-        )
 
         # Get the element map if available
         element_map = getattr(self.img_h, "element_map", None)
@@ -263,12 +259,6 @@ class ImageDraw:
                 filtered_pixels.append((x, y, z))
 
         # Draw the filtered walls
-        _LOGGER.debug(
-            "%s: Drawing %d of %d wall pixels after filtering",
-            self.file_name,
-            len(filtered_pixels),
-            len(pixels),
-        )
         if filtered_pixels:
             return await self.img_h.draw.from_json_to_image(
                 img_np_array, filtered_pixels, pixel_size, color_wall
@@ -415,26 +405,8 @@ class ImageDraw:
             room_store = RoomStore(self.file_name)
             room_keys = list(room_store.get_rooms().keys())
 
-            _LOGGER.debug(
-                "%s: Active zones debug - segment_id: %s, room_keys: %s, active_zones: %s",
-                self.file_name,
-                segment_id,
-                room_keys,
-                self.img_h.active_zones,
-            )
-
             if segment_id in room_keys:
                 position = room_keys.index(segment_id)
-                _LOGGER.debug(
-                    "%s: Segment ID %s found at position %s, active_zones[%s] = %s",
-                    self.file_name,
-                    segment_id,
-                    position,
-                    position,
-                    self.img_h.active_zones[position]
-                    if position < len(self.img_h.active_zones)
-                    else "OUT_OF_BOUNDS",
-                )
                 if position < len(self.img_h.active_zones):
                     self.img_h.zooming = bool(self.img_h.active_zones[position])
                 else:
@@ -531,12 +503,6 @@ class ImageDraw:
         # This helps prevent false positives for points very far from any room
         map_boundary = 20000  # Typical map size is around 5000-10000 units
         if abs(robot_x) > map_boundary or abs(robot_y) > map_boundary:
-            _LOGGER.debug(
-                "%s robot position (%s, %s) is far outside map boundaries.",
-                self.file_name,
-                robot_x,
-                robot_y,
-            )
             self.img_h.robot_in_room = last_room
             self.img_h.zooming = False
             temp = {
@@ -549,10 +515,6 @@ class ImageDraw:
 
         # Search through all rooms to find which one contains the robot
         if self.img_h.rooms_pos is None:
-            _LOGGER.debug(
-                "%s: No rooms data available for robot position detection.",
-                self.file_name,
-            )
             self.img_h.robot_in_room = last_room
             self.img_h.zooming = False
             temp = {
@@ -590,26 +552,8 @@ class ImageDraw:
                         room_store = RoomStore(self.file_name)
                         room_keys = list(room_store.get_rooms().keys())
 
-                        _LOGGER.debug(
-                            "%s: Active zones debug - segment_id: %s, room_keys: %s, active_zones: %s",
-                            self.file_name,
-                            segment_id,
-                            room_keys,
-                            self.img_h.active_zones,
-                        )
-
                         if segment_id in room_keys:
                             position = room_keys.index(segment_id)
-                            _LOGGER.debug(
-                                "%s: Segment ID %s found at position %s, active_zones[%s] = %s",
-                                self.file_name,
-                                segment_id,
-                                position,
-                                position,
-                                self.img_h.active_zones[position]
-                                if position < len(self.img_h.active_zones)
-                                else "OUT_OF_BOUNDS",
-                            )
                             if position < len(self.img_h.active_zones):
                                 self.img_h.zooming = bool(
                                     self.img_h.active_zones[position]
@@ -627,11 +571,6 @@ class ImageDraw:
                     else:
                         self.img_h.zooming = False
 
-                    _LOGGER.debug(
-                        "%s is in %s room (polygon detection).",
-                        self.file_name,
-                        self.img_h.robot_in_room["room"],
-                    )
                     return temp
             # Fallback to bounding box if no outline is available
             elif "corners" in room:
@@ -665,19 +604,10 @@ class ImageDraw:
                     # Handle active zones
                     self._check_active_zone_and_set_zooming()
 
-                    _LOGGER.debug(
-                        "%s is in %s room (bounding box detection).",
-                        self.file_name,
-                        self.img_h.robot_in_room["room"],
-                    )
                     return temp
             room_count += 1
 
         # Robot not found in any room
-        _LOGGER.debug(
-            "%s not located within any room coordinates.",
-            self.file_name,
-        )
         self.img_h.robot_in_room = last_room
         self.img_h.zooming = False
         temp = {

{valetudo_map_parser-0.1.10b6 → valetudo_map_parser-0.1.10rc2}/SCR/valetudo_map_parser/hypfer_handler.py

@@ -13,7 +13,9 @@ import numpy as np
 from PIL import Image
 
 from .config.async_utils import AsyncNumPy, AsyncPIL
-from .config.auto_crop import AutoCrop
+
+# from .config.auto_crop import AutoCrop
+from mvcrender.autocrop import AutoCrop
 from .config.drawable_elements import DrawableElement
 from .config.shared import CameraShared
 from .config.utils import pil_to_webp_bytes
@@ -50,7 +52,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
         AutoCrop.__init__(self, self)
         self.calibration_data = None  # camera shared data.
         self.data = ImageData  # imported Image Data Module.
-
         # Initialize drawing configuration using the shared utility function
         self.drawing_config, self.draw, self.enhanced_draw = initialize_drawing_config(
             self
@@ -83,9 +84,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
         )
         if room_properties:
             rooms = RoomStore(self.file_name, room_properties)
-            LOGGER.debug(
-                "%s: Rooms data extracted! %s", self.file_name, rooms.get_rooms()
-            )
             # Convert room_properties to the format expected by async_get_robot_in_room
             self.rooms_pos = []
             for room_id, room_data in room_properties.items():
@@ -97,7 +95,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                     }
                 )
         else:
-            LOGGER.debug("%s: Rooms data not available!", self.file_name)
             self.rooms_pos = None
         return room_properties
 
@@ -121,7 +118,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
         # Check if the JSON data is not None else process the image.
         try:
             if m_json is not None:
-                LOGGER.debug("%s: Creating Image.", self.file_name)
                 # Get the image size from the JSON data
                 self.img_size = self.json_data.image_size
                 # Get the JSON ID from the JSON data.
@@ -176,11 +172,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                                     ):
                                         # Add this room to the disabled rooms set
                                         disabled_rooms.add(room_id)
-                                        LOGGER.debug(
-                                            "%s: Room %d is disabled and will be skipped",
-                                            self.file_name,
-                                            current_room_id,
-                                        )
                                 room_id = (
                                     room_id + 1
                                 ) % 16  # Cycle room_id back to 0 after 15
@@ -283,12 +274,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                     new_frame_hash != self.img_hash
                 ):
                     self.frame_number = 0
-                LOGGER.debug(
-                    "%s: %s at Frame Number: %s",
-                    self.file_name,
-                    str(self.json_id),
-                    str(self.frame_number),
-                )
                 # Ensure persistent working buffer exists and matches base (allocate only when needed)
                 if (
                     self.img_work_layer is None
@@ -383,13 +368,15 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                 self.zooming = self.imd.img_h.zooming
 
                 # Resize the image
-                img_np_array = await self.async_auto_trim_and_zoom_image(
+                img_np_array = self.async_auto_trim_and_zoom_image(
                     img_np_array,
                     colors["background"],
                     int(self.shared.margins),
                     int(self.shared.image_rotate),
                     self.zooming,
                 )
+                # self.crop_img_size = [img_np_array.shape[1], img_np_array.shape[0]]
+                # LOGGER.info("%s: Image size: %s", self.file_name, self.crop_img_size)
             # If the image is None return None and log the error.
             if img_np_array is None:
                 LOGGER.warning("%s: Image array is None.", self.file_name)
@@ -415,13 +402,11 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                     # Convert directly from NumPy to WebP for better performance
                     webp_bytes = await numpy_to_webp_bytes(img_np_array)
                     del img_np_array
-                    LOGGER.debug("%s: Frame Completed.", self.file_name)
                     return webp_bytes
                 else:
                     # Convert to PIL Image (original behavior)
                     pil_img = await AsyncPIL.async_fromarray(img_np_array, mode="RGBA")
                     del img_np_array
-                    LOGGER.debug("%s: Frame Completed.", self.file_name)
                     return pil_img
         except (RuntimeError, RuntimeWarning) as e:
             LOGGER.warning(
@@ -438,12 +423,9 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
         if self.room_propriety:
             return self.room_propriety
         if self.json_data:
-            LOGGER.debug("Checking %s Rooms data..", self.file_name)
             self.room_propriety = await self.async_extract_room_properties(
                 self.json_data.json_data
             )
-            if self.room_propriety:
-                LOGGER.debug("Got %s Rooms Attributes.", self.file_name)
         return self.room_propriety
 
     def get_calibration_data(self) -> CalibrationPoints:

{valetudo_map_parser-0.1.10b6 → valetudo_map_parser-0.1.10rc2}/SCR/valetudo_map_parser/map_data.py

@@ -9,9 +9,18 @@ Version: v0.1.10
 from __future__ import annotations
 
 import numpy as np
-from typing import List, Sequence, TypeVar, Any, TypedDict, NotRequired, Literal
-
-from dataclasses import dataclass, field
+from typing import (
+    List,
+    Sequence,
+    TypeVar,
+    Any,
+    TypedDict,
+    NotRequired,
+    Literal,
+    Optional,
+)
+
+from dataclasses import dataclass, field, asdict
 
 from .config.types import ImageSize, JsonType
 
@@ -475,7 +484,7 @@ class RandImageData:
         return json_data.get("path", {})
 
     @staticmethod
-    def get_rrm_goto_predicted_path(json_data: JsonType) -> List or None:
+    def get_rrm_goto_predicted_path(json_data: JsonType) -> Optional[list]:
         """Get the predicted path data from the json."""
         try:
             predicted_path = json_data.get("goto_predicted_path", {})
@@ -517,7 +526,7 @@ class RandImageData:
         return angle, json_data.get("robot_angle", 0)
 
     @staticmethod
-    def get_rrm_goto_target(json_data: JsonType) -> list or None:
+    def get_rrm_goto_target(json_data: JsonType) -> Any:
         """Get the goto target from the json."""
         try:
             path_data = json_data.get("goto_target", {})
@@ -544,7 +553,7 @@ class RandImageData:
         return formatted_zones
 
     @staticmethod
-    def _rrm_valetudo_format_zone(coordinates: list) -> Any:
+    def _rrm_valetudo_format_zone(coordinates: list) -> list[dict[str, Any]]:
         """Format the zones from RRM to Valetudo."""
         formatted_zones = []
         for zone_data in coordinates:
@@ -749,3 +758,55 @@ class HyperMapData:
             layers=layers,
             active_zones=active_zones,
         )
+
+    def to_dict(self) -> dict[str, Any]:
+        """Return a dictionary representation of this dataclass."""
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "HyperMapData":
+        """Construct a HyperMapData from a plain dictionary.
+        Unknown keys are ignored; missing keys use safe defaults.
+        """
+        return cls(
+            json_data=data.get("json_data"),
+            json_id=data.get("json_id") or None,
+            obstacles=data.get("obstacles", {}),
+            paths=data.get("paths", {}),
+            image_size=data.get("image_size", {}),
+            areas=data.get("areas", {}),
+            pixel_size=int(data.get("pixel_size", 0) or 0),
+            entity_dict=data.get("entity_dict", {}),
+            layers=data.get("layers", {}),
+            active_zones=data.get("active_zones", []),
+            virtual_walls=data.get("virtual_walls", []),
+        )
+
+    def update_from_dict(self, updates: dict[str, Any]) -> None:
+        """Update one or more fields in place, preserving the rest.
+        Unknown keys are ignored; pixel_size is coerced to int.
+        """
+        if not updates:
+            return
+        allowed = {
+            "json_data",
+            "json_id",
+            "obstacles",
+            "paths",
+            "image_size",
+            "areas",
+            "pixel_size",
+            "entity_dict",
+            "layers",
+            "active_zones",
+            "virtual_walls",
+        }
+        for key, value in updates.items():
+            if key not in allowed:
+                continue
+            if key == "pixel_size":
+                try:
+                    value = int(value)
+                except (TypeError, ValueError):
+                    continue
+            setattr(self, key, value)

{valetudo_map_parser-0.1.10b6 → valetudo_map_parser-0.1.10rc2}/SCR/valetudo_map_parser/rand256_handler.py

@@ -14,7 +14,9 @@ from typing import Any
 import numpy as np
 
 from .config.async_utils import AsyncNumPy, AsyncPIL
-from .config.auto_crop import AutoCrop
+
+# from .config.auto_crop import AutoCrop
+from mvcrender.autocrop import AutoCrop
 from .config.drawable_elements import DrawableElement
 from .config.types import (
     COLORS,
@@ -111,29 +113,19 @@ class ReImageHandler(BaseHandler, AutoCrop):
 
             # Update shared.map_rooms with the room IDs for MQTT active zone mapping
             self.shared.map_rooms = room_ids
-            _LOGGER.debug("Updated shared.map_rooms with room IDs: %s", room_ids)
 
             # get the zones and points data
             zone_properties = await self.async_zone_propriety(zones_data)
             # get the 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,
-                    f"{len(zone_properties)} Zones" if zone_properties else None,
-                ]
-                extracted_data = ", ".join(filter(None, extracted_data))
-                _LOGGER.debug("Extracted data: %s", extracted_data)
-            else:
+            if not (room_properties or zone_properties):
                 self.rooms_pos = None
-                _LOGGER.debug("%s: Rooms and Zones data not available!", self.file_name)
 
             rooms = RoomStore(self.file_name, room_properties)
-            _LOGGER.debug("Rooms Data: %s", rooms.get_rooms())
             return room_properties, zone_properties, point_properties
         except (RuntimeError, ValueError) as e:
-            _LOGGER.debug(
+            _LOGGER.warning(
                 "No rooms Data or Error in extract_room_properties: %s",
                 e,
                 exc_info=True,
@@ -177,9 +169,6 @@ class ReImageHandler(BaseHandler, AutoCrop):
                 # Increment frame number
                 self.frame_number += 1
                 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)
-                )
                 if self.frame_number > 5:
                     self.frame_number = 0
 
@@ -301,11 +290,6 @@ class ReImageHandler(BaseHandler, AutoCrop):
                     self.rooms_pos = original_rooms_pos
 
             except Exception as e:
-                _LOGGER.debug(
-                    "%s: Early room extraction failed: %s, falling back to robot-position zoom",
-                    self.file_name,
-                    e,
-                )
                 # Fallback to robot-position-based zoom if room extraction fails
                 if (
                     self.shared.image_auto_zoom
@@ -313,10 +297,6 @@ class ReImageHandler(BaseHandler, AutoCrop):
                     and robot_position
                 ):
                     self.zooming = True
-                    _LOGGER.debug(
-                        "%s: Enabling fallback robot-position-based zoom",
-                        self.file_name,
-                    )
 
         return self.img_base_layer, robot_position, robot_position_angle
 
@@ -379,19 +359,10 @@ class ReImageHandler(BaseHandler, AutoCrop):
             active_zones = self.shared.rand256_active_zone
             if active_zones and any(zone for zone in active_zones):
                 self.zooming = True
-                _LOGGER.debug(
-                    "%s: Enabling zoom for Rand256 - active zones detected: %s",
-                    self.file_name,
-                    active_zones,
-                )
             else:
                 self.zooming = False
-                _LOGGER.debug(
-                    "%s: Zoom disabled for Rand256 - no active zones set",
-                    self.file_name,
-                )
 
-        img_np_array = await self.async_auto_trim_and_zoom_image(
+        img_np_array = self.async_auto_trim_and_zoom_image(
             img_np_array,
             detect_colour=colors["background"],
             margin_size=int(self.shared.margins),
@@ -410,7 +381,6 @@ class ReImageHandler(BaseHandler, AutoCrop):
         if self.check_zoom_and_aspect_ratio():
             resize_params = prepare_resize_params(self, pil_img, True)
             pil_img = await self.async_resize_images(resize_params)
-        _LOGGER.debug("%s: Frame Completed.", self.file_name)
         return pil_img
 
     async def get_rooms_attributes(
@@ -420,12 +390,9 @@ class ReImageHandler(BaseHandler, AutoCrop):
         if self.room_propriety:
             return self.room_propriety
         if self.json_data and destinations:
-            _LOGGER.debug("Checking for rooms data..")
             self.room_propriety = await self.extract_room_properties(
                 self.json_data, destinations
             )
-            if self.room_propriety:
-                _LOGGER.debug("Got Rooms Attributes.")
         return self.room_propriety
 
     @staticmethod
@@ -537,12 +504,6 @@ class ReImageHandler(BaseHandler, AutoCrop):
         # 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:
-            _LOGGER.debug(
-                "%s robot position (%s, %s) is far outside map boundaries.",
-                self.file_name,
-                robot_x,
-                robot_y,
-            )
             self.robot_in_room = last_room
             self.zooming = False
             temp = {
@@ -555,10 +516,6 @@ class ReImageHandler(BaseHandler, AutoCrop):
 
         # Search through all rooms to find which one contains the robot
         if not self.rooms_pos:
-            _LOGGER.debug(
-                "%s: No rooms data available for robot position detection.",
-                self.file_name,
-            )
             self.robot_in_room = last_room
             self.zooming = False
             temp = {
@@ -569,7 +526,6 @@ class ReImageHandler(BaseHandler, AutoCrop):
             }
             return temp
 
-        _LOGGER.debug("%s: Searching for robot in rooms...", self.file_name)
         for room in self.rooms_pos:
             # Check if the room has an outline (polygon points)
             if "outline" in room:
@@ -598,19 +554,10 @@ class ReImageHandler(BaseHandler, AutoCrop):
                     else:
                         self.zooming = False
 
-                    _LOGGER.debug(
-                        "%s is in %s room (polygon detection).",
-                        self.file_name,
-                        self.robot_in_room["room"],
-                    )
                     return temp
             room_count += 1
 
         # Robot not found in any room
-        _LOGGER.debug(
-            "%s not located within any room coordinates.",
-            self.file_name,
-        )
         self.robot_in_room = last_room
         self.zooming = False
         temp = {

{valetudo_map_parser-0.1.10b6 → valetudo_map_parser-0.1.10rc2}/SCR/valetudo_map_parser/reimg_draw.py

@@ -213,7 +213,6 @@ class ImageDraw:
         except KeyError as e:
             _LOGGER.warning("%s: No charger position found: %s", self.file_name, e)
         else:
-            _LOGGER.debug("Charger position: %s", charger_pos)
             if charger_pos:
                 charger_pos_dictionary = {
                     "x": (charger_pos[0] * 10),
@@ -317,11 +316,6 @@ class ImageDraw:
             robot_position_angle = round(angle[0], 0)
             if robot_pos and robot_position_angle:
                 robot_position = robot_pos
-                _LOGGER.debug(
-                    "robot position: %s, robot angle: %s",
-                    str(robot_pos),
-                    str(robot_position_angle),
-                )
                 if self.img_h.rooms_pos is None:
                     self.img_h.robot_pos = {
                         "x": robot_position[0] * 10,

{valetudo_map_parser-0.1.10b6 → valetudo_map_parser-0.1.10rc2}/SCR/valetudo_map_parser/rooms_handler.py

@@ -104,14 +104,11 @@ class RoomsHandler:
                         is_enabled = self.drawing_config.is_enabled(room_element)
                         if not is_enabled:
                             # Skip this room if it's disabled
-                            LOGGER.debug("Skipping disabled room %s", segment_id)
                             return None, None
             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)
-                LOGGER.debug(
-                    "Could not convert segment_id %s to room element", segment_id
-                )
+                pass
 
         # Optimization: Create a smaller mask for just the room area
         if not pixels:
@@ -221,9 +218,8 @@ class RoomsHandler:
                 if room_id is not None and room_data is not None:
                     room_properties[room_id] = room_data
 
-        # Log timing information
+        # Log timing information (kept internal, no debug output)
         total_time = time.time() - start_total
-        LOGGER.debug("Room extraction Total time: %.3fs", total_time)
         return room_properties
 
 
@@ -339,11 +335,11 @@ class RandRoomsHandler:
                         is_enabled = self.drawing_config.is_enabled(room_element)
                         if not is_enabled:
                             # Skip this room if it's disabled
-                            LOGGER.debug("Skipping disabled room %s", segment_id)
                             return None, None
             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
                 )
@@ -467,8 +463,6 @@ class RandRoomsHandler:
 
                 room_properties[room_id] = room_data
 
-        # Log timing information
+        # Log timing information (kept internal, no debug output)
         total_time = time.time() - start_total
-        LOGGER.debug("Room extraction Total time: %.3fs", total_time)
-
         return room_properties

{valetudo_map_parser-0.1.10b6 → valetudo_map_parser-0.1.10rc2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "valetudo-map-parser"
-version = "0.1.10b6"
+version = "0.1.10rc2"
 description = "A Python library to parse Valetudo map data returning a PIL Image object."
 authors = ["Sandro Cantarella <gsca075@gmail.com>"]
 license = "Apache-2.0"
@@ -14,10 +14,11 @@ packages = [{include = "valetudo_map_parser", from = "SCR"}]
 "Changelog" = "https://github.com/sca075/Python-package-valetudo-map-parser/releases"
 
 [tool.poetry.dependencies]
-python = ">=3.12"
+python = ">=3.13"
 numpy = ">=1.26.4"
 Pillow = ">=10.3.0"
 scipy = ">=1.12.0"
+mvcrender = ">=0.0.2"
 
 [tool.poetry.group.dev.dependencies]
 ruff = "*"