iris-pex-embedded-python 3.2.1b3__tar.gz → 3.3.0__tar.gz

{iris_pex_embedded_python-3.2.1b3 → iris_pex_embedded_python-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: iris_pex_embedded_python
-Version: 3.2.1b3
+Version: 3.3.0
 Summary: Iris Interoperability based on Embedded Python
 Author-email: grongier <guillaume.rongier@intersystems.com>
 License: MIT License

{iris_pex_embedded_python-3.2.1b3 → iris_pex_embedded_python-3.3.0}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools", "wheel"]
 
 [project]
 name = "iris_pex_embedded_python"
-version = "3.2.1b3"
+version = "3.3.0"
 description = "Iris Interoperability based on Embedded Python"
 readme = "README.md"
 authors = [

iris_pex_embedded_python-3.3.0/src/iop/_async_request.py

@@ -0,0 +1,62 @@
+import asyncio
+import iris
+from typing import Any, Optional, Union
+from iop._dispatch import dispatch_deserializer, dispatch_serializer
+from iop._message import _Message as Message
+
+class AsyncRequest(asyncio.Future):
+    _message_header_id: int = 0
+    _queue_name: str = ""
+    _end_time: int = 0
+    _response: Any = None
+    _done: bool = False
+
+    def __init__(self, target: str, request: Union[Message, Any], 
+                 timeout: int = -1, description: Optional[str] = None, host: Optional[Any] = None) -> None:
+        super().__init__()
+        self.target = target
+        self.request = request
+        self.timeout = timeout
+        self.description = description
+        self.host = host
+        self._iris_handle = host.iris_handle
+        asyncio.create_task(self.send())
+
+    async def send(self) -> None:
+        # init parameters
+        message_header_id = iris.ref()
+        queue_name = iris.ref()
+        end_time = iris.ref()
+        request = dispatch_serializer(self.request)
+
+        # send request
+        self._iris_handle.dispatchSendRequestAsyncNG(
+            self.target, request, self.timeout, self.description,
+            message_header_id, queue_name, end_time)
+        
+        # get byref values
+        self._message_header_id = message_header_id.value
+        self._queue_name = queue_name.value
+        self._end_time = end_time.value
+
+        while not self._done:
+            await asyncio.sleep(0.1)
+            self.is_done()
+
+        self.set_result(self._response)
+
+    def is_done(self) -> None:
+        response = iris.ref()
+        status = self._iris_handle.dispatchIsRequestDone(self.timeout, self._end_time,
+                                                       self._queue_name, self._message_header_id,
+                                                       response)
+        
+        self._response = dispatch_deserializer(response.value)
+
+        if status == 2: # message found
+            self._done = True
+        elif status == 1: # message not found
+            pass
+        else:
+            self._done = True
+            self.set_exception(RuntimeError(iris.system.Status.GetOneStatusText(status)))

iris_pex_embedded_python-3.3.0/src/iop/_business_host.py

@@ -0,0 +1,222 @@
+from inspect import getsource
+from typing import Any,List, Optional, Tuple, Union
+
+import iris
+
+from iop._common import _Common
+from iop._message import _Message as Message
+from iop._decorators import input_serializer_param, output_deserializer
+from iop._dispatch import dispatch_serializer, dispatch_deserializer
+from iop._async_request import AsyncRequest
+
+class _BusinessHost(_Common):
+    """Base class for business components that defines common methods.
+    
+    This is a superclass for BusinessService, BusinessProcess, and BusinessOperation that
+    defines common functionality like message serialization/deserialization and request handling.
+    """
+
+    buffer: int = 64000
+    DISPATCH: List[Tuple[str, str]] = []
+
+    @input_serializer_param(1, 'request')
+    @output_deserializer
+    def send_request_sync(self, target: str, request: Union[Message, Any], 
+                         timeout: int = -1, description: Optional[str] = None) -> Any:
+        """Send message synchronously to target component.
+        
+        Args:
+            target: Name of target component
+            request: Message to send
+            timeout: Timeout in seconds, -1 means wait forever 
+            description: Optional description for logging
+            
+        Returns:
+            Response from target component
+            
+        Raises:
+            TypeError: If request is invalid type
+        """
+        return self.iris_handle.dispatchSendRequestSync(target, request, timeout, description)
+
+    @input_serializer_param(1, 'request')
+    def send_request_async(self, target: str, request: Union[Message, Any], 
+                          description: Optional[str] = None) -> None:
+        """Send message asynchronously to target component.
+        
+        Args:
+            target: Name of target component
+            request: Message to send
+            description: Optional description for logging
+            
+        Raises:
+            TypeError: If request is invalid type
+        """
+        return self.iris_handle.dispatchSendRequestAsync(target, request, description)
+    
+    async def send_request_async_ng(self, target: str, request: Union[Message, Any], 
+                                   timeout: int = -1, description: Optional[str] = None) -> Any:
+        """Send message asynchronously to target component with asyncio.
+        
+        Args:
+            target: Name of target component
+            request: Message to send
+            timeout: Timeout in seconds, -1 means wait forever 
+            description: Optional description for logging
+            
+        Returns:
+            Response from target component
+        """
+        return await AsyncRequest(target, request, timeout, description, self)
+
+    def send_multi_request_sync(self, target_request: List[Tuple[str, Union[Message, Any]]], 
+                               timeout: int = -1, description: Optional[str] = None) -> List[Tuple[str, Union[Message, Any], Any, int]]:
+        """Send multiple messages synchronously to target components.
+        
+        Args:
+            target_request: List of tuples (target, request) to send
+            timeout: Timeout in seconds, -1 means wait forever 
+            description: Optional description for logging
+            
+        Returns:
+            List of tuples (target, request, response, status)
+            
+        Raises:
+            TypeError: If target_request is not a list of tuples
+            ValueError: If target_request is empty
+        """
+        self._validate_target_request(target_request)
+        
+        call_list = [self._create_call_structure(target, request) 
+                    for target, request in target_request]
+        
+        response_list = self.iris_handle.dispatchSendRequestSyncMultiple(call_list, timeout)
+        
+        return [(target_request[i][0],
+                target_request[i][1], 
+                dispatch_deserializer(response_list[i].Response),
+                response_list[i].ResponseCode) 
+                for i in range(len(target_request))]
+
+    def _validate_target_request(self, target_request: List[Tuple[str, Union[Message, Any]]]) -> None:
+        """Validate the target_request parameter structure."""
+        if not isinstance(target_request, list):
+            raise TypeError("target_request must be a list")
+        if not target_request:
+            raise ValueError("target_request must not be empty")
+        if not all(isinstance(item, tuple) and len(item) == 2 for item in target_request):
+            raise TypeError("target_request must contain tuples of (target, request)")
+
+    def _create_call_structure(self, target: str, request: Union[Message, Any]) -> Any:
+        """Create an Ens.CallStructure object for the request."""
+        call = iris.cls("Ens.CallStructure")._New()
+        call.TargetDispatchName = target
+        call.Request = dispatch_serializer(request)
+        return call
+
+    @staticmethod
+    def OnGetConnections() -> Optional[List[str]]:
+        """The OnGetConnections() method returns all of the targets of any SendRequestSync or SendRequestAsync
+        calls for the class. Implement this method to allow connections between components to show up in 
+        the interoperability UI.
+
+        Returns:
+            An IRISList containing all targets for this class. Default is None.
+        """
+        return None
+
+    def SendRequestSync(self, target: str, request: Union[Message, Any], 
+                       timeout: int = -1, description: Optional[str] = None) -> Any:
+        """DEPRECATED: use send_request_sync.
+        
+        Args:
+            target: The target of the request
+            request: The request to send
+            timeout: The timeout in seconds, -1 means wait forever 
+            description: A string that describes the request
+            
+        Returns:
+            The response from the target component
+        """
+        return self.send_request_sync(target, request, timeout, description)
+        
+    def SendRequestAsync(self, target: str, request: Union[Message, Any], 
+                        description: Optional[str] = None) -> None:
+        """DEPRECATED: use send_request_async.
+        
+        Args:
+            target: The target of the request
+            request: The request to send
+            description: A string that describes the request
+        """
+        return self.send_request_async(target, request, description)
+
+    @staticmethod
+    def getAdapterType() -> Optional[str]:
+        """DEPRECATED: use get_adapter_type.
+        
+        Returns:
+            Name of the registered Adapter
+        """
+        return
+        
+    @staticmethod
+    def get_adapter_type() -> Optional[str]:
+        """Returns the name of the registered Adapter.
+        
+        Returns:
+            Name of the registered Adapter
+        """
+        return 
+    
+    def on_get_connections(self) -> List[str]:
+        """The OnGetConnections() method returns all of the targets of any SendRequestSync or SendRequestAsync
+        calls for the class. Implement this method to allow connections between components to show up in 
+        the interoperability UI.
+
+        Returns:
+            A list containing all targets for this class.
+        """
+        ## Parse the class code to find all invocations of send_request_sync and send_request_async
+        ## and return the targets
+        targer_list = []
+        # get the source code of the class
+        source = getsource(self.__class__)
+        # find all invocations of send_request_sync and send_request_async
+        for method in ['send_request_sync', 'send_request_async', 'SendRequestSync', 'SendRequestAsync']:
+            i = source.find(method)
+            while i != -1:
+                j = source.find("(", i)
+                if j != -1:
+                    k = source.find(",", j)
+                    if k != -1:
+                        target = source[j+1:k]
+                        if target.find("=") != -1:
+                            # it's a keyword argument, remove the keyword
+                            target = target[target.find("=")+1:].strip()
+                        if target not in targer_list:
+                            targer_list.append(target)
+                i = source.find(method, i+1)
+
+        for target in targer_list:
+            # if target is a string, remove the quotes
+            if target[0] == "'" and target[-1] == "'":
+                targer_list[targer_list.index(target)] = target[1:-1]
+            elif target[0] == '"' and target[-1] == '"':
+                targer_list[targer_list.index(target)] = target[1:-1]
+            # if target is a variable, try to find the value of the variable
+            else:
+                self.on_init()
+                try:
+                    if target.find("self.") != -1:
+                        # it's a class variable
+                        targer_list[targer_list.index(target)] = getattr(self, target[target.find(".")+1:])
+                    elif target.find(".") != -1:
+                        # it's a class variable
+                        targer_list[targer_list.index(target)] = getattr(getattr(self, target[:target.find(".")]), target[target.find(".")+1:])
+                    else:
+                        targer_list[targer_list.index(target)] = getattr(self, target)
+                except Exception as e:
+                    pass
+
+        return targer_list

{iris_pex_embedded_python-3.2.1b3 → iris_pex_embedded_python-3.3.0}/src/iop/_business_operation.py

@@ -1,6 +1,8 @@
 import importlib
 from typing import Any, List, Optional, Union, Tuple
 from iop._business_host import _BusinessHost
+from iop._decorators import input_deserializer, output_serializer, input_serializer, output_deserializer
+from iop._dispatch import create_dispatch, dispach_message
 
 class _BusinessOperation(_BusinessHost):
     """Business operation component that handles outbound communication.
@@ -45,15 +47,15 @@ class _BusinessOperation(_BusinessHost):
 
     def _dispatch_on_init(self, host_object: Any) -> None:
         """For internal use only."""
-        self._create_dispatch()
+        create_dispatch(self)
         self.on_init()
         return
 
-    @_BusinessHost.input_deserialzer
-    @_BusinessHost.output_serialzer
+    @input_deserializer
+    @output_serializer
     def _dispatch_on_message(self, request: Any) -> Any:
         """For internal use only."""
-        return self._dispach_message(request)
+        return dispach_message(self,request)
 
     def OnMessage(self, request: Any) -> Any:
         """DEPRECATED : use on_message

{iris_pex_embedded_python-3.2.1b3 → iris_pex_embedded_python-3.3.0}/src/iop/_business_process.py

@@ -1,5 +1,7 @@
 from typing import Any, List, Optional, Union
 from iop._business_host import _BusinessHost
+from iop._decorators import input_deserializer, input_serializer_param, output_serializer, input_serializer, output_deserializer
+from iop._dispatch import create_dispatch, dispach_message
 
 class _BusinessProcess(_BusinessHost):
     """Business process component that contains routing and transformation logic.
@@ -60,7 +62,7 @@ class _BusinessProcess(_BusinessHost):
         """
         return self.OnComplete(request, response)
 
-    @_BusinessHost.input_serialzer_param(0,'response')
+    @input_serializer_param(0,'response')
     def reply(self, response: Any) -> None:
         """Send the specified response to the production component that sent the initial request.
 
@@ -69,7 +71,7 @@ class _BusinessProcess(_BusinessHost):
         """
         return self.iris_handle.dispatchReply(response)
     
-    @_BusinessHost.input_serialzer_param(1,'request')
+    @input_serializer_param(1,'request')
     def send_request_async(self, target: str, request: Any, response_required: bool=True, completion_key: Optional[str]=None, description: Optional[str]=None) -> None:
         """Send the specified message to the target business process or business operation asynchronously.
         
@@ -139,7 +141,7 @@ class _BusinessProcess(_BusinessHost):
     def _dispatch_on_init(self, host_object: Any) -> None:
         """For internal use only."""
         self._restore_persistent_properties(host_object)
-        self._create_dispatch()
+        create_dispatch(self)
         self.on_init()
         self._save_persistent_properties(host_object)
         return
@@ -151,17 +153,17 @@ class _BusinessProcess(_BusinessHost):
         self._save_persistent_properties(host_object)
         return
 
-    @_BusinessHost.input_deserialzer
-    @_BusinessHost.output_serialzer
+    @input_deserializer
+    @output_serializer
     def _dispatch_on_request(self, host_object: Any, request: Any) -> Any:
         """For internal use only."""
         self._restore_persistent_properties(host_object)
-        return_object = self._dispach_message(request)
+        return_object = dispach_message(self,request)
         self._save_persistent_properties(host_object)
         return return_object
     
-    @_BusinessHost.input_deserialzer
-    @_BusinessHost.output_serialzer
+    @input_deserializer
+    @output_serializer
     def _dispatch_on_response(self, host_object: Any, request: Any, response: Any, call_request: Any, call_response: Any, completion_key: str) -> Any:
         """For internal use only."""
         self._restore_persistent_properties(host_object)
@@ -169,8 +171,8 @@ class _BusinessProcess(_BusinessHost):
         self._save_persistent_properties(host_object)
         return return_object
 
-    @_BusinessHost.input_deserialzer
-    @_BusinessHost.output_serialzer
+    @input_deserializer
+    @output_serializer
     def _dispatch_on_complete(self, host_object: Any, request: Any, response: Any) -> Any:
         """For internal use only."""
         self._restore_persistent_properties(host_object)

{iris_pex_embedded_python-3.2.1b3 → iris_pex_embedded_python-3.3.0}/src/iop/_business_service.py

@@ -1,5 +1,6 @@
 import importlib
 from iop._business_host import _BusinessHost
+from iop._decorators import input_deserializer, output_serializer, input_serializer, output_deserializer
 
 class _BusinessService(_BusinessHost):
     """ This class is responsible for receiving the data from external system and sending it to business processes or business operations in the production.
@@ -36,8 +37,8 @@ class _BusinessService(_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)

{iris_pex_embedded_python-3.2.1b3 → iris_pex_embedded_python-3.3.0}/src/iop/_cli.py

@@ -143,8 +143,10 @@ class Command:
         _Utils.migrate(migrate_path)
 
     def _handle_log(self) -> None:
-        log_name = _Director.get_default_production() if self.args.log == 'not_set' else self.args.log
-        print(_Director.get_production_log(log_name))
+        if self.args.log == 'not_set':
+            print(_Director.log_production())
+        else:
+            print(_Director.log_production_top(self.args.log))
 
     def _handle_init(self) -> None:
         _Utils.setup(None)

{iris_pex_embedded_python-3.2.1b3 → iris_pex_embedded_python-3.3.0}/src/iop/_common.py

@@ -1,11 +1,11 @@
 import abc
-import dataclasses
 import inspect
-import iris
 import traceback
-from typing import Any, ClassVar, Dict, List, Optional, Tuple, Type
-from iop._log_manager import LogManager
-import logging
+from typing import Any, ClassVar, List, Optional, Tuple
+
+import iris
+
+from iop._log_manager import LogManager, logging
 
 class _Common(metaclass=abc.ABCMeta):
     """Base class that defines common methods for all component types.
@@ -19,100 +19,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 +173,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.
         

iris_pex_embedded_python-3.3.0/src/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

{iris_pex_embedded_python-3.2.1b3 → iris_pex_embedded_python-3.3.0}/src/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():
@@ -221,7 +222,7 @@ class _Director():
                     await asyncio.sleep(1)
 
     @staticmethod
-    def log_production_top(top):
+    def log_production_top(top=10):
         """ 
         Log the top N logs of the production
         Parameters:
@@ -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)}'