python-roborock 2.48.0__tar.gz → 2.49.0__tar.gz

{python_roborock-2.48.0 → python_roborock-2.49.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-roborock
-Version: 2.48.0
+Version: 2.49.0
 Summary: A package to control Roborock vacuums.
 Home-page: https://github.com/humbertogontijo/python-roborock
 License: GPL-3.0-only

{python_roborock-2.48.0 → python_roborock-2.49.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-roborock"
-version = "2.48.0"
+version = "2.49.0"
 description = "A package to control Roborock vacuums."
 authors = ["humbertogontijo <humbertogontijo@users.noreply.github.com>"]
 license = "GPL-3.0-only"

{python_roborock-2.48.0 → python_roborock-2.49.0}/roborock/clean_modes.py

@@ -1,11 +1,10 @@
 from __future__ import annotations
 
-from roborock import DeviceFeatures
-
 from .code_mappings import RoborockModeEnum
+from .device_features import DeviceFeatures
 
 
-class CleanModes(RoborockModeEnum):
+class VacuumModes(RoborockModeEnum):
     GENTLE = ("gentle", 105)
     OFF = ("off", 105)
     QUIET = ("quiet", 101)
@@ -27,7 +26,7 @@ class CleanRoutes(RoborockModeEnum):
     CUSTOMIZED = ("custom", 302)
 
 
-class CleanModesOld(RoborockModeEnum):
+class VacuumModesOld(RoborockModeEnum):
     QUIET = ("quiet", 38)
     BALANCED = ("balanced", 60)
     TURBO = ("turbo", 75)
@@ -48,18 +47,40 @@ class WaterModes(RoborockModeEnum):
     SMART_MODE = ("smart_mode", 209)
 
 
-def get_clean_modes(features: DeviceFeatures) -> list[CleanModes]:
+class WashTowelModes(RoborockModeEnum):
+    SMART = ("smart", 10)
+    LIGHT = ("light", 0)
+    BALANCED = ("balanced", 1)
+    DEEP = ("deep", 2)
+    SUPER_DEEP = ("super_deep", 8)
+
+
+def get_wash_towel_modes(features: DeviceFeatures) -> list[WashTowelModes]:
+    """Get the valid wash towel modes for the device"""
+    modes = [WashTowelModes.LIGHT, WashTowelModes.BALANCED, WashTowelModes.DEEP]
+    if features.is_super_deep_wash_supported and not features.is_dirty_replenish_clean_supported:
+        modes.append(WashTowelModes.SUPER_DEEP)
+    elif features.is_dirty_replenish_clean_supported:
+        modes.append(WashTowelModes.SMART)
+    return modes
+
+
+def get_clean_modes(features: DeviceFeatures) -> list[VacuumModes]:
     """Get the valid clean modes for the device - also known as 'fan power' or 'suction mode'"""
-    modes = [CleanModes.QUIET, CleanModes.BALANCED, CleanModes.TURBO, CleanModes.MAX]
+    modes = [VacuumModes.QUIET, VacuumModes.BALANCED, VacuumModes.TURBO, VacuumModes.MAX]
     if features.is_max_plus_mode_supported or features.is_none_pure_clean_mop_with_max_plus:
         # If the vacuum has max plus mode supported
-        modes.append(CleanModes.MAX_PLUS)
+        modes.append(VacuumModes.MAX_PLUS)
     if features.is_pure_clean_mop_supported:
         # If the vacuum is capable of 'pure mop clean' aka no vacuum
-        modes.append(CleanModes.OFF)
+        modes.append(VacuumModes.OFF)
     else:
         # If not, we can add gentle
-        modes.append(CleanModes.GENTLE)
+        modes.append(VacuumModes.GENTLE)
+    if features.is_smart_clean_mode_set_supported:
+        modes.append(VacuumModes.SMART_MODE)
+    if features.is_customized_clean_supported:
+        modes.append(VacuumModes.CUSTOMIZED)
     return modes
 
 
@@ -72,7 +93,7 @@ def get_clean_routes(features: DeviceFeatures, region: str) -> list[CleanRoutes]
         if not (
             features.is_corner_clean_mode_supported
             and features.is_clean_route_deep_slow_plus_supported
-            and region == "CN"
+            and region == "cn"
         ):
             # for some reason there is a china specific deep plus mode
             supported.append(CleanRoutes.DEEP_PLUS_CN)
@@ -81,6 +102,11 @@ def get_clean_routes(features: DeviceFeatures, region: str) -> list[CleanRoutes]
 
     if features.is_clean_route_fast_mode_supported:
         supported.append(CleanRoutes.FAST)
+    if features.is_smart_clean_mode_set_supported:
+        supported.append(CleanRoutes.SMART_MODE)
+    if features.is_customized_clean_supported:
+        supported.append(CleanRoutes.CUSTOMIZED)
+
     return supported
 
 
@@ -97,4 +123,18 @@ def get_water_modes(features: DeviceFeatures) -> list[WaterModes]:
         supported_modes.append(WaterModes.CUSTOM)
     if features.is_mop_shake_module_supported and features.is_mop_shake_water_max_supported:
         supported_modes.append(WaterModes.EXTREME)
+    if features.is_smart_clean_mode_set_supported:
+        supported_modes.append(WaterModes.SMART_MODE)
+    if features.is_customized_clean_supported:
+        supported_modes.append(WaterModes.CUSTOMIZED)
+
     return supported_modes
+
+
+def is_smart_mode_set(water_mode: WaterModes, clean_mode: VacuumModes, mop_mode: CleanRoutes) -> bool:
+    """Check if the smart mode is set for the given water mode and clean mode"""
+    return (
+        water_mode == WaterModes.SMART_MODE
+        or clean_mode == VacuumModes.SMART_MODE
+        or mop_mode == CleanRoutes.SMART_MODE
+    )

{python_roborock-2.48.0 → python_roborock-2.49.0}/roborock/device_features.py

@@ -116,14 +116,45 @@ DUAL_LINE_CAMERA_FEATURES = [
 NEW_DEFAULT_FEATURES = [ProductFeatures.REMOTE_BACK, ProductFeatures.CLEANMODE_MAXPLUS]
 
 
-PEARL_FEATURES = NEW_DEFAULT_FEATURES + SINGLE_LINE_CAMERA_FEATURES + [ProductFeatures.MOP_SPIN_MODULE]
+PEARL_FEATURES = SINGLE_LINE_CAMERA_FEATURES + [ProductFeatures.CLEANMODE_MAXPLUS, ProductFeatures.MOP_SPIN_MODULE]
 PEARL_PLUS_FEATURES = NEW_DEFAULT_FEATURES + RGB_CAMERA_FEATURES + [ProductFeatures.MOP_SPIN_MODULE]
 ULTRON_FEATURES = NEW_DEFAULT_FEATURES + DUAL_LINE_CAMERA_FEATURES + [ProductFeatures.MOP_SHAKE_MODULE]
 ULTRONSV_FEATURES = NEW_DEFAULT_FEATURES + RGB_CAMERA_FEATURES + [ProductFeatures.MOP_SHAKE_MODULE]
-TANOSS_FEATURES = NEW_DEFAULT_FEATURES + [ProductFeatures.MOP_SHAKE_MODULE]
-TOPAZSPOWER_FEATURES = NEW_DEFAULT_FEATURES + [ProductFeatures.MOP_SHAKE_MODULE]
+TANOSS_FEATURES = [ProductFeatures.REMOTE_BACK, ProductFeatures.MOP_SHAKE_MODULE]
+TOPAZSPOWER_FEATURES = [ProductFeatures.CLEANMODE_MAXPLUS, ProductFeatures.MOP_SHAKE_MODULE]
 
-product_feature_map = {
+PRODUCTS_WITHOUT_CUSTOM_CLEAN: set[RoborockProductNickname] = {
+    RoborockProductNickname.TANOS,
+    RoborockProductNickname.RUBYPLUS,
+    RoborockProductNickname.RUBYSC,
+    RoborockProductNickname.RUBYSE,
+}
+PRODUCTS_WITHOUT_DEFAULT_3D_MAP: set[RoborockProductNickname] = {
+    RoborockProductNickname.TANOS,
+    RoborockProductNickname.TANOSSPLUS,
+    RoborockProductNickname.TANOSE,
+    RoborockProductNickname.TANOSV,
+    RoborockProductNickname.RUBYPLUS,
+    RoborockProductNickname.RUBYSC,
+    RoborockProductNickname.RUBYSE,
+}
+PRODUCTS_WITHOUT_PURE_CLEAN_MOP: set[RoborockProductNickname] = {
+    RoborockProductNickname.TANOS,
+    RoborockProductNickname.TANOSE,
+    RoborockProductNickname.TANOSV,
+    RoborockProductNickname.TANOSSLITE,
+    RoborockProductNickname.TANOSSE,
+    RoborockProductNickname.TANOSSC,
+    RoborockProductNickname.ULTRONLITE,
+    RoborockProductNickname.ULTRONE,
+    RoborockProductNickname.RUBYPLUS,
+    RoborockProductNickname.RUBYSLITE,
+    RoborockProductNickname.RUBYSC,
+    RoborockProductNickname.RUBYSE,
+}
+
+# Base map containing the initial, unconditional features for each product.
+_BASE_PRODUCT_FEATURE_MAP: dict[RoborockProductNickname, list[ProductFeatures]] = {
     RoborockProductNickname.PEARL: PEARL_FEATURES,
     RoborockProductNickname.PEARLS: PEARL_FEATURES,
     RoborockProductNickname.PEARLPLUS: PEARL_PLUS_FEATURES,
@@ -139,7 +170,8 @@ product_feature_map = {
     RoborockProductNickname.PEARLSLITE: PEARL_FEATURES,
     RoborockProductNickname.PEARLE: PEARL_FEATURES,
     RoborockProductNickname.PEARLELITE: PEARL_FEATURES,
-    RoborockProductNickname.VIVIANC: PEARL_PLUS_FEATURES,
+    RoborockProductNickname.VIVIANC: [ProductFeatures.CLEANMODE_MAXPLUS, ProductFeatures.MOP_SPIN_MODULE]
+    + SINGLE_LINE_CAMERA_FEATURES,
     RoborockProductNickname.CORALPRO: PEARL_PLUS_FEATURES,
     RoborockProductNickname.ULTRONLITE: SINGLE_LINE_CAMERA_FEATURES
     + [ProductFeatures.CLEANMODE_NONE_PURECLEANMOP_WITH_MAXPLUS, ProductFeatures.MOP_ELECTRONIC_MODULE],
@@ -150,7 +182,7 @@ product_feature_map = {
     ],
     RoborockProductNickname.ULTRONSPLUS: ULTRON_FEATURES,
     RoborockProductNickname.VERDELITE: ULTRONSV_FEATURES,
-    RoborockProductNickname.TOPAZS: NEW_DEFAULT_FEATURES + [ProductFeatures.MOP_SHAKE_MODULE],
+    RoborockProductNickname.TOPAZS: [ProductFeatures.REMOTE_BACK, ProductFeatures.MOP_SHAKE_MODULE],
     RoborockProductNickname.TOPAZSPLUS: NEW_DEFAULT_FEATURES
     + DUAL_LINE_CAMERA_FEATURES
     + [ProductFeatures.MOP_SHAKE_MODULE],
@@ -173,6 +205,16 @@ product_feature_map = {
     RoborockProductNickname.RUBYSLITE: [ProductFeatures.MOP_ELECTRONIC_MODULE],
 }
 
+PRODUCT_FEATURE_MAP: dict[RoborockProductNickname, list[ProductFeatures]] = {
+    product: (
+        features
+        + ([ProductFeatures.DEFAULT_CLEANMODECUSTOM] if product not in PRODUCTS_WITHOUT_CUSTOM_CLEAN else [])
+        + ([ProductFeatures.DEFAULT_MAP3D] if product not in PRODUCTS_WITHOUT_DEFAULT_3D_MAP else [])
+        + ([ProductFeatures.CLEANMODE_PURECLEANMOP] if product not in PRODUCTS_WITHOUT_PURE_CLEAN_MOP else [])
+    )
+    for product, features in _BASE_PRODUCT_FEATURE_MAP.items()
+}
+
 
 @dataclass
 class DeviceFeatures:
@@ -424,6 +466,9 @@ class DeviceFeatures:
         metadata={"product_features": [ProductFeatures.MOP_SHAKE_MODULE, ProductFeatures.MOP_SPIN_MODULE]}
     )
     is_mop_shake_module_supported: bool = field(metadata={"product_features": [ProductFeatures.MOP_SHAKE_MODULE]})
+    is_customized_clean_supported: bool = field(
+        metadata={"product_features": [ProductFeatures.MOP_SHAKE_MODULE, ProductFeatures.MOP_SPIN_MODULE]}
+    )
 
     @classmethod
     def from_feature_flags(
@@ -493,7 +538,7 @@ class DeviceFeatures:
                     kwargs[f.name] = product_nickname not in blacklist
             elif (product_features := f.metadata.get("product_features")) is not None:
                 if product_nickname is not None:
-                    available_features = product_feature_map.get(product_nickname, [])
+                    available_features = PRODUCT_FEATURE_MAP.get(product_nickname, [])
                     if any(feat in available_features for feat in product_features):  # type: ignore
                         kwargs[f.name] = True
 

python_roborock-2.49.0/roborock/map/map_parser.py

@@ -0,0 +1,106 @@
+"""Module for parsing v1 Roborock map content."""
+
+import io
+import logging
+from dataclasses import dataclass, field
+
+from vacuum_map_parser_base.config.color import ColorsPalette, SupportedColor
+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.map_data_parser import RoborockMapDataParser
+
+from roborock.exceptions import RoborockException
+
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_DRAWABLES = {
+    Drawable.CHARGER: True,
+    Drawable.CLEANED_AREA: False,
+    Drawable.GOTO_PATH: False,
+    Drawable.IGNORED_OBSTACLES: False,
+    Drawable.IGNORED_OBSTACLES_WITH_PHOTO: False,
+    Drawable.MOP_PATH: False,
+    Drawable.NO_CARPET_AREAS: False,
+    Drawable.NO_GO_AREAS: False,
+    Drawable.NO_MOPPING_AREAS: False,
+    Drawable.OBSTACLES: False,
+    Drawable.OBSTACLES_WITH_PHOTO: False,
+    Drawable.PATH: True,
+    Drawable.PREDICTED_PATH: False,
+    Drawable.VACUUM_POSITION: True,
+    Drawable.VIRTUAL_WALLS: False,
+    Drawable.ZONES: False,
+}
+DEFAULT_MAP_SCALE = 4
+MAP_FILE_FORMAT = "PNG"
+
+
+def _default_drawable_factory() -> list[Drawable]:
+    return [drawable for drawable, default_value in DEFAULT_DRAWABLES.items() if default_value]
+
+
+@dataclass
+class MapParserConfig:
+    """Configuration for the Roborock map parser."""
+
+    drawables: list[Drawable] = field(default_factory=_default_drawable_factory)
+    """List of drawables to include in the map rendering."""
+
+    show_background: bool = True
+    """Whether to show the background of the map."""
+
+    map_scale: int = DEFAULT_MAP_SCALE
+    """Scale factor for the map."""
+
+
+@dataclass
+class ParsedMapData:
+    """Roborock Map Data.
+
+    This class holds the parsed map data and the rendered image.
+    """
+
+    image_content: bytes | None
+    """The rendered image of the map in PNG format."""
+
+    map_data: MapData | None
+    """The parsed map data which contains metadata for points on the map."""
+
+
+class MapParser:
+    """Roborock Map Parser.
+
+    This class is used to parse the map data from the device and render it into an image.
+    """
+
+    def __init__(self, config: MapParserConfig) -> None:
+        """Initialize the MapParser."""
+        self._map_parser = _create_map_data_parser(config)
+
+    def parse(self, map_bytes: bytes) -> ParsedMapData | None:
+        """Parse map_bytes and return MapData and the image."""
+        try:
+            parsed_map = self._map_parser.parse(map_bytes)
+        except (IndexError, ValueError) as err:
+            raise RoborockException("Failed to parse map data") from err
+        if parsed_map.image is None:
+            raise RoborockException("Failed to render map image")
+        img_byte_arr = io.BytesIO()
+        parsed_map.image.data.save(img_byte_arr, format=MAP_FILE_FORMAT)
+        return ParsedMapData(image_content=img_byte_arr.getvalue(), map_data=parsed_map)
+
+
+def _create_map_data_parser(config: MapParserConfig) -> RoborockMapDataParser:
+    """Create a RoborockMapDataParser based on the config entry."""
+    colors = ColorsPalette()
+    if not config.show_background:
+        colors = ColorsPalette({SupportedColor.MAP_OUTSIDE: (0, 0, 0, 0)})
+    return RoborockMapDataParser(
+        colors,
+        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),
+        [],
+    )