valetudo-map-parser 0.1.9b67__py3-none-any.whl → 0.1.9b68__py3-none-any.whl

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/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/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/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/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.dist-info → valetudo_map_parser-0.1.9b68.dist-info}/METADATA

@@ -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.dist-info → valetudo_map_parser-0.1.9b68.dist-info}/RECORD

@@ -4,24 +4,24 @@ valetudo_map_parser/config/async_utils.py,sha256=r96x4rVis2y57KSnWfVxraSGi0cOz0f
 valetudo_map_parser/config/auto_crop.py,sha256=Aes7vfv4z8ihYvGaH5Nryj6Y9mHDerZLIeyvePjf9aQ,19259
 valetudo_map_parser/config/color_utils.py,sha256=nXD6WeNmdFdoMxPDW-JFpjnxJSaZR1jX-ouNfrx6zvE,4502
 valetudo_map_parser/config/colors.py,sha256=DG-oPQoN5gsnwDbEsuFr8a0hRCxmbFHObWa4_5pr-70,29910
-valetudo_map_parser/config/drawable.py,sha256=d9hdEjmlXnbnEKgy2RiKVGiUlU8pbWF14MfNlVpDgcw,40947
+valetudo_map_parser/config/drawable.py,sha256=UpmXlCqZX_D7rqepk8IzTrzflgweLQ7n05ZeGIFRur8,37850
 valetudo_map_parser/config/drawable_elements.py,sha256=o-5oiXmfqPwNQLzKIhkEcZD_A47rIU9E0CqKgWipxgc,11516
 valetudo_map_parser/config/enhanced_drawable.py,sha256=QlGxlUMVgECUXPtFwIslyjubWxQuhIixsRymWV3lEvk,12586
 valetudo_map_parser/config/optimized_element_map.py,sha256=52BCnkvVv9bre52LeVIfT8nhnEIpc0TuWTv1xcNu0Rk,15744
 valetudo_map_parser/config/rand256_parser.py,sha256=LU3y7XvRRQxVen9iwom0dOaDnJJvhZdg97NqOYRZFas,16279
-valetudo_map_parser/config/shared.py,sha256=J_66BuhgqRJUjXKBwKh8qih1iyiTq9ZiaZwduIROYmE,12560
+valetudo_map_parser/config/shared.py,sha256=AQ73878TGCxbHQhgrAxSROLqFE-Zz4fJhTdoi9gBvJo,12736
 valetudo_map_parser/config/types.py,sha256=saL7pULKAdTRQ_ShR2arT8IV472e9MBC_SohTthlGp8,17567
-valetudo_map_parser/config/utils.py,sha256=fnzzNywE0Z1qw968hUa_yGslq3YhOP7daFj21miuhjI,31354
+valetudo_map_parser/config/utils.py,sha256=MR1UIOwHWYJ8lFrPYhfyi9IV7C08S-DqCyIPppsB2tM,33913
 valetudo_map_parser/hypfer_draw.py,sha256=ZK_WybvukHd8nNk2mq5icrOu1Ue3SVCIC6_Hc9bTg0Q,29396
-valetudo_map_parser/hypfer_handler.py,sha256=X-okVYDeHRWfwx08XIvqimoI-mghqekTe3GlyzV62gA,24214
+valetudo_map_parser/hypfer_handler.py,sha256=f9SCphArA-LO2ySrTKpxn6k4htM-JRrbrxKFh3AjnD8,23171
 valetudo_map_parser/hypfer_rooms_handler.py,sha256=NkpOA6Gdq-2D3lLAxvtNuuWMvPXHxeMY2TO5RZLSHlU,22652
 valetudo_map_parser/map_data.py,sha256=Op0LTCakcTJ1Q0rxQhl6BpgSby_6nJenCQS2Y2FHtRk,17243
 valetudo_map_parser/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-valetudo_map_parser/rand256_handler.py,sha256=vrfoX7RM8NFhpbzrc2BSLEA8VGx4B_sXBG_uAZSO8W0,29216
+valetudo_map_parser/rand256_handler.py,sha256=6Qt-xFJ3PITQNSAJTaEo6jl6TdgFms7ay1rnk4vekgk,27653
 valetudo_map_parser/reimg_draw.py,sha256=1q8LkNTPHEA9Tsapc_JnVw51kpPYNhaBU-KmHkefCQY,12507
 valetudo_map_parser/rooms_handler.py,sha256=ovqQtAjauAqwUNPR0aX27P2zhheQmqfaFhDE3_AwYWk,17821
-valetudo_map_parser-0.1.9b67.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
-valetudo_map_parser-0.1.9b67.dist-info/METADATA,sha256=0ItPS5MJeqacL3gkVvxoL9T9jvRJi5o9rFmNwByD7cA,3353
-valetudo_map_parser-0.1.9b67.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
-valetudo_map_parser-0.1.9b67.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-valetudo_map_parser-0.1.9b67.dist-info/RECORD,,
+valetudo_map_parser-0.1.9b68.dist-info/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
+valetudo_map_parser-0.1.9b68.dist-info/METADATA,sha256=hBV8Inc5QpIw-TcGWC-sLqhRb60TlFq1OVkMmm1iBek,3353
+valetudo_map_parser-0.1.9b68.dist-info/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
+valetudo_map_parser-0.1.9b68.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+valetudo_map_parser-0.1.9b68.dist-info/RECORD,,