optimize and some refactoring in debugger

Author: d-biehl

robotcode/debugger/__main__.py

@@ -177,6 +177,7 @@ async def run_robot(
 
         exit_code = -1
         try:
+
             exit_code = robot.run_cli(args, False)
         finally:
             if server.protocol.connected:
@@ -200,8 +201,6 @@ async def run_robot(
     except asyncio.CancelledError:
         pass
     finally:
-        await run_coroutine_from_thread_async(server.protocol.wait_for_all_events_sended)
-
         if server.protocol.connected:
             await run_coroutine_from_thread_async(server.protocol.terminate, loop=server.loop)
             try:

robotcode/debugger/server.py

@@ -1,11 +1,11 @@
 import asyncio
 import os
-from typing import Any, List, Literal, Optional, Union
+from typing import Any, Literal, Optional, Union
 
 from ..jsonrpc2.protocol import rpc_method
 from ..jsonrpc2.server import JsonRPCServer, JsonRpcServerMode, TcpParams
 from ..utils import async_tools
-from ..utils.async_tools import run_coroutine_from_thread_as_future_async
+from ..utils.async_tools import run_coroutine_from_thread
 from ..utils.logging import LoggingDescriptor
 from .dap_types import (
     ConfigurationDoneArguments,
@@ -66,29 +66,12 @@ def __init__(self) -> None:
 
         self._received_configuration_done_event = async_tools.Event()
         self._received_configuration_done = False
-        self._sended_events: List[asyncio.Future[None]] = []
 
         Debugger.instance().send_event.add(self.on_debugger_send_event)
 
     def on_debugger_send_event(self, sender: Any, event: Event) -> None:
-        def remove_future(future: "asyncio.Future[None]") -> None:
-            self._sended_events.remove(future)
-
         if self._loop is not None:
-            future = run_coroutine_from_thread_as_future_async(self.send_event_async, event, loop=self._loop)
-            self._sended_events.append(future)
-            future.add_done_callback(remove_future)
-
-    async def wait_for_all_events_sended(self, timeout: float = 5) -> bool:
-        async def wait() -> bool:
-            while True:
-                if self._sended_events:
-                    await asyncio.sleep(0.01)
-                else:
-                    return True
-            return False
-
-        return await asyncio.wait_for(asyncio.create_task(wait()), timeout)
+            run_coroutine_from_thread(self.send_event_async, event, loop=self._loop)
 
     @property
     def connected(self) -> bool:

robotcode/utils/async_tools.py

@@ -739,7 +739,7 @@ def run_coroutine_from_thread(
     return result.cfuture.result()
 
 
-def run_coroutine_from_thread_as_future_async(
+def run_coroutine_from_thread_as_future(
     func: Callable[..., Coroutine[Any, Any, _T]],
     *args: Any,
     loop: Optional[asyncio.AbstractEventLoop] = None,
@@ -760,7 +760,7 @@ async def run_coroutine_from_thread_async(
     if loop is None:
         loop = asyncio.get_running_loop()
 
-    return await run_coroutine_from_thread_as_future_async(func, *args, loop=loop, **kwargs)
+    return await run_coroutine_from_thread_as_future(func, *args, loop=loop, **kwargs)
 
 
 def wrap_sub_future(