iris-pex-embedded-python 3.5.5b4__py3-none-any.whl

iop/_cli.py

@@ -0,0 +1,247 @@
+from __future__ import annotations
+import argparse
+import json
+import logging
+import os
+from dataclasses import dataclass
+from enum import Enum, auto
+import sys
+from typing import Optional, Callable
+from importlib.metadata import version
+
+from ._director import _Director
+from ._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()
+    UPDATE = 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
+    namespace: Optional[str] = None
+    force_local: bool = False
+    update: bool = False
+
+class Command:
+    def __init__(self, args: CommandArgs):
+        self.args = args
+
+        if self.args.namespace and self.args.namespace != 'not_set':
+            # set environment variable IRISNAMESPACE
+            os.environ['IRISNAMESPACE'] = self.args.namespace
+
+    def _has_primary_command(self) -> bool:
+        return any([
+            self.args.default,
+            self.args.list,
+            self.args.start,
+            self.args.stop,
+            self.args.kill,
+            self.args.restart,
+            self.args.status,
+            self.args.test,
+            self.args.version,
+            self.args.export,
+            self.args.migrate,
+            self.args.log,
+            self.args.init,
+            self.args.update,
+        ])
+
+    def execute(self) -> None:
+        if self.args.namespace == 'not_set' and not self._has_primary_command():
+            print(os.getenv('IRISNAMESPACE', 'not set'))
+            return
+
+        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,
+            CommandType.UPDATE: self._handle_update,
+        }
+        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
+        if self.args.update: return CommandType.UPDATE
+        return CommandType.HELP
+
+    def _handle_default(self) -> None:
+        if self.args.default == 'not_set':
+            print(_Director.get_default_production())
+        elif self.args.default is not None:
+            _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_update(self) -> None:
+        _Director.update_production()
+
+    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 migrate_path is not None:
+            if not os.path.isabs(migrate_path):
+                migrate_path = os.path.join(os.getcwd(), migrate_path)
+            _Utils.migrate_remote(migrate_path, force_local=self.args.force_local)
+
+    def _handle_log(self) -> None:
+        if self.args.log == 'not_set':
+            print(_Director.log_production())
+        elif self.args.log is not None:
+            print(_Director.log_production_top(int(self.args.log)))
+
+    def _handle_init(self) -> None:
+        _Utils.setup(None)
+
+    def _handle_help(self) -> None:
+        create_parser().print_help()
+        try:
+            print(f"\nDefault production: {_Director.get_default_production()}")
+            print(f"\nNamespace: {os.getenv('IRISNAMESPACE','not set')}")
+        except Exception:
+            logging.warning("Could not retrieve 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')
+    parser.add_argument('-u', '--update', help='update a production', action='store_true')
+
+    # 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')
+
+    migrate = main_parser.add_argument_group('migrate arguments')
+    migrate.add_argument('--force-local', help='force local migration, skip remote even if REMOTE_SETTINGS is present', action='store_true')
+
+    namespace = main_parser.add_argument_group('namespace arguments')
+    namespace.add_argument('-n', '--namespace', help='set namespace', 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

@@ -0,0 +1,334 @@
+import abc
+import inspect
+import traceback
+from typing import Any, ClassVar, List, Optional, Tuple
+
+from . import _iris
+from ._log_manager import LogManager, logging
+from ._debugpy import debugpython
+
+class _Common(metaclass=abc.ABCMeta):
+    """Base class that defines common methods for all component types.
+    
+    Provides core functionality like initialization, teardown, connection handling
+    and message type checking that is shared across component types.
+    """
+
+    INFO_URL: ClassVar[str]
+    ICON_URL: ClassVar[str]
+    iris_handle: Any = None
+    _log_to_console: bool = False
+    _logger: Optional[logging.Logger] = None
+
+    @staticmethod
+    def get_adapter_type() -> Optional[str]:
+        """Get the adapter type for this component. Override in subclasses."""
+        return None
+
+    @property
+    def logger(self) -> logging.Logger:
+        if self._logger is None:
+            self._logger = LogManager.get_logger(self.__class__.__name__,self.log_to_console)
+        return self._logger
+    
+    @logger.setter
+    def logger(self, value: logging.Logger) -> None:
+        self._logger = value
+
+    @property
+    def log_to_console(self) -> bool:
+        return self._log_to_console
+    
+    @log_to_console.setter
+    def log_to_console(self, value: bool) -> None:
+        self._log_to_console = value
+        self.logger = LogManager.get_logger(self.__class__.__name__,value)
+
+    # Lifecycle methods
+    def on_init(self) -> None:
+        """Initialize component when started."""
+        pass
+
+    def on_tear_down(self) -> None:
+        """Clean up component before termination."""
+        pass
+
+    def on_connected(self) -> None:
+        """Handle component connection/reconnection."""
+        pass
+
+    # Internal dispatch methods 
+    def _dispatch_on_connected(self, host_object: Any) -> None:
+        self.on_connected()
+
+    def _dispatch_on_init(self, host_object: Any) -> None:
+        """Initialize component when started."""
+        self.on_init()
+
+    def _dispatch_on_tear_down(self, host_object: Any) -> None:
+        self.on_tear_down()
+
+    def _set_iris_handles(self, handle_current: Any, handle_partner: Any) -> None:
+        """Internal method to set IRIS handles."""
+        pass
+
+    def _debugpy(self, host) -> None:
+        """Set up debugpy for debugging."""
+        if debugpython is not None:
+            debugpython(self=self, host_object=host)
+
+    # Component information methods
+    @classmethod
+    def _get_info(cls) -> List[str]:
+        """Get component configuration information.
+        
+        Returns information used to display in Production config UI including:
+        - Superclass
+        - Description  
+        - InfoURL
+        - IconURL
+        - Adapter type (for Business Services/Operations)
+        """
+        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 ["'iop.BusinessService'","'iop.BusinessOperation'","'iop.DuplexOperation'","'iop.DuplexService'",
+                                 "'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:
+                        # for retro-compatibility
+                        adapter = cls.getAdapterType() # type: ignore
+                    break
+                elif classname in ["'iop.BusinessProcess'","'iop.DuplexProcess'","'iop.InboundAdapter'","'iop.OutboundAdapter'",
+                                   "'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) -> List[List[Any]]:
+        """Get component properties for Production configuration.
+        
+        Returns list of property definitions containing:
+        - Property name
+        - Data type
+        - Default value 
+        - Required flag
+        - Category
+        - Description
+        
+        Only includes non-private class attributes and properties.
+        """
+        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'
+                                             ,'log_to_console','logger','iris_handle'
+                                             ,'DISPATCH','adapter','Adapter','buffer'
+                                             ,'BusinessHost','business_host','business_host_python'):
+                            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
+
+    # Logging methods
+    def _log(self) -> Tuple[str, Optional[str]]:
+        """Get class and method name for logging.
+        
+        Returns:
+            Tuple of (class_name, method_name)
+        """
+        current_class = self.__class__.__name__
+        current_method = None
+        try:
+            frame = traceback.extract_stack()[-4]
+            current_method = frame.name
+        except:
+            pass
+        return current_class, current_method
+
+    def _logging(self, message: str, level: int, to_console: Optional[bool] = None) -> None:
+        """Write log entry.
+        
+        Args:
+            message: Message to log
+            level: Log level
+            to_console: If True, log to console instead of IRIS
+        """
+        current_class, current_method = self._log()
+        if to_console is None:
+            to_console = self.log_to_console
+        if level == logging.DEBUG:
+            self.logger.debug(message, extra={'to_console': to_console, 'class_name': current_class, 'method_name': current_method})
+        elif level == logging.INFO:
+            self.logger.info(message, extra={'to_console': to_console, 'class_name': current_class, 'method_name': current_method})
+        elif level == logging.CRITICAL:
+            self.logger.critical(message, extra={'to_console': to_console, 'class_name': current_class, 'method_name': current_method})
+        elif level == logging.WARNING:
+            self.logger.warning(message, extra={'to_console': to_console, 'class_name': current_class, 'method_name': current_method})
+        elif level == logging.ERROR:
+            self.logger.error(message, extra={'to_console': to_console, 'class_name': current_class, 'method_name': current_method})
+
+    def trace(self, message: str, to_console: Optional[bool] = None) -> None:
+        """Write trace log entry.
+        
+        Args:
+            message: Message to log
+            to_console: If True, log to console instead of IRIS
+        """
+        self._logging(message, logging.DEBUG, to_console)
+
+    def log_info(self, message: str, to_console: Optional[bool] = None) -> None:
+        """Write info log entry.
+        
+        Args:
+            message: Message to log
+            to_console: If True, log to console instead of IRIS
+        """
+        self._logging(message, logging.INFO, to_console)
+
+    def log_alert(self, message: str, to_console: Optional[bool] = None) -> None:
+        """Write alert log entry.
+        
+        Args:
+            message: Message to log
+            to_console: If True, log to console instead of IRIS
+        """
+        self._logging(message, logging.CRITICAL, to_console)
+
+    def log_warning(self, message: str, to_console: Optional[bool] = None) -> None:
+        """Write warning log entry.
+        
+        Args:
+            message: Message to log
+            to_console: If True, log to console instead of IRIS
+        """
+        self._logging(message, logging.WARNING, to_console)
+
+    def log_error(self, message: str, to_console: Optional[bool] = None) -> None:
+        """Write error log entry.
+        
+        Args:
+            message: Message to log
+            to_console: If True, log to console instead of IRIS
+        """
+        self._logging(message, logging.ERROR, to_console)
+
+    def log_assert(self, message: str) -> None:
+        """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.
+        """
+        iris = _iris.get_iris()
+        current_class, current_method = self._log()
+        iris.cls("Ens.Util.Log").LogAssert(current_class, current_method, message)
+
+    def LOGINFO(self, message: str) -> None:
+        """DEPRECATED: Use log_info."""
+        return self.log_info(message=message)
+
+    def LOGALERT(self, message: str) -> None:
+        """DEPRECATED: Use log_alert."""
+        return self.log_alert(message)
+
+    def LOGWARNING(self, message: str) -> None:
+        """DEPRECATED: Use log_warning."""
+        return self.log_warning(message)
+
+    def LOGERROR(self, message: str) -> None:
+        """DEPRECATED: Use log_error."""
+        return self.log_error(message)
+
+    def LOGASSERT(self, message: str) -> None:
+        """DEPRECATED: Use log_assert."""
+        return self.log_assert(message)
+        
+    def OnInit(self) -> None:
+        """DEPRECATED: Use on_init."""
+        return 
+
+    def OnTearDown(self) -> None:
+        """DEPRECATED: Use on_tear_down."""
+        return 
+
+    def OnConnected(self) -> None:
+        """DEPRECATED: Use on_connected."""
+        return