Robot Size Configurable

.github/workflows/code_quality.yaml

@@ -26,7 +26,7 @@ jobs:
         uses: actions/setup-python@v6
         id: python
         with:
-          python-version: "3.12"
+          python-version: "3.13"
 
       - name: Install Poetry
         run: pip install poetry

.github/workflows/release.yaml

@@ -13,10 +13,10 @@ jobs:
       - uses: actions/checkout@v5
 
       # Step 2: Set up Python
-      - name: Set up Python 3.12
+      - name: Set up Python 3.13
         uses: actions/setup-python@v6
         with:
-          python-version: "3.12"
+          python-version: "3.13"
 
       # Step 3: Install Poetry
       - name: Install Poetry

SCR/__init__.py

@@ -1,2 +1,2 @@
 """Valetudo map parser.
-Version: 0.1.9"""
+Version: 0.1.10"""

SCR/valetudo_map_parser/__init__.py

@@ -1,5 +1,7 @@
 """Valetudo map parser.
-Version: 0.1.9"""
+Version: 0.1.10"""
+
+from pathlib import Path
 
 from .config.colors import ColorsManagement
 from .config.drawable import Drawable
@@ -19,14 +21,27 @@
     NumpyArray,
     ImageSize,
 )
+from .config.status_text.status_text import StatusText
+from .config.status_text.translations import translations as STATUS_TEXT_TRANSLATIONS
 from .hypfer_handler import HypferMapImageHandler
 from .rand256_handler import ReImageHandler
 from .rooms_handler import RoomsHandler, RandRoomsHandler
+from .map_data import HyperMapData
+
+
+def get_default_font_path() -> str:
+    """Return the absolute path to the bundled default font directory.
+
+    This returns the path to the fonts folder; the caller can join a specific font file
+    to avoid hard-coding a particular font here.
+    """
+    return str((Path(__file__).resolve().parent / "config" / "fonts").resolve())
 
 
 __all__ = [
     "RoomsHandler",
     "RandRoomsHandler",
+    "HyperMapData",
     "HypferMapImageHandler",
     "ReImageHandler",
     "RRMapParser",
@@ -47,4 +62,7 @@
     "PilPNG",
     "NumpyArray",
     "ImageSize",
+    "StatusText",
+    "STATUS_TEXT_TRANSLATIONS",
+    "get_default_font_path",
 ]

SCR/valetudo_map_parser/config/auto_crop.py

@@ -6,10 +6,9 @@
 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 @@ def _calculate_trimmed_dimensions(self):
 
     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 @@ async def _async_auto_crop_data(self, tdata: TrimsData):  # , tdata=None
                 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 @@ def auto_crop_offset(self):
 
     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 @@ async def _init_auto_crop(self):
 
         # 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 @@ async def async_image_margins(
         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 @@ async def async_get_room_bounding_box(
             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 @@ async def async_auto_trim_and_zoom_image(
         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 @@ async def async_auto_trim_and_zoom_image(
             # 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(

SCR/valetudo_map_parser/config/colors.py

@@ -250,7 +250,7 @@ def add_alpha_to_rgb(alpha_channels, rgb_colors):
             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 @@ def set_initial_colours(self, device_info: dict) -> None:
             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]:
         """

SCR/valetudo_map_parser/config/drawable.py

@@ -11,6 +11,7 @@
 from __future__ import annotations
 
 import logging
+from pathlib import Path
 
 import numpy as np
 from PIL import Image, ImageDraw, ImageFont
@@ -874,11 +875,25 @@ def status_text(
         position: bool,
     ) -> None:
         """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)
+        module_dir = Path(__file__).resolve().parent
+        default_font_path = module_dir / "fonts" / "FiraSans.ttf"
+        # 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()
+
+        # 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:

SCR/valetudo_map_parser/config/shared.py

@@ -1,7 +1,7 @@
 """
 Class Camera Shared.
 Keep the data between the modules.
-Version: v0.1.9
+Version: v0.1.10
 """
 
 import asyncio
@@ -58,6 +58,7 @@ def __init__(self, file_name):
         self.frame_number: int = 0  # camera Frame number
         self.destinations: list = []  # MQTT rand destinations
         self.rand256_active_zone: list = []  # Active zone for rand256
+        self.rand256_zone_coordinates: list = []  # Active zone coordinates for rand256
         self.is_rand: bool = False  # MQTT rand data
         self._new_mqtt_message = False  # New MQTT message
         # Initialize last_image with default gray image (250x150 minimum)
@@ -69,6 +70,7 @@ def __init__(self, file_name):
         self.image_last_updated: float = 0.0  # Last image update time
         self.image_format = "image/pil"  # Image format
         self.image_size = None  # Image size
+        self.robot_size = None  # Robot size
         self.image_auto_zoom: bool = False  # Auto zoom image
         self.image_zoom_lock_ratio: bool = True  # Zoom lock ratio
         self.image_ref_height: int = 0  # Image reference height
@@ -81,8 +83,7 @@ def __init__(self, file_name):
         self.user_colors = Colors  # User base colors
         self.rooms_colors = Colors  # Rooms colors
         self.vacuum_battery = 0  # Vacuum battery state
-        self.vacuum_bat_charged: bool = True  # Vacuum charged and ready
-        self.vacuum_connection = None  # Vacuum connection state
+        self.vacuum_connection = False  # Vacuum connection state
         self.vacuum_state = None  # Vacuum state
         self.charger_position = None  # Vacuum Charger position
         self.show_vacuum_state = None  # Show vacuum state on the map
@@ -197,14 +198,13 @@ def generate_attributes(self) -> dict:
         attrs = {
             ATTR_CAMERA_MODE: self.camera_mode,
             ATTR_VACUUM_BATTERY: f"{self.vacuum_battery}%",
-            ATTR_VACUUM_CHARGING: self.vacuum_bat_charged,
+            ATTR_VACUUM_CHARGING: self.vacuum_bat_charged(),
             ATTR_VACUUM_POSITION: self.current_room,
             ATTR_VACUUM_STATUS: self.vacuum_state,
             ATTR_VACUUM_JSON_ID: self.vac_json_id,
             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
             )
@@ -302,19 +302,30 @@ def update_shared_data(self, device_info):
             )
             # 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
+            robot_size = device_info.get("robot_size", 25)
+            try:
+                robot_size = int(robot_size)
+            except (ValueError, TypeError):
+                robot_size = 25
+            # Clamp robot_size to [8, 25]
+            if robot_size < 8:
+                robot_size = 8
+            elif robot_size > 25:
+                robot_size = 25
+            instance.robot_size = robot_size
 
         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
             )