fix(debugger): rework async code in debugger and some other little quitrks in debugger, like hiding the debugger thread when debuggin python code

closes #242

Author: d-biehl

packages/core/src/robotcode/core/concurrent.py

@@ -217,7 +217,9 @@ def _remove_future_from_running_tasks(future: Task[Any]) -> None:
 _P = ParamSpec("_P")
 
 
-def run_as_task(callable: Callable[_P, _TResult], *args: _P.args, **kwargs: _P.kwargs) -> Task[_TResult]:
+def _create_task_in_thread(
+    callable: Callable[_P, _TResult], *args: _P.args, **kwargs: _P.kwargs
+) -> Tuple[Task[_TResult], threading.Thread]:
     future: Task[_TResult] = Task()
     with _running_tasks_lock:
         thread = threading.Thread(
@@ -227,8 +229,26 @@ def run_as_task(callable: Callable[_P, _TResult], *args: _P.args, **kwargs: _P.k
         )
         _running_tasks[future] = thread
         future.add_done_callback(_remove_future_from_running_tasks)
+
     # TODO: don't set daemon=True because it can be deprecated in future pyhton versions
     thread.daemon = True
+    return future, thread
+
+
+def run_as_task(callable: Callable[_P, _TResult], *args: _P.args, **kwargs: _P.kwargs) -> Task[_TResult]:
+    future, thread = _create_task_in_thread(callable, *args, **kwargs)
+
+    thread.start()
+
+    return future
+
+
+def run_as_debugpy_hidden_task(callable: Callable[_P, _TResult], *args: _P.args, **kwargs: _P.kwargs) -> Task[_TResult]:
+    future, thread = _create_task_in_thread(callable, *args, **kwargs)
+
+    thread.pydev_do_not_trace = True  # type: ignore[attr-defined]
+    thread.is_pydev_daemon_thread = True  # type: ignore[attr-defined]
+
     thread.start()
 
     return future

packages/core/src/robotcode/core/utils/debugpy.py

@@ -1,5 +1,8 @@
+import threading
 from typing import Optional, Sequence, Tuple, Union
 
+from robotcode.core.concurrent import run_as_debugpy_hidden_task
+
 from .logging import LoggingDescriptor
 from .net import find_free_port
 
@@ -15,14 +18,25 @@ def is_debugpy_installed() -> bool:
     return True
 
 
-def wait_for_debugpy_connected() -> bool:
+def wait_for_debugpy_connected(timeout: float = 30) -> bool:
     if is_debugpy_installed():
         import debugpy  # noqa: T100
 
+        connected = threading.Event()
         _logger.info("wait for debugpy client")
+
+        def _wait_for_client() -> bool:
+            if not connected.wait(timeout=timeout):
+                debugpy.wait_for_client.cancel()
+                return False
+
+            return True
+
+        wait_task = run_as_debugpy_hidden_task(_wait_for_client)
         debugpy.wait_for_client()  # noqa: T100
+        connected.set()
+        return wait_task.result()
 
-        return True
     return False
 
 

packages/debugger/src/robotcode/debugger/cli.py

@@ -1,4 +1,3 @@
-import asyncio
 from typing import Optional, Sequence, Tuple
 
 import click
@@ -22,7 +21,8 @@
     add_help_option=True,
 )
 @click.option(
-    "--debug / --no-debug",
+    "--debug/--no-debug",
+    is_flag=True,
     default=True,
     help="Enable/disable debug mode",
     show_default=True,
@@ -34,7 +34,7 @@
     show_default=True,
 )
 @click.option(
-    "--wait-for-client / --no-wait-for-client",
+    "--wait-for-client/--no-wait-for-client",
     is_flag=True,
     default=True,
     help="Waits until a debug client is connected.",
@@ -55,14 +55,14 @@
     show_default=True,
 )
 @click.option(
-    "--debugpy / --no-debugpy",
+    "--debugpy/--no-debugpy",
     is_flag=True,
     default=False,
     help="Enable/disable python debugging.",
     show_default=True,
 )
 @click.option(
-    "--debugpy-wait-for-client",
+    "--debugpy-wait-for-client/--no-debugpy-wait-for-client",
     is_flag=True,
     default=True,
     help="Waits for a debugpy client to connect.",
@@ -170,28 +170,26 @@ def debug(
 
     try:
         app.exit(
-            asyncio.run(
-                run_debugger(
-                    ctx=ctx,
-                    app=app,
-                    args=list(robot_options_and_args),
-                    mode=mode,
-                    addresses=bind,
-                    port=port if port is not None else DEBUGGER_DEFAULT_PORT,
-                    pipe_name=pipe_name,
-                    debug=debug,
-                    stop_on_entry=stop_on_entry,
-                    wait_for_client=wait_for_client,
-                    wait_for_client_timeout=wait_for_client_timeout,
-                    configuration_done_timeout=configuration_done_timeout,
-                    debugpy=debugpy,
-                    debugpy_wait_for_client=debugpy_wait_for_client,
-                    debugpy_port=debugpy_port,
-                    output_messages=output_messages,
-                    output_log=output_log,
-                    output_timestamps=output_timestamps,
-                    group_output=group_output,
-                )
+            run_debugger(
+                ctx=ctx,
+                app=app,
+                args=list(robot_options_and_args),
+                mode=mode,
+                addresses=bind,
+                port=port if port is not None else DEBUGGER_DEFAULT_PORT,
+                pipe_name=pipe_name,
+                debug=debug,
+                stop_on_entry=stop_on_entry,
+                wait_for_client=wait_for_client,
+                wait_for_client_timeout=wait_for_client_timeout,
+                configuration_done_timeout=configuration_done_timeout,
+                debugpy=debugpy,
+                debugpy_wait_for_client=debugpy_wait_for_client,
+                debugpy_port=debugpy_port,
+                output_messages=output_messages,
+                output_log=output_log,
+                output_timestamps=output_timestamps,
+                group_output=group_output,
             )
         )
 

packages/debugger/src/robotcode/debugger/protocol.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 import asyncio
 import inspect
 import json
@@ -142,7 +140,7 @@ def _handle_body(self, body: bytes, charset: str) -> None:
             )
 
     def _handle_messages(self, iterator: Iterator[ProtocolMessage]) -> None:
-        def done(f: asyncio.Future[Any]) -> None:
+        def done(f: "asyncio.Future[Any]") -> None:
             ex = f.exception()
             if ex is not None and not isinstance(ex, asyncio.CancelledError):
                 self._logger.exception(ex, exc_info=ex)
@@ -249,15 +247,14 @@ def handle_request(self, message: Request) -> None:
 
             self._received_request[message.seq] = result
 
-        def done(t: asyncio.Task[Any]) -> None:
+        def done(t: "asyncio.Task[Any]") -> None:
             try:
                 self.send_response(message.seq, message.command, t.result())
             except asyncio.CancelledError:
                 self._logger.debug(lambda: f"request message {message!r} canceled")
             except (SystemExit, KeyboardInterrupt):
                 raise
             except DebugAdapterRPCErrorException as ex:
-                self._logger.exception(ex)
                 self.send_error(
                     message=ex.message,
                     request_seq=message.seq,
@@ -321,7 +318,7 @@ def send_request(self, request: Request, return_type: Optional[Type[TResult]] =
     @_logger.call
     def send_request_async(
         self, request: Request, return_type: Optional[Type[TResult]] = None
-    ) -> asyncio.Future[TResult]:
+    ) -> "asyncio.Future[TResult]":
         return asyncio.wrap_future(self.send_request(request, return_type))
 
     @_logger.call