valetudo-map-parser 0.1.9b50__tar.gz → 0.1.9b52__tar.gz

{valetudo_map_parser-0.1.9b50 → valetudo_map_parser-0.1.9b52}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: valetudo-map-parser
-Version: 0.1.9b50
+Version: 0.1.9b52
 Summary: A Python library to parse Valetudo map data returning a PIL Image object.
 License: Apache-2.0
 Author: Sandro Cantarella

{valetudo_map_parser-0.1.9b50 → valetudo_map_parser-0.1.9b52}/SCR/valetudo_map_parser/__init__.py

@@ -15,11 +15,13 @@ from .config.types import (
     TrimCropData,
     UserLanguageStore,
 )
+from .hypfer_rooms_handler import HypferRoomsHandler
 from .hypfer_handler import HypferMapImageHandler
 from .rand25_handler import ReImageHandler
 
 
 __all__ = [
+    "HypferRoomsHandler",
     "HypferMapImageHandler",
     "ReImageHandler",
     "RRMapParser",

valetudo_map_parser-0.1.9b52/SCR/valetudo_map_parser/config/color_utils.py

@@ -0,0 +1,105 @@
+"""Utility functions for color operations in the map parser."""
+
+from typing import Tuple, Optional
+
+from .colors import ColorsManagement
+from .types import NumpyArray, Color
+
+
+def get_blended_color(
+    x0: int,
+    y0: int,
+    x1: int,
+    y1: int,
+    arr: Optional[NumpyArray],
+    color: Color,
+) -> Color:
+    """
+    Get a blended color for a pixel based on the current element map and the new element to draw.
+
+    This function:
+    1. Gets the background colors at the start and end points (with offset to avoid sampling already drawn pixels)
+    2. Directly blends the foreground color with the background using straight alpha
+    3. Returns the average of the two blended colors
+
+    Returns:
+        Blended RGBA color to use for drawing
+    """
+    # Extract foreground color components
+    fg_r, fg_g, fg_b, fg_a = color
+    fg_alpha = fg_a / 255.0  # Convert to 0-1 range
+
+    # Fast path for fully opaque or transparent foreground
+    if fg_a == 255:
+        return color
+    if fg_a == 0:
+        # Sample background at midpoint
+        mid_x, mid_y = (x0 + x1) // 2, (y0 + y1) // 2
+        if 0 <= mid_y < arr.shape[0] and 0 <= mid_x < arr.shape[1]:
+            return tuple(arr[mid_y, mid_x])
+        return (0, 0, 0, 0)  # Default if out of bounds
+
+    # Calculate direction vector for offset sampling
+    dx = x1 - x0
+    dy = y1 - y0
+    length = max(1, (dx**2 + dy**2) ** 0.5)  # Avoid division by zero
+    offset = 5  # 5-pixel offset to avoid sampling already drawn pixels
+
+    # Calculate offset coordinates for start point (move away from the line)
+    offset_x0 = int(x0 - (offset * dx / length))
+    offset_y0 = int(y0 - (offset * dy / length))
+
+    # Calculate offset coordinates for end point (move away from the line)
+    offset_x1 = int(x1 + (offset * dx / length))
+    offset_y1 = int(y1 + (offset * dy / length))
+
+    # Sample background at offset start point
+    if 0 <= offset_y0 < arr.shape[0] and 0 <= offset_x0 < arr.shape[1]:
+        bg_color_start = arr[offset_y0, offset_x0]
+        # Direct straight alpha blending
+        start_r = int(fg_r * fg_alpha + bg_color_start[0] * (1 - fg_alpha))
+        start_g = int(fg_g * fg_alpha + bg_color_start[1] * (1 - fg_alpha))
+        start_b = int(fg_b * fg_alpha + bg_color_start[2] * (1 - fg_alpha))
+        start_a = int(fg_a + bg_color_start[3] * (1 - fg_alpha))
+        start_blended_color = (start_r, start_g, start_b, start_a)
+    else:
+        # If offset point is out of bounds, try original point
+        if 0 <= y0 < arr.shape[0] and 0 <= x0 < arr.shape[1]:
+            bg_color_start = arr[y0, x0]
+            start_r = int(fg_r * fg_alpha + bg_color_start[0] * (1 - fg_alpha))
+            start_g = int(fg_g * fg_alpha + bg_color_start[1] * (1 - fg_alpha))
+            start_b = int(fg_b * fg_alpha + bg_color_start[2] * (1 - fg_alpha))
+            start_a = int(fg_a + bg_color_start[3] * (1 - fg_alpha))
+            start_blended_color = (start_r, start_g, start_b, start_a)
+        else:
+            start_blended_color = color
+
+    # Sample background at offset end point
+    if 0 <= offset_y1 < arr.shape[0] and 0 <= offset_x1 < arr.shape[1]:
+        bg_color_end = arr[offset_y1, offset_x1]
+        # Direct straight alpha blending
+        end_r = int(fg_r * fg_alpha + bg_color_end[0] * (1 - fg_alpha))
+        end_g = int(fg_g * fg_alpha + bg_color_end[1] * (1 - fg_alpha))
+        end_b = int(fg_b * fg_alpha + bg_color_end[2] * (1 - fg_alpha))
+        end_a = int(fg_a + bg_color_end[3] * (1 - fg_alpha))
+        end_blended_color = (end_r, end_g, end_b, end_a)
+    else:
+        # If offset point is out of bounds, try original point
+        if 0 <= y1 < arr.shape[0] and 0 <= x1 < arr.shape[1]:
+            bg_color_end = arr[y1, x1]
+            end_r = int(fg_r * fg_alpha + bg_color_end[0] * (1 - fg_alpha))
+            end_g = int(fg_g * fg_alpha + bg_color_end[1] * (1 - fg_alpha))
+            end_b = int(fg_b * fg_alpha + bg_color_end[2] * (1 - fg_alpha))
+            end_a = int(fg_a + bg_color_end[3] * (1 - fg_alpha))
+            end_blended_color = (end_r, end_g, end_b, end_a)
+        else:
+            end_blended_color = color
+
+    # Use the average of the two blended colors
+    blended_color = (
+        (start_blended_color[0] + end_blended_color[0]) // 2,
+        (start_blended_color[1] + end_blended_color[1]) // 2,
+        (start_blended_color[2] + end_blended_color[2]) // 2,
+        (start_blended_color[3] + end_blended_color[3]) // 2,
+    )
+    return blended_color

{valetudo_map_parser-0.1.9b50 → valetudo_map_parser-0.1.9b52}/SCR/valetudo_map_parser/config/colors.py

@@ -407,61 +407,56 @@ class ColorsManagement:
     def blend_colors(background: Color, foreground: Color) -> Color:
         """
         Blend foreground color with background color based on alpha values.
-
-        This is used when drawing elements that overlap on the map.
-        The alpha channel determines how much of the foreground color is visible.
-        Uses optimized calculations for better performance.
+        Optimized version with more fast paths and simplified calculations.
 
         :param background: Background RGBA color (r,g,b,a)
         :param foreground: Foreground RGBA color (r,g,b,a) to blend on top
         :return: Blended RGBA color
         """
-        # Extract components
-        bg_r, bg_g, bg_b, bg_a = background
-        fg_r, fg_g, fg_b, fg_a = foreground
+        # Fast paths for common cases
+        fg_a = foreground[3]
 
-        # Fast path for common cases
-        if fg_a == 255:
+        if fg_a == 255:  # Fully opaque foreground
             return foreground
-        if fg_a == 0:
-            return background
 
-        # Calculate alpha blending
-        # Convert alpha from [0-255] to [0-1] for calculations
-        fg_alpha = fg_a / 255.0
-        bg_alpha = bg_a / 255.0
+        if fg_a == 0:  # Fully transparent foreground
+            return background
 
-        # Calculate resulting alpha
-        out_alpha = fg_alpha + bg_alpha * (1 - fg_alpha)
+        bg_a = background[3]
+        if bg_a == 0:  # Fully transparent background
+            return foreground
 
-        # Avoid division by zero
-        if out_alpha < 0.0001:
-            return Color[0, 0, 0, 0]  # Fully transparent result
+        # Extract components (only after fast paths)
+        bg_r, bg_g, bg_b = background[:3]
+        fg_r, fg_g, fg_b = foreground[:3]
 
-        # Calculate blended RGB components
-        # Using a more efficient calculation method
-        alpha_ratio = fg_alpha / out_alpha
-        inv_alpha_ratio = 1.0 - alpha_ratio
+        # Pre-calculate the blend factor once (avoid repeated division)
+        blend = fg_a / 255.0
+        inv_blend = 1.0 - blend
 
-        out_r = int(fg_r * alpha_ratio + bg_r * inv_alpha_ratio)
-        out_g = int(fg_g * alpha_ratio + bg_g * inv_alpha_ratio)
-        out_b = int(fg_b * alpha_ratio + bg_b * inv_alpha_ratio)
+        # Simple linear interpolation for RGB channels
+        # This is faster than the previous implementation
+        out_r = int(fg_r * blend + bg_r * inv_blend)
+        out_g = int(fg_g * blend + bg_g * inv_blend)
+        out_b = int(fg_b * blend + bg_b * inv_blend)
 
-        # Convert alpha back to [0-255] range
-        out_a = int(out_alpha * 255)
+        # Alpha blending - simplified calculation
+        out_a = int(fg_a + bg_a * inv_blend)
 
-        # Ensure values are in valid range (using min/max for efficiency)
-        out_r = max(0, min(255, out_r))
-        out_g = max(0, min(255, out_g))
-        out_b = max(0, min(255, out_b))
+        # No need for min/max checks as the blend math keeps values in range
+        # when input values are valid (0-255)
 
         return [out_r, out_g, out_b, out_a]
 
+    # Cache for recently sampled background colors
+    _bg_color_cache = {}
+    _cache_size = 1024  # Limit cache size to avoid memory issues
+
     @staticmethod
     def sample_and_blend_color(array, x: int, y: int, foreground: Color) -> Color:
         """
         Sample the background color from the array at coordinates (x,y) and blend with foreground color.
-        Uses scipy.ndimage for efficient sampling when appropriate.
+        Optimized version with caching and faster sampling.
 
         Args:
             array: The RGBA numpy array representing the image
@@ -472,53 +467,43 @@ class ColorsManagement:
         Returns:
             Blended RGBA color
         """
-        # Ensure coordinates are within bounds
+        # Fast path for fully opaque foreground - no need to sample or blend
+        if foreground[3] == 255:
+            return foreground
+
+        # Ensure array exists
         if array is None:
             return foreground
 
+        # Check if coordinates are within bounds
         height, width = array.shape[:2]
         if not (0 <= y < height and 0 <= x < width):
-            return foreground  # Return foreground if coordinates are out of bounds
-
-        # Fast path for fully opaque foreground
-        if foreground[3] == 255:
             return foreground
 
-        # The array is in RGBA format with shape (height, width, 4)
-        try:
-            # Use scipy.ndimage for sampling with boundary handling
-            # This is more efficient for large arrays and handles edge cases better
-            if (
-                array.size > 1000000
-            ):  # Only use for larger arrays where the overhead is worth it
-                # Create coordinates array for the sampling point
-                coordinates = np.array([[y, x]])
-
-                # Sample each channel separately with nearest neighbor interpolation
-                # This is faster than sampling all channels at once for large arrays
-                r = ndimage.map_coordinates(
-                    array[..., 0], coordinates.T, order=0, mode="nearest"
-                )[0]
-                g = ndimage.map_coordinates(
-                    array[..., 1], coordinates.T, order=0, mode="nearest"
-                )[0]
-                b = ndimage.map_coordinates(
-                    array[..., 2], coordinates.T, order=0, mode="nearest"
-                )[0]
-                a = ndimage.map_coordinates(
-                    array[..., 3], coordinates.T, order=0, mode="nearest"
-                )[0]
-                background = (int(r), int(g), int(b), int(a))
-            else:
-                # For smaller arrays, direct indexing is faster
-                background = tuple(array[y, x])
-        except (IndexError, ValueError):
-            # Fallback to direct indexing if ndimage fails
+        # Check cache for this coordinate
+        cache_key = (id(array), x, y)
+        cache = ColorsManagement._bg_color_cache
+
+        if cache_key in cache:
+            background = cache[cache_key]
+        else:
+            # Sample the background color using direct indexing (fastest method)
             try:
-                background = tuple(array[y, x])
+                background = tuple(map(int, array[y, x]))
+
+                # Update cache (with simple LRU-like behavior)
+                if len(cache) >= ColorsManagement._cache_size:
+                    # Remove a random entry if cache is full
+                    cache.pop(next(iter(cache)))
+                cache[cache_key] = background
+
             except (IndexError, ValueError):
                 return foreground
 
+        # Fast path for fully transparent foreground
+        if foreground[3] == 0:
+            return background
+
         # Blend the colors
         return ColorsManagement.blend_colors(background, foreground)
 

valetudo_map_parser-0.1.9b52/SCR/valetudo_map_parser/config/drawable_elements.py

@@ -0,0 +1,307 @@
+"""
+Drawable Elements Configuration.
+Defines the elements that can be drawn on the map and their properties.
+Version: 0.1.9
+"""
+
+from __future__ import annotations
+
+from enum import IntEnum
+from typing import Dict, List, Tuple, Union
+import numpy as np
+from .types import LOGGER
+
+from .colors import DefaultColors, SupportedColor
+
+# Type aliases
+Color = Tuple[int, int, int, int]  # RGBA color
+PropertyDict = Dict[str, Union[Color, float, int]]
+
+
+class DrawableElement(IntEnum):
+    """Enumeration of drawable map elements with unique integer codes."""
+
+    # Base elements
+    FLOOR = 1
+    WALL = 2
+    ROBOT = 3
+    CHARGER = 4
+    VIRTUAL_WALL = 5
+    RESTRICTED_AREA = 6
+    NO_MOP_AREA = 7
+    OBSTACLE = 8
+    PATH = 9
+    PREDICTED_PATH = 10
+    GO_TO_TARGET = 11
+
+    # Rooms (101-115 for up to 15 rooms)
+    ROOM_1 = 101
+    ROOM_2 = 102
+    ROOM_3 = 103
+    ROOM_4 = 104
+    ROOM_5 = 105
+    ROOM_6 = 106
+    ROOM_7 = 107
+    ROOM_8 = 108
+    ROOM_9 = 109
+    ROOM_10 = 110
+    ROOM_11 = 111
+    ROOM_12 = 112
+    ROOM_13 = 113
+    ROOM_14 = 114
+    ROOM_15 = 115
+
+
+class DrawingConfig:
+    """Configuration for which elements to draw and their properties."""
+
+    def __init__(self):
+        """Initialize with all elements enabled by default."""
+        # Dictionary of element_code -> enabled status
+        self._enabled_elements = {element: True for element in DrawableElement}
+
+        # Dictionary of element_code -> drawing properties (color, opacity, etc.)
+        self._element_properties: Dict[DrawableElement, PropertyDict] = {}
+
+        # Initialize default properties
+        self._set_default_properties()
+
+    def _set_default_properties(self):
+        """Set default drawing properties for each element."""
+        # Set properties for rooms using DefaultColors
+        for room_id in range(1, 16):
+            room_element = getattr(DrawableElement, f"ROOM_{room_id}")
+            room_key = SupportedColor.room_key(room_id - 1)
+            rgb = DefaultColors.DEFAULT_ROOM_COLORS.get(room_key, (135, 206, 250))
+            alpha = DefaultColors.DEFAULT_ALPHA.get(f"alpha_room_{room_id - 1}", 255.0)
+
+            self._element_properties[room_element] = {
+                "color": (*rgb, int(alpha)),
+                "opacity": alpha / 255.0,
+                "z_index": 10,  # Drawing order
+            }
+
+        # Map DrawableElement to SupportedColor
+        element_color_mapping = {
+            DrawableElement.FLOOR: SupportedColor.MAP_BACKGROUND,
+            DrawableElement.WALL: SupportedColor.WALLS,
+            DrawableElement.ROBOT: SupportedColor.ROBOT,
+            DrawableElement.CHARGER: SupportedColor.CHARGER,
+            DrawableElement.VIRTUAL_WALL: SupportedColor.NO_GO,
+            DrawableElement.RESTRICTED_AREA: SupportedColor.NO_GO,
+            DrawableElement.PATH: SupportedColor.PATH,
+            DrawableElement.PREDICTED_PATH: SupportedColor.PREDICTED_PATH,
+            DrawableElement.GO_TO_TARGET: SupportedColor.GO_TO,
+            DrawableElement.NO_MOP_AREA: SupportedColor.NO_GO,  # Using NO_GO for no-mop areas
+            DrawableElement.OBSTACLE: SupportedColor.NO_GO,  # Using NO_GO for obstacles
+        }
+
+        # Set z-index for each element type
+        z_indices = {
+            DrawableElement.FLOOR: 0,
+            DrawableElement.WALL: 20,
+            DrawableElement.ROBOT: 50,
+            DrawableElement.CHARGER: 40,
+            DrawableElement.VIRTUAL_WALL: 30,
+            DrawableElement.RESTRICTED_AREA: 25,
+            DrawableElement.NO_MOP_AREA: 25,
+            DrawableElement.OBSTACLE: 15,
+            DrawableElement.PATH: 35,
+            DrawableElement.PREDICTED_PATH: 34,
+            DrawableElement.GO_TO_TARGET: 45,
+        }
+
+        # Set properties for other elements using DefaultColors
+        for element, color_key in element_color_mapping.items():
+            rgb = DefaultColors.COLORS_RGB.get(color_key, (0, 0, 0))
+            alpha_key = f"alpha_{color_key}"
+            alpha = DefaultColors.DEFAULT_ALPHA.get(alpha_key, 255.0)
+
+            # Special case for semi-transparent elements
+            if element in [
+                DrawableElement.RESTRICTED_AREA,
+                DrawableElement.NO_MOP_AREA,
+                DrawableElement.PREDICTED_PATH,
+            ]:
+                alpha = 125.0  # Semi-transparent by default
+
+            self._element_properties[element] = {
+                "color": (*rgb, int(alpha)),
+                "opacity": alpha / 255.0,
+                "z_index": z_indices.get(element, 0),
+            }
+
+    def enable_element(self, element_code: DrawableElement) -> None:
+        """Enable drawing of a specific element."""
+        if element_code in self._enabled_elements:
+            self._enabled_elements[element_code] = True
+            LOGGER.info(
+                "Enabled element %s (%s)", element_code.name, element_code.value
+            )
+            LOGGER.info(
+                "Element %s is now enabled: %s",
+                element_code.name,
+                self._enabled_elements[element_code],
+            )
+
+    def disable_element(self, element_code: DrawableElement) -> None:
+        """Disable drawing of a specific element."""
+        if element_code in self._enabled_elements:
+            self._enabled_elements[element_code] = False
+            LOGGER.info(
+                "Disabled element %s (%s)", element_code.name, element_code.value
+            )
+            LOGGER.info(
+                "Element %s is now enabled: %s",
+                element_code.name,
+                self._enabled_elements[element_code],
+            )
+
+    def set_elements(self, element_codes: List[DrawableElement]) -> None:
+        """Enable only the specified elements, disable all others."""
+        # First disable all
+        for element in self._enabled_elements:
+            self._enabled_elements[element] = False
+
+        # Then enable specified ones
+        for element in element_codes:
+            if element in self._enabled_elements:
+                self._enabled_elements[element] = True
+
+    def is_enabled(self, element_code: DrawableElement) -> bool:
+        """Check if an element is enabled for drawing."""
+        enabled = self._enabled_elements.get(element_code, False)
+        LOGGER.debug(
+            "Checking if element %s is enabled: %s",
+            element_code.name if hasattr(element_code, "name") else element_code,
+            enabled,
+        )
+        return enabled
+
+    def set_property(
+        self, element_code: DrawableElement, property_name: str, value
+    ) -> None:
+        """Set a drawing property for an element."""
+        if element_code in self._element_properties:
+            self._element_properties[element_code][property_name] = value
+
+    def get_property(
+        self, element_code: DrawableElement, property_name: str, default=None
+    ):
+        """Get a drawing property for an element."""
+        if element_code in self._element_properties:
+            return self._element_properties[element_code].get(property_name, default)
+        return default
+
+    def get_enabled_elements(self) -> List[DrawableElement]:
+        """Get list of enabled element codes."""
+        return [
+            element for element, enabled in self._enabled_elements.items() if enabled
+        ]
+
+    def get_drawing_order(self) -> List[DrawableElement]:
+        """Get list of enabled elements in drawing order (by z_index)."""
+        enabled = self.get_enabled_elements()
+        return sorted(enabled, key=lambda e: self.get_property(e, "z_index", 0))
+
+    def update_from_device_info(self, device_info: dict) -> None:
+        """Update configuration based on device info dictionary."""
+        # Map DrawableElement to SupportedColor
+        element_color_mapping = {
+            DrawableElement.FLOOR: SupportedColor.MAP_BACKGROUND,
+            DrawableElement.WALL: SupportedColor.WALLS,
+            DrawableElement.ROBOT: SupportedColor.ROBOT,
+            DrawableElement.CHARGER: SupportedColor.CHARGER,
+            DrawableElement.VIRTUAL_WALL: SupportedColor.NO_GO,
+            DrawableElement.RESTRICTED_AREA: SupportedColor.NO_GO,
+            DrawableElement.PATH: SupportedColor.PATH,
+            DrawableElement.PREDICTED_PATH: SupportedColor.PREDICTED_PATH,
+            DrawableElement.GO_TO_TARGET: SupportedColor.GO_TO,
+            DrawableElement.NO_MOP_AREA: SupportedColor.NO_GO,
+            DrawableElement.OBSTACLE: SupportedColor.NO_GO,
+        }
+
+        # Update room colors from device info
+        for room_id in range(1, 16):
+            room_element = getattr(DrawableElement, f"ROOM_{room_id}")
+            color_key = SupportedColor.room_key(room_id - 1)
+            alpha_key = f"alpha_room_{room_id - 1}"
+
+            if color_key in device_info:
+                rgb = device_info[color_key]
+                alpha = device_info.get(alpha_key, 255.0)
+
+                # Create RGBA color
+                rgba = (*rgb, int(alpha))
+
+                # Update color and opacity
+                self.set_property(room_element, "color", rgba)
+                self.set_property(room_element, "opacity", alpha / 255.0)
+
+                LOGGER.debug(
+                    "Updated room %d color to %s with alpha %s", room_id, rgb, alpha
+                )
+
+        # Update other element colors
+        for element, color_key in element_color_mapping.items():
+            if color_key in device_info:
+                rgb = device_info[color_key]
+                alpha_key = f"alpha_{color_key}"
+                alpha = device_info.get(alpha_key, 255.0)
+
+                # Special case for semi-transparent elements
+                if element in [
+                    DrawableElement.RESTRICTED_AREA,
+                    DrawableElement.NO_MOP_AREA,
+                    DrawableElement.PREDICTED_PATH,
+                ]:
+                    if alpha > 200:  # If alpha is too high for these elements
+                        alpha = 125.0  # Use a more appropriate default
+
+                # Create RGBA color
+                rgba = (*rgb, int(alpha))
+
+                # Update color and opacity
+                self.set_property(element, "color", rgba)
+                self.set_property(element, "opacity", alpha / 255.0)
+
+                LOGGER.debug(
+                    "Updated element %s color to %s with alpha %s",
+                    element.name,
+                    rgb,
+                    alpha,
+                )
+
+        # Check for disabled elements using specific boolean flags
+        # Map element disable flags to DrawableElement enum values
+        element_disable_mapping = {
+            "disable_floor": DrawableElement.FLOOR,
+            "disable_wall": DrawableElement.WALL,
+            "disable_robot": DrawableElement.ROBOT,
+            "disable_charger": DrawableElement.CHARGER,
+            "disable_virtual_walls": DrawableElement.VIRTUAL_WALL,
+            "disable_restricted_areas": DrawableElement.RESTRICTED_AREA,
+            "disable_no_mop_areas": DrawableElement.NO_MOP_AREA,
+            "disable_obstacles": DrawableElement.OBSTACLE,
+            "disable_path": DrawableElement.PATH,
+            "disable_predicted_path": DrawableElement.PREDICTED_PATH,
+            "disable_go_to_target": DrawableElement.GO_TO_TARGET,
+        }
+
+        # Process base element disable flags
+        for disable_key, element in element_disable_mapping.items():
+            if device_info.get(disable_key, False):
+                self.disable_element(element)
+                LOGGER.info(
+                    "Disabled %s element from device_info setting", element.name
+                )
+
+        # Process room disable flags (1-15)
+        for room_id in range(1, 16):
+            disable_key = f"disable_room_{room_id}"
+            if device_info.get(disable_key, False):
+                room_element = getattr(DrawableElement, f"ROOM_{room_id}")
+                self.disable_element(room_element)
+                LOGGER.info(
+                    "Disabled ROOM_%d element from device_info setting", room_id
+                )