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

valetudo_map_parser/config/utils.py

@@ -110,82 +110,17 @@ class BaseHandler:
         """
         try:
             # Backup current image to last_image before processing new one
-            if hasattr(self.shared, "new_image") and self.shared.new_image is not None:
-                # Close old last_image to free memory before replacing it
-                if hasattr(self.shared, "last_image") and self.shared.last_image is not None:
-                    try:
-                        self.shared.last_image.close()
-                    except Exception:
-                        pass  # Ignore errors if image is already closed
-                self.shared.last_image = self.shared.new_image
+            self._backup_last_image()
 
             # Call the appropriate handler method based on handler type
-            if hasattr(self, "get_image_from_rrm"):
-                # This is a Rand256 handler
-                new_image = await self.get_image_from_rrm(
-                    m_json=m_json,
-                    destinations=destinations,
-                )
+            new_image = await self._generate_new_image(m_json, destinations)
+            if new_image is None:
+                return self._handle_failed_image_generation()
 
-            elif hasattr(self, "async_get_image_from_json"):
-                # This is a Hypfer handler
-                self.json_data = await HyperMapData.async_from_valetudo_json(m_json)
-                new_image = await self.async_get_image_from_json(
-                    m_json=m_json,
-                )
-            else:
-                LOGGER.warning(
-                    "%s: Handler type not recognized for async_get_image",
-                    self.file_name,
-                )
-                return (
-                    self.shared.last_image
-                    if hasattr(self.shared, "last_image")
-                    else None
-                )
+            # Process and store the new image
+            return await self._process_new_image(new_image, destinations, bytes_format)
 
-            # Store the new image in shared data
-            if new_image is not None:
-                # Update shared data
-                await self._async_update_shared_data(destinations)
-                self.shared.new_image = new_image
-                # Add text to the image
-                if self.shared.show_vacuum_state:
-                    text_editor = StatusText(self.shared)
-                    img_text = await text_editor.get_status_text(new_image)
-                    Drawable.status_text(
-                        new_image,
-                        img_text[1],
-                        self.shared.user_colors[8],
-                        img_text[0],
-                        self.shared.vacuum_status_font,
-                        self.shared.vacuum_status_position,
-                    )
-                # Convert to binary (PNG bytes) if requested
-                if bytes_format:
-                    self.shared.binary_image = pil_to_png_bytes(new_image)
-                else:
-                    self.shared.binary_image = pil_to_png_bytes(self.shared.last_image)
-                # Update the timestamp with current datetime
-                self.shared.image_last_updated = datetime.datetime.fromtimestamp(time())
-                LOGGER.debug("%s: Frame Completed.", self.file_name)
-                data = {}
-                if bytes_format:
-                    data = self.shared.to_dict()
-                return new_image, data
-            else:
-                LOGGER.warning(
-                    "%s: Failed to generate image from JSON data", self.file_name
-                )
-                if bytes_format and hasattr(self.shared, "last_image"):
-                    return pil_to_png_bytes(self.shared.last_image), {}
-                return (
-                    self.shared.last_image
-                    if hasattr(self.shared, "last_image")
-                    else None
-                ), {}
-
-        except Exception as e:
+        except (ValueError, TypeError, AttributeError, KeyError, RuntimeError) as e:
             LOGGER.warning(
                 "%s: Error in async_get_image: %s",
                 self.file_name,
@@ -193,24 +128,111 @@ class BaseHandler:
                 exc_info=True,
             )
             return (
-                self.shared.last_image if hasattr(self.shared, "last_image") else None
+                self.shared.last_image if hasattr(self.shared, "last_image") else None,
+                {},
             )
 
+    def _backup_last_image(self):
+        """Backup current image to last_image before processing new one."""
+        if hasattr(self.shared, "new_image") and self.shared.new_image is not None:
+            # Close old last_image to free memory before replacing it
+            if (
+                hasattr(self.shared, "last_image")
+                and self.shared.last_image is not None
+            ):
+                try:
+                    self.shared.last_image.close()
+                except (OSError, AttributeError, RuntimeError):
+                    pass  # Ignore errors if image is already closed
+            self.shared.last_image = self.shared.new_image
+
+    async def _generate_new_image(
+        self, m_json: dict | None, destinations: Destinations | None
+    ) -> PilPNG | None:
+        """Generate new image based on handler type."""
+        if hasattr(self, "get_image_from_rrm"):
+            # This is a Rand256 handler
+            return await self.get_image_from_rrm(
+                m_json=m_json,
+                destinations=destinations,
+            )
+
+        if hasattr(self, "async_get_image_from_json"):
+            # This is a Hypfer handler
+            self.json_data = await HyperMapData.async_from_valetudo_json(m_json)
+            return await self.async_get_image_from_json(m_json=m_json)
+
+        LOGGER.warning(
+            "%s: Handler type not recognized for async_get_image",
+            self.file_name,
+        )
+        return None
+
+    def _handle_failed_image_generation(self) -> Tuple[PilPNG | None, dict]:
+        """Handle case when image generation fails."""
+        LOGGER.warning("%s: Failed to generate image from JSON data", self.file_name)
+        return (
+            self.shared.last_image if hasattr(self.shared, "last_image") else None
+        ), self.shared.to_dict()
+
+    async def _process_new_image(
+        self, new_image: PilPNG, destinations: Destinations | None, bytes_format: bool
+    ) -> Tuple[PilPNG, dict]:
+        """Process and store the new image with text and binary conversion."""
+        # Update shared data
+        await self._async_update_shared_data(destinations)
+        self.shared.new_image = new_image
+
+        # Add text to the image
+        if self.shared.show_vacuum_state:
+            await self._add_status_text(new_image)
+
+        # Convert to binary (PNG bytes) if requested
+        self._convert_to_binary(new_image, bytes_format)
+
+        # Update the timestamp with current datetime
+        self.shared.image_last_updated = datetime.datetime.fromtimestamp(time())
+        LOGGER.debug("%s: Frame Completed.", self.file_name)
+
+        data = self.shared.to_dict() if bytes_format else {}
+        return new_image, data
+
+    async def _add_status_text(self, new_image: PilPNG):
+        """Add status text to the image."""
+        text_editor = StatusText(self.shared)
+        img_text = await text_editor.get_status_text(new_image)
+        Drawable.status_text(
+            new_image,
+            img_text[1],
+            self.shared.user_colors[8],
+            img_text[0],
+            self.shared.vacuum_status_font,
+            self.shared.vacuum_status_position,
+        )
+
+    def _convert_to_binary(self, new_image: PilPNG, bytes_format: bool):
+        """Convert image to binary PNG bytes."""
+        if bytes_format:
+            self.shared.binary_image = pil_to_png_bytes(new_image)
+        else:
+            self.shared.binary_image = pil_to_png_bytes(self.shared.last_image)
+
     async def _async_update_shared_data(self, destinations: Destinations | None = None):
         """Update the shared data with the latest information."""
 
         if hasattr(self, "get_rooms_attributes") and (
             self.shared.map_rooms is None and destinations is not None
         ):
+            # pylint: disable=no-member
             self.shared.map_rooms = await self.get_rooms_attributes(destinations)
             if self.shared.map_rooms:
                 LOGGER.debug("%s: Rand256 attributes rooms updated", self.file_name)
 
-
         if hasattr(self, "async_get_rooms_attributes") and (
             self.shared.map_rooms is None
         ):
             if self.shared.map_rooms is None:
+                # pylint: disable=no-member
                 self.shared.map_rooms = await self.async_get_rooms_attributes()
                 if self.shared.map_rooms:
                     LOGGER.debug("%s: Hyper attributes rooms updated", self.file_name)
@@ -219,6 +241,7 @@ class BaseHandler:
             hasattr(self, "get_calibration_data")
             and self.shared.attr_calibration_points is None
         ):
+            # pylint: disable=no-member
             self.shared.attr_calibration_points = self.get_calibration_data(
                 self.shared.image_rotate
             )
@@ -474,7 +497,8 @@ class BaseHandler:
             return hashlib.sha256(data_json.encode()).hexdigest()
         return None
 
-    async def async_copy_array(self, original_array: NumpyArray) -> NumpyArray:
+    @staticmethod
+    async def async_copy_array(original_array: NumpyArray) -> NumpyArray:
         """Copy the array using AsyncNumPy to yield control to the event loop."""
         return await AsyncNumPy.async_copy(original_array)
 

valetudo_map_parser/const.py

@@ -0,0 +1,288 @@
+"""Constants for the Valetudo Map Parser library."""
+
+CAMERA_STORAGE = "valetudo_camera"
+ATTR_IMAGE_LAST_UPDATED = "image_last_updated"
+ATTR_ROTATE = "rotate_image"
+ATTR_CROP = "crop_image"
+ATTR_MARGINS = "margins"
+ATTR_CONTENT_TYPE = "content_type"
+CONF_OFFSET_TOP = "offset_top"
+CONF_OFFSET_BOTTOM = "offset_bottom"
+CONF_OFFSET_LEFT = "offset_left"
+CONF_OFFSET_RIGHT = "offset_right"
+CONF_ASPECT_RATIO = "aspect_ratio"
+CONF_VAC_STAT = "show_vac_status"
+CONF_VAC_STAT_SIZE = "vac_status_size"
+CONF_VAC_STAT_POS = "vac_status_position"
+CONF_VAC_STAT_FONT = "vac_status_font"
+CONF_VACUUM_CONNECTION_STRING = "vacuum_map"
+CONF_VACUUM_ENTITY_ID = "vacuum_entity"
+CONF_VACUUM_CONFIG_ENTRY_ID = "vacuum_config_entry"
+CONF_VACUUM_IDENTIFIERS = "vacuum_identifiers"
+CONF_SNAPSHOTS_ENABLE = "enable_www_snapshots"
+CONF_EXPORT_SVG = "get_svg_file"
+CONF_AUTO_ZOOM = "auto_zoom"
+CONF_ZOOM_LOCK_RATIO = "zoom_lock_ratio"
+CONF_TRIMS_SAVE = "save_trims"
+ICON = "mdi:camera"
+NAME = "MQTT Vacuum Camera"
+
+DEFAULT_IMAGE_SIZE = {
+    "x": 5120,
+    "y": 5120,
+    "centre": [(5120 // 2), (5120 // 2)],
+}
+
+COLORS = [
+    "wall",
+    "zone_clean",
+    "robot",
+    "background",
+    "move",
+    "charger",
+    "no_go",
+    "go_to",
+]
+
+SENSOR_NO_DATA = {
+    "mainBrush": 0,
+    "sideBrush": 0,
+    "filter": 0,
+    "currentCleanTime": 0,
+    "currentCleanArea": 0,
+    "cleanTime": 0,
+    "cleanArea": 0,
+    "cleanCount": 0,
+    "battery": 0,
+    "state": 0,
+    "last_run_start": 0,
+    "last_run_end": 0,
+    "last_run_duration": 0,
+    "last_run_area": 0,
+    "last_bin_out": 0,
+    "last_bin_full": 0,
+    "last_loaded_map": "NoMap",
+    "robot_in_room": "Unsupported",
+}
+
+DEFAULT_PIXEL_SIZE = 5
+
+DEFAULT_VALUES = {
+    "rotate_image": "0",
+    "margins": "100",
+    "aspect_ratio": "None",
+    "offset_top": 0,
+    "offset_bottom": 0,
+    "offset_left": 0,
+    "offset_right": 0,
+    "auto_zoom": False,
+    "zoom_lock_ratio": True,
+    "show_vac_status": False,
+    "vac_status_font": "SCR/valetudo_map_parser/config/fonts/FiraSans.ttf",
+    "vac_status_size": 50,
+    "vac_status_position": True,
+    "get_svg_file": False,
+    "save_trims": True,
+    "trims_data": {"trim_left": 0, "trim_up": 0, "trim_right": 0, "trim_down": 0},
+    "enable_www_snapshots": False,
+    "color_charger": [255, 128, 0],
+    "color_move": [238, 247, 255],
+    "color_wall": [255, 255, 0],
+    "color_robot": [255, 255, 204],
+    "color_go_to": [0, 255, 0],
+    "color_no_go": [255, 0, 0],
+    "color_zone_clean": [255, 255, 255],
+    "color_background": [0, 125, 255],
+    "color_text": [255, 255, 255],
+    "alpha_charger": 255.0,
+    "alpha_move": 255.0,
+    "alpha_wall": 255.0,
+    "alpha_robot": 255.0,
+    "alpha_go_to": 255.0,
+    "alpha_no_go": 125.0,
+    "alpha_zone_clean": 125.0,
+    "alpha_background": 255.0,
+    "alpha_text": 255.0,
+    "color_room_0": [135, 206, 250],
+    "color_room_1": [176, 226, 255],
+    "color_room_2": [165, 105, 18],
+    "color_room_3": [164, 211, 238],
+    "color_room_4": [141, 182, 205],
+    "color_room_5": [96, 123, 139],
+    "color_room_6": [224, 255, 255],
+    "color_room_7": [209, 238, 238],
+    "color_room_8": [180, 205, 205],
+    "color_room_9": [122, 139, 139],
+    "color_room_10": [175, 238, 238],
+    "color_room_11": [84, 153, 199],
+    "color_room_12": [133, 193, 233],
+    "color_room_13": [245, 176, 65],
+    "color_room_14": [82, 190, 128],
+    "color_room_15": [72, 201, 176],
+    "alpha_room_0": 255.0,
+    "alpha_room_1": 255.0,
+    "alpha_room_2": 255.0,
+    "alpha_room_3": 255.0,
+    "alpha_room_4": 255.0,
+    "alpha_room_5": 255.0,
+    "alpha_room_6": 255.0,
+    "alpha_room_7": 255.0,
+    "alpha_room_8": 255.0,
+    "alpha_room_9": 255.0,
+    "alpha_room_10": 255.0,
+    "alpha_room_11": 255.0,
+    "alpha_room_12": 255.0,
+    "alpha_room_13": 255.0,
+    "alpha_room_14": 255.0,
+    "alpha_room_15": 255.0,
+}
+
+FONTS_AVAILABLE = [
+    {
+        "label": "Fira Sans",
+        "value": "config/fonts/FiraSans.ttf",
+    },
+    {
+        "label": "Inter",
+        "value": "config/fonts/Inter-VF.ttf",
+    },
+    {
+        "label": "M Plus Regular",
+        "value": "config/fonts/MPLUSRegular.ttf",
+    },
+    {
+        "label": "Noto Sans CJKhk",
+        "value": "config/fonts/NotoSansCJKhk-VF.ttf",
+    },
+    {
+        "label": "Noto Kufi Arabic",
+        "value": "config/fonts/NotoKufiArabic-VF.ttf",
+    },
+    {
+        "label": "Noto Sans Khojki",
+        "value": "config/fonts/NotoSansKhojki.ttf",
+    },
+    {
+        "label": "Lato Regular",
+        "value": "config/fonts/Lato-Regular.ttf",
+    },
+]
+
+NOT_STREAMING_STATES = {
+    "idle",
+    "paused",
+    "charging",
+    "error",
+    "docked",
+}
+
+DECODED_TOPICS = {
+    "/MapData/segments",
+    "/maploader/map",
+    "/maploader/status",
+    "/StatusStateAttribute/status",
+    "/StatusStateAttribute/error_description",
+    "/$state",
+    "/BatteryStateAttribute/level",
+    "/WifiConfigurationCapability/ips",
+    "/state",  # Rand256
+    "/destinations",  # Rand256
+    "/command",  # Rand256
+    "/custom_command",  # Rand256
+    "/attributes",  # Rand256
+}
+
+
+# self.command_topic need to be added to this dictionary after init.
+NON_DECODED_TOPICS = {
+    "/MapData/map-data",
+    "/map_data",
+}
+
+"""App Constants. Not in use, and dummy values"""
+IDLE_SCAN_INTERVAL = 120
+CLEANING_SCAN_INTERVAL = 5
+IS_ALPHA = "add_base_alpha"
+IS_ALPHA_R1 = "add_room_1_alpha"
+IS_ALPHA_R2 = "add_room_2_alpha"
+IS_OFFSET = "add_offset"
+
+"""Base Colours RGB"""
+COLOR_CHARGER = "color_charger"
+COLOR_MOVE = "color_move"
+COLOR_ROBOT = "color_robot"
+COLOR_NO_GO = "color_no_go"
+COLOR_GO_TO = "color_go_to"
+COLOR_BACKGROUND = "color_background"
+COLOR_ZONE_CLEAN = "color_zone_clean"
+COLOR_WALL = "color_wall"
+COLOR_TEXT = "color_text"
+
+"""Rooms Colours RGB"""
+COLOR_ROOM_0 = "color_room_0"
+COLOR_ROOM_1 = "color_room_1"
+COLOR_ROOM_2 = "color_room_2"
+COLOR_ROOM_3 = "color_room_3"
+COLOR_ROOM_4 = "color_room_4"
+COLOR_ROOM_5 = "color_room_5"
+COLOR_ROOM_6 = "color_room_6"
+COLOR_ROOM_7 = "color_room_7"
+COLOR_ROOM_8 = "color_room_8"
+COLOR_ROOM_9 = "color_room_9"
+COLOR_ROOM_10 = "color_room_10"
+COLOR_ROOM_11 = "color_room_11"
+COLOR_ROOM_12 = "color_room_12"
+COLOR_ROOM_13 = "color_room_13"
+COLOR_ROOM_14 = "color_room_14"
+COLOR_ROOM_15 = "color_room_15"
+
+"""Alpha for RGBA Colours"""
+ALPHA_CHARGER = "alpha_charger"
+ALPHA_MOVE = "alpha_move"
+ALPHA_ROBOT = "alpha_robot"
+ALPHA_NO_GO = "alpha_no_go"
+ALPHA_GO_TO = "alpha_go_to"
+ALPHA_BACKGROUND = "alpha_background"
+ALPHA_ZONE_CLEAN = "alpha_zone_clean"
+ALPHA_WALL = "alpha_wall"
+ALPHA_TEXT = "alpha_text"
+ALPHA_ROOM_0 = "alpha_room_0"
+ALPHA_ROOM_1 = "alpha_room_1"
+ALPHA_ROOM_2 = "alpha_room_2"
+ALPHA_ROOM_3 = "alpha_room_3"
+ALPHA_ROOM_4 = "alpha_room_4"
+ALPHA_ROOM_5 = "alpha_room_5"
+ALPHA_ROOM_6 = "alpha_room_6"
+ALPHA_ROOM_7 = "alpha_room_7"
+ALPHA_ROOM_8 = "alpha_room_8"
+ALPHA_ROOM_9 = "alpha_room_9"
+ALPHA_ROOM_10 = "alpha_room_10"
+ALPHA_ROOM_11 = "alpha_room_11"
+ALPHA_ROOM_12 = "alpha_room_12"
+ALPHA_ROOM_13 = "alpha_room_13"
+ALPHA_ROOM_14 = "alpha_room_14"
+ALPHA_ROOM_15 = "alpha_room_15"
+
+""" Constants for the attribute keys """
+ATTR_FRIENDLY_NAME = "friendly_name"
+ATTR_VACUUM_BATTERY = "battery"
+ATTR_VACUUM_CHARGING = "charging"
+ATTR_VACUUM_POSITION = "vacuum_position"
+ATTR_VACUUM_TOPIC = "vacuum_topic"
+ATTR_VACUUM_STATUS = "vacuum_status"
+ATTR_JSON_DATA = "json_data"
+ATTR_VACUUM_JSON_ID = "vacuum_json_id"
+ATTR_CALIBRATION_POINTS = "calibration_points"
+ATTR_SNAPSHOT = "snapshot"
+ATTR_SNAPSHOT_PATH = "snapshot_path"
+ATTR_ROOMS = "rooms"
+ATTR_ZONES = "zones"
+ATTR_POINTS = "points"
+ATTR_OBSTACLES = "obstacles"
+ATTR_CAMERA_MODE = "camera_mode"
+
+# Status text cost
+charge_level = "\u03de"  # unicode Koppa symbol
+charging = "\u2211"  # unicode Charging symbol
+dot = " \u00b7 "  # unicode middle dot
+text_size_coverage = 1.5  # resize factor for the text