#30 Add get_iris_id method to Message classes and update serialization logic

- Implemented get_iris_id method in _Message and its subclasses to retrieve the IRIS ID.
- Updated MessageSerializer to handle IRIS ID during serialization and deserialization.
- Added tests for get_iris_id functionality in message classes.

Author: grongierisc

CHANGELOG.md

@@ -10,6 +10,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 - Initial support for venv
 - New `send_generator_request` method in `iop` module to send generator requests
+- Add `get_iris_id` method to `Message*` classes to retrieve the IRIS ID of a message
 
 ## [3.4.4] - 2025-06-13
 ### Added

src/iop/_message.py

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import Any, Optional
 
 from pydantic import BaseModel
 
@@ -7,7 +7,11 @@ class _Message:
     This class has no properties or methods. Users subclass Message and add properties.
     The IOP framework provides the persistence to objects derived from the Message class.
     """
-    pass
+    _iris_id: Optional[str] = None
+    
+    def get_iris_id(self) -> Optional[str]:
+        """Get the IRIS ID of the message."""
+        return self._iris_id
 
 class _PickleMessage(_Message):
     """ The abstract class that is the superclass for persistent messages sent from one component to another.
@@ -19,12 +23,18 @@ class _PickleMessage(_Message):
 class _PydanticMessage(BaseModel):
     """Base class for Pydantic-based messages that can be serialized to IRIS."""
 
+    _iris_id: Optional[str] = None
+
     def __init__(self, **data: Any):
         super().__init__(**data)
 
-class _PydanticPickleMessage(BaseModel):
+    def get_iris_id(self) -> Optional[str]:
+        """Get the IRIS ID of the message."""
+        return self._iris_id
+
+class _PydanticPickleMessage(_PydanticMessage):
     """Base class for Pydantic-based messages that can be serialized to IRIS."""
-    
+
     def __init__(self, **data: Any):
         super().__init__(**data)
 

src/iop/_serialization.py

@@ -26,19 +26,10 @@ class TempPydanticModel(BaseModel):
 class MessageSerializer:
     """Handles message serialization and deserialization."""
 
-    @staticmethod
-    def _convert_to_json_safe(obj: Any) -> Any:
-        """Convert objects to JSON-safe format."""
-        if isinstance(obj, BaseModel):
-            return obj.model_dump_json()
-        elif is_dataclass(obj) and isinstance(obj, _Message):
-            return TempPydanticModel.model_validate(dataclass_to_dict(obj)).model_dump_json()
-        else:
-            raise SerializationError(f"Object {obj} must be a Pydantic model or dataclass Message")
-
     @staticmethod
     def serialize(message: Any, use_pickle: bool = False, is_generator:bool = False) -> Any:
         """Serializes a message to IRIS format."""
+        message = remove_iris_id(message)
         if use_pickle:
             return MessageSerializer._serialize_pickle(message, is_generator)
         return MessageSerializer._serialize_json(message, is_generator)
@@ -58,12 +49,34 @@ def _serialize_json(message: Any, is_generator: bool = False) -> Any:
         else:
             msg.json = json_string
         return msg
+    
+    @staticmethod
+    def _serialize_pickle(message: Any, is_generator: bool = False) -> Any:
+        """Serializes a message to IRIS format using pickle."""
+        message = remove_iris_id(message)
+        pickle_string = codecs.encode(pickle.dumps(message), "base64").decode()
+        if is_generator:
+            msg = _iris.get_iris().cls('IOP.Generator.Message.StartPickle')._New()
+        else:
+            msg = _iris.get_iris().cls('IOP.PickleMessage')._New()
+        msg.classname = f"{message.__class__.__module__}.{message.__class__.__name__}"
+        msg.jstr = _Utils.string_to_stream(pickle_string)
+        return msg
 
     @staticmethod
     def deserialize(serial: Any, use_pickle: bool = False) -> Any:
         if use_pickle:
-            return MessageSerializer._deserialize_pickle(serial)
-        return MessageSerializer._deserialize_json(serial)
+            msg=MessageSerializer._deserialize_pickle(serial)
+        else:
+            msg=MessageSerializer._deserialize_json(serial)
+    
+        try:
+            iris_id = serial._Id()
+            msg._iris_id = iris_id if iris_id else None
+        except Exception as e:
+            pass
+
+        return msg
 
     @staticmethod
     def _deserialize_json(serial: Any) -> Any:
@@ -90,17 +103,6 @@ def _deserialize_json(serial: Any) -> Any:
         except Exception as e:
             raise SerializationError(f"Failed to deserialize JSON: {str(e)}")
 
-    @staticmethod
-    def _serialize_pickle(message: Any, is_generator: bool = False) -> Any:
-        pickle_string = codecs.encode(pickle.dumps(message), "base64").decode()
-        if is_generator:
-            msg = _iris.get_iris().cls('IOP.Generator.Message.StartPickle')._New()
-        else:
-            msg = _iris.get_iris().cls('IOP.PickleMessage')._New()
-        msg.classname = f"{message.__class__.__module__}.{message.__class__.__name__}"
-        msg.jstr = _Utils.string_to_stream(pickle_string)
-        return msg
-
     @staticmethod
     def _deserialize_pickle(serial: Any) -> Any:
         string = _Utils.stream_to_string(serial.jstr)
@@ -112,6 +114,24 @@ def _parse_classname(classname: str) -> tuple[str, str]:
         if j <= 0:
             raise SerializationError(f"Classname must include a module: {classname}")
         return classname[:j], classname[j+1:]
+    
+    @staticmethod
+    def _convert_to_json_safe(obj: Any) -> Any:
+        """Convert objects to JSON-safe format."""
+        if isinstance(obj, BaseModel):
+            return obj.model_dump_json()
+        elif is_dataclass(obj) and isinstance(obj, _Message):
+            return TempPydanticModel.model_validate(dataclass_to_dict(obj)).model_dump_json()
+        else:
+            raise SerializationError(f"Object {obj} must be a Pydantic model or dataclass Message")
+
+    
+def remove_iris_id(message: Any) -> Any:
+    try:
+        del message._iris_id
+    except AttributeError:
+        pass
+    return message
 
 def dataclass_from_dict(klass: Type | Any, dikt: Dict) -> Any:
     """Converts a dictionary to a dataclass instance.

src/tests/bench/bench_bp.py

@@ -9,4 +9,4 @@ def on_init(self):
 
     def on_message(self, request):
         for _ in range(self.size):
-            _ = self.send_request_sync(self.target,request)
+            rsp = self.send_request_sync(self.target,request)

src/tests/test_message.py

@@ -1,10 +1,61 @@
 import iris
 
+from iop import Message, PickleMessage, PydanticMessage, PydanticPickleMessage
+from iop._dispatch import dispatch_serializer, dispatch_deserializer
+
+from dataclasses import dataclass
+
+@dataclass
+class SimpleMessage(Message):
+    """A simple message class for testing"""
+
+    integer: int
+    string: str
+
+@dataclass
+class SimplePickleMessage(PickleMessage):
+    """A simple pickle message class for testing"""
+
+    integer: int
+    string: str
+
+class SimplePydanticMessage(PydanticMessage):
+    """A simple Pydantic message class for testing"""
+
+    integer: int
+    string: str
+
+class SimplePydanticPickleMessage(PydanticPickleMessage):
+    """A simple Pydantic pickle message class for testing"""
+
+    integer: int
+    string: str
+
+import pytest
+
 def test_iop_message_set_json():
     # test set_json
     iop_message = iris.cls('IOP.Message')._New()
     iop_message.json = 'test'
     assert iop_message.jstr.Read() == 'test'
     assert iop_message.type == 'String'
     assert iop_message.jsonString == 'test'
-    assert iop_message.json == 'test'
+    assert iop_message.json == 'test'
+
+@pytest.mark.parametrize("message_class", [
+    SimpleMessage,
+    SimplePickleMessage,
+    SimplePydanticMessage,
+    SimplePydanticPickleMessage
+]
+)
+def test_get_iris_id(message_class):
+    message = message_class(integer=42, string='test')
+    assert message.get_iris_id() is None
+
+    serialized_message = dispatch_serializer(message)
+    serialized_message._Save()
+    deserialized_message = dispatch_deserializer(serialized_message)
+
+    assert deserialized_message.get_iris_id() is not None
+