valetudo-map-parser 0.1.8__py3-none-any.whl → 0.1.9a0__py3-none-any.whl

valetudo_map_parser/config/types.py

@@ -4,29 +4,27 @@ Version 0.0.1
 """
 
 import asyncio
-from dataclasses import dataclass
 import json
 import logging
-from typing import Any, Dict, Tuple, Union
+import threading
+from dataclasses import asdict, dataclass
+from typing import Any, Dict, Optional, Tuple, TypedDict, Union
 
-from PIL import Image
 import numpy as np
+from PIL import Image
+
 
 DEFAULT_ROOMS = 1
 
-MY_LOGGER = logging.getLogger(__name__)
+LOGGER = logging.getLogger(__package__)
 
-Color = Union[Tuple[int, int, int], Tuple[int, int, int, int]]
-Colors = Dict[str, Color]
-CalibrationPoints = list[dict[str, Any]]
-RobotPosition = dict[str, int | float]
-ChargerPosition = dict[str, Any]
-RoomsProperties = dict[str, dict[str, int | list[tuple[Any, Any]]]]
-ImageSize = dict[str, int | list[int]]
-JsonType = Any  # json.loads() return type is Any
-PilPNG = Image.Image
-NumpyArray = np.ndarray
-Point = Tuple[int, int]
+
+class RoomProperty(TypedDict):
+    number: int
+    outline: list[tuple[int, int]]
+    name: str
+    x: int
+    y: int
 
 
 # pylint: disable=no-member
@@ -73,43 +71,37 @@ class TrimCropData:
         )
 
 
-# pylint: disable=no-member
 class RoomStore:
-    """Store the room data for the vacuum."""
-
-    _instance = None
-    _lock = asyncio.Lock()
-
-    def __init__(self):
-        self.vacuums_data = {}
-
-    def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super(RoomStore, cls).__new__(cls)
-            cls._instance.vacuums_data = {}
-        return cls._instance
-
-    async def async_set_rooms_data(self, vacuum_id: str, rooms_data: dict) -> None:
-        """Set the room data for the vacuum."""
-        async with self._lock:
-            self.vacuums_data[vacuum_id] = rooms_data
+    _instances: Dict[str, "RoomStore"] = {}
+    _lock = threading.Lock()
+
+    def __new__(cls, vacuum_id: str, rooms_data: Optional[dict] = None) -> "RoomStore":
+        with cls._lock:
+            if vacuum_id not in cls._instances:
+                instance = super(RoomStore, cls).__new__(cls)
+                instance.vacuum_id = vacuum_id
+                instance.vacuums_data = rooms_data or {}
+                cls._instances[vacuum_id] = instance
+            else:
+                if rooms_data is not None:
+                    cls._instances[vacuum_id].vacuums_data = rooms_data
+        return cls._instances[vacuum_id]
+
+    def get_rooms(self) -> dict:
+        return self.vacuums_data
+
+    def set_rooms(self, rooms_data: dict) -> None:
+        self.vacuums_data = rooms_data
+
+    def get_rooms_count(self) -> int:
+        if isinstance(self.vacuums_data, dict):
+            count = len(self.vacuums_data)
+            return count if count > 0 else DEFAULT_ROOMS
+        return DEFAULT_ROOMS
 
-    async def async_get_rooms_data(self, vacuum_id: str) -> dict:
-        """Get the room data for a vacuum."""
-        async with self._lock:
-            data = self.vacuums_data.get(vacuum_id, {})
-            if isinstance(data, str):
-                json_data = json.loads(data)
-                return json_data
-            return data
-
-    async def async_get_rooms_count(self, vacuum_id: str) -> int:
-        """Count the number of rooms for a vacuum."""
-        async with self._lock:
-            count = len(self.vacuums_data.get(vacuum_id, {}))
-            if count == 0:
-                return DEFAULT_ROOMS
-            return count
+    @classmethod
+    def get_all_instances(cls) -> Dict[str, "RoomStore"]:
+        return cls._instances
 
 
 # pylint: disable=no-member
@@ -202,8 +194,20 @@ class SnapshotStore:
             self.vacuum_json_data[vacuum_id] = json_data
 
 
+Color = Union[Tuple[int, int, int], Tuple[int, int, int, int]]
+Colors = Dict[str, Color]
+CalibrationPoints = list[dict[str, Any]]
+RobotPosition = dict[str, int | float]
+ChargerPosition = dict[str, Any]
+RoomsProperties = dict[str, RoomProperty]
+ImageSize = dict[str, int | list[int]]
+JsonType = Any  # json.loads() return type is Any
+PilPNG = Image.Image  # Keep for backward compatibility
+WebPBytes = bytes  # WebP image as bytes
+NumpyArray = np.ndarray
+Point = Tuple[int, int]
+
 CAMERA_STORAGE = "valetudo_camera"
-DEFAULT_ROOMS = 1  # 15 is the maximum number of rooms.
 ATTR_ROTATE = "rotate_image"
 ATTR_CROP = "crop_image"
 ATTR_MARGINS = "margins"
@@ -284,6 +288,7 @@ DEFAULT_VALUES = {
     "vac_status_position": True,
     "get_svg_file": False,
     "save_trims": True,
+    "trims_data": {"trim_left": 0, "trim_up": 0, "trim_right": 0, "trim_down": 0},
     "enable_www_snapshots": False,
     "color_charger": [255, 128, 0],
     "color_move": [238, 247, 255],
@@ -345,6 +350,7 @@ KEYS_TO_UPDATE = [
     "offset_bottom",
     "offset_left",
     "offset_right",
+    "trims_data",
     "auto_zoom",
     "zoom_lock_ratio",
     "show_vac_status",
@@ -562,7 +568,8 @@ ALPHA_ROOM_15 = "alpha_room_15"
 
 """ Constants for the attribute keys """
 ATTR_FRIENDLY_NAME = "friendly_name"
-ATTR_VACUUM_BATTERY = "vacuum_battery"
+ATTR_VACUUM_BATTERY = "battery"
+ATTR_VACUUM_CHARGING = "charging"
 ATTR_VACUUM_POSITION = "vacuum_position"
 ATTR_VACUUM_TOPIC = "vacuum_topic"
 ATTR_VACUUM_STATUS = "vacuum_status"
@@ -588,3 +595,49 @@ class CameraModes:
     CAMERA_STANDBY = "camera_standby"
     CAMERA_OFF = False
     CAMERA_ON = True
+
+
+# noinspection PyTypeChecker
+@dataclass
+class TrimsData:
+    """Dataclass to store and manage trims data."""
+
+    floor: str = ""
+    trim_up: int = 0
+    trim_left: int = 0
+    trim_down: int = 0
+    trim_right: int = 0
+
+    @classmethod
+    def from_json(cls, json_data: str):
+        """Create a TrimsConfig instance from a JSON string."""
+        data = json.loads(json_data)
+        return cls(
+            floor=data.get("floor", ""),
+            trim_up=data.get("trim_up", 0),
+            trim_left=data.get("trim_left", 0),
+            trim_down=data.get("trim_down", 0),
+            trim_right=data.get("trim_right", 0),
+        )
+
+    def to_json(self) -> str:
+        """Convert TrimsConfig instance to a JSON string."""
+        return json.dumps(asdict(self))
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        """Initialize TrimData from a dictionary."""
+        return cls(**data)
+
+    def to_dict(self) -> dict:
+        """Convert TrimData to a dictionary."""
+        return asdict(self)
+
+    def clear(self) -> dict:
+        """Clear all the trims."""
+        self.floor = ""
+        self.trim_up = 0
+        self.trim_left = 0
+        self.trim_down = 0
+        self.trim_right = 0
+        return asdict(self)