python-roborock 4.7.1__tar.gz → 4.7.2__tar.gz

{python_roborock-4.7.1 → python_roborock-4.7.2}/PKG-INFO

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

{python_roborock-4.7.1 → python_roborock-4.7.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-roborock"
-version = "4.7.1"
+version = "4.7.2"
 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-4.7.1 → python_roborock-4.7.2}/roborock/devices/traits/v1/home.py

@@ -24,7 +24,7 @@ from roborock.data import CombinedMapInfo, NamedRoomMapping, RoborockBase
 from roborock.data.v1.v1_code_mappings import RoborockStateCode
 from roborock.devices.cache import DeviceCache
 from roborock.devices.traits.v1 import common
-from roborock.exceptions import RoborockDeviceBusy, RoborockException
+from roborock.exceptions import RoborockDeviceBusy, RoborockException, RoborockInvalidStatus
 from roborock.roborock_typing import RoborockCommand
 
 from .map_content import MapContent, MapContentTrait
@@ -171,7 +171,12 @@ class HomeTrait(RoborockBase, common.V1TraitMixin):
             # We need to load each map to get its room data
             if len(sorted_map_infos) > 1:
                 _LOGGER.debug("Loading map %s", map_info.map_flag)
-                await self._maps_trait.set_current_map(map_info.map_flag)
+                try:
+                    await self._maps_trait.set_current_map(map_info.map_flag)
+                except RoborockInvalidStatus as ex:
+                    # Device is in a state that forbids map switching. Translate to
+                    # "busy" so callers can fall back to refreshing the current map only.
+                    raise RoborockDeviceBusy("Cannot switch maps right now (device action locked)") from ex
                 await asyncio.sleep(MAP_SLEEP)
 
             map_content = await self._refresh_map_content()

{python_roborock-4.7.1 → python_roborock-4.7.2}/roborock/exceptions.py

@@ -87,5 +87,9 @@ class RoborockDeviceBusy(RoborockException):
     """Class for Roborock device busy exceptions."""
 
 
+class RoborockInvalidStatus(RoborockException):
+    """Class for Roborock invalid status exceptions (device action locked)."""
+
+
 class RoborockUnsupportedFeature(RoborockException):
     """Class for Roborock unsupported feature exceptions."""

{python_roborock-4.7.1 → python_roborock-4.7.2}/roborock/protocols/v1_protocol.py

@@ -13,7 +13,7 @@ from enum import StrEnum
 from typing import Any, Protocol, TypeVar, overload
 
 from roborock.data import RoborockBase, RRiot
-from roborock.exceptions import RoborockException, RoborockUnsupportedFeature
+from roborock.exceptions import RoborockException, RoborockInvalidStatus, RoborockUnsupportedFeature
 from roborock.protocol import Utils
 from roborock.roborock_message import RoborockMessage, RoborockMessageProtocol
 from roborock.roborock_typing import RoborockCommand
@@ -106,6 +106,24 @@ class RequestMessage:
 
 ResponseData = dict[str, Any] | list | int
 
+# V1 RPC error code mappings to specific exception types
+_V1_ERROR_CODE_EXCEPTIONS: dict[int, type[RoborockException]] = {
+    -10007: RoborockInvalidStatus,  # "invalid status" - device action locked
+}
+
+
+def _create_api_error(error: Any) -> RoborockException:
+    """Create an appropriate exception for a V1 RPC error response.
+
+    Maps known error codes to specific exception types for easier handling
+    at higher levels.
+    """
+    if isinstance(error, dict):
+        code = error.get("code")
+        if isinstance(code, int) and (exc_type := _V1_ERROR_CODE_EXCEPTIONS.get(code)):
+            return exc_type(error)
+    return RoborockException(error)
+
 
 @dataclass(kw_only=True, frozen=True)
 class ResponseMessage:
@@ -154,26 +172,38 @@ def decode_rpc_response(message: RoborockMessage) -> ResponseMessage:
         ) from e
 
     request_id: int | None = data_point_response.get("id")
-    exc: RoborockException | None = None
+    api_error: RoborockException | None = None
     if error := data_point_response.get("error"):
-        exc = RoborockException(error)
+        api_error = _create_api_error(error)
+
     if (result := data_point_response.get("result")) is None:
-        exc = RoborockException(f"Invalid V1 message format: missing 'result' in data point for {message.payload!r}")
+        # Some firmware versions return an error-only response (no "result" key).
+        # Preserve that error instead of overwriting it with a parsing exception.
+        if api_error is None:
+            api_error = RoborockException(
+                f"Invalid V1 message format: missing 'result' in data point for {message.payload!r}"
+            )
+        result = {}
     else:
         _LOGGER.debug("Decoded V1 message result: %s", result)
         if isinstance(result, str):
             if result == "unknown_method":
-                exc = RoborockUnsupportedFeature("The method called is not recognized by the device.")
+                api_error = RoborockUnsupportedFeature("The method called is not recognized by the device.")
             elif result != "ok":
-                exc = RoborockException(f"Unexpected API Result: {result}")
+                api_error = RoborockException(f"Unexpected API Result: {result}")
             result = {}
         if not isinstance(result, dict | list | int):
-            raise RoborockException(
-                f"Invalid V1 message format: 'result' was unexpected type {type(result)}. {message.payload!r}"
-            )
-    if not request_id and exc:
-        raise exc
-    return ResponseMessage(request_id=request_id, data=result, api_error=exc)
+            # If we already have an API error, prefer returning a response object
+            # rather than failing to decode the message entirely.
+            if api_error is None:
+                raise RoborockException(
+                    f"Invalid V1 message format: 'result' was unexpected type {type(result)}. {message.payload!r}"
+                )
+            result = {}
+
+    if not request_id and api_error:
+        raise api_error
+    return ResponseMessage(request_id=request_id, data=result, api_error=api_error)
 
 
 @dataclass