lsp-devtools 0.2.2__tar.gz → 0.2.4__tar.gz

{lsp_devtools-0.2.2 → lsp_devtools-0.2.4}/CHANGES.md

@@ -1,3 +1,28 @@
+## v0.2.4 - 2024-11-23
+
+### Fixes
+
+- The `lsp-devtools agent` should now suppress `asyncio.CancelledError` exceptions allowing the agent to process to terminate gracefully ([#191](https://github.com/swyddfa/lsp-devtools/issues/191))
+
+### Misc
+
+- Drop Python 3.8 support ([#190](https://github.com/swyddfa/lsp-devtools/issues/190))
+- Migrate to pygls `v2.0a2` ([#192](https://github.com/swyddfa/lsp-devtools/issues/192))
+
+
+## v0.2.3 - 2024-05-22
+
+
+### Enhancements
+
+- The `lsp-devtools agent` now forwards the server's `stderr` channel ([#165](https://github.com/swyddfa/lsp-devtools/issues/165))
+
+### Fixes
+
+- All `lsp-devtools` commands should no longer crash when encountering messages containing unicode characters ([#157](https://github.com/swyddfa/lsp-devtools/issues/157))
+- Commands like `lsp-devtools record` should now continue to function after encountering an error ([#158](https://github.com/swyddfa/lsp-devtools/issues/158))
+
+
 ## v0.2.2 - 2024-01-29
 
 

{lsp_devtools-0.2.2 → lsp_devtools-0.2.4}/PKG-INFO

@@ -1,31 +1,27 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: lsp-devtools
-Version: 0.2.2
+Version: 0.2.4
 Summary: Developer tooling for language servers
 Project-URL: Bug Tracker, https://github.com/swyddfa/lsp-devtools/issues
-Project-URL: Documentation, https://swyddfa.github.io/lsp-devtools/
+Project-URL: Documentation, https://lsp-devtools.readthedocs.io/en/latest/
 Project-URL: Source Code, https://github.com/swyddfa/lsp-devtools
 Author-email: Alex Carney <alcarneyme@gmail.com>
 License: MIT
-License-File: LICENSE
 Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Requires-Dist: aiosqlite
-Requires-Dist: importlib-resources; python_version < '3.9'
 Requires-Dist: platformdirs
-Requires-Dist: pygls>=1.1.0
+Requires-Dist: pygls>=2.0a2
 Requires-Dist: stamina
 Requires-Dist: textual>=0.41.0
-Requires-Dist: typing-extensions; python_version < '3.8'
 Description-Content-Type: text/markdown
 
 # lsp-devtools: Developer tooling for language servers

lsp_devtools-0.2.4/hatch.toml

@@ -0,0 +1,19 @@
+[version]
+path = "lsp_devtools/__init__.py"
+validate-bump = false
+
+[build.targets.sdist]
+include = ["lsp_devtools", "tests", "CHANGES.md"]
+
+[build.targets.wheel]
+packages = ["lsp_devtools"]
+
+[envs.hatch-test]
+extra-dependencies = ["pytest-asyncio"]
+
+[envs.hatch-test.env-vars]
+UV_PRERELEASE="allow"
+
+[envs.hatch-static-analysis]
+config-path = "ruff_defaults.toml"
+dependencies = ["ruff==0.8.0"]

lsp_devtools-0.2.4/lsp_devtools/__init__.py

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

{lsp_devtools-0.2.2 → lsp_devtools-0.2.4}/lsp_devtools/agent/__init__.py

@@ -1,66 +1,43 @@
+from __future__ import annotations
+
 import argparse
 import asyncio
-import logging
 import subprocess
 import sys
-from typing import List
-from uuid import uuid4
 
 from .agent import Agent
+from .agent import RPCMessage
 from .agent import logger
+from .agent import parse_rpc_message
 from .client import AgentClient
-from .protocol import MESSAGE_TEXT_NOTIFICATION
-from .protocol import MessageText
 from .server import AgentServer
-from .server import parse_rpc_message
 
 __all__ = [
     "Agent",
     "AgentClient",
     "AgentServer",
+    "RPCMessage",
     "logger",
-    "MESSAGE_TEXT_NOTIFICATION",
-    "MessageText",
     "parse_rpc_message",
 ]
 
 
-class MessageHandler(logging.Handler):
-    """Logging handler that forwards captured JSON-RPC messages through to the
-    ``AgentServer`` instance."""
-
-    def __init__(self, client: AgentClient, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.client = client
-        self.session = str(uuid4())
-        self._buffer: List[MessageText] = []
-
-    def emit(self, record: logging.LogRecord):
-        message = MessageText(
-            text=record.args[0],  # type: ignore
-            session=self.session,
-            timestamp=record.created,
-            source=record.__dict__["source"],
-        )
-
-        if not self.client.connected:
-            self._buffer.append(message)
-            return
+async def forward_stderr(server: asyncio.subprocess.Process):
+    """Forward the server's stderr to the agent's stderr."""
+    if server.stderr is None:
+        return
 
-        # Send any buffered messages
-        while len(self._buffer) > 0:
-            self.client.protocol.message_text_notification(self._buffer.pop(0))
+    # EOF is signalled with an empty bytestring
+    while (line := await server.stderr.readline()) != b"":
+        sys.stderr.buffer.write(line)
 
-        self.client.protocol.message_text_notification(message)
 
-
-async def main(args, extra: List[str]):
+async def main(args, extra: list[str]):
     if extra is None:
         print("Missing server start command", file=sys.stderr)
         return 1
 
     command, *arguments = extra
-
     server = await asyncio.create_subprocess_exec(
         command,
         *arguments,
@@ -68,23 +45,21 @@ async def main(args, extra: List[str]):
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
     )
-    agent = Agent(server, sys.stdin.buffer, sys.stdout.buffer)
-
     client = AgentClient()
-    handler = MessageHandler(client)
-    handler.setLevel(logging.INFO)
-
-    logger.setLevel(logging.INFO)
-    logger.addHandler(handler)
+    agent = Agent(server, sys.stdin.buffer, sys.stdout.buffer, client.forward_message)
 
     await asyncio.gather(
         client.start_tcp(args.host, args.port),
         agent.start(),
+        forward_stderr(server),
     )
 
 
-def run_agent(args, extra: List[str]):
-    asyncio.run(main(args, extra))
+def run_agent(args, extra: list[str]):
+    try:
+        asyncio.run(main(args, extra))
+    except asyncio.CancelledError:
+        pass
 
 
 def cli(commands: argparse._SubParsersAction):

{lsp_devtools-0.2.2 → lsp_devtools-0.2.4}/lsp_devtools/agent/agent.py

@@ -2,35 +2,81 @@ from __future__ import annotations
 
 import asyncio
 import inspect
+import json
 import logging
 import re
 import sys
 import typing
+from datetime import datetime
+from datetime import timezone
 from functools import partial
+from uuid import uuid4
+
+import attrs
 
 if typing.TYPE_CHECKING:
+    from collections.abc import Coroutine
+    from typing import Any
     from typing import BinaryIO
-    from typing import Optional
-    from typing import Set
-    from typing import Tuple
+    from typing import Callable
+    from typing import Union
+
+    from pygls.io_ import AsyncReader
+
+    MessageHandler = Callable[[bytes], Union[None, Coroutine[Any, Any, None]]]
 
+UTC = timezone.utc
 logger = logging.getLogger("lsp_devtools.agent")
 
 
-async def forward_message(source: str, dest: asyncio.StreamWriter, message: bytes):
-    """Forward the given message to the destination channel"""
-    dest.write(message)
-    await dest.drain()
+@attrs.define
+class RPCMessage:
+    """A Json-RPC message."""
 
-    # Log the full message
-    logger.info(
-        "%s",
-        message.decode("utf8"),
-        extra={"source": source},
-    )
+    headers: dict[str, str]
+
+    body: dict[str, Any]
+
+    def __getitem__(self, key: str):
+        return self.headers[key]
+
+
+def parse_rpc_message(data: bytes) -> RPCMessage:
+    """Parse a JSON-RPC message from the given set of bytes."""
+
+    headers: dict[str, str] = {}
+    body: dict[str, Any] | None = None
+    headers_complete = False
+
+    for line in data.split(b"\r\n"):
+        if line == b"":
+            if "Content-Length" not in headers:
+                raise ValueError("Missing 'Content-Length' header")
 
+            headers_complete = True
+            continue
 
-async def aio_readline(reader: asyncio.StreamReader, message_handler):
+        if headers_complete:
+            length = int(headers["Content-Length"])
+            if len(line) != length:
+                raise ValueError("Incorrect 'Content-Length'")
+
+            body = json.loads(line)
+            continue
+
+        if (idx := line.find(b":")) < 0:
+            raise ValueError(f"Invalid header: {line!r}")
+
+        name, value = line[:idx], line[idx + 1 :]
+        headers[name.decode("utf8").strip()] = value.decode("utf8").strip()
+
+    if body is None:
+        raise ValueError("Missing message body")
+
+    return RPCMessage(headers, body)
+
+
+async def aio_readline(reader: AsyncReader, message_handler: MessageHandler):
     CONTENT_LENGTH_PATTERN = re.compile(rb"^Content-Length: (\d+)\r\n$")
 
     # Initialize message buffer
@@ -70,7 +116,7 @@ async def aio_readline(reader: asyncio.StreamReader, message_handler):
 
 async def get_streams(
     stdin, stdout
-) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]:
+) -> tuple[asyncio.StreamReader, asyncio.StreamWriter]:
     """Convert blocking stdin/stdout streams into async streams."""
     loop = asyncio.get_running_loop()
 
@@ -90,29 +136,35 @@ class Agent:
     enabling them to be recorded."""
 
     def __init__(
-        self, server: asyncio.subprocess.Process, stdin: BinaryIO, stdout: BinaryIO
+        self,
+        server: asyncio.subprocess.Process,
+        stdin: BinaryIO,
+        stdout: BinaryIO,
+        handler: MessageHandler,
     ):
         self.stdin = stdin
         self.stdout = stdout
         self.server = server
+        self.handler = handler
+        self.session_id = str(uuid4())
 
-        self._tasks: Set[asyncio.Task] = set()
-        self.reader: Optional[asyncio.StreamReader] = None
-        self.writer: Optional[asyncio.StreamWriter] = None
+        self._tasks: set[asyncio.Task] = set()
+        self.reader: asyncio.StreamReader | None = None
+        self.writer: asyncio.StreamWriter | None = None
 
     async def start(self):
         # Get async versions of stdin/stdout
         self.reader, self.writer = await get_streams(self.stdin, self.stdout)
 
         # Keep mypy happy
-        assert self.server.stdin
-        assert self.server.stdout
+        if self.server.stdin is None or self.server.stdout is None:
+            raise RuntimeError("Unable to find server I/O streams")
 
         # Connect stdin to the subprocess' stdin
         client_to_server = asyncio.create_task(
             aio_readline(
                 self.reader,
-                partial(forward_message, "client", self.server.stdin),
+                partial(self.forward_message, "client", self.server.stdin),
             ),
         )
         self._tasks.add(client_to_server)
@@ -121,7 +173,7 @@ class Agent:
         server_to_client = asyncio.create_task(
             aio_readline(
                 self.server.stdout,
-                partial(forward_message, "server", self.writer),
+                partial(self.forward_message, "server", self.writer),
             ),
         )
         self._tasks.add(server_to_client)
@@ -133,6 +185,30 @@ class Agent:
             self._watch_server_process(),
         )
 
+    async def forward_message(
+        self, source: str, dest: asyncio.StreamWriter, message: bytes
+    ):
+        """Forward the given message to the destination channel"""
+
+        # Forward the message as-is to the client/server
+        dest.write(message)
+        await dest.drain()
+
+        # Include some additional metadata before passing it onto the devtool.
+        # TODO: How do we make sure we choose the same encoding as `message`?
+        now = datetime.now(tz=UTC).isoformat()
+        fields = [
+            f"Message-Source: {source}\r\n".encode(),
+            f"Message-Session: {self.session_id}\r\n".encode(),
+            f"Message-Timestamp: {now}\r\n".encode(),
+            message,
+        ]
+
+        if inspect.iscoroutine(res := self.handler(b"".join(fields))):
+            task = asyncio.create_task(res)
+            self._tasks.add(task)
+            task.add_done_callback(self._tasks.discard)
+
     async def _watch_server_process(self):
         """Once the server process exits, ensure that the agent is also shutdown."""
         ret = await self.server.wait()
@@ -148,13 +224,10 @@ class Agent:
             except TimeoutError:
                 self.server.kill()
 
-        args = {}
-        if sys.version_info.minor > 8:
-            args["msg"] = "lsp-devtools agent is stopping."
-
         # Cancel the tasks connecting client to server
         for task in self._tasks:
-            task.cancel(**args)
+            logger.debug("cancelling: %s", task)
+            task.cancel(msg="lsp-devtools agent is stopping.")
 
         if self.writer:
             self.writer.close()

lsp_devtools-0.2.4/lsp_devtools/agent/client.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import asyncio
+import inspect
+import typing
+
+import stamina
+from pygls.client import JsonRPCClient
+from pygls.protocol import default_converter
+
+from lsp_devtools.agent.protocol import AgentProtocol
+
+if typing.TYPE_CHECKING:
+    from typing import Any
+
+
+class AgentClient(JsonRPCClient):
+    """Client for connecting to an AgentServer instance."""
+
+    protocol: AgentProtocol
+
+    def __init__(self):
+        super().__init__(
+            protocol_cls=AgentProtocol, converter_factory=default_converter
+        )
+        self.connected = False
+        self._buffer: list[bytes] = []
+        self._tasks: set[asyncio.Task[Any]] = set()
+
+    def _report_server_error(self, error, source):
+        # Bail on error
+        # TODO: Report the actual error somehow
+        self._stop_event.set()
+
+    def feature(self, feature_name: str, options: Any | None = None):
+        return self.protocol.fm.feature(feature_name, options)
+
+    async def start_tcp(self, host: str, port: int):
+        # The user might not have started the server app immediately and since the
+        # agent will live as long as the wrapper language server we may as well
+        # try indefinitely.
+        retries = stamina.retry_context(
+            on=OSError,
+            attempts=None,
+            timeout=None,
+            wait_initial=1,
+            wait_max=60,
+        )
+        async for attempt in retries:
+            with attempt:
+                await super().start_tcp(host, port)
+                self.connected = True
+
+    def forward_message(self, message: bytes):
+        """Forward the given message to the server instance."""
+
+        if not self.connected or self.protocol.writer is None:
+            self._buffer.append(message)
+            return
+
+        # Send any buffered messages
+        while len(self._buffer) > 0:
+            res = self.protocol.writer.write(self._buffer.pop(0))
+            if inspect.isawaitable(res):
+                task = asyncio.ensure_future(res)
+                task.add_done_callback(self._tasks.discard)
+                self._tasks.add(task)
+
+        res = self.protocol.writer.write(message)
+        if inspect.isawaitable(res):
+            task = asyncio.ensure_future(res)
+            task.add_done_callback(self._tasks.discard)
+            self._tasks.add(task)

lsp_devtools-0.2.4/lsp_devtools/agent/protocol.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from pygls.protocol import JsonRPCProtocol
+
+
+class AgentProtocol(JsonRPCProtocol):
+    """The RPC protocol exposed by the agent."""

lsp_devtools-0.2.4/lsp_devtools/agent/server.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import traceback
+import typing
+
+from pygls.protocol import default_converter
+from pygls.server import JsonRPCServer
+
+from lsp_devtools.agent.agent import aio_readline
+from lsp_devtools.agent.protocol import AgentProtocol
+from lsp_devtools.database import Database
+
+if typing.TYPE_CHECKING:
+    from typing import Any
+
+    from lsp_devtools.agent.agent import MessageHandler
+
+
+class AgentServer(JsonRPCServer):
+    """A pygls server that accepts connections from agents allowing them to send their
+    collected messages."""
+
+    lsp: AgentProtocol
+
+    def __init__(
+        self,
+        *args,
+        logger: logging.Logger | None = None,
+        handler: MessageHandler | None = None,
+        **kwargs,
+    ):
+        if "protocol_cls" not in kwargs:
+            kwargs["protocol_cls"] = AgentProtocol
+
+        if "converter_factory" not in kwargs:
+            kwargs["converter_factory"] = default_converter
+
+        super().__init__(*args, **kwargs)
+
+        self.logger = logger or logging.getLogger(__name__)
+        self.handler = handler or self._default_handler
+        self.db: Database | None = None
+
+        self._client_buffer: list[str] = []
+        self._server_buffer: list[str] = []
+        self._tcp_server: asyncio.Task | None = None
+
+    def _default_handler(self, data: bytes):
+        message = self.protocol.structure_message(json.loads(data))
+        self.protocol.handle_message(message)
+
+    def _report_server_error(self, error: Exception, source):
+        """Report internal server errors."""
+        tb = "".join(
+            traceback.format_exception(type(error), error, error.__traceback__)
+        )
+        self.logger.error("%s: %s", type(error).__name__, error)
+        self.logger.debug("%s", tb)
+
+    def feature(self, feature_name: str, options: Any | None = None):
+        return self.lsp.fm.feature(feature_name, options)
+
+    async def start_tcp(self, host: str, port: int) -> None:  # type: ignore[override]
+        async def handle_client(
+            reader: asyncio.StreamReader, writer: asyncio.StreamWriter
+        ):
+            self.protocol.set_writer(writer)
+
+            try:
+                await aio_readline(reader, self.handler)
+            except asyncio.CancelledError:
+                pass
+            finally:
+                writer.close()
+                await writer.wait_closed()
+
+            # Uncomment if we ever need to introduce a mode where the server stops
+            # automatically once a session ends.
+            #
+            # self.stop()
+
+        server = await asyncio.start_server(handle_client, host, port)
+        async with server:
+            self._tcp_server = asyncio.create_task(server.serve_forever())
+            await self._tcp_server
+
+    def stop(self):
+        if self._tcp_server is not None:
+            self._tcp_server.cancel()

{lsp_devtools-0.2.2 → lsp_devtools-0.2.4}/lsp_devtools/client/__init__.py

@@ -1,9 +1,10 @@
+from __future__ import annotations
+
 import argparse
 import asyncio
 import logging
 import os
 import pathlib
-from typing import List
 from uuid import uuid4
 
 import platformdirs
@@ -54,7 +55,7 @@ class LSPClient(App):
     ]
 
     def __init__(
-        self, db: Database, server_command: List[str], session: str, *args, **kwargs
+        self, db: Database, server_command: list[str], session: str, *args, **kwargs
     ):
         super().__init__(*args, **kwargs)
 
@@ -65,11 +66,13 @@ class LSPClient(App):
         self.server_command = server_command
         self.lsp_client = LanguageClient()
 
-        self._async_tasks: List[asyncio.Task] = []
+        self._async_tasks: list[asyncio.Task] = []
 
     def compose(self) -> ComposeResult:
         message_viewer = MessageViewer("")
-        messages_table = MessagesTable(self.db, message_viewer, session=self.session)
+        messages_table = MessagesTable(
+            self.db, message_viewer, session=self.lsp_client.session_id
+        )
 
         yield Header()
         yield Explorer(".")
@@ -138,14 +141,14 @@ class LSPClient(App):
         await super().action_quit()
 
 
-def client(args, extra: List[str]):
+def client(args, extra: list[str]):
     if len(extra) == 0:
         raise ValueError("Missing server command.")
 
     db = Database(args.dbpath)
 
     session = str(uuid4())
-    dbhandler = DatabaseLogHandler(db, session=session)
+    dbhandler = DatabaseLogHandler(db)
     dbhandler.setLevel(logging.INFO)
 
     logger.setLevel(logging.INFO)

{lsp_devtools-0.2.2 → lsp_devtools-0.2.4}/lsp_devtools/client/editor/text_editor.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import contextlib
 import pathlib
 import typing
-from typing import List
 from typing import Union
 
 from lsprotocol import types
@@ -15,7 +14,7 @@ from textual.widgets import TextArea
 if typing.TYPE_CHECKING:
     from lsp_devtools.client.lsp import LanguageClient
 
-CompletionResult = Union[List[types.CompletionItem], types.CompletionList, None]
+CompletionResult = Union[list[types.CompletionItem], types.CompletionList, None]
 
 
 # TODO: Refactor to
@@ -104,7 +103,7 @@ class TextEditor(TextArea):
                     version=self.version, uri=self.uri
                 ),
                 content_changes=[
-                    types.TextDocumentContentChangeEvent_Type1(
+                    types.TextDocumentContentChangePartial(
                         text=edit.text,
                         range=types.Range(
                             start=types.Position(line=start_line, character=start_col),