Remove debugpy calls from initialization methods and enhance debugpy configuration in relevant classes

Author: grongierisc

src/iop/_business_operation.py

@@ -47,7 +47,6 @@ def _set_iris_handles(self, handle_current: Any, handle_partner: Any) -> None:
 
     def _dispatch_on_init(self, host_object: Any) -> None:
         """For internal use only."""
-        self._debugpy(host_object=host_object)
         create_dispatch(self)
         self.on_init()
         return

src/iop/_business_process.py

@@ -141,7 +141,6 @@ def _dispatch_on_connected(self, host_object: Any) -> None:
     def _dispatch_on_init(self, host_object: Any) -> None:
         """For internal use only."""
         self._restore_persistent_properties(host_object)
-        self._debugpy(host_object=host_object)
         create_dispatch(self)
         self.on_init()
         self._save_persistent_properties(host_object)

src/iop/_business_service.py

@@ -18,9 +18,6 @@ class _BusinessService(_BusinessHost):
 
     def _dispatch_on_init(self, host_object) -> None:
         """For internal use only."""
-
-        self._debugpy(host_object=host_object)
-
         self.on_init()
 
         return

src/iop/_common.py

@@ -8,6 +8,8 @@
 
 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.
     
@@ -59,85 +61,20 @@ def _dispatch_on_connected(self, host_object: Any) -> None:
 
     def _dispatch_on_init(self, host_object: Any) -> None:
         """Initialize component when started."""
-        self._debugpy(host_object)
         self.on_init()
 
-    def _debugpy(self, host_object: Any) -> None:
-        """Enable debugpy for debugging purposes."""
-        # iris.cls('%SYS.Python').Debugging(1)
-        from iop._debugpy import enable_debugpy, wait_for_debugpy_connected, find_free_port, is_debugpy_installed
-        import sys, os
-
-        # 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 not None:
-            port = host_object.port
-            timeout = host_object.timeout
-            enabled = host_object.enable
-            python_interpreter_path = host_object.PythonInterpreterPath
-        else:
-            self.log_alert("No host object found, cannot enable debugpy.")
-            return
-        
-        if python_interpreter_path != "":
-            # the user has set a specific python interpreter path, so we need to set the path to the python executable
-            # to the one that is running this script
-            if os.path.exists(python_interpreter_path):
-                sys.executable = python_interpreter_path
-            else:
-                self.log_alert(f"Python path {python_interpreter_path} does not exist, cannot set python path for debugpy.")
-                return
-        elif sys.executable.find('irisdb') > 0:
-            # the executable is the IRIS executable, so we need to set the path to the python executable
-            # to the one that is running this script
-            installdir = os.environ.get('IRISINSTALLDIR') or os.environ.get('ISC_PACKAGE_INSTALLDIR')
-            if installdir is not None:
-                if sys.platform == 'win32':
-                    python_path = os.path.join(installdir, 'bin', 'irispython.exe')
-                else:
-                    python_path = os.path.join(installdir, 'bin', 'irispython')
-                if os.path.exists(python_path):
-                    sys.executable = python_path
-                else:
-                    self.log_alert(f"Python path {python_path} does not exist, cannot set python path for debugpy.")
-                    return
-            else:
-                self.log_alert("IRISINSTALLDIR or ISC_PACKAGE_INSTALLDIR not set, cannot set python path for debugpy.")
-                return
-
-        if enabled:
-            self.log_info(f"Debugpy is running in {sys.executable}.")
-            if is_debugpy_installed():
-                if port is None or port <= 0:
-                    port = find_free_port()
-                self.log_info(f"Debugpy enabled.")
-                try:
-                    enable_debugpy(port=port, address=None)
-                except Exception as e:
-                    self.log_alert(f"Error enabling debugpy: {e}")
-                    return
-
-                self.trace(f"Waiting for {timeout} sec to debugpy connection on port {port}...")
-                if wait_for_debugpy_connected(timeout=timeout, port=port):
-                    self.log_info("Debugpy connected.")
-                else:
-                    self.log_alert(f"Debugpy connection timed out after {timeout} seconds.")
-            else:
-                self.log_alert("Debugpy is not installed.")
-        else:
-            self.log_info("Debugpy is not enabled.")
-
-
     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]:

src/iop/_debugpy.py

@@ -3,9 +3,10 @@
 import time
 import contextlib
 import socket
+import os
+import sys
 from contextlib import closing
-
-from typing import Optional, Tuple, Union, Sequence, cast, Callable, TypeVar, Dict, Any
+from typing import Optional, cast, Any, Dict
 
 def find_free_port(start: Optional[int] = None, end: Optional[int] = None) -> int:
     port = start
@@ -32,38 +33,113 @@ def find_free_port(start: Optional[int] = None, end: Optional[int] = None) -> in
             return find_free_port(None)
         raise
 
-
 def is_debugpy_installed() -> bool:
     try:
         __import__("debugpy")
+        return True
     except ImportError:
         return False
-    return True
 
+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=0) -> bool:
-    import debugpy  # noqa: T100
+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
 
-    class T(threading.Thread):
-        daemon = True
-        def run(self):
-            time.sleep(timeout)
-            debugpy.wait_for_client.cancel()
-    T().start()
-    debugpy.wait_for_client()
-    if debugpy.is_client_connected():
-        return True
+    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
 
-    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 enable_debugpy(port: int, address = None) -> bool:
+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__)
 
-    import debugpy  # noqa: T100
 
-    if address is None:
-        address = "0.0.0.0"
+    if host_object is None:
+        self.log_alert("No host object found, cannot enable debugpy.")
+        return
 
-    debugpy.listen((address, port))
+    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}")

src/iop/cls/IOP/Common.cls

@@ -40,7 +40,9 @@ Method GetModule() As %String
 Method %OnNew(pConfigName As %String) As %Status
 {
     $$$ThrowOnError(..Connect())
-	Quit $method($this,"initConfig",.pConfigName) ; call subclass
+	$$$ThrowOnError($method($this,"initConfig",.pConfigName)) ; call subclass
+    do ..%class."_debugpy"($this)
+    Quit $$$OK
 }
 
 Method OnInit() As %Status

src/tests/bench/bench_bo.py

@@ -2,9 +2,6 @@
 
 class BenchIoPOperation(BusinessOperation):
 
-    def on_init(self):
-        self.log_info("BenchIoPOperation initialized")
-
     def on_message(self, request):
-
+        self.log_info("BenchIoPOperation received message")
         return request

src/tests/bench/bench_bp.py

@@ -1,4 +1,5 @@
 from iop import BusinessProcess
+import debugpy
 
 class BenchIoPProcess(BusinessProcess):
     def on_init(self):
@@ -8,5 +9,6 @@ def on_init(self):
             self.target = 'Python.BenchIoPOperation'
 
     def on_message(self, request):
+        debugpy.is_client_connected()
         for _ in range(self.size):
             _ = self.send_request_sync(self.target,request)