lspleanklib 0.1.1__tar.gz

lspleanklib-0.1.1/.gitignore

@@ -0,0 +1,5 @@
+__pycache__
+dist
+build
+*.egg-info
+_version.py

lspleanklib-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 E. Castedo Ellerman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

lspleanklib-0.1.1/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.1
+Name: lspleanklib
+Version: 0.1.1
+Summary: LSP proxy and library to link LSP-enabled editors to Lake LSP servers
+Author-email: Castedo Ellerman <castedo@castedo.com>
+License: MIT License
+        
+        Copyright (c) 2026 E. Castedo Ellerman
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be
+        included in all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+        FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+        DEALINGS IN THE SOFTWARE.
+        
+Keywords: lsp,language-server-protocol,jsonrpc
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: POSIX
+Requires-Python: >=3.12
+License-File: LICENSE
+Provides-Extra: crossplatform
+Requires-Dist: platformdirs; extra == "crossplatform"

lspleanklib-0.1.1/justfile

@@ -0,0 +1,19 @@
+#!/usr/bin/env -S just --justfile
+
+default:
+    just --list
+
+test:
+    ruff check lspleanklib || true
+    mypy --strict lspleanklib
+    mypy tests --cache-dir tests/.mypy_cache
+    pytest -vv tests --timeout=2 \
+#      -m 'not slow' \
+#      --durations=3 \
+#      --log-cli-level=DEBUG \
+
+clean:
+    rm -rf dist
+    rm -rf build
+    rm -rf *.egg-info
+    rm -f _version.py

lspleanklib-0.1.1/lspleanklib/__init__.py

@@ -0,0 +1,40 @@
+from .jsonrpc import (
+    ErrorCode,
+    JsonRpcMsg,
+    MethodCall,
+    Response,
+    RpcChannel,
+    RpcInterface,
+    RpcMsgChannel,
+    RpcMsgConnection,
+    awaitable_error,
+    json_rpc_channel,
+)
+from .lspleank import lspleank_connect_main
+from .server import (
+    RpcDirChannelFactory,
+    RpcSubprocessFactory,
+    channel_lsp_server,
+    get_user_socket_path,
+)
+from .util import LspAny, LspObject
+
+__all__ = (
+    'ErrorCode',
+    'JsonRpcMsg',
+    'LspAny',
+    'LspObject',
+    'MethodCall',
+    'Response',
+    'RpcChannel',
+    'RpcDirChannelFactory',
+    'RpcInterface',
+    'RpcMsgChannel',
+    'RpcMsgConnection',
+    'RpcSubprocessFactory',
+    'awaitable_error',
+    'channel_lsp_server',
+    'get_user_socket_path',
+    'json_rpc_channel',
+    'lspleank_connect_main',
+)

lspleanklib-0.1.1/lspleanklib/__main__.py

@@ -0,0 +1,3 @@
+from .lspleank import main
+
+exit(main())

lspleanklib-0.1.1/lspleanklib/aio.py

@@ -0,0 +1,100 @@
+"""
+Asynchronous IO
+"""
+
+import asyncio, io, os, typing
+from asyncio import AbstractEventLoop, Future
+from collections.abc import Callable
+from concurrent.futures import ThreadPoolExecutor
+from typing import BinaryIO
+
+
+class MinimalWriter(typing.Protocol):
+    def write(self, data: bytes) -> None: ...
+    async def drain(self) -> None: ...
+    def close(self) -> None: ...
+    async def wait_closed(self) -> None: ...
+    def is_closing(self) -> bool: ...
+
+
+class MinimalReader(typing.Protocol):
+    async def readuntil(self) -> bytes: ...  # read until and return with '\n'
+    async def readexactly(self, n: int) -> bytes: ...
+    async def read(self) -> bytes: ...
+    def at_eof(self) -> bool: ...
+
+
+class DuplexStream:
+    def __init__(self, ain: MinimalReader, aout: MinimalWriter):
+        self.ain = ain
+        self.aout = aout
+
+
+class WriterFileAdapter(MinimalWriter):
+    def __init__(self, fout: BinaryIO, *, loop: AbstractEventLoop):
+        self._fout = fout
+        self._loop = loop
+        self._pool = ThreadPoolExecutor(1, thread_name_prefix="blocking_write")
+        self._buf: list[bytes] = []
+        self._closing: Future[None] | None = None
+
+    def write(self, data: bytes) -> None:
+        if self._closing is not None:
+            raise ValueError('write to closed file')
+        if data:
+            self._buf.append(data)
+
+    async def drain(self) -> None:
+        if self._buf:
+            todo = tuple(self._buf)
+            self._buf.clear()
+            await self._loop.run_in_executor(self._pool, self._drain, todo)
+
+    def _drain(self, todo: tuple[bytes, ...]) -> None:
+        for data in todo:
+            self._fout.write(data)
+        self._fout.flush()
+
+    def close(self) -> None:
+        if self._closing is None:
+            self._closing = self._loop.run_in_executor(self._pool, self._fout.close)
+
+    async def wait_closed(self) -> None:
+        if self._closing is None:
+            raise ValueError('file not closed')
+        await self._closing
+
+    def is_closing(self) -> bool:
+        return self._closing is not None
+
+
+class ReadFilePump:
+    def __init__(
+        self,
+        fd: int,
+        *,
+        loop: AbstractEventLoop,
+        on_eof: Callable[[], None] = lambda: None,
+    ) -> None:
+        self._fd = fd
+        self._loop = loop
+        self.stream = asyncio.StreamReader(loop=loop)
+        self._on_eof = on_eof
+
+    def run(self) -> None:
+        try:
+            while True:
+                try:
+                    data = os.read(self._fd, io.DEFAULT_BUFFER_SIZE)
+                except KeyboardInterrupt as ex:
+                    nex = IOError('file read interrupted')
+                    nex.__cause__ = ex
+                    self._loop.call_soon_threadsafe(self.stream.set_exception, nex)
+                    return
+                if data:
+                    self._loop.call_soon_threadsafe(self.stream.feed_data, data)
+                else:
+                    self._loop.call_soon_threadsafe(self.stream.feed_eof)
+                    return
+        finally:
+            self._loop.call_soon_threadsafe(self._on_eof)

lspleanklib-0.1.1/lspleanklib/cli.py

@@ -0,0 +1,25 @@
+"""
+CLI common code
+"""
+
+
+def version() -> str:
+    try:
+        from ._version import version  # type: ignore[import-not-found, import-untyped, unused-ignore]
+
+        return str(version)
+    except ImportError:
+        return '0.0.0'
+
+
+def split_cmd_line(
+    cmd_line_args: list[str], default_extra_args: list[str] | None = None
+) -> tuple[list[str], list[str]]:
+    try:
+        cut = cmd_line_args.index('--')
+    except ValueError:
+        cut = len(cmd_line_args)
+    extra_args = cmd_line_args[cut + 1 :]
+    if default_extra_args is None:
+        default_extra_args = []
+    return (cmd_line_args[:cut], extra_args or default_extra_args)

lspleanklib-0.1.1/lspleanklib/jsonrpc.py

@@ -0,0 +1,332 @@
+"""
+JSON-RPC for Language Server Protocol
+"""
+
+from __future__ import annotations
+import asyncio, copy, enum, json, typing
+from asyncio import AbstractEventLoop, Future, TaskGroup
+from collections.abc import Awaitable, Mapping, Sequence
+from dataclasses import asdict, dataclass
+from typing import Any, TypeAlias
+from warnings import warn
+
+from .aio import DuplexStream, MinimalReader, MinimalWriter
+from .util import LspAny, LspObject, log
+
+
+class ErrorCode(enum.IntEnum):
+    UnknownErrorCode = -32001
+    ServerNotInitialized = -32002
+    InvalidRequest = -32600
+    MethodNotFound = -32601
+    InvalidParams = -32602
+    InternalError = -32603
+    RequestFailed = -32803
+
+
+ErrorCodes = ErrorCode  # in the LSP specification the name is unpythonic plural
+
+
+async def write_message(stream: MinimalWriter, msg: Mapping[str, Any]) -> None:
+    body = json.dumps(msg, separators=(',', ':')).encode()
+    header = f"Content-Length: {len(body)}\r\n\r\n".encode()
+    stream.write(header)
+    stream.write(body)
+    await stream.drain()
+
+
+async def read_message(stream: MinimalReader) -> dict[str, Any] | None:
+    body_length = 0
+    try:
+        while True:
+            line = await stream.readuntil()
+            key_val = line.split(b':', 2)
+            if len(key_val) == 2:
+                if key_val[0].lower() == b'content-length':
+                    body_length = int(key_val[1].strip())
+            else:
+                # end of header (empty line if correct LSP)
+                break
+        body = await stream.readexactly(body_length)
+        ret = json.loads(body)
+        if not isinstance(ret, dict):
+            raise ValueError("expecting JSON-RPC message to be JSON object")
+        return ret
+    except asyncio.exceptions.IncompleteReadError as ex:
+        if ex.partial:
+            raise ValueError("truncated stream input") from ex
+        return None
+
+
+MsgParams: TypeAlias = Sequence[LspAny] | Mapping[str, LspAny]
+
+
+@dataclass
+class MethodCall:
+    method: str
+    params: MsgParams | None = None
+
+    def to_lsp_obj(self) -> LspObject:
+        lobj: dict[str, LspAny] = {'method': self.method}
+        if self.params is not None:
+            lobj['params'] = copy.deepcopy(self.params)
+        return lobj
+
+
+@dataclass
+class ResponseError:
+    code: int
+    message: str
+    data: LspAny | None = None
+
+    @staticmethod
+    def from_lsp_obj(msg: LspObject) -> ResponseError:
+        code = msg.get('code')
+        if not isinstance(code, int):
+            code = ErrorCode.UnknownErrorCode
+        return ResponseError(code, str(msg.get('message')), msg.get('data'))
+
+
+async def awaitable_error(ec: ErrorCode) -> Response:
+    return Response.from_error_code(ec)
+
+
+@dataclass
+class Response:
+    result: LspAny
+    error: ResponseError | None = None
+
+    @staticmethod
+    def from_lsp_obj(msg: LspObject) -> Response:
+        error = msg.get('error')
+        if error is None:
+            return Response(msg.get('result'))
+        elif not isinstance(error, dict):
+            raise ValueError('LSP errors must be JSON objects')
+        else:
+            return Response(None, ResponseError.from_lsp_obj(error))
+
+    @staticmethod
+    def from_error_code(ec: ErrorCode) -> Response:
+        return Response(None, ResponseError(ec, ec.name))
+
+    def to_lsp_obj(self) -> LspObject:
+        if self.error:
+            return {'error': asdict(self.error)}
+        else:
+            return {'result': self.result}
+
+
+@dataclass
+class JsonRpcMsg:
+    payload: MethodCall | Response
+    id: int | str | None = None
+
+    @staticmethod
+    def from_jsonrpc(msg: LspObject) -> JsonRpcMsg:
+        if msg.get('jsonrpc') != '2.0':
+            raise ValueError('JSON object is not JSON-RPC 2.0 message')
+        msg_id = typing.cast(int | str | None, msg.get('id'))
+        method = msg.get('method')
+        if method is None:
+            return JsonRpcMsg(Response.from_lsp_obj(msg), msg_id)
+        elif not isinstance(method, str):
+            raise ValueError('LSP method names must be strings')
+        else:
+            params = typing.cast(MsgParams | None, msg.get('params'))
+            return JsonRpcMsg(MethodCall(method, params), msg_id)
+
+    def to_lsp_obj(self) -> LspObject:
+        ret: dict[str, LspAny] = {} if self.id is None else {'id': self.id}
+        ret.update(self.payload.to_lsp_obj())
+        ret['jsonrpc'] = '2.0'
+        return ret
+
+
+class IncommingResponses:
+    def __init__(self, loop: AbstractEventLoop) -> None:
+        self._loop = loop
+        self._todo: dict[int | str | None, Future[Response]] = {}
+        self.next_id = 1
+
+    def __bool__(self) -> bool:
+        return bool(self._todo)
+
+    def cancel_all(self) -> None:
+        while self._todo:
+            msg_id, expect = self._todo.popitem()
+            expect.cancel()
+
+    def prepare(self, fixed_id: str | None) -> tuple[int | str, Future[Response]]:
+        msg_id = self.next_id if fixed_id is None else fixed_id
+        if fixed_id is None:
+            self.next_id += 1
+        stale = self._todo.pop(msg_id, None)
+        if stale is not None:
+            warn(f"Response abandoned due to id reuse by new request: {msg_id}")
+            stale.cancel()
+        expect: Future[Response] = self._loop.create_future()
+        self._todo[msg_id] = expect
+        return (msg_id, expect)
+
+    def got_response(self, response: Response, msg_id: int | str | None) -> None:
+        expect = self._todo.pop(msg_id, None)
+        if expect:
+            expect.set_result(response)
+        else:
+            warn(f"Unexpected response with id: {msg_id}")
+
+
+class RpcMsgConnection(typing.Protocol):
+    async def close_and_wait(self) -> None: ...
+    async def write(self, msg: JsonRpcMsg) -> None: ...
+    async def read(self) -> JsonRpcMsg | None: ...
+
+
+class JsonRpcMsgStream(RpcMsgConnection):
+    def __init__(self, aio: DuplexStream):
+        self._aio = aio
+
+    async def close_and_wait(self) -> None:
+        self._aio.aout.close()
+        await self._aio.aout.wait_closed()
+
+    async def write(self, msg: JsonRpcMsg) -> None:
+        await write_message(self._aio.aout, msg.to_lsp_obj())
+
+    async def read(self) -> JsonRpcMsg | None:
+        while (msg := await read_message(self._aio.ain)) is not None:
+            try:
+                return JsonRpcMsg.from_jsonrpc(msg)
+            except ValueError as ex:
+                log.exception(ex)
+        return None
+
+
+class RpcInterface(typing.Protocol):
+    async def close_and_wait(self) -> None: ...
+    async def notify(self, mc: MethodCall) -> None: ...
+    async def request(
+        self, mc: MethodCall, fix_id: str | None = None
+    ) -> Awaitable[Response]: ...
+
+
+class RemoteRpcProxy(RpcInterface):
+    def __init__(self, conn: RpcMsgConnection, *, loop: AbstractEventLoop):
+        self._conn = conn
+        self._expecting: IncommingResponses | None = IncommingResponses(loop)
+
+    async def close_and_wait(self) -> None:
+        log.debug(f"closing {self.__class__.__name__}")
+        await self._conn.close_and_wait()
+
+    async def notify(self, mc: MethodCall) -> None:
+        msg = JsonRpcMsg(mc)
+        try:
+            await self._conn.write(msg)
+        except RuntimeError:
+            log.exception(f"Write failed for RPC call '{mc.method}'")
+
+    async def request(
+        self, mc: MethodCall, fix_id: str | None = None
+    ) -> Awaitable[Response]:
+        if self._expecting is None:
+            warn('request called on closed or closing RPC connection')
+            return awaitable_error(ErrorCode.InternalError)
+        (msg_id, expect) = self._expecting.prepare(fix_id)
+        try:
+            await self._conn.write(JsonRpcMsg(mc, msg_id))
+        except RuntimeError:
+            error_response = Response.from_error_code(ErrorCode.InternalError)
+            self._expecting.got_response(error_response, msg_id)
+            log.exception(f"Write failed for RPC call '{mc.method}'")
+        return expect
+
+    def got_response(self, response: Response, msg_id: int | str | None) -> None:
+        if self._expecting is None:
+            warn('RemoteRpcProxy.got_response called after end_of_incoming_responses')
+        else:
+            self._expecting.got_response(response, msg_id)
+
+    def end_of_incomming_responses(self) -> None:
+        if self._expecting:
+            self._expecting.cancel_all()
+            log.info("orphaned incoming responses cancelled")
+        self._expecting = None
+
+
+class RpcChannel(typing.Protocol):
+    @property
+    def proxy(self) -> RpcInterface: ...
+
+    async def pump(self, impl: RpcInterface | None = None) -> None: ...
+
+
+class NoClient(RpcInterface):
+    async def notify(self, mc: MethodCall) -> None:
+        warn(f"No client RPC implementation for '{mc.method}' notification")
+
+    async def request(
+        self, mc: MethodCall, fix_id: str | None = None
+    ) -> Awaitable[Response]:
+        warn(f"No client RPC implementation for '{mc.method}' request")
+        return awaitable_error(ErrorCode.MethodNotFound)
+
+    async def close_and_wait(self) -> None:
+        pass
+
+
+async def await_send_response(
+    conn: RpcMsgConnection, tbd: Awaitable[Response], msg_id: int | str | None
+) -> None:
+    try:
+        response = await tbd
+        await conn.write(JsonRpcMsg(response, msg_id))
+    except (asyncio.CancelledError, ValueError) as ex:
+        # writing to closed aout stream raises ValueError
+        log.exception(ex)
+
+
+class RpcMsgChannel(RpcChannel):
+    def __init__(self, conn: RpcMsgConnection, *, name: str, loop: AbstractEventLoop):
+        self._conn = conn
+        self._proxy = RemoteRpcProxy(conn, loop=loop)
+        self.name = name
+
+    @property
+    def proxy(self) -> RpcInterface:
+        return self._proxy
+
+    async def pump(self, impl: RpcInterface | None = None) -> None:
+        """Listen for JSONRPC message on connection input until stream EOF.
+
+        impl: implements the methods for RPC calls received on stream input
+        """
+        impl = impl or NoClient()
+        try:
+            async with TaskGroup() as response_tasks:
+                try:
+                    while (msg := await self._conn.read()) is not None:
+                        if isinstance(msg.payload, Response):
+                            self._proxy.got_response(msg.payload, msg.id)
+                        elif msg.id is None:
+                            await impl.notify(msg.payload)
+                        else:
+                            fix_id = msg.id if isinstance(msg.id, str) else None
+                            tbd = await impl.request(msg.payload, fix_id)
+                            coro = await_send_response(self._conn, tbd, msg.id)
+                            response_tasks.create_task(coro)
+                finally:
+                    await impl.close_and_wait()
+                    self._proxy.end_of_incomming_responses()
+                    log.debug(f"{self.name} pump done reading responses")
+        finally:
+            log.debug(f"{self.name} pump closing connection")
+            await self._conn.close_and_wait()
+
+
+def json_rpc_channel(
+    ain: MinimalReader, aout: MinimalWriter, *, name: str, loop: AbstractEventLoop
+) -> RpcMsgChannel:
+    stream = JsonRpcMsgStream(DuplexStream(ain, aout))
+    return RpcMsgChannel(stream, name=name, loop=loop)

lspleanklib-0.1.1/lspleanklib/lake.py

@@ -0,0 +1,87 @@
+"""
+Code for the Lake LSP server
+"""
+
+from collections.abc import Awaitable
+from pathlib import Path
+
+from .jsonrpc import (
+    ErrorCode,
+    MethodCall,
+    Response,
+    RpcChannel,
+    RpcInterface,
+    awaitable_error,
+)
+from .server import (
+    RpcDirChannelFactory,
+    leank_init_call,
+    leank_init_response,
+    text_doc_caps,
+)
+from .util import awaitable, get_uri_path
+
+
+class LakeClient(RpcInterface):
+    def __init__(self, leank_client: RpcInterface):
+        self.client = leank_client
+
+    async def close_and_wait(self) -> None:
+        await self.client.close_and_wait()
+
+    async def notify(self, mc: MethodCall) -> None:
+        await self.client.notify(mc)
+
+    async def request(
+        self, mc: MethodCall, fix_id: str | None = None
+    ) -> Awaitable[Response]:
+        if mc.method == "client/registerCapability":
+            return awaitable_error(ErrorCode.MethodNotFound)
+        return await self.client.request(mc, fix_id)
+
+
+class LeankServer(RpcInterface):
+    def __init__(self, lake_server: RpcInterface):
+        self._lake_server = lake_server
+
+    async def close_and_wait(self) -> None:
+        await self._lake_server.close_and_wait()
+
+    async def notify(self, mc: MethodCall) -> None:
+        await self._lake_server.notify(mc)
+
+    async def request(
+        self, mc: MethodCall, fix_id: str | None = None
+    ) -> Awaitable[Response]:
+        if mc.method != "initialized":
+            return await self._lake_server.request(mc)
+        else:
+            init_params = mc.params if isinstance(mc.params, dict) else {}
+            lsp_root = get_uri_path(init_params, 'rootUri')
+            init_call = leank_init_call(lsp_root, text_doc_caps(init_params))
+            aw_response = await self._lake_server.request(init_call)
+            response = await aw_response
+            return awaitable(leank_init_response(response))
+
+
+class LeankLakeChannel(RpcChannel):
+    def __init__(self, lake_channel: RpcChannel):
+        self._lake_channel = lake_channel
+        self._leank_server = LeankServer(lake_channel.proxy)
+
+    @property
+    def proxy(self) -> RpcInterface:
+        return self._leank_server
+
+    async def pump(self, leank_client: RpcInterface | None = None) -> None:
+        impl = None if leank_client is None else LakeClient(leank_client)
+        await self._lake_channel.pump(impl)
+
+
+class LeankLakeFactory(RpcDirChannelFactory):
+    def __init__(self, lake_factory: RpcDirChannelFactory):
+        self._lake_factory = lake_factory
+
+    async def anew(self, work_root: Path) -> RpcChannel:
+        lake_channel = await self._lake_factory.anew(work_root)
+        return LeankLakeChannel(lake_channel)