Refactor serialization functions by consolidating and removing deprecated methods for improved clarity and maintainability

Author: grongierisc

src/iop/_dispatch.py

@@ -6,34 +6,12 @@
 from typing import Any, Dict, List, Type
 
 import iris
-from dacite import Config, from_dict
 from pydantic import BaseModel
 
 from iop._utils import _Utils
-from iop._serialization import IrisJSONEncoder, IrisJSONDecoder
+from iop._serialization import IrisJSONEncoder, IrisJSONDecoder, serialize_message, serialize_pickle_message, deserialize_message, deserialize_pickle_message
 from iop._message_validator import is_message_instance, is_pickle_message_instance, is_iris_object_instance
 
-def serialize_pickle_message(message: Any) -> iris.cls:
-    """Converts a python dataclass message into an iris iop.message.
-
-    Args:
-        message: The message to serialize, an instance of a class that is a subclass of Message.
-
-    Returns:
-        The message in json format.
-    """
-    pickle_string = codecs.encode(pickle.dumps(message), "base64").decode()
-    module = message.__class__.__module__
-    classname = message.__class__.__name__
-
-    msg = iris.cls('IOP.PickleMessage')._New()
-    msg.classname = module + "." + classname
-
-    stream = _Utils.string_to_stream(pickle_string)
-    msg.jstr = stream
-
-    return msg
-
 def dispatch_serializer(message: Any) -> Any:
     """Serializes the message based on its type.
     
@@ -59,42 +37,6 @@ def dispatch_serializer(message: Any) -> Any:
 
     raise TypeError("The message must be an instance of a class that is a subclass of Message or IRISObject %Persistent class.")
 
-def serialize_message(message: Any) -> iris.cls:
-    """Converts a python dataclass message into an iris iop.message.
-
-    Args:
-        message: The message to serialize, an instance of a class that is a subclass of Message.
-
-    Returns:
-        The message in json format.
-    """
-    json_string = json.dumps(message, cls=IrisJSONEncoder, ensure_ascii=False)
-    module = message.__class__.__module__
-    classname = message.__class__.__name__
-
-    msg = iris.cls('IOP.Message')._New()
-    msg.classname = module + "." + classname
-
-    if hasattr(msg, 'buffer') and len(json_string) > msg.buffer:
-        msg.json = _Utils.string_to_stream(json_string, msg.buffer)
-    else:
-        msg.json = json_string
-
-    return msg
-
-def deserialize_pickle_message(serial: iris.cls) -> Any:
-    """Converts an iris iop.message into a python dataclass message.
-    
-    Args:
-        serial: The serialized message
-        
-    Returns:
-        The deserialized message
-    """
-    string = _Utils.stream_to_string(serial.jstr)
-    msg = pickle.loads(codecs.decode(string.encode(), "base64"))
-    return msg
-
 def dispatch_deserializer(serial: Any) -> Any:
     """Deserializes the message based on its type.
     
@@ -125,62 +67,6 @@ def dispatch_deserializer(serial: Any) -> Any:
     else:
         return serial
 
-def deserialize_message(serial: iris.cls) -> Any:
-    """Converts an iris iop.message into a python dataclass message.
-    
-    Args:
-        serial: The serialized message
-        
-    Returns:
-        The deserialized message
-    """
-    if (serial.classname is None):
-        raise ValueError("JSON message malformed, must include classname")
-    classname = serial.classname
-
-    j = classname.rindex(".")
-    if (j <= 0):
-        raise ValueError("Classname must include a module: " + classname)
-    try:
-        module = importlib.import_module(classname[:j])
-        msg = getattr(module, classname[j+1:])
-    except Exception:
-        raise ImportError("Class not found: " + classname)
-
-    string = ""
-    if (serial.type == 'Stream'):
-        string = _Utils.stream_to_string(serial.json)
-    else:
-        string = serial.json
-
-    jdict = json.loads(string, cls=IrisJSONDecoder)
-    return dataclass_from_dict(msg, jdict)
-
-def dataclass_from_dict(klass: Type, dikt: Dict) -> Any:
-    """Converts a dictionary to a dataclass instance.
-    
-    Args:
-        klass: The dataclass to convert to
-        dikt: The dictionary to convert to a dataclass
-        
-    Returns:
-        A dataclass object with the fields of the dataclass and the fields of the dictionary.
-    """
-    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/_serialization.py

@@ -7,9 +7,7 @@
 import json
 import pickle
 import uuid
-from abc import ABC, abstractmethod
-from dataclasses import is_dataclass
-from typing import Any, Dict, Type, Optional
+from typing import Any, Dict, Type
 
 from dacite import Config, from_dict
 import iris

src/tests/test_dispatch.py

@@ -3,17 +3,20 @@
 import decimal
 import uuid
 from dataclasses import dataclass
-import iris
 
 from iop._dispatch import (
-    serialize_message,
-    deserialize_message,
-    serialize_pickle_message,
-    deserialize_pickle_message,
     dispatch_serializer,
-    dispatch_deserializer,
-    dataclass_from_dict
-)
+    dispatch_deserializer
+    )
+
+from iop._serialization import (
+    dataclass_from_dict, 
+    serialize_message, 
+    deserialize_message, 
+    serialize_pickle_message, 
+    deserialize_pickle_message
+    )
+
 from iop._message import _Message as Message
 from iop._message import _PydanticMessage as PydanticMessage