valetudo-map-parser 0.1.9b75__py3-none-any.whl → 0.1.10__py3-none-any.whl

valetudo_map_parser/rooms_handler.py

@@ -7,7 +7,6 @@ Version: 0.1.9
 
 from __future__ import annotations
 
-import time
 from typing import Any, Dict, List, Optional, Tuple
 
 import numpy as np
@@ -16,8 +15,7 @@ from scipy.spatial import ConvexHull
 
 from .config.drawable_elements import DrawableElement, DrawingConfig
 from .config.types import LOGGER, RoomsProperties
-
-from .map_data import RandImageData, ImageData
+from .map_data import RandImageData
 
 
 class RoomsHandler:
@@ -104,14 +102,11 @@ class RoomsHandler:
                         is_enabled = self.drawing_config.is_enabled(room_element)
                         if not is_enabled:
                             # Skip this room if it's disabled
-                            LOGGER.debug("Skipping disabled room %s", segment_id)
                             return None, None
             except (ValueError, TypeError):
                 # If segment_id is not a valid integer, we can't map it to a room element
                 # In this case, we'll include the room (fail open)
-                LOGGER.debug(
-                    "Could not convert segment_id %s to room element", segment_id
-                )
+                pass
 
         # Optimization: Create a smaller mask for just the room area
         if not pixels:
@@ -207,7 +202,6 @@ class RoomsHandler:
         Returns:
             Dictionary of room properties
         """
-        start_total = time.time()
         room_properties = {}
         pixel_size = json_data.get("pixelSize", 5)
         height = json_data["size"]["y"]
@@ -220,10 +214,6 @@ class RoomsHandler:
                 )
                 if room_id is not None and room_data is not None:
                     room_properties[room_id] = room_data
-
-        # Log timing information
-        total_time = time.time() - start_total
-        LOGGER.debug("Room extraction Total time: %.3fs", total_time)
         return room_properties
 
 
@@ -339,11 +329,11 @@ class RandRoomsHandler:
                         is_enabled = self.drawing_config.is_enabled(room_element)
                         if not is_enabled:
                             # Skip this room if it's disabled
-                            LOGGER.debug("Skipping disabled room %s", segment_id)
                             return None, None
             except (ValueError, TypeError):
                 # If segment_id is not a valid integer, we can't map it to a room element
                 # In this case, we'll include the room (fail open)
+                pass
                 LOGGER.debug(
                     "Could not convert segment_id %s to room element", segment_id
                 )
@@ -399,7 +389,6 @@ class RandRoomsHandler:
         Returns:
             Dictionary of room properties
         """
-        start_total = time.time()
         room_properties = {}
 
         # Get basic map information
@@ -467,8 +456,4 @@ class RandRoomsHandler:
 
                 room_properties[room_id] = room_data
 
-        # Log timing information
-        total_time = time.time() - start_total
-        LOGGER.debug("Room extraction Total time: %.3fs", total_time)
-
         return room_properties

{valetudo_map_parser-0.1.9b75.dist-info → valetudo_map_parser-0.1.10.dist-info}/METADATA

@@ -1,16 +1,19 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: valetudo-map-parser
-Version: 0.1.9b75
+Version: 0.1.10
 Summary: A Python library to parse Valetudo map data returning a PIL Image object.
 License: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE.txt
 Author: Sandro Cantarella
 Author-email: gsca075@gmail.com
-Requires-Python: >=3.12
+Requires-Python: >=3.13
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: Pillow (>=10.3.0)
+Requires-Dist: mvcrender (>=0.0.5)
 Requires-Dist: numpy (>=1.26.4)
 Requires-Dist: scipy (>=1.12.0)
 Project-URL: Bug Tracker, https://github.com/sca075/Python-package-valetudo-map-parser/issues

valetudo_map_parser-0.1.10.dist-info/RECORD

@@ -0,0 +1,34 @@
+valetudo_map_parser/__init__.py,sha256=l_O2iyvj49KkUtuW7lMIZJcEaV_6_-YFaVZkiVeSh9g,1743
+valetudo_map_parser/config/__init__.py,sha256=DQ9plV3ZF_K25Dp5ZQHPDoG-40dQoJNdNi-dfNeR3Zc,48
+valetudo_map_parser/config/async_utils.py,sha256=e1j9uTtg4dhPVWvB2_XgqaH4aeSjRAPz-puRMbGoOs8,3204
+valetudo_map_parser/config/auto_crop.py,sha256=oNb8oazitd0h5q3hUkCZXeF7KxDGK90QuugLe5VEZeo,18180
+valetudo_map_parser/config/color_utils.py,sha256=LBdXo_40Ff9llgsIzjxD7V-hP9NceZIvAaxhBpI_Fhw,4463
+valetudo_map_parser/config/colors.py,sha256=DMY5aHDS-alW2CZ2j8U7QVGHK_H8M0fBDX2OGuryirc,29914
+valetudo_map_parser/config/drawable.py,sha256=WuoDuiFwLkPLHBMZEGrsRQGACrOdmrUeWgLbi406PNE,31565
+valetudo_map_parser/config/drawable_elements.py,sha256=_iHdAuzbAoIOeT8JEZrvSu5fVojIdhAyH5ABUVi-x3Y,11496
+valetudo_map_parser/config/fonts/FiraSans.ttf,sha256=Pavz1Iv0WZ-Vz_2S-Z6kJqAU1TEfUqXrXsOvJl6XzZc,440984
+valetudo_map_parser/config/fonts/Inter-VF.ttf,sha256=zzy0OwNm4txt9g4RMrHJpMFXd_DNjlpT4MFRJAA-ntQ,804612
+valetudo_map_parser/config/fonts/Lato-Regular.ttf,sha256=6CVCrtgpP0n8g8Sq6lZrH2tPx6mrXaEeb7m8CXO1Mks,75152
+valetudo_map_parser/config/fonts/MPLUSRegular.ttf,sha256=IGdcNSRP4dDxQskbE3Ybuwz7T0flhCBuzwfhLMcPt9s,3380812
+valetudo_map_parser/config/fonts/NotoKufiArabic-VF.ttf,sha256=NaIy40eLx7d3ts0kuenp0GjWd-YN24J6DpSvX2L3vLA,433800
+valetudo_map_parser/config/fonts/NotoSansCJKhk-VF.ttf,sha256=xIXXLKCJzmWoPEg8HdvxeRgotMjjxF6l6ugGP-IWRJU,36135040
+valetudo_map_parser/config/fonts/NotoSansKhojki.ttf,sha256=XJWzSmpN-Ql6jTfTvFojP_JkCHOztQvixQc1_7hPWrc,107388
+valetudo_map_parser/config/optimized_element_map.py,sha256=52BCnkvVv9bre52LeVIfT8nhnEIpc0TuWTv1xcNu0Rk,15744
+valetudo_map_parser/config/rand256_parser.py,sha256=3ZoVu7Wj091prm80QTnJ06F2pcbXB0EMF948-BCt478,21505
+valetudo_map_parser/config/shared.py,sha256=1MN04rZAicZ4ZyKnpEYLkF-Yx5PjCzfvB0DoYdiMnok,11790
+valetudo_map_parser/config/status_text/status_text.py,sha256=29E8b3adl_Rr_BH8-J35ia2cOS716sPzVk_cezFiWQ4,4053
+valetudo_map_parser/config/status_text/translations.py,sha256=mmPbJkl_2A59w49wnesQf3ocXqwZxBsrqNX-yt5FSCQ,9132
+valetudo_map_parser/config/types.py,sha256=ospbcr6apPvDm91KWjiB4SoYVuU6z0OwEMX5cwczpBc,18134
+valetudo_map_parser/config/utils.py,sha256=vpHxapGPyYjWwzc23J4XTm6EgCzC2wq7icjqUuiEK4o,38369
+valetudo_map_parser/hypfer_draw.py,sha256=4zajujSOvtpRI_GMlmlioM3mDo19MvuOP861LhZmVlw,22495
+valetudo_map_parser/hypfer_handler.py,sha256=WTIM3UQaW2XXtnxbRF0M-yzSJtptYI6RW1MIYAdfvPg,19968
+valetudo_map_parser/map_data.py,sha256=1-kxE82o8BfaJojYrD0LXoUAgCNpD6d50yLGc4w7ZWc,27433
+valetudo_map_parser/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+valetudo_map_parser/rand256_handler.py,sha256=K5ygOilr1jri-amMpqybC_4Fp9x0pZr3PAVgG98rC_M,21495
+valetudo_map_parser/reimg_draw.py,sha256=Pwm_QUHiJd4o657qr-mlsWQ_TtGCBB-ucsA84t-IwOg,12474
+valetudo_map_parser/rooms_handler.py,sha256=vr_1LUZg11-z9dHo6fnWZTnTpguM4oNbtw6ZnxvKZ6Y,17175
+valetudo_map_parser-0.1.10.dist-info/METADATA,sha256=_FCSBZ7vNOkbxzhn42MkattttPLlNMshSxdWS98V58E,3401
+valetudo_map_parser-0.1.10.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+valetudo_map_parser-0.1.10.dist-info/licenses/LICENSE,sha256=Lh-qBbuRV0-jiCIBhfV7NgdwFxQFOXH3BKOzK865hRs,10480
+valetudo_map_parser-0.1.10.dist-info/licenses/NOTICE.txt,sha256=5lTOuWiU9aiEnJ2go8sc7lTJ7ntMBx0g0GFnNrswCY4,2533
+valetudo_map_parser-0.1.10.dist-info/RECORD,,

{valetudo_map_parser-0.1.9b75.dist-info → valetudo_map_parser-0.1.10.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.3
+Generator: poetry-core 2.2.1
 Root-Is-Purelib: true
 Tag: py3-none-any

valetudo_map_parser/config/enhanced_drawable.py

@@ -1,324 +0,0 @@
-"""
-Enhanced Drawable Class.
-Provides drawing utilities with element selection support.
-Version: 0.1.9
-"""
-
-from __future__ import annotations
-
-import logging
-
-# math is not used in this file
-from typing import Optional, Tuple
-
-import numpy as np
-
-from .colors import ColorsManagement
-from .drawable import Drawable
-from .drawable_elements import (
-    DrawableElement,
-    DrawingConfig,
-)
-
-
-# Type aliases
-NumpyArray = np.ndarray
-Color = Tuple[int, int, int, int]
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class EnhancedDrawable(Drawable):
-    """Enhanced drawing utilities with element selection support."""
-
-    def __init__(self, drawing_config: Optional[DrawingConfig] = None):
-        """Initialize with optional drawing configuration."""
-        super().__init__()
-        self.drawing_config = drawing_config or DrawingConfig()
-
-    # Color blending methods have been moved to ColorsManagement class in colors.py
-
-    # Pixel blending methods have been moved to ColorsManagement class in colors.py
-
-    async def draw_map(
-        self, map_data: dict, base_array: Optional[NumpyArray] = None
-    ) -> NumpyArray:
-        """
-        Draw the map with selected elements.
-
-        Args:
-            map_data: The map data dictionary
-            base_array: Optional base array to draw on
-
-        Returns:
-            The image array with all elements drawn
-        """
-        # Get map dimensions
-        size_x = map_data.get("size", {}).get("x", 1024)
-        size_y = map_data.get("size", {}).get("y", 1024)
-
-        # Create empty image if none provided
-        if base_array is None:
-            background_color = self.drawing_config.get_property(
-                DrawableElement.FLOOR, "color", (200, 200, 200, 255)
-            )
-            base_array = await self.create_empty_image(size_x, size_y, background_color)
-
-        # Draw elements in order of z-index
-        for element in self.drawing_config.get_drawing_order():
-            if element == DrawableElement.FLOOR:
-                base_array = await self._draw_floor(map_data, base_array)
-            elif element == DrawableElement.WALL:
-                base_array = await self._draw_walls(map_data, base_array)
-            elif element == DrawableElement.ROBOT:
-                base_array = await self._draw_robot(map_data, base_array)
-            elif element == DrawableElement.CHARGER:
-                base_array = await self._draw_charger(map_data, base_array)
-            elif element == DrawableElement.VIRTUAL_WALL:
-                base_array = await self._draw_virtual_walls(map_data, base_array)
-            elif element == DrawableElement.RESTRICTED_AREA:
-                base_array = await self._draw_restricted_areas(map_data, base_array)
-            elif element == DrawableElement.NO_MOP_AREA:
-                base_array = await self._draw_no_mop_areas(map_data, base_array)
-            elif element == DrawableElement.PATH:
-                base_array = await self._draw_path(map_data, base_array)
-            elif element == DrawableElement.PREDICTED_PATH:
-                base_array = await self._draw_predicted_path(map_data, base_array)
-            elif element == DrawableElement.GO_TO_TARGET:
-                base_array = await self._draw_go_to_target(map_data, base_array)
-            elif DrawableElement.ROOM_1 <= element <= DrawableElement.ROOM_15:
-                room_id = element - DrawableElement.ROOM_1 + 1
-                base_array = await self._draw_room(map_data, room_id, base_array)
-
-        return base_array
-
-    async def _draw_floor(self, map_data: dict, array: NumpyArray) -> NumpyArray:
-        """Draw the floor layer."""
-        if not self.drawing_config.is_enabled(DrawableElement.FLOOR):
-            return array
-
-        # Implementation depends on the map data format
-        # This is a placeholder - actual implementation would use map_data to draw floor
-
-        return array
-
-    async def _draw_walls(self, map_data: dict, array: NumpyArray) -> NumpyArray:
-        """Draw the walls."""
-        if not self.drawing_config.is_enabled(DrawableElement.WALL):
-            return array
-
-        # Get wall color from drawing config
-        wall_color = self.drawing_config.get_property(
-            DrawableElement.WALL, "color", (255, 255, 0, 255)
-        )
-
-        # Implementation depends on the map data format
-        # For Valetudo maps, we would look at the layers with type "wall"
-        # This is a simplified example - in a real implementation, we would extract the actual wall pixels
-
-        # Find wall data in map_data
-        wall_pixels = []
-        for layer in map_data.get("layers", []):
-            if layer.get("type") == "wall":
-                # Extract wall pixels from the layer
-                # This is a placeholder - actual implementation would depend on the map data format
-                wall_pixels = layer.get("pixels", [])
-                break
-
-        # Draw wall pixels with color blending
-        for x, y in wall_pixels:
-            # Use sample_and_blend_color from ColorsManagement
-            blended_color = ColorsManagement.sample_and_blend_color(
-                array, x, y, wall_color
-            )
-            if 0 <= y < array.shape[0] and 0 <= x < array.shape[1]:
-                array[y, x] = blended_color
-
-        return array
-
-    async def _draw_robot(self, map_data: dict, array: NumpyArray) -> NumpyArray:
-        """Draw the robot."""
-        if not self.drawing_config.is_enabled(DrawableElement.ROBOT):
-            return array
-
-        # Get robot color from drawing config
-        robot_color = self.drawing_config.get_property(
-            DrawableElement.ROBOT, "color", (255, 255, 204, 255)
-        )
-
-        # Extract robot position and angle from map_data
-        robot_position = map_data.get("robot", {}).get("position", None)
-        robot_angle = map_data.get("robot", {}).get("angle", 0)
-
-        if robot_position:
-            x, y = robot_position.get("x", 0), robot_position.get("y", 0)
-
-            # Draw robot with color blending
-            # Create a circle around the robot position
-            radius = 25  # Same as in the robot drawing method
-            for dy in range(-radius, radius + 1):
-                for dx in range(-radius, radius + 1):
-                    if dx * dx + dy * dy <= radius * radius:
-                        map_x, map_y = int(x + dx), int(y + dy)
-                        # Use sample_and_blend_color from ColorsManagement
-                        blended_color = ColorsManagement.sample_and_blend_color(
-                            array, map_x, map_y, robot_color
-                        )
-                        if 0 <= map_y < array.shape[0] and 0 <= map_x < array.shape[1]:
-                            array[map_y, map_x] = blended_color
-        return array
-
-    async def _draw_charger(self, map_data: dict, array: NumpyArray) -> NumpyArray:
-        """Draw the charger."""
-        if not self.drawing_config.is_enabled(DrawableElement.CHARGER):
-            return array
-
-        # Get charger color from drawing config
-        charger_color = self.drawing_config.get_property(
-            DrawableElement.CHARGER, "color", (255, 128, 0, 255)
-        )
-
-        # Implementation depends on the map data format
-        # This would extract charger data from map_data and draw it
-
-        return array
-
-    async def _draw_virtual_walls(
-        self, map_data: dict, array: NumpyArray
-    ) -> NumpyArray:
-        """Draw virtual walls."""
-        if not self.drawing_config.is_enabled(DrawableElement.VIRTUAL_WALL):
-            return array
-
-        # Get virtual wall color from drawing config
-        wall_color = self.drawing_config.get_property(
-            DrawableElement.VIRTUAL_WALL, "color", (255, 0, 0, 255)
-        )
-
-        # Implementation depends on the map data format
-        # This would extract virtual wall data from map_data and draw it
-
-        return array
-
-    async def _draw_restricted_areas(
-        self, map_data: dict, array: NumpyArray
-    ) -> NumpyArray:
-        """Draw restricted areas."""
-        if not self.drawing_config.is_enabled(DrawableElement.RESTRICTED_AREA):
-            return array
-
-        # Get restricted area color from drawing config
-        area_color = self.drawing_config.get_property(
-            DrawableElement.RESTRICTED_AREA, "color", (255, 0, 0, 125)
-        )
-
-        # Implementation depends on the map data format
-        # This would extract restricted area data from map_data and draw it
-
-        return array
-
-    async def _draw_no_mop_areas(self, map_data: dict, array: NumpyArray) -> NumpyArray:
-        """Draw no-mop areas."""
-        if not self.drawing_config.is_enabled(DrawableElement.NO_MOP_AREA):
-            return array
-
-        # Get no-mop area color from drawing config
-        area_color = self.drawing_config.get_property(
-            DrawableElement.NO_MOP_AREA, "color", (0, 0, 255, 125)
-        )
-
-        # Implementation depends on the map data format
-        # This would extract no-mop area data from map_data and draw it
-
-        return array
-
-    async def _draw_path(self, map_data: dict, array: NumpyArray) -> NumpyArray:
-        """Draw the robot's path."""
-        if not self.drawing_config.is_enabled(DrawableElement.PATH):
-            return array
-
-        # Get path color from drawing config
-        path_color = self.drawing_config.get_property(
-            DrawableElement.PATH, "color", (238, 247, 255, 255)
-        )
-
-        # Implementation depends on the map data format
-        # This would extract path data from map_data and draw it
-
-        return array
-
-    async def _draw_predicted_path(
-        self, map_data: dict, array: NumpyArray
-    ) -> NumpyArray:
-        """Draw the predicted path."""
-        if not self.drawing_config.is_enabled(DrawableElement.PREDICTED_PATH):
-            return array
-
-        # Get predicted path color from drawing config
-        path_color = self.drawing_config.get_property(
-            DrawableElement.PREDICTED_PATH, "color", (238, 247, 255, 125)
-        )
-
-        # Implementation depends on the map data format
-        # This would extract predicted path data from map_data and draw it
-
-        return array
-
-    async def _draw_go_to_target(self, map_data: dict, array: NumpyArray) -> NumpyArray:
-        """Draw the go-to target."""
-        if not self.drawing_config.is_enabled(DrawableElement.GO_TO_TARGET):
-            return array
-
-        # Get go-to target color from drawing config
-        target_color = self.drawing_config.get_property(
-            DrawableElement.GO_TO_TARGET, "color", (0, 255, 0, 255)
-        )
-
-        # Implementation depends on the map data format
-        # This would extract go-to target data from map_data and draw it
-
-        return array
-
-    async def _draw_room(
-        self, map_data: dict, room_id: int, array: NumpyArray
-    ) -> NumpyArray:
-        """Draw a specific room."""
-        element = getattr(DrawableElement, f"ROOM_{room_id}")
-        if not self.drawing_config.is_enabled(element):
-            return array
-
-        # Get room color from drawing config
-        room_color = self.drawing_config.get_property(
-            element,
-            "color",
-            (135, 206, 250, 255),  # Default light blue
-        )
-
-        # Implementation depends on the map data format
-        # For Valetudo maps, we would look at the layers with type "segment"
-        # This is a simplified example - in a real implementation, we would extract the actual room pixels
-
-        # Find room data in map_data
-        room_pixels = []
-        for layer in map_data.get("layers", []):
-            if layer.get("type") == "segment" and str(
-                layer.get("metaData", {}).get("segmentId")
-            ) == str(room_id):
-                # Extract room pixels from the layer
-                # This is a placeholder - actual implementation would depend on the map data format
-                # For example, it might use compressed pixels or other data structures
-
-                # For demonstration, let's assume we have a list of (x, y) coordinates
-                room_pixels = layer.get("pixels", [])
-                break
-
-        # Draw room pixels with color blending
-        for x, y in room_pixels:
-            # Use sample_and_blend_color from ColorsManagement
-            blended_color = ColorsManagement.sample_and_blend_color(
-                array, x, y, room_color
-            )
-            if 0 <= y < array.shape[0] and 0 <= x < array.shape[1]:
-                array[y, x] = blended_color
-
-        return array