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

{iris_pex_embedded_python-3.2.1b2 → 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.1b2
+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.1b2 → 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.1b2"
+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.1b2 → 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.1b2 → 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.1b2 → 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.3.0/src/iop/_cli.py

@@ -0,0 +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
+
+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:
+        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)
+
+    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()