robotcode-debugger 0.80.0__tar.gz → 0.82.0__tar.gz

{robotcode_debugger-0.80.0 → robotcode_debugger-0.82.0}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.3
 Name: robotcode-debugger
-Version: 0.80.0
+Version: 0.82.0
 Summary: RobotCode Debugger for Robot Framework
 Project-URL: Homepage, https://robotcode.io
-Project-URL: Donate, https://github.com/sponsors/d-biehl
+Project-URL: Donate, https://opencollective.com/robotcode
 Project-URL: Documentation, https://github.com/robotcodedev/robotcode#readme
 Project-URL: Changelog, https://github.com/robotcodedev/robotcode/blob/main/CHANGELOG.md
 Project-URL: Issues, https://github.com/robotcodedev/robotcode/issues
@@ -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.80.0
-Requires-Dist: robotcode-runner==0.80.0
+Requires-Dist: robotcode-jsonrpc2==0.82.0
+Requires-Dist: robotcode-runner==0.82.0
 Requires-Dist: robotframework>=4.1.0
 Provides-Extra: debugpy
 Requires-Dist: debugpy; extra == 'debugpy'

{robotcode_debugger-0.80.0 → robotcode_debugger-0.82.0}/pyproject.toml

@@ -28,8 +28,8 @@ classifiers = [
 dynamic = ["version"]
 dependencies = [
   "robotframework>=4.1.0",
-  "robotcode-jsonrpc2==0.80.0",
-  "robotcode-runner==0.80.0",
+  "robotcode-jsonrpc2==0.82.0",
+  "robotcode-runner==0.82.0",
 ]
 
 [project.optional-dependencies]
@@ -40,7 +40,7 @@ debugger = "robotcode.debugger.hooks"
 
 [project.urls]
 Homepage = "https://robotcode.io"
-Donate = "https://github.com/sponsors/d-biehl"
+Donate = "https://opencollective.com/robotcode"
 Documentation = "https://github.com/robotcodedev/robotcode#readme"
 Changelog = "https://github.com/robotcodedev/robotcode/blob/main/CHANGELOG.md"
 Issues = "https://github.com/robotcodedev/robotcode/issues"

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

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

{robotcode_debugger-0.80.0 → robotcode_debugger-0.82.0}/src/robotcode/debugger/cli.py

@@ -1,4 +1,3 @@
-import asyncio
 from typing import Optional, Sequence, Tuple
 
 import click
@@ -22,7 +21,8 @@ DEBUGPY_DEFAULT_PORT = 5678
     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 @@ DEBUGPY_DEFAULT_PORT = 5678
     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 @@ DEBUGPY_DEFAULT_PORT = 5678
     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,
             )
         )
 

{robotcode_debugger-0.80.0 → robotcode_debugger-0.82.0}/src/robotcode/debugger/protocol.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 import asyncio
 import inspect
 import json
@@ -142,7 +140,7 @@ class DebugAdapterProtocol(JsonRPCProtocolBase):
             )
 
     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,7 +247,7 @@ class DebugAdapterProtocol(JsonRPCProtocolBase):
 
             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:
@@ -257,7 +255,6 @@ class DebugAdapterProtocol(JsonRPCProtocolBase):
             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 @@ class DebugAdapterProtocol(JsonRPCProtocolBase):
     @_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

{robotcode_debugger-0.80.0 → robotcode_debugger-0.82.0}/src/robotcode/debugger/run.py

@@ -2,7 +2,8 @@ import asyncio
 import functools
 import os
 import threading
-import warnings
+import time
+from concurrent.futures import CancelledError
 from typing import (
     TYPE_CHECKING,
     Callable,
@@ -15,10 +16,7 @@ from typing import (
 
 import click
 
-from robotcode.core.async_tools import (
-    run_coroutine_from_thread_async,
-    run_coroutine_in_thread,
-)
+from robotcode.core.concurrent import run_as_debugpy_hidden_task
 from robotcode.core.types import ServerMode, TcpParams
 from robotcode.core.utils.debugpy import (
     enable_debugpy,
@@ -53,20 +51,22 @@ def set_server(value: "DebugAdapterServer") -> None:
 
 
 @_logger.call
-async def wait_for_server(timeout: float = 5) -> "DebugAdapterServer":
-    async def wait() -> None:
-        while get_server() is None:
-            await asyncio.sleep(0.005)
+def wait_for_server(timeout: float = 10) -> "DebugAdapterServer":
 
-    await asyncio.wait_for(wait(), timeout)
+    start_time = time.monotonic()
+    while get_server() is None and time.monotonic() - start_time < timeout:
+        time.sleep(0.005)
 
     result = get_server()
-    assert result is not None
+
+    if result is None:
+        raise RuntimeError("Timeout to get server instance.")
+
     return result
 
 
 @_logger.call
-async def _debug_adapter_server_(
+async def _debug_adapter_server_async(
     on_config_done_callback: Optional[Callable[["DebugAdapterServer"], None]],
     mode: ServerMode,
     addresses: Union[str, Sequence[str], None],
@@ -89,14 +89,26 @@ async def _debug_adapter_server_(
         await server.serve()
 
 
+def _debug_adapter_server_(
+    on_config_done_callback: Optional[Callable[["DebugAdapterServer"], None]],
+    mode: ServerMode,
+    addresses: Union[str, Sequence[str], None],
+    port: int,
+    pipe_name: Optional[str],
+) -> None:
+    asyncio.run(_debug_adapter_server_async(on_config_done_callback, mode, addresses, port, pipe_name))
+
+
 DEFAULT_TIMEOUT = 10.0
 
 
 config_done_callback: Optional[Callable[["DebugAdapterServer"], None]] = None
+debugpy_connected = threading.Event()
 
 
 @_logger.call
-async def start_debugpy_async(
+def start_debugpy(
+    app: Application,
     debugpy_port: Optional[int] = None,
     addresses: Union[Sequence[str], str, None] = None,
     wait_for_debugpy_client: bool = False,
@@ -122,17 +134,22 @@ async def start_debugpy_async(
             )
 
             if wait_for_debugpy_client:
-                wait_for_debugpy_connected()
+                app.verbose(f"Wait for debugpy incomming connections listening on {addresses}:{port}")
+                if not wait_for_debugpy_connected(wait_for_client_timeout):
+                    app.warning("No debugpy client connected")
+                else:
+                    app.verbose("Debugpy client connected")
+            debugpy_connected.set()
 
         config_done_callback = connect_debugpy
 
 
 @_logger.call
-async def run_debugger(
+def run_debugger(
     ctx: click.Context,
     app: Application,
     args: List[str],
-    mode: str,
+    mode: ServerMode,
     addresses: Union[str, Sequence[str], None],
     port: int,
     pipe_name: Optional[str] = None,
@@ -150,19 +167,21 @@ async def run_debugger(
     group_output: bool = False,
 ) -> int:
     if debug and debugpy and not is_debugpy_installed():
-        app.warning("Debugpy not installed.")
+        app.warning("Debugpy not installed")
 
     if debug and debugpy:
-        app.verbose("Try to start debugpy session.")
-        await start_debugpy_async(
+        app.verbose("Try to start debugpy session")
+        start_debugpy(
+            app,
             debugpy_port,
             addresses,
             debugpy_wait_for_client,
             wait_for_client_timeout,
         )
 
-    app.verbose("Start robotcode debugger thread.")
-    server_future = run_coroutine_in_thread(
+    app.verbose("Start robotcode debugger thread")
+
+    run_as_debugpy_hidden_task(
         _debug_adapter_server_,
         config_done_callback,
         mode,
@@ -171,41 +190,29 @@ async def run_debugger(
         pipe_name,
     )
 
-    server = await wait_for_server()
+    server = wait_for_server()
+
     exit_code = 255
 
     try:
         if wait_for_client:
-            app.verbose("Wait for incomming connections.")
+            app.verbose("Wait for incomming connections")
             try:
-                await run_coroutine_from_thread_async(
-                    server.protocol.wait_for_client,
-                    wait_for_client_timeout,
-                    loop=server.loop,
-                )
-            except asyncio.CancelledError:
-                pass
-            except asyncio.TimeoutError as e:
-                raise ConnectionError("No incomming connection from a debugger client.") from e
+                server.protocol.wait_for_client(wait_for_client_timeout)
+            except TimeoutError as e:
+                raise ConnectionError("No incomming connection from a debugger client") from e
 
-            await run_coroutine_from_thread_async(server.protocol.wait_for_initialized, loop=server.loop)
+            server.protocol.wait_for_initialized(wait_for_client_timeout)
 
         if wait_for_client:
             app.verbose("Wait for debug configuration.")
             try:
-                await run_coroutine_from_thread_async(
-                    server.protocol.wait_for_configuration_done,
-                    configuration_done_timeout,
-                    loop=server.loop,
-                )
-            except asyncio.CancelledError:
-                pass
-            except asyncio.TimeoutError as e:
-                raise ConnectionError("Timeout to get configuration from client.") from e
+                server.protocol.wait_for_configuration_done(configuration_done_timeout)
+            except TimeoutError as e:
+                raise ConnectionError("Timeout to get configuration from client") from e
 
         if debugpy and debugpy_wait_for_client:
-            app.verbose("Wait for debugpy incomming connections.")
-            wait_for_debugpy_connected()
+            debugpy_connected.wait(wait_for_client_timeout)
 
         args = [
             "--listener",
@@ -225,14 +232,14 @@ async def run_debugger(
         Debugger.instance().set_main_thread(threading.current_thread())
         Debugger.instance().server_loop = server.loop
 
-        app.verbose("Start the debugger instance.")
+        app.verbose("Start the debugger instance")
         Debugger.instance().start()
 
         exit_code = 0
         try:
             from robotcode.runner.cli.robot import robot
 
-            app.verbose("Start robot.")
+            app.verbose("Start robot")
             try:
                 robot_ctx = robot.make_context("robot", args, parent=ctx)
                 robot.invoke(robot_ctx)
@@ -240,8 +247,7 @@ async def run_debugger(
                 exit_code = cast(int, e.code)
         finally:
             if server.protocol.connected:
-                await run_coroutine_from_thread_async(
-                    server.protocol.send_event_async,
+                server.protocol.send_event(
                     Event(
                         event="robotExited",
                         body={
@@ -250,27 +256,19 @@ async def run_debugger(
                             "outputFile": Debugger.instance().robot_output_file,
                             "exitCode": exit_code,
                         },
-                    ),
-                    loop=server.loop,
+                    )
                 )
 
-                await run_coroutine_from_thread_async(server.protocol.exit, exit_code, loop=server.loop)
-    except asyncio.CancelledError:
+                server.protocol.exit(exit_code)
+    except CancelledError:
         pass
     finally:
         if server.protocol.connected:
-            await run_coroutine_from_thread_async(server.protocol.terminate, loop=server.loop)
+            server.protocol.terminate()
 
-            try:
-                await run_coroutine_from_thread_async(server.protocol.wait_for_disconnected, loop=server.loop)
-            except asyncio.TimeoutError:
-                warnings.warn("Timeout at disconnect client occurred.")
+            if not server.protocol.wait_for_disconnected():
+                app.warning("Timeout to get disconnected from client")
 
-        server_future.cancel()
-
-        try:
-            await server_future
-        except asyncio.CancelledError:
-            pass
+        server.loop.stop()
 
     return exit_code

{robotcode_debugger-0.80.0 → robotcode_debugger-0.82.0}/src/robotcode/debugger/server.py

@@ -1,8 +1,9 @@
 import asyncio
 import os
+import threading
 from typing import Any, Callable, Dict, List, Literal, Optional, Union
 
-from robotcode.core import async_tools
+from robotcode.core import concurrent
 from robotcode.core.types import ServerMode, TcpParams
 from robotcode.core.utils.logging import LoggingDescriptor
 from robotcode.jsonrpc2.protocol import rpc_method
@@ -59,21 +60,21 @@ class DebugAdapterServerProtocol(DebugAdapterProtocol):
     def __init__(self) -> None:
         super().__init__()
 
-        self._connected_event = async_tools.Event()
-        self._disconnected_event = async_tools.Event()
+        self._connected_event = threading.Event()
+        self._disconnected_event = threading.Event()
         self._connected = False
         self._sigint_signaled = False
 
         self._initialized = False
-        self._initialized_event = async_tools.Event()
+        self._initialized_event = threading.Event()
 
-        self._exited_lock = async_tools.Lock()
+        self._exited_lock = concurrent.RLock()
         self._exited = False
 
-        self._terminated_lock = async_tools.Lock()
+        self._terminated_lock = concurrent.RLock()
         self._terminated = False
 
-        self._received_configuration_done_event = async_tools.Event()
+        self._received_configuration_done_event = threading.Event()
         self._received_configuration_done = False
         self.received_configuration_done_callback: Optional[Callable[[], None]] = None
 
@@ -88,13 +89,13 @@ class DebugAdapterServerProtocol(DebugAdapterProtocol):
         return self._connected
 
     @property
-    async def exited(self) -> bool:
-        async with self._exited_lock:
+    def exited(self) -> bool:
+        with self._exited_lock:
             return self._exited
 
     @property
-    async def terminated(self) -> bool:
-        async with self._terminated_lock:
+    def terminated(self) -> bool:
+        with self._terminated_lock:
             return self._terminated
 
     @_logger.call
@@ -116,22 +117,24 @@ class DebugAdapterServerProtocol(DebugAdapterProtocol):
         self._disconnected_event.set()
 
     @_logger.call
-    async def wait_for_client(self, timeout: float = 5) -> bool:
-        await asyncio.wait_for(self._connected_event.wait(), timeout)
+    def wait_for_client(self, timeout: float = 5) -> bool:
+        if not self._connected_event.wait(timeout):
+            raise TimeoutError("Timeout waiting for client")
 
         return self._connected
 
     @_logger.call
-    async def wait_for_initialized(self, timeout: float = 30) -> bool:
-        await asyncio.wait_for(self._initialized_event.wait(), timeout)
+    def wait_for_initialized(self, timeout: float = 30) -> bool:
+        if not self._initialized_event.wait(timeout):
+            raise TimeoutError("Timeout waiting for client initialization")
 
         return self._initialized
 
     @_logger.call
-    async def wait_for_disconnected(self, timeout: float = 30) -> bool:
-        await asyncio.wait_for(self._disconnected_event.wait(), timeout)
+    def wait_for_disconnected(self, timeout: float = 5) -> bool:
+        self._disconnected_event.wait(timeout)
 
-        return self._connected
+        return not self._connected
 
     @rpc_method(name="initialize", param_type=InitializeRequestArguments)
     async def _initialize(self, arguments: InitializeRequestArguments, *args: Any, **kwargs: Any) -> Capabilities:
@@ -211,15 +214,15 @@ class DebugAdapterServerProtocol(DebugAdapterProtocol):
         self._initialized_event.set()
 
     @_logger.call
-    async def exit(self, exit_code: int) -> None:
-        async with self._exited_lock:
-            await self.send_event_async(ExitedEvent(body=ExitedEventBody(exit_code=exit_code)))
+    def exit(self, exit_code: int) -> None:
+        with self._exited_lock:
+            self.send_event(ExitedEvent(body=ExitedEventBody(exit_code=exit_code)))
             self._exited = True
 
     @_logger.call
-    async def terminate(self) -> None:
-        async with self._terminated_lock:
-            await self.send_event_async(TerminatedEvent())
+    def terminate(self) -> None:
+        with self._terminated_lock:
+            self.send_event(TerminatedEvent())
             self._terminated = True
 
     @rpc_method(name="terminate", param_type=TerminateArguments)
@@ -251,11 +254,7 @@ class DebugAdapterServerProtocol(DebugAdapterProtocol):
         *args: Any,
         **kwargs: Any,
     ) -> None:
-        if (
-            (not (await self.exited) or not (await self.terminated))
-            and arguments is not None
-            and arguments.terminate_debuggee
-        ):
+        if (not (self.exited) or not (self.terminated)) and arguments is not None and arguments.terminate_debuggee:
             os._exit(-1)
         else:
             await self.send_event_async(Event("disconnectRequested"))
@@ -290,8 +289,9 @@ class DebugAdapterServerProtocol(DebugAdapterProtocol):
             self.received_configuration_done_callback()
 
     @_logger.call
-    async def wait_for_configuration_done(self, timeout: float = 5) -> bool:
-        await asyncio.wait_for(self._received_configuration_done_event.wait(), timeout)
+    def wait_for_configuration_done(self, timeout: float = 5) -> bool:
+        if not self._received_configuration_done_event.wait(timeout):
+            raise TimeoutError("Timeout waiting for configuration done event")
 
         return self._received_configuration_done
 

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

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