iris-pex-embedded-python 2.3.28b3__py3-none-any.whl → 3.0.0__py3-none-any.whl

grongier/pex/_director.py

@@ -1,286 +1 @@
-import iris
-import datetime
-import intersystems_iris.dbapi._DBAPI as irisdbapi
-import signal
-import functools
-import asyncio
-from dataclasses import dataclass
-
-from grongier.pex._business_host import _BusinessHost
-from grongier.pex._utils import _Utils
-
-class _Director():
-    """ The Directorclass is used for nonpolling business services, that is, business services which are not automatically
-    called by the production framework (through the inbound adapter) at the call interval.
-    Instead these business services are created by a custom application by calling the Director.CreateBusinessService() method.
-    """
-
-    @staticmethod
-    def CreateBusinessService(target):
-        """ DEPRECATED : use create_business_service
-        The CreateBusinessService() method initiates the specifiied business service.
-
-        Parameters:
-        connection: an IRISConnection object that specifies the connection to an IRIS instance for Java.
-        target: a string that specifies the name of the business service in the production definition.
-
-        Returns:
-            an object that contains an instance of IRISBusinessService
-        """
-        return _Director.create_business_service(target)
-
-    @staticmethod
-    def create_business_service(target):
-        """ The create_business_service() method initiates the specified business service.
-
-        Parameters:
-        connection: an IRISConnection object that specifies the connection to an IRIS instance for Java.
-        target: a string that specifies the name of the business service in the production definition.
-
-        Returns:
-            an object that contains an instance of IRISBusinessService
-        """
-        iris_object = iris.cls("Grongier.PEX.Director").dispatchCreateBusinessService(target)
-        return iris_object
-
-    @staticmethod
-    def create_python_business_service(target):
-        """ The create_business_service() method initiates the specified business service.
-
-        Parameters:
-        connection: an IRISConnection object that specifies the connection to an IRIS instance for Java.
-        target: a string that specifies the name of the business service in the production definition.
-
-        Returns:
-            an object that contains an instance of IRISBusinessService
-        """
-        iris_object = iris.cls("Grongier.PEX.Director").dispatchCreateBusinessService(target)
-        return iris_object.GetClass()
-    
-    ### List of function to manage the production
-    ### start production
-    @staticmethod
-    def start_production_with_log(production_name=None):
-        if production_name is None or production_name == '':
-            production_name = _Director.get_default_production()
-        # create two async task
-        loop = asyncio.get_event_loop()
-        # add signal handler
-        handler = SigintHandler()
-        loop.add_signal_handler(signal.SIGINT, functools.partial(handler.signal_handler, signal.SIGINT, loop))
-        loop.run_until_complete(asyncio.gather(
-            _Director._start_production_async(production_name, handler),
-            _Director._log_production_async(handler)
-        ))
-        loop.close()
-
-    @staticmethod
-    async def _start_production_async(production_name=None, handler=None):
-        _Director.start_production(production_name)
-        while True:
-            if handler.sigint:
-                _Director.stop_production()
-                break
-            await asyncio.sleep(1)
-
-    @staticmethod
-    def start_production(production_name=None):
-        if production_name is None or production_name == '':
-            production_name = _Director.get_default_production()
-        iris.cls('Ens.Director').StartProduction(production_name)
-
-    ### stop production
-    @staticmethod
-    def stop_production():
-        iris.cls('Ens.Director').StopProduction()
-
-    ### restart production
-    @staticmethod
-    def restart_production():
-        iris.cls('Ens.Director').RestartProduction()
-
-    ### shutdown production
-    @staticmethod
-    def shutdown_production():
-        iris.cls('Ens.Director').StopProduction(10,1)
-
-    ### update production
-    @staticmethod
-    def update_production():
-        iris.cls('Ens.Director').UpdateProduction()
-
-    ### list production
-    @staticmethod
-    def list_productions():
-        return iris.cls('Grongier.PEX.Director').dispatchListProductions()
-    
-    ### status production
-    @staticmethod
-    def status_production():
-        dikt = iris.cls('Grongier.PEX.Director').StatusProduction()
-        if dikt['Production'] is None or dikt['Production'] == '':
-            dikt['Production'] = _Director.get_default_production()
-        return dikt
-
-    ### set default production
-    @staticmethod
-    def set_default_production(production_name=''):
-        #set ^Ens.Configuration("SuperUser","LastProduction")
-        glb = iris.gref("^Ens.Configuration")
-        glb['csp', "LastProduction"] = production_name
-
-    ### get default production
-    @staticmethod
-    def get_default_production():
-        glb = iris.gref("^Ens.Configuration")
-        default_production_name = glb['csp', "LastProduction"]
-        if default_production_name is None or default_production_name == '':
-            default_production_name = 'Not defined'
-        return default_production_name
-
-    @staticmethod
-    def format_log(row: list) -> str:
-        # 0,  1,          2,   3,         4,         5,           6,            7,     8,    9,          10,       11
-        # ID, ConfigName, Job, MessageId, SessionId, SourceClass, SourceMethod, Stack, Text, TimeLogged, TraceCat, Type
-        # yield all except stack aand tracecat
-        # in first position, the timelogged
-        # cast the result to string
-        # convert Type to its string value
-            # Assert,Error,Warning,Info,Trace,Alert
-        typ = row[11]
-        if typ == 1:
-            typ = 'Assert'
-        elif typ == 2:
-            typ = 'Error'
-        elif typ == 3:
-            typ = 'Warning'
-        elif typ == 4:
-            typ = 'Info'
-        elif typ == 5:
-            typ = 'Trace'
-        elif typ == 6:
-            typ = 'Alert'
-        return str(row[9]) + ' ' + typ + ' ' + str(row[1]) + ' ' + str(row[2]) + ' ' + str(row[3]) + ' ' + str(row[4]) + ' ' + str(row[5]) + ' ' + str(row[6]) + ' ' + str(row[8])
-
-    @staticmethod
-    def read_top_log(cursor,top) -> list:
-        sql = """
-        SELECT top ?
-        ID, ConfigName, Job, MessageId, SessionId, SourceClass, SourceMethod, Stack, Text, TimeLogged, TraceCat, Type
-        FROM Ens_Util.Log
-        order by id desc
-        """
-        result = []
-        cursor.execute(sql, top)
-        for row in cursor:
-            result.append(_Director.format_log(row))
-        return result
-
-    @staticmethod
-    def read_log(cursor) -> list:
-        sql = """
-        SELECT 
-        ID, ConfigName, Job, MessageId, SessionId, SourceClass, SourceMethod, Stack, Text, TimeLogged, TraceCat, Type
-        FROM Ens_Util.Log
-        where TimeLogged >= ?
-        order by id desc
-        """
-        result = []
-        cursor.execute(sql, (datetime.datetime.now() - datetime.timedelta(seconds=1),))
-        for row in cursor:
-            result.append(_Director.format_log(row))
-        return result
-
-    @staticmethod
-    async def _log_production_async(handler):
-        """ Log production 
-            if ctrl+c is pressed, the log is stopped
-        """
-        with irisdbapi.connect(embedded=True) as conn:
-            with conn.cursor() as cursor:
-                while True:
-                    for row in reversed(_Director.read_log(cursor)):
-                        print(row)
-                    if handler.sigint_log:
-                        break
-                    await asyncio.sleep(1)
-
-    @staticmethod
-    def log_production_top(top):
-        """ 
-        Log the top N logs of the production
-        Parameters:
-        top: the number of log to display
-        """
-        with irisdbapi.connect(embedded=True) as conn:
-            with conn.cursor() as cursor:
-                for row in reversed(_Director.read_top_log(cursor, top)):
-                    print(row)
-
-    @staticmethod
-    def log_production():
-        """ Log production 
-            if ctrl+c is pressed, the log is stopped
-        """
-        loop = asyncio.get_event_loop()
-        handler = SigintHandler(log_only=True)
-        loop.add_signal_handler(signal.SIGINT, functools.partial(handler.signal_handler, signal.SIGINT, loop))
-        with irisdbapi.connect(embedded=True) as conn:
-            with conn.cursor() as cursor:
-                for row in reversed(_Director.read_top_log(cursor, 10)):
-                    print(row)
-        loop.run_until_complete(_Director._log_production_async(handler))
-        loop.close()
-
-    @staticmethod
-    def test_component(target,message=None,classname=None,body=None):
-        """ 
-        Test a component
-        Parameters:
-        target: the name of the component
-        classname: the name of the class to test
-        body: the body of the message
-        """
-        if not message:
-            message = iris.cls('Ens.Request')._New()
-        if classname:
-            # if classname start with 'iris.' then create an iris object
-            if classname.startswith('iris.'):
-                # strip the iris. prefix
-                classname = classname[5:]
-                if body:
-                    message = iris.cls(classname)._New(body)
-                else:
-                    message = iris.cls(classname)._New()
-            # else create a python object
-            else:
-                # python message are casted to Grongier.PEX.Message
-                message = iris.cls("Grongier.PEX.Message")._New()
-                message.classname = classname
-                if body:
-                    message.jstr = _Utils.string_to_stream(body)
-                else:
-                    message.jstr = _Utils.string_to_stream("{}")
-        # serialize the message
-        business_host = _BusinessHost()
-        serial_message = business_host._dispatch_serializer(message)
-        response = iris.cls('Grongier.PEX.Utils').dispatchTestComponent(target,serial_message)
-        try:
-            deserialized_response = business_host._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)}'
-        return deserialized_response
-
-            
-@dataclass
-class SigintHandler():
-    
-    sigint: bool = False
-    sigint_log: bool = False
-    log_only: bool = False
-
-    def signal_handler(self, signal, frame):
-        if self.sigint or self.log_only:
-            self.sigint_log = True
-        self.sigint = True
+from iop._director import _Director

grongier/pex/_utils.py

@@ -1,369 +1 @@
-import os
-import ast
-import iris
-import inspect
-import xmltodict
-import pkg_resources
-
-class _Utils():
-    @staticmethod
-    def raise_on_error(sc):
-        """
-        If the status code is an error, raise an exception
-        
-        :param sc: The status code returned by the Iris API
-        """
-        if iris.system.Status.IsError(sc):
-            raise RuntimeError(iris.system.Status.GetOneStatusText(sc))
-
-    @staticmethod
-    def setup(path:str = None):
-
-        if path is None:
-            # get the path of the data folder with pkg_resources
-            path = pkg_resources.resource_filename('grongier', 'cls')
-
-        _Utils.raise_on_error(iris.cls('%SYSTEM.OBJ').LoadDir(path,'cubk',"*.cls",1))
-
-    @staticmethod
-    def register_component(module:str,classname:str,path:str,overwrite:int=1,iris_classname:str='Python'):
-        """
-        It registers a component in the Iris database.
-        
-        :param module: The name of the module that contains the class
-        :type module: str
-        :param classname: The name of the class you want to register
-        :type classname: str
-        :param path: The path to the component
-        :type path: str
-        :param overwrite: 0 = no, 1 = yes
-        :type overwrite: int
-        :param iris_classname: The name of the class in the Iris class hierarchy
-        :type iris_classname: str
-        :return: The return value is a string.
-        """
-        path = os.path.normpath(path)
-        # get the absolute path of the folder
-        path = os.path.abspath(path)
-        return iris.cls('Grongier.PEX.Utils').dispatchRegisterComponent(module,classname,path,overwrite,iris_classname)
-
-    @staticmethod
-    def register_folder(path:str,overwrite:int=1,iris_package_name:str='Python'):
-        """
-        > This function takes a path to a folder, and registers all the Python files in that folder as IRIS
-        classes
-        
-        :param path: the path to the folder containing the files you want to register
-        :type path: str
-        :param overwrite: 
-        :type overwrite: int
-        :param iris_package_name: The name of the iris package you want to register the file to
-        :type iris_package_name: str
-        """
-        path = os.path.normpath(path)
-        # get the absolute path of the folder
-        path = os.path.abspath(path)
-        for filename in os.listdir(path):
-            if filename.endswith(".py"): 
-                _Utils._register_file(filename, path, overwrite, iris_package_name)
-            else:
-                continue
-
-    @staticmethod
-    def register_file(file:str,overwrite:int=1,iris_package_name:str='Python'):
-        """
-        It takes a file name, a boolean to overwrite existing components, and the name of the Iris
-        package that the file is in. It then opens the file, parses it, and looks for classes that extend
-        BusinessOperation, BusinessProcess, or BusinessService. If it finds one, it calls register_component
-        with the module name, class name, path, overwrite boolean, and the full Iris package name
-        
-        :param file: the name of the file containing the component
-        :type file: str
-        :param overwrite: if the component already exists, overwrite it
-        :type overwrite: int
-        :param iris_package_name: the name of the iris package that you want to register the components to
-        :type iris_package_name: str
-        """
-        head_tail = os.path.split(file)
-        return _Utils._register_file(head_tail[1],head_tail[0],overwrite,iris_package_name)
-
-    @staticmethod
-    def _register_file(filename:str,path:str,overwrite:int=1,iris_package_name:str='Python'):
-        """
-        It takes a file name, a path, a boolean to overwrite existing components, and the name of the Iris
-        package that the file is in. It then opens the file, parses it, and looks for classes that extend
-        BusinessOperation, BusinessProcess, or BusinessService. If it finds one, it calls register_component
-        with the module name, class name, path, overwrite boolean, and the full Iris package name
-        
-        :param filename: the name of the file containing the component
-        :type filename: str
-        :param path: the path to the directory containing the files to be registered
-        :type path: str
-        :param overwrite: if the component already exists, overwrite it
-        :type overwrite: int
-        :param iris_package_name: the name of the iris package that you want to register the components to
-        :type iris_package_name: str
-        """
-        #pour chaque classe dans le module, appeler register_component
-        f =  os.path.join(path,filename)
-        with open(f) as file:
-            node = ast.parse(file.read())
-            #list of class in the file
-            classes = [n for n in node.body if isinstance(n, ast.ClassDef)]
-            for klass in classes:
-                extend = ''
-                if len(klass.bases) == 1:
-                    if hasattr(klass.bases[0],'id'):
-                        extend = klass.bases[0].id
-                    else:
-                        extend = klass.bases[0].attr
-                if  extend in ('BusinessOperation','BusinessProcess','BusinessService','DuplexService','DuplexProcess','DuplexOperation','InboundAdapter','OutboundAdapter'):
-                    module = _Utils.filename_to_module(filename)
-                    iris_class_name = f"{iris_package_name}.{module}.{klass.name}"
-                    # strip "_" for iris class name
-                    iris_class_name = iris_class_name.replace('_','')
-                    _Utils.register_component(module, klass.name, path, overwrite, iris_class_name)
-    @staticmethod
-    def register_package(package:str,path:str,overwrite:int=1,iris_package_name:str='Python'):
-        """
-        It takes a package name, a path to the package, a flag to overwrite existing files, and the name of
-        the iris package to register the files to. It then loops through all the files in the package and
-        registers them to the iris package
-        
-        :param package: the name of the package you want to register
-        :type package: str
-        :param path: the path to the directory containing the package
-        :type path: str
-        :param overwrite: 0 = don't overwrite, 1 = overwrite
-        :type overwrite: int
-        :param iris_package_name: The name of the package in the Iris package manager
-        :type iris_package_name: str
-        """
-        for filename in os.listdir(os.path.join(path,package)):
-            if filename.endswith(".py"):
-                _Utils._register_file(filename, os.path.join(path,package), overwrite, iris_package_name)
-            else:
-                continue
-
-    @staticmethod
-    def filename_to_module(filename) -> str:
-        """
-        It takes a filename and returns the module name
-        
-        :param filename: The name of the file to be imported
-        :return: The module name
-        """
-        module = ''
-
-        path,file = os.path.split(filename)
-        mod = file.split('.')[0]
-        packages = path.replace(os.sep, ('.'))
-        if len(packages) >1:
-            module = packages+'.'+mod
-        else:
-            module = mod
-
-        return module
-
-    @staticmethod
-    def migrate(filename=None,root_path=None):
-        """ 
-        Read the settings.py file and register all the components
-        settings.py file has two dictionaries:
-            * CLASSES
-                * key: the name of the class
-                * value: an instance of the class
-            * PRODUCTIONS
-                list of dictionaries:
-                * key: the name of the production
-                * value: a dictionary containing the settings for the production
-        """
-        # try to load the settings file
-        if filename:
-            import sys
-            path = None
-            # check if the filename is absolute or relative
-            if os.path.isabs(filename):
-                path = os.path.dirname(filename)
-            else:
-                raise ValueError("The filename must be absolute")
-            # add the path to the system path
-            sys.path.append(path)
-        import settings
-        # get the path of the settings file
-        path = os.path.dirname(inspect.getfile(settings))
-        try:
-            # set the classes settings
-            _Utils.set_classes_settings(settings.CLASSES,path)
-        except AttributeError:
-            print("No classes to register")
-        try:
-            # set the productions settings
-            _Utils.set_productions_settings(settings.PRODUCTIONS,path)
-        except AttributeError:
-            print("No productions to register")
-
-
-
-    @staticmethod
-    def set_classes_settings(class_items,root_path=None):
-        """
-        It takes a dictionary of classes and returns a dictionary of settings for each class
-        
-        :param class_items: a dictionary of classes
-        :return: a dictionary of settings for each class
-        """
-        for key, value in class_items.items():
-            if inspect.isclass(value):
-                path = None
-                if root_path:
-                    path = root_path
-                else:
-                    path = os.path.dirname(inspect.getfile(value))
-                _Utils.register_component(value.__module__,value.__name__,path,1,key)
-            elif inspect.ismodule(value):
-                path = None
-                if root_path:
-                    path = root_path
-                else:
-                    path = os.path.dirname(inspect.getfile(value))
-                _Utils._register_file(value.__name__+'.py',path,1,key)
-            # if the value is a dict
-            elif isinstance(value,dict):
-                # if the dict has a key 'path' and a key 'module' and a key 'class'
-                if 'path' in value and 'module' in value and 'class' in value:
-                    # register the component
-                    _Utils.register_component(value['module'],value['class'],value['path'],1,key)
-                # if the dict has a key 'path' and a key 'package'
-                elif 'path' in value and 'package' in value:
-                    # register the package
-                    _Utils.register_package(value['package'],value['path'],1,key)
-                # if the dict has a key 'path' and a key 'file'
-                elif 'path' in value and 'file' in value:
-                    # register the file
-                    _Utils._register_file(value['file'],value['path'],1,key)
-                # if the dict has a key 'path'
-                elif 'path' in value:
-                    # register folder
-                    _Utils.register_folder(value['path'],1,key)
-                else:
-                    raise ValueError(f"Invalid value for {key}.")
-
-    @staticmethod
-    def set_productions_settings(production_list,root_path=None):
-        """
-        It takes a list of dictionaries and registers the productions
-        """
-        # for each production in the list
-        for production in production_list:
-            # get the production name (first key in the dictionary)
-            production_name = list(production.keys())[0]
-            # set the first key to 'production'
-            production['Production'] = production.pop(production_name)
-            # handle Items
-            production = _Utils.handle_items(production,root_path)
-            # transform the json as an xml
-            xml = _Utils.dict_to_xml(production)
-            # register the production
-            _Utils.register_production(production_name,xml)
-
-    @staticmethod
-    def handle_items(production,root_path=None):
-        # if an item is a class, register it and replace it with the name of the class
-        if 'Item' in production['Production']:
-            # for each item in the list
-            for i,item in enumerate(production['Production']['Item']):
-                # if the attribute "@ClassName" is a class, register it and replace it with the name of the class
-                if '@ClassName' in item:
-                    if inspect.isclass(item['@ClassName']):
-                        path = None
-                        if root_path:
-                            path = root_path
-                        else:
-                            path = os.path.dirname(inspect.getfile(item['@ClassName']))
-                        _Utils.register_component(item['@ClassName'].__module__,item['@ClassName'].__name__,path,1,item['@Name'])
-                        # replace the class with the name of the class
-                        production['Production']['Item'][i]['@ClassName'] = item['@Name']
-                # if the attribute "@ClassName" is a dict
-                elif isinstance(item['@ClassName'],dict):
-                    # create a new dict where the key is the name of the class and the value is the dict
-                    class_dict = {item['@Name']:item['@ClassName']}
-                    # pass the new dict to set_classes_settings
-                    _Utils.set_classes_settings(class_dict)
-                    # replace the class with the name of the class
-                    production['Production']['Item'][i]['@ClassName'] = item['@Name']
-                else:
-                    raise ValueError(f"Invalid value for {item['@Name']}.")
-
-        return production
-
-    @staticmethod
-    def dict_to_xml(json):
-        """
-        It takes a json and returns an xml
-        
-        :param json: a json
-        :return: an xml
-        """
-        xml = xmltodict.unparse(json,pretty=True)
-        # remove the xml version tag
-        xml = xml.replace('<?xml version="1.0" encoding="utf-8"?>','')
-        # remove the new line at the beginning of the xml
-        xml = xml[1:]
-        return xml
-    
-    @staticmethod
-    def register_production(production_name,xml):
-        """
-        It takes a production name and an xml and registers the production
-        
-        :param production_name: the name of the production
-        :type production_name: str
-        :param xml: the xml of the production
-        :type xml: str
-        """
-        # split the production name in the package name and the production name
-        # the production name is the last part of the string
-        package = '.'.join(production_name.split('.')[:-1])
-        production_name = production_name.split('.')[-1]
-        stream = _Utils.string_to_stream(xml)
-        # register the production
-        _Utils.raise_on_error(iris.cls('Grongier.PEX.Utils').CreateProduction(package,production_name,stream))
-
-    @staticmethod
-    def export_production(production_name):
-        """
-        It takes a production name and exports the production
-        
-        :param production_name: the name of the production
-        :type production_name: str
-        """
-        def postprocessor(path, key, value):
-            if value is None:
-                return key, ''
-            return key, value
-        # export the production
-        xdata = iris.cls('Grongier.PEX.Utils').ExportProduction(production_name)
-        # for each chunk of 1024 characters
-        string = _Utils.stream_to_string(xdata)
-        # convert the xml to a dictionary
-        data = xmltodict.parse(string,postprocessor=postprocessor)
-        # return the dictionary
-        return data
-
-    @staticmethod
-    def stream_to_string(stream)-> str:
-        string = ""
-        stream.Rewind()
-        while not stream.AtEnd:
-            string += stream.Read(4092)
-        return string
-    
-    @staticmethod
-    def string_to_stream(string:str):
-        stream = iris.cls('%Stream.GlobalCharacter')._New()
-        n = 4092
-        chunks = [string[i:i+n] for i in range(0, len(string), n)]
-        for chunk in chunks:
-            stream.Write(chunk)
-        return stream
+from iop._utils import _Utils

iop/__init__.py

@@ -0,0 +1,24 @@
+from iop._business_service import _BusinessService
+from iop._business_process import _BusinessProcess
+from iop._private_session_duplex import _PrivateSessionDuplex
+from iop._private_session_process import _PrivateSessionProcess
+from iop._business_operation import _BusinessOperation
+from iop._inbound_adapter import _InboundAdapter
+from iop._outbound_adapter import _OutboundAdapter
+from iop._message import _Message
+from iop._pickle_message import _PickleMessage
+from iop._director import _Director
+from iop._utils import _Utils
+
+class Utils(_Utils): pass
+class InboundAdapter(_InboundAdapter): pass
+class OutboundAdapter(_OutboundAdapter): pass
+class BusinessService(_BusinessService): pass
+class BusinessOperation(_BusinessOperation): pass
+class BusinessProcess(_BusinessProcess): pass
+class DuplexService(_PrivateSessionDuplex): pass
+class DuplexOperation(_PrivateSessionDuplex): pass
+class DuplexProcess(_PrivateSessionProcess): pass
+class Message(_Message): pass
+class PickleMessage(_PickleMessage): pass
+class Director(_Director): pass

iop/__main__.py

@@ -0,0 +1,4 @@
+# main entry is _cli.main()
+if __name__ == '__main__':
+    import iop._cli as _cli
+    _cli.main()