refactor(debugger): some code simplifications

Author: d-biehl

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

@@ -1,6 +1,3 @@
-from __future__ import annotations
-
-import asyncio
 import itertools
 import os
 import pathlib
@@ -157,7 +154,7 @@ def __init__(self, thread_id: Any) -> None:
 class StackFrameEntry:
     def __init__(
         self,
-        parent: Optional[StackFrameEntry],
+        parent: Optional["StackFrameEntry"],
         context: Any,
         name: str,
         type: str,
@@ -193,7 +190,7 @@ def __init__(
     def __repr__(self) -> str:
         return f"StackFrameEntry({self.name!r}, {self.type!r}, {self.source!r}, {self.line!r}, {self.column!r})"
 
-    def get_first_or_self(self) -> StackFrameEntry:
+    def get_first_or_self(self) -> "StackFrameEntry":
         if self.stack_frames:
             return self.stack_frames[0]
         return self
@@ -260,14 +257,14 @@ def end_keyword(self, data: running.Keyword, result: result.Keyword) -> None:
 
 
 class Debugger:
-    __instance: ClassVar[Optional[Debugger]] = None
+    __instance: ClassVar[Optional["Debugger"]] = None
     __lock: ClassVar = threading.RLock()
     __inside_instance: ClassVar = False
 
     _logger = LoggingDescriptor()
 
     @classmethod
-    def instance(cls) -> Debugger:
+    def instance(cls) -> "Debugger":
         if cls.__instance is not None:
             return cls.__instance
         with cls.__lock:
@@ -318,7 +315,6 @@ def __init__(self) -> None:
         self.terminated = False
         self.attached = False
         self.path_mappings: List[PathMapping] = []
-        self.server_loop: Optional[asyncio.AbstractEventLoop] = None
 
         self._keyword_to_evaluate: Optional[Callable[..., Any]] = None
         self._evaluated_keyword_result: Any = None
@@ -917,14 +913,12 @@ def end_suite(self, name: str, attributes: Dict[str, Any]) -> None:
             status = attributes.get("status", "")
 
             if status == "FAIL":
-                if self.server_loop:
-                    self.process_end_state(
-                        status,
-                        {"failed_suite"},
-                        "Suite failed.",
-                        f"Suite failed{f': {v}' if (v := attributes.get('message')) else ''}",
-                    )
-
+                self.process_end_state(
+                    status,
+                    {"failed_suite"},
+                    "Suite failed.",
+                    f"Suite failed{f': {v}' if (v := attributes.get('message')) else ''}",
+                )
                 self.wait_for_running()
 
         source = attributes.get("source")

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

@@ -12,6 +12,7 @@
     List,
     Mapping,
     Optional,
+    Set,
     Tuple,
     Type,
     TypeVar,
@@ -81,6 +82,7 @@ def __init__(self) -> None:
         self._received_request_lock = threading.RLock()
         self._received_request: OrderedDict[int, asyncio.Future[Any]] = OrderedDict()
         self._initialized = False
+        self._running_handle_message_tasks: Set[asyncio.Future[Any]] = set()
 
     @_logger.call
     def send_message(self, message: ProtocolMessage) -> None:
@@ -140,14 +142,10 @@ def _handle_body(self, body: bytes, charset: str) -> None:
             )
 
     def _handle_messages(self, iterator: Iterator[ProtocolMessage]) -> 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)
-
         for m in iterator:
             task = asyncio.create_task(self.handle_message(m), name="handle_message")
-            task.add_done_callback(done)
+            self._running_handle_message_tasks.add(task)
+            task.add_done_callback(self._running_handle_message_tasks.discard)
 
     @_logger.call
     async def handle_message(self, message: ProtocolMessage) -> None:

packages/debugger/src/robotcode/debugger/run.py

@@ -230,7 +230,6 @@ def run_debugger(
         Debugger.instance().colored_output = app.colored
         Debugger.instance().debug = debug
         Debugger.instance().set_main_thread(threading.current_thread())
-        Debugger.instance().server_loop = server.loop
 
         app.verbose("Start the debugger instance")
         Debugger.instance().start()
@@ -267,7 +266,7 @@ def run_debugger(
             server.protocol.terminate()
 
             if not server.protocol.wait_for_disconnected():
-                app.warning("Timeout to get disconnected from client")
+                app.verbose("Timeout to get disconnected from client")
 
         server.loop.stop()