robotcode-debugger 0.105.0__tar.gz → 0.106.0__tar.gz

{robotcode_debugger-0.105.0 → robotcode_debugger-0.106.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotcode-debugger
-Version: 0.105.0
+Version: 0.106.0
 Summary: RobotCode Debugger for Robot Framework
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://opencollective.com/robotcode
@@ -25,8 +25,8 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.8
-Requires-Dist: robotcode-jsonrpc2==0.105.0
-Requires-Dist: robotcode-runner==0.105.0
+Requires-Dist: robotcode-jsonrpc2==0.106.0
+Requires-Dist: robotcode-runner==0.106.0
 Requires-Dist: robotframework>=4.1.0
 Provides-Extra: debugpy
 Requires-Dist: debugpy; extra == 'debugpy'

{robotcode_debugger-0.105.0 → robotcode_debugger-0.106.0}/pyproject.toml

@@ -28,8 +28,8 @@ classifiers = [
 dynamic = ["version"]
 dependencies = [
   "robotframework>=4.1.0",
-  "robotcode-jsonrpc2==0.105.0",
-  "robotcode-runner==0.105.0",
+  "robotcode-jsonrpc2==0.106.0",
+  "robotcode-runner==0.106.0",
 ]
 
 [project.optional-dependencies]

robotcode_debugger-0.106.0/src/robotcode/debugger/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.106.0"

{robotcode_debugger-0.105.0 → robotcode_debugger-0.106.0}/src/robotcode/debugger/dap_types.py

@@ -523,6 +523,9 @@ class SourceBreakpoint(Model):
     hit_condition: Optional[str] = None
     log_message: Optional[str] = None
 
+    def __hash__(self) -> int:
+        return hash((self.line, self.column, self.condition, self.hit_condition, self.log_message))
+
 
 @dataclass
 class SetBreakpointsArguments(Model):

{robotcode_debugger-0.105.0 → robotcode_debugger-0.106.0}/src/robotcode/debugger/debugger.py

@@ -8,6 +8,7 @@ import time
 import weakref
 from collections import deque
 from enum import Enum
+from functools import cached_property
 from pathlib import Path, PurePath
 from typing import (
     Any,
@@ -25,6 +26,7 @@ from typing import (
     Sequence,
     Set,
     Tuple,
+    TypedDict,
     Union,
     cast,
 )
@@ -67,6 +69,7 @@ from .dap_types import (
     Variable,
     VariablePresentationHint,
 )
+from .id_manager import IdManager
 
 if get_robot_version() >= (7, 0):
     from robot.running import UserKeyword as UserKeywordHandler
@@ -163,6 +166,10 @@ class InvalidThreadIdError(Exception):
         super().__init__(f"Invalid thread id {thread_id}")
 
 
+class MarkerObject:
+    pass
+
+
 class StackFrameEntry:
     def __init__(
         self,
@@ -193,10 +200,10 @@ class StackFrameEntry:
         self.libname = libname
         self.kwname = kwname
         self.longname = longname
-        self._suite_marker = object()
-        self._test_marker = object()
-        self._local_marker = object()
-        self._global_marker = object()
+        self._suite_marker = MarkerObject()
+        self._test_marker = MarkerObject()
+        self._local_marker = MarkerObject()
+        self._global_marker = MarkerObject()
         self.stack_frames: Deque[StackFrameEntry] = deque()
 
     def __repr__(self) -> str:
@@ -207,21 +214,27 @@ class StackFrameEntry:
             return self.stack_frames[0]
         return self
 
-    @property
+    _id_manager = IdManager()
+
+    @cached_property
     def id(self) -> int:
-        return id(self)
+        return self._id_manager.get_id(self)
 
+    @cached_property
     def test_id(self) -> int:
-        return id(self._test_marker)
+        return self._id_manager.get_id(self._test_marker)
 
+    @cached_property
     def suite_id(self) -> int:
-        return id(self._suite_marker)
+        return self._id_manager.get_id(self._suite_marker)
 
+    @cached_property
     def local_id(self) -> int:
-        return id(self._local_marker)
+        return self._id_manager.get_id(self._local_marker)
 
+    @cached_property
     def global_id(self) -> int:
-        return id(self._global_marker)
+        return self._id_manager.get_id(self._global_marker)
 
 
 class HitCountEntry(NamedTuple):
@@ -268,6 +281,15 @@ else:
             self.steps.pop()
 
 
+breakpoint_id_manager = IdManager()
+
+
+class ExceptionInformation(TypedDict):
+    text: Optional[str]
+    description: str
+    status: str
+
+
 class Debugger:
     __instance: ClassVar[Optional["Debugger"]] = None
     __lock: ClassVar = threading.RLock()
@@ -341,6 +363,7 @@ class Debugger:
         self._evaluate_cache: List[Any] = []
         self._variables_cache: Dict[int, Any] = {}
         self._variables_object_cache: List[Any] = []
+        self._current_exception: Optional[ExceptionInformation] = None
 
     @property
     def state(self) -> State:
@@ -432,7 +455,8 @@ class Debugger:
             self.condition.notify_all()
 
     def pause_thread(self, thread_id: int) -> None:
-        if self.main_thread is None or thread_id != self.main_thread.ident:
+        # thread_id 0 means all threads
+        if self.main_thread is None or (thread_id != 0 and thread_id != self.main_thread.ident):
             raise InvalidThreadIdError(thread_id)
 
         with self.condition:
@@ -521,6 +545,7 @@ class Debugger:
         lines: Optional[List[int]] = None,
         source_modified: Optional[bool] = None,
     ) -> List[Breakpoint]:
+
         if self.is_windows_path(source.path or ""):
             path: pathlib.PurePath = pathlib.PureWindowsPath(source.path or "")
         else:
@@ -535,7 +560,7 @@ class Debugger:
             )
             return [
                 Breakpoint(
-                    id=id(v),
+                    id=breakpoint_id_manager.get_id(v),
                     source=Source(path=str(path)),
                     verified=True,
                     line=v.line,
@@ -559,6 +584,7 @@ class Debugger:
                 self,
                 StoppedEvent(
                     body=StoppedEventBody(
+                        description="Paused",
                         reason=StoppedReason.PAUSE,
                         thread_id=threading.current_thread().ident,
                     )
@@ -574,6 +600,7 @@ class Debugger:
                     self,
                     StoppedEvent(
                         body=StoppedEventBody(
+                            description="Next step",
                             reason=StoppedReason.STEP,
                             thread_id=threading.current_thread().ident,
                         )
@@ -588,6 +615,7 @@ class Debugger:
                 self,
                 StoppedEvent(
                     body=StoppedEventBody(
+                        description="Step in",
                         reason=StoppedReason.STEP,
                         thread_id=threading.current_thread().ident,
                     )
@@ -602,6 +630,7 @@ class Debugger:
                 self,
                 StoppedEvent(
                     body=StoppedEventBody(
+                        description="Step out",
                         reason=StoppedReason.STEP,
                         thread_id=threading.current_thread().ident,
                     )
@@ -613,6 +642,7 @@ class Debugger:
             if source_path in self.breakpoints:
                 breakpoints = [v for v in self.breakpoints[source_path].breakpoints if v.line == line_no]
                 if len(breakpoints) > 0:
+
                     for point in breakpoints:
                         if point.condition is not None:
                             hit = False
@@ -673,9 +703,10 @@ class Debugger:
                             self,
                             StoppedEvent(
                                 body=StoppedEventBody(
+                                    description="Breakpoint hit",
                                     reason=StoppedReason.BREAKPOINT,
                                     thread_id=threading.current_thread().ident,
-                                    hit_breakpoint_ids=[id(v) for v in breakpoints],
+                                    hit_breakpoint_ids=[breakpoint_id_manager.get_id(v) for v in breakpoints],
                                 )
                             ),
                         )
@@ -704,6 +735,8 @@ class Debugger:
             self.requested_state = RequestedState.Nothing
             self.state = State.Paused
 
+            self._current_exception = {"text": text, "description": description, "status": status}
+
             self.send_event(
                 self,
                 StoppedEvent(
@@ -757,6 +790,7 @@ class Debugger:
                     continue
 
                 break
+            self._current_exception = None
 
     def start_output_group(self, name: str, attributes: Dict[str, Any], type: Optional[str] = None) -> None:
         if self.group_output:
@@ -971,7 +1005,7 @@ class Debugger:
             if status == "FAIL":
                 self.process_end_state(
                     status,
-                    {"failed_test"},
+                    {""},
                     "Test failed.",
                     f"Test failed{f': {v}' if (v := attributes.get('message')) else ''}",
                 )
@@ -1136,7 +1170,7 @@ class Debugger:
                             {"uncaught_failed_keyword"}
                             if self.is_not_caughted_by_keyword()
                             and self.is_not_caugthed_by_except(self.last_fail_message)
-                            else {}
+                            else []
                         ),
                     },
                     "Keyword failed.",
@@ -1346,7 +1380,7 @@ class Debugger:
                         name="Local",
                         expensive=False,
                         presentation_hint="local",
-                        variables_reference=entry.local_id(),
+                        variables_reference=entry.local_id,
                     )
                 )
                 if context.variables._test is not None and entry.type == "KEYWORD":
@@ -1355,7 +1389,7 @@ class Debugger:
                             name="Test",
                             expensive=False,
                             presentation_hint="test",
-                            variables_reference=entry.test_id(),
+                            variables_reference=entry.test_id,
                         )
                     )
                 if context.variables._suite is not None and entry.type in [
@@ -1367,7 +1401,7 @@ class Debugger:
                             name="Suite",
                             expensive=False,
                             presentation_hint="suite",
-                            variables_reference=entry.suite_id(),
+                            variables_reference=entry.suite_id,
                         )
                     )
                 if context.variables._global is not None:
@@ -1376,20 +1410,24 @@ class Debugger:
                             name="Global",
                             expensive=False,
                             presentation_hint="global",
-                            variables_reference=entry.global_id(),
+                            variables_reference=entry.global_id,
                         )
                     )
 
         return result
 
+    _cache_id_manager = IdManager()
+
     def _new_cache_id(self) -> int:
-        o = object()
+        o = MarkerObject()
         self._variables_object_cache.append(o)
-        return id(o)
+        return StackFrameEntry._id_manager.get_id(o)
 
     debug_repr = DebugRepr()
 
-    def _create_variable(self, name: str, value: Any) -> Variable:
+    def _create_variable(
+        self, name: str, value: Any, presentation_hint: Optional[VariablePresentationHint] = None
+    ) -> Variable:
         if isinstance(value, Mapping):
             v_id = self._new_cache_id()
             self._variables_cache[v_id] = value
@@ -1400,7 +1438,9 @@ class Debugger:
                 variables_reference=v_id,
                 named_variables=len(value) + 1,
                 indexed_variables=0,
-                presentation_hint=VariablePresentationHint(kind="data"),
+                presentation_hint=(
+                    presentation_hint if presentation_hint is not None else VariablePresentationHint(kind="data")
+                ),
             )
 
         if isinstance(value, Sequence) and not isinstance(value, str):
@@ -1443,18 +1483,18 @@ class Debugger:
                 (
                     v
                     for v in self.stack_frames
-                    if variables_reference in [v.global_id(), v.suite_id(), v.test_id(), v.local_id()]
+                    if variables_reference in [v.global_id, v.suite_id, v.test_id, v.local_id]
                 ),
                 None,
             )
             if entry is not None:
                 context = entry.context()
                 if context is not None:
-                    if entry.global_id() == variables_reference:
+                    if entry.global_id == variables_reference:
                         result.update(
                             {k: self._create_variable(k, v) for k, v in context.variables._global.as_dict().items()}
                         )
-                    elif entry.suite_id() == variables_reference:
+                    elif entry.suite_id == variables_reference:
                         globals = context.variables._global.as_dict()
                         vars = entry.get_first_or_self().variables()
                         vars_dict = vars.as_dict() if vars is not None else {}
@@ -1465,7 +1505,7 @@ class Debugger:
                                 if (k not in globals or globals[k] != v) and (k in vars_dict)
                             }
                         )
-                    elif entry.test_id() == variables_reference:
+                    elif entry.test_id == variables_reference:
                         globals = context.variables._suite.as_dict()
                         vars = entry.get_first_or_self().variables()
                         vars_dict = vars.as_dict() if vars is not None else {}
@@ -1476,8 +1516,16 @@ class Debugger:
                                 if (k not in globals or globals[k] != v) and (k in vars_dict)
                             }
                         )
-                    elif entry.local_id() == variables_reference:
+                    elif entry.local_id == variables_reference:
                         vars = entry.get_first_or_self().variables()
+
+                        if self._current_exception is not None:
+                            result["${EXCEPTION}"] = self._create_variable(
+                                "${EXCEPTION}",
+                                self._current_exception,
+                                VariablePresentationHint(kind="virtual"),
+                            )
+
                         if vars is not None:
                             p = entry.parent() if entry.parent else None
 
@@ -1821,7 +1869,7 @@ class Debugger:
             (
                 v
                 for v in self.full_stack_frames
-                if variables_reference in [v.global_id(), v.local_id(), v.suite_id(), v.test_id()]
+                if variables_reference in [v.global_id, v.local_id, v.suite_id, v.test_id]
             ),
             None,
         )
@@ -1856,7 +1904,7 @@ class Debugger:
                 if option.filter_id in [
                     "failed_keyword",
                     "uncaught_failed_keyword",
-                    "failed_test",
+                    "",
                     "failed_suite",
                 ]:
                     entry = ExceptionBreakpointsEntry(

robotcode_debugger-0.106.0/src/robotcode/debugger/default_capabilities.py

@@ -0,0 +1,48 @@
+from .dap_types import Capabilities, ExceptionBreakpointsFilter
+
+DFEAULT_CAPABILITIES = Capabilities(
+    supports_configuration_done_request=True,
+    supports_conditional_breakpoints=True,
+    supports_hit_conditional_breakpoints=True,
+    support_terminate_debuggee=True,
+    supports_evaluate_for_hovers=True,
+    supports_terminate_request=True,
+    supports_log_points=True,
+    supports_set_expression=True,
+    supports_set_variable=True,
+    supports_value_formatting_options=True,
+    exception_breakpoint_filters=[
+        ExceptionBreakpointsFilter(
+            filter="failed_keyword",
+            label="Failed Keywords",
+            description="Breaks on failed keywords",
+            default=False,
+            supports_condition=True,
+        ),
+        ExceptionBreakpointsFilter(
+            filter="uncaught_failed_keyword",
+            label="Uncaught Failed Keywords",
+            description="Breaks on uncaught failed keywords",
+            default=True,
+            supports_condition=True,
+        ),
+        ExceptionBreakpointsFilter(
+            filter="failed_test",
+            label="Failed Test",
+            description="Breaks on failed tests",
+            default=False,
+            supports_condition=True,
+        ),
+        ExceptionBreakpointsFilter(
+            filter="failed_suite",
+            label="Failed Suite",
+            description="Breaks on failed suite",
+            default=False,
+            supports_condition=True,
+        ),
+    ],
+    supports_exception_options=True,
+    supports_exception_filter_options=True,
+    supports_completions_request=True,
+    supports_a_n_s_i_styling=True,
+)

robotcode_debugger-0.106.0/src/robotcode/debugger/id_manager.py

@@ -0,0 +1,64 @@
+import weakref
+from collections import deque
+from typing import Any, Deque, Dict, Optional
+
+
+class IdManager:
+    def __init__(self) -> None:
+        self.max_id: int = 2**31 - 1
+        self.next_id: int = 0
+
+        self.released_ids: Deque[int] = deque()
+        self.object_to_id: weakref.WeakKeyDictionary[Any, int] = weakref.WeakKeyDictionary()
+        self.id_to_object: weakref.WeakValueDictionary[int, Any] = weakref.WeakValueDictionary()
+        self._finalizers: Dict[int, weakref.ref[Any]] = {}
+
+    def get_id(self, obj: Any) -> int:
+        if obj in self.object_to_id:
+            return self.object_to_id[obj]
+
+        if self.released_ids:
+            obj_id: int = self.released_ids.popleft()
+        else:
+            if self.next_id > self.max_id:
+                raise RuntimeError("Keine IDs mehr verfügbar!")
+            obj_id = self.next_id
+            self.next_id += 1
+
+        self.object_to_id[obj] = obj_id
+        self.id_to_object[obj_id] = obj
+
+        def _on_object_gc(ref: "weakref.ReferenceType[Any]", id_: int = obj_id) -> None:
+            self.release_id(id_)
+
+        ref = weakref.ref(obj, _on_object_gc)
+        self._finalizers[obj_id] = ref
+
+        return obj_id
+
+    def release_id(self, obj_id: int) -> None:
+        if obj_id in self.id_to_object:
+            del self.id_to_object[obj_id]
+
+        if obj_id in self._finalizers:
+            del self._finalizers[obj_id]
+
+        self.released_ids.append(obj_id)
+
+    def release_obj(self, obj: Any) -> None:
+        if obj in self.object_to_id:
+            obj_id: int = self.object_to_id.pop(obj)
+
+            if obj_id in self.id_to_object:
+                del self.id_to_object[obj_id]
+
+            if obj_id in self._finalizers:
+                del self._finalizers[obj_id]
+
+            self.released_ids.append(obj_id)
+
+    def get_object(self, obj_id: int) -> Optional[Any]:
+        return self.id_to_object.get(obj_id)
+
+    def get_id_from_obj(self, obj: Any) -> Optional[int]:
+        return self.object_to_id.get(obj)

{robotcode_debugger-0.105.0 → robotcode_debugger-0.106.0}/src/robotcode/debugger/launcher/server.py

@@ -23,7 +23,6 @@ from ..dap_types import (
     DisconnectArguments,
     DisconnectRequest,
     Event,
-    ExceptionBreakpointsFilter,
     InitializeRequest,
     InitializeRequestArguments,
     LaunchRequestArguments,
@@ -39,6 +38,7 @@ from ..dap_types import (
     TerminatedEvent,
     TerminateRequest,
 )
+from ..default_capabilities import DFEAULT_CAPABILITIES
 from ..protocol import DebugAdapterProtocol
 from .client import DAPClient, DAPClientError
 
@@ -91,49 +91,7 @@ class LauncherDebugAdapterProtocol(DebugAdapterProtocol):
 
         self._initialized = True
 
-        return Capabilities(
-            supports_configuration_done_request=True,
-            supports_conditional_breakpoints=True,
-            supports_hit_conditional_breakpoints=True,
-            support_terminate_debuggee=True,
-            # support_suspend_debuggee=True,
-            supports_evaluate_for_hovers=True,
-            supports_terminate_request=True,
-            supports_log_points=True,
-            supports_set_expression=True,
-            supports_set_variable=True,
-            supports_value_formatting_options=True,
-            exception_breakpoint_filters=[
-                ExceptionBreakpointsFilter(
-                    filter="failed_keyword",
-                    label="Failed Keywords",
-                    description="Breaks on failed keywords",
-                    default=False,
-                ),
-                ExceptionBreakpointsFilter(
-                    filter="uncaught_failed_keyword",
-                    label="Uncaught Failed Keywords",
-                    description="Breaks on uncaught failed keywords",
-                    default=True,
-                ),
-                ExceptionBreakpointsFilter(
-                    filter="failed_test",
-                    label="Failed Test",
-                    description="Breaks on failed tests",
-                    default=False,
-                ),
-                ExceptionBreakpointsFilter(
-                    filter="failed_suite",
-                    label="Failed Suite",
-                    description="Breaks on failed suite",
-                    default=False,
-                ),
-            ],
-            supports_exception_options=True,
-            supports_exception_filter_options=True,
-            supports_completions_request=True,
-            supports_a_n_s_i_styling=True,
-        )
+        return DFEAULT_CAPABILITIES
 
     @rpc_method(name="launch", param_type=LaunchRequestArguments)
     async def _launch(

{robotcode_debugger-0.105.0 → robotcode_debugger-0.106.0}/src/robotcode/debugger/listeners.py

@@ -16,6 +16,8 @@ from .debugger import Debugger
 class RobotExecutionEventBody(Model):
     type: str
     id: str
+    name: str
+    parent_id: Optional[str] = None
     attributes: Optional[Dict[str, Any]] = None
     failed_keywords: Optional[List[Dict[str, Any]]] = None
 
@@ -34,15 +36,19 @@ class ListenerV2:
     def __init__(self) -> None:
         self.failed_keywords: Optional[List[Dict[str, Any]]] = None
         self.last_fail_message: Optional[str] = None
+        self.suite_id_stack: List[str] = []
 
     def start_suite(self, name: str, attributes: Dict[str, Any]) -> None:
+        id = f"{source_from_attributes(attributes)};{attributes.get('longname', '')}"
         Debugger.instance().send_event(
             self,
             Event(
                 event="robotStarted",
                 body=RobotExecutionEventBody(
                     type="suite",
-                    id=f"{source_from_attributes(attributes)};{attributes.get('longname', '')}",
+                    name=name,
+                    id=id,
+                    parent_id=self.suite_id_stack[-1] if self.suite_id_stack else None,
                     attributes=dict(attributes),
                 ),
             ),
@@ -51,8 +57,10 @@ class ListenerV2:
         Debugger.instance().start_output_group(name, attributes, "SUITE")
 
         Debugger.instance().start_suite(name, attributes)
+        self.suite_id_stack.append(id)
 
     def end_suite(self, name: str, attributes: Dict[str, Any]) -> None:
+        id = f"{source_from_attributes(attributes)};{attributes.get('longname', '')}"
         Debugger.instance().end_suite(name, attributes)
 
         Debugger.instance().end_output_group(name, attributes, "SUITE")
@@ -63,13 +71,15 @@ class ListenerV2:
                 event="robotEnded",
                 body=RobotExecutionEventBody(
                     type="suite",
+                    name=name,
                     attributes=dict(attributes),
-                    id=f"{source_from_attributes(attributes)};{attributes.get('longname', '')}",
+                    id=id,
+                    parent_id=self.suite_id_stack[-1] if self.suite_id_stack else None,
                     failed_keywords=self.failed_keywords,
                 ),
             ),
         )
-
+        self.suite_id_stack.pop()
         self.failed_keywords = None
 
     def start_test(self, name: str, attributes: Dict[str, Any]) -> None:
@@ -81,8 +91,10 @@ class ListenerV2:
                 event="robotStarted",
                 body=RobotExecutionEventBody(
                     type="test",
+                    name=name,
                     id=f"{source_from_attributes(attributes)};{attributes.get('longname', '')};"
                     f"{attributes.get('lineno', 0)}",
+                    parent_id=self.suite_id_stack[-1] if self.suite_id_stack else None,
                     attributes=dict(attributes),
                 ),
             ),
@@ -103,8 +115,10 @@ class ListenerV2:
                 event="robotEnded",
                 body=RobotExecutionEventBody(
                     type="test",
+                    name=name,
                     id=f"{source_from_attributes(attributes)};{attributes.get('longname', '')};"
                     f"{attributes.get('lineno', 0)}",
+                    parent_id=self.suite_id_stack[-1] if self.suite_id_stack else None,
                     attributes=dict(attributes),
                     failed_keywords=self.failed_keywords,
                 ),
@@ -308,6 +322,7 @@ class ListenerV3:
                         event="robotSetFailed",
                         body=RobotExecutionEventBody(
                             type="test",
+                            name=result_item.name,
                             attributes={
                                 "longname": result_item.longname,
                                 "status": str(result_item.status),
@@ -325,6 +340,7 @@ class ListenerV3:
                         ),
                     ),
                 )
+
             if isinstance(result_item, result.TestSuite):
                 for r in result_item.suites:
                     p = next((i for i in data_item.suites if i.id == r.id), None) if data_item else None

{robotcode_debugger-0.105.0 → robotcode_debugger-0.106.0}/src/robotcode/debugger/server.py

@@ -23,7 +23,6 @@ from .dap_types import (
     EvaluateArguments,
     EvaluateResponseBody,
     Event,
-    ExceptionBreakpointsFilter,
     ExitedEvent,
     ExitedEventBody,
     InitializedEvent,
@@ -50,6 +49,7 @@ from .dap_types import (
     VariablesResponseBody,
 )
 from .debugger import Debugger, PathMapping
+from .default_capabilities import DFEAULT_CAPABILITIES
 from .protocol import DebugAdapterProtocol
 
 TCP_DEFAULT_PORT = 6612
@@ -132,7 +132,7 @@ class DebugAdapterServerProtocol(DebugAdapterProtocol):
         return self._initialized
 
     @_logger.call
-    def wait_for_disconnected(self, timeout: float = 15) -> bool:
+    def wait_for_disconnected(self, timeout: float = 1) -> bool:
         self._disconnected_event.wait(timeout)
 
         return not self._connected
@@ -144,49 +144,7 @@ class DebugAdapterServerProtocol(DebugAdapterProtocol):
         if self.loop is not None:
             self.loop.call_soon(self.initialized)
 
-        return Capabilities(
-            supports_configuration_done_request=True,
-            supports_conditional_breakpoints=True,
-            supports_hit_conditional_breakpoints=True,
-            support_terminate_debuggee=True,
-            # support_suspend_debuggee=True,
-            supports_evaluate_for_hovers=True,
-            supports_terminate_request=True,
-            supports_log_points=True,
-            supports_set_expression=True,
-            supports_set_variable=True,
-            supports_value_formatting_options=True,
-            exception_breakpoint_filters=[
-                ExceptionBreakpointsFilter(
-                    filter="failed_keyword",
-                    label="Failed Keywords",
-                    description="Breaks on failed keywords",
-                    default=False,
-                ),
-                ExceptionBreakpointsFilter(
-                    filter="uncaught_failed_keyword",
-                    label="Uncaught Failed Keywords",
-                    description="Breaks on uncaught failed keywords",
-                    default=True,
-                ),
-                ExceptionBreakpointsFilter(
-                    filter="failed_test",
-                    label="Failed Test",
-                    description="Breaks on failed tests",
-                    default=False,
-                ),
-                ExceptionBreakpointsFilter(
-                    filter="failed_suite",
-                    label="Failed Suite",
-                    description="Breaks on failed suite",
-                    default=False,
-                ),
-            ],
-            supports_exception_options=True,
-            supports_exception_filter_options=True,
-            supports_completions_request=True,
-            supports_a_n_s_i_styling=True,
-        )
+        return DFEAULT_CAPABILITIES
 
     @rpc_method(name="attach", param_type=AttachRequestArguments)
     async def _attach(

robotcode_debugger-0.105.0/src/robotcode/debugger/__version__.py

@@ -1 +0,0 @@
-__version__ = "0.105.0"