valetudo-map-parser 0.1.9b67__tar.gz → 0.1.9b68__tar.gz

{valetudo_map_parser-0.1.9b67 → valetudo_map_parser-0.1.9b68}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: valetudo-map-parser
-Version: 0.1.9b67
+Version: 0.1.9b68
 Summary: A Python library to parse Valetudo map data returning a PIL Image object.
 License: Apache-2.0
 Author: Sandro Cantarella

{valetudo_map_parser-0.1.9b67 → valetudo_map_parser-0.1.9b68}/SCR/valetudo_map_parser/config/drawable.py

@@ -14,7 +14,6 @@ import logging
 import math
 import asyncio
 import inspect
-import threading
 
 import numpy as np
 from PIL import ImageDraw, ImageFont
@@ -27,72 +26,6 @@ from .types import Color, NumpyArray, PilPNG, Point, Tuple, Union
 _LOGGER = logging.getLogger(__name__)
 
 
-class ImageArrayPool:
-    """Thread-safe memory pool for reusing image arrays to reduce allocation overhead."""
-
-    def __init__(self, max_arrays_per_size: int = 3):
-        self._pools = {}  # {(width, height): [array1, array2, ...]}
-        self._lock = threading.Lock()
-        self._max_arrays_per_size = max_arrays_per_size
-
-    def get_array(self, width: int, height: int, background_color: Color) -> NumpyArray:
-        """Get a reusable array or create a new one if none available."""
-        key = (width, height)
-
-        with self._lock:
-            if key in self._pools and self._pools[key]:
-                # Reuse existing array
-                array = self._pools[key].pop()
-                _LOGGER.debug("Reused array from pool for size %dx%d", width, height)
-            else:
-                # Create new array
-                array = np.empty((height, width, 4), dtype=np.uint8)
-                _LOGGER.debug("Created new array for size %dx%d", width, height)
-
-        # Fill with background color (outside lock for better performance)
-        array[:] = background_color
-        return array
-
-    def return_array(self, array: NumpyArray) -> None:
-        """Return an array to the pool for reuse."""
-        if array is None:
-            return
-
-        height, width = array.shape[:2]
-        key = (width, height)
-
-        with self._lock:
-            if key not in self._pools:
-                self._pools[key] = []
-
-            # Only keep up to max_arrays_per_size arrays per size
-            if len(self._pools[key]) < self._max_arrays_per_size:
-                self._pools[key].append(array)
-                _LOGGER.debug("Returned array to pool for size %dx%d (pool size: %d)",
-                             width, height, len(self._pools[key]))
-            else:
-                _LOGGER.debug("Pool full for size %dx%d, discarding array", width, height)
-
-    def clear_pool(self) -> None:
-        """Clear all arrays from the pool."""
-        with self._lock:
-            total_arrays = sum(len(arrays) for arrays in self._pools.values())
-            self._pools.clear()
-            _LOGGER.debug("Cleared image array pool (%d arrays freed)", total_arrays)
-
-    def get_pool_stats(self) -> dict:
-        """Get statistics about the current pool state."""
-        with self._lock:
-            stats = {}
-            for (width, height), arrays in self._pools.items():
-                stats[f"{width}x{height}"] = len(arrays)
-            return stats
-
-
-# Global shared pool instance for both Hypfer and Rand256 handlers
-_image_pool = ImageArrayPool()
-
-
 class Drawable:
     """
     Collection of drawing utility functions for the image handlers.
@@ -112,27 +45,13 @@ class Drawable:
     async def create_empty_image(
         width: int, height: int, background_color: Color
     ) -> NumpyArray:
-        """Create the empty background image NumPy array using memory pool for better performance.
+        """Create the empty background image NumPy array.
         Background color is specified as an RGBA tuple.
-        Optimized: Uses shared memory pool to reuse arrays and reduce allocation overhead."""
-        # Get array from shared pool (reuses memory when possible)
-        return _image_pool.get_array(width, height, background_color)
-
-    @staticmethod
-    def return_image_to_pool(image_array: NumpyArray) -> None:
-        """Return an image array to the memory pool for reuse.
-        Call this when you're done with an image array to enable memory reuse."""
-        _image_pool.return_array(image_array)
-
-    @staticmethod
-    def get_pool_stats() -> dict:
-        """Get statistics about the current memory pool state."""
-        return _image_pool.get_pool_stats()
-
-    @staticmethod
-    def clear_image_pool() -> None:
-        """Clear all arrays from the memory pool."""
-        _image_pool.clear_pool()
+        Optimized: Uses np.empty + broadcast instead of np.full for better performance."""
+        # Use np.empty + broadcast instead of np.full (avoids double initialization)
+        img_array = np.empty((height, width, 4), dtype=np.uint8)
+        img_array[:] = background_color  # Broadcast color to all pixels efficiently
+        return img_array
 
     @staticmethod
     async def from_json_to_image(

{valetudo_map_parser-0.1.9b67 → valetudo_map_parser-0.1.9b68}/SCR/valetudo_map_parser/config/shared.py

@@ -39,6 +39,7 @@ from .types import (
     CameraModes,
     Colors,
     TrimsData,
+    PilPNG,
 )
 
 
@@ -58,9 +59,10 @@ class CameraShared:
         self.rand256_active_zone: list = []  # Active zone for rand256
         self.is_rand: bool = False  # MQTT rand data
         self._new_mqtt_message = False  # New MQTT message
-        self.last_image = None  # Last image received
-        self.current_image = None  # Current image
-        self.binary_image = None  # Current image in binary format
+        self.last_image = PilPNG | None  # Last image received
+        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.image_auto_zoom: bool = False  # Auto zoom image
@@ -115,7 +117,7 @@ class CameraShared:
 
 
 
-    def _state_charging(self) -> bool:
+    def vacuum_bat_charged(self) -> bool:
         """Check if the vacuum is charging."""
         return (self.vacuum_state == "docked") and (int(self.vacuum_battery) < 100)
 
@@ -193,7 +195,7 @@ class CameraShared:
         attrs = {
             ATTR_CAMERA_MODE: self.camera_mode,
             ATTR_VACUUM_BATTERY: f"{self.vacuum_battery}%",
-            ATTR_VACUUM_CHARGING: self._state_charging(),
+            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,
@@ -228,12 +230,13 @@ class CameraShared:
 class CameraSharedManager:
     """Camera Shared Manager class."""
 
-    def __init__(self, file_name, device_info):
+    def __init__(self, file_name: str, device_info: dict = None):
         self._instances = {}
         self._lock = asyncio.Lock()
         self.file_name = file_name
-        self.device_info = device_info
-        self.update_shared_data(device_info)
+        if device_info:
+            self.device_info = device_info
+            self.update_shared_data(device_info)
 
         # Automatically initialize shared data for the instance
         # self._init_shared_data(device_info)

{valetudo_map_parser-0.1.9b67 → valetudo_map_parser-0.1.9b68}/SCR/valetudo_map_parser/config/utils.py

@@ -1,5 +1,6 @@
 """Utility code for the valetudo map parser."""
 
+import datetime
 import hashlib
 import json
 from dataclasses import dataclass
@@ -79,6 +80,67 @@ class BaseHandler:
         """Return the robot position."""
         return self.robot_pos
 
+    async def async_get_pil_image(
+        self,
+        m_json: dict | None,
+        destinations: list | None = None,
+    ) -> PilPNG | None:
+        """
+        Unified async function to get PIL image from JSON data for both Hypfer and Rand256 handlers.
+
+        This function:
+        1. Calls the appropriate async_get_image_from_json method
+        2. Stores the processed data in shared.new_image
+        3. Backs up previous data to shared.last_image
+        4. Updates shared.image_last_updated with current datetime
+
+        @param m_json: The JSON data to use to draw the image
+        @param destinations: MQTT destinations for labels (used by Rand256)
+        @return: PIL Image or None
+        """
+        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:
+                self.shared.last_image = self.shared.new_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,
+                    return_webp=False  # Always return PIL Image
+                )
+            elif hasattr(self, 'async_get_image_from_json'):
+                # This is a Hypfer handler
+                new_image = await self.async_get_image_from_json(
+                    m_json=m_json,
+                    return_webp=False  # Always return PIL Image
+                )
+            else:
+                LOGGER.warning("%s: Handler type not recognized for async_get_pil_image", self.file_name)
+                return None
+
+            # Store the new image in shared data
+            if new_image is not None:
+                self.shared.new_image = new_image
+                # Update the timestamp with current datetime
+                self.shared.image_last_updated = datetime.datetime.now().timestamp()
+                LOGGER.debug("%s: Image processed and stored in shared data", self.file_name)
+            else:
+                LOGGER.warning("%s: Failed to generate image from JSON data", self.file_name)
+
+            return new_image
+
+        except Exception as e:
+            LOGGER.error(
+                "%s: Error in async_get_pil_image: %s",
+                self.file_name,
+                str(e),
+                exc_info=True
+            )
+            return None
+
     def get_charger_position(self) -> ChargerPosition | None:
         """Return the charger position."""
         return self.charger_pos

{valetudo_map_parser-0.1.9b67 → valetudo_map_parser-0.1.9b68}/SCR/valetudo_map_parser/hypfer_handler.py

@@ -8,11 +8,10 @@ Version: 0.1.9
 from __future__ import annotations
 
 import asyncio
-import json
 
 from PIL import Image
 
-from .config.async_utils import AsyncNumPy, AsyncPIL, AsyncParallel
+from .config.async_utils import AsyncNumPy, AsyncPIL
 from .config.auto_crop import AutoCrop
 from .config.drawable_elements import DrawableElement
 from .config.shared import CameraShared
@@ -25,6 +24,7 @@ from .config.types import (
     RoomsProperties,
     RoomStore,
     WebPBytes,
+    JsonType,
 )
 from .config.utils import (
     BaseHandler,
@@ -100,7 +100,7 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
     # noinspection PyUnresolvedReferences,PyUnboundLocalVariable
     async def async_get_image_from_json(
         self,
-        m_json: json | None,
+        m_json: JsonType | None,
         return_webp: bool = False,
     ) -> WebPBytes | Image.Image | None:
         """Get the image from the JSON data.
@@ -232,13 +232,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                                 disabled_rooms if layer_type == "wall" else None,
                             )
 
-                            # Update element map for this layer
-                            if is_room_layer and 0 < room_id <= 15:
-                                # Mark the room in the element map
-                                room_element = getattr(
-                                    DrawableElement, f"ROOM_{room_id}", None
-                                )
-
                     # Draw the virtual walls if enabled
                     if self.drawing_config.is_enabled(DrawableElement.VIRTUAL_WALL):
                         img_np_array = await self.imd.async_draw_virtual_walls(
@@ -313,10 +306,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                     LOGGER.info("%s: Drawing path", self.file_name)
                     data_tasks.append(self._prepare_path_data(m_json))
 
-                # Execute data preparation in parallel if we have tasks
-                if data_tasks:
-                    prepared_data = await AsyncParallel.parallel_data_preparation(*data_tasks)
-
                 # Process drawing operations sequentially (since they modify the same array)
                 # Draw zones if enabled
                 if self.drawing_config.is_enabled(DrawableElement.RESTRICTED_AREA):
@@ -390,9 +379,7 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
             if self.check_zoom_and_aspect_ratio():
                 # Convert to PIL for resizing
                 pil_img = await AsyncPIL.async_fromarray(img_np_array, mode="RGBA")
-                # Return array to pool for reuse instead of just deleting
-                from .config.drawable import Drawable
-                Drawable.return_image_to_pool(img_np_array)
+                del img_np_array
                 resize_params = prepare_resize_params(self, pil_img, False)
                 resized_image = await self.async_resize_images(resize_params)
 
@@ -407,17 +394,13 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                 if return_webp:
                     # Convert directly from NumPy to WebP for better performance
                     webp_bytes = await numpy_to_webp_bytes(img_np_array)
-                    # Return array to pool for reuse instead of just deleting
-                    from .config.drawable import Drawable
-                    Drawable.return_image_to_pool(img_np_array)
+                    del img_np_array
                     LOGGER.debug("%s: Frame Completed.", self.file_name)
                     return webp_bytes
                 else:
                     # Convert to PIL Image (original behavior)
                     pil_img = await AsyncPIL.async_fromarray(img_np_array, mode="RGBA")
-                    # Return array to pool for reuse instead of just deleting
-                    from .config.drawable import Drawable
-                    Drawable.return_image_to_pool(img_np_array)
+                    del img_np_array
                     LOGGER.debug("%s: Frame Completed.", self.file_name)
                     return pil_img
         except (RuntimeError, RuntimeWarning) as e:
@@ -506,7 +489,8 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
         except (ValueError, KeyError):
             return None
 
-    async def _prepare_goto_data(self, entity_dict):
+    @staticmethod
+    async def _prepare_goto_data(entity_dict):
         """Prepare go-to flag data for parallel processing."""
         await asyncio.sleep(0)  # Yield control
         # Extract go-to target data from entity_dict
@@ -516,6 +500,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
         """Prepare path data for parallel processing."""
         await asyncio.sleep(0)  # Yield control
         try:
-            return self.data.find_path_entities(m_json)
+            return self.data.find_paths_entities(m_json)
         except (ValueError, KeyError):
             return None

{valetudo_map_parser-0.1.9b67 → valetudo_map_parser-0.1.9b68}/SCR/valetudo_map_parser/rand256_handler.py

@@ -7,15 +7,13 @@ Version: 0.1.9.a6
 
 from __future__ import annotations
 
-import asyncio
 import logging
 import uuid
 from typing import Any
 
 import numpy as np
-from PIL import Image
 
-from .config.async_utils import AsyncNumPy, AsyncPIL, AsyncParallel
+from .config.async_utils import AsyncNumPy, AsyncPIL
 from .config.auto_crop import AutoCrop
 from .config.drawable_elements import DrawableElement
 from .config.types import (
@@ -147,7 +145,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
         m_json: JsonType,  # json data
         destinations: None = None,  # MQTT destinations for labels
         return_webp: bool = False,
-    ) -> WebPBytes | Image.Image | None:
+    ) -> WebPBytes | PilPNG | None:
         """Generate Images from the json data.
         @param m_json: The JSON data to use to draw the image.
         @param destinations: MQTT destinations for labels (unused).
@@ -168,14 +166,6 @@ class ReImageHandler(BaseHandler, AutoCrop):
                 self.json_id = str(uuid.uuid4())  # image id
                 _LOGGER.info("Vacuum Data ID: %s", self.json_id)
 
-                # Prepare parallel data extraction tasks
-                data_tasks = []
-                data_tasks.append(self._prepare_zone_data(m_json))
-                data_tasks.append(self._prepare_path_data(m_json))
-
-                # Execute data preparation tasks in parallel
-                zone_data, path_data = await asyncio.gather(*data_tasks, return_exceptions=True)
-
                 (
                     img_np_array,
                     robot_position,
@@ -202,16 +192,12 @@ class ReImageHandler(BaseHandler, AutoCrop):
                 if return_webp:
                     # Convert directly to WebP bytes for better performance
                     webp_bytes = await numpy_to_webp_bytes(img_np_array)
-                    # Return array to pool for reuse instead of just deleting
-                    from .config.drawable import Drawable
-                    Drawable.return_image_to_pool(img_np_array)
+                    del img_np_array  # free memory
                     return webp_bytes
                 else:
                     # Convert to PIL Image using async utilities
                     pil_img = await AsyncPIL.async_fromarray(img_np_array, mode="RGBA")
-                    # Return array to pool for reuse instead of just deleting
-                    from .config.drawable import Drawable
-                    Drawable.return_image_to_pool(img_np_array)
+                    del img_np_array  # free memory
                     return await self._finalize_image(pil_img)
 
         except (RuntimeError, RuntimeWarning) as e:
@@ -311,11 +297,6 @@ class ReImageHandler(BaseHandler, AutoCrop):
                     original_rooms_pos = self.rooms_pos
                     self.rooms_pos = temp_rooms_pos
 
-                    # Perform robot room detection to check active zones
-                    robot_room_result = await self.async_get_robot_in_room(
-                        robot_position[0], robot_position[1], robot_position_angle
-                    )
-
                     # Restore original rooms_pos
                     self.rooms_pos = original_rooms_pos
 
@@ -692,20 +673,4 @@ class ReImageHandler(BaseHandler, AutoCrop):
         """Copy the array using async utilities."""
         return await AsyncNumPy.async_copy(original_array)
 
-    async def _prepare_zone_data(self, m_json):
-        """Prepare zone data for parallel processing."""
-        await asyncio.sleep(0)  # Yield control
-        try:
-            return self.data.find_zone_entities(m_json)
-        except (ValueError, KeyError):
-            return None
-
-    async def _prepare_path_data(self, m_json):
-        """Prepare path data for parallel processing."""
-        await asyncio.sleep(0)  # Yield control
-        try:
-            return self.data.find_path_entities(m_json)
-        except (ValueError, KeyError):
-            return None
-
 

{valetudo_map_parser-0.1.9b67 → valetudo_map_parser-0.1.9b68}/pyproject.toml

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