valetudo-map-parser 0.1.10rc6__tar.gz → 0.1.10rc7__tar.gz

{valetudo_map_parser-0.1.10rc6 → valetudo_map_parser-0.1.10rc7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: valetudo-map-parser
-Version: 0.1.10rc6
+Version: 0.1.10rc7
 Summary: A Python library to parse Valetudo map data returning a PIL Image object.
 License: Apache-2.0
 License-File: LICENSE
@@ -13,7 +13,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: Pillow (>=10.3.0)
-Requires-Dist: mvcrender (>=0.0.2)
+Requires-Dist: mvcrender (>=0.0.4)
 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.10rc6 → valetudo_map_parser-0.1.10rc7}/SCR/valetudo_map_parser/config/rand256_parser.py

@@ -24,6 +24,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 +41,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 +76,61 @@ 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]:
+        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:
+        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:
+        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 +146,19 @@ class RRMapParser:
                 angle = raw_angle
         return {"position": [x, y], "angle": angle}
 
+
+    @staticmethod
+    def _parse_walls(data: bytes, header: bytes) -> list:
+        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."""
@@ -127,59 +204,45 @@ class RRMapParser:
             return {}
 
     def parse_blocks(self, raw: bytes, pixels: bool = True) -> Dict[int, Any]:
-        """Parse all blocks using Xiaomi method."""
         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)
-
-                # 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)
-                )
-
+                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)
+
+                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 +428,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 +475,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-0.1.10rc6 → valetudo_map_parser-0.1.10rc7}/SCR/valetudo_map_parser/config/shared.py

@@ -12,12 +12,13 @@ from PIL import Image
 from .types import (
     ATTR_CALIBRATION_POINTS,
     ATTR_CAMERA_MODE,
+    ATTR_CONTENT_TYPE,
     ATTR_MARGINS,
     ATTR_OBSTACLES,
     ATTR_POINTS,
     ATTR_ROOMS,
     ATTR_ROTATE,
-    ATTR_SNAPSHOT,
+    ATTR_IMAGE_LAST_UPDATED,
     ATTR_VACUUM_BATTERY,
     ATTR_VACUUM_CHARGING,
     ATTR_VACUUM_JSON_ID,
@@ -179,12 +180,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 +196,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,
@@ -211,10 +212,8 @@ class CameraShared:
         return {
             "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,
+                "pil_image": self.new_image,
+                "size": self.new_image.size if self.new_image else (10, 10),
             },
             "attributes": self.generate_attributes(),
         }

{valetudo_map_parser-0.1.10rc6 → valetudo_map_parser-0.1.10rc7}/SCR/valetudo_map_parser/config/types.py

@@ -18,23 +18,29 @@ 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
 
+
+# list[dict[str, str | list[int]]] | list[dict[str, str | list[list[int]]]] | list[dict[str, str | int]] | 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]]
+
 
 class RoomProperty(TypedDict):
     number: int
@@ -227,9 +233,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"

{valetudo_map_parser-0.1.10rc6 → valetudo_map_parser-0.1.10rc7}/SCR/valetudo_map_parser/config/utils.py

@@ -23,7 +23,7 @@ from .types import (
     NumpyArray,
     PilPNG,
     RobotPosition,
-    Destinations
+    Destinations,
 )
 from ..map_data import HyperMapData
 from .async_utils import AsyncNumPy
@@ -197,26 +197,27 @@ class BaseHandler:
         """Update the shared data with the latest information."""
 
         if hasattr(self, "get_rooms_attributes") and (
-                self.shared.map_rooms is None and destinations is not None
+            self.shared.map_rooms is None and destinations is not None
         ):
-            (
-                self.shared.map_rooms,
-                self.shared.map_pred_zones,
-                self.shared.map_pred_points,
-            ) = await self.get_rooms_attributes(destinations)
+            (self.shared.map_rooms,) = await self.get_rooms_attributes(destinations)
             if self.shared.map_rooms:
                 LOGGER.debug("%s: Rand256 attributes rooms updated", self.file_name)
 
         if hasattr(self, "async_get_rooms_attributes") and (
-                self.shared.map_rooms is None
+            self.shared.map_rooms is None
         ):
             if self.shared.map_rooms is None:
                 self.shared.map_rooms = await self.async_get_rooms_attributes()
                 if self.shared.map_rooms:
                     LOGGER.debug("%s: Hyper attributes rooms updated", self.file_name)
 
-        if hasattr(self, "get_calibration_data") and self.shared.attr_calibration_points is None:
-            self.shared.attr_calibration_points = self.get_calibration_data(self.shared.image_rotate)
+        if (
+            hasattr(self, "get_calibration_data")
+            and self.shared.attr_calibration_points is None
+        ):
+            self.shared.attr_calibration_points = self.get_calibration_data(
+                self.shared.image_rotate
+            )
 
         if not self.shared.image_size:
             self.shared.image_size = self.get_img_size()
@@ -228,14 +229,19 @@ class BaseHandler:
 
         self.shared.current_room = self.get_robot_position()
 
-    def prepare_resize_params(self, pil_img: PilPNG, rand: bool=False) -> ResizeParams:
+    def prepare_resize_params(
+        self, pil_img: PilPNG, rand: bool = False
+    ) -> ResizeParams:
         """Prepare resize parameters for image resizing."""
         if self.shared.image_rotate in [0, 180]:
             width, height = pil_img.size
         else:
             height, width = pil_img.size
-        LOGGER.debug("Shared PIL image size: %s x %s", self.shared.image_ref_width,
-                     self.shared.image_ref_height)
+        LOGGER.debug(
+            "Shared PIL image size: %s x %s",
+            self.shared.image_ref_width,
+            self.shared.image_ref_height,
+        )
         return ResizeParams(
             pil_img=pil_img,
             width=width,

{valetudo_map_parser-0.1.10rc6 → valetudo_map_parser-0.1.10rc7}/SCR/valetudo_map_parser/hypfer_handler.py

@@ -14,7 +14,6 @@ from PIL import Image
 
 from .config.async_utils import AsyncPIL
 
-# from .config.auto_crop import AutoCrop
 from mvcrender.autocrop import AutoCrop
 from .config.drawable_elements import DrawableElement
 from .config.shared import CameraShared
@@ -60,7 +59,6 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
             None  # persistent working buffer to avoid per-frame allocations
         )
         self.active_zones = []  # vacuum active zones.
-        self.svg_wait = False  # SVG image creation wait.
         self.imd = ImDraw(self)  # Image Draw class.
         self.color_grey = (128, 128, 128, 255)
         self.file_name = self.shared.file_name  # file name of the vacuum.
@@ -362,7 +360,7 @@ class HypferMapImageHandler(BaseHandler, AutoCrop):
                 self.zooming = self.imd.img_h.zooming
 
                 # Resize the image
-                img_np_array = self.async_auto_trim_and_zoom_image(
+                img_np_array = self.auto_trim_and_zoom_image(
                     img_np_array,
                     colors["background"],
                     int(self.shared.margins),

{valetudo_map_parser-0.1.10rc6 → valetudo_map_parser-0.1.10rc7}/SCR/valetudo_map_parser/map_data.py

@@ -539,16 +539,17 @@ class RandImageData:
         return None
 
     @staticmethod
-    def get_rrm_currently_cleaned_zones(json_data: JsonType) -> dict:
+    def get_rrm_currently_cleaned_zones(json_data: JsonType) -> list[dict[str, Any]]:
         """Get the currently cleaned zones from the json."""
         re_zones = json_data.get("currently_cleaned_zones", [])
         formatted_zones = RandImageData._rrm_valetudo_format_zone(re_zones)
         return formatted_zones
 
     @staticmethod
-    def get_rrm_forbidden_zones(json_data: JsonType) -> dict:
+    def get_rrm_forbidden_zones(json_data: JsonType) -> list[dict[str, Any]]:
         """Get the forbidden zones from the json."""
         re_zones = json_data.get("forbidden_zones", [])
+        re_zones.extend(json_data.get("forbidden_mop_zones", []))
         formatted_zones = RandImageData._rrm_valetudo_format_zone(re_zones)
         return formatted_zones
 

{valetudo_map_parser-0.1.10rc6 → valetudo_map_parser-0.1.10rc7}/SCR/valetudo_map_parser/rand256_handler.py

@@ -7,7 +7,6 @@ Version: 0.1.9.a6
 
 from __future__ import annotations
 
-import logging
 import uuid
 from typing import Any
 
@@ -15,7 +14,6 @@ import numpy as np
 
 from .config.async_utils import AsyncPIL
 
-# from .config.auto_crop import AutoCrop
 from mvcrender.autocrop import AutoCrop
 from .config.drawable_elements import DrawableElement
 from .config.types import (
@@ -28,6 +26,7 @@ from .config.types import (
     RobotPosition,
     RoomsProperties,
     RoomStore,
+    LOGGER,
 )
 from .config.utils import (
     BaseHandler,
@@ -39,9 +38,6 @@ from .reimg_draw import ImageDraw
 from .rooms_handler import RandRoomsHandler
 
 
-_LOGGER = logging.getLogger(__name__)
-
-
 # noinspection PyTypeChecker
 class ReImageHandler(BaseHandler, AutoCrop):
     """
@@ -112,17 +108,17 @@ class ReImageHandler(BaseHandler, AutoCrop):
             self.shared.map_rooms = room_ids
 
             # get the zones and points data
-            zone_properties = await self.async_zone_propriety(zones_data)
+            self.shared.map_pred_zones = await self.async_zone_propriety(zones_data)
             # get the points data
-            point_properties = await self.async_points_propriety(points_data)
+            self.shared.map_pred_points = await self.async_points_propriety(points_data)
 
-            if not (room_properties or zone_properties):
+            if not (room_properties or self.shared.map_pred_zones):
                 self.rooms_pos = None
 
             rooms = RoomStore(self.file_name, room_properties)
-            return room_properties, zone_properties, point_properties
+            return room_properties
         except (RuntimeError, ValueError) as e:
-            _LOGGER.warning(
+            LOGGER.warning(
                 "No rooms Data or Error in extract_room_properties: %s",
                 e,
                 exc_info=True,
@@ -146,12 +142,12 @@ class ReImageHandler(BaseHandler, AutoCrop):
 
         try:
             if (m_json is not None) and (not isinstance(m_json, tuple)):
-                _LOGGER.info("%s: Composing the image for the camera.", self.file_name)
+                LOGGER.info("%s: Composing the image for the camera.", self.file_name)
                 self.json_data = m_json
                 size_x, size_y = self.data.get_rrm_image_size(m_json)
                 self.img_size = DEFAULT_IMAGE_SIZE
                 self.json_id = str(uuid.uuid4())  # image id
-                _LOGGER.info("Vacuum Data ID: %s", self.json_id)
+                LOGGER.info("Vacuum Data ID: %s", self.json_id)
 
                 (
                     img_np_array,
@@ -178,7 +174,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
                 return await self._finalize_image(pil_img)
 
         except (RuntimeError, RuntimeWarning) as e:
-            _LOGGER.warning(
+            LOGGER.warning(
                 "%s: Runtime Error %s during image creation.",
                 self.file_name,
                 str(e),
@@ -214,7 +210,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
                     colors["background"],
                     DEFAULT_PIXEL_SIZE,
                 )
-                _LOGGER.info("%s: Completed base Layers", self.file_name)
+                LOGGER.info("%s: Completed base Layers", self.file_name)
 
                 # Update element map for rooms
                 if 0 < room_id <= 15:
@@ -350,7 +346,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
             else:
                 self.zooming = False
 
-        img_np_array = self.async_auto_trim_and_zoom_image(
+        img_np_array = self.auto_trim_and_zoom_image(
             img_np_array,
             detect_colour=colors["background"],
             margin_size=int(self.shared.margins),
@@ -362,7 +358,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
 
     async def _finalize_image(self, pil_img):
         if not self.shared.image_ref_width or not self.shared.image_ref_height:
-            _LOGGER.warning(
+            LOGGER.warning(
                 "Image finalization failed: Invalid image dimensions. Returning original image."
             )
             return pil_img
@@ -515,7 +511,7 @@ class ReImageHandler(BaseHandler, AutoCrop):
         """Return the map calibration data."""
         if not self.calibration_data and self.crop_img_size:
             self.calibration_data = []
-            _LOGGER.info(
+            LOGGER.info(
                 "%s: Getting Calibrations points %s",
                 self.file_name,
                 str(self.crop_area),