iris-pex-embedded-python 3.5.5b4__py3-none-any.whl

iop/_business_host.py

@@ -0,0 +1,256 @@
+from inspect import getsource
+from typing import Any,List, Optional, Tuple, Union
+
+from . import _iris
+from ._common import _Common
+from ._message import _Message as Message
+from ._decorators import input_serializer_param, output_deserializer, input_deserializer, output_serializer
+from ._dispatch import dispatch_serializer, dispatch_deserializer, dispach_message
+from ._async_request import AsyncRequest
+from ._generator_request import _GeneratorRequest
+
+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_generator_request(self, target: str, request: Union[Message, Any], 
+                              timeout: int = -1, description: Optional[str] = None) -> _GeneratorRequest:
+        """Send message as a generator request 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:
+            _GeneratorRequest: An instance of _GeneratorRequest to iterate over responses
+        Raises:
+            TypeError: If request is not of type Message
+        """
+        return _GeneratorRequest(self, target, request, timeout, description)
+
+    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."""
+        iris = _iris.get_iris()
+        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
+        target_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 target_list:
+                            target_list.append(target)
+                i = source.find(method, i+1)
+
+        for target in target_list:
+            # if target is a string, remove the quotes
+            if target[0] == "'" and target[-1] == "'":
+                target_list[target_list.index(target)] = target[1:-1]
+            elif target[0] == '"' and target[-1] == '"':
+                target_list[target_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
+                        target_list[target_list.index(target)] = getattr(self, target[target.find(".")+1:])
+                    elif target.find(".") != -1:
+                        # it's a class variable
+                        target_list[target_list.index(target)] = getattr(getattr(self, target[:target.find(".")]), target[target.find(".")+1:])
+                    else:
+                        target_list[target_list.index(target)] = getattr(self, target)
+                except Exception as e:
+                    pass
+
+        return target_list
+
+    @input_deserializer
+    def _dispatch_generator_started(self, request: Any) -> Any:
+        """For internal use only."""
+        self._gen = dispach_message(self, request)
+        # check if self._gen is a generator
+        if not hasattr(self._gen, '__iter__'):
+            raise TypeError("Expected a generator or iterable object, got: {}".format(type(self._gen).__name__))
+        
+        return _iris.get_iris().IOP.Generator.Message.Ack._New()
+    
+    @output_serializer
+    def _dispatch_generator_poll(self) -> Any:
+        """For internal use only."""
+        try:
+            return next(self._gen)
+        except StopIteration:
+            return _iris.get_iris().IOP.Generator.Message.Stop._New()

iop/_business_operation.py

@@ -0,0 +1,75 @@
+import importlib
+from typing import Any, List, Optional, Union, Tuple
+
+from ._business_host import _BusinessHost
+from ._decorators import input_deserializer, output_serializer, input_serializer, output_deserializer
+from ._dispatch import create_dispatch, dispach_message
+
+class _BusinessOperation(_BusinessHost):
+    """Business operation component that handles outbound communication.
+    
+    Responsible for sending messages to external systems. Can optionally use an 
+    adapter to handle the outbound messaging protocol.
+    """
+
+    DISPATCH: List[Tuple[str, str]] = []
+    Adapter: Any = None
+    adapter: Any = None
+
+    def on_message(self, request: Any) -> Any:
+        """Handle incoming messages.
+        
+        Process messages received from other production components and either
+        send to external system or forward to another component.
+
+        Args:
+            request: The incoming message
+            
+        Returns:
+            Response message
+        """
+        return self.OnMessage(request)
+
+    def on_keepalive(self) -> None:
+        """
+        Called when the server sends a keepalive message.
+        """
+        return
+
+    def _set_iris_handles(self, handle_current: Any, handle_partner: Any) -> None:
+        """For internal use only."""
+        self.iris_handle = handle_current
+        if type(handle_partner).__module__.find('iris') == 0:
+            if handle_partner._IsA("Grongier.PEX.OutboundAdapter") or handle_partner._IsA("IOP.OutboundAdapter"):
+                module = importlib.import_module(handle_partner.GetModule())
+                handle_partner = getattr(module, handle_partner.GetClassname())()
+            self.Adapter = self.adapter = handle_partner
+        return
+
+    def _dispatch_on_init(self, host_object: Any) -> None:
+        """For internal use only."""
+        create_dispatch(self)
+        self.on_init()
+        return
+
+    @input_deserializer
+    @output_serializer
+    def _dispatch_on_message(self, request: Any) -> Any:
+        """For internal use only."""
+        return dispach_message(self,request)
+
+    def OnMessage(self, request: Any) -> Any:
+        """DEPRECATED : use on_message
+        Called when the business operation receives a message from another production component.
+        Typically, the operation will either send the message to the external system or forward it to a business process or another business operation.
+        If the operation has an adapter, it uses the Adapter.invoke() method to call the method on the adapter that sends the message to the external system.
+        If the operation is forwarding the message to another production component, it uses the SendRequestAsync() or the SendRequestSync() method
+
+        Parameters:
+        request: An instance of either a subclass of Message or of IRISObject containing the incoming message for the business operation.
+
+        Returns:
+        The response object
+        """
+        return
+    

iop/_business_process.py

@@ -0,0 +1,224 @@
+from typing import Any, List, Optional, Union
+
+from ._business_host import _BusinessHost
+from ._decorators import input_deserializer, input_serializer_param, output_serializer, input_serializer, output_deserializer
+from ._dispatch import create_dispatch, dispach_message
+
+class _BusinessProcess(_BusinessHost):
+    """Business process component that contains routing and transformation logic.
+    
+    A business process can receive messages from services, other processes, or operations.
+    It can modify messages, transform formats, and route based on content.
+    """
+
+    DISPATCH: List[tuple] = []
+    PERSISTENT_PROPERTY_LIST: Optional[List[str]] = None
+
+    def on_message(self, request: Any) -> Any:
+        """Handle incoming messages.
+
+        Args:
+            request: The incoming message
+
+        Returns:
+            Response message
+        """
+        return self.on_request(request)
+
+    def on_request(self, request: Any) -> Any:
+        """Process initial requests sent to this component.
+        
+        Args:
+            request: The incoming request message
+            
+        Returns:
+            Response message
+        """
+        return self.OnRequest(request)
+
+    def on_response(self, request: Any, response: Any, call_request: Any, call_response: Any, completion_key: str) -> Any:
+        """Handle responses to messages sent by this component.
+        
+        Args:
+            request: The initial request message
+            response: The response message
+            call_request: The request sent to the target
+            call_response: The incoming response
+            completion_key: The completion key specified in the outgoing SendAsync() method
+            
+        Returns:
+            Response message
+        """
+        return self.OnResponse(request, response, call_request, call_response, completion_key)
+
+    def on_complete(self, request: Any, response: Any) -> Any:
+        """Called after all responses to requests sent by this component have been handled.
+        
+        Args:
+            request: The initial request message
+            response: The response message
+            
+        Returns:
+            Response message
+        """
+        return self.OnComplete(request, 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.
+
+        Args:
+            response: The response message
+        """
+        return self.iris_handle.dispatchReply(response)
+    
+    @input_serializer_param(1,'request')
+    def send_request_async(self, target: str, request: Any, description: Optional[str]=None, completion_key: Optional[str]=None, response_required: bool=True) -> None:
+        """Send the specified message to the target business process or business operation asynchronously.
+        
+        Args:
+            target: The name of the business process or operation to receive the request
+            request: The message to send to the target
+            description: An optional description property in the message header
+            completion_key: A string that will be returned with the response if the maximum time is exceeded
+            response_required: Whether a response is required
+            
+        Raises:
+            TypeError: If request is not of type Message or IRISObject
+        """
+        # Convert boolean to int for Iris API
+        if response_required:
+            response_required = 1 # type: ignore
+        else:
+            response_required = 0 # type: ignore
+        return self.iris_handle.dispatchSendRequestAsync(target, request, response_required, completion_key, description)
+
+    def set_timer(self, timeout: Union[int, str], completion_key: Optional[str]=None) -> None:
+        """Specify the maximum time the business process will wait for responses.
+
+        Args:
+            timeout: The maximum time to wait for responses
+            completion_key: A string that will be returned with the response if the maximum time is exceeded
+        """
+        self.iris_handle.dispatchSetTimer(timeout, completion_key)
+        return
+
+    def _set_iris_handles(self, handle_current: Any, handle_partner: Any) -> None:
+        """For internal use only."""
+        self.iris_handle = handle_current
+        return
+
+    def _save_persistent_properties(self, host_object: Any) -> None:
+        """For internal use only."""
+        if self.PERSISTENT_PROPERTY_LIST is None:
+            return
+        for prop in self.PERSISTENT_PROPERTY_LIST:
+            val = getattr(self, prop, None)
+            typ = val.__class__.__name__
+            if typ in ["str", "int", "float", "bool", "bytes"]:
+                try:
+                    host_object.setPersistentProperty(prop, val)
+                except:
+                    pass
+        return
+
+    def _restore_persistent_properties(self, host_object: Any) -> None:
+        """For internal use only."""
+        if self.PERSISTENT_PROPERTY_LIST is None:
+            return
+        for prop in self.PERSISTENT_PROPERTY_LIST:
+            try:
+                val = host_object.getPersistentProperty(prop)
+                setattr(self, prop, val)
+            except:
+                pass
+        return
+
+    def _dispatch_on_connected(self, host_object: Any) -> None:
+        """For internal use only."""
+        self.on_connected()
+        self._save_persistent_properties(host_object)
+        return
+
+    def _dispatch_on_init(self, host_object: Any) -> None:
+        """For internal use only."""
+        self._restore_persistent_properties(host_object)
+        create_dispatch(self)
+        self.on_init()
+        self._save_persistent_properties(host_object)
+        return
+
+    def _dispatch_on_tear_down(self, host_object: Any) -> None:
+        """For internal use only."""
+        self._restore_persistent_properties(host_object)
+        self.on_tear_down()
+        self._save_persistent_properties(host_object)
+        return
+
+    @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 = dispach_message(self,request)
+        self._save_persistent_properties(host_object)
+        return return_object
+    
+    @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)
+        return_object = self.on_response(request, response, call_request, call_response, completion_key)
+        self._save_persistent_properties(host_object)
+        return return_object
+
+    @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)
+        return_object = self.on_complete(request, response)
+        self._save_persistent_properties(host_object)
+        return return_object
+
+    def OnRequest(self, request: Any) -> Any:
+        """ 
+        DEPRECATED: Use on_request.
+        
+        Args:
+            request: The incoming request message
+            
+        Returns:
+            Response message
+        """
+        return 
+
+    def OnResponse(self, request: Any, response: Any, call_request: Any, call_response: Any, completion_key: str) -> Any:
+        """ 
+        DEPRECATED: Use on_response.
+        
+        Args:
+            request: The initial request message
+            response: The response message
+            call_request: The request sent to the target
+            call_response: The incoming response
+            completion_key: The completion key specified in the outgoing SendAsync() method
+            
+        Returns:
+            Response message
+        """
+        return response
+
+    def OnComplete(self, request: Any, response: Any) -> Any:
+        """ 
+        DEPRECATED: Use on_complete.
+        
+        Args:
+            request: The initial request message
+            response: The response message
+            
+        Returns:
+            Response message
+        """
+        return response

iop/_business_service.py

@@ -0,0 +1,63 @@
+import importlib
+
+from ._business_host import _BusinessHost
+from ._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.
+    The business service can use an adapter to access the external system, which is specified in the InboundAdapter property. 
+    There are three ways of implementing a business service:
+    1) Polling business service with an adapter - The production framework at regular intervals calls the adapter’s OnTask() method, 
+        which sends the incoming data to the the business service ProcessInput() method, which, in turn calls the OnProcessInput method with your code.
+    2) Polling business service that uses the default adapter - In this case, the framework calls the default adapter's OnTask method with no data. 
+        The OnProcessInput() method then performs the role of the adapter and is responsible for accessing the external system and receiving the data.
+    3) Nonpolling business service - The production framework does not initiate the business service. Instead custom code in either a long-running process 
+        or one that is started at regular intervals initiates the business service by calling the Director.CreateBusinessService() method.
+    """
+    Adapter = adapter = None
+    _wait_for_next_call_interval = False
+
+    def _dispatch_on_init(self, host_object) -> None:
+        """For internal use only."""
+        self.on_init()
+
+        return
+
+    def on_process_input(self, message_input):
+        """ Receives the message from the inbond adapter via the PRocessInput method and is responsible for forwarding it to target business processes or operations.
+        If the business service does not specify an adapter, then the default adapter calls this method with no message 
+        and the business service is responsible for receiving the data from the external system and validating it.
+
+        Parameters:
+        message_input: an instance of IRISObject or subclass of Message containing the data that the inbound adapter passes in.
+            The message can have any structure agreed upon by the inbound adapter and the business service. 
+        """
+        return self.OnProcessInput(message_input)
+
+    def _set_iris_handles(self, handle_current, handle_partner):
+        """ For internal use only. """
+        self.iris_handle = handle_current
+        if type(handle_partner).__module__.find('iris') == 0:
+            if handle_partner._IsA("Grongier.PEX.InboundAdapter") or handle_partner._IsA("IOP.InboundAdapter"):
+                module = importlib.import_module(handle_partner.GetModule())
+                handle_partner = getattr(module, handle_partner.GetClassname())()
+        self.Adapter = self.adapter = handle_partner
+        return
+    
+    @input_deserializer
+    @output_serializer
+    def _dispatch_on_process_input(self, request):
+        """ For internal use only. """
+        return self.on_process_input(request)
+
+    def OnProcessInput(self, message_input):
+        """  DEPRECATED : use on_process_input
+        Receives the message from the inbond adapter via the PRocessInput method and is responsible for forwarding it to target business processes or operations.
+        If the business service does not specify an adapter, then the default adapter calls this method with no message 
+        and the business service is responsible for receiving the data from the external system and validating it.
+
+        Parameters:
+        messageInput: an instance of IRISObject or subclass of Message containing the data that the inbound adapter passes in.
+            The message can have any structure agreed upon by the inbound adapter and the business service. 
+        """
+        return