fix: Support unknown q10 DPS enum codes

Author: allenporter

roborock/data/code_mappings.py

@@ -55,6 +55,7 @@ class RoborockModeEnum(StrEnum):
     """A custom StrEnum that also stores an integer code for each member."""
 
     code: int
+    """The integer code associated with the enum member."""
 
     def __new__(cls, value: str, code: int) -> RoborockModeEnum:
         """Creates a new enum member."""
@@ -68,7 +69,18 @@ def from_code(cls, code: int) -> RoborockModeEnum:
         for member in cls:
             if member.code == code:
                 return member
-        raise ValueError(f"{code} is not a valid code for {cls.__name__}")
+        message = f"{code} is not a valid code for {cls.__name__}"
+        if message not in completed_warnings:
+            completed_warnings.add(message)
+            _LOGGER.warning(message)
+        raise ValueError(message)
+
+    @classmethod
+    def from_code_optional(cls, code: int) -> RoborockModeEnum | None:
+        try:
+            return cls.from_code(code)
+        except ValueError:
+            return None
 
     @classmethod
     def from_value(cls, value: str) -> RoborockModeEnum:

roborock/protocols/b01_q10_protocol.py

@@ -44,12 +44,9 @@ def _convert_datapoints(datapoints: dict[str, Any], message: RoborockMessage) ->
             code = int(key)
         except ValueError as e:
             raise ValueError(f"dps key is not a valid integer: {e} for {message.payload!r}") from e
-        try:
-            dps = B01_Q10_DP.from_code(code)
-        except ValueError as e:
-            raise ValueError(f"dps key is not a valid B01_Q10_DP: {e} for {message.payload!r}") from e
-        # Update from_code to use `Self` on newer python version to remove this type ignore
-        result[dps] = value  # type: ignore[index]
+        if (dps := B01_Q10_DP.from_code_optional(code)) is not None:
+            # Update from_code to use `Self` on newer python version to remove this type ignore
+            result[dps] = value  # type: ignore[index]
     return result
 
 

tests/data/test_code_mappings.py

@@ -20,6 +20,11 @@ def test_invalid_from_code() -> None:
         B01_Q10_DP.from_code(999999)
 
 
+def test_invalid_from_code_optional() -> None:
+    """Test invalid from_code_optional method."""
+    assert B01_Q10_DP.from_code_optional(999999) is None
+
+
 def test_from_name() -> None:
     """Test from_name method."""
     assert B01_Q10_DP.START_CLEAN == B01_Q10_DP.from_name("START_CLEAN")

tests/protocols/test_b01_q10_protocol.py

@@ -58,7 +58,6 @@ def test_decode_rpc_payload(filename: str, snapshot: SnapshotAssertion) -> None:
         (b'{"dps": {"not_a_number": 123}}', "dps key is not a valid integer"),
         (b'{"dps": {"101": 123}}', "Invalid dpCommon format: expected dict"),
         (b'{"dps": {"101": {"not_a_number": 123}}}', "Invalid dpCommon format: dps key is not a valid intege"),
-        (b'{"dps": {"909090": 123}}', "dps key is not a valid B01_Q10_DP"),
     ],
 )
 def test_decode_invalid_rpc_payload(payload: bytes, expected_error_message: str) -> None:
@@ -75,6 +74,23 @@ def test_decode_invalid_rpc_payload(payload: bytes, expected_error_message: str)
         decode_rpc_response(message)
 
 
+def test_decode_unknown_dps_code() -> None:
+    """Test decoding a B01 RPC response protocol message."""
+    message = RoborockMessage(
+        protocol=RoborockMessageProtocol.RPC_RESPONSE,
+        payload=b'{"dps": {"909090": 123, "122":100}}',
+        seq=12750,
+        version=b"B01",
+        random=97431,
+        timestamp=1652547161,
+    )
+
+    decoded_message = decode_rpc_response(message)
+    assert decoded_message == {
+        B01_Q10_DP.BATTERY: 100,
+    }
+
+
 @pytest.mark.parametrize(
     ("command", "params"),
     [