valetudo-map-parser 0.1.7__tar.gz → 0.1.9a0__tar.gz

valetudo_map_parser-0.1.9a0/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.3
+Name: valetudo-map-parser
+Version: 0.1.9a0
+Summary: A Python library to parse Valetudo map data returning a PIL Image object.
+License: Apache-2.0
+Author: Sandro Cantarella
+Author-email: gsca075@gmail.com
+Requires-Python: >=3.12
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: Pillow (>=10.3.0)
+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
+Project-URL: Changelog, https://github.com/sca075/Python-package-valetudo-map-parser/releases
+Project-URL: Homepage, https://github.com/sca075/Python-package-valetudo-map-parser
+Project-URL: Repository, https://github.com/sca075/Python-package-valetudo-map-parser
+Description-Content-Type: text/markdown
+
+# Python-package-valetudo-map-parser
+
+---
+### What is it:
+❗This is an _unofficial_ project and is not created, maintained, or in any sense linked to [valetudo.cloud](https://valetudo.cloud)
+
+A Python library that converts Valetudo vacuum JSON map data into PIL (Python Imaging Library) images. This package is primarily developed for and used in the [MQTT Vacuum Camera](https://github.com/sca075/mqtt_vacuum_camera) project.
+
+---
+
+### Features:
+- Processes map data from Valetudo-compatible robot vacuums
+- Supports both Hypfer and Rand256 vacuum data formats
+- Renders comprehensive map visualizations including:
+  - Walls and obstacles
+  - Robot position and cleaning path
+  - Room segments and boundaries
+  - Cleaning zones
+  - Virtual restrictions
+  - LiDAR data
+- Provides auto-cropping and dynamic zooming
+- Supports image rotation and aspect ratio management
+- Enables custom color schemes
+- Handles multilingual labels
+- Implements thread-safe data sharing
+
+### Installation:
+```bash
+pip install valetudo_map_parser
+```
+
+### Requirements:
+- Python 3.12 or higher
+- Dependencies:
+  - Pillow (PIL) for image processing
+  - NumPy for array operations
+
+### Usage:
+The library is configured using a dictionary format. See our [sample code](https://github.com/sca075/Python-package-valetudo-map-parser/blob/main/tests/test.py) for implementation examples.
+
+Key functionalities:
+- Decodes raw data from Rand256 format
+- Processes JSON data from compatible vacuums
+- Returns Pillow PNG images
+- Provides calibration and room property extraction
+- Supports asynchronous operations
+
+### Development Status:
+Current version: 0.1.9.b41
+- Full functionality available in versions >= 0.1.9
+- Actively maintained and enhanced
+- Uses Poetry for dependency management
+- Implements comprehensive testing
+- Enforces code quality through ruff, isort, and pylint
+
+### Contributing:
+Contributions are welcome! You can help by:
+- Submitting code improvements
+- Enhancing documentation
+- Reporting issues
+- Suggesting new features
+
+### Disclaimer:
+This project is provided "as is" without warranty of any kind. Users assume all risks associated with its use.
+
+### License:
+Apache-2.0
+
+---
+For more information about Valetudo, visit [valetudo.cloud](https://valetudo.cloud)
+Integration with Home Assistant: [MQTT Vacuum Camera](https://github.com/sca075/mqtt_vacuum_camera)
+

valetudo_map_parser-0.1.9a0/README.md

@@ -0,0 +1,71 @@
+# Python-package-valetudo-map-parser
+
+---
+### What is it:
+❗This is an _unofficial_ project and is not created, maintained, or in any sense linked to [valetudo.cloud](https://valetudo.cloud)
+
+A Python library that converts Valetudo vacuum JSON map data into PIL (Python Imaging Library) images. This package is primarily developed for and used in the [MQTT Vacuum Camera](https://github.com/sca075/mqtt_vacuum_camera) project.
+
+---
+
+### Features:
+- Processes map data from Valetudo-compatible robot vacuums
+- Supports both Hypfer and Rand256 vacuum data formats
+- Renders comprehensive map visualizations including:
+  - Walls and obstacles
+  - Robot position and cleaning path
+  - Room segments and boundaries
+  - Cleaning zones
+  - Virtual restrictions
+  - LiDAR data
+- Provides auto-cropping and dynamic zooming
+- Supports image rotation and aspect ratio management
+- Enables custom color schemes
+- Handles multilingual labels
+- Implements thread-safe data sharing
+
+### Installation:
+```bash
+pip install valetudo_map_parser
+```
+
+### Requirements:
+- Python 3.12 or higher
+- Dependencies:
+  - Pillow (PIL) for image processing
+  - NumPy for array operations
+
+### Usage:
+The library is configured using a dictionary format. See our [sample code](https://github.com/sca075/Python-package-valetudo-map-parser/blob/main/tests/test.py) for implementation examples.
+
+Key functionalities:
+- Decodes raw data from Rand256 format
+- Processes JSON data from compatible vacuums
+- Returns Pillow PNG images
+- Provides calibration and room property extraction
+- Supports asynchronous operations
+
+### Development Status:
+Current version: 0.1.9.b41
+- Full functionality available in versions >= 0.1.9
+- Actively maintained and enhanced
+- Uses Poetry for dependency management
+- Implements comprehensive testing
+- Enforces code quality through ruff, isort, and pylint
+
+### Contributing:
+Contributions are welcome! You can help by:
+- Submitting code improvements
+- Enhancing documentation
+- Reporting issues
+- Suggesting new features
+
+### Disclaimer:
+This project is provided "as is" without warranty of any kind. Users assume all risks associated with its use.
+
+### License:
+Apache-2.0
+
+---
+For more information about Valetudo, visit [valetudo.cloud](https://valetudo.cloud)
+Integration with Home Assistant: [MQTT Vacuum Camera](https://github.com/sca075/mqtt_vacuum_camera)

valetudo_map_parser-0.1.9a0/SCR/valetudo_map_parser/__init__.py

@@ -0,0 +1,50 @@
+"""Valetudo map parser.
+Version: 0.1.9"""
+
+from .config.colors import ColorsManagement
+from .config.drawable import Drawable
+from .config.drawable_elements import DrawableElement, DrawingConfig
+from .config.enhanced_drawable import EnhancedDrawable
+from .config.rand256_parser import RRMapParser
+from .config.shared import CameraShared, CameraSharedManager
+from .config.types import (
+    CameraModes,
+    RoomsProperties,
+    RoomStore,
+    SnapshotStore,
+    TrimCropData,
+    UserLanguageStore,
+    JsonType,
+    PilPNG,
+    NumpyArray,
+    ImageSize,
+)
+from .hypfer_handler import HypferMapImageHandler
+from .rand256_handler import ReImageHandler
+from .rooms_handler import RoomsHandler, RandRoomsHandler
+
+
+__all__ = [
+    "RoomsHandler",
+    "RandRoomsHandler",
+    "HypferMapImageHandler",
+    "ReImageHandler",
+    "RRMapParser",
+    "CameraShared",
+    "CameraSharedManager",
+    "ColorsManagement",
+    "Drawable",
+    "DrawableElement",
+    "DrawingConfig",
+    "EnhancedDrawable",
+    "SnapshotStore",
+    "UserLanguageStore",
+    "RoomStore",
+    "RoomsProperties",
+    "TrimCropData",
+    "CameraModes",
+    "JsonType",
+    "PilPNG",
+    "NumpyArray",
+    "ImageSize",
+]

valetudo_map_parser-0.1.9a0/SCR/valetudo_map_parser/config/async_utils.py

@@ -0,0 +1,93 @@
+"""Async utility functions for making NumPy and PIL operations truly async."""
+
+import asyncio
+import io
+from typing import Any, Callable
+
+import numpy as np
+from numpy import rot90
+from PIL import Image
+
+
+async def make_async(func: Callable, *args, **kwargs) -> Any:
+    """Convert a synchronous function to async by yielding control to the event loop."""
+    return await asyncio.to_thread(func, *args, **kwargs)
+
+
+class AsyncNumPy:
+    """Async wrappers for NumPy operations that yield control to the event loop."""
+
+    @staticmethod
+    async def async_copy(array: np.ndarray) -> np.ndarray:
+        """Async array copying."""
+        return await make_async(np.copy, array)
+
+    @staticmethod
+    async def async_full(
+        shape: tuple, fill_value: Any, dtype: np.dtype = None
+    ) -> np.ndarray:
+        """Async array creation with fill value."""
+        return await make_async(np.full, shape, fill_value, dtype=dtype)
+
+    @staticmethod
+    async def async_rot90(array: np.ndarray, k: int = 1) -> np.ndarray:
+        """Async array rotation."""
+        return await make_async(rot90, array, k)
+
+
+class AsyncPIL:
+    """Async wrappers for PIL operations that yield control to the event loop."""
+
+    @staticmethod
+    async def async_fromarray(array: np.ndarray, mode: str = "RGBA") -> Image.Image:
+        """Async PIL Image creation from NumPy array."""
+        return await make_async(Image.fromarray, array, mode)
+
+    @staticmethod
+    async def async_resize(
+        image: Image.Image, size: tuple, resample: int = None
+    ) -> Image.Image:
+        """Async image resizing."""
+        if resample is None:
+            resample = Image.LANCZOS
+        return await make_async(image.resize, size, resample)
+
+    @staticmethod
+    async def async_save_to_bytes(
+        image: Image.Image, format_type: str = "WEBP", **kwargs
+    ) -> bytes:
+        """Async image saving to bytes."""
+
+        def save_to_bytes():
+            buffer = io.BytesIO()
+            image.save(buffer, format=format_type, **kwargs)
+            return buffer.getvalue()
+
+        return await make_async(save_to_bytes)
+
+
+class AsyncParallel:
+    """Helper functions for parallel processing with asyncio.gather()."""
+
+    @staticmethod
+    async def parallel_data_preparation(*tasks):
+        """Execute multiple data preparation tasks in parallel."""
+        return await asyncio.gather(*tasks, return_exceptions=True)
+
+    @staticmethod
+    async def parallel_array_operations(base_array: np.ndarray, operations: list):
+        """Execute multiple array operations in parallel on copies of the base array."""
+
+        # Create tasks for parallel execution
+        tasks = []
+        for operation_func, *args in operations:
+            # Each operation works on a copy of the base array
+            array_copy = await AsyncNumPy.async_copy(base_array)
+            tasks.append(operation_func(array_copy, *args))
+
+        # Execute all operations in parallel
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+
+        # Filter out exceptions and return successful results
+        successful_results = [r for r in results if not isinstance(r, Exception)]
+        return successful_results