robotcode-debugger 2.3.1__tar.gz → 2.5.0__tar.gz

{robotcode_debugger-2.3.1 → robotcode_debugger-2.5.0}/.gitignore

@@ -334,4 +334,8 @@ bundled/libs
 results/
 
 # kilocode
-.kilocode/
+.kilocode/
+
+# .agents
+.agents/
+skills-lock.json

{robotcode_debugger-2.3.1 → robotcode_debugger-2.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotcode-debugger
-Version: 2.3.1
+Version: 2.5.0
 Summary: RobotCode Debugger for Robot Framework
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://opencollective.com/robotcode

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

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

{robotcode_debugger-2.3.1 → robotcode_debugger-2.5.0}/src/robotcode/debugger/debugger.py

@@ -36,11 +36,13 @@ from robot.api.parsing import get_model
 from robot.errors import VariableError
 from robot.output import LOGGER
 from robot.running import EXECUTION_CONTEXTS, Keyword, TestCase, TestSuite
+from robot.running.model import Try
+from robot.utils import Matcher as RobotMatcher
 from robot.variables import evaluate_expression
 
 from robotcode.core.event import event
 from robotcode.core.utils.logging import LoggingDescriptor
-from robotcode.robot.utils import get_robot_version
+from robotcode.robot.utils import RF_VERSION
 
 from .dap_types import (
     Breakpoint,
@@ -72,16 +74,12 @@ from .dap_types import (
 )
 from .id_manager import IdManager
 
-if get_robot_version() >= (5, 0):
-    from robot.running.model import Try
-    from robot.utils import Matcher as RobotMatcher
-
-if get_robot_version() >= (7, 0):
+if RF_VERSION >= (7, 0):
     from robot.running import UserKeyword as UserKeywordHandler
 else:
     from robot.running.userkeyword import UserKeywordHandler
 
-if get_robot_version() >= (6, 1):
+if RF_VERSION >= (6, 1):
 
     def internal_evaluate_expression(expression: str, variable_store: Any) -> Any:
         return evaluate_expression(expression, variable_store)
@@ -303,7 +301,7 @@ class DebugLoggerBase:
         self.steps: List[Any] = []
 
 
-if get_robot_version() < (7, 0):
+if RF_VERSION < (7, 0):
 
     class DebugLogger(DebugLoggerBase):
         def start_keyword(self, kw: Any) -> None:
@@ -1119,7 +1117,7 @@ class Debugger:
 
         self.remove_stackframe_entry(longname, type, source, line_no)
 
-    if get_robot_version() >= (7, 0):
+    if RF_VERSION >= (7, 0):
 
         def get_current_keyword_handler(self, name: str) -> UserKeywordHandler:
             return EXECUTION_CONTEXTS.current.namespace.get_runner(name).keyword
@@ -1252,7 +1250,7 @@ class Debugger:
 
         return False
 
-    if get_robot_version() >= (7, 0):
+    if RF_VERSION >= (7, 0):
 
         def _get_step_data(self, step: Any) -> Any:
             return step
@@ -1262,31 +1260,23 @@ class Debugger:
         def _get_step_data(self, step: Any) -> Any:
             return step.data
 
-    if get_robot_version() < (5, 0):
-
-        def is_not_caugthed_by_except(self, message: Optional[str]) -> bool:
-            if not message:
-                return True
-            return False
-    else:
+    def is_not_caugthed_by_except(self, message: Optional[str]) -> bool:
+        if not message:
+            return True
 
-        def is_not_caugthed_by_except(self, message: Optional[str]) -> bool:
-            if not message:
-                return True
+        # TODO resolve variables in exception message
 
-            # TODO resolve variables in exception message
-
-            if self.debug_logger:
-                if self.debug_logger.steps:
-                    for branch in [
-                        self._get_step_data(f)
-                        for f in reversed(self.debug_logger.steps)
-                        if isinstance(self._get_step_data(f), Try)
-                    ]:
-                        for except_branch in branch.except_branches:
-                            if self._should_run_except(except_branch, message):
-                                return False
-            return True
+        if self.debug_logger:
+            if self.debug_logger.steps:
+                for branch in [
+                    self._get_step_data(f)
+                    for f in reversed(self.debug_logger.steps)
+                    if isinstance(self._get_step_data(f), Try)
+                ]:
+                    for except_branch in branch.except_branches:
+                        if self._should_run_except(except_branch, message):
+                            return False
+        return True
 
     def end_keyword(self, name: str, attributes: AttributeDict) -> None:
         if self.state == State.CallKeyword:
@@ -1602,7 +1592,7 @@ class Debugger:
 
         return Variable(name=name, value=self.debug_repr.repr(value), type=repr(type(value)))
 
-    if get_robot_version() >= (7, 0):
+    if RF_VERSION >= (7, 0):
 
         def get_handler_args(self, handler: UserKeywordHandler) -> Any:
             return handler.args
@@ -1764,7 +1754,7 @@ class Debugger:
     SPLIT_LINE: ClassVar = re.compile(r"(?= {2,}| ?\t)\s*")
     CURRDIR: ClassVar = re.compile(r"(?i)\$\{CURDIR\}")
 
-    if get_robot_version() >= (7, 0):
+    if RF_VERSION >= (7, 0):
 
         def _run_keyword(self, kw: Keyword, context: Any) -> Any:
             return kw.run(context.steps[-1][1], context)
@@ -1774,7 +1764,7 @@ class Debugger:
         def _run_keyword(self, kw: Keyword, context: Any) -> Any:
             return kw.run(context)
 
-    if get_robot_version() >= (7, 2):
+    if RF_VERSION >= (7, 2):
 
         @staticmethod
         def check_message_is_logged(listener: Any, msg: Any) -> bool:
@@ -1963,7 +1953,7 @@ class Debugger:
             result = None
 
             if len(test.body):
-                if get_robot_version() >= (7, 3):
+                if RF_VERSION >= (7, 3):
                     result = self._execute_keywords_with_delayed_logging_v73(test.body, evaluate_context)
                 else:
                     result = self._execute_keywords_with_delayed_logging_legacy(test.body, evaluate_context)
@@ -2003,7 +1993,7 @@ class Debugger:
                     result = e
                     break
                 finally:
-                    if get_robot_version() <= (7, 2):
+                    if RF_VERSION <= (7, 2):
                         self._process_delayed_log_messages()
         return result
 
@@ -2161,7 +2151,7 @@ class Debugger:
 
         return result or None
 
-    if get_robot_version() >= (7, 0):
+    if RF_VERSION >= (7, 0):
 
         def _get_keywords_from_lib(self, lib: Any) -> Any:
             return lib.keywords

{robotcode_debugger-2.3.1 → robotcode_debugger-2.5.0}/src/robotcode/debugger/launcher/client.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 import asyncio
+import logging
+import weakref
 from typing import Any, Optional, Sequence
 
 from robotcode.core.event import event
@@ -38,6 +40,17 @@ class DAPClientError(Exception):
     pass
 
 
+class _DAPClientState:
+    __slots__ = ("closed", "logger", "loop", "protocol", "transport")
+
+    def __init__(self, logger: logging.Logger) -> None:
+        self.logger = logger
+        self.loop: Optional[asyncio.AbstractEventLoop] = None
+        self.protocol: Optional[DAPClientProtocol] = None
+        self.transport: Optional[asyncio.BaseTransport] = None
+        self.closed = False
+
+
 class DAPClient:
     _logger = LoggingDescriptor()
 
@@ -48,8 +61,43 @@ class DAPClient:
     ) -> None:
         self.parent = parent
         self.tcp_params = tcp_params
-        self._protocol: Optional[DAPClientProtocol] = None
-        self._transport: Optional[asyncio.BaseTransport] = None
+        self._state = _DAPClientState(
+            logging.getLogger(f"{type(self).__module__}.{type(self).__qualname__}"),
+        )
+        self._finalizer = weakref.finalize(self, DAPClient._finalize_resources, self._state)
+
+    @staticmethod
+    def _finalize_resources(state: _DAPClientState) -> None:
+        if state.closed or state.transport is None:
+            return
+
+        try:
+            if state.loop is not None and not state.loop.is_closed() and state.loop.is_running():
+                state.loop.call_soon_threadsafe(state.transport.close)
+            else:
+                state.transport.close()
+        except BaseException:
+            pass
+
+        state.logger.debug(
+            "DAPClient was garbage collected without calling close(); the transport was closed best-effort only.",
+        )
+
+    @property
+    def _protocol(self) -> Optional[DAPClientProtocol]:
+        return self._state.protocol
+
+    @_protocol.setter
+    def _protocol(self, value: Optional[DAPClientProtocol]) -> None:
+        self._state.protocol = value
+
+    @property
+    def _transport(self) -> Optional[asyncio.BaseTransport]:
+        return self._state.transport
+
+    @_transport.setter
+    def _transport(self, value: Optional[asyncio.BaseTransport]) -> None:
+        self._state.transport = value
 
     @event
     def on_closed(sender) -> None: ...
@@ -61,11 +109,10 @@ class DAPClient:
             self._transport = None
             self._protocol = None
 
+        self._state.closed = True
+        self._finalizer.detach()
         self.on_closed(self)
 
-    def __del__(self) -> None:
-        self.close()
-
     @_logger.call
     def on_connection_lost(self, sender: Any, exc: Optional[BaseException]) -> None:
         if sender == self._protocol:
@@ -76,6 +123,8 @@ class DAPClient:
         async def wait() -> None:
             while self._protocol is None:
                 try:
+                    current_loop = asyncio.get_running_loop()
+                    self._state.loop = current_loop
                     if self.tcp_params.host is not None:
                         if isinstance(self.tcp_params.host, Sequence):
                             host = self.tcp_params.host[0]
@@ -86,7 +135,7 @@ class DAPClient:
                     (
                         self._transport,
                         protocol,
-                    ) = await asyncio.get_running_loop().create_connection(
+                    ) = await current_loop.create_connection(
                         self._create_protocol,
                         host=host,
                         port=self.tcp_params.port,

{robotcode_debugger-2.3.1 → robotcode_debugger-2.5.0}/src/robotcode/debugger/launcher/server.py

@@ -11,7 +11,7 @@ from robotcode.core.types import ServerMode, TcpParams
 from robotcode.core.utils.logging import LoggingDescriptor
 from robotcode.jsonrpc2.protocol import rpc_method
 from robotcode.jsonrpc2.server import JsonRPCServer
-from robotcode.robot.utils import get_robot_version
+from robotcode.robot.utils import RF_VERSION
 
 from ..cli import DEBUGGER_DEFAULT_PORT, DEBUGPY_DEFAULT_PORT
 from ..dap_types import (
@@ -85,6 +85,11 @@ class LauncherDebugAdapterProtocol(DebugAdapterProtocol):
     def connected(self) -> bool:
         return self._client is not None and self._client.connected
 
+    def close(self) -> None:
+        if self._client is not None:
+            self._client.close()
+            self._client = None
+
     @rpc_method(name="initialize", param_type=InitializeRequestArguments)
     async def _initialize(self, arguments: InitializeRequestArguments, *args: Any, **kwargs: Any) -> Capabilities:
         self._initialize_arguments = arguments
@@ -189,7 +194,7 @@ class LauncherDebugAdapterProtocol(DebugAdapterProtocol):
 
         run_args = []
 
-        if get_robot_version() >= (6, 0) and languages:
+        if RF_VERSION >= (6, 0) and languages:
             for lang in languages:
                 run_args += ["--language", lang]
 
@@ -352,3 +357,9 @@ class LauncherServer(JsonRPCServer[LauncherDebugAdapterProtocol]):
         self.protocol = LauncherDebugAdapterProtocol(debugger_script=self.debugger_script)
 
         return self.protocol
+
+    def _close(self) -> None:
+        if self.protocol is not None:
+            self.protocol.close()
+
+        super()._close()

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

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