valetudo-map-parser 0.1.9b74__tar.gz → 0.1.10rc2__tar.gz

{valetudo_map_parser-0.1.9b74 → 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.9b74
+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.9b74 → valetudo_map_parser-0.1.10rc2}/SCR/valetudo_map_parser/__init__.py

@@ -1,11 +1,12 @@
 """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
 from .config.drawable_elements import DrawableElement, DrawingConfig
 from .config.enhanced_drawable import EnhancedDrawable
-from .config.utils import webp_bytes_to_pil
 from .config.rand256_parser import RRMapParser
 from .config.shared import CameraShared, CameraSharedManager
 from .config.types import (
@@ -15,16 +16,32 @@ from .config.types import (
     SnapshotStore,
     TrimCropData,
     UserLanguageStore,
-    WebPBytes,
+    JsonType,
+    PilPNG,
+    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",
@@ -41,6 +58,11 @@ __all__ = [
     "RoomsProperties",
     "TrimCropData",
     "CameraModes",
-    "WebPBytes",
-    "webp_bytes_to_pil",
+    "JsonType",
+    "PilPNG",
+    "NumpyArray",
+    "ImageSize",
+    "StatusText",
+    "STATUS_TEXT_TRANSLATIONS",
+    "get_default_font_path",
 ]

{valetudo_map_parser-0.1.9b74 → 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.9b74 → 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.9b74 → valetudo_map_parser-0.1.10rc2}/SCR/valetudo_map_parser/config/drawable.py

@@ -11,7 +11,7 @@ Optimized with NumPy and SciPy for better performance.
 from __future__ import annotations
 
 import logging
-import math
+from pathlib import Path
 
 import numpy as np
 from PIL import Image, ImageDraw, ImageFont
@@ -160,7 +160,7 @@ class Drawable:
 
         # Get blended colors for flag and pole
         flag_alpha = flag_color[3] if len(flag_color) == 4 else 255
-        pole_color_base = (0, 0, 255)  # Blue for the pole
+        pole_color_base = [0, 0, 255]  # Blue for the pole
         pole_alpha = 255
 
         # Blend flag color if needed
@@ -170,7 +170,12 @@ class Drawable:
             )
 
         # Create pole color with alpha
-        pole_color: Color = (*pole_color_base, pole_alpha)
+        pole_color: Color = (
+            pole_color_base[0],
+            pole_color_base[1],
+            pole_color_base[2],
+            pole_alpha,
+        )
 
         # Blend pole color if needed
         if pole_alpha < 255:
@@ -223,20 +228,18 @@ class Drawable:
 
     @staticmethod
     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.
-        """
+        """Check if a point (x, y) is inside a polygon defined by a list of points."""
         n = len(points)
         inside = False
-        xinters = 0.0
+        inters_x = 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) and x <= max(p1x, p2x):
                     if p1y != p2y:
-                        xinters = (y - p1y) * (p2x - p1x) / (p2y - p1y) + p1x
-                    if p1x == p2x or x <= xinters:
+                        inters_x = (y - p1y) * (p2x - p1x) / (p2y - p1y) + p1x
+                    if p1x == p2x or x <= inters_x:
                         inside = not inside
             p1x, p1y = p2x, p2y
         return inside
@@ -251,8 +254,7 @@ class Drawable:
         color: Color,
         width: int = 3,
     ) -> np.ndarray:
-        """
-        Draw a line on a NumPy array (layer) from point A to B using Bresenham's algorithm.
+        """Draw a line on a NumPy array (layer) from point A to B using Bresenham's algorithm.
 
         Args:
             layer: The numpy array to draw on (H, W, C)
@@ -283,11 +285,11 @@ class Drawable:
             x_min = max(0, x1 - half_w)
             x_max = min(w, x1 + half_w + 1)
 
-            submask = mask[
+            sub_mask = mask[
                 (y_min - (y1 - half_w)) : (y_max - (y1 - half_w)),
                 (x_min - (x1 - half_w)) : (x_max - (x1 - half_w)),
             ]
-            layer[y_min:y_max, x_min:x_max][submask] = blended_color
+            layer[y_min:y_max, x_min:x_max][sub_mask] = blended_color
 
             if x1 == x2 and y1 == y2:
                 break
@@ -317,12 +319,14 @@ class Drawable:
         return layer
 
     @staticmethod
-    async def lines(arr: NumpyArray, coords, width: int, color: Color) -> NumpyArray:
+    async def lines(
+        arr: NumpyArray, coordinates, width: int, color: Color
+    ) -> NumpyArray:
         """
         Join the coordinates creating a continuous line (path).
         Optimized with vectorized operations for better performance.
         """
-        for coord in coords:
+        for coord in coordinates:
             x0, y0 = coord[0]
             try:
                 x1, y1 = coord[1]
@@ -466,9 +470,6 @@ class Drawable:
             # Adjust points to the mask's coordinate system
             adjusted_points = [(p[0] - min_x, p[1] - min_y) for p in points]
 
-            # Create a grid of coordinates and use it to test all points at once
-            y_indices, x_indices = np.mgrid[0 : mask.shape[0], 0 : mask.shape[1]]
-
             # Test each point in the grid
             for i in range(mask.shape[0]):
                 for j in range(mask.shape[1]):
@@ -545,68 +546,63 @@ class Drawable:
         angle: float,
         fill: Color,
         robot_state: str | None = None,
+        radius: int = 25,  # user-configurable
     ) -> NumpyArray:
         """
-        Draw the robot on a smaller array to reduce memory cost.
-        Optimized with NumPy vectorized operations for better performance.
+        Draw the robot with configurable size. All elements scale with radius.
         """
-        # Ensure coordinates are within bounds
+        # Minimum radius to keep things visible
+        radius = max(8, min(radius, 25))
+
         height, width = layers.shape[:2]
         if not (0 <= x < width and 0 <= y < height):
             return layers
 
-        # Calculate the bounding box for the robot
-        radius = 25
-        box_size = radius * 2 + 2  # Add a small margin
-
-        # Calculate the region to draw on
+        # Bounding box
         top_left_x = max(0, x - radius - 1)
         top_left_y = max(0, y - radius - 1)
         bottom_right_x = min(width, x + radius + 1)
         bottom_right_y = min(height, y + radius + 1)
 
-        # Skip if the robot is completely outside the image
         if top_left_x >= bottom_right_x or top_left_y >= bottom_right_y:
             return layers
 
-        # Create a temporary layer for the robot
         tmp_width = bottom_right_x - top_left_x
         tmp_height = bottom_right_y - top_left_y
         tmp_layer = layers[top_left_y:bottom_right_y, top_left_x:bottom_right_x].copy()
 
-        # Calculate the robot center in the temporary layer
         tmp_x = x - top_left_x
         tmp_y = y - top_left_y
 
-        # Calculate robot parameters
-        r_scaled = radius // 11
-        r_cover = r_scaled * 12
+        # All geometry proportional to radius
+        r_scaled: float = max(1.0, radius / 11.0)
+        r_cover = int(r_scaled * 10)
+        r_lidar = max(1, int(r_scaled * 3))
+        r_button = max(1, int(r_scaled * 1))
+        lidar_offset = int(radius * 0.6)  # was fixed 15
+        button_offset = int(radius * 0.8)  # was fixed 20
+
         lidar_angle = np.deg2rad(angle + 90)
-        r_lidar = r_scaled * 3
-        r_button = r_scaled * 1
 
-        # Set colors based on robot state
         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 main robot body
+        # Body
         tmp_layer = Drawable._filled_circle(
             tmp_layer, (tmp_y, tmp_x), radius, fill, outline, 1
         )
 
-        # Draw the robot direction indicator
+        # Direction wedge
         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))
-        y1 = int(tmp_y + r_cover * math.cos(a1))
-        x2 = int(tmp_x - r_cover * math.sin(a2))
-        y2 = int(tmp_y + r_cover * math.cos(a2))
-
-        # Draw the direction line
+        a1 = np.deg2rad((angle + 90) - 80)
+        a2 = np.deg2rad((angle + 90) + 80)
+        x1 = int(tmp_x - r_cover * np.sin(a1))
+        y1 = int(tmp_y + r_cover * np.cos(a1))
+        x2 = int(tmp_x - r_cover * np.sin(a2))
+        y2 = int(tmp_y + r_cover * np.cos(a2))
         if (
             0 <= x1 < tmp_width
             and 0 <= y1 < tmp_height
@@ -615,25 +611,23 @@ class Drawable:
         ):
             tmp_layer = Drawable._line(tmp_layer, x1, y1, x2, y2, outline, width=1)
 
-        # Draw the lidar indicator
-        lidar_x = int(tmp_x + 15 * np.cos(lidar_angle))
-        lidar_y = int(tmp_y + 15 * np.sin(lidar_angle))
+        # Lidar
+        lidar_x = int(tmp_x + lidar_offset * np.cos(lidar_angle))
+        lidar_y = int(tmp_y + lidar_offset * np.sin(lidar_angle))
         if 0 <= lidar_x < tmp_width and 0 <= lidar_y < tmp_height:
             tmp_layer = Drawable._filled_circle(
                 tmp_layer, (lidar_y, lidar_x), r_lidar, outline
             )
 
-        # Draw the button indicator
-        butt_x = int(tmp_x - 20 * np.cos(lidar_angle))
-        butt_y = int(tmp_y - 20 * np.sin(lidar_angle))
+        # Button
+        butt_x = int(tmp_x - button_offset * np.cos(lidar_angle))
+        butt_y = int(tmp_y - button_offset * np.sin(lidar_angle))
         if 0 <= butt_x < tmp_width and 0 <= butt_y < tmp_height:
             tmp_layer = Drawable._filled_circle(
                 tmp_layer, (butt_y, butt_x), r_button, outline
             )
 
-        # Copy the robot layer back to the main layer
         layers[top_left_y:bottom_right_y, top_left_x:bottom_right_x] = tmp_layer
-
         return layers
 
     @staticmethod
@@ -781,11 +775,11 @@ class Drawable:
                             continue
 
                         t = np.linspace(0, 1, length * 2)
-                        x_coords = np.round(x1 * (1 - t) + x2 * t).astype(int)
-                        y_coords = np.round(y1 * (1 - t) + y2 * t).astype(int)
+                        x_coordinates = np.round(x1 * (1 - t) + x2 * t).astype(int)
+                        y_coordinates = np.round(y1 * (1 - t) + y2 * t).astype(int)
 
                         # Add line points to mask
-                        for x, y in zip(x_coords, y_coords):
+                        for x, y in zip(x_coordinates, y_coordinates):
                             if width == 1:
                                 mask[y, x] = True
                             else:
@@ -827,7 +821,6 @@ class Drawable:
 
         # Precompute circular mask for radius
         radius = 6
-        diameter = radius * 2 + 1
         yy, xx = np.ogrid[-radius : radius + 1, -radius : radius + 1]
         circle_mask = (xx**2 + yy**2) <= radius**2
 
@@ -882,11 +875,25 @@ class Drawable:
         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:

{valetudo_map_parser-0.1.9b74 → valetudo_map_parser-0.1.10rc2}/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 @@ class CameraShared:
         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 @@ class CameraShared:
         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 @@ class CameraShared:
         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 @@ class CameraShared:
         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,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.10rc2/SCR/valetudo_map_parser/config/status_text/status_text.py

@@ -0,0 +1,95 @@
+"""
+Version: 0.1.10
+Status text of the vacuum cleaners.
+Class to handle the status text of the vacuum cleaners.
+"""
+
+from __future__ import annotations
+
+from ..types import LOGGER, PilPNG
+from .translations import translations
+
+LOGGER.propagate = True
+
+
+class StatusText:
+    """
+    Status text of the vacuum cleaners.
+    """
+
+    def __init__(self, camera_shared):
+        self._shared = camera_shared
+        self.file_name = self._shared.file_name
+
+    @staticmethod
+    async def get_vacuum_status_translation(
+        language: str = "en",
+    ) -> dict[str, str] | None:
+        """
+        Get the vacuum status translation.
+        @param language: Language code, default 'en'.
+        @return: Mapping for the given language or None.
+        """
+        return translations.get((language or "en").lower())
+
+    async def translate_vacuum_status(self) -> str:
+        """Return the translated status with EN fallback and safe default."""
+        status = self._shared.vacuum_state or "unknown"
+        language = (self._shared.user_language or "en").lower()
+        translation = await self.get_vacuum_status_translation(language)
+        if not translation:
+            translation = translations.get("en", {})
+        return translation.get(status, str(status).capitalize())
+
+    async def get_status_text(self, text_img: PilPNG) -> tuple[list[str], int]:
+        """
+        Compose the image status text.
+        :param text_img: Image to draw the text on.
+        :return status_text, text_size: List of the status text and the text size.
+        """
+        status_text = ["If you read me, something really went wrong.."]  # default text
+        text_size_coverage = 1.5  # resize factor for the text
+        text_size = self._shared.vacuum_status_size  # default text size
+        charge_level = "\u03de"  # unicode Koppa symbol
+        charging = "\u2211"  # unicode Charging symbol
+        vacuum_state = await self.translate_vacuum_status()
+        if self._shared.show_vacuum_state:
+            status_text = [f"{self.file_name}: {vacuum_state}"]
+            language = (self._shared.user_language or "en").lower()
+            lang_map = translations.get(language) or translations.get("en", {})
+            if not self._shared.vacuum_connection:
+                mqtt_disc = lang_map.get(
+                    "mqtt_disconnected",
+                    translations.get("en", {}).get(
+                        "mqtt_disconnected", "Disconnected from MQTT?"
+                    ),
+                )
+                status_text = [f"{self.file_name}: {mqtt_disc}"]
+            else:
+                if self._shared.current_room:
+                    in_room = self._shared.current_room.get("in_room")
+                    if in_room:
+                        status_text.append(f" ({in_room})")
+                if self._shared.vacuum_state == "docked":
+                    if self._shared.vacuum_bat_charged():
+                        status_text.append(" \u00b7 ")
+                        status_text.append(f"{charging}{charge_level} ")
+                        status_text.append(f"{self._shared.vacuum_battery}%")
+                    else:
+                        status_text.append(" \u00b7 ")
+                        status_text.append(f"{charge_level} ")
+                        ready_txt = lang_map.get(
+                            "ready",
+                            translations.get("en", {}).get("ready", "Ready."),
+                        )
+                        status_text.append(ready_txt)
+                else:
+                    status_text.append(" \u00b7 ")
+                    status_text.append(f"{charge_level}")
+                    status_text.append(f" {self._shared.vacuum_battery}%")
+                if text_size >= 50 and getattr(text_img, "width", None):
+                    text_pixels = max(1, sum(len(text) for text in status_text))
+                    text_size = int(
+                        (text_size_coverage * text_img.width) // text_pixels
+                    )
+        return status_text, text_size