use signature for mapping of dataclass de/serialization

Author: d-biehl

robotcode/language_server/common/lsp_types.py

@@ -4,15 +4,15 @@
 from enum import Enum, IntEnum, IntFlag
 from typing import Any, Dict, Iterator, List, Literal, Optional, Tuple, Union
 
-from ...utils.dataclasses import to_camel_case, to_snake_case, HasCaseEncoder, HasCaseDecoder
+from ...utils.dataclasses import to_camel_case, to_snake_case
 
 ProgressToken = Union[str, int]
 DocumentUri = str
 URI = str
 
 
 @dataclass
-class Model(HasCaseEncoder, HasCaseDecoder):
+class Model:
     @classmethod
     def _encode_case(cls, s: str) -> str:
         return to_camel_case(s)

robotcode/utils/dataclasses.py

@@ -1,5 +1,7 @@
+# pyright: reportMissingTypeArgument=true, reportMissingParameterType=true
 import dataclasses
 import enum
+import inspect
 import json
 import re
 from typing import (
@@ -149,6 +151,7 @@ def convert_value(value: Any, types: Union[Type[_T], Tuple[Type[_T], ...], None]
         match: Optional[Type[_T]] = None
         match_same_keys: Optional[List[str]] = None
         match_value: Optional[Dict[str, Any]] = None
+        match_signature: Optional[inspect.Signature] = None
         match_type_hints: Optional[Dict[str, Any]] = None
 
         for t in types:
@@ -159,21 +162,40 @@ def convert_value(value: Any, types: Union[Type[_T], Tuple[Type[_T], ...], None]
                 _get_config(t, HasCaseDecoder)._decode_case(k): v for k, v in value.items()  # type: ignore
             }
             type_hints = get_type_hints(origin or t)
-            same_keys = [k for k in cased_value.keys() if k in type_hints]
-            different_keys = [k for k in cased_value.keys() if k not in type_hints]
-            if same_keys and not different_keys:
-                if match_same_keys is None or len(match_same_keys) < len(same_keys):
-                    match_same_keys = same_keys
-                    match = t
-                    match_value = cased_value
-                    match_type_hints = type_hints
-                elif match_same_keys is not None and len(match_same_keys) == len(same_keys):
-                    raise TypeError(
-                        f"Value {repr(value)} matches to more then one types of "
-                        f"{repr(types[0].__name__) if len(types)==1 else ' | '.join(repr(e.__name__) for e in types)}."
-                    )
-
-        if match is not None and match_value is not None and match_type_hints is not None:
+            try:
+                signature = inspect.signature(origin or t)
+            except ValueError:
+                continue
+
+            same_keys = [k for k in cased_value.keys() if k in signature.parameters.keys()]
+            if not same_keys:
+                continue
+
+            different_keys = [k for k in cased_value.keys() if k not in signature.parameters.keys()]
+            if different_keys:
+                continue
+
+            if not all(k in same_keys for k, v in signature.parameters.items() if v.default == inspect.Parameter.empty):
+                continue
+
+            if match_same_keys is None or len(match_same_keys) < len(same_keys):
+                match_same_keys = same_keys
+                match = t
+                match_value = cased_value
+                match_signature = signature
+                match_type_hints = type_hints
+            elif match_same_keys is not None and len(match_same_keys) == len(same_keys):
+                raise TypeError(
+                    f"Value {repr(value)} matches to more then one types of "
+                    f"{repr(types[0].__name__) if len(types)==1 else ' | '.join(repr(e.__name__) for e in types)}."
+                )
+
+        if (
+            match is not None
+            and match_value is not None
+            and match_signature is not None
+            and match_type_hints is not None
+        ):
             params: Dict[str, Any] = {k: convert_value(v, match_type_hints[k]) for k, v in match_value.items()}
             try:
                 return match(**params)  # type: ignore

tests/robotcode/utils/test_dataclasses.py

@@ -1,11 +1,10 @@
+# flake8: noqa E501
 from dataclasses import dataclass
 from enum import Enum
 from typing import Any, Dict, List, Optional, Union
 
 import pytest
 
-from robotcode.utils.dataclasses import as_json, from_json, to_camel_case, to_snake_case
-
 from robotcode.language_server.common.lsp_types import (
     CallHierarchyClientCapabilities,
     ClientCapabilities,
@@ -80,6 +79,7 @@
     WorkspaceSymbolClientCapabilitiesSymbolKind,
     WorkspaceSymbolClientCapabilitiesTagSupport,
 )
+from robotcode.utils.dataclasses import as_json, from_json, to_camel_case, to_snake_case
 
 
 class EnumData(Enum):
@@ -316,23 +316,40 @@ def test_decode_with_union_and_some_same_keys() -> None:
 
 def test_decode_with_union_and_same_keys_should_raise_typeerror() -> None:
     with pytest.raises(TypeError):
-        from_json(
-            '{"a_union_field": {"a": 1, "b":2}}', ComplexItemWithUnionTypeWithSameProperties
-        ) == ComplexItemWithUnionTypeWithSameProperties(SimpleItem2(1, 2, 3))
+        from_json('{"a_union_field": {"a": 1, "b":2}}', ComplexItemWithUnionTypeWithSameProperties)
 
 
 def test_decode_with_union_and_no_keys_should_raise_typeerror() -> None:
     with pytest.raises(TypeError):
-        from_json(
-            '{"a_union_field": {}}', ComplexItemWithUnionTypeWithSameProperties
-        ) == ComplexItemWithUnionTypeWithSameProperties(SimpleItem2(1, 2, 3))
+        from_json('{"a_union_field": {}}', ComplexItemWithUnionTypeWithSameProperties)
 
 
 def test_decode_with_union_and_no_match_should_raise_typeerror() -> None:
     with pytest.raises(TypeError):
-        from_json(
-            '{"a_union_field": {"x": 1, "y":2}}', ComplexItemWithUnionTypeWithSameProperties
-        ) == ComplexItemWithUnionTypeWithSameProperties(SimpleItem2(1, 2, 3))
+        from_json('{"a_union_field": {"x": 1, "y":2}}', ComplexItemWithUnionTypeWithSameProperties)
+
+
+@dataclass
+class SimpleItem3:
+    a: int
+    b: int
+    c: int
+
+
+@pytest.mark.parametrize(
+    ("expr", "type", "expected"),
+    [
+        ('{"a":1, "b": 2}', (SimpleItem, SimpleItem3), SimpleItem(1, 2)),
+        ('{"a":1, "b": 2, "c": 3}', (SimpleItem, SimpleItem3), SimpleItem3(1, 2, 3)),
+    ],
+)
+def test_decode_with_some_same_fields(expr: Any, type: Any, expected: str) -> None:
+    assert from_json(expr, type) == expected
+
+
+def test_decode_with_some_unambigous_fields_should_raise_typeerror() -> None:
+    with pytest.raises(TypeError):
+        from_json('{"a":1, "b": 2}', (SimpleItem, SimpleItem2))  # type: ignore
 
 
 @dataclass