iris-pex-embedded-python 3.2.1b3__py3-none-any.whl → 3.3.0b2__py3-none-any.whl

iop/_common.py

@@ -7,6 +7,8 @@ from typing import Any, ClassVar, Dict, List, Optional, Tuple, Type
 from iop._log_manager import LogManager
 import logging
 
+from iop._message_validator import is_iris_object_instance, is_message_instance, is_pickle_message_instance
+
 class _Common(metaclass=abc.ABCMeta):
     """Base class that defines common methods for all component types.
     
@@ -19,100 +21,34 @@ class _Common(metaclass=abc.ABCMeta):
     iris_handle: Any = None
     log_to_console: bool = False
 
+    # Lifecycle methods
     def on_init(self) -> None:
-        """Initialize component when started.
-        
-        Called when component starts. Use to initialize required structures.
-        """
-        return self.OnInit()
+        """Initialize component when started."""
+        pass
 
     def on_tear_down(self) -> None:
-        """Clean up component before termination.
-        
-        Called before component terminates. Use to free resources.
-        """
-        return self.OnTearDown()
+        """Clean up component before termination."""
+        pass
 
     def on_connected(self) -> None:
-        """Handle component connection/reconnection.
-        
-        Called when component connects or reconnects after disconnection.
-        Use to initialize connection-dependent structures.
-        """
-        return self.OnConnected()
+        """Handle component connection/reconnection."""
+        pass
 
+    # Internal dispatch methods 
     def _dispatch_on_connected(self, host_object: Any) -> None:
-        """Internal dispatch for connection handling."""
         self.on_connected()
-        return
 
     def _dispatch_on_init(self, host_object: Any) -> None:
-        """Internal dispatch for initialization."""
         self.on_init()
-        return
 
     def _dispatch_on_tear_down(self, host_object: Any) -> None:
-        """Internal dispatch for teardown."""
         self.on_tear_down()
-        return
 
     def _set_iris_handles(self, handle_current: Any, handle_partner: Any) -> None:
         """Internal method to set IRIS handles."""
         pass
 
-    @classmethod
-    def _is_message_instance(cls, obj: Any) -> bool:
-        """Check if object is a valid Message instance.
-        
-        Args:
-            obj: Object to check
-            
-        Returns:
-            True if object is a Message instance
-            
-        Raises:
-            TypeError: If object is Message class but not a dataclass
-        """
-        if cls._is_message_class(type(obj)):
-            if not dataclasses.is_dataclass(obj):
-                raise TypeError(f"{type(obj).__module__}.{type(obj).__qualname__} must be a dataclass")
-            return True
-        return False
-
-    @classmethod
-    def _is_pickle_message_instance(cls, obj: Any) -> bool:
-        """Check if object is a PickleMessage instance."""
-        if cls._is_pickel_message_class(type(obj)):
-            return True
-        return False
-    
-    @classmethod
-    def _is_iris_object_instance(cls, obj: Any) -> bool:
-        """Check if object is an IRIS persistent object."""
-        if (obj is not None and type(obj).__module__.find('iris') == 0) and obj._IsA("%Persistent"):
-            return True
-        return False
-
-    @classmethod
-    def _is_message_class(cls, klass: Type) -> bool:
-        name = klass.__module__ + '.' + klass.__qualname__
-        if name == "iop.Message" or name == "grongier.pex.Message": 
-            return True
-        for c in klass.__bases__:
-            if cls._is_message_class(c): 
-                return True
-        return False
-
-    @classmethod
-    def _is_pickel_message_class(cls, klass: Type) -> bool:
-        name = klass.__module__ + '.' + klass.__qualname__
-        if name == "iop.PickleMessage" or name == "grongier.pex.PickleMessage": 
-            return True
-        for c in klass.__bases__:
-            if cls._is_pickel_message_class(c): 
-                return True
-        return False
-
+    # Component information methods
     @classmethod
     def _get_info(cls) -> List[str]:
         """Get component configuration information.
@@ -239,6 +175,7 @@ class _Common(metaclass=abc.ABCMeta):
             pass
         return ret
     
+    # Logging methods
     def _log(self) -> Tuple[str, Optional[str]]:
         """Get class and method name for logging.
         

iop/_decorators.py

@@ -0,0 +1,48 @@
+from functools import wraps
+from typing import Any, Callable
+from iop._dispatch import dispatch_deserializer, dispatch_serializer
+
+def input_serializer(fonction: Callable) -> Callable:
+    """Decorator that serializes all input arguments."""
+    def _dispatch_serializer(self, *params: Any, **param2: Any) -> Any:
+        serialized = [dispatch_serializer(param) for param in params]
+        param2 = {key: dispatch_serializer(value) for key, value in param2.items()}
+        return fonction(self, *serialized, **param2)
+    return _dispatch_serializer
+
+def input_serializer_param(position: int, name: str) -> Callable:
+    """Decorator that serializes specific parameter by position or name."""
+    def _input_serializer_param(fonction: Callable) -> Callable:
+        @wraps(fonction) 
+        def _dispatch_serializer(self, *params: Any, **param2: Any) -> Any:
+            serialized = [
+                dispatch_serializer(param) if i == position else param
+                for i, param in enumerate(params)
+            ]
+            param2 = {
+                key: dispatch_serializer(value) if key == name else value
+                for key, value in param2.items()
+            }
+            return fonction(self, *serialized, **param2)
+        return _dispatch_serializer
+    return _input_serializer_param
+
+def output_deserializer(fonction: Callable) -> Callable:
+    """Decorator that deserializes function output."""
+    def _dispatch_deserializer(self, *params: Any, **param2: Any) -> Any:
+        return dispatch_deserializer(fonction(self, *params, **param2))
+    return _dispatch_deserializer
+
+def input_deserializer(fonction: Callable) -> Callable:
+    """Decorator that deserializes all input arguments."""
+    def _dispatch_deserializer(self, *params: Any, **param2: Any) -> Any:
+        serialized = [dispatch_deserializer(param) for param in params]
+        param2 = {key: dispatch_deserializer(value) for key, value in param2.items()}
+        return fonction(self, *serialized, **param2)
+    return _dispatch_deserializer
+
+def output_serializer(fonction: Callable) -> Callable:
+    """Decorator that serializes function output."""
+    def _dispatch_serializer(self, *params: Any, **param2: Any) -> Any:
+        return dispatch_serializer(fonction(self, *params, **param2))
+    return _dispatch_serializer

iop/_director.py

@@ -7,6 +7,7 @@ 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
 
 class _Director():
@@ -278,10 +279,10 @@ class _Director():
                     message.json = _Utils.string_to_stream("{}")
         # serialize the message
         business_host = _BusinessHost()
-        serial_message = business_host._dispatch_serializer(message)
+        serial_message = dispatch_serializer(message)
         response = iris.cls('IOP.Utils').dispatchTestComponent(target,serial_message)
         try:
-            deserialized_response = business_host._dispatch_deserializer(response)
+            deserialized_response = dispatch_deserializer(response)
         except ImportError as e:
             # can't import the class, return the string
             deserialized_response = f'{response.classname} : {_Utils.stream_to_string(response.jstr)}'

iop/_dispatch.py

@@ -0,0 +1,219 @@
+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 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.
+    """
+    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

iop/_log_manager.py

@@ -46,6 +46,23 @@ class IRISLogHandler(logging.Handler):
         self.method_name = method_name
         self.to_console = to_console
 
+        # Map Python logging levels to IRIS logging methods
+        self.level_map = {
+            logging.DEBUG: iris.cls("Ens.Util.Log").LogTrace,
+            logging.INFO: iris.cls("Ens.Util.Log").LogInfo,
+            logging.WARNING: iris.cls("Ens.Util.Log").LogWarning,
+            logging.ERROR: iris.cls("Ens.Util.Log").LogError,
+            logging.CRITICAL: iris.cls("Ens.Util.Log").LogAlert,
+        }
+        # Map Python logging levels to IRIS logging Console level
+        self.level_map_console = {
+            logging.DEBUG: -1,
+            logging.INFO: 0,
+            logging.WARNING: 1,
+            logging.ERROR: 2,
+            logging.CRITICAL: 3,
+        }
+
     def format(self, record: logging.LogRecord) -> str:
         """Format the log record into a string.
         
@@ -55,8 +72,6 @@ class IRISLogHandler(logging.Handler):
         Returns:
             Formatted log message
         """
-        if self.to_console:
-            return f"{record}"
         return record.getMessage()
 
     def emit(self, record: logging.LogRecord) -> None:
@@ -65,17 +80,10 @@ class IRISLogHandler(logging.Handler):
         Args:
             record: The logging record to emit
         """
-        # Map Python logging levels to IRIS logging methods
-        level_map = {
-            logging.DEBUG: iris.cls("Ens.Util.Log").LogTrace,
-            logging.INFO: iris.cls("Ens.Util.Log").LogInfo,
-            logging.WARNING: iris.cls("Ens.Util.Log").LogWarning,
-            logging.ERROR: iris.cls("Ens.Util.Log").LogError,
-            logging.CRITICAL: iris.cls("Ens.Util.Log").LogAlert,
-        }
 
-        log_func = level_map.get(record.levelno, iris.cls("Ens.Util.Log").LogInfo)
+        log_func = self.level_map.get(record.levelno, iris.cls("Ens.Util.Log").LogInfo)
         if self.to_console or (hasattr(record, "to_console") and record.to_console):
-            iris.cls("%SYS.System").WriteToConsoleLog(self.format(record),0,0,"IoP.Log")
+            iris.cls("%SYS.System").WriteToConsoleLog(self.format(record),
+                0,self.level_map_console.get(record.levelno, 0),record.name)
         else:
             log_func(self.class_name, self.method_name, self.format(record))

iop/_message_validator.py

@@ -0,0 +1,41 @@
+import dataclasses
+from typing import Any, Type
+
+
+def is_message_instance(obj: Any) -> bool:
+    """Check if object is a valid Message instance."""
+    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")
+        return True
+    return False
+
+
+def is_pickle_message_instance(obj: Any) -> bool:
+    """Check if object is a PickleMessage instance."""
+    if is_pickle_message_class(type(obj)):
+        return True
+    return False
+
+
+def is_iris_object_instance(obj: Any) -> bool:
+    """Check if object is an IRIS persistent object."""
+    return (obj is not None and 
+            type(obj).__module__.startswith('iris') and 
+            obj._IsA("%Persistent"))
+
+
+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"): 
+        return True
+    return any(is_message_class(c) for c in klass.__bases__)
+
+
+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"):
+        return True
+    return any(is_pickle_message_class(c) for c in klass.__bases__)

iop/_private_session_duplex.py

@@ -1,5 +1,6 @@
 import importlib
 from iop._business_host import _BusinessHost
+from iop._decorators import input_deserializer, input_serializer_param, output_serializer, input_serializer, output_deserializer
 
 class _PrivateSessionDuplex(_BusinessHost):
     
@@ -21,8 +22,8 @@ class _PrivateSessionDuplex(_BusinessHost):
         """
         pass
 
-    @_BusinessHost.input_deserialzer
-    @_BusinessHost.output_serialzer
+    @input_deserializer
+    @output_serializer
     def _dispatch_on_message(self, request):
         """ For internal use only. """
         return self._dispach_message(request)
@@ -38,8 +39,8 @@ class _PrivateSessionDuplex(_BusinessHost):
         self.Adapter = self.adapter = handle_partner
         return
 
-    @_BusinessHost.input_deserialzer
-    @_BusinessHost.output_serialzer
+    @input_deserializer
+    @output_serializer
     def _dispatch_on_process_input(self, request):
         """ For internal use only. """
         return self.on_process_input(request)
@@ -55,8 +56,8 @@ class _PrivateSessionDuplex(_BusinessHost):
         """
         return 
 
-    @_BusinessHost.input_serialzer_param(0,'document')
-    @_BusinessHost.output_deserialzer
+    @input_serializer_param(0,'document')
+    @output_deserializer
     def send_document_to_process(self, document):
         """ Send the specified message to the target business process or business operation synchronously.
             
@@ -75,8 +76,8 @@ class _PrivateSessionDuplex(_BusinessHost):
 
         return self.iris_handle.dispatchSendDocumentToProcess(document)
 
-    @_BusinessHost.input_deserialzer
-    @_BusinessHost.output_serialzer
+    @input_deserializer
+    @output_serializer
     def _dispatch_on_private_session_started(self, source_config_name,self_generated):
         """ For internal use only. """
 
@@ -87,8 +88,8 @@ class _PrivateSessionDuplex(_BusinessHost):
     def on_private_session_started(self,source_config_name,self_generated):
         pass
 
-    @_BusinessHost.input_deserialzer
-    @_BusinessHost.output_serialzer
+    @input_deserializer
+    @output_serializer
     def _dispatch_on_private_session_stopped(self, source_config_name,self_generated,message):
         """ For internal use only. """
 

iop/_private_session_process.py

@@ -1,10 +1,10 @@
 from iop._business_process import _BusinessProcess
-from iop._business_host import _BusinessHost
+from iop._decorators import input_deserializer, output_serializer, input_serializer, output_deserializer
 
 class _PrivateSessionProcess(_BusinessProcess):
     
-    @_BusinessHost.input_deserialzer
-    @_BusinessHost.output_serialzer
+    @input_deserializer
+    @output_serializer
     def _dispatch_on_document(self, host_object,source_config_name, request):
         """ For internal use only. """
         self._restore_persistent_properties(host_object)
@@ -16,8 +16,8 @@ class _PrivateSessionProcess(_BusinessProcess):
         pass
 
 
-    @_BusinessHost.input_deserialzer
-    @_BusinessHost.output_serialzer
+    @input_deserializer
+    @output_serializer
     def _dispatch_on_private_session_started(self, host_object, source_config_name,self_generated):
         """ For internal use only. """
         self._restore_persistent_properties(host_object)
@@ -28,8 +28,8 @@ class _PrivateSessionProcess(_BusinessProcess):
     def on_private_session_started(self,source_config_name,self_generated):
         pass
 
-    @_BusinessHost.input_deserialzer
-    @_BusinessHost.output_serialzer
+    @input_deserializer
+    @output_serializer
     def _dispatch_on_private_session_stopped(self, host_object, source_config_name,self_generated,message):
         """ For internal use only. """
         self._restore_persistent_properties(host_object)