valetudo-map-parser 0.1.10rc6__py3-none-any.whl → 0.1.11b0__py3-none-any.whl

valetudo_map_parser/config/rand256_parser.py

@@ -1,7 +1,8 @@
-"""New Rand256 Map Parser - Based on Xiaomi/Roborock implementation with precise binary parsing."""
+"""New Rand256 Map Parser -
+Based on Xiaomi/Roborock implementation with precise binary parsing."""
 
-import struct
 import math
+import struct
 from enum import Enum
 from typing import Any, Dict, List, Optional
 
@@ -24,6 +25,14 @@ class RRMapParser:
         VIRTUAL_WALLS = 10
         CURRENTLY_CLEANED_BLOCKS = 11
         FORBIDDEN_MOP_ZONES = 12
+        OBSTACLES = 13
+        IGNORED_OBSTACLES = 14
+        OBSTACLES_WITH_PHOTO = 15
+        IGNORED_OBSTACLES_WITH_PHOTO = 16
+        CARPET_MAP = 17
+        MOP_PATH = 18
+        NO_CARPET_AREAS = 19
+        DIGEST = 1024
 
     class Tools:
         """Tools for coordinate transformations."""
@@ -33,6 +42,7 @@ class RRMapParser:
 
     def __init__(self):
         """Initialize the parser."""
+        self.is_valid = False
         self.map_data: Dict[str, Any] = {}
 
     # Xiaomi/Roborock style byte extraction methods
@@ -67,6 +77,64 @@ class RRMapParser:
         value = RRMapParser._get_int32(data, address)
         return value if value < 0x80000000 else value - 0x100000000
 
+    @staticmethod
+    def _parse_carpet_map(data: bytes) -> set[int]:
+        """Parse carpet map using Xiaomi method."""
+        carpet_map = set()
+
+        for i, v in enumerate(data):
+            if v:
+                carpet_map.add(i)
+        return carpet_map
+
+    @staticmethod
+    def _parse_area(header: bytes, data: bytes) -> list:
+        """Parse area using Xiaomi method."""
+        area_pairs = RRMapParser._get_int16(header, 0x08)
+        areas = []
+        for area_start in range(0, area_pairs * 16, 16):
+            x0 = RRMapParser._get_int16(data, area_start + 0)
+            y0 = RRMapParser._get_int16(data, area_start + 2)
+            x1 = RRMapParser._get_int16(data, area_start + 4)
+            y1 = RRMapParser._get_int16(data, area_start + 6)
+            x2 = RRMapParser._get_int16(data, area_start + 8)
+            y2 = RRMapParser._get_int16(data, area_start + 10)
+            x3 = RRMapParser._get_int16(data, area_start + 12)
+            y3 = RRMapParser._get_int16(data, area_start + 14)
+            areas.append(
+                [
+                    x0,
+                    RRMapParser.Tools.DIMENSION_MM - y0,
+                    x1,
+                    RRMapParser.Tools.DIMENSION_MM - y1,
+                    x2,
+                    RRMapParser.Tools.DIMENSION_MM - y2,
+                    x3,
+                    RRMapParser.Tools.DIMENSION_MM - y3,
+                ]
+            )
+        return areas
+
+    @staticmethod
+    def _parse_zones(data: bytes, header: bytes) -> list:
+        """Parse zones using Xiaomi method."""
+        zone_pairs = RRMapParser._get_int16(header, 0x08)
+        zones = []
+        for zone_start in range(0, zone_pairs * 8, 8):
+            x0 = RRMapParser._get_int16(data, zone_start + 0)
+            y0 = RRMapParser._get_int16(data, zone_start + 2)
+            x1 = RRMapParser._get_int16(data, zone_start + 4)
+            y1 = RRMapParser._get_int16(data, zone_start + 6)
+            zones.append(
+                [
+                    x0,
+                    RRMapParser.Tools.DIMENSION_MM - y0,
+                    x1,
+                    RRMapParser.Tools.DIMENSION_MM - y1,
+                ]
+            )
+        return zones
+
     @staticmethod
     def _parse_object_position(block_data_length: int, data: bytes) -> Dict[str, Any]:
         """Parse object position using Xiaomi method."""
@@ -82,6 +150,26 @@ class RRMapParser:
                 angle = raw_angle
         return {"position": [x, y], "angle": angle}
 
+    @staticmethod
+    def _parse_walls(data: bytes, header: bytes) -> list:
+        """Parse walls using Xiaomi method."""
+        wall_pairs = RRMapParser._get_int16(header, 0x08)
+        walls = []
+        for wall_start in range(0, wall_pairs * 8, 8):
+            x0 = RRMapParser._get_int16(data, wall_start + 0)
+            y0 = RRMapParser._get_int16(data, wall_start + 2)
+            x1 = RRMapParser._get_int16(data, wall_start + 4)
+            y1 = RRMapParser._get_int16(data, wall_start + 6)
+            walls.append(
+                [
+                    x0,
+                    RRMapParser.Tools.DIMENSION_MM - y0,
+                    x1,
+                    RRMapParser.Tools.DIMENSION_MM - y1,
+                ]
+            )
+        return walls
+
     @staticmethod
     def _parse_path_block(buf: bytes, offset: int, length: int) -> Dict[str, Any]:
         """Parse path block using EXACT same method as working parser."""
@@ -131,55 +219,66 @@ class RRMapParser:
         blocks = {}
         map_header_length = self._get_int16(raw, 0x02)
         block_start_position = map_header_length
-
         while block_start_position < len(raw):
             try:
-                # Parse block header using Xiaomi method
                 block_header_length = self._get_int16(raw, block_start_position + 0x02)
                 header = self._get_bytes(raw, block_start_position, block_header_length)
                 block_type = self._get_int16(header, 0x00)
                 block_data_length = self._get_int32(header, 0x04)
                 block_data_start = block_start_position + block_header_length
                 data = self._get_bytes(raw, block_data_start, block_data_length)
+                match block_type:
+                    case self.Types.DIGEST.value:
+                        self.is_valid = True
+                    case (
+                        self.Types.ROBOT_POSITION.value
+                        | self.Types.CHARGER_LOCATION.value
+                    ):
+                        blocks[block_type] = self._parse_object_position(
+                            block_data_length, data
+                        )
+                    case self.Types.PATH.value | self.Types.GOTO_PREDICTED_PATH.value:
+                        blocks[block_type] = self._parse_path_block(
+                            raw, block_start_position, block_data_length
+                        )
+                    case self.Types.CURRENTLY_CLEANED_ZONES.value:
+                        blocks[block_type] = {"zones": self._parse_zones(data, header)}
+                    case self.Types.FORBIDDEN_ZONES.value:
+                        blocks[block_type] = {
+                            "forbidden_zones": self._parse_area(header, data)
+                        }
+                    case self.Types.FORBIDDEN_MOP_ZONES.value:
+                        blocks[block_type] = {
+                            "forbidden_mop_zones": self._parse_area(header, data)
+                        }
+                    case self.Types.GOTO_TARGET.value:
+                        blocks[block_type] = {"position": self._parse_goto_target(data)}
+                    case self.Types.VIRTUAL_WALLS.value:
+                        blocks[block_type] = {
+                            "virtual_walls": self._parse_walls(data, header)
+                        }
+                    case self.Types.CARPET_MAP.value:
+                        data = RRMapParser._get_bytes(
+                            raw, block_data_start, block_data_length
+                        )
+                        blocks[block_type] = {
+                            "carpet_map": self._parse_carpet_map(data)
+                        }
+                    case self.Types.IMAGE.value:
+                        header_length = self._get_int8(header, 2)
+                        blocks[block_type] = self._parse_image_block(
+                            raw,
+                            block_start_position,
+                            block_data_length,
+                            header_length,
+                            pixels,
+                        )
 
-                # Parse different block types
-                if block_type == self.Types.ROBOT_POSITION.value:
-                    blocks[block_type] = self._parse_object_position(
-                        block_data_length, data
-                    )
-                elif block_type == self.Types.CHARGER_LOCATION.value:
-                    blocks[block_type] = self._parse_object_position(
-                        block_data_length, data
-                    )
-                elif block_type == self.Types.PATH.value:
-                    blocks[block_type] = self._parse_path_block(
-                        raw, block_start_position, block_data_length
-                    )
-                elif block_type == self.Types.GOTO_PREDICTED_PATH.value:
-                    blocks[block_type] = self._parse_path_block(
-                        raw, block_start_position, block_data_length
-                    )
-                elif block_type == self.Types.GOTO_TARGET.value:
-                    blocks[block_type] = {"position": self._parse_goto_target(data)}
-                elif block_type == self.Types.IMAGE.value:
-                    # Get header length for Gen1/Gen3 detection
-                    header_length = self._get_int8(header, 2)
-                    blocks[block_type] = self._parse_image_block(
-                        raw,
-                        block_start_position,
-                        block_data_length,
-                        header_length,
-                        pixels,
-                    )
-
-                # Move to next block using Xiaomi method
                 block_start_position = (
                     block_start_position + block_data_length + self._get_int8(header, 2)
                 )
-
             except (struct.error, IndexError):
                 break
-
         return blocks
 
     def _parse_image_block(
@@ -365,8 +464,32 @@ class RRMapParser:
                 ]
 
             # Add missing fields to match expected JSON format
-            parsed_map_data["forbidden_zones"] = []
-            parsed_map_data["virtual_walls"] = []
+            parsed_map_data["currently_cleaned_zones"] = (
+                blocks[self.Types.CURRENTLY_CLEANED_ZONES.value]["zones"]
+                if self.Types.CURRENTLY_CLEANED_ZONES.value in blocks
+                else []
+            )
+            parsed_map_data["forbidden_zones"] = (
+                blocks[self.Types.FORBIDDEN_ZONES.value]["forbidden_zones"]
+                if self.Types.FORBIDDEN_ZONES.value in blocks
+                else []
+            )
+            parsed_map_data["forbidden_mop_zones"] = (
+                blocks[self.Types.FORBIDDEN_MOP_ZONES.value]["forbidden_mop_zones"]
+                if self.Types.FORBIDDEN_MOP_ZONES.value in blocks
+                else []
+            )
+            parsed_map_data["virtual_walls"] = (
+                blocks[self.Types.VIRTUAL_WALLS.value]["virtual_walls"]
+                if self.Types.VIRTUAL_WALLS.value in blocks
+                else []
+            )
+            parsed_map_data["carpet_areas"] = (
+                blocks[self.Types.CARPET_MAP.value]["carpet_map"]
+                if self.Types.CARPET_MAP.value in blocks
+                else []
+            )
+            parsed_map_data["is_valid"] = self.is_valid
 
             return parsed_map_data
 
@@ -388,8 +511,3 @@ class RRMapParser:
             except (struct.error, IndexError, ValueError):
                 return None
         return self.map_data
-
-    @staticmethod
-    def get_int32(data: bytes, address: int) -> int:
-        """Get a 32-bit integer from the data - kept for compatibility."""
-        return struct.unpack_from("<i", data, address)[0]

valetudo_map_parser/config/shared.py

@@ -7,17 +7,20 @@ Version: v0.1.12
 import asyncio
 import logging
 from typing import List
+
 from PIL import Image
 
+from .utils import pil_size_rotation
 from .types import (
     ATTR_CALIBRATION_POINTS,
     ATTR_CAMERA_MODE,
+    ATTR_CONTENT_TYPE,
+    ATTR_IMAGE_LAST_UPDATED,
     ATTR_MARGINS,
     ATTR_OBSTACLES,
     ATTR_POINTS,
     ATTR_ROOMS,
     ATTR_ROTATE,
-    ATTR_SNAPSHOT,
     ATTR_VACUUM_BATTERY,
     ATTR_VACUUM_CHARGING,
     ATTR_VACUUM_JSON_ID,
@@ -37,10 +40,11 @@ from .types import (
     CONF_VAC_STAT_SIZE,
     CONF_ZOOM_LOCK_RATIO,
     DEFAULT_VALUES,
+    NOT_STREAMING_STATES,
     CameraModes,
     Colors,
-    TrimsData,
     PilPNG,
+    TrimsData,
 )
 
 
@@ -116,10 +120,17 @@ class CameraShared:
         self.trims = TrimsData.from_dict(DEFAULT_VALUES["trims_data"])
         self.skip_room_ids: List[str] = []
         self.device_info = None
+        self._battery_state = None
 
     def vacuum_bat_charged(self) -> bool:
         """Check if the vacuum is charging."""
-        return (self.vacuum_state == "docked") and (int(self.vacuum_battery) < 100)
+        if self.vacuum_state != "docked":
+                self._battery_state = "not_charging"
+        elif (self._battery_state == "charging") and (int(self.vacuum_battery) == 100):
+            self._battery_state = "charged"
+        else:
+            self._battery_state = "charging" if int(self.vacuum_battery) < 100 else "not_charging"
+        return (self.vacuum_state == "docked") and (self._battery_state == "charged")
 
     @staticmethod
     def _compose_obstacle_links(vacuum_host_ip: str, obstacles: list) -> list | None:
@@ -179,12 +190,14 @@ class CameraShared:
     def generate_attributes(self) -> dict:
         """Generate and return the shared attribute's dictionary."""
         attrs = {
+            ATTR_IMAGE_LAST_UPDATED: self.image_last_updated,
+            ATTR_CONTENT_TYPE: self.image_format,
+            ATTR_VACUUM_JSON_ID: self.vac_json_id,
             ATTR_CAMERA_MODE: self.camera_mode,
+            ATTR_VACUUM_STATUS: self.vacuum_state,
             ATTR_VACUUM_BATTERY: f"{self.vacuum_battery}%",
             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,
             ATTR_CALIBRATION_POINTS: self.attr_calibration_points,
         }
         if self.obstacles_pos and self.vacuum_ips:
@@ -193,8 +206,6 @@ class CameraShared:
             )
             attrs[ATTR_OBSTACLES] = self.obstacles_data
 
-        attrs[ATTR_SNAPSHOT] = self.snapshot_take if self.enable_snapshots else False
-
         shared_attrs = {
             ATTR_ROOMS: self.map_rooms,
             ATTR_ZONES: self.map_pred_zones,
@@ -206,18 +217,25 @@ class CameraShared:
 
         return attrs
 
+    def is_streaming(self) -> bool:
+        """Return true if the device is streaming."""
+        updated_status = self.vacuum_state
+        attr_is_streaming = ((updated_status not in NOT_STREAMING_STATES 
+                              or self.vacuum_bat_charged()) 
+                             or not self.binary_image)
+        return attr_is_streaming
+
     def to_dict(self) -> dict:
         """Return a dictionary with image and attributes data."""
-        return {
+        data = {
             "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,
+                "size": pil_size_rotation(self.image_rotate, self.new_image),
+                "streaming": self.is_streaming()
             },
             "attributes": self.generate_attributes(),
         }
+        return data
 
 
 class CameraSharedManager:

valetudo_map_parser/config/status_text/status_text.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 from ..types import LOGGER, PilPNG
 from .translations import translations
 
+
 LOGGER.propagate = True
 
 

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, List, NotRequired
+from typing import Any, Dict, List, NotRequired, Optional, Tuple, TypedDict, Union
 
 import numpy as np
 from PIL import Image
@@ -18,23 +18,28 @@ 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]]
+    updated: NotRequired[Optional[float | int]]
+
 
 class RoomProperty(TypedDict):
     number: int
@@ -216,7 +221,9 @@ class SnapshotStore:
 Color = Union[Tuple[int, int, int], Tuple[int, int, int, int]]
 Colors = Dict[str, Color]
 CalibrationPoints = list[dict[str, Any]]
-RobotPosition = Optional[dict[str, Union[int | float]]]
+RobotPosition: type[tuple[Any, Any, dict[str, int | float] | None]] = tuple[
+    Any, Any, dict[str, int | float] | None
+]
 ChargerPosition = dict[str, Any]
 RoomsProperties = dict[str, RoomProperty]
 ImageSize = dict[str, int | list[int]]
@@ -227,9 +234,11 @@ NumpyArray = np.ndarray
 Point = Tuple[int, int]
 
 CAMERA_STORAGE = "valetudo_camera"
+ATTR_IMAGE_LAST_UPDATED = "image_last_updated"
 ATTR_ROTATE = "rotate_image"
 ATTR_CROP = "crop_image"
 ATTR_MARGINS = "margins"
+ATTR_CONTENT_TYPE = "content_type"
 CONF_OFFSET_TOP = "offset_top"
 CONF_OFFSET_BOTTOM = "offset_bottom"
 CONF_OFFSET_LEFT = "offset_left"