python-roborock 7.12.3__tar.gz → 7.12.4__tar.gz

{python_roborock-7.12.3 → python_roborock-7.12.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: python-roborock
-Version: 7.12.3
+Version: 7.12.4
 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-7.12.3 → python_roborock-7.12.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-roborock"
-version = "7.12.3"
+version = "7.12.4"
 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-7.12.3 → python_roborock-7.12.4}/roborock/data/v1/v1_clean_modes.py

@@ -199,14 +199,20 @@ def get_water_modes(features: DeviceFeatures) -> list[WaterModes]:
 
 def get_water_slide_mode_name(code: int) -> str | None:
     """Get the app's range name for a water slide code, or None if out of range."""
+    mode = _resolve_water_slide_mode(code)
+    return mode.value if mode is not None else None
+
+
+def _resolve_water_slide_mode(code: int) -> WaterModes | None:
+    """Resolve a raw slider code to the water mode for its app range."""
     if code == 200:
-        return WaterModes.OFF.value
+        return WaterModes.OFF
     position = code - 220
     if position < 1:
         return None
     for last_position, mode in _WATER_SLIDE_RANGES:
         if position <= last_position:
-            return mode.value
+            return mode
     return None
 
 
@@ -300,7 +306,14 @@ def get_cleaning_mode_parameters(cleaning_mode: CleaningMode, features: DeviceFe
         raise RoborockUnsupportedFeature(f"Cleaning mode {cleaning_mode.value!r} is not supported")
 
     fan_power, water_box_mode, mop_mode = _get_clean_motor_mode_params(cleaning_mode, features)
-    params: dict[str, int] = {"fan_power": fan_power.code, "water_box_mode": water_box_mode.code}
+    water_code = water_box_mode.code
+    if features.is_water_slide_mode_supported:
+        # Aliased water enums retain legacy codes; the device mapping preserves
+        # slide-specific wire values without changing the user-facing names.
+        water_code = next(
+            code for code, name in get_water_mode_mapping(features).items() if name == water_box_mode.value
+        )
+    params: dict[str, int] = {"fan_power": fan_power.code, "water_box_mode": water_code}
     if features.is_clean_route_setting_supported:
         params["mop_mode"] = mop_mode.code
     return [params]
@@ -337,6 +350,8 @@ def get_current_cleaning_mode(
         return None
     clean_mode_enum = _resolve_clean_mode(clean_mode, features)
     water_mode_enum = _resolve_mode_code(water_mode, WaterModes)
+    if features.is_water_slide_mode_supported and isinstance(water_mode, int):
+        water_mode_enum = _resolve_water_slide_mode(water_mode) or water_mode_enum
     mop_mode_enum = _resolve_mode_code(mop_mode, CleanRoutes)
     if clean_mode_enum is None or water_mode_enum is None:
         return None

{python_roborock-7.12.3 → python_roborock-7.12.4}/roborock/map/b01_q10_map_parser.py

@@ -801,8 +801,8 @@ class B01Q10MapParser:
         """
         return self.parsed_from_packet(packet)
 
-    def parsed_from_packet(self, packet: Q10MapPacket) -> ParsedMapData:
-        """Render a (possibly erase-modified) packet into a PNG + ``MapData``."""
+    def map_data_from_packet(self, packet: Q10MapPacket) -> MapData:
+        """Build MapData with a rendered base image, without PNG serialization."""
         image = self._render(packet)
 
         map_data = MapData()
@@ -830,17 +830,23 @@ class B01Q10MapParser:
         if packet.carpet_mask is not None:
             map_data.carpet_map = {i for i, value in enumerate(packet.carpet_mask) if value}
 
+        return map_data
+
+    def parsed_from_packet(self, packet: Q10MapPacket) -> ParsedMapData:
+        """Render a (possibly erase-modified) packet into a PNG + ``MapData``."""
+        map_data = self.map_data_from_packet(packet)
         image_bytes = io.BytesIO()
-        image.save(image_bytes, format=_MAP_FILE_FORMAT)
+        if map_data.image is not None:
+            map_data.image.data.save(image_bytes, format=_MAP_FILE_FORMAT)
         return ParsedMapData(image_content=image_bytes.getvalue(), map_data=map_data)
 
     def _render(self, packet: Q10MapPacket) -> Image.Image:
         """Render the Q10 grid with the V1 map palette."""
         palette = _build_palette(packet.grid, packet.width)
-        rgba = bytearray()
-        for value in packet.grid:
-            rgba.extend(palette[value])
-        img = Image.frombytes("RGBA", (packet.width, packet.height), bytes(rgba))
+        flat_palette = [channel for color in palette for channel in color]
+        p_img = Image.frombytes("P", (packet.width, packet.height), packet.grid)
+        p_img.putpalette(flat_palette, rawmode="RGBA")
+        img = p_img.convert("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

{python_roborock-7.12.3 → python_roborock-7.12.4}/roborock/map/b01_q10_render.py

@@ -109,10 +109,9 @@ def render_q10_map(
             # areas disappear (as the app shows).
             render_packet = erased_packet(packet, cells)
 
-    parsed = parser.parsed_from_packet(render_packet)
-    if parsed.image_content is None or parsed.map_data is None:
+    map_data = parser.map_data_from_packet(render_packet)
+    if map_data.image is None:
         raise RoborockException("Failed to render Q10 map image")
-    map_data = parsed.map_data
 
     has_drawables = False
     if trace_calibration is not None and trace is not None:
@@ -128,7 +127,9 @@ def render_q10_map(
     if has_drawables:
         return _draw_map_content(map_data, config=config)
 
-    return parsed.image_content
+    buffer = io.BytesIO()
+    map_data.image.data.save(buffer, format="PNG")
+    return buffer.getvalue()
 
 
 def solve_q10_calibration(

{python_roborock-7.12.3 → python_roborock-7.12.4}/roborock/map/room_colors.py

@@ -23,23 +23,31 @@ def adjacency_aware_room_colors(
     if width <= 0:
         return {}
 
+    lut = [room_id_from_cell(i) for i in range(256)]
     room_ids: set[int] = set()
     neighbors: dict[int, set[int]] = {}
     for index, value in enumerate(grid):
-        room_id = room_id_from_cell(value)
+        room_id = lut[value] if 0 <= value < 256 else 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)
+        if index % width:
+            left_val = grid[index - 1]
+            if left_val != value:
+                neighbor_id = lut[left_val] if 0 <= left_val < 256 else room_id_from_cell(left_val)
+                if neighbor_id is not None and neighbor_id != room_id:
+                    neighbors[room_id].add(neighbor_id)
+                    neighbors.setdefault(neighbor_id, set()).add(room_id)
+
+        if index >= width:
+            up_val = grid[index - width]
+            if up_val != value:
+                neighbor_id = lut[up_val] if 0 <= up_val < 256 else room_id_from_cell(up_val)
+                if neighbor_id is not None and neighbor_id != room_id:
+                    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):