iris-pex-embedded-python 3.4.0b14__py3-none-any.whl → 3.4.1__py3-none-any.whl

iop/_async_request.py

@@ -1,5 +1,5 @@
 import asyncio
-import iris
+from . import _iris
 from typing import Any, Optional, Union
 from iop._dispatch import dispatch_deserializer, dispatch_serializer
 from iop._message import _Message as Message
@@ -24,6 +24,7 @@ class AsyncRequest(asyncio.Future):
 
     async def send(self) -> None:
         # init parameters
+        iris = _iris.get_iris()
         message_header_id = iris.ref()
         queue_name = iris.ref()
         end_time = iris.ref()
@@ -46,6 +47,7 @@ class AsyncRequest(asyncio.Future):
         self.set_result(self._response)
 
     def is_done(self) -> None:
+        iris = _iris.get_iris()
         response = iris.ref()
         status = self._iris_handle.dispatchIsRequestDone(self.timeout, self._end_time,
                                                        self._queue_name, self._message_header_id,

iop/_business_host.py

@@ -1,7 +1,7 @@
 from inspect import getsource
 from typing import Any,List, Optional, Tuple, Union
 
-import iris
+from . import _iris
 
 from iop._common import _Common
 from iop._message import _Message as Message
@@ -109,6 +109,7 @@ class _BusinessHost(_Common):
 
     def _create_call_structure(self, target: str, request: Union[Message, Any]) -> Any:
         """Create an Ens.CallStructure object for the request."""
+        iris = _iris.get_iris()
         call = iris.cls("Ens.CallStructure")._New()
         call.TargetDispatchName = target
         call.Request = dispatch_serializer(request)

iop/_business_service.py

@@ -16,6 +16,12 @@ class _BusinessService(_BusinessHost):
     Adapter = adapter = None
     _wait_for_next_call_interval = False
 
+    def _dispatch_on_init(self, host_object) -> None:
+        """For internal use only."""
+        self.on_init()
+
+        return
+
     def on_process_input(self, message_input):
         """ Receives the message from the inbond adapter via the PRocessInput method and is responsible for forwarding it to target business processes or operations.
         If the business service does not specify an adapter, then the default adapter calls this method with no message 

iop/_cli.py

@@ -7,10 +7,10 @@ from enum import Enum, auto
 import sys
 from typing import Optional, Callable
 from importlib.metadata import version
-
 from iop._director import _Director
 from iop._utils import _Utils
 
+
 class CommandType(Enum):
     DEFAULT = auto()
     LIST = auto()
@@ -46,11 +46,16 @@ class CommandArgs:
     test: Optional[str] = None
     classname: Optional[str] = None
     body: Optional[str] = None
+    namespace: Optional[str] = None
 
 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 execute(self) -> None:
         command_type = self._determine_command_type()
         command_handlers = {
@@ -182,6 +187,9 @@ def create_parser() -> argparse.ArgumentParser:
     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')
+
+    namespace = main_parser.add_argument_group('namespace arguments')
+    namespace.add_argument('-n', '--namespace', help='set namespace', nargs='?', const='not_set')
     
     return main_parser
 

iop/_common.py

@@ -1,12 +1,15 @@
 import abc
 import inspect
 import traceback
+
 from typing import Any, ClassVar, List, Optional, Tuple
 
-import iris
+from . import _iris
 
 from iop._log_manager import LogManager, logging
 
+from iop._debugpy import debugpython
+
 class _Common(metaclass=abc.ABCMeta):
     """Base class that defines common methods for all component types.
     
@@ -57,6 +60,7 @@ class _Common(metaclass=abc.ABCMeta):
         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:
@@ -66,6 +70,11 @@ class _Common(metaclass=abc.ABCMeta):
         """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]:
@@ -285,6 +294,7 @@ class _Common(metaclass=abc.ABCMeta):
         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)
 

iop/_debugpy.py

@@ -0,0 +1,145 @@
+
+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()
+
+    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}")

iop/_director.py

@@ -1,8 +1,7 @@
 import asyncio
 import datetime
 import functools
-import iris
-import intersystems_iris.dbapi._DBAPI as irisdbapi
+from . import _iris
 import signal
 from dataclasses import dataclass
 
@@ -55,7 +54,7 @@ class _Director():
         Returns:
             an object that contains an instance of IRISBusinessService
         """
-        iris_object = iris.cls("IOP.Director").dispatchCreateBusinessService(target)
+        iris_object = _iris.get_iris().cls("IOP.Director").dispatchCreateBusinessService(target)
         return iris_object
 
     @staticmethod
@@ -69,7 +68,7 @@ class _Director():
         Returns:
             an object that contains an instance of IRISBusinessService
         """
-        iris_object = iris.cls("IOP.Director").dispatchCreateBusinessService(target)
+        iris_object = _iris.get_iris().cls("IOP.Director").dispatchCreateBusinessService(target)
         return iris_object.GetClass()
     
     ### List of function to manage the production
@@ -102,37 +101,37 @@ class _Director():
     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)
+        _iris.get_iris().cls('Ens.Director').StartProduction(production_name)
 
     ### stop production
     @staticmethod
     def stop_production():
-        iris.cls('Ens.Director').StopProduction()
+        _iris.get_iris().cls('Ens.Director').StopProduction()
 
     ### restart production
     @staticmethod
     def restart_production():
-        iris.cls('Ens.Director').RestartProduction()
+        _iris.get_iris().cls('Ens.Director').RestartProduction()
 
     ### shutdown production
     @staticmethod
     def shutdown_production():
-        iris.cls('Ens.Director').StopProduction(10,1)
+        _iris.get_iris().cls('Ens.Director').StopProduction(10,1)
 
     ### update production
     @staticmethod
     def update_production():
-        iris.cls('Ens.Director').UpdateProduction()
+        _iris.get_iris().cls('Ens.Director').UpdateProduction()
 
     ### list production
     @staticmethod
     def list_productions():
-        return iris.cls('IOP.Director').dispatchListProductions()
+        return _iris.get_iris().cls('IOP.Director').dispatchListProductions()
     
     ### status production
     @staticmethod
     def status_production():
-        dikt = iris.cls('IOP.Director').StatusProduction()
+        dikt = _iris.get_iris().cls('IOP.Director').StatusProduction()
         if dikt['Production'] is None or dikt['Production'] == '':
             dikt['Production'] = _Director.get_default_production()
         return dikt
@@ -141,13 +140,13 @@ class _Director():
     @staticmethod
     def set_default_production(production_name=''):
         #set ^Ens.Configuration("SuperUser","LastProduction")
-        glb = iris.gref("^Ens.Configuration")
+        glb = _iris.get_iris().gref("^Ens.Configuration")
         glb['csp', "LastProduction"] = production_name
 
     ### get default production
     @staticmethod
     def get_default_production():
-        glb = iris.gref("^Ens.Configuration")
+        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'
@@ -178,7 +177,7 @@ class _Director():
         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:
+    def read_top_log(top) -> list:
         sql = """
         SELECT top ?
         ID, ConfigName, Job, MessageId, SessionId, SourceClass, SourceMethod, Stack, Text, TimeLogged, TraceCat, Type
@@ -186,13 +185,14 @@ class _Director():
         order by id desc
         """
         result = []
-        cursor.execute(sql, top)
-        for row in cursor:
+        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(cursor) -> list:
+    def read_log() -> list:
         sql = """
         SELECT 
         ID, ConfigName, Job, MessageId, SessionId, SourceClass, SourceMethod, Stack, Text, TimeLogged, TraceCat, Type
@@ -201,8 +201,12 @@ class _Director():
         order by id desc
         """
         result = []
-        cursor.execute(sql, (datetime.datetime.now() - datetime.timedelta(seconds=1),))
-        for row in cursor:
+        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
 
@@ -211,14 +215,12 @@ class _Director():
         """ 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)
+        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):
@@ -227,10 +229,8 @@ class _Director():
         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)
+        for row in reversed(_Director.read_top_log(top)):
+            print(row)
 
     @staticmethod
     def log_production():
@@ -240,10 +240,10 @@ class _Director():
         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)
+
+        for row in reversed(_Director.read_top_log( 10)):
+            print(row)
+    
         loop.run_until_complete(_Director._log_production_async(handler))
         loop.close()
 
@@ -257,20 +257,20 @@ class _Director():
         body: the body of the message
         """
         if not message:
-            message = iris.cls('Ens.Request')._New()
+            message = _iris.get_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)
+                    message = _iris.get_iris().cls(classname)._New(body)
                 else:
-                    message = iris.cls(classname)._New()
+                    message = _iris.get_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 = _iris.get_iris().cls("IOP.Message")._New()
                 message.classname = classname
                 if body:
                     message.json = body
@@ -278,7 +278,7 @@ class _Director():
                     message.json = _Utils.string_to_stream("{}")
         # serialize the message
         serial_message = dispatch_serializer(message)
-        response = iris.cls('IOP.Utils').dispatchTestComponent(target,serial_message)
+        response = _iris.get_iris().cls('IOP.Utils').dispatchTestComponent(target,serial_message)
         try:
             deserialized_response = dispatch_deserializer(response)
         except ImportError as e:

iop/_iris.py

@@ -0,0 +1,7 @@
+import os
+
+def get_iris(namespace:str=None)->'iris':
+    if namespace:
+        os.environ['IRISNAMESPACE'] = namespace
+    import iris
+    return iris

iop/_log_manager.py

@@ -1,5 +1,5 @@
 import traceback
-import iris
+from . import _iris
 import logging
 from typing import Optional, Tuple
 
@@ -41,11 +41,11 @@ class IRISLogHandler(logging.Handler):
 
         # Map Python logging levels to IRIS logging methods
         self.level_map = {
-            logging.DEBUG: iris.cls("Ens.Util.Log").LogTrace,
-            logging.INFO: iris.cls("Ens.Util.Log").LogInfo,
-            logging.WARNING: iris.cls("Ens.Util.Log").LogWarning,
-            logging.ERROR: iris.cls("Ens.Util.Log").LogError,
-            logging.CRITICAL: iris.cls("Ens.Util.Log").LogAlert,
+            logging.DEBUG: 5,
+            logging.INFO: 4,
+            logging.WARNING: 3,
+            logging.ERROR: 2,
+            logging.CRITICAL: 6,
         }
         # Map Python logging levels to IRIS logging Console level
         self.level_map_console = {
@@ -76,8 +76,8 @@ class IRISLogHandler(logging.Handler):
         class_name = record.class_name if hasattr(record, "class_name") else record.name
         method_name = record.method_name if hasattr(record, "method_name") else record.funcName
         if self.to_console or (hasattr(record, "to_console") and record.to_console):
-            iris.cls("%SYS.System").WriteToConsoleLog(self.format(record),
+            _iris.get_iris().cls("%SYS.System").WriteToConsoleLog(self.format(record),
                 0,self.level_map_console.get(record.levelno, 0),class_name+"."+method_name)
         else:
-            log_func = self.level_map.get(record.levelno, iris.cls("Ens.Util.Log").LogInfo)
-            log_func(class_name, method_name, self.format(record))
+            log_lvl = self.level_map.get(record.levelno, 4)
+            _iris.get_iris().cls("Ens.Util.Log").Log(log_lvl,class_name, method_name, self.format(record))

iop/_serialization.py

@@ -4,13 +4,13 @@ import importlib
 import inspect
 import pickle
 import json
-from dataclasses import asdict, is_dataclass
+from dataclasses import is_dataclass
 from typing import Any, Dict, Type
 
-import iris
+from . import _iris
 from pydantic import BaseModel, TypeAdapter, ValidationError
 
-from iop._message import _PydanticPickleMessage
+from iop._message import _PydanticPickleMessage, _Message
 from iop._utils import _Utils
 
 class SerializationError(Exception):
@@ -31,23 +31,23 @@ class MessageSerializer:
         """Convert objects to JSON-safe format."""
         if isinstance(obj, BaseModel):
             return obj.model_dump_json()
-        elif is_dataclass(obj):
+        elif is_dataclass(obj) and isinstance(obj, _Message):
             return TempPydanticModel.model_validate(dataclass_to_dict(obj)).model_dump_json()
         else:
-            raise SerializationError(f"Object {obj} must be a Pydantic model or dataclass")
+            raise SerializationError(f"Object {obj} must be a Pydantic model or dataclass Message")
 
     @staticmethod
-    def serialize(message: Any, use_pickle: bool = False) -> iris.cls:
+    def serialize(message: Any, use_pickle: bool = False) -> Any:
         """Serializes a message to IRIS format."""
         if isinstance(message, _PydanticPickleMessage) or use_pickle:
             return MessageSerializer._serialize_pickle(message)
         return MessageSerializer._serialize_json(message)
 
     @staticmethod
-    def _serialize_json(message: Any) -> iris.cls:
+    def _serialize_json(message: Any) -> Any:
         json_string = MessageSerializer._convert_to_json_safe(message)
         
-        msg = iris.cls('IOP.Message')._New()
+        msg = _iris.get_iris().cls('IOP.Message')._New()
         msg.classname = f"{message.__class__.__module__}.{message.__class__.__name__}"
         
         if hasattr(msg, 'buffer') and len(json_string) > msg.buffer:
@@ -57,13 +57,13 @@ class MessageSerializer:
         return msg
 
     @staticmethod
-    def deserialize(serial: iris.cls, use_pickle: bool = False) -> Any:
+    def deserialize(serial: Any, use_pickle: bool = False) -> Any:
         if use_pickle:
             return MessageSerializer._deserialize_pickle(serial)
         return MessageSerializer._deserialize_json(serial)
 
     @staticmethod
-    def _deserialize_json(serial: iris.cls) -> Any:
+    def _deserialize_json(serial: Any) -> Any:
         if not serial.classname:
             raise SerializationError("JSON message malformed, must include classname")
         
@@ -88,15 +88,15 @@ class MessageSerializer:
             raise SerializationError(f"Failed to deserialize JSON: {str(e)}")
 
     @staticmethod
-    def _serialize_pickle(message: Any) -> iris.cls:
+    def _serialize_pickle(message: Any) -> Any:
         pickle_string = codecs.encode(pickle.dumps(message), "base64").decode()
-        msg = iris.cls('IOP.PickleMessage')._New()
+        msg = _iris.get_iris().cls('IOP.PickleMessage')._New()
         msg.classname = f"{message.__class__.__module__}.{message.__class__.__name__}"
         msg.jstr = _Utils.string_to_stream(pickle_string)
         return msg
 
     @staticmethod
-    def _deserialize_pickle(serial: iris.cls) -> Any:
+    def _deserialize_pickle(serial: Any) -> Any:
         string = _Utils.stream_to_string(serial.jstr)
         return pickle.loads(codecs.decode(string.encode(), "base64"))
 
@@ -149,12 +149,20 @@ def dataclass_from_dict(klass: Type, dikt: Dict) -> Any:
 def dataclass_to_dict(instance: Any) -> Dict:
     """Converts a class instance to a dictionary.
     Handles non attended fields."""
-    dikt = asdict(instance)
-    # assign any extra fields
-    for k, v in vars(instance).items():
-        if k not in dikt:
-            dikt[k] = v
-    return dikt
+    result = {}
+    for field in instance.__dict__:
+        value = getattr(instance, field)
+        if is_dataclass(value):
+            result[field] = dataclass_to_dict(value)
+        elif isinstance(value, list):
+            result[field] = [dataclass_to_dict(i) if is_dataclass(i) else i for i in value]
+        elif isinstance(value, dict):
+            result[field] = {k: dataclass_to_dict(v) if is_dataclass(v) else v for k, v in value.items()}
+        elif hasattr(value, '__dict__'):
+            result[field] = dataclass_to_dict(value)
+        else:
+            result[field] = value
+    return result
 
 # Maintain backwards compatibility
 serialize_pickle_message = lambda msg: MessageSerializer.serialize(msg, use_pickle=True)