valetudo-map-parser 0.1.10rc5__tar.gz → 0.1.10rc6__tar.gz

{valetudo_map_parser-0.1.10rc5 → valetudo_map_parser-0.1.10rc6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: valetudo-map-parser
-Version: 0.1.10rc5
+Version: 0.1.10rc6
 Summary: A Python library to parse Valetudo map data returning a PIL Image object.
 License: Apache-2.0
 License-File: LICENSE

{valetudo_map_parser-0.1.10rc5 → valetudo_map_parser-0.1.10rc6}/SCR/valetudo_map_parser/config/shared.py

@@ -1,7 +1,7 @@
 """
 Class Camera Shared.
 Keep the data between the modules.
-Version: v0.1.10
+Version: v0.1.12
 """
 
 import asyncio
@@ -54,71 +54,68 @@ class CameraShared:
     """
 
     def __init__(self, file_name):
-        self.camera_mode: str = CameraModes.MAP_VIEW  # Camera mode
-        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)
-        self.last_image = Image.new(
-            "RGBA", (250, 150), (128, 128, 128, 255)
-        )  # Gray default image
-        self.new_image: PilPNG | None = None  # New image received
-        self.binary_image: bytes | None = None  # Current image in binary format
-        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
-        self.image_ref_width: int = 0  # Image reference width
-        self.image_aspect_ratio: str = "None"  # Change Image aspect ratio
-        self.image_grab = True  # Grab image from MQTT
-        self.image_rotate: int = 0  # Rotate image
-        self.drawing_limit: float = 0.0  # Drawing CPU limit
-        self.current_room = None  # Current room of rhe vacuum
-        self.user_colors = Colors  # User base colors
-        self.rooms_colors = Colors  # Rooms colors
-        self.vacuum_battery = 0  # Vacuum battery 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
+        self.camera_mode: str = CameraModes.MAP_VIEW
+        self.frame_number: int = 0
+        self.destinations: list = []
+        self.rand256_active_zone: list = []
+        self.rand256_zone_coordinates: list = []
+        self.is_rand: bool = False
+        self._new_mqtt_message = False
+        self.last_image = Image.new("RGBA", (250, 150), (128, 128, 128, 255))
+        self.new_image: PilPNG | None = None
+        self.binary_image: bytes | None = None
+        self.image_last_updated: float = 0.0
+        self.image_format = "image/pil"
+        self.image_size = None
+        self.robot_size = None
+        self.image_auto_zoom: bool = False
+        self.image_zoom_lock_ratio: bool = True
+        self.image_ref_height: int = 0
+        self.image_ref_width: int = 0
+        self.image_aspect_ratio: str = "None"
+        self.image_grab = True
+        self.image_rotate: int = 0
+        self.drawing_limit: float = 0.0
+        self.current_room = None
+        self.user_colors = Colors
+        self.rooms_colors = Colors
+        self.vacuum_battery = 0
+        self.vacuum_connection = False
+        self.vacuum_state = None
+        self.charger_position = None
+        self.show_vacuum_state = None
         self.vacuum_status_font: str = (
-            "custom_components/mqtt_vacuum_camera/utils/fonts/FiraSans.ttf"  # Font
+            "custom_components/mqtt_vacuum_camera/utils/fonts/FiraSans.ttf"
         )
-        self.vacuum_status_size: int = 50  # Vacuum status size
-        self.vacuum_status_position: bool = True  # Vacuum status text image top
-        self.snapshot_take = False  # Take snapshot
-        self.vacuum_error = None  # Vacuum error
-        self.vacuum_api = None  # Vacuum API
-        self.vacuum_ips = None  # Vacuum IPs
-        self.vac_json_id = None  # Vacuum json id
-        self.margins = "100"  # Image margins
-        self.obstacles_data = None  # Obstacles data
-        self.obstacles_pos = None  # Obstacles position
-        self.offset_top = 0  # Image offset top
-        self.offset_down = 0  # Image offset down
-        self.offset_left = 0  # Image offset left
-        self.offset_right = 0  # Image offset right
-        self.export_svg = False  # Export SVG
-        self.svg_path = None  # SVG Export path
-        self.enable_snapshots = False  # Enable snapshots
-        self.file_name = file_name  # vacuum friendly name as File name
-        self.attr_calibration_points = None  # Calibration points of the image
-        self.map_rooms = None  # Rooms data from the vacuum
-        self.map_pred_zones = None  # Predefined zones data
-        self.map_pred_points = None  # Predefined points data
-        self.map_new_path = None  # New path data
-        self.map_old_path = None  # Old path data
-        self.user_language = None  # User language
+        self.vacuum_status_size: int = 50
+        self.vacuum_status_position: bool = True
+        self.snapshot_take = False
+        self.vacuum_error = None
+        self.vacuum_api = None
+        self.vacuum_ips = None
+        self.vac_json_id = None
+        self.margins = "100"
+        self.obstacles_data = None
+        self.obstacles_pos = None
+        self.offset_top = 0
+        self.offset_down = 0
+        self.offset_left = 0
+        self.offset_right = 0
+        self.export_svg = False
+        self.svg_path = None
+        self.enable_snapshots = False
+        self.file_name = file_name
+        self.attr_calibration_points = None
+        self.map_rooms = None
+        self.map_pred_zones = None
+        self.map_pred_points = None
+        self.map_new_path = None
+        self.map_old_path = None
+        self.user_language = None
         self.trim_crop_data = None
-        self.trims = TrimsData.from_dict(DEFAULT_VALUES["trims_data"])  # Trims data
+        self.trims = TrimsData.from_dict(DEFAULT_VALUES["trims_data"])
         self.skip_room_ids: List[str] = []
-        self.device_info = None  # Store the device_info
+        self.device_info = None
 
     def vacuum_bat_charged(self) -> bool:
         """Check if the vacuum is charging."""
@@ -126,49 +123,35 @@ class CameraShared:
 
     @staticmethod
     def _compose_obstacle_links(vacuum_host_ip: str, obstacles: list) -> list | None:
-        """
-        Compose JSON with obstacle details including the image link.
-        """
+        """Compose JSON with obstacle details including the image link."""
         obstacle_links = []
         if not obstacles or not vacuum_host_ip:
             return None
 
         for obstacle in obstacles:
-            # Extract obstacle details
             label = obstacle.get("label", "")
             points = obstacle.get("points", {})
             image_id = obstacle.get("id", "None")
 
             if label and points and image_id and vacuum_host_ip:
-                # Append formatted obstacle data
                 if image_id != "None":
-                    # Compose the link
                     image_link = (
                         f"http://{vacuum_host_ip}"
                         f"/api/v2/robot/capabilities/ObstacleImagesCapability/img/{image_id}"
                     )
                     obstacle_links.append(
-                        {
-                            "point": points,
-                            "label": label,
-                            "link": image_link,
-                        }
+                        {"point": points, "label": label, "link": image_link}
                     )
                 else:
-                    obstacle_links.append(
-                        {
-                            "point": points,
-                            "label": label,
-                        }
-                    )
+                    obstacle_links.append({"point": points, "label": label})
         return obstacle_links
 
     def update_user_colors(self, user_colors):
-        """Update the user colors."""
+        """Update user colors palette"""
         self.user_colors = user_colors
 
     def get_user_colors(self):
-        """Get the user colors."""
+        """Return user colors"""
         return self.user_colors
 
     def update_rooms_colors(self, user_colors):
@@ -176,7 +159,7 @@ class CameraShared:
         self.rooms_colors = user_colors
 
     def get_rooms_colors(self):
-        """Get the rooms colors."""
+        """Return rooms colors"""
         return self.rooms_colors
 
     def reset_trims(self) -> dict:
@@ -185,7 +168,7 @@ class CameraShared:
         return self.trims
 
     async def batch_update(self, **kwargs):
-        """Batch update multiple attributes."""
+        """Update the data of Shared in Batch"""
         for key, value in kwargs.items():
             setattr(self, key, value)
 
@@ -210,24 +193,32 @@ class CameraShared:
             )
             attrs[ATTR_OBSTACLES] = self.obstacles_data
 
-        if self.enable_snapshots:
-            attrs[ATTR_SNAPSHOT] = self.snapshot_take
-        else:
-            attrs[ATTR_SNAPSHOT] = False
+        attrs[ATTR_SNAPSHOT] = self.snapshot_take if self.enable_snapshots else False
 
-        # Add dynamic shared attributes if they are available
         shared_attrs = {
             ATTR_ROOMS: self.map_rooms,
             ATTR_ZONES: self.map_pred_zones,
             ATTR_POINTS: self.map_pred_points,
         }
-
         for key, value in shared_attrs.items():
             if value is not None:
                 attrs[key] = value
 
         return attrs
 
+    def to_dict(self) -> dict:
+        """Return a dictionary with image and attributes data."""
+        return {
+            "image": {
+                "binary": self.binary_image,
+                "pil_image_size": self.new_image.size,
+                "size": self.new_image.size if self.new_image else None,
+                "format": self.image_format,
+                "updated": self.image_last_updated,
+            },
+            "attributes": self.generate_attributes(),
+        }
+
 
 class CameraSharedManager:
     """Camera Shared Manager class."""

{valetudo_map_parser-0.1.10rc5 → valetudo_map_parser-0.1.10rc6}/SCR/valetudo_map_parser/config/types.py

@@ -8,7 +8,7 @@ import json
 import logging
 import threading
 from dataclasses import asdict, dataclass
-from typing import Any, Dict, Optional, Tuple, TypedDict, Union
+from typing import Any, Dict, Optional, Tuple, TypedDict, Union, List, NotRequired
 
 import numpy as np
 from PIL import Image
@@ -18,6 +18,23 @@ DEFAULT_ROOMS = 1
 
 LOGGER = logging.getLogger(__package__)
 
+class Spot(TypedDict):
+    name: str
+    coordinates: List[int]  # [x, y]
+
+class Zone(TypedDict):
+    name: str
+    coordinates: List[List[int]]  # [[x1, y1, x2, y2, repeats], ...]
+
+class Room(TypedDict):
+    name: str
+    id: int
+
+class Destinations(TypedDict, total=False):
+    spots: NotRequired[Optional[List[Spot]]]
+    zones: NotRequired[Optional[List[Zone]]]
+    rooms: NotRequired[Optional[List[Room]]]
+    updated: NotRequired[Optional[int]]
 
 class RoomProperty(TypedDict):
     number: int

{valetudo_map_parser-0.1.10rc5 → valetudo_map_parser-0.1.10rc6}/SCR/valetudo_map_parser/config/utils.py

@@ -5,7 +5,7 @@ from time import time
 import hashlib
 import json
 from dataclasses import dataclass
-from typing import Callable, List, Optional
+from typing import Callable, List, Optional, Tuple
 import io
 
 import numpy as np
@@ -23,6 +23,7 @@ from .types import (
     NumpyArray,
     PilPNG,
     RobotPosition,
+    Destinations
 )
 from ..map_data import HyperMapData
 from .async_utils import AsyncNumPy
@@ -91,9 +92,9 @@ class BaseHandler:
     async def async_get_image(
         self,
         m_json: dict | None,
-        destinations: list | None = None,
+        destinations: Destinations | None = None,
         bytes_format: bool = False,
-    ) -> PilPNG | bytes:
+    ) -> Tuple[PilPNG | bytes, dict]:
         """
         Unified async function to get PIL image from JSON data for both Hypfer and Rand256 handlers.
 
@@ -108,7 +109,7 @@ class BaseHandler:
         @param bytes_format: If True, also convert to PNG bytes and store in shared.binary_image
         @param text_enabled: If True, draw text on the image
         @param vacuum_status: Vacuum status to display on the image
-        @return: PIL Image or None
+        @return: PIL Image or None and data dictionary
         """
         try:
             # Backup current image to last_image before processing new one
@@ -122,6 +123,7 @@ class BaseHandler:
                     m_json=m_json,
                     destinations=destinations,
                 )
+
             elif hasattr(self, "async_get_image_from_json"):
                 # This is a Hypfer handler
                 self.json_data = await HyperMapData.async_from_valetudo_json(m_json)
@@ -141,7 +143,10 @@ class BaseHandler:
 
             # 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)
@@ -160,18 +165,22 @@ class BaseHandler:
                     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())
-                return new_image
+                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 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:
             LOGGER.warning(
@@ -184,6 +193,41 @@ class BaseHandler:
                 self.shared.last_image if hasattr(self.shared, "last_image") else None
             )
 
+    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
+        ):
+            (
+                self.shared.map_rooms,
+                self.shared.map_pred_zones,
+                self.shared.map_pred_points,
+            ) = 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:
+                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)
+
+        if hasattr(self, "get_calibration_data") and self.shared.attr_calibration_points is None:
+            self.shared.attr_calibration_points = self.get_calibration_data(self.shared.image_rotate)
+
+        if not self.shared.image_size:
+            self.shared.image_size = self.get_img_size()
+
+        self.shared.vac_json_id = self.get_json_id()
+
+        if not self.shared.charger_position:
+            self.shared.charger_position = self.get_charger_position()
+
+        self.shared.current_room = self.get_robot_position()
+
     def prepare_resize_params(self, pil_img: PilPNG, rand: bool=False) -> ResizeParams:
         """Prepare resize parameters for image resizing."""
         if self.shared.image_rotate in [0, 180]:

{valetudo_map_parser-0.1.10rc5 → valetudo_map_parser-0.1.10rc6}/SCR/valetudo_map_parser/hypfer_handler.py

@@ -409,11 +409,10 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
             )
         return self.room_propriety
 
-    def get_calibration_data(self) -> CalibrationPoints:
+    def get_calibration_data(self, rotation_angle: int = 0) -> CalibrationPoints:
         """Get the calibration data from the JSON data.
         this will create the attribute calibration points."""
         calibration_data = []
-        rotation_angle = self.shared.image_rotate
         LOGGER.info("Getting %s Calibrations points.", self.file_name)
 
         # Define the map points (fixed)

{valetudo_map_parser-0.1.10rc5 → valetudo_map_parser-0.1.10rc6}/SCR/valetudo_map_parser/map_data.py

@@ -709,7 +709,7 @@ class HyperMapData:
     """Class to handle the map data snapshots."""
 
     json_data: Any = None
-    json_id: str = "" or None
+    json_id: Optional[str] = None
     obstacles: dict[str, list[Any]] = field(default_factory=dict)
     paths: dict[str, list[Any]] = field(default_factory=dict)
     image_size: dict[str, int | list[int]] = field(default_factory=dict)

{valetudo_map_parser-0.1.10rc5 → valetudo_map_parser-0.1.10rc6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "valetudo-map-parser"
-version = "0.1.10rc5"
+version = "0.1.10rc6"
 description = "A Python library to parse Valetudo map data returning a PIL Image object."
 authors = ["Sandro Cantarella <gsca075@gmail.com>"]
 license = "Apache-2.0"