python-roborock 6.0.0__tar.gz → 6.2.0__tar.gz

{python_roborock-6.0.0 → python_roborock-6.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-roborock
-Version: 6.0.0
+Version: 6.2.0
 Summary: A package to control Roborock vacuums.
 Project-URL: Repository, https://github.com/python-roborock/python-roborock
 Project-URL: Documentation, https://python-roborock.readthedocs.io/

{python_roborock-6.0.0 → python_roborock-6.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-roborock"
-version = "6.0.0"
+version = "6.2.0"
 description = "A package to control Roborock vacuums."
 authors = [{ name = "humbertogontijo", email = "humbertogontijo@users.noreply.github.com" }, {name="Lash-L"}, {name="allenporter"}]
 requires-python = ">=3.11, <4"

{python_roborock-6.0.0 → python_roborock-6.2.0}/roborock/data/code_mappings.py

@@ -10,10 +10,22 @@ completed_warnings = set()
 class RoborockEnum(IntEnum):
     """Roborock Enum for codes with int values"""
 
+    _display_name_: str | None
+
+    def __new__(cls, value: int, display_name: str | None = None) -> Self:
+        member = int.__new__(cls, value)
+        member._value_ = value
+        member._display_name_ = display_name
+        return member
+
     @property
     def name(self) -> str:
         return super().name.lower()
 
+    @property
+    def display_name(self) -> str:
+        return self._display_name_ or self.name
+
     @classmethod
     def _missing_(cls: type[Self], key) -> Self:
         if hasattr(cls, "unknown"):
@@ -30,8 +42,13 @@ class RoborockEnum(IntEnum):
         return default_value
 
     @classmethod
-    def as_dict(cls: type[Self]):
-        return {i.name: i.value for i in cls if i.name != "missing"}
+    def as_dict(cls: type[Self]) -> dict[str, int]:
+        result: dict[str, int] = {}
+        for item in cls:
+            if item.name == "missing":
+                continue
+            result.setdefault(item.display_name, item.value)
+        return result
 
     @classmethod
     def as_enum_dict(cls: type[Self]):

{python_roborock-6.0.0 → python_roborock-6.2.0}/roborock/data/dyad/dyad_code_mappings.py

@@ -95,7 +95,7 @@ class DyadError(RoborockEnum):
     battery_temperature_protection = (
         20007  # Battery temperature protection. Wait for the temperature to return to a normal range.
     )
-    battery_temperature_protection_2 = 20008
+    battery_temperature_protection_2 = (20008, "battery_temperature_protection")
     power_adapter_error = 20009  # Check if the power adapter is working properly.
     dirty_charging_contacts = 10007  # Disconnection between the device and dock. Wipe charging contacts.
     low_battery = 20017  # Low battery level. Charge before starting self-cleaning.

{python_roborock-6.0.0 → python_roborock-6.2.0}/roborock/data/v1/v1_code_mappings.py

@@ -8,40 +8,40 @@ class RoborockFinishReason(RoborockEnum):
     manual_interrupt = 21  # Cleaning interrupted by user
     cleanup_interrupted = 24  # Cleanup interrupted
     manual_interrupt_2 = 21
-    manual_interrupt_12 = 29
+    manual_interrupt_12 = (29, "manual_interrupt")
     breakpoint = 32  # Could not continue cleaning
-    breakpoint_2 = 33
-    cleanup_interrupted_2 = 34
-    manual_interrupt_3 = 35
-    manual_interrupt_4 = 36
-    manual_interrupt_5 = 37
-    manual_interrupt_6 = 43
+    breakpoint_2 = (33, "breakpoint")
+    cleanup_interrupted_2 = (34, "cleanup_interrupted")
+    manual_interrupt_3 = (35, "manual_interrupt")
+    manual_interrupt_4 = (36, "manual_interrupt")
+    manual_interrupt_5 = (37, "manual_interrupt")
+    manual_interrupt_6 = (43, "manual_interrupt")
     locate_fail = 45  # Positioning Failed
-    cleanup_interrupted_3 = 64
-    locate_fail_2 = 65
-    manual_interrupt_7 = 48
-    manual_interrupt_8 = 49
-    manual_interrupt_9 = 50
-    cleanup_interrupted_4 = 51
+    cleanup_interrupted_3 = (64, "cleanup_interrupted")
+    locate_fail_2 = (65, "locate_fail")
+    manual_interrupt_7 = (48, "manual_interrupt")
+    manual_interrupt_8 = (49, "manual_interrupt")
+    manual_interrupt_9 = (50, "manual_interrupt")
+    cleanup_interrupted_4 = (51, "cleanup_interrupted")
     finished_cleaning = 52  # Finished cleaning
-    finished_cleaning_2 = 54
-    finished_cleaning_3 = 55
-    finished_cleaning_4 = 56
-    finished_clenaing_5 = 57
-    manual_interrupt_10 = 60
+    finished_cleaning_2 = (54, "finished_cleaning")
+    finished_cleaning_3 = (55, "finished_cleaning")
+    finished_cleaning_4 = (56, "finished_cleaning")
+    finished_clenaing_5 = (57, "finished_cleaning")
+    manual_interrupt_10 = (60, "manual_interrupt")
     area_unreachable = 61  # Area unreachable
-    area_unreachable_2 = 62
+    area_unreachable_2 = (62, "area_unreachable")
     washing_error = 67  # Washing error
     back_to_wash_failure = 68  # Failed to return to the dock
-    cleanup_interrupted_5 = 101
-    breakpoint_4 = 102
-    manual_interrupt_11 = 103
-    cleanup_interrupted_6 = 104
-    cleanup_interrupted_7 = 105
-    cleanup_interrupted_8 = 106
-    cleanup_interrupted_9 = 107
-    cleanup_interrupted_10 = 109
-    cleanup_interrupted_11 = 110
+    cleanup_interrupted_5 = (101, "cleanup_interrupted")
+    breakpoint_4 = (102, "breakpoint")
+    manual_interrupt_11 = (103, "manual_interrupt")
+    cleanup_interrupted_6 = (104, "cleanup_interrupted")
+    cleanup_interrupted_7 = (105, "cleanup_interrupted")
+    cleanup_interrupted_8 = (106, "cleanup_interrupted")
+    cleanup_interrupted_9 = (107, "cleanup_interrupted")
+    cleanup_interrupted_10 = (109, "cleanup_interrupted")
+    cleanup_interrupted_11 = (110, "cleanup_interrupted")
     patrol_success = 114  # Cruise completed
     patrol_fail = 115  # Cruise failed
     pet_patrol_success = 116  # Pet found
@@ -159,7 +159,7 @@ class ClearWaterBoxStatus(RoborockDssCodes):
 
     okay = 0
     out_of_water = 1
-    out_of_water_2 = 38
+    out_of_water_2 = (38, "out_of_water")
     refill_error = 48
 
 
@@ -168,7 +168,7 @@ class DirtyWaterBoxStatus(RoborockDssCodes):
 
     okay = 0
     full_not_installed = 1
-    full_not_installed_2 = 39
+    full_not_installed_2 = (39, "full_not_installed")
     drain_error = 49
 
 
@@ -232,7 +232,7 @@ class RoborockErrorCode(RoborockEnum):
     clear_brush_exception = 42  # Check that the water filter has been correctly installed
     clear_brush_exception_2 = 43  # Positioning button error
     filter_screen_exception = 44  # Clean the dock water filter
-    mopping_roller_2 = 45  # Wash roller may be jammed
+    mopping_roller_2 = (45, "mopping_roller_1")  # Wash roller may be jammed
     up_water_exception = 48
     drain_water_exception = 49
     temperature_protection = 51  # Unit temperature protection
@@ -421,7 +421,7 @@ class RoborockStateCode(RoborockEnum):
     segment_cleaning = 18
     emptying_the_bin = 22  # on s7+
     washing_the_mop = 23  # on a46
-    washing_the_mop_2 = 25
+    washing_the_mop_2 = (25, "washing_the_mop")
     going_to_wash_the_mop = 26  # on a46
     in_call = 28
     mapping = 29

{python_roborock-6.0.0 → python_roborock-6.2.0}/roborock/data/v1/v1_containers.py

@@ -144,11 +144,11 @@ class StatusV2(RoborockBase):
 
     @property
     def error_code_name(self) -> str | None:
-        return self.error_code.name if self.error_code is not None else None
+        return self.error_code.display_name if self.error_code is not None else None
 
     @property
     def state_name(self) -> str | None:
-        return self.state.name if self.state is not None else None
+        return self.state.display_name if self.state is not None else None
 
     @property
     def current_map(self) -> int | None:

{python_roborock-6.0.0 → python_roborock-6.2.0}/roborock/map/b01_q10_map_parser.py

@@ -19,13 +19,13 @@ documentation that informed this clean-room implementation comes from the
 https://github.com/v1b3c0d3x3r/roborock-qseries-map-bridge
 """
 
-import colorsys
 import io
 import math
 import statistics
 from dataclasses import dataclass, field, replace
 
 from PIL import Image
+from vacuum_map_parser_base.config.color import ColorsPalette, SupportedColor
 from vacuum_map_parser_base.config.image_config import ImageConfig
 from vacuum_map_parser_base.map_data import ImageData, MapData
 
@@ -40,6 +40,7 @@ from .b01_grid_layers import (
     decompose_grid,
 )
 from .map_parser import ParsedMapData
+from .room_colors import adjacency_aware_room_colors
 
 _MAP_FILE_FORMAT = "PNG"
 
@@ -655,12 +656,12 @@ class B01Q10MapParser:
         return ParsedMapData(image_content=image_bytes.getvalue(), map_data=map_data)
 
     def _render(self, packet: Q10MapPacket) -> Image.Image:
-        """Render the Q10 grid: rooms get distinct colors, walls white, rest dark."""
-        palette = _build_palette(packet.grid)
-        rgb = bytearray()
+        """Render the Q10 grid with the V1 map palette."""
+        palette = _build_palette(packet.grid, packet.width)
+        rgba = bytearray()
         for value in packet.grid:
-            rgb.extend(palette[value])
-        img = Image.frombytes("RGB", (packet.width, packet.height), bytes(rgb))
+            rgba.extend(palette[value])
+        img = Image.frombytes("RGBA", (packet.width, packet.height), bytes(rgba))
         # The ss07 grid is stored top-down (row 0 = top of the home), so it is
         # rendered as-is -- unlike the V1/Q7 convention, no vertical flip.
         scale = self._config.map_scale
@@ -669,15 +670,32 @@ class B01Q10MapParser:
         return img
 
 
-def _build_palette(grid: bytes) -> list[tuple[int, int, int]]:
-    """Map each grid value to an RGB color (rooms distinct, walls white)."""
-    palette: list[tuple[int, int, int]] = [(28, 30, 38)] * 256  # default: unknown/outside
-    room_values = sorted({v for v in set(grid) if 0 < v < _WALL_THRESHOLD})
-    for index, value in enumerate(room_values):
-        hue = (index * 0.139) % 1.0
-        r, g, b = colorsys.hsv_to_rgb(hue, 0.5, 0.95)
-        palette[value] = (int(r * 255), int(g * 255), int(b * 255))
+def _opaque(color: tuple[int, ...]) -> tuple[int, int, int, int]:
+    """Return a palette color as RGBA."""
+    return (color[0], color[1], color[2], color[3] if len(color) == 4 else 255)
+
+
+def _build_palette(grid: bytes, width: int) -> list[tuple[int, int, int, int]]:
+    """Map Q10 cells onto the same colors used by the V1 map renderer."""
+
+    def room_id(value: int) -> int | None:
+        return max(1, value // 4) if 0 < value < _WALL_THRESHOLD else None
+
+    colors = ColorsPalette()
+    room_colors = adjacency_aware_room_colors(
+        grid,
+        width,
+        colors,
+        room_id,
+    )
+    outside = (0, 0, 0, 0)
+    palette = [outside] * 256
+    for value in {value for value in grid if 0 < value < _WALL_THRESHOLD}:
+        palette[value] = _opaque(room_colors[max(1, value // 4)])
+    wall = _opaque(colors.get_color(SupportedColor.GREY_WALL))
     for value in range(_WALL_THRESHOLD, 256):
-        palette[value] = (235, 235, 240)  # walls / borders
-    palette[0] = (28, 30, 38)
+        palette[value] = wall
+    palette[_UNSEGMENTED_FLOOR_VALUE] = _opaque(colors.get_color(SupportedColor.MAP_INSIDE))
+    palette[_BACKGROUND_VALUE] = outside
+    palette[0] = outside
     return palette

{python_roborock-6.0.0 → python_roborock-6.2.0}/roborock/map/map_parser.py

@@ -2,6 +2,7 @@
 
 import io
 import logging
+import threading
 from dataclasses import dataclass, field
 
 from vacuum_map_parser_base.config.color import ColorsPalette, SupportedColor
@@ -9,10 +10,13 @@ from vacuum_map_parser_base.config.drawable import Drawable
 from vacuum_map_parser_base.config.image_config import ImageConfig
 from vacuum_map_parser_base.config.size import Size, Sizes
 from vacuum_map_parser_base.map_data import MapData
+from vacuum_map_parser_roborock.image_parser import RoborockImageParser
 from vacuum_map_parser_roborock.map_data_parser import RoborockMapDataParser
 
 from roborock.exceptions import RoborockException
 
+from .room_colors import adjacency_aware_room_colors
+
 _LOGGER = logging.getLogger(__name__)
 
 DEFAULT_DRAWABLES = {
@@ -98,6 +102,52 @@ class MapParser:
         return ParsedMapData(image_content=img_byte_arr.getvalue(), map_data=parsed_map)
 
 
+class _AdjacencyAwareRoborockImageParser(RoborockImageParser):
+    """Apply the shared adjacency color policy to V1 room cells."""
+
+    def __init__(
+        self,
+        palette: ColorsPalette,
+        image_config: ImageConfig,
+        *,
+        recolor_rooms: bool = True,
+    ) -> None:
+        super().__init__(palette, image_config)
+        self._room_palette = palette
+        self._base_room_colors = palette.cached_room_colors.copy()
+        self._recolor_rooms = recolor_rooms
+        self._palette_lock = threading.Lock()
+
+    def parse(
+        self,
+        raw_data: bytes,
+        width: int,
+        height: int,
+        carpet_map: set[int] | None,
+        removed_map: set[int] | None = None,
+    ):
+        """Assign non-conflicting room colors before the V1 image pass."""
+        with self._palette_lock:
+            # cached_room_colors is a read-only property, so reset its dict in place.
+            cached_room_colors = self._room_palette.cached_room_colors
+            cached_room_colors.clear()
+            cached_room_colors.update(self._base_room_colors)
+
+            if self._recolor_rooms:
+
+                def room_id(value: int) -> int | None:
+                    if value in (self.MAP_OUTSIDE, self.MAP_WALL, self.MAP_INSIDE, self.MAP_SCAN):
+                        return None
+                    return self._get_room_number(value) if value & 0x07 == 0x07 else None
+
+                room_colors = adjacency_aware_room_colors(raw_data, width, self._room_palette, room_id)
+                for number, color in room_colors.items():
+                    # ColorsPalette caches both forms for get_room_color(str | int).
+                    cached_room_colors[number] = color
+                    cached_room_colors[str(number)] = color
+            return super().parse(raw_data, width, height, carpet_map, removed_map)
+
+
 def _create_map_data_parser(config: MapParserConfig) -> RoborockMapDataParser:
     """Create a RoborockMapDataParser based on the config entry."""
     color_dicts = {}
@@ -114,10 +164,18 @@ def _create_map_data_parser(config: MapParserConfig) -> RoborockMapDataParser:
     if not config.show_rooms:
         room_colors = {str(x): (0, 0, 0, 0) for x in range(1, 32)}
 
-    return RoborockMapDataParser(
-        ColorsPalette(color_dicts, room_colors),
+    palette = ColorsPalette(color_dicts, room_colors)
+    image_config = ImageConfig(scale=config.map_scale)
+    parser = RoborockMapDataParser(
+        palette,
         Sizes({k: v * config.map_scale for k, v in Sizes.SIZES.items() if k != Size.MOP_PATH_WIDTH}),
         config.drawables,
-        ImageConfig(scale=config.map_scale),
+        image_config,
         [],
     )
+    parser._image_parser = _AdjacencyAwareRoborockImageParser(
+        palette,
+        image_config,
+        recolor_rooms=config.show_rooms,
+    )
+    return parser

python_roborock-6.2.0/roborock/map/room_colors.py

@@ -0,0 +1,59 @@
+"""Deterministic room colors that keep adjacent segments distinguishable."""
+
+from collections.abc import Callable, Sequence
+
+from vacuum_map_parser_base.config.color import Color, ColorsPalette
+
+RoomIdFromCell = Callable[[int], int | None]
+
+
+def adjacency_aware_room_colors(
+    grid: Sequence[int],
+    width: int,
+    palette: ColorsPalette,
+    room_id_from_cell: RoomIdFromCell,
+) -> dict[int, Color]:
+    """Return room colors, changing only adjacent same-color conflicts.
+
+    Room IDs remain the stable preference, matching the existing V1 palette.
+    When two rooms sharing an edge resolve to the same RGB value, the
+    higher-numbered room receives the first palette color not already used by
+    one of its colored neighbors.
+    """
+    if width <= 0:
+        return {}
+
+    room_ids: set[int] = set()
+    neighbors: dict[int, set[int]] = {}
+    for index, value in enumerate(grid):
+        room_id = room_id_from_cell(value)
+        if room_id is None:
+            continue
+        room_ids.add(room_id)
+        neighbors.setdefault(room_id, set())
+
+        for neighbor_index in (index - 1 if index % width else -1, index - width):
+            if neighbor_index < 0:
+                continue
+            neighbor_id = room_id_from_cell(grid[neighbor_index])
+            if neighbor_id is None or neighbor_id == room_id:
+                continue
+            neighbors[room_id].add(neighbor_id)
+            neighbors.setdefault(neighbor_id, set()).add(room_id)
+
+    candidates: list[Color] = []
+    for palette_id in map(int, ColorsPalette.ROOM_COLORS):
+        color = palette.get_room_color(palette_id)
+        if color not in candidates:
+            candidates.append(color)
+
+    assigned: dict[int, Color] = {}
+    for room_id in sorted(room_ids):
+        preferred = palette.get_room_color(room_id)
+        neighbor_colors = {assigned[neighbor] for neighbor in neighbors[room_id] if neighbor in assigned}
+        assigned[room_id] = (
+            preferred
+            if preferred not in neighbor_colors
+            else next((color for color in candidates if color not in neighbor_colors), preferred)
+        )
+    return assigned