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

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)

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)

iop/_cli.py

@@ -1,141 +1,198 @@
+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
 
-def parse_args():
-    # parse arguments
-    main_parser = argparse.ArgumentParser()
-    parser = main_parser.add_mutually_exclusive_group()
-    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')
-    start = main_parser.add_argument_group('start arguments')
-    start.add_argument('-D', '--detach', help='start a production in detach mode', action='store_true')
-    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')
-    test = main_parser.add_argument_group('test arguments')
-    # add classname argument
-    test.add_argument('-C', '--classname', help='test classname', nargs='?', const='not_set')
-    # body argument
-    test.add_argument('-B', '--body', help='test body', nargs='?', const='not_set')
-    return main_parser
-
-def main(argv=None):
-    # build arguments
-    parser = parse_args()
-    args = parser.parse_args(argv)
-
-    if args.default:
-        # set default production
-        if args.default == 'not_set':
-            # display default production name
+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(args.default)
+            _Director.set_default_production(self.args.default)
 
-    elif args.list:
-        # display list of productions
+    def _handle_list(self) -> None:
         dikt = _Director.list_productions()
         print(json.dumps(dikt, indent=4))
 
-    elif args.start:
-        production_name = None
-        if args.start == 'not_set':
-            # start default production
-            production_name = _Director.get_default_production()
-        else:
-            # start production with name
-            production_name = args.start
-        if args.detach:
-            # start production in detach mode
+    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)
 
-    elif args.init:
-        if args.init == 'not_set':
-            # set arg to None
-            args.init = None
-        _Utils.setup(args.start)
+    def _handle_stop(self) -> None:
+        _Director.stop_production()
+        print(f"Production {_Director.get_default_production()} stopped")
 
-    elif args.kill:
-        # kill a production
+    def _handle_kill(self) -> None:
         _Director.shutdown_production()
 
-    elif args.restart:
-        # restart a production
+    def _handle_restart(self) -> None:
         _Director.restart_production()
 
-    elif args.migrate:
-        # check if migrate is absolute path
-        if os.path.isabs(args.migrate):
-            # migrate a production with absolute path
-            _Utils.migrate(args.migrate)
-        else:
-            # migrate a production with relative path
-            _Utils.migrate(os.path.join(os.getcwd(), args.migrate))
+    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)
 
-    elif args.version:
-        # display version
+    def _handle_version(self) -> None:
         print(version('iris-pex-embedded-python'))
 
-    elif args.log:
-        # display log
-        if args.log == 'not_set':
-            # display default production log
-            _Director.log_production()
-        else:
-            _Director.log_production_top(args.log)
+    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))
 
-    elif args.stop:
-        # stop a production
-        _Director.stop_production()
-        print(f"Production {_Director.get_default_production()} stopped")
+    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)
 
-    elif args.status:
-        dikt=_Director.status_production()
-        print(json.dumps(dikt, indent=4))
+    def _handle_log(self) -> None:
+        if self.args.log == 'not_set':
+            print(_Director.log_production())
+        else:
+            print(_Director.log_production_top(self.args.log))
 
-    elif args.test:
-        classname = None
-        body = None
-        if args.test == 'not_set':
-            # set arg to None
-            args.test = None
-        if args.classname:
-            classname = args.classname
-        if args.body:
-            body = args.body
-        response = _Director.test_component(args.test, classname=classname, body=body)
-        print(response)
+    def _handle_init(self) -> None:
+        _Utils.setup(None)
 
-    elif args.export:
-        if args.export == 'not_set':
-            # export default production
-            args.export=_Director.get_default_production()
+    def _handle_help(self) -> None:
+        create_parser().print_help()
+        print(f"\nDefault production: {_Director.get_default_production()}")
 
-        dikt = _Utils.export_production(args.export)
-        print(json.dumps(dikt, indent=4))
+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')
 
-    else:
-        # display help
-        parser.print_help()
-        print()
-        print("Default production : " + _Director.get_default_production())
+    # 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()

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.
         

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():
@@ -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)}'