iris-pex-embedded-python 3.3.1__py3-none-any.whl → 3.4.0__py3-none-any.whl

grongier/pex/__init__.py

@@ -6,7 +6,7 @@ from iop._business_operation import _BusinessOperation
 from iop._inbound_adapter import _InboundAdapter
 from iop._outbound_adapter import _OutboundAdapter
 from iop._message import _Message
-from iop._pickle_message import _PickleMessage
+from iop._message import _PickleMessage
 from iop._director import _Director
 from iop._utils import _Utils
 

iop/__init__.py

@@ -3,9 +3,8 @@ from iop._business_process import _BusinessProcess
 from iop._business_service import _BusinessService
 from iop._director import _Director
 from iop._inbound_adapter import _InboundAdapter
-from iop._message import _Message
+from iop._message import _Message, _PickleMessage, _PydanticMessage, _PydanticPickleMessage
 from iop._outbound_adapter import _OutboundAdapter
-from iop._pickle_message import _PickleMessage
 from iop._private_session_duplex import _PrivateSessionDuplex
 from iop._private_session_process import _PrivateSessionProcess
 from iop._utils import _Utils
@@ -21,4 +20,6 @@ class DuplexOperation(_PrivateSessionDuplex): pass
 class DuplexProcess(_PrivateSessionProcess): pass
 class Message(_Message): pass
 class PickleMessage(_PickleMessage): pass
+class PydanticMessage(_PydanticMessage): pass
+class PydanticPickleMessage(_PydanticPickleMessage): pass
 class Director(_Director): pass

iop/_common.py

@@ -17,7 +17,27 @@ class _Common(metaclass=abc.ABCMeta):
     INFO_URL: ClassVar[str]
     ICON_URL: ClassVar[str]
     iris_handle: Any = None
-    log_to_console: bool = False
+    _log_to_console: bool = False
+    _logger: logging.Logger = None
+
+    @property
+    def logger(self) -> logging.Logger:
+        if self._logger is None:
+            self._logger = LogManager.get_logger(self.__class__.__name__,self.log_to_console)
+        return self._logger
+    
+    @logger.setter
+    def logger(self, value: logging.Logger) -> None:
+        self._logger = value
+
+    @property
+    def log_to_console(self) -> bool:
+        return self._log_to_console
+    
+    @log_to_console.setter
+    def log_to_console(self, value: bool) -> None:
+        self._log_to_console = value
+        self.logger = LogManager.get_logger(self.__class__.__name__,value)
 
     # Lifecycle methods
     def on_init(self) -> None:
@@ -128,7 +148,10 @@ class _Common(metaclass=abc.ABCMeta):
                 if not member[0].startswith('_'):
                     # remove other methods and functions
                     if not inspect.ismethod(member[1]) and not inspect.isfunction(member[1]) and not inspect.isclass(member[1]):
-                        if member[0] not in ('INFO_URL','ICON_URL','PERSISTENT_PROPERTY_LIST') :
+                        if member[0] not in ('INFO_URL','ICON_URL','PERSISTENT_PROPERTY_LIST'
+                                             ,'log_to_console','logger','iris_handle'
+                                             ,'DISPATCH','adapter','Adapter','buffer'
+                                             ,'BusinessHost','business_host','business_host_python'):
                             name = member[0]
                             req = 0
                             cat = "Additional"
@@ -172,7 +195,7 @@ class _Common(metaclass=abc.ABCMeta):
         except:
             pass
         return ret
-    
+
     # Logging methods
     def _log(self) -> Tuple[str, Optional[str]]:
         """Get class and method name for logging.
@@ -189,15 +212,27 @@ class _Common(metaclass=abc.ABCMeta):
             pass
         return current_class, current_method
 
-    @property
-    def logger(self) -> logging.Logger:
-        """Get a logger instance for this component.
+    def _logging(self, message: str, level: int, to_console: Optional[bool] = None) -> None:
+        """Write log entry.
         
-        Returns:
-            Logger configured for IRIS integration
+        Args:
+            message: Message to log
+            level: Log level
+            to_console: If True, log to console instead of IRIS
         """
-        class_name, method_name = self._log()
-        return LogManager.get_logger(class_name, method_name, self.log_to_console)
+        current_class, current_method = self._log()
+        if to_console is None:
+            to_console = self.log_to_console
+        if level == logging.DEBUG:
+            self.logger.debug(message, extra={'to_console': to_console, 'class_name': current_class, 'method_name': current_method})
+        elif level == logging.INFO:
+            self.logger.info(message, extra={'to_console': to_console, 'class_name': current_class, 'method_name': current_method})
+        elif level == logging.CRITICAL:
+            self.logger.critical(message, extra={'to_console': to_console, 'class_name': current_class, 'method_name': current_method})
+        elif level == logging.WARNING:
+            self.logger.warning(message, extra={'to_console': to_console, 'class_name': current_class, 'method_name': current_method})
+        elif level == logging.ERROR:
+            self.logger.error(message, extra={'to_console': to_console, 'class_name': current_class, 'method_name': current_method})
 
     def trace(self, message: str, to_console: Optional[bool] = None) -> None:
         """Write trace log entry.
@@ -206,8 +241,7 @@ class _Common(metaclass=abc.ABCMeta):
             message: Message to log
             to_console: If True, log to console instead of IRIS
         """
-        self.logger.debug(message, extra={'to_console': to_console})
-
+        self._logging(message, logging.DEBUG, to_console)
 
     def log_info(self, message: str, to_console: Optional[bool] = None) -> None:
         """Write info log entry.
@@ -216,7 +250,7 @@ class _Common(metaclass=abc.ABCMeta):
             message: Message to log
             to_console: If True, log to console instead of IRIS
         """
-        self.logger.info(message, extra={'to_console': to_console})
+        self._logging(message, logging.INFO, to_console)
 
     def log_alert(self, message: str, to_console: Optional[bool] = None) -> None:
         """Write alert log entry.
@@ -225,7 +259,7 @@ class _Common(metaclass=abc.ABCMeta):
             message: Message to log
             to_console: If True, log to console instead of IRIS
         """
-        self.logger.critical(message, extra={'to_console': to_console})
+        self._logging(message, logging.CRITICAL, to_console)
 
     def log_warning(self, message: str, to_console: Optional[bool] = None) -> None:
         """Write warning log entry.
@@ -234,7 +268,7 @@ class _Common(metaclass=abc.ABCMeta):
             message: Message to log
             to_console: If True, log to console instead of IRIS
         """
-        self.logger.warning(message, extra={'to_console': to_console})
+        self._logging(message, logging.WARNING, to_console)
 
     def log_error(self, message: str, to_console: Optional[bool] = None) -> None:
         """Write error log entry.
@@ -243,7 +277,7 @@ class _Common(metaclass=abc.ABCMeta):
             message: Message to log
             to_console: If True, log to console instead of IRIS
         """
-        self.logger.error(message, extra={'to_console': to_console})
+        self._logging(message, logging.ERROR, to_console)
 
     def log_assert(self, message: str) -> None:
         """Write a log entry of type "assert". Log entries can be viewed in the management portal.

iop/_director.py

@@ -6,7 +6,6 @@ import intersystems_iris.dbapi._DBAPI as irisdbapi
 import signal
 from dataclasses import dataclass
 
-from iop._business_host import _BusinessHost
 from iop._dispatch import dispatch_deserializer, dispatch_serializer
 from iop._utils import _Utils
 
@@ -278,7 +277,6 @@ class _Director():
                 else:
                     message.json = _Utils.string_to_stream("{}")
         # serialize the message
-        business_host = _BusinessHost()
         serial_message = dispatch_serializer(message)
         response = iris.cls('IOP.Utils').dispatchTestComponent(target,serial_message)
         try:

iop/_dispatch.py

@@ -1,38 +1,9 @@
-import codecs
-import importlib
 from inspect import signature
-import json
-import pickle
-from typing import Any, Dict, List, Type
+from typing import Any
 
-import iris
-from dacite import Config, from_dict
-
-from iop._utils import _Utils
-from iop._serialization import IrisJSONEncoder, IrisJSONDecoder
+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 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.
     
@@ -58,42 +29,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.
     
@@ -124,59 +59,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.
-    """
-    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.
     

iop/_log_manager.py

@@ -1,3 +1,4 @@
+import traceback
 import iris
 import logging
 from typing import Optional, Tuple
@@ -6,7 +7,7 @@ class LogManager:
     """Manages logging integration between Python's logging module and IRIS."""
 
     @staticmethod
-    def get_logger(class_name: str, method_name: Optional[str] = None, to_console: bool = False) -> logging.Logger:
+    def get_logger(class_name: str, to_console: bool = False) -> logging.Logger:
         """Get a logger instance configured for IRIS integration.
         
         Args:
@@ -17,11 +18,11 @@ class LogManager:
         Returns:
             Logger instance configured for IRIS integration
         """
-        logger = logging.getLogger(f"{class_name}.{method_name}" if method_name else class_name)
+        logger = logging.Logger(f"{class_name}")
         
         # Only add handler if none exists
         if not logger.handlers:
-            handler = IRISLogHandler(class_name, method_name, to_console)
+            handler = IRISLogHandler(to_console=to_console)
             formatter = logging.Formatter('%(message)s')
             handler.setFormatter(formatter)
             logger.addHandler(handler)
@@ -33,17 +34,9 @@ class LogManager:
 class IRISLogHandler(logging.Handler):
     """Custom logging handler that routes Python logs to IRIS logging system."""
 
-    def __init__(self, class_name: str, method_name: Optional[str] = None, to_console: bool = False):
-        """Initialize the handler with context information.
-        
-        Args:
-            class_name: Name of the class logging the message
-            method_name: Optional name of the method logging the message
-            console: If True, log to the console instead of IRIS
-        """
+    def __init__(self, to_console: bool = False):
+        """Initialize the IRIS logging handler."""
         super().__init__()
-        self.class_name = class_name
-        self.method_name = method_name
         self.to_console = to_console
 
         # Map Python logging levels to IRIS logging methods
@@ -80,10 +73,11 @@ class IRISLogHandler(logging.Handler):
         Args:
             record: The logging record to emit
         """
-
-        log_func = self.level_map.get(record.levelno, iris.cls("Ens.Util.Log").LogInfo)
+        class_name = record.class_name if hasattr(record, "class_name") else record.name
+        method_name = record.method_name if hasattr(record, "method_name") else record.funcName
         if self.to_console or (hasattr(record, "to_console") and record.to_console):
             iris.cls("%SYS.System").WriteToConsoleLog(self.format(record),
-                0,self.level_map_console.get(record.levelno, 0),record.name)
+                0,self.level_map_console.get(record.levelno, 0),class_name+"."+method_name)
         else:
-            log_func(self.class_name, self.method_name, self.format(record))
+            log_func = self.level_map.get(record.levelno, iris.cls("Ens.Util.Log").LogInfo)
+            log_func(class_name, method_name, self.format(record))

iop/_message.py

@@ -1,6 +1,28 @@
+from typing import Any
+from pydantic import BaseModel
+
 class _Message:
     """ The abstract class that is the superclass for persistent messages sent from one component to another.
     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
+    pass
+
+class _PickleMessage:
+    """ The abstract class that is the superclass for persistent messages sent from one component to another.
+    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
+
+class _PydanticMessage(BaseModel):
+    """Base class for Pydantic-based messages that can be serialized to IRIS."""
+    
+    def __init__(self, **data: Any):
+        super().__init__(**data)
+
+class _PydanticPickleMessage(BaseModel):
+    """Base class for Pydantic-based messages that can be serialized to IRIS."""
+    
+    def __init__(self, **data: Any):
+        super().__init__(**data)

iop/_message_validator.py

@@ -1,9 +1,12 @@
 import dataclasses
 from typing import Any, Type
+from iop._message import _Message, _PickleMessage, _PydanticPickleMessage, BaseModel
 
 
 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")
@@ -13,6 +16,8 @@ def is_message_instance(obj: Any) -> bool:
 
 def is_pickle_message_instance(obj: Any) -> bool:
     """Check if object is a PickleMessage instance."""
+    if isinstance(obj, _PydanticPickleMessage):
+        return True
     if is_pickle_message_class(type(obj)):
         return True
     return False
@@ -27,15 +32,16 @@ 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, _Message):
         return True
-    return any(is_message_class(c) for c in klass.__bases__)
+    return False
+
 
 
 def is_pickle_message_class(klass: Type) -> bool:
     """Check if class is a PickleMessage type."""
-    name = f"{klass.__module__}.{klass.__qualname__}"
-    if name in ("iop.PickleMessage", "grongier.pex.PickleMessage"):
+    if issubclass(klass, _PickleMessage):
+        return True
+    if issubclass(klass, _PydanticPickleMessage):
         return True
-    return any(is_pickle_message_class(c) for c in klass.__bases__)
+    return False

iop/_serialization.py

@@ -1,161 +1,52 @@
 from __future__ import annotations
-import base64
 import codecs
-import datetime
-import decimal
 import importlib
-import json
+import inspect
 import pickle
-import uuid
-from abc import ABC, abstractmethod
-from dataclasses import is_dataclass
-from typing import Any, Dict, Type, Optional
+import json
+from dataclasses import asdict, is_dataclass
+from typing import Any, Dict, Type
 
-from dacite import Config, from_dict
 import iris
+from pydantic import BaseModel, TypeAdapter, ValidationError
 
+from iop._message import _PydanticPickleMessage
 from iop._utils import _Utils
 
-# Constants
-DATETIME_FORMAT_LENGTH = 23
-TIME_FORMAT_LENGTH = 12
-TYPE_SEPARATOR = ':'
-SUPPORTED_TYPES = {
-    'datetime', 'date', 'time', 'dataframe', 
-    'decimal', 'uuid', 'bytes'
-}
-
 class SerializationError(Exception):
-    """Base exception for serialization errors."""
+    """Exception raised for serialization errors."""
     pass
 
-class TypeConverter:
-    """Handles type conversion for special data types."""
-    
-    @staticmethod
-    def convert_to_string(typ: str, obj: Any) -> str:
-        if typ == 'dataframe':
-            return obj.to_json(orient="table")
-        elif typ == 'datetime':
-            return TypeConverter._format_datetime(obj)
-        elif typ == 'date':
-            return obj.isoformat()
-        elif typ == 'time':
-            return TypeConverter._format_time(obj)
-        elif typ == 'bytes':
-            return base64.b64encode(obj).decode("UTF-8")
-        return str(obj)
-
-    @staticmethod
-    def convert_from_string(typ: str, val: str) -> Any:
-        try:
-            if typ == 'datetime':
-                return datetime.datetime.fromisoformat(val)
-            elif typ == 'date':
-                return datetime.date.fromisoformat(val)
-            elif typ == 'time':
-                return datetime.time.fromisoformat(val)
-            elif typ == 'dataframe':
-                try:
-                    import pandas as pd
-                except ImportError:
-                    raise SerializationError("Failed to load pandas module")
-                return pd.read_json(val, orient="table")
-            elif typ == 'decimal':
-                return decimal.Decimal(val)
-            elif typ == 'uuid':
-                return uuid.UUID(val)
-            elif typ == 'bytes':
-                return base64.b64decode(val.encode("UTF-8"))
-            return val
-        except Exception as e:
-            raise SerializationError(f"Failed to convert type {typ}: {str(e)}")
-
-    @staticmethod
-    def _format_datetime(dt: datetime.datetime) -> str:
-        r = dt.isoformat()
-        if dt.microsecond:
-            r = r[:DATETIME_FORMAT_LENGTH] + r[26:]
-        if r.endswith("+00:00"):
-            r = r[:-6] + "Z"
-        return r
-
-    @staticmethod
-    def _format_time(t: datetime.time) -> str:
-        r = t.isoformat()
-        if t.microsecond:
-            r = r[:TIME_FORMAT_LENGTH]
-        return r
-
-class IrisJSONEncoder(json.JSONEncoder):
-    """JSONEncoder that handles dates, decimals, UUIDs, etc."""
-    
-    def default(self, obj: Any) -> Any:
-        if obj.__class__.__name__ == 'DataFrame':
-            return f'dataframe:{TypeConverter.convert_to_string("dataframe", obj)}'
-        elif isinstance(obj, datetime.datetime):
-            return f'datetime:{TypeConverter.convert_to_string("datetime", obj)}'
-        elif isinstance(obj, datetime.date):
-            return f'date:{TypeConverter.convert_to_string("date", obj)}'
-        elif isinstance(obj, datetime.time):
-            return f'time:{TypeConverter.convert_to_string("time", obj)}'
-        elif isinstance(obj, decimal.Decimal):
-            return f'decimal:{obj}'
-        elif isinstance(obj, uuid.UUID):
-            return f'uuid:{obj}'
-        elif isinstance(obj, bytes):
-            return f'bytes:{TypeConverter.convert_to_string("bytes", obj)}'
-        elif hasattr(obj, '__dict__'):
-            return obj.__dict__
-        return super().default(obj)
-
-class IrisJSONDecoder(json.JSONDecoder):
-    """JSONDecoder that handles special type annotations."""
-    
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        super().__init__(object_hook=self.object_hook, *args, **kwargs)
-
-    def object_hook(self, obj: Dict) -> Dict:
-        return {
-            key: self._process_value(value)
-            for key, value in obj.items()
-        }
-                
-    def _process_value(self, value: Any) -> Any:
-        if isinstance(value, str) and TYPE_SEPARATOR in value:
-            typ, val = value.split(TYPE_SEPARATOR, 1)
-            if typ in SUPPORTED_TYPES:
-                return TypeConverter.convert_from_string(typ, val)
-        return value
+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 use_pickle:
+        if isinstance(message, _PydanticPickleMessage) or use_pickle:
             return MessageSerializer._serialize_pickle(message)
         return MessageSerializer._serialize_json(message)
 
-    @staticmethod
-    def deserialize(serial: iris.cls, use_pickle: bool = False) -> Any:
-        """Deserializes a message from IRIS format."""
-        if use_pickle:
-            return MessageSerializer._deserialize_pickle(serial)
-        return MessageSerializer._deserialize_json(serial)
-
-    @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 _serialize_json(message: Any) -> iris.cls:
-        json_string = json.dumps(message, cls=IrisJSONEncoder, ensure_ascii=False)
+        json_string = MessageSerializer._convert_to_json_safe(message)
+        
         msg = iris.cls('IOP.Message')._New()
         msg.classname = f"{message.__class__.__module__}.{message.__class__.__name__}"
         
@@ -166,9 +57,10 @@ class MessageSerializer:
         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"))
+    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:
@@ -186,11 +78,28 @@ class MessageSerializer:
                       if serial.type == 'Stream' else serial.json)
         
         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(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(".")
@@ -199,18 +108,53 @@ class MessageSerializer:
         return classname[:j], classname[j+1:]
 
 def dataclass_from_dict(klass: Type, dikt: Dict) -> Any:
-    """Converts a dictionary to a dataclass instance."""
-    ret = from_dict(klass, dikt, Config(check_types=False))
+    """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:
+            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
+        
+        field_dict[field_name] = process_field(dikt[field_name], field_info.annotation)
+
+    # Create instance
+    instance = klass(**field_dict)
     
-    try:
-        fieldtypes = klass.__annotations__
-    except Exception:
-        fieldtypes = {}
+    # 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)
     
-    for key, val in dikt.items():
-        if key not in fieldtypes:
-            setattr(ret, key, val)
-    return ret
+    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)

iop/_utils.py

@@ -6,8 +6,10 @@ import inspect
 import xmltodict
 import pkg_resources
 import importlib
+import importlib.util
 import json
-from dc_schema import get_schema
+from iop._message import _Message, _PydanticMessage
+from pydantic import TypeAdapter
 
 class _Utils():
     @staticmethod
@@ -42,7 +44,13 @@ class _Utils():
         
         :param cls: The class to register
         """
-        schema = get_schema(cls)
+        if issubclass(cls,_PydanticMessage):
+            schema = cls.model_json_schema()
+        elif issubclass(cls,_Message):
+            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__
         schema_str = json.dumps(schema)
         categories = schema_name
@@ -234,7 +242,7 @@ class _Utils():
             settings = _Utils.import_module_from_path('settings',filename)
         else:
             # import settings from the settings module
-            import settings
+            import settings # type: ignore
         # get the path of the settings file
         path = os.path.dirname(inspect.getfile(settings))
         try:
@@ -254,7 +262,7 @@ class _Utils():
         except AttributeError:
             print("No schemas to register")
         try:
-            sys.path.remove(path)
+            sys.path.remove(os.path.normpath(path))
         except ValueError:
             pass
 

iop/cls/IOP/Common.cls

@@ -37,11 +37,17 @@ Method GetModule() As %String
     Return ..%module
 }
 
+Method %OnNew(pConfigName As %String) As %Status
+{
+    $$$ThrowOnError(..Connect())
+	Quit $method($this,"initConfig",.pConfigName) ; call subclass
+}
+
 Method OnInit() As %Status
 {
     set tSC = $$$OK
     try {
-        $$$ThrowOnError(..Connect())
+        
         do ..%class."_dispatch_on_init"($this)
     } catch ex {
         set tSC = ex.AsStatus()
@@ -199,7 +205,6 @@ ClassMethod OnGetConnections(
     Catch ex {
     }
 
-
     // Get settings
     do pItem.GetModifiedSetting("%classpaths", .tClasspaths)
     do pItem.GetModifiedSetting("%classname", .tClassname)

iop/cls/IOP/Utils.cls

@@ -275,6 +275,54 @@ ClassMethod GenerateProxyClass(
 		set:($Case(tSuperClass,"IOP.InboundAdapter":1,"IOP.OutboundAdapter":1,:0)) type = "Adapter"
 		set tSETTINGSParamValue = $REPLACE(tSETTINGSParamValue,"$type",type)
 		
+		#dim tCustomProp As %Dictionary.PropertyDefinition
+		#dim tPropInfo,tPropName,tDataType,tDefault,tDesc,tPropCat,tContext As %String
+
+		set builtins = ##class(%SYS.Python).Import("builtins")
+		#; each remote setting is of form $lb(propName,dataType,defaultVal,required,category,description,editorContext)
+		For i=0:1:builtins.len(pRemoteSettings)-1 {
+			Set tPropInfo = pRemoteSettings."__getitem__"(i)
+			Continue:""=tPropInfo ; this shouldn't happen, but just in case
+			Set tPropName = tPropInfo."__getitem__"(0)
+			Set tDataType = tPropInfo."__getitem__"(1)
+			If (""=tPropName) || (""=tDataType) {
+				Set tSC = $$$ERROR($$$EnsErrGeneral,"All properties must have a name and datatype defined")
+				Quit
+			}
+			Set tCustomProp = ##class(%Dictionary.PropertyDefinition).%New()
+			Set tCustomProp.Name = tPropName
+			If $Case(tDataType,"String":1,"Integer":1,"Boolean":1,"Numeric":1,:0) {
+				Set tDataType = "%"_tDataType
+			} ElseIf '##class(%Dictionary.ClassDefinition).%ExistsId(tDataType) {
+				Set tDataType = "%String"
+			}
+			Set tCustomProp.Type = tDataType
+			If tDataType["%String" {
+				Set tSC = tCustomProp.Parameters.SetAt("255","MAXLEN")
+				Quit:$$$ISERR(tSC)
+			}
+			Set tDefault = tPropInfo."__getitem__"(2)
+			If ""'=tDefault {
+				Set tCustomProp.InitialExpression = $$$quote(tDefault)
+			}
+			Set tCustomProp.Required = tPropInfo."__getitem__"(3)
+			
+			Set tSC = tCOSClass.Properties.Insert(tCustomProp)
+			Quit:$$$ISERR(tSC)
+			
+			#dim tMethod As %Dictionary.MethodDefinition = ##class(%Dictionary.MethodDefinition).%New()
+			Set tMethod.Name = tPropName_"Set"
+			Set tMethod.ReturnType = "%Status"
+			Set tMethod.FormalSpec = "value:"_tDataType
+			Do tMethod.Implementation.WriteLine("	Set ..%class."""_tPropName_""" = value")
+			Do tMethod.Implementation.WriteLine("	Quit $$$OK")
+			Set tSC = tCOSClass.Methods.Insert(tMethod)
+
+			Set tPropCat = "Python Attributes"
+			Set tSETTINGSParamValue = tSETTINGSParamValue_","_tPropName_":"_tPropCat
+		}
+		Quit:$$$ISERR(tSC)
+
 		#dim tSETTINGSParam As %Dictionary.ParameterDefinition = ##class(%Dictionary.ParameterDefinition).%New()
 		Set tSETTINGSParam.Name = "SETTINGS"
 		Set tSETTINGSParam.Default = tSETTINGSParamValue

{iris_pex_embedded_python-3.3.1.dist-info → iris_pex_embedded_python-3.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: iris_pex_embedded_python
-Version: 3.3.1
+Version: 3.4.0
 Summary: Iris Interoperability based on Embedded Python
 Author-email: grongier <guillaume.rongier@intersystems.com>
 License: MIT License
@@ -44,12 +44,12 @@ 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
+Dynamic: license-file
 
 # IoP (Interoperability On Python)
 

{iris_pex_embedded_python-3.3.1.dist-info → iris_pex_embedded_python-3.4.0.dist-info}/RECORD

@@ -19,7 +19,7 @@ grongier/cls/Grongier/PEX/PrivateSession/Message/Poll.cls,sha256=pcUgHgxX1pMH-wQ
 grongier/cls/Grongier/PEX/PrivateSession/Message/Start.cls,sha256=T3jNoR8RjKr1InQ6SgqBYTgFwpSB0Q60WholjbvForg,433
 grongier/cls/Grongier/PEX/PrivateSession/Message/Stop.cls,sha256=zy30ZXXN4XcovPij-kOF3PuH1SkP1EUvlEJQRx2S9RU,431
 grongier/cls/Grongier/Service/WSGI.cls,sha256=7u2SsFmnsubMfdazvaDchKCM3yesPRMfKBzMIkwQ9xc,77
-grongier/pex/__init__.py,sha256=zHFF0Znipx1fwHYUEBZjNOYoZH1ro7z4IgYDU32kdn0,1067
+grongier/pex/__init__.py,sha256=CPLDFa4dusvGX9VZYTUk-M0Xa_yR4e4Gqku1rIT75qo,1060
 grongier/pex/__main__.py,sha256=pQzVtkDhAeI6dpNRC632dVk2SGZZIEDwDufdgZe8VWs,98
 grongier/pex/_business_host.py,sha256=dlV8CWJad8Pr2TNfD9OjcVKaq5gEYQACZla1FK6-bDM,44
 grongier/pex/_cli.py,sha256=hOHz3n-aHtULuhdCkqZ_SSb3sv7M6j2WhRxgCTvgR9I,64
@@ -90,7 +90,7 @@ intersystems_iris/pex/_InboundAdapter.py,sha256=gZlWl7afumamkj8pNbpLyKFSzhaTAiAX
 intersystems_iris/pex/_Message.py,sha256=Ugaa_lsEYke__pI5kdC7phAuyPQ7rxXUcROJL4cUxVQ,320
 intersystems_iris/pex/_OutboundAdapter.py,sha256=ao2Ubbta2DcrQGdzDUD_j1Zsk8bvUfcZNKTZkzPTNBU,1628
 intersystems_iris/pex/__init__.py,sha256=l_I1dpnluWawbFrGMDC0GLHpuHwjbpd-nho8otFX6TE,1379
-iop/__init__.py,sha256=fX1Osx2Dmcuv8C5hmvoG4fPDIbk0qksJcIgpQibJ_p4,1067
+iop/__init__.py,sha256=1C589HojSVK0yJf1KuTPA39ZjrOYO0QFLv45rqbZpA4,1183
 iop/__main__.py,sha256=pQzVtkDhAeI6dpNRC632dVk2SGZZIEDwDufdgZe8VWs,98
 iop/_async_request.py,sha256=btDFNFaO-Yvl6wvgXrCYNWoQb2RtbzEvTJsk7j03b30,2170
 iop/_business_host.py,sha256=wI2LlVTVjEqE8GWE9nSz1WHvqTduAuJQTk7Ky7qkz4U,9658
@@ -98,31 +98,30 @@ iop/_business_operation.py,sha256=ml4BIn1BfrGx8AUGISFR71DZIUCP8vZ2yn9SQjaSzTM,30
 iop/_business_process.py,sha256=hj6nDIP5Mz5UYbm0vDjvs9lPSEYVQxGJl6tQRcDGTBk,8548
 iop/_business_service.py,sha256=lPTp3_tcLTOWvHlE_YwrcImLGf1PJBUgIOrV-8ctFLw,3851
 iop/_cli.py,sha256=IwvVxglSTVkCDXwANLMqnd8mfxGtWB6GjBSdEy8EMm0,7551
-iop/_common.py,sha256=E_Mn2t--klAtT4p1MzW1KtcKcLrB1g4Flq5H4JlV8Vs,11619
+iop/_common.py,sha256=HnrI6l3TOHSkp3TcbcmLXHW_vrnRI80oD2in5_We2e8,13444
 iop/_decorators.py,sha256=ZpgEETLdKWv58AoSMfXnm3_mA-6qPphIegjG-npDgwg,2324
-iop/_director.py,sha256=DrswFoqJ6IG62hkW-0ZffTtZdxw6KNozlZSIq3O6d-o,11629
-iop/_dispatch.py,sha256=4317Z0ujXxDGUQaL7WX6zfGzBPOdw70MWiqmLUKxhik,6611
+iop/_director.py,sha256=fmsM9b_i0BHiWX5kjUYO9-k2A5Cz7Kg0435Dh7jwoFI,11542
+iop/_dispatch.py,sha256=I3TAhvTuk8j4VcROI9vAitJ0a7Nk1BYAWKRrLeNsjr0,3203
 iop/_inbound_adapter.py,sha256=PS5ToqhrYcXq9ZdLbCBqAfVp8kCeRACm_KF66pwBO9U,1652
-iop/_log_manager.py,sha256=PZnGWsi-zvWo-bumQO5BK-8kHG2XW-WnZ6ShL7QeZ4c,3499
-iop/_message.py,sha256=LSkfZcmEu1aj2hdSg3sUHSWNc8tWWZR8Q2_h9_axVrs,325
-iop/_message_validator.py,sha256=xMMPOZOop3Nv12E3_QPI5caTgYgAzoKlRxcMmUkrj2c,1379
+iop/_log_manager.py,sha256=f9T8yhcVJlCVNY7E_tb2e65QB_rJWYNF6J586OV2ukA,3240
+iop/_message.py,sha256=pJQOjRIdw4wSDoJamvItGODMe-UjDU71XihgWdtCAqc,1120
+iop/_message_validator.py,sha256=K6FxLe72gBHQXZTLVrFw87rABGM0F6CTaNtZ2MqJoss,1408
 iop/_outbound_adapter.py,sha256=YTAhLrRf9chEAd53mV6KKbpaHOKNOKJHoGgj5wakRR0,726
-iop/_pickle_message.py,sha256=noKfc2VkXufV3fqjKvNHN_oANQ1YN9ffCaSV0XSTAIE,331
 iop/_private_session_duplex.py,sha256=mzlFABh-ly51X1uSWw9YwQbktfMvuNdp2ALlRvlDow4,5152
 iop/_private_session_process.py,sha256=todprfYFSDr-h-BMvWL_IGC6wbQqkMy3mPHWEWCUSE0,1686
-iop/_serialization.py,sha256=jHJGTMpKI2QDcF_m7R0WyH_J-vjQyYpNpD0ktn9Rqo4,8106
-iop/_utils.py,sha256=Aqtp9Jx3ghzkNs4f2cOZXYwv8cGsjmdBocnkP64fa3M,19574
+iop/_serialization.py,sha256=EEhPbRpgODsGEt3RMiThr5g7Ox6lOT28XFQeAQq2eik,6162
+iop/_utils.py,sha256=jj1UZHVXYg5uB08E0ETKfpmXQX-TWYSdPl4BO43k2RY,19976
 iop/cls/IOP/BusinessOperation.cls,sha256=lrymqZ8wHl5kJjXwdjbQVs5sScV__yIWGh-oGbiB_X0,914
 iop/cls/IOP/BusinessProcess.cls,sha256=s3t38w1ykHqM26ETcbCYLt0ocjZyVVahm-_USZkuJ1E,2855
 iop/cls/IOP/BusinessService.cls,sha256=7ebn32J9PiZXUgXuh5Xxm_7X6zHBiqkJr9c_dWxbPO8,1021
-iop/cls/IOP/Common.cls,sha256=mJvfTGxJeqLDlBxdnCt-hYiVZEJpfvmdzYEC_UqKeHo,11234
+iop/cls/IOP/Common.cls,sha256=vrS9yo4aUgMiLwfhBFJvj7hG6zYQfcSIiu5o1hdppuU,11355
 iop/cls/IOP/Director.cls,sha256=M43LoTb6lwSr0J81RFxi1YLW1mwda09wQ7Xqr3nBtxo,2008
 iop/cls/IOP/InboundAdapter.cls,sha256=GeoCm6q5HcLJ5e4VxgqXiErJXqolBbpKwpunaNzpvjU,610
 iop/cls/IOP/Message.cls,sha256=ZrYQHosgfTG9wv7i-WQ8j71YXZMmL4_mN16xtIDwcRg,25180
 iop/cls/IOP/OutboundAdapter.cls,sha256=9eOwy5ojwcTzwrHs6LNrFQvUD8aqcoNCZrILN1ycdDM,958
 iop/cls/IOP/PickleMessage.cls,sha256=S3y7AClQ8mAILjxPuHdCjGosBZYzGbUQ5WTv4mYPNMQ,1673
 iop/cls/IOP/Test.cls,sha256=gAC9PEfMZsvAEWIa241-ug2FWAhITbN1SOispZzJPnI,2094
-iop/cls/IOP/Utils.cls,sha256=ZTBr02spm4ppxVBfhnUwb08BmhTjG5-ZbItRshYHs1I,13746
+iop/cls/IOP/Utils.cls,sha256=gQBp0lC4F7FWkv1JEDe45qsaLcVlg995t2th46nDGx8,15745
 iop/cls/IOP/Duplex/Operation.cls,sha256=K_fmgeLjPZQbHgNrc0kd6DUQoW0fDn1VHQjJxHo95Zk,525
 iop/cls/IOP/Duplex/Process.cls,sha256=xbefZ4z84a_IUhavWN6P_gZBzqkdJ5XRTXxro6iDvAg,6986
 iop/cls/IOP/Duplex/Service.cls,sha256=sTMOQUCMBgVitmQkM8bbsrmrRtCdj91VlctJ3I7b8WU,161
@@ -134,11 +133,11 @@ iop/cls/IOP/PrivateSession/Message/Start.cls,sha256=uk-WTe66GicCshgmVy3F5ugHiAyP
 iop/cls/IOP/PrivateSession/Message/Stop.cls,sha256=7g3gKFUjNg0WXBLuWnj-VnCs5G6hSE09YTzGEp0zbGc,1390
 iop/cls/IOP/Service/WSGI.cls,sha256=VLNCXEwmHW9dBnE51uGE1nvGX6T4HjhqePT3LVhsjAE,10440
 iop/wsgi/handlers.py,sha256=NrFLo_YbAh-x_PlWhAiWkQnUUN2Ss9HoEm63dDWCBpQ,2947
+iris_pex_embedded_python-3.4.0.dist-info/licenses/LICENSE,sha256=rZSiBFId_sfbJ6RL0GjjPX-InNLkNS9ou7eQsikciI8,1089
 irisnative/_IRISNative.py,sha256=HQ4nBhc8t8_5OtxdMG-kx1aa-T1znf2I8obZOPLOPzg,665
 irisnative/__init__.py,sha256=6YmvBLQSURsCPKaNg7LK-xpo4ipDjrlhKuwdfdNb3Kg,341
-iris_pex_embedded_python-3.3.1.dist-info/LICENSE,sha256=rZSiBFId_sfbJ6RL0GjjPX-InNLkNS9ou7eQsikciI8,1089
-iris_pex_embedded_python-3.3.1.dist-info/METADATA,sha256=dsJ4pvP-mBaxashySn6A9FgZ6pKVLjidQBu_dRC_fZY,4425
-iris_pex_embedded_python-3.3.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-iris_pex_embedded_python-3.3.1.dist-info/entry_points.txt,sha256=pj-i4LSDyiSP6xpHlVjMCbg1Pik7dC3_sdGY3Yp9Vhk,38
-iris_pex_embedded_python-3.3.1.dist-info/top_level.txt,sha256=VWDlX4YF4qFVRGrG3-Gs0kgREol02i8gIpsHNbhfFPw,42
-iris_pex_embedded_python-3.3.1.dist-info/RECORD,,
+iris_pex_embedded_python-3.4.0.dist-info/METADATA,sha256=TFlJSzZBj5MucQV3yMzyEnjkDEff9XXx5nCkTsnooSU,4417
+iris_pex_embedded_python-3.4.0.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+iris_pex_embedded_python-3.4.0.dist-info/entry_points.txt,sha256=pj-i4LSDyiSP6xpHlVjMCbg1Pik7dC3_sdGY3Yp9Vhk,38
+iris_pex_embedded_python-3.4.0.dist-info/top_level.txt,sha256=VWDlX4YF4qFVRGrG3-Gs0kgREol02i8gIpsHNbhfFPw,42
+iris_pex_embedded_python-3.4.0.dist-info/RECORD,,

{iris_pex_embedded_python-3.3.1.dist-info → iris_pex_embedded_python-3.4.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (77.0.3)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

iop/_pickle_message.py

@@ -1,6 +0,0 @@
-class _PickleMessage:
-    """ The abstract class that is the superclass for persistent messages sent from one component to another.
-    This class has no properties or methods. Users subclass Message and add properties.
-    The PEX framework provides the persistence to objects derived from the Message class.
-    """
-    pass