iris-pex-embedded-python 3.4.0b3__tar.gz → 3.4.0b5__tar.gz

{iris_pex_embedded_python-3.4.0b3 → iris_pex_embedded_python-3.4.0b5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: iris_pex_embedded_python
-Version: 3.4.0b3
+Version: 3.4.0b5
 Summary: Iris Interoperability based on Embedded Python
 Author-email: grongier <guillaume.rongier@intersystems.com>
 License: MIT License
@@ -44,12 +44,10 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Utilities
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: dacite>=1.6.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: xmltodict>=0.12.0
 Requires-Dist: iris-embedded-python-wrapper>=0.0.6
 Requires-Dist: setuptools>=40.8.0
-Requires-Dist: dc-schema>=0.0.8
 Requires-Dist: jsonpath-ng>=1.7.0
 
 # IoP (Interoperability On Python)

{iris_pex_embedded_python-3.4.0b3 → iris_pex_embedded_python-3.4.0b5}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools", "wheel"]
 
 [project]
 name = "iris_pex_embedded_python"
-version = "3.4.0b3"
+version = "3.4.0b5"
 description = "Iris Interoperability based on Embedded Python"
 readme = "README.md"
 authors = [
@@ -27,12 +27,10 @@ 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",
-    "dc-schema>=0.0.8",
     "jsonpath-ng>=1.7.0"
 ]
 

iris_pex_embedded_python-3.4.0b5/src/iop/_dispatch.py

@@ -0,0 +1,101 @@
+from inspect import signature
+from typing import Any
+
+from iop._serialization import 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 dispatch_serializer(message: Any) -> Any:
+    """Serializes the message based on its type.
+    
+    Args:
+        message: The message to serialize
+        
+    Returns:
+        The serialized message
+        
+    Raises:
+        TypeError: If message is invalid type
+    """
+    if message is not None:
+        if is_message_instance(message):
+            return serialize_message(message)
+        elif is_pickle_message_instance(message):
+            return serialize_pickle_message(message)
+        elif is_iris_object_instance(message):
+            return message
+
+    if message == "" or message is None:
+        return message
+
+    raise TypeError("The message must be an instance of a class that is a subclass of Message or IRISObject %Persistent class.")
+
+def dispatch_deserializer(serial: Any) -> Any:
+    """Deserializes the message based on its type.
+    
+    Args:
+        serial: The serialized message
+        
+    Returns:
+        The deserialized message
+    """
+    if (
+        serial is not None
+        and type(serial).__module__.startswith('iris')
+        and (
+            serial._IsA("IOP.Message")
+            or serial._IsA("Grongier.PEX.Message")
+        )
+    ):
+        return deserialize_message(serial)
+    elif (
+        serial is not None
+        and type(serial).__module__.startswith('iris')
+        and (
+            serial._IsA("IOP.PickleMessage")
+            or serial._IsA("Grongier.PEX.PickleMessage")
+        )
+    ):
+        return deserialize_pickle_message(serial)
+    else:
+        return serial
+
+def dispach_message(host, request: Any) -> Any:
+    """Dispatches the message to the appropriate method.
+    
+    Args:
+        request: The request object
+        
+    Returns:
+        The response object
+    """
+    call = 'on_message'
+
+    module = request.__class__.__module__
+    classname = request.__class__.__name__
+
+    for msg, method in host.DISPATCH:
+        if msg == module + "." + classname:
+            call = method
+
+    return getattr(host, call)(request)
+
+def create_dispatch(host) -> None:
+    """Creates a list of tuples, where each tuple contains the name of a class and the name of a method
+    that takes an instance of that class as its only argument.
+    """
+    if len(host.DISPATCH) == 0:
+        method_list = [func for func in dir(host) if callable(getattr(host, func)) and not func.startswith("_")]
+        for method in method_list:
+            try:
+                param = signature(getattr(host, method)).parameters
+            except ValueError as e:
+                param = ''
+            if (len(param) == 1):
+                annotation = str(param[list(param)[0]].annotation)
+                i = annotation.find("'")
+                j = annotation.rfind("'")
+                if j == -1:
+                    j = None
+                classname = annotation[i+1:j]
+                host.DISPATCH.append((classname, method))
+    return

iris_pex_embedded_python-3.4.0b5/src/iop/_serialization.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+import codecs
+import importlib
+import inspect
+import pickle
+import json
+from dataclasses import asdict, is_dataclass
+from typing import Any, Dict, Type
+
+import iris
+from pydantic import BaseModel, TypeAdapter
+
+from iop._message import _PydanticPickleMessage
+from iop._utils import _Utils
+
+class SerializationError(Exception):
+    """Exception raised for serialization errors."""
+    pass
+
+class TempPydanticModel(BaseModel):
+    model_config = {
+        'arbitrary_types_allowed' : True,
+        'extra' : 'allow'
+    }
+
+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):
+            return TempPydanticModel.model_validate(dataclass_to_dict(obj)).model_dump_json()
+        else:
+            raise SerializationError(f"Object {obj} must be a Pydantic model or dataclass")
+
+    @staticmethod
+    def serialize(message: Any, use_pickle: bool = False) -> iris.cls:
+        """Serializes a message to IRIS format."""
+        if isinstance(message, _PydanticPickleMessage) or use_pickle:
+            return MessageSerializer._serialize_pickle(message)
+        return MessageSerializer._serialize_json(message)
+
+    @staticmethod
+    def _serialize_json(message: Any) -> iris.cls:
+        json_string = MessageSerializer._convert_to_json_safe(message)
+        
+        msg = iris.cls('IOP.Message')._New()
+        msg.classname = f"{message.__class__.__module__}.{message.__class__.__name__}"
+        
+        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
+
+    @staticmethod
+    def deserialize(serial: iris.cls, use_pickle: bool = False) -> Any:
+        if use_pickle:
+            return MessageSerializer._deserialize_pickle(serial)
+        return MessageSerializer._deserialize_json(serial)
+
+    @staticmethod
+    def _deserialize_json(serial: iris.cls) -> Any:
+        if not serial.classname:
+            raise SerializationError("JSON message malformed, must include classname")
+        
+        try:
+            module_name, class_name = MessageSerializer._parse_classname(serial.classname)
+            module = importlib.import_module(module_name)
+            msg_class = getattr(module, class_name)
+        except Exception as e:
+            raise SerializationError(f"Failed to load class {serial.classname}: {str(e)}")
+
+        json_string = (_Utils.stream_to_string(serial.json) 
+                      if serial.type == 'Stream' else serial.json)
+        
+        try:
+            if issubclass(msg_class, BaseModel):
+                return msg_class.model_validate_json(json_string)
+            elif is_dataclass(msg_class):
+                return dataclass_from_dict(msg_class, json.loads(json_string))
+            else:
+                raise SerializationError(f"Class {msg_class} must be a Pydantic model or dataclass")
+        except Exception as e:
+            raise SerializationError(f"Failed to deserialize JSON: {str(e)}")
+
+    @staticmethod
+    def _serialize_pickle(message: Any) -> iris.cls:
+        pickle_string = codecs.encode(pickle.dumps(message), "base64").decode()
+        msg = 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: iris.cls) -> Any:
+        string = _Utils.stream_to_string(serial.jstr)
+        return pickle.loads(codecs.decode(string.encode(), "base64"))
+
+    @staticmethod
+    def _parse_classname(classname: str) -> tuple[str, str]:
+        j = classname.rindex(".")
+        if j <= 0:
+            raise SerializationError(f"Classname must include a module: {classname}")
+        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)
+        if value is None:
+            processed_dict[key] = None
+            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)
+    return instance
+
+def dataclass_to_dict(instance: Any) -> Dict:
+    """Converts a class instance to a dictionary.
+    Handles non attended fields."""
+    dikt = asdict(instance)
+    # assign any extra fields
+    for k, v in vars(instance).items():
+        if k not in dikt:
+            dikt[k] = v
+    return dikt
+
+# Maintain backwards compatibility
+serialize_pickle_message = lambda msg: MessageSerializer.serialize(msg, use_pickle=True)
+serialize_message = lambda msg: MessageSerializer.serialize(msg, use_pickle=False)
+deserialize_pickle_message = lambda serial: MessageSerializer.deserialize(serial, use_pickle=True)
+deserialize_message = lambda serial: MessageSerializer.deserialize(serial, use_pickle=False)

{iris_pex_embedded_python-3.4.0b3 → iris_pex_embedded_python-3.4.0b5}/src/iop/_utils.py

@@ -8,7 +8,7 @@ import pkg_resources
 import importlib
 import json
 from iop._message import _Message, _PydanticMessage
-from dc_schema import get_schema
+from pydantic import TypeAdapter
 
 class _Utils():
     @staticmethod
@@ -46,7 +46,8 @@ class _Utils():
         if issubclass(cls,_PydanticMessage):
             schema = cls.model_json_schema()
         elif issubclass(cls,_Message):
-            schema = get_schema(cls)
+            type_adapter = TypeAdapter(cls)
+            schema = type_adapter.json_schema()
         else:
             raise ValueError("The class must be a subclass of _Message or _PydanticMessage")
         schema_name = cls.__module__ + '.' + cls.__name__

{iris_pex_embedded_python-3.4.0b3 → iris_pex_embedded_python-3.4.0b5}/src/iris_pex_embedded_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: iris_pex_embedded_python
-Version: 3.4.0b3
+Version: 3.4.0b5
 Summary: Iris Interoperability based on Embedded Python
 Author-email: grongier <guillaume.rongier@intersystems.com>
 License: MIT License
@@ -44,12 +44,10 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Utilities
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: dacite>=1.6.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: xmltodict>=0.12.0
 Requires-Dist: iris-embedded-python-wrapper>=0.0.6
 Requires-Dist: setuptools>=40.8.0
-Requires-Dist: dc-schema>=0.0.8
 Requires-Dist: jsonpath-ng>=1.7.0
 
 # IoP (Interoperability On Python)

{iris_pex_embedded_python-3.4.0b3 → iris_pex_embedded_python-3.4.0b5}/src/iris_pex_embedded_python.egg-info/requires.txt

@@ -1,7 +1,5 @@
-dacite>=1.6.0
 pydantic>=2.0.0
 xmltodict>=0.12.0
 iris-embedded-python-wrapper>=0.0.6
 setuptools>=40.8.0
-dc-schema>=0.0.8
 jsonpath-ng>=1.7.0

iris_pex_embedded_python-3.4.0b3/src/iop/_dispatch.py

@@ -1,223 +0,0 @@
-import codecs
-import importlib
-from inspect import signature
-import json
-import pickle
-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._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.
-    
-    Args:
-        message: The message to serialize
-        
-    Returns:
-        The serialized message
-        
-    Raises:
-        TypeError: If message is invalid type
-    """
-    if message is not None:
-        if is_message_instance(message):
-            return serialize_message(message)
-        elif is_pickle_message_instance(message):
-            return serialize_pickle_message(message)
-        elif is_iris_object_instance(message):
-            return message
-
-    if message == "" or message is None:
-        return message
-
-    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.
-    
-    Args:
-        serial: The serialized message
-        
-    Returns:
-        The deserialized message
-    """
-    if (
-        serial is not None
-        and type(serial).__module__.startswith('iris')
-        and (
-            serial._IsA("IOP.Message")
-            or serial._IsA("Grongier.PEX.Message")
-        )
-    ):
-        return deserialize_message(serial)
-    elif (
-        serial is not None
-        and type(serial).__module__.startswith('iris')
-        and (
-            serial._IsA("IOP.PickleMessage")
-            or serial._IsA("Grongier.PEX.PickleMessage")
-        )
-    ):
-        return deserialize_pickle_message(serial)
-    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.
-    
-    Args:
-        request: The request object
-        
-    Returns:
-        The response object
-    """
-    call = 'on_message'
-
-    module = request.__class__.__module__
-    classname = request.__class__.__name__
-
-    for msg, method in host.DISPATCH:
-        if msg == module + "." + classname:
-            call = method
-
-    return getattr(host, call)(request)
-
-def create_dispatch(host) -> None:
-    """Creates a list of tuples, where each tuple contains the name of a class and the name of a method
-    that takes an instance of that class as its only argument.
-    """
-    if len(host.DISPATCH) == 0:
-        method_list = [func for func in dir(host) if callable(getattr(host, func)) and not func.startswith("_")]
-        for method in method_list:
-            try:
-                param = signature(getattr(host, method)).parameters
-            except ValueError as e:
-                param = ''
-            if (len(param) == 1):
-                annotation = str(param[list(param)[0]].annotation)
-                i = annotation.find("'")
-                j = annotation.rfind("'")
-                if j == -1:
-                    j = None
-                classname = annotation[i+1:j]
-                host.DISPATCH.append((classname, method))
-    return