Add Pydantic support for message handling and update dependencies

Author: grongierisc

pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools", "wheel"]
 
 [project]
 name = "iris_pex_embedded_python"
-version = "3.3.2"
+version = "3.4.0"
 description = "Iris Interoperability based on Embedded Python"
 readme = "README.md"
 authors = [
@@ -28,6 +28,7 @@ classifiers = [
 
 dependencies = [
     "dacite >=1.6.0",
+    "pydantic>=2.0.0",
     "xmltodict>=0.12.0",
     "iris-embedded-python-wrapper>=0.0.6",
     "setuptools>=40.8.0",

requirements-dev.txt

@@ -9,4 +9,5 @@ wheel
 twine
 iris-embedded-python-wrapper
 dc-schema
-jsonpath-ng
+jsonpath-ng
+pydantic>=2.0.0

src/iop/__init__.py

@@ -4,6 +4,7 @@
 from iop._director import _Director
 from iop._inbound_adapter import _InboundAdapter
 from iop._message import _Message
+from iop._pydantic_message import _PydanticMessage
 from iop._outbound_adapter import _OutboundAdapter
 from iop._pickle_message import _PickleMessage
 from iop._private_session_duplex import _PrivateSessionDuplex
@@ -21,4 +22,5 @@ class DuplexOperation(_PrivateSessionDuplex): pass
 class DuplexProcess(_PrivateSessionProcess): pass
 class Message(_Message): pass
 class PickleMessage(_PickleMessage): pass
+class PydanticMessage(_PydanticMessage): pass
 class Director(_Director): pass

src/iop/_dispatch.py

@@ -7,6 +7,7 @@
 
 import iris
 from dacite import Config, from_dict
+from pydantic import BaseModel
 
 from iop._utils import _Utils
 from iop._serialization import IrisJSONEncoder, IrisJSONDecoder
@@ -165,17 +166,20 @@ def dataclass_from_dict(klass: Type, dikt: Dict) -> Any:
     Returns:
         A dataclass object with the fields of the dataclass and the fields of the dictionary.
     """
-    ret = from_dict(klass, dikt, Config(check_types=False))
-    
-    try:
-        fieldtypes = klass.__annotations__
-    except Exception as e:
-        fieldtypes = []
-    
-    for key, val in dikt.items():
-        if key not in fieldtypes:
-            setattr(ret, key, val)
-    return ret
+    if issubclass(klass, BaseModel):
+        return klass.model_validate(dikt)
+    else:
+        ret = from_dict(klass, dikt, Config(check_types=False))
+        
+        try:
+            fieldtypes = klass.__annotations__
+        except Exception as e:
+            fieldtypes = []
+        
+        for key, val in dikt.items():
+            if key not in fieldtypes:
+                setattr(ret, key, val)
+        return ret
 
 def dispach_message(host, request: Any) -> Any:
     """Dispatches the message to the appropriate method.

src/iop/_message_validator.py

@@ -1,9 +1,13 @@
 import dataclasses
 from typing import Any, Type
+from pydantic import BaseModel
+from iop._message import _Message
 
 
 def is_message_instance(obj: Any) -> bool:
     """Check if object is a valid Message instance."""
+    if isinstance(obj, BaseModel):
+        return True
     if is_message_class(type(obj)):
         if not dataclasses.is_dataclass(obj):
             raise TypeError(f"{type(obj).__module__}.{type(obj).__qualname__} must be a dataclass")
@@ -27,10 +31,12 @@ def is_iris_object_instance(obj: Any) -> bool:
 
 def is_message_class(klass: Type) -> bool:
     """Check if class is a Message type."""
-    name = f"{klass.__module__}.{klass.__qualname__}"
-    if name in ("iop.Message", "grongier.pex.Message"): 
+    if issubclass(klass, BaseModel):
+        return True
+    if issubclass(klass, _Message):
         return True
-    return any(is_message_class(c) for c in klass.__bases__)
+    return False
+
 
 
 def is_pickle_message_class(klass: Type) -> bool:

src/iop/_pydantic_message.py

@@ -0,0 +1,9 @@
+
+from typing import Any
+from pydantic import BaseModel
+
+class _PydanticMessage(BaseModel):
+    """Base class for Pydantic-based messages that can be serialized to IRIS."""
+    
+    def __init__(self, **data: Any):
+        super().__init__(**data)

src/iop/_serialization.py

@@ -15,6 +15,7 @@
 import iris
 
 from iop._utils import _Utils
+from pydantic import BaseModel
 
 # Constants
 DATETIME_FORMAT_LENGTH = 23
@@ -91,6 +92,8 @@ class IrisJSONEncoder(json.JSONEncoder):
     """JSONEncoder that handles dates, decimals, UUIDs, etc."""
 
     def default(self, obj: Any) -> Any:
+        if isinstance(obj, BaseModel):
+            return obj.model_dump()
         if obj.__class__.__name__ == 'DataFrame':
             return f'dataframe:{TypeConverter.convert_to_string("dataframe", obj)}'
         elif isinstance(obj, datetime.datetime):
@@ -134,6 +137,9 @@ class MessageSerializer:
     @staticmethod
     def serialize(message: Any, use_pickle: bool = False) -> iris.cls:
         """Serializes a message to IRIS format."""
+        if isinstance(message, BaseModel):
+            return (MessageSerializer._serialize_pickle(message) 
+                   if use_pickle else MessageSerializer._serialize_json(message))
         if use_pickle:
             return MessageSerializer._serialize_pickle(message)
         return MessageSerializer._serialize_json(message)
@@ -155,7 +161,11 @@ def _serialize_pickle(message: Any) -> iris.cls:
 
     @staticmethod
     def _serialize_json(message: Any) -> iris.cls:
-        json_string = json.dumps(message, cls=IrisJSONEncoder, ensure_ascii=False)
+        if isinstance(message, BaseModel):
+            json_string = json.dumps(message.model_dump(), cls=IrisJSONEncoder, ensure_ascii=False)
+        else:
+            json_string = json.dumps(message, cls=IrisJSONEncoder, ensure_ascii=False)
+            
         msg = iris.cls('IOP.Message')._New()
         msg.classname = f"{message.__class__.__module__}.{message.__class__.__name__}"
 
@@ -187,7 +197,10 @@ def _deserialize_json(serial: iris.cls) -> Any:
 
         try:
             json_dict = json.loads(json_string, cls=IrisJSONDecoder)
-            return dataclass_from_dict(msg_class, json_dict)
+            if issubclass(msg_class, BaseModel):
+                return msg_class.model_validate(json_dict)
+            else:
+                return dataclass_from_dict(msg_class, json_dict)
         except Exception as e:
             raise SerializationError(f"Failed to deserialize JSON: {str(e)}")
 

src/tests/bench/msg.py

@@ -1,6 +1,10 @@
-from grongier.pex import Message
+from iop import PydanticMessage
+from iop import Message
 from dataclasses import dataclass
 
 @dataclass
 class MyMessage(Message):
+    message : str = None
+
+class MyPydanticMessage(PydanticMessage):
     message : str = None

src/tests/test_bench.py

@@ -29,6 +29,18 @@ class TestBenchIoP:
             'message_type': 'msg.MyMessage',
             'use_json': True
         },
+        {
+            'name': 'Python BP to Python BO with Python Pydantic Message',
+            'component': 'Python.BenchIoPProcess',
+            'message_type': 'msg.MyPydanticMessage',
+            'use_json': True
+        },
+        {
+            'name': 'Python BP to ObjetScript BO with Python Pydantic Message',
+            'component': 'Python.BenchIoPProcess.To.Cls',
+            'message_type': 'msg.MyPydanticMessage',
+            'use_json': True
+        },
         {
             'name': 'ObjetScript BP to Python BO with Iris Message',
             'component': 'Bench.Process',
@@ -52,6 +64,18 @@ class TestBenchIoP:
             'component': 'Bench.Process.To.Cls',
             'message_type': 'msg.MyMessage',
             'use_json': True
+        },
+        {
+            'name': 'ObjetScript BP to Python BO with Python Pydantic Message',
+            'component': 'Bench.Process',
+            'message_type': 'msg.MyPydanticMessage',
+            'use_json': True
+        },
+        {
+            'name': 'ObjetScript BP to ObjetScript BO with Python Pydantic Message',
+            'component': 'Bench.Process.To.Cls',
+            'message_type': 'msg.MyPydanticMessage',
+            'use_json': True
         }
     ]