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

grongier/pex/_cli.py

@@ -1,152 +1 @@
-# _manager.py is the main entry point of the pex package
-# it's a command line interface to manage productions
-# eg :
-#   python3 -m grongier.pex -h : display help and the default production name
-#   python3 -m grongier.pex -l : list productions
-#   python3 -m grongier.pex -d <production_name> : set the default production to <production_name>
-#   python3 -m grongier.pex -s <production_name> : start a production named <production_name> if <production_name> is not set, the default production is started
-#   python3 -m grongier.pex -k <production_name> : stop a production named <production_name> if <production_name> is not set, the default production is killed
-#   python3 -m grongier.pex -r <production_name> : restart a production named <production_name> if <production_name> is not set, the default production is restarted
-#   python3 -m grongier.pex -m <settings_file> : migrate a production and classes with the settings file <settings_file>
-#   python3 -m grongier.pex -x <production_name> : export a production named <production_name> if <production_name> is not set, the default production is exported
-from grongier.pex._director import _Director
-from grongier.pex._utils import _Utils
-
-import argparse
-import json
-import os
-from importlib.metadata import version 
-
-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
-            print(_Director.get_default_production())
-        else:
-            _Director.set_default_production(args.default)
-
-    elif args.list:
-        # display list of productions
-        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
-            _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)
-
-    elif args.kill:
-        # kill a production
-        _Director.shutdown_production()
-
-    elif args.restart:
-        # restart a production
-        _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))
-
-    elif args.version:
-        # display version
-        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)
-
-    elif args.stop:
-        # stop a production
-        _Director.stop_production()
-        print(f"Production {_Director.get_default_production()} stopped")
-
-    elif args.status:
-        dikt=_Director.status_production()
-        print(json.dumps(dikt, indent=4))
-
-    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)
-
-    elif args.export:
-        if args.export == 'not_set':
-            # export default production
-            args.export=_Director.get_default_production()
-
-        dikt = _Utils.export_production(args.export)
-        print(json.dumps(dikt, indent=4))
-
-    else:
-        # display help
-        parser.print_help()
-        print()
-        print("Default production : " + _Director.get_default_production())
-
-
-if __name__ == '__main__':
-    main()
+from iop._cli import main

grongier/pex/_common.py

@@ -1,347 +1 @@
-import traceback
-import dataclasses
-import inspect
-import iris
-import abc
-
-class _Common(metaclass=abc.ABCMeta):
-    """ This is a common superclass for all component types that defines common methods."""
-
-    INFO_URL: str
-    ICON_URL: str
-    iris_handle = None
-
-    def on_init(self):
-        """ The on_init() method is called when the component is started.
-        Use the on_init() method to initialize any structures needed by the component."""
-        return self.OnInit()
-
-    def on_tear_down(self):
-        """ Called before the component is terminated. Use it to free any structures."""
-        return self.OnTearDown()
-
-    def on_connected(self):
-        """ The on_connected() method is called when the component is connected or reconnected after being disconnected.
-        Use the on_connected() method to initialize any structures needed by the component."""
-        return self.OnConnected()
-
-    def _dispatch_on_connected(self, host_object):
-        """ For internal use only. """
-        self.on_connected()
-        return
-
-    def _dispatch_on_init(self, host_object):
-        """ For internal use only. """
-        self.on_init()
-        return
-
-    def _dispatch_on_tear_down(self, host_object):
-        """ For internal use only. """
-        self.on_tear_down()
-        return
-
-    def _set_iris_handles(self, handle_current, handle_partner):
-        pass
-
-    @classmethod
-    def _is_message_instance(cls, obj):
-        if cls._is_message_class(type(obj)):
-            if not dataclasses.is_dataclass(obj):
-                raise TypeError(type(obj).__module__ + '.' + type(obj).__qualname__+" must be a dataclass")
-            return True
-        return False
-
-    @classmethod
-    def _is_pickle_message_instance(cls, obj):
-        if cls._is_pickel_message_class(type(obj)):
-            return True
-        return False
-    
-    @classmethod
-    def _is_iris_object_instance(cls, obj):
-        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):
-        name = klass.__module__ + '.' + klass.__qualname__
-        if 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):
-        name = klass.__module__ + '.' + klass.__qualname__
-        if name == "grongier.pex.PickleMessage": 
-            return True
-        for c in klass.__bases__:
-            if cls._is_pickel_message_class(c): 
-                return True
-        return False
-
-    @classmethod
-    def _get_info(cls):
-        """ Get class information to display in the Informational Settings expando for Production config items of this Business Host or Adapter.
-        This method returns a list of Superclass, Description, InfoURL, and IconURL, and possibly Adapter (if class is a Business Service or Business Operation)
-        IconURL is not yet displayed anywhere
-        """
-        ret = []
-        desc = ""
-        info_url = ""
-        icon_url = ""
-        super_class = ""
-        adapter = ""
-        try:
-            # Get tuple of the class's base classes and loop through them until we find one of the PEX component classes
-            classes = inspect.getmro(cls)
-            for cl in classes:
-                classname = str(cl)[7:-1]
-                if classname in ["'grongier.pex.BusinessService'","'grongier.pex.BusinessOperation'","'grongier.pex.DuplexOperation'","'grongier.pex.DuplexService'"] :
-                    # Remove the apostrophes and set as super_class, then find if it uses an adapter
-                    super_class = classname[1:-1]
-                    adapter = cls.get_adapter_type()
-                    if adapter is None:
-                        adapter = cls.getAdapterType()
-                    break
-                elif classname in ["'grongier.pex.BusinessProcess'","'grongier.pex.DuplexProcess'","'grongier.pex.InboundAdapter'","'grongier.pex.OutboundAdapter'"] :
-                    # Remove the apostrophes and set as super_class
-                    super_class = classname[1:-1]
-                    break
-
-            if ""==super_class:
-                return ""
-            ret.append(super_class)
-
-            # Get the class documentation, if any
-            class_desc = inspect.getdoc(cls)
-            super_desc = inspect.getdoc(classes[1])
-            if class_desc!=super_desc:
-                desc = class_desc
-            ret.append(str(desc))
-
-            info_url = inspect.getattr_static(cls,"INFO_URL","")
-            icon_url = inspect.getattr_static(cls,"ICON_URL","")
-
-            ret.append(info_url)
-            ret.append(icon_url)
-            
-            if ""!=adapter:
-                ret.append(adapter)
-        except Exception as e:
-            raise e
-        return ret
-
-    @classmethod
-    def _get_properties(cls):
-        """ Get a list of the Attributes and Properties of this Python class.
-        Return value is a list of lists of form $lb(propName,data_type,defaultVal,required,category,description).
-        which can be used by the Production Configuration to display them as settings.
-        This list will only include class attributes (no instance attributes) and properties which are not marked to be private by use of the _ prefix.
-        For class attributes, we will use the value that it is defined with as the defaultVal and its type as the data_type, or "" and String if set to None.
-        Add a function attrName_info() for a attribute or property 'attrName' in order to add more information about that attribute by using the function annotation for the return value.
-        The annotation should be a dictionary including any of 'IsRequired', 'Category', 'Description', 'DataType', or 'ExcludeFromSettings' as keys.
-        'ExcludeFromSettings' should be a boolean, and if true will exclude an attribute from being returned in the list, and so prevent it from being displayed as a setting in the Production Configuration Page
-        'DataType' does not need to be specified if it is the same as the type of the attribute definition.  Otherwise, it can be either a Python type or a string.
-        If 'IsRequired' is not specified, this will default to false.
-        If 'Category' is not specified, the attribute will be added to the Additional category.
-        """
-        ret = []
-        try:
-            # getmembers() returns all the members of an obj
-            for member in inspect.getmembers(cls):
-                # remove private and protected functions
-                if not member[0].startswith('_'):
-                    # remove other methods and functions
-                    if not inspect.ismethod(member[1]) and not inspect.isfunction(member[1]) and not inspect.isclass(member[1]):
-                        if member[0] not in ('INFO_URL','ICON_URL','PERSISTENT_PROPERTY_LIST') :
-                            name = member[0]
-                            req = 0
-                            cat = "Additional"
-                            desc = ""
-                            # get value, set to "" if None or a @property
-                            val = member[1]
-                            if isinstance(val,property) or (val is None):
-                                val = ""
-                            dt = str(type(val))[8:-2]
-                            # get datatype from attribute definition, default to String
-                            data_type = {'int':'Integer','float':'Numeric','complex':'Numeric','bool':'Boolean'}.get(dt,'String')
-                            # if the user has created a attr_info function, then check the annotation on the return from that for more information about this attribute
-                            if hasattr(cls,name + '_info') :
-                                func = getattr(cls,name+'_info')
-                                if callable(func) :
-                                    annotations = func.__annotations__['return']
-                                    if annotations is not None:
-                                        if bool(annotations.get("ExcludeFromSettings")) :
-                                            # don't add this attribute to the settings list
-                                            continue
-                                        req = bool(annotations.get("IsRequired"))
-                                        cat = annotations.get("Category","Additional")
-                                        desc = annotations.get("Description")
-                                        dt = annotations.get("DataType")
-                                        # only override DataType found 
-                                        if (dt is not None) and ("" != dt):
-                                            data_type = {int:'Integer',float:'Number',complex:'Number',bool:'Boolean',str:'String'}.get(dt,str(dt))
-                                    default = func()
-                                    if default is not None:
-                                        val = default
-                            # create list of information for this specific property
-                            info = []
-                            info.append(name)    # Name        
-                            info.append(data_type) # DataType
-                            info.append(val)  # Default Value
-                            info.append(req) # Required
-                            info.append(cat) # Category
-                            info.append(desc) # Description
-                            # add this property to the list
-                            ret.append(info)
-        except:
-            pass
-        return ret
-
-    def log_info(self, message):
-        """ Write a log entry of type "info". Log entries can be viewed in the management portal.
-        
-        Parameters:
-        message: a string that is written to the log.
-        """
-
-        current_class = self.__class__.__name__
-        current_method = None
-        try:
-            frame = traceback.extract_stack()[-2]
-            current_method = frame.name
-        except:
-            pass
-        iris.cls("Ens.Util.Log").LogInfo(current_class, current_method, message)
-        return
-
-    def log_alert(self, message):
-        """ Write a log entry of type "alert". Log entries can be viewed in the management portal.
-        
-        Parameters:
-        message: a string that is written to the log.
-        """
-        current_class = self.__class__.__name__
-        current_method = None
-        try:
-            frame = traceback.extract_stack()[-2]
-            current_method = frame.name
-        except:
-            pass
-        iris.cls("Ens.Util.Log").LogAlert(current_class, current_method, message)
-        return
-
-    def log_warning(self, message):
-        """ Write a log entry of type "warning". Log entries can be viewed in the management portal.
-        
-        Parameters:
-        message: a string that is written to the log.
-        """
-        current_class = self.__class__.__name__
-        current_method = None
-        try:
-            frame = traceback.extract_stack()[-2]
-            current_method = frame.name
-        except:
-            pass
-        iris.cls("Ens.Util.Log").LogWarning(current_class, current_method, message)
-        return
-
-    def log_error(self, message):
-        """ Write a log entry of type "error". Log entries can be viewed in the management portal.
-        
-        Parameters:
-        message: a string that is written to the log.
-        """
-        current_class = self.__class__.__name__
-        current_method = None
-        try:
-            frame = traceback.extract_stack()[-2]
-            current_method = frame.name
-        except:
-            pass
-        iris.cls("Ens.Util.Log").LogError(current_class, current_method, message)
-        return
-
-    def log_assert(self, message):
-        """ Write a log entry of type "assert". Log entries can be viewed in the management portal.
-        
-        Parameters:
-        message: a string that is written to the log.
-        """
-        current_class = self.__class__.__name__
-        current_method = None
-        try:
-            frame = traceback.extract_stack()[-2]
-            current_method = frame.name
-        except:
-            pass
-        iris.cls("Ens.Util.Log").LogAssert(current_class, current_method, message)
-        return
-
-    def LOGINFO(self, message):
-        """ DECAPRETED : use log_info
-        Write a log entry of type "info". Log entries can be viewed in the management portal.
-        
-        Parameters:
-        message: a string that is written to the log.
-        """
-        return self.log_info(message=message)
-
-    def LOGALERT(self, message):
-        """ DECAPRETED : use log_alert
-        Write a log entry of type "alert". Log entries can be viewed in the management portal.
-        
-        Parameters:
-        message: a string that is written to the log.
-        """
-        return self.log_alert(message)
-
-    def LOGWARNING(self, message):
-        """ DECAPRETED : use log_warning
-        Write a log entry of type "warning". Log entries can be viewed in the management portal.
-        
-        Parameters:
-        message: a string that is written to the log.
-        """
-        return self.log_warning(message)
-
-    def LOGERROR(self, message):
-        """ DECAPRETED : use log_error
-        Write a log entry of type "error". Log entries can be viewed in the management portal.
-        
-        Parameters:
-        message: a string that is written to the log.
-        """
-        return self.log_error(message)
-
-    def LOGASSERT(self, message):
-        """ DECAPRETED : use log_assert
-        Write a log entry of type "assert". Log entries can be viewed in the management portal.
-        
-        Parameters:
-        message: a string that is written to the log.
-        """
-        return self.log_assert(message)
-        
-    def OnInit(self):
-        """ DEPRECATED : use on_init
-        The on_init() method is called when the component is started.
-        Use the on_init() method to initialize any structures needed by the component."""
-        return 
-
-    def OnTearDown(self):
-        """ DEPRECATED : use on_tear_down
-        Called before the component is terminated. Use it to freee any structures.
-        """
-        return 
-
-    def OnConnected(self):
-        """ DEPRECATED : use on_connected
-        The on_connected() method is called when the component is connected or reconnected after being disconnected.
-        Use the on_connected() method to initialize any structures needed by the component."""
-        return 
+from iop._common import _Common