valetudo-map-parser 0.1.11b1__py3-none-any.whl → 0.1.12b0__py3-none-any.whl

valetudo_map_parser/config/drawable.py

@@ -12,13 +12,14 @@ from __future__ import annotations
 
 import logging
 from pathlib import Path
+from typing import Union
 
 import numpy as np
 from mvcrender.blend import get_blended_color, sample_and_blend_color
 from mvcrender.draw import circle_u8, line_u8, polygon_u8
-from PIL import Image, ImageDraw, ImageFont
+from PIL import ImageDraw, ImageFont
 
-from .types import Color, NumpyArray, PilPNG, Point, Tuple, Union
+from .types import Color, NumpyArray, PilPNG, Point
 
 
 _LOGGER = logging.getLogger(__name__)
@@ -204,24 +205,6 @@ class Drawable:
         layer = Drawable._line(layer, xp1, yp1, xp2, yp2, pole_color, pole_width)
         return layer
 
-    @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."""
-        n = len(points)
-        inside = False
-        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:
-                        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
-
     @staticmethod
     def _line(
         layer: NumpyArray,
@@ -328,56 +311,6 @@ class Drawable:
         image[y1:y2, x1:x2] = color
         return image
 
-    @staticmethod
-    def _polygon_outline(
-        arr: NumpyArray,
-        points: list[Tuple[int, int]],
-        width: int,
-        outline_color: Color,
-        fill_color: Color = None,
-    ) -> NumpyArray:
-        """
-        Draw the outline of a polygon on the array using _line, and optionally fill it.
-        Uses NumPy vectorized operations for improved performance.
-        """
-        # Draw the outline
-        for i, _ in enumerate(points):
-            current_point = points[i]
-            next_point = points[(i + 1) % len(points)]
-            arr = Drawable._line(
-                arr,
-                current_point[0],
-                current_point[1],
-                next_point[0],
-                next_point[1],
-                outline_color,
-                width,
-            )
-
-        # Fill the polygon if a fill color is provided
-        if fill_color is not None:
-            # Get the bounding box of the polygon
-            min_x = max(0, min(p[0] for p in points))
-            max_x = min(arr.shape[1] - 1, max(p[0] for p in points))
-            min_y = max(0, min(p[1] for p in points))
-            max_y = min(arr.shape[0] - 1, max(p[1] for p in points))
-
-            # Create a mask for the polygon region
-            mask = np.zeros((max_y - min_y + 1, max_x - min_x + 1), dtype=bool)
-
-            # Adjust points to the mask's coordinate system
-            adjusted_points = [(p[0] - min_x, p[1] - min_y) for p in points]
-
-            # Test each point in the grid
-            for i in range(mask.shape[0]):
-                for j in range(mask.shape[1]):
-                    mask[i, j] = Drawable.point_inside(j, i, adjusted_points)
-
-            # Apply the fill color to the masked region
-            arr[min_y : max_y + 1, min_x : max_x + 1][mask] = fill_color
-
-        return arr
-
     @staticmethod
     async def zones(layers: NumpyArray, coordinates, color: Color) -> NumpyArray:
         """
@@ -419,14 +352,18 @@ class Drawable:
             mask_rgba = np.zeros((box_h, box_w, 4), dtype=np.uint8)
 
             # Convert points to xs, ys arrays (adjusted to local bbox coordinates)
-            xs = np.array([int(pts[i] - min_x) for i in range(0, len(pts), 2)], dtype=np.int32)
-            ys = np.array([int(pts[i] - min_y) for i in range(1, len(pts), 2)], dtype=np.int32)
+            xs = np.array(
+                [int(pts[i] - min_x) for i in range(0, len(pts), 2)], dtype=np.int32
+            )
+            ys = np.array(
+                [int(pts[i] - min_y) for i in range(1, len(pts), 2)], dtype=np.int32
+            )
 
             # Draw filled polygon on mask
             polygon_u8(mask_rgba, xs, ys, (0, 0, 0, 0), 0, (255, 255, 255, 255))
 
             # Extract boolean mask from first channel
-            zone_mask = (mask_rgba[:, :, 0] > 0)
+            zone_mask = mask_rgba[:, :, 0] > 0
             del mask_rgba
             del xs
             del ys

valetudo_map_parser/config/rand256_parser.py

@@ -281,6 +281,49 @@ class RRMapParser:
                 break
         return blocks
 
+    def _process_image_pixels(
+        self,
+        buf: bytes,
+        offset: int,
+        g3offset: int,
+        length: int,
+        pixels: bool,
+        parameters: Dict[str, Any],
+    ) -> None:
+        """Process image pixels sequentially - segments are organized as blocks."""
+        current_segments = {}
+
+        for i in range(length):
+            pixel_byte = struct.unpack(
+                "<B",
+                buf[offset + 24 + g3offset + i : offset + 25 + g3offset + i],
+            )[0]
+
+            segment_type = pixel_byte & 0x07
+            if segment_type == 0:
+                continue
+
+            if segment_type == 1 and pixels:
+                # Wall pixel
+                parameters["pixels"]["walls"].append(i)
+            else:
+                # Floor or room segment
+                segment_id = pixel_byte >> 3
+                if segment_id == 0 and pixels:
+                    # Floor pixel
+                    parameters["pixels"]["floor"].append(i)
+                elif segment_id != 0:
+                    # Room segment - segments are sequential blocks
+                    if segment_id not in current_segments:
+                        parameters["segments"]["id"].append(segment_id)
+                        parameters["segments"]["pixels_seg_" + str(segment_id)] = []
+                        current_segments[segment_id] = True
+
+                    if pixels:
+                        parameters["segments"]["pixels_seg_" + str(segment_id)].append(
+                            i
+                        )
+
     def _parse_image_block(
         self, buf: bytes, offset: int, length: int, hlength: int, pixels: bool = True
     ) -> Dict[str, Any]:
@@ -330,41 +373,9 @@ class RRMapParser:
                 parameters["dimensions"]["height"] > 0
                 and parameters["dimensions"]["width"] > 0
             ):
-                # Process data sequentially - segments are organized as blocks
-                current_segments = {}
-
-                for i in range(length):
-                    pixel_byte = struct.unpack(
-                        "<B",
-                        buf[offset + 24 + g3offset + i : offset + 25 + g3offset + i],
-                    )[0]
-
-                    segment_type = pixel_byte & 0x07
-                    if segment_type == 0:
-                        continue
-
-                    if segment_type == 1 and pixels:
-                        # Wall pixel
-                        parameters["pixels"]["walls"].append(i)
-                    else:
-                        # Floor or room segment
-                        segment_id = pixel_byte >> 3
-                        if segment_id == 0 and pixels:
-                            # Floor pixel
-                            parameters["pixels"]["floor"].append(i)
-                        elif segment_id != 0:
-                            # Room segment - segments are sequential blocks
-                            if segment_id not in current_segments:
-                                parameters["segments"]["id"].append(segment_id)
-                                parameters["segments"][
-                                    "pixels_seg_" + str(segment_id)
-                                ] = []
-                                current_segments[segment_id] = True
-
-                            if pixels:
-                                parameters["segments"][
-                                    "pixels_seg_" + str(segment_id)
-                                ].append(i)
+                self._process_image_pixels(
+                    buf, offset, g3offset, length, pixels, parameters
+                )
 
             parameters["segments"]["count"] = len(parameters["segments"]["id"])
             return parameters
@@ -377,6 +388,79 @@ class RRMapParser:
                 "pixels": {"floor": [], "walls": [], "segments": {}},
             }
 
+    def _calculate_angle_from_points(self, points: list) -> Optional[float]:
+        """Calculate angle from last two points in a path."""
+        if len(points) >= 2:
+            last_point = points[-1]
+            second_last = points[-2]
+            dx = last_point[0] - second_last[0]
+            dy = last_point[1] - second_last[1]
+            if dx != 0 or dy != 0:
+                angle_rad = math.atan2(dy, dx)
+                return math.degrees(angle_rad)
+        return None
+
+    def _transform_path_coordinates(self, points: list) -> list:
+        """Apply coordinate transformation to path points."""
+        return [[point[0], self.Tools.DIMENSION_MM - point[1]] for point in points]
+
+    def _parse_path_data(self, blocks: dict, parsed_map_data: dict) -> list:
+        """Parse path data with coordinate transformation."""
+        transformed_path_points = []
+        if self.Types.PATH.value in blocks:
+            path_data = blocks[self.Types.PATH.value].copy()
+            transformed_path_points = self._transform_path_coordinates(
+                path_data["points"]
+            )
+            path_data["points"] = transformed_path_points
+
+            angle = self._calculate_angle_from_points(transformed_path_points)
+            if angle is not None:
+                path_data["current_angle"] = angle
+            parsed_map_data["path"] = path_data
+        return transformed_path_points
+
+    def _parse_goto_path_data(self, blocks: dict, parsed_map_data: dict) -> None:
+        """Parse goto predicted path with coordinate transformation."""
+        if self.Types.GOTO_PREDICTED_PATH.value in blocks:
+            goto_path_data = blocks[self.Types.GOTO_PREDICTED_PATH.value].copy()
+            goto_path_data["points"] = self._transform_path_coordinates(
+                goto_path_data["points"]
+            )
+
+            angle = self._calculate_angle_from_points(goto_path_data["points"])
+            if angle is not None:
+                goto_path_data["current_angle"] = angle
+            parsed_map_data["goto_predicted_path"] = goto_path_data
+
+    def _add_zone_data(self, blocks: dict, parsed_map_data: dict) -> None:
+        """Add zone and area data to parsed map."""
+        parsed_map_data["currently_cleaned_zones"] = (
+            blocks[self.Types.CURRENTLY_CLEANED_ZONES.value]["zones"]
+            if self.Types.CURRENTLY_CLEANED_ZONES.value in blocks
+            else []
+        )
+        parsed_map_data["forbidden_zones"] = (
+            blocks[self.Types.FORBIDDEN_ZONES.value]["forbidden_zones"]
+            if self.Types.FORBIDDEN_ZONES.value in blocks
+            else []
+        )
+        parsed_map_data["forbidden_mop_zones"] = (
+            blocks[self.Types.FORBIDDEN_MOP_ZONES.value]["forbidden_mop_zones"]
+            if self.Types.FORBIDDEN_MOP_ZONES.value in blocks
+            else []
+        )
+        parsed_map_data["virtual_walls"] = (
+            blocks[self.Types.VIRTUAL_WALLS.value]["virtual_walls"]
+            if self.Types.VIRTUAL_WALLS.value in blocks
+            else []
+        )
+        parsed_map_data["carpet_areas"] = (
+            blocks[self.Types.CARPET_MAP.value]["carpet_map"]
+            if self.Types.CARPET_MAP.value in blocks
+            else []
+        )
+
     def parse_rrm_data(
         self, map_buf: bytes, pixels: bool = False
     ) -> Optional[Dict[str, Any]]:
@@ -393,39 +477,14 @@ class RRMapParser:
                 robot_data = blocks[self.Types.ROBOT_POSITION.value]
                 parsed_map_data["robot"] = robot_data["position"]
 
-            # Parse path data with coordinate transformation FIRST
-            transformed_path_points = []
-            if self.Types.PATH.value in blocks:
-                path_data = blocks[self.Types.PATH.value].copy()
-                # Apply coordinate transformation like current parser
-                transformed_path_points = [
-                    [point[0], self.Tools.DIMENSION_MM - point[1]]
-                    for point in path_data["points"]
-                ]
-                path_data["points"] = transformed_path_points
-
-                # Calculate current angle from transformed points
-                if len(transformed_path_points) >= 2:
-                    last_point = transformed_path_points[-1]
-                    second_last = transformed_path_points[-2]
-                    dx = last_point[0] - second_last[0]
-                    dy = last_point[1] - second_last[1]
-                    if dx != 0 or dy != 0:
-                        angle_rad = math.atan2(dy, dx)
-                        path_data["current_angle"] = math.degrees(angle_rad)
-                parsed_map_data["path"] = path_data
-
-            # Get robot angle from TRANSFORMED path data (like current implementation)
-            robot_angle = 0
-            if len(transformed_path_points) >= 2:
-                last_point = transformed_path_points[-1]
-                second_last = transformed_path_points[-2]
-                dx = last_point[0] - second_last[0]
-                dy = last_point[1] - second_last[1]
-                if dx != 0 or dy != 0:
-                    angle_rad = math.atan2(dy, dx)
-                    robot_angle = int(math.degrees(angle_rad))
+            # Parse path data with coordinate transformation
+            transformed_path_points = self._parse_path_data(blocks, parsed_map_data)
 
+            # Get robot angle from transformed path data
+            robot_angle = 0
+            angle = self._calculate_angle_from_points(transformed_path_points)
+            if angle is not None:
+                robot_angle = int(angle)
             parsed_map_data["robot_angle"] = robot_angle
 
             # Parse charger position
@@ -438,24 +497,7 @@ class RRMapParser:
                 parsed_map_data["image"] = blocks[self.Types.IMAGE.value]
 
             # Parse goto predicted path
-            if self.Types.GOTO_PREDICTED_PATH.value in blocks:
-                goto_path_data = blocks[self.Types.GOTO_PREDICTED_PATH.value].copy()
-                # Apply coordinate transformation
-                goto_path_data["points"] = [
-                    [point[0], self.Tools.DIMENSION_MM - point[1]]
-                    for point in goto_path_data["points"]
-                ]
-                # Calculate current angle from transformed points (like working parser)
-                if len(goto_path_data["points"]) >= 2:
-                    points = goto_path_data["points"]
-                    last_point = points[-1]
-                    second_last = points[-2]
-                    dx = last_point[0] - second_last[0]
-                    dy = last_point[1] - second_last[1]
-                    if dx != 0 or dy != 0:
-                        angle_rad = math.atan2(dy, dx)
-                        goto_path_data["current_angle"] = math.degrees(angle_rad)
-                parsed_map_data["goto_predicted_path"] = goto_path_data
+            self._parse_goto_path_data(blocks, parsed_map_data)
 
             # Parse goto target
             if self.Types.GOTO_TARGET.value in blocks:
@@ -463,32 +505,8 @@ class RRMapParser:
                     "position"
                 ]
 
-            # Add missing fields to match expected JSON format
-            parsed_map_data["currently_cleaned_zones"] = (
-                blocks[self.Types.CURRENTLY_CLEANED_ZONES.value]["zones"]
-                if self.Types.CURRENTLY_CLEANED_ZONES.value in blocks
-                else []
-            )
-            parsed_map_data["forbidden_zones"] = (
-                blocks[self.Types.FORBIDDEN_ZONES.value]["forbidden_zones"]
-                if self.Types.FORBIDDEN_ZONES.value in blocks
-                else []
-            )
-            parsed_map_data["forbidden_mop_zones"] = (
-                blocks[self.Types.FORBIDDEN_MOP_ZONES.value]["forbidden_mop_zones"]
-                if self.Types.FORBIDDEN_MOP_ZONES.value in blocks
-                else []
-            )
-            parsed_map_data["virtual_walls"] = (
-                blocks[self.Types.VIRTUAL_WALLS.value]["virtual_walls"]
-                if self.Types.VIRTUAL_WALLS.value in blocks
-                else []
-            )
-            parsed_map_data["carpet_areas"] = (
-                blocks[self.Types.CARPET_MAP.value]["carpet_map"]
-                if self.Types.CARPET_MAP.value in blocks
-                else []
-            )
+            # Add zone and area data
+            self._add_zone_data(blocks, parsed_map_data)
             parsed_map_data["is_valid"] = self.is_valid
 
             return parsed_map_data

valetudo_map_parser/config/shared.py

@@ -11,7 +11,7 @@ from typing import List
 from PIL import Image
 
 from .utils import pil_size_rotation
-from .types import (
+from ..const import (
     ATTR_CALIBRATION_POINTS,
     ATTR_CAMERA_MODE,
     ATTR_CONTENT_TYPE,
@@ -39,7 +39,10 @@ from .types import (
     CONF_VAC_STAT_POS,
     CONF_VAC_STAT_SIZE,
     CONF_ZOOM_LOCK_RATIO,
+    NOT_STREAMING_STATES,
     DEFAULT_VALUES,
+)
+from .types import (
     CameraModes,
     Colors,
     PilPNG,
@@ -119,10 +122,21 @@ class CameraShared:
         self.trims = TrimsData.from_dict(DEFAULT_VALUES["trims_data"])
         self.skip_room_ids: List[str] = []
         self.device_info = None
+        self._battery_state = None
 
     def vacuum_bat_charged(self) -> bool:
         """Check if the vacuum is charging."""
-        return (self.vacuum_state == "docked") and (int(self.vacuum_battery) < 100)
+        if self.vacuum_state != "docked":
+            self._battery_state = "not_charging"
+        elif (self._battery_state == "charging_done") and (
+            int(self.vacuum_battery) == 100
+        ):
+            self._battery_state = "charged"
+        else:
+            self._battery_state = (
+                "charging" if int(self.vacuum_battery) < 100 else "charging_done"
+            )
+        return (self.vacuum_state == "docked") and (self._battery_state == "charging")
 
     @staticmethod
     def _compose_obstacle_links(vacuum_host_ip: str, obstacles: list) -> list | None:
@@ -209,17 +223,25 @@ class CameraShared:
 
         return attrs
 
+    def is_streaming(self) -> bool:
+        """Return true if the device is streaming."""
+        updated_status = self.vacuum_state
+        attr_is_streaming = (
+            updated_status not in NOT_STREAMING_STATES or self.vacuum_bat_charged()
+        ) or not self.binary_image
+        return attr_is_streaming
+
     def to_dict(self) -> dict:
         """Return a dictionary with image and attributes data."""
-
-        return {
+        data = {
             "image": {
                 "binary": self.binary_image,
-                "pil_image": self.new_image,
                 "size": pil_size_rotation(self.image_rotate, self.new_image),
+                "streaming": self.is_streaming(),
             },
             "attributes": self.generate_attributes(),
         }
+        return data
 
 
 class CameraSharedManager:
@@ -233,9 +255,6 @@ class CameraSharedManager:
             self.device_info = device_info
             self.update_shared_data(device_info)
 
-        # Automatically initialize shared data for the instance
-        # self._init_shared_data(device_info)
-
     def update_shared_data(self, device_info):
         """Initialize the shared data with device_info."""
         instance = self.get_instance()  # Retrieve the correct instance

valetudo_map_parser/config/status_text/__init__.py

@@ -0,0 +1,6 @@
+"""Status text module for vacuum cleaners."""
+
+from .status_text import StatusText
+from .translations import translations
+
+__all__ = ["StatusText", "translations"]

valetudo_map_parser/config/status_text/status_text.py

@@ -1,15 +1,16 @@
 """
-Version: 0.1.10
+Version: 0.1.12
 Status text of the vacuum cleaners.
 Class to handle the status text of the vacuum cleaners.
 """
 
 from __future__ import annotations
+from typing import Callable
 
+from ...const import text_size_coverage, charge_level, charging, dot
 from ..types import LOGGER, PilPNG
 from .translations import translations
 
-
 LOGGER.propagate = True
 
 
@@ -21,9 +22,18 @@ class StatusText:
     def __init__(self, camera_shared):
         self._shared = camera_shared
         self.file_name = self._shared.file_name
+        self._language = (self._shared.user_language or "en").lower()
+        self._lang_map = translations.get(self._language) or translations.get("en", {})
+        self._compose_functions: list[Callable[[list[str]], list[str]]] = [
+            self._current_room,
+            self._docked_charged,
+            self._docked_ready,
+            self._active,
+            self._mqtt_disconnected,
+        ]  # static ordered sequence of compose functions
 
     @staticmethod
-    async def get_vacuum_status_translation(
+    async def _get_vacuum_status_translation(
         language: str = "en",
     ) -> dict[str, str] | None:
         """
@@ -33,64 +43,79 @@ class StatusText:
         """
         return translations.get((language or "en").lower())
 
-    async def translate_vacuum_status(self) -> str:
+    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)
+        translation = await self._get_vacuum_status_translation(language)
         if not translation:
             translation = translations.get("en", {})
         return translation.get(status, str(status).capitalize())
 
+    def _mqtt_disconnected(self, current_state: list[str]) -> list[str]:
+        """Return the translated MQTT disconnected status."""
+        if not self._shared.vacuum_connection:
+            mqtt_disc = (self._lang_map or {}).get(
+                "mqtt_disconnected",
+                translations.get("en", {}).get(
+                    "mqtt_disconnected", "Disconnected from MQTT?"
+                ),
+            )
+            return [f"{self.file_name}: {mqtt_disc}"]
+        return current_state
+
+    def _docked_charged(self, current_state: list[str]) -> list[str]:
+        """Return the translated docked and charging status."""
+        if self._shared.vacuum_state == "docked" and self._shared.vacuum_bat_charged():
+            current_state.append(dot)
+            current_state.append(f"{charging}{charge_level} ")
+            current_state.append(f"{self._shared.vacuum_battery}%")
+        return current_state
+
+    def _docked_ready(self, current_state: list[str]) -> list[str]:
+        """Return the translated docked and ready status."""
+        if (
+            self._shared.vacuum_state == "docked"
+            and not self._shared.vacuum_bat_charged()
+        ):
+            current_state.append(dot)
+            current_state.append(f"{charge_level} ")
+            ready_txt = (self._lang_map or {}).get(
+                "ready",
+                translations.get("en", {}).get("ready", "Ready."),
+            )
+            current_state.append(ready_txt)
+        return current_state
+
+    def _current_room(self, current_state: list[str]) -> list[str]:
+        """Return the current room information."""
+        if self._shared.current_room:
+            in_room = self._shared.current_room.get("in_room")
+            if in_room and in_room != "Room 31":
+                current_state.append(f" ({in_room})")
+        return current_state
+
+    def _active(self, current_state: list[str]) -> list[str]:
+        """Return the translated active status."""
+        if self._shared.vacuum_state != "docked":
+            current_state.append(dot)
+            current_state.append(f"{charge_level}")
+            current_state.append(f" {self._shared.vacuum_battery}%")
+        return current_state
+
     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
-                    )
+        vacuum_state = await self._translate_vacuum_status()
+        status_text = [f"{self.file_name}: {vacuum_state}"]
+        # Compose Status Text with available data.
+        for func in self._compose_functions:
+            status_text = func(status_text)
+        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