python-roborock 2.53.1__tar.gz → 2.58.0__tar.gz

python_roborock-2.58.0/.gitignore

@@ -0,0 +1,21 @@
+dist
+venv
+.venv
+.idea
+roborock/__pycache__
+*.pyc
+.coverage
+
+# Sphinx documentation
+docs/_build/
+
+# mkdocs documentation
+/site
+/docs/build/
+.DS_Store
+
+# gemini-cli settings
+.gemini/
+
+# GitHub App credentials
+gha-creds-*.json

{python_roborock-2.53.1 → python_roborock-2.58.0}/PKG-INFO

@@ -1,35 +1,30 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: python-roborock
-Version: 2.53.1
+Version: 2.58.0
 Summary: A package to control Roborock vacuums.
-Home-page: https://github.com/humbertogontijo/python-roborock
-License: GPL-3.0-only
-Keywords: roborock,vacuum,homeassistant
-Author: humbertogontijo
-Author-email: humbertogontijo@users.noreply.github.com
-Requires-Python: >=3.11,<4.0
+Project-URL: Repository, https://github.com/humbertogontijo/python-roborock
+Project-URL: Documentation, https://python-roborock.readthedocs.io/
+Author: Lash-L, allenporter
+Author-email: humbertogontijo <humbertogontijo@users.noreply.github.com>
+License-Expression: GPL-3.0-only
+License-File: LICENSE
+Keywords: homeassistant,roborock,vacuum
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries
-Requires-Dist: aiohttp (>=3.8.2,<4.0.0)
-Requires-Dist: aiomqtt (>=2.3.2,<3.0.0)
-Requires-Dist: async-timeout
-Requires-Dist: click (>=8)
-Requires-Dist: click-shell (>=2.1,<3.0)
-Requires-Dist: construct (>=2.10.57,<3.0.0)
-Requires-Dist: paho-mqtt (>=1.6.1,<3.0.0)
-Requires-Dist: pycryptodome (>=3.18,<4.0)
-Requires-Dist: pycryptodomex (>=3.18,<4.0) ; sys_platform == "darwin"
-Requires-Dist: pyrate-limiter (>=3.7.0,<4.0.0)
+Requires-Python: <4,>=3.11
+Requires-Dist: aiohttp<4,>=3.8.2
+Requires-Dist: aiomqtt<3,>=2.3.2
+Requires-Dist: click-shell~=2.1
+Requires-Dist: click>=8
+Requires-Dist: construct<3,>=2.10.57
+Requires-Dist: paho-mqtt<3.0.0,>=1.6.1
+Requires-Dist: pycryptodomex~=3.18; sys_platform == 'darwin'
+Requires-Dist: pycryptodome~=3.18
+Requires-Dist: pyrate-limiter<4,>=3.7.0
 Requires-Dist: vacuum-map-parser-roborock
-Project-URL: Documentation, https://python-roborock.readthedocs.io/
-Project-URL: Repository, https://github.com/humbertogontijo/python-roborock
 Description-Content-Type: text/markdown
 
 # Roborock
@@ -108,4 +103,3 @@ Please note this may not immediately contain the latest devices.
 ## Credits
 
 Thanks @rovo89 for https://gist.github.com/rovo89/dff47ed19fca0dfdda77503e66c2b7c7 And thanks @PiotrMachowski for https://github.com/PiotrMachowski/Home-Assistant-custom-components-Xiaomi-Cloud-Map-Extractor
-

python_roborock-2.58.0/pyproject.toml

@@ -0,0 +1,100 @@
+[project]
+name = "python-roborock"
+version = "2.58.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"
+readme = "README.md"
+license = "GPL-3.0-only"
+keywords = [
+    "roborock",
+    "vacuum",
+    "homeassistant",
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Natural Language :: English",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = [
+    "click>=8",
+    "aiohttp>=3.8.2,<4",
+    "pycryptodome~=3.18",
+    "pycryptodomex~=3.18 ; sys_platform == 'darwin'",
+    "paho-mqtt>=1.6.1,<3.0.0",
+    "construct>=2.10.57,<3",
+    "vacuum-map-parser-roborock",
+    "pyrate-limiter>=3.7.0,<4",
+    "aiomqtt>=2.3.2,<3",
+    "click-shell~=2.1",
+]
+
+[project.urls]
+Repository = "https://github.com/humbertogontijo/python-roborock"
+Documentation = "https://python-roborock.readthedocs.io/"
+
+[project.scripts]
+roborock = "roborock.cli:main"
+
+[dependency-groups]
+dev = [
+    "pytest-asyncio>=1.1.0",
+    "pytest",
+    "pre-commit>=3.5,<5.0",
+    "mypy",
+    "ruff==0.14.0",
+    "codespell",
+    "pyshark>=0.6,<0.7",
+    "aioresponses>=0.7.7,<0.8",
+    "freezegun>=1.5.1,<2",
+    "pytest-timeout>=2.3.1,<3",
+    "syrupy>=4.9.1,<5",
+    "pdoc>=15.0.4,<16",
+]
+
+[tool.hatch.build.targets.sdist]
+include = ["roborock"]
+
+[tool.hatch.build.targets.wheel]
+include = ["roborock"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.semantic_release]
+branch = "main"
+version_toml = ["pyproject.toml:tool.poetry.version"]
+build_command = "pip install poetry && poetry build"
+
+[tool.semantic_release.commit_parser_options]
+allowed_tags = [
+    "chore",
+    "docs",
+    "feat",
+    "fix",
+    "refactor"
+]
+major_tags= ["refactor"]
+
+[tool.ruff]
+lint.ignore = ["F403", "E741"]
+lint.select=["E", "F", "UP", "I"]
+line-length = 120
+
+[tool.ruff.lint.per-file-ignores]
+"*/__init__.py" = ["F401"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+timeout = 30
+log_format = "%(asctime)s.%(msecs)03d %(levelname)s (%(threadName)s) [%(name)s] %(message)s"
+
+[tool.uv]
+dev-dependencies = [
+    "pyyaml>=6.0.3",
+    "pyshark>=0.6",
+]

{python_roborock-2.53.1 → python_roborock-2.58.0}/roborock/api.py

@@ -83,7 +83,7 @@ class RoborockClient(ABC):
             if response == "unknown_method":
                 raise UnknownMethodError("Unknown method")
             return response
-        except (asyncio.TimeoutError, asyncio.CancelledError):
+        except (TimeoutError, asyncio.CancelledError):
             raise RoborockTimeout(f"id={request_id} Timeout after {self.queue_timeout} seconds") from None
         finally:
             self._waiting_queue.pop(request_id, None)

{python_roborock-2.53.1 → python_roborock-2.58.0}/roborock/clean_modes.py

@@ -45,6 +45,12 @@ class WaterModes(RoborockModeEnum):
     CUSTOM = ("custom_water_flow", 207)
     EXTREME = ("extreme", 208)
     SMART_MODE = ("smart_mode", 209)
+    PURE_WATER_FLOW_START = ("slight", 221)
+    PURE_WATER_FLOW_SMALL = ("low", 225)
+    PURE_WATER_FLOW_MIDDLE = ("medium", 235)
+    PURE_WATER_FLOW_LARGE = ("moderate", 245)
+    PURE_WATER_SUPER_BEGIN = ("high", 248)
+    PURE_WATER_FLOW_END = ("extreme", 250)
 
 
 class WashTowelModes(RoborockModeEnum):
@@ -112,6 +118,18 @@ def get_clean_routes(features: DeviceFeatures, region: str) -> list[CleanRoutes]
 
 def get_water_modes(features: DeviceFeatures) -> list[WaterModes]:
     """Get the valid water modes for the device - also known as 'water flow' or 'water level'"""
+    # If the device supports water slide mode, it uses a completely different set of modes. Technically, it can even
+    # support values in between. But for now we will just support the main values.
+    if features.is_water_slide_mode_supported:
+        return [
+            WaterModes.PURE_WATER_FLOW_START,
+            WaterModes.PURE_WATER_FLOW_SMALL,
+            WaterModes.PURE_WATER_FLOW_MIDDLE,
+            WaterModes.PURE_WATER_FLOW_LARGE,
+            WaterModes.PURE_WATER_SUPER_BEGIN,
+            WaterModes.PURE_WATER_FLOW_END,
+        ]
+
     supported_modes = [WaterModes.OFF]
     if features.is_mop_shake_module_supported:
         # For mops that have the vibrating mop pad, they do mild standard intense
@@ -131,6 +149,15 @@ def get_water_modes(features: DeviceFeatures) -> list[WaterModes]:
     return supported_modes
 
 
+def is_mode_customized(clean_mode: VacuumModes, water_mode: WaterModes, mop_mode: CleanRoutes) -> bool:
+    """Check if any of the cleaning modes are set to a custom value."""
+    return (
+        clean_mode == VacuumModes.CUSTOMIZED
+        or water_mode == WaterModes.CUSTOMIZED
+        or mop_mode == CleanRoutes.CUSTOMIZED
+    )
+
+
 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 (

{python_roborock-2.53.1 → python_roborock-2.58.0}/roborock/cli.py

@@ -41,8 +41,9 @@ from pyshark import FileCapture  # type: ignore
 from pyshark.capture.live_capture import LiveCapture, UnknownInterfaceException  # type: ignore
 from pyshark.packet.packet import Packet  # type: ignore
 
-from roborock import SHORT_MODEL_TO_ENUM, DeviceFeatures, RoborockCommand, RoborockException
-from roborock.containers import DeviceData, HomeData, NetworkInfo, RoborockBase, UserData
+from roborock import SHORT_MODEL_TO_ENUM, RoborockCommand
+from roborock.containers import CombinedMapInfo, DeviceData, HomeData, NetworkInfo, RoborockBase, UserData
+from roborock.device_features import DeviceFeatures
 from roborock.devices.cache import Cache, CacheData
 from roborock.devices.device import RoborockDevice
 from roborock.devices.device_manager import DeviceManager, create_device_manager, create_home_data_api
@@ -50,6 +51,7 @@ from roborock.devices.traits import Trait
 from roborock.devices.traits.v1 import V1TraitMixin
 from roborock.devices.traits.v1.consumeable import ConsumableAttribute
 from roborock.devices.traits.v1.map_content import MapContentTrait
+from roborock.exceptions import RoborockException, RoborockUnsupportedFeature
 from roborock.protocol import MessageParser
 from roborock.version_1_apis.roborock_mqtt_client_v1 import RoborockMqttClientV1
 from roborock.web_api import RoborockApiClient
@@ -116,6 +118,7 @@ class ConnectionCache(RoborockBase):
     email: str
     home_data: HomeData | None = None
     network_info: dict[str, NetworkInfo] | None = None
+    home_cache: dict[int, CombinedMapInfo] | None = None
 
 
 class DeviceConnectionManager:
@@ -258,14 +261,21 @@ class RoborockContext(Cache):
 
     async def get(self) -> CacheData:
         """Get cached value."""
+        _LOGGER.debug("Getting cache data")
         connection_cache = self.cache_data()
-        return CacheData(home_data=connection_cache.home_data, network_info=connection_cache.network_info or {})
+        return CacheData(
+            home_data=connection_cache.home_data,
+            network_info=connection_cache.network_info or {},
+            home_cache=connection_cache.home_cache,
+        )
 
     async def set(self, value: CacheData) -> None:
         """Set value in the cache."""
+        _LOGGER.debug("Setting cache data")
         connection_cache = self.cache_data()
         connection_cache.home_data = value.home_data
         connection_cache.network_info = value.network_info
+        connection_cache.home_cache = value.home_cache
         self.update(connection_cache)
 
 
@@ -392,14 +402,21 @@ async def _v1_trait(context: RoborockContext, device_id: str, display_func: Call
     device = await device_manager.get_device(device_id)
     if device.v1_properties is None:
         raise RoborockException(f"Device {device.name} does not support V1 protocol")
-
+    await device.v1_properties.discover_features()
     trait = display_func(device.v1_properties)
     await trait.refresh()
     return trait
 
 
 async def _display_v1_trait(context: RoborockContext, device_id: str, display_func: Callable[[], Trait]) -> None:
-    trait = await _v1_trait(context, device_id, display_func)
+    try:
+        trait = await _v1_trait(context, device_id, display_func)
+    except RoborockUnsupportedFeature:
+        click.echo("Feature not supported by device")
+        return
+    except RoborockException as e:
+        click.echo(f"Error: {e}")
+        return
     click.echo(dump_json(trait.as_dict()))
 
 
@@ -523,6 +540,116 @@ async def reset_consumable(ctx, device_id: str, consumable: str):
     click.echo(f"Reset {consumable} for device {device_id}")
 
 
+@session.command()
+@click.option("--device_id", required=True)
+@click.option("--enabled", type=bool, help="Enable (True) or disable (False) the child lock.")
+@click.pass_context
+@async_command
+async def child_lock(ctx, device_id: str, enabled: bool | None):
+    """Get device child lock status."""
+    context: RoborockContext = ctx.obj
+    try:
+        trait = await _v1_trait(context, device_id, lambda v1: v1.child_lock)
+    except RoborockUnsupportedFeature:
+        click.echo("Feature not supported by device")
+        return
+    if enabled is not None:
+        if enabled:
+            await trait.enable()
+        else:
+            await trait.disable()
+        click.echo(f"Set child lock to {enabled} for device {device_id}")
+        await trait.refresh()
+
+    click.echo(dump_json(trait.as_dict()))
+
+
+@session.command()
+@click.option("--device_id", required=True)
+@click.option("--enabled", type=bool, help="Enable (True) or disable (False) the DND status.")
+@click.pass_context
+@async_command
+async def dnd(ctx, device_id: str, enabled: bool | None):
+    """Get Do Not Disturb Timer status."""
+    context: RoborockContext = ctx.obj
+    try:
+        trait = await _v1_trait(context, device_id, lambda v1: v1.dnd)
+    except RoborockUnsupportedFeature:
+        click.echo("Feature not supported by device")
+        return
+    if enabled is not None:
+        if enabled:
+            await trait.enable()
+        else:
+            await trait.disable()
+        click.echo(f"Set DND to {enabled} for device {device_id}")
+        await trait.refresh()
+
+    click.echo(dump_json(trait.as_dict()))
+
+
+@session.command()
+@click.option("--device_id", required=True)
+@click.option("--enabled", required=False, type=bool, help="Enable (True) or disable (False) the Flow LED.")
+@click.pass_context
+@async_command
+async def flow_led_status(ctx, device_id: str, enabled: bool | None):
+    """Get device Flow LED status."""
+    context: RoborockContext = ctx.obj
+    try:
+        trait = await _v1_trait(context, device_id, lambda v1: v1.flow_led_status)
+    except RoborockUnsupportedFeature:
+        click.echo("Feature not supported by device")
+        return
+    if enabled is not None:
+        if enabled:
+            await trait.enable()
+        else:
+            await trait.disable()
+        click.echo(f"Set Flow LED to {enabled} for device {device_id}")
+        await trait.refresh()
+
+    click.echo(dump_json(trait.as_dict()))
+
+
+@session.command()
+@click.option("--device_id", required=True)
+@click.option("--enabled", required=False, type=bool, help="Enable (True) or disable (False) the LED.")
+@click.pass_context
+@async_command
+async def led_status(ctx, device_id: str, enabled: bool | None):
+    """Get device LED status."""
+    context: RoborockContext = ctx.obj
+    try:
+        trait = await _v1_trait(context, device_id, lambda v1: v1.led_status)
+    except RoborockUnsupportedFeature:
+        click.echo("Feature not supported by device")
+        return
+    if enabled is not None:
+        if enabled:
+            await trait.enable()
+        else:
+            await trait.disable()
+        click.echo(f"Set LED Status to {enabled} for device {device_id}")
+        await trait.refresh()
+
+    click.echo(dump_json(trait.as_dict()))
+
+
+@session.command()
+@click.option("--device_id", required=True)
+@click.option("--enabled", required=True, type=bool, help="Enable (True) or disable (False) the child lock.")
+@click.pass_context
+@async_command
+async def set_child_lock(ctx, device_id: str, enabled: bool):
+    """Set the child lock status."""
+    context: RoborockContext = ctx.obj
+    trait = await _v1_trait(context, device_id, lambda v1: v1.child_lock)
+    await trait.set_child_lock(enabled)
+    status = "enabled" if enabled else "disabled"
+    click.echo(f"Child lock {status} for device {device_id}")
+
+
 @session.command()
 @click.option("--device_id", required=True)
 @click.pass_context
@@ -533,6 +660,52 @@ async def rooms(ctx, device_id: str):
     await _display_v1_trait(context, device_id, lambda v1: v1.rooms)
 
 
+@session.command()
+@click.option("--device_id", required=True)
+@click.pass_context
+@async_command
+async def features(ctx, device_id: str):
+    """Get device room mapping info."""
+    context: RoborockContext = ctx.obj
+    await _display_v1_trait(context, device_id, lambda v1: v1.device_features)
+
+
+@session.command()
+@click.option("--device_id", required=True)
+@click.option("--refresh", is_flag=True, default=False, help="Refresh status before discovery.")
+@click.pass_context
+@async_command
+async def home(ctx, device_id: str, refresh: bool):
+    """Discover and cache home layout (maps and rooms)."""
+    context: RoborockContext = ctx.obj
+    device_manager = await context.get_device_manager()
+    device = await device_manager.get_device(device_id)
+    if device.v1_properties is None:
+        raise RoborockException(f"Device {device.name} does not support V1 protocol")
+
+    # Ensure we have the latest status before discovery
+    await device.v1_properties.status.refresh()
+
+    home_trait = device.v1_properties.home
+    await home_trait.discover_home()
+    if refresh:
+        await home_trait.refresh()
+
+    # Display the discovered home cache
+    if home_trait.home_cache:
+        cache_summary = {
+            map_flag: {
+                "name": map_data.name,
+                "room_count": len(map_data.rooms),
+                "rooms": [{"segment_id": room.segment_id, "name": room.name} for room in map_data.rooms],
+            }
+            for map_flag, map_data in home_trait.home_cache.items()
+        }
+        click.echo(dump_json(cache_summary))
+    else:
+        click.echo("No maps discovered")
+
+
 @click.command()
 @click.option("--device_id", required=True)
 @click.option("--cmd", required=True)
@@ -541,21 +714,14 @@ async def rooms(ctx, device_id: str):
 @async_command
 async def command(ctx, cmd, device_id, params):
     context: RoborockContext = ctx.obj
-    cache_data = await context.get_devices()
-
-    home_data = cache_data.home_data
-    devices = home_data.get_all_devices()
-    device = next(device for device in devices if device.duid == device_id)
-    model = next(
-        (product.model for product in home_data.products if device is not None and product.id == device.product_id),
-        None,
-    )
-    if model is None:
-        raise RoborockException(f"Could not find model for device {device.name}")
-    device_info = DeviceData(device=device, model=model)
-    mqtt_client = RoborockMqttClientV1(cache_data.user_data, device_info)
-    await mqtt_client.send_command(cmd, json.loads(params) if params is not None else None)
-    await mqtt_client.async_release()
+    device_manager = await context.get_device_manager()
+    device = await device_manager.get_device(device_id)
+    if device.v1_properties is None:
+        raise RoborockException(f"Device {device.name} does not support V1 protocol")
+    command_trait: Trait = device.v1_properties.command
+    result = await command_trait.send(cmd, json.loads(params) if params is not None else None)
+    if result:
+        click.echo(dump_json(result))
 
 
 @click.command()
@@ -780,6 +946,12 @@ cli.add_command(map_data)
 cli.add_command(consumables)
 cli.add_command(reset_consumable)
 cli.add_command(rooms)
+cli.add_command(home)
+cli.add_command(features)
+cli.add_command(child_lock)
+cli.add_command(dnd)
+cli.add_command(flow_led_status)
+cli.add_command(led_status)
 
 
 def main():

{python_roborock-2.53.1 → python_roborock-2.58.0}/roborock/code_mappings.py

@@ -768,6 +768,40 @@ class RoborockStartType(RoborockEnum):
     smart_watch = 821
 
 
+class RoborockDssCodes(RoborockEnum):
+    @classmethod
+    def _missing_(cls: type[RoborockEnum], key) -> RoborockEnum:
+        # If the calculated value is not provided, then it should be viewed as okay.
+        # As the math will sometimes result in you getting numbers that don't matter.
+        return cls.okay  # type: ignore
+
+
+class ClearWaterBoxStatus(RoborockDssCodes):
+    """Status of the clear water box."""
+
+    okay = 0
+    out_of_water = 1
+    out_of_water_2 = 38
+    refill_error = 48
+
+
+class DirtyWaterBoxStatus(RoborockDssCodes):
+    """Status of the dirty water box."""
+
+    okay = 0
+    full_not_installed = 1
+    full_not_installed_2 = 39
+    drain_error = 49
+
+
+class DustBagStatus(RoborockDssCodes):
+    """Status of the dust bag."""
+
+    okay = 0
+    not_installed = 1
+    full = 34
+
+
 class DyadSelfCleanMode(RoborockEnum):
     self_clean = 1
     self_clean_and_dry = 2