Refactor dataclass_from_dict to improve field processing and error handling; add tests for message serialization

Author: grongierisc

src/iop/_serialization.py

@@ -8,7 +8,7 @@
 from typing import Any, Dict, Type
 
 import iris
-from pydantic import BaseModel, TypeAdapter
+from pydantic import BaseModel, TypeAdapter, ValidationError
 
 from iop._message import _PydanticPickleMessage
 from iop._utils import _Utils
@@ -108,38 +108,42 @@ def _parse_classname(classname: str) -> tuple[str, str]:
         return classname[:j], classname[j+1:]
 
 def dataclass_from_dict(klass: Type, dikt: Dict) -> Any:
-    field_types = {
-        key: val.annotation
-        for key, val in inspect.signature(klass).parameters.items()
-    }
-    processed_dict = {}
-    for key, val in inspect.signature(klass).parameters.items():
-        if key not in dikt and val.default != val.empty:
-            processed_dict[key] = val.default
-            continue
-        
-        value = dikt.get(key)
+    """Converts a dictionary to a dataclass instance.
+    Handles non attended fields and nested dataclasses."""
+    
+    def process_field(value: Any, field_type: Type) -> Any:
         if value is None:
-            processed_dict[key] = None
+            return None
+        if is_dataclass(field_type):
+            return dataclass_from_dict(field_type, value)
+        if field_type != inspect.Parameter.empty:
+            try:
+                return TypeAdapter(field_type).validate_python(value)
+            except ValidationError:
+                return value
+        return value
+
+    # Get field definitions from class signature
+    fields = inspect.signature(klass).parameters
+    field_dict = {}
+
+    # Process each field
+    for field_name, field_info in fields.items():
+        if field_name not in dikt:
+            if field_info.default != field_info.empty:
+                field_dict[field_name] = field_info.default
             continue
-
-        try:
-            field_type = field_types[key]
-            if field_type != inspect.Parameter.empty:
-                adapter = TypeAdapter(field_type)
-                processed_dict[key] = adapter.validate_python(value)
-            else:
-                processed_dict[key] = value
-        except Exception:
-            processed_dict[key] = value
-
-    instance = klass(
-        **processed_dict
-    )
-    # handle any extra fields
-    for k, v in dikt.items():
-        if k not in processed_dict:
-            setattr(instance, k, v)
+        
+        field_dict[field_name] = process_field(dikt[field_name], field_info.annotation)
+
+    # Create instance
+    instance = klass(**field_dict)
+    
+    # Add any extra fields not in the dataclass definition
+    for key, value in dikt.items():
+        if key not in field_dict:
+            setattr(instance, key, value)
+    
     return instance
 
 def dataclass_to_dict(instance: Any) -> Dict:

src/tests/test_serialization.py

@@ -1,5 +1,6 @@
 import datetime
 import decimal
+from typing import Optional
 import uuid
 from dataclasses import dataclass
 
@@ -33,6 +34,44 @@ class FullMessge:
     data: bytes
     items: list  # Changed from df to a simple list
 
+@dataclass
+class MyObject:
+    value: str = None
+    foo: int = None
+    bar: float = 3.14
+
+@dataclass
+class Msg:
+    text: str
+    number: int
+    my_obj: MyObject
+
+def test_message_serialization():
+
+
+    msg = Msg(text="hello", number=42, my_obj=None)
+
+    my_obj = MyObject(value="test", foo=None)
+
+    # hack my_obj as a dict
+    msg.my_obj = {}
+    msg.my_obj['value'] = "test"
+    msg.my_obj['foo'] = None
+    msg.my_obj['other'] = 3.14
+
+    # Test serialization
+    serial = serialize_message(msg)
+    assert type(serial).__module__.startswith('iris') and serial._IsA("IOP.Message")
+    assert serial.classname == f"{Msg.__module__}.{Msg.__name__}"
+
+    # Test deserialization
+    result = deserialize_message(serial)
+    assert isinstance(result, Msg)
+    assert result.text == msg.text
+    assert result.number == msg.number
+    assert result.my_obj == my_obj
+
+
 def test_json_serialization():
     # Create test data
     test_items = [{'col1': 1, 'col2': 'a'}, {'col1': 2, 'col2': 'b'}]  # Simple list of dicts instead of DataFrame