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

iop/_common.py

@@ -0,0 +1,352 @@
+import abc
+import dataclasses
+import inspect
+import iris
+import traceback
+from typing import Any, ClassVar, Dict, List, Optional, Tuple, Type
+from iop._log_manager import LogManager
+import logging
+
+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
+
+    def on_init(self) -> None:
+        """Initialize component when started.
+        
+        Called when component starts. Use to initialize required structures.
+        """
+        return self.OnInit()
+
+    def on_tear_down(self) -> None:
+        """Clean up component before termination.
+        
+        Called before component terminates. Use to free resources.
+        """
+        return self.OnTearDown()
+
+    def on_connected(self) -> None:
+        """Handle component connection/reconnection.
+        
+        Called when component connects or reconnects after disconnection.
+        Use to initialize connection-dependent structures.
+        """
+        return self.OnConnected()
+
+    def _dispatch_on_connected(self, host_object: Any) -> None:
+        """Internal dispatch for connection handling."""
+        self.on_connected()
+        return
+
+    def _dispatch_on_init(self, host_object: Any) -> None:
+        """Internal dispatch for initialization."""
+        self.on_init()
+        return
+
+    def _dispatch_on_tear_down(self, host_object: Any) -> None:
+        """Internal dispatch for teardown."""
+        self.on_tear_down()
+        return
+
+    def _set_iris_handles(self, handle_current: Any, handle_partner: Any) -> None:
+        """Internal method to set IRIS handles."""
+        pass
+
+    @classmethod
+    def _is_message_instance(cls, obj: Any) -> bool:
+        """Check if object is a valid Message instance.
+        
+        Args:
+            obj: Object to check
+            
+        Returns:
+            True if object is a Message instance
+            
+        Raises:
+            TypeError: If object is Message class but not a dataclass
+        """
+        if cls._is_message_class(type(obj)):
+            if not dataclasses.is_dataclass(obj):
+                raise TypeError(f"{type(obj).__module__}.{type(obj).__qualname__} must be a dataclass")
+            return True
+        return False
+
+    @classmethod
+    def _is_pickle_message_instance(cls, obj: Any) -> bool:
+        """Check if object is a PickleMessage instance."""
+        if cls._is_pickel_message_class(type(obj)):
+            return True
+        return False
+    
+    @classmethod
+    def _is_iris_object_instance(cls, obj: Any) -> bool:
+        """Check if object is an IRIS persistent object."""
+        if (obj is not None and type(obj).__module__.find('iris') == 0) and obj._IsA("%Persistent"):
+            return True
+        return False
+
+    @classmethod
+    def _is_message_class(cls, klass: Type) -> bool:
+        name = klass.__module__ + '.' + klass.__qualname__
+        if name == "iop.Message" or name == "grongier.pex.Message": 
+            return True
+        for c in klass.__bases__:
+            if cls._is_message_class(c): 
+                return True
+        return False
+
+    @classmethod
+    def _is_pickel_message_class(cls, klass: Type) -> bool:
+        name = klass.__module__ + '.' + klass.__qualname__
+        if name == "iop.PickleMessage" or name == "grongier.pex.PickleMessage": 
+            return True
+        for c in klass.__bases__:
+            if cls._is_pickel_message_class(c): 
+                return True
+        return False
+
+    @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:
+                        adapter = cls.getAdapterType()
+                    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') :
+                            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(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
+
+    @property
+    def logger(self) -> logging.Logger:
+        """Get a logger instance for this component.
+        
+        Returns:
+            Logger configured for IRIS integration
+        """
+        class_name, method_name = self._log()
+        return LogManager.get_logger(class_name, method_name, self.log_to_console)
+
+    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.logger.debug(message, extra={'to_console': 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.logger.info(message, extra={'to_console': 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.logger.critical(message, extra={'to_console': 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.logger.warning(message, extra={'to_console': 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.logger.error(message, extra={'to_console': 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.
+        """
+        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

iop/_director.py

@@ -0,0 +1,301 @@
+import asyncio
+import datetime
+import functools
+import iris
+import intersystems_iris.dbapi._DBAPI as irisdbapi
+import signal
+from dataclasses import dataclass
+
+from iop._business_host import _BusinessHost
+from iop._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.
+    """
+
+    _bs = {}
+
+    def get_business_service(self,target,force_session_id=False):
+        """ get the business service
+        Parameters:
+        target: the name of the business service
+        force_session_id: if True, force the session id to be a new one
+        """
+        if target not in self._bs or self._bs[target] is None:
+            self._bs[target] = _Director.create_python_business_service(target)
+        if force_session_id:
+            self._bs[target].iris_handle._SessionId = ""
+            self._bs[target].iris_handle.ForceSessionId()
+        return self._bs[target]
+
+    @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("IOP.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("IOP.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('IOP.Director').dispatchListProductions()
+    
+    ### status production
+    @staticmethod
+    def status_production():
+        dikt = iris.cls('IOP.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("IOP.Message")._New()
+                message.classname = classname
+                if body:
+                    message.json = body
+                else:
+                    message.json = _Utils.string_to_stream("{}")
+        # serialize the message
+        business_host = _BusinessHost()
+        serial_message = business_host._dispatch_serializer(message)
+        response = iris.cls('IOP.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

{grongier/pex → iop}/_inbound_adapter.py

@@ -1,4 +1,4 @@
-from grongier.pex._common import _Common
+from iop._common import _Common
 
 class _InboundAdapter(_Common):
     """ Responsible for receiving the data from the external system, validating the data,