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

iop/_debugpy.py

@@ -0,0 +1,187 @@
+
+import threading
+import time
+import contextlib
+import socket
+import os
+import sys
+from contextlib import closing
+from typing import Optional, cast, Any, Dict
+
+def find_free_port(start: Optional[int] = None, end: Optional[int] = None) -> int:
+    port = start
+    if port is None:
+        port = 0
+    if end is None:
+        end = port
+
+    try:
+        with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as s:
+            with contextlib.suppress(Exception):
+                s.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
+
+            s.bind(("0.0.0.0", port))
+
+            s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            return cast(int, s.getsockname()[1])
+    except (SystemExit, KeyboardInterrupt):
+        raise
+    except BaseException:
+        if port and end > port:
+            return find_free_port(port + 1, end)
+        if start and start > 0:
+            return find_free_port(None)
+        raise
+
+def is_debugpy_installed() -> bool:
+    try:
+        __import__("debugpy")
+        return True
+    except ImportError:
+        return False
+
+def _get_python_interpreter_path(install_dir: Optional[str]) -> Optional[str]:
+    """Get the path to the Python interpreter."""
+    if not install_dir:
+        return None
+        
+    python_exe = 'irispython.exe' if sys.platform == 'win32' else 'irispython'
+    python_path = os.path.join(install_dir, 'bin', python_exe)
+    
+    return python_path if os.path.exists(python_path) else None
+
+def _get_debugpy_config(python_path: str) -> Dict[str, str]:
+    """Get the debugpy configuration."""
+    return {"python": python_path}
+
+def configure_debugpy(self, python_path: Optional[str] = None) -> bool:
+    """Configure debugpy with the appropriate Python interpreter."""
+    import debugpy
+
+    if not python_path:
+        install_dir = os.environ.get('IRISINSTALLDIR') or os.environ.get('ISC_PACKAGE_INSTALLDIR')
+        python_path = _get_python_interpreter_path(install_dir)
+        
+    if not python_path:
+        self.log_alert("Could not determine Python interpreter path")
+        return False
+
+    try:
+        debugpy.configure(_get_debugpy_config(python_path))
+        self.log_info(f"Debugpy configured with Python interpreter: {python_path}")
+        return True
+    except Exception as e:
+        self.log_alert(f"Failed to configure debugpy: {e}")
+        return False
+
+def wait_for_debugpy_connected(timeout: float = 30, port: int = 0) -> bool:
+    """Wait for debugpy client to connect."""
+    import debugpy
+
+    if not is_debugpy_installed():
+        return False
+
+    def timeout_handler():
+        time.sleep(timeout)
+        debugpy.wait_for_client.cancel() # type: ignore
+
+    threading.Thread(target=timeout_handler, daemon=True).start()
+    
+    try:
+        debugpy.wait_for_client()
+        return debugpy.is_client_connected()
+    except Exception:
+        import pydevd # type: ignore
+        pydevd.stoptrace()
+        return False
+
+def enable_debugpy(port: int, address: str = "0.0.0.0") -> None:
+    """Enable debugpy server on specified port and address."""
+    import debugpy
+    debugpy.listen((address, port))
+
+def debugpython(self, host_object: Any) -> None:
+    """Enable and configure debugpy for debugging purposes."""
+    # hack to set __file__ for os module in debugpy
+    # This is a workaround for the issue where debugpy cannot find the __file__ attribute of the os module.
+    if not hasattr(os, '__file__'):
+        setattr(os, '__file__', __file__)
+
+
+    if host_object is None:
+        self.log_alert("No host object found, cannot enable debugpy.")
+        return
+
+    if host_object._enable != 1:
+        self.log_info("Debugpy is not enabled.")
+        return
+
+    if not is_debugpy_installed():
+        self.log_alert("Debugpy is not installed.")
+        return
+
+    # Configure Python interpreter
+    if host_object._PythonInterpreterPath != '':
+        success = configure_debugpy(self, host_object.PythonInterpreterPath)
+    else:
+        success = configure_debugpy(self)
+
+    if not success:
+        return
+
+    # Setup debugging server
+    port = host_object._port if host_object._port and host_object._port > 0 else find_free_port()
+    
+    try:
+        enable_debugpy(port=port)
+        self.log_info(f"Debugpy enabled on port {port}")
+        
+        self.trace(f"Waiting {host_object._timeout} seconds for debugpy connection...")
+        if wait_for_debugpy_connected(timeout=host_object._timeout, port=port):
+            self.log_info("Debugpy connected successfully")
+        else:
+            self.log_alert(f"Debugpy connection timed out after {host_object._timeout} seconds")
+    except Exception as e:
+        self.log_alert(f"Error enabling debugpy: {e}")
+
+def debugpy_in_iris(iris_dir, port) -> bool:
+
+    if not hasattr(os, '__file__'):
+        setattr(os, '__file__', __file__)
+
+    if not is_debugpy_installed():
+        print("debugpy is not installed.")
+        return False
+    if not iris_dir:
+        print("IRIS directory is not specified.")
+        return False
+    
+    import debugpy
+    python_path = _get_python_interpreter_path(mgr_dir_to_install_dir(iris_dir))
+    if not python_path:
+        return False
+    debugpy.configure(_get_debugpy_config(python_path))
+
+    try:
+        enable_debugpy(port=port)
+    except Exception as e:
+        print(f"Failed to enable debugpy: {e}")
+        return False
+
+    print(f"Debugpy is waiting for connection on port {port}...")
+    if wait_for_debugpy_connected(timeout=30, port=port):
+        print(f"Debugpy is connected on port {port}")
+        return True
+    else:
+        print(f"Debugpy connection timed out after 30 seconds on port {port}")
+        return False
+
+def mgr_dir_to_install_dir(mgr_dir: str) -> Optional[str]:
+    """Convert manager directory to install directory."""
+    import os
+    if not mgr_dir:
+        return None
+    install_dir = os.path.dirname(os.path.dirname(mgr_dir))
+    if os.path.exists(install_dir):
+        return install_dir
+    return None

iop/_decorators.py

@@ -0,0 +1,49 @@
+from functools import wraps
+from typing import Any, Callable
+
+from ._dispatch import dispatch_deserializer, dispatch_serializer
+
+def input_serializer(fonction: Callable) -> Callable:
+    """Decorator that serializes all input arguments."""
+    def _dispatch_serializer(self, *params: Any, **param2: Any) -> Any:
+        serialized = [dispatch_serializer(param) for param in params]
+        param2 = {key: dispatch_serializer(value) for key, value in param2.items()}
+        return fonction(self, *serialized, **param2)
+    return _dispatch_serializer
+
+def input_serializer_param(position: int, name: str) -> Callable:
+    """Decorator that serializes specific parameter by position or name."""
+    def _input_serializer_param(fonction: Callable) -> Callable:
+        @wraps(fonction) 
+        def _dispatch_serializer(self, *params: Any, **param2: Any) -> Any:
+            serialized = [
+                dispatch_serializer(param) if i == position else param
+                for i, param in enumerate(params)
+            ]
+            param2 = {
+                key: dispatch_serializer(value) if key == name else value
+                for key, value in param2.items()
+            }
+            return fonction(self, *serialized, **param2)
+        return _dispatch_serializer
+    return _input_serializer_param
+
+def output_deserializer(fonction: Callable) -> Callable:
+    """Decorator that deserializes function output."""
+    def _dispatch_deserializer(self, *params: Any, **param2: Any) -> Any:
+        return dispatch_deserializer(fonction(self, *params, **param2))
+    return _dispatch_deserializer
+
+def input_deserializer(fonction: Callable) -> Callable:
+    """Decorator that deserializes all input arguments."""
+    def _dispatch_deserializer(self, *params: Any, **param2: Any) -> Any:
+        serialized = [dispatch_deserializer(param) for param in params]
+        param2 = {key: dispatch_deserializer(value) for key, value in param2.items()}
+        return fonction(self, *serialized, **param2)
+    return _dispatch_deserializer
+
+def output_serializer(fonction: Callable) -> Callable:
+    """Decorator that serializes function output."""
+    def _dispatch_serializer(self, *params: Any, **param2: Any) -> Any:
+        return dispatch_serializer(fonction(self, *params, **param2))
+    return _dispatch_serializer

iop/_director.py

@@ -0,0 +1,301 @@
+import asyncio
+import datetime
+import functools
+import signal
+from dataclasses import dataclass
+
+from . import _iris
+from ._dispatch import dispatch_deserializer, dispatch_serializer
+from ._utils import _Utils
+
+@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
+
+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.get_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.get_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:str, handler: SigintHandler):
+        _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.get_iris().cls('Ens.Director').StartProduction(production_name)
+
+    ### stop production
+    @staticmethod
+    def stop_production():
+        _iris.get_iris().cls('Ens.Director').StopProduction()
+
+    ### restart production
+    @staticmethod
+    def restart_production():
+        _iris.get_iris().cls('Ens.Director').RestartProduction()
+
+    ### shutdown production
+    @staticmethod
+    def shutdown_production():
+        _iris.get_iris().cls('Ens.Director').StopProduction(10,1)
+
+    ### update production
+    @staticmethod
+    def update_production():
+        _iris.get_iris().cls('Ens.Director').UpdateProduction()
+
+    ### list production
+    @staticmethod
+    def list_productions():
+        return _iris.get_iris().cls('IOP.Director').dispatchListProductions()
+    
+    ### status production
+    @staticmethod
+    def status_production():
+        dikt = _iris.get_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.get_iris().gref("^Ens.Configuration")
+        glb['csp', "LastProduction"] = production_name
+
+    ### get default production
+    @staticmethod
+    def get_default_production():
+        glb = _iris.get_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(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 = []
+        stmt = _iris.get_iris().sql.prepare(sql)
+        rs = stmt.execute(top)
+        for row in rs:
+            result.append(_Director.format_log(row))
+        return result
+
+    @staticmethod
+    def read_log() -> 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 = []
+        stmt = _iris.get_iris().sql.prepare(sql)
+        time = datetime.datetime.now() - datetime.timedelta(seconds=1)
+        # convert to utc time
+        time = time.astimezone(datetime.timezone.utc)
+        rs = stmt.execute(time.isoformat(sep=' '))
+        for row in rs:
+            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
+        """
+        while True:
+            for row in reversed(_Director.read_log()):
+                print(row)
+            if handler.sigint_log:
+                break
+            await asyncio.sleep(1)
+
+    @staticmethod
+    def log_production_top(top=10):
+        """ 
+        Log the top N logs of the production
+        Parameters:
+        top: the number of log to display
+        """
+        for row in reversed(_Director.read_top_log(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))
+
+        for row in reversed(_Director.read_top_log( 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
+        """
+        iris = _iris.get_iris()
+        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
+        serial_message = dispatch_serializer(message)
+        response = iris.cls('IOP.Utils').dispatchTestComponent(target,serial_message)
+        try:
+            deserialized_response = 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
+

iop/_dispatch.py

@@ -0,0 +1,136 @@
+from inspect import signature, Parameter
+from typing import Any, List, Tuple, Callable
+
+from ._serialization import serialize_message, serialize_pickle_message, deserialize_message, deserialize_pickle_message, serialize_message_generator, serialize_pickle_message_generator
+from ._message_validator import is_message_instance, is_pickle_message_instance, is_iris_object_instance
+
+def dispatch_serializer(message: Any, is_generator: bool = False) -> Any:
+    """Serializes the message based on its type.
+    
+    Args:
+        message: The message to serialize
+        
+    Returns:
+        The serialized message
+        
+    Raises:
+        TypeError: If message is invalid type
+    """
+    if message is not None:
+        if is_message_instance(message):
+            if is_generator:
+                return serialize_message_generator(message)
+            return serialize_message(message)
+        elif is_pickle_message_instance(message):
+            if is_generator:
+                return serialize_pickle_message_generator(message)
+            return serialize_pickle_message(message)
+        elif is_iris_object_instance(message):
+            return message
+
+    if message == "" or message is None:
+        return message
+
+    if hasattr(message, '__iter__'):
+        raise TypeError("You may have tried to invoke a generator function without using the 'send_generator_request' method. Please use that method to handle generator functions.")
+
+    raise TypeError("The message must be an instance of a class that is a subclass of Message or IRISObject %Persistent class.")
+
+def dispatch_deserializer(serial: Any) -> Any:
+    """Deserializes the message based on its type.
+    
+    Args:
+        serial: The serialized message
+        
+    Returns:
+        The deserialized message
+    """
+    if (
+        serial is not None
+        and type(serial).__module__.startswith('iris')
+        and (
+            serial._IsA("IOP.Message")
+            or serial._IsA("Grongier.PEX.Message")
+        )
+    ):
+        return deserialize_message(serial)
+    elif (
+        serial is not None
+        and type(serial).__module__.startswith('iris')
+        and (
+            serial._IsA("IOP.PickleMessage")
+            or serial._IsA("Grongier.PEX.PickleMessage")
+        )
+    ):
+        return deserialize_pickle_message(serial)
+    else:
+        return serial
+
+def dispach_message(host: Any, request: Any) -> Any:
+    """Dispatches the message to the appropriate method.
+    
+    Args:
+        request: The request object
+        
+    Returns:
+        The response object
+    """
+    call = 'on_message'
+
+    module = request.__class__.__module__
+    classname = request.__class__.__name__
+
+    for msg, method in host.DISPATCH:
+        if msg == module + "." + classname:
+            call = method
+
+    return getattr(host, call)(request)
+
+def create_dispatch(host: Any) -> None:
+    """Creates a dispatch table mapping class names to their handler methods.
+    The dispatch table consists of tuples of (fully_qualified_class_name, method_name).
+    Only methods that take a single typed parameter are considered as handlers.
+    """
+    if len(host.DISPATCH) > 0:
+        return
+
+    for method_name in get_callable_methods(host):
+        handler_info = get_handler_info(host, method_name)
+        if handler_info:
+            host.DISPATCH.append(handler_info)
+
+def get_callable_methods(host: Any) -> List[str]:
+    """Returns a list of callable method names that don't start with underscore."""
+    return [
+        func for func in dir(host) 
+        if callable(getattr(host, func)) and not func.startswith("_")
+    ]
+
+def get_handler_info(host: Any, method_name: str) -> Tuple[str, str] | None:
+    """Analyzes a method to determine if it's a valid message handler.
+    Returns a tuple of (fully_qualified_class_name, method_name) if valid,
+    None otherwise.
+    """
+    try:
+        params = signature(getattr(host, method_name)).parameters
+        if len(params) != 1:
+            return None
+
+        param: Parameter = next(iter(params.values()))
+        annotation = param.annotation
+
+        if isinstance(annotation, str):
+            # return it as is, assuming it's a fully qualified class name
+            return annotation, method_name
+        
+        if is_iris_object_instance(annotation):
+            return f"{type(annotation).__module__}.{type(annotation).__name__}", method_name
+        
+        if annotation == Parameter.empty or not isinstance(annotation, type):
+
+            return None
+
+        return f"{annotation.__module__}.{annotation.__name__}", method_name
+            
+    except ValueError:
+        return None