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

iop/_business_operation.py

@@ -0,0 +1,71 @@
+import importlib
+from typing import Any, List, Optional, Union, Tuple
+from iop._business_host import _BusinessHost
+
+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."""
+        self._create_dispatch()
+        self.on_init()
+        return
+
+    @_BusinessHost.input_deserialzer
+    @_BusinessHost.output_serialzer
+    def _dispatch_on_message(self, request: Any) -> Any:
+        """For internal use only."""
+        return self._dispach_message(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,220 @@
+from typing import Any, List, Optional, Union
+from iop._business_host import _BusinessHost
+
+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)
+
+    @_BusinessHost.input_serialzer_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)
+    
+    @_BusinessHost.input_serialzer_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.
+        
+        Args:
+            target: The name of the business process or operation to receive the request
+            request: The message to send to the target
+            response_required: Whether a response is required
+            completion_key: A string that will be returned with the response if the maximum time is exceeded
+            description: An optional description property in the message header
+            
+        Raises:
+            TypeError: If request is not of type Message or IRISObject
+        """
+        if response_required:
+            response_required = 1
+        else:
+            response_required = 0
+        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)
+        self._create_dispatch()
+        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
+
+    @_BusinessHost.input_deserialzer
+    @_BusinessHost.output_serialzer
+    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)
+        self._save_persistent_properties(host_object)
+        return return_object
+    
+    @_BusinessHost.input_deserialzer
+    @_BusinessHost.output_serialzer
+    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
+
+    @_BusinessHost.input_deserialzer
+    @_BusinessHost.output_serialzer
+    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

{grongier/pex → iop}/_business_service.py

@@ -1,5 +1,5 @@
 import importlib
-from grongier.pex._business_host import _BusinessHost
+from iop._business_host import _BusinessHost
 
 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.
@@ -30,7 +30,7 @@ class _BusinessService(_BusinessHost):
         """ For internal use only. """
         self.iris_handle = handle_current
         if type(handle_partner).__module__.find('iris') == 0:
-            if handle_partner._IsA("Grongier.PEX.InboundAdapter"):
+            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

iop/_cli.py

@@ -0,0 +1,196 @@
+from __future__ import annotations
+import argparse
+import json
+import os
+from dataclasses import dataclass
+from enum import Enum, auto
+import sys
+from typing import Optional, Callable
+from importlib.metadata import version
+
+from iop._director import _Director
+from iop._utils import _Utils
+
+class CommandType(Enum):
+    DEFAULT = auto()
+    LIST = auto()
+    START = auto()
+    STOP = auto()
+    KILL = auto()
+    RESTART = auto()
+    STATUS = auto()
+    TEST = auto()
+    VERSION = auto()
+    EXPORT = auto()
+    MIGRATE = auto()
+    LOG = auto()
+    INIT = auto()
+    HELP = auto()
+
+@dataclass
+class CommandArgs:
+    """Container for parsed command arguments"""
+    default: Optional[str] = None
+    list: bool = False
+    start: Optional[str] = None
+    detach: bool = False
+    stop: bool = False
+    kill: bool = False
+    restart: bool = False
+    status: bool = False
+    migrate: Optional[str] = None
+    export: Optional[str] = None
+    version: bool = False
+    log: Optional[str] = None
+    init: Optional[str] = None
+    test: Optional[str] = None
+    classname: Optional[str] = None
+    body: Optional[str] = None
+
+class Command:
+    def __init__(self, args: CommandArgs):
+        self.args = args
+
+    def execute(self) -> None:
+        command_type = self._determine_command_type()
+        command_handlers = {
+            CommandType.DEFAULT: self._handle_default,
+            CommandType.LIST: self._handle_list,
+            CommandType.START: self._handle_start,
+            CommandType.STOP: self._handle_stop,
+            CommandType.KILL: self._handle_kill,
+            CommandType.RESTART: self._handle_restart,
+            CommandType.STATUS: self._handle_status,
+            CommandType.TEST: self._handle_test,
+            CommandType.VERSION: self._handle_version,
+            CommandType.EXPORT: self._handle_export,
+            CommandType.MIGRATE: self._handle_migrate,
+            CommandType.LOG: self._handle_log,
+            CommandType.INIT: self._handle_init,
+            CommandType.HELP: self._handle_help
+        }
+        handler = command_handlers.get(command_type)
+        if handler:
+            handler()
+
+    def _determine_command_type(self) -> CommandType:
+        if self.args.default: return CommandType.DEFAULT
+        if self.args.list: return CommandType.LIST
+        if self.args.start: return CommandType.START
+        if self.args.stop: return CommandType.STOP
+        if self.args.kill: return CommandType.KILL
+        if self.args.restart: return CommandType.RESTART
+        if self.args.status: return CommandType.STATUS
+        if self.args.test: return CommandType.TEST
+        if self.args.version: return CommandType.VERSION
+        if self.args.export: return CommandType.EXPORT
+        if self.args.migrate: return CommandType.MIGRATE
+        if self.args.log: return CommandType.LOG
+        if self.args.init: return CommandType.INIT
+        return CommandType.HELP
+
+    def _handle_default(self) -> None:
+        if self.args.default == 'not_set':
+            print(_Director.get_default_production())
+        else:
+            _Director.set_default_production(self.args.default)
+
+    def _handle_list(self) -> None:
+        dikt = _Director.list_productions()
+        print(json.dumps(dikt, indent=4))
+
+    def _handle_start(self) -> None:
+        production_name = self.args.start if self.args.start != 'not_set' else _Director.get_default_production()
+        if self.args.detach:
+            _Director.start_production(production_name)
+            print(f"Production {production_name} started")
+        else:
+            _Director.start_production_with_log(production_name)
+
+    def _handle_stop(self) -> None:
+        _Director.stop_production()
+        print(f"Production {_Director.get_default_production()} stopped")
+
+    def _handle_kill(self) -> None:
+        _Director.shutdown_production()
+
+    def _handle_restart(self) -> None:
+        _Director.restart_production()
+
+    def _handle_status(self) -> None:
+        print(json.dumps(_Director.status_production(), indent=4))
+
+    def _handle_test(self) -> None:
+        test_name = None if self.args.test == 'not_set' else self.args.test
+        response = _Director.test_component(
+            test_name,
+            classname=self.args.classname if self.args.classname != 'not_set' else None,
+            body=self.args.body if self.args.body != 'not_set' else None
+        )
+        print(response)
+
+    def _handle_version(self) -> None:
+        print(version('iris-pex-embedded-python'))
+
+    def _handle_export(self) -> None:
+        export_name = _Director.get_default_production() if self.args.export == 'not_set' else self.args.export
+        print(json.dumps(_Utils.export_production(export_name), indent=4))
+
+    def _handle_migrate(self) -> None:
+        migrate_path = self.args.migrate
+        if not os.path.isabs(migrate_path):
+            migrate_path = os.path.join(os.getcwd(), migrate_path)
+        _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))
+
+    def _handle_init(self) -> None:
+        _Utils.setup(None)
+
+    def _handle_help(self) -> None:
+        create_parser().print_help()
+        print(f"\nDefault production: {_Director.get_default_production()}")
+
+def create_parser() -> argparse.ArgumentParser:
+    """Create and configure argument parser"""
+    main_parser = argparse.ArgumentParser()
+    parser = main_parser.add_mutually_exclusive_group()
+    
+    # Main commands
+    parser.add_argument('-d', '--default', help='set the default production', nargs='?', const='not_set')
+    parser.add_argument('-l', '--list', help='list productions', action='store_true')
+    parser.add_argument('-s', '--start', help='start a production', nargs='?', const='not_set')
+    parser.add_argument('-S', '--stop', help='stop a production', action='store_true')
+    parser.add_argument('-k', '--kill', help='kill a production', action='store_true')
+    parser.add_argument('-r', '--restart', help='restart a production', action='store_true')
+    parser.add_argument('-x', '--status', help='status a production', action='store_true')
+    parser.add_argument('-m', '-M', '--migrate', help='migrate production and classes with settings file')
+    parser.add_argument('-e', '--export', help='export a production', nargs='?', const='not_set')
+    parser.add_argument('-v', '--version', help='display version', action='store_true')
+    parser.add_argument('-L', '--log', help='display log', nargs='?', const='not_set')
+    parser.add_argument('-i', '--init', help='init the pex module in iris', nargs='?', const='not_set')
+    parser.add_argument('-t', '--test', help='test the pex module in iris', nargs='?', const='not_set')
+
+    # Command groups
+    start = main_parser.add_argument_group('start arguments')
+    start.add_argument('-D', '--detach', help='start a production in detach mode', action='store_true')
+    
+    test = main_parser.add_argument_group('test arguments')
+    test.add_argument('-C', '--classname', help='test classname', nargs='?', const='not_set')
+    test.add_argument('-B', '--body', help='test body', nargs='?', const='not_set')
+    
+    return main_parser
+
+def main(argv=None) -> None:
+    parser = create_parser()
+    args = parser.parse_args(argv)
+    cmd_args = CommandArgs(**vars(args))
+    
+    command = Command(cmd_args)
+    command.execute()
+    sys.exit(0)
+
+if __name__ == '__main__':
+    main()