linked-data-python 0.0.4__py3-none-any.whl → 0.2.0__py3-none-any.whl

ldpy/lsp/backend.py

@@ -0,0 +1,118 @@
+"""Delegated Python backend: a real Python language server (pylsp) in a
+subprocess, to which the ldpy server forwards translated requests
+(request forwarding, NOT a fork).
+
+The backend only ever sees shadow documents: for every open .ldpy, a
+didOpen/didChange of the transpiled Python under the URI <uri>.shadow.py.
+"""
+
+import subprocess
+import sys
+import threading
+
+from ldpy.lsp.rpc import Endpoint, read_message, RpcClosed
+
+
+class PythonBackend:
+    """Lifecycle and delegation to `python -m pylsp` (or another argv)."""
+
+    def __init__(self, argv=None, root_uri=None):
+        self.argv = argv or [sys.executable, "-m", "pylsp"]
+        self.root_uri = root_uri
+        self.proc = None
+        self.endpoint = None
+        self.diagnostics_handler = None    # callable(uri_ombre, diagnostics)
+        self._reader = None
+
+    # -- cycle de vie -------------------------------------------------------
+
+    def start(self):
+        """Start the subprocess and do the initialize handshake."""
+        self.proc = subprocess.Popen(
+            self.argv, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL)
+        self.endpoint = Endpoint(self.proc.stdout, self.proc.stdin)
+        self._reader = threading.Thread(target=self._pump, daemon=True)
+        self._reader.start()
+        self.endpoint.request("initialize", {
+            "processId": None,
+            "rootUri": self.root_uri,
+            "capabilities": {"textDocument": {
+                "synchronization": {},
+                "completion": {"completionItem": {"snippetSupport": False}},
+                "hover": {"contentFormat": ["markdown", "plaintext"]},
+                "definition": {}, "references": {}, "signatureHelp": {},
+            }},
+        }, timeout=30.0)
+        self.endpoint.notify("initialized", {})
+        return self
+
+    def _pump(self):
+        try:
+            while True:
+                msg = read_message(self.endpoint.reader)
+                if "id" in msg and ("result" in msg or "error" in msg):
+                    self.endpoint.feed_response(msg)
+                elif msg.get("method") == "textDocument/publishDiagnostics":
+                    if self.diagnostics_handler:
+                        p = msg.get("params", {})
+                        self.diagnostics_handler(p.get("uri", ""),
+                                                 p.get("diagnostics", []))
+                elif "id" in msg:
+                    # server->client request (configuration…): empty answer
+                    self.endpoint.respond(msg["id"], result=None)
+        except (RpcClosed, ValueError, OSError):
+            pass
+
+    def stop(self):
+        """Clean stop (shutdown/exit), kill as a last resort."""
+        if not self.proc:
+            return
+        try:
+            self.endpoint.request("shutdown", {}, timeout=5.0)
+            self.endpoint.notify("exit")
+            self.proc.wait(timeout=5.0)
+        except Exception:
+            self.proc.kill()
+        self.proc = None
+
+    def alive(self):
+        """Is the backend subprocess still running?"""
+        return self.proc is not None and self.proc.poll() is None
+
+    # -- shadow documents ---------------------------------------------------
+
+    def open_shadow(self, uri, text, version=1):
+        """didOpen of the Python shadow document, on the backend."""
+        self.endpoint.notify("textDocument/didOpen", {"textDocument": {
+            "uri": uri, "languageId": "python",
+            "version": version, "text": text}})
+
+    def change_shadow(self, uri, text, version):
+        """didChange (full sync) of the shadow document."""
+        self.endpoint.notify("textDocument/didChange", {
+            "textDocument": {"uri": uri, "version": version},
+            "contentChanges": [{"text": text}]})
+
+    def close_shadow(self, uri):
+        """didClose of the shadow document."""
+        self.endpoint.notify("textDocument/didClose",
+                             {"textDocument": {"uri": uri}})
+
+    # -- requests -----------------------------------------------------------
+
+    def forward(self, method, params, timeout=15.0):
+        """Forward an already translated request; returns the raw result
+        (or raises the backend error)."""
+        resp = self.endpoint.request(method, params, timeout=timeout)
+        if "error" in resp:
+            raise BackendError(resp["error"])
+        return resp.get("result")
+
+
+class BackendError(Exception):
+    """A JSON-RPC error returned by the delegated backend."""
+
+    def __init__(self, error):
+        super().__init__(error.get("message", "erreur backend"))
+        self.error = error

ldpy/lsp/rpc.py

@@ -0,0 +1,104 @@
+"""JSON-RPC 2.0 over streams with Content-Length headers (the LSP framing).
+
+Used twice: on the server side (the editor's stdin/stdout) and on the client
+side (the pipes of the delegated Python backend). No dependency.
+"""
+
+import io
+import json
+import threading
+
+
+class RpcClosed(Exception):
+    """The JSON-RPC stream is over (EOF or a truncated body)."""
+
+
+def read_message(stream):
+    """Read one framed message; raises RpcClosed at end of stream."""
+    length = None
+    while True:
+        line = stream.readline()
+        if not line:
+            raise RpcClosed()
+        line = line.strip()
+        if not line:
+            break
+        if line.lower().startswith(b"content-length:"):
+            length = int(line.split(b":", 1)[1])
+    if length is None:
+        raise RpcClosed()
+    body = stream.read(length)
+    if len(body) < length:
+        raise RpcClosed()
+    return json.loads(body.decode("utf-8"))
+
+
+def write_message(stream, msg):
+    """Write a message with its Content-Length header."""
+    body = json.dumps(msg, ensure_ascii=False).encode("utf-8")
+    stream.write(b"Content-Length: %d\r\n\r\n" % len(body))
+    stream.write(body)
+    stream.flush()
+
+
+class Endpoint:
+    """A JSON-RPC endpoint: outgoing requests paired up, writes serialised.
+
+    Pumping incoming messages is the caller's job (the server loop) or a
+    reader thread's (the backend client)."""
+
+    def __init__(self, reader, writer):
+        self.reader = reader
+        self.writer = writer
+        self._wlock = threading.Lock()
+        self._next_id = 1
+        self._pending = {}          # id -> threading.Event + answer slot
+
+    def send(self, msg):
+        """Write a raw message (writes serialised by a lock)."""
+        with self._wlock:
+            write_message(self.writer, msg)
+
+    def notify(self, method, params=None):
+        """Send a notification (no id)."""
+        self.send({"jsonrpc": "2.0", "method": method,
+                   "params": params if params is not None else {}})
+
+    def request_async(self, method, params=None):
+        """Send a request; returns (id, event) — the answer will arrive
+        via feed_response()."""
+        with self._wlock:
+            rid = self._next_id
+            self._next_id += 1
+            slot = {"event": threading.Event(), "response": None}
+            self._pending[rid] = slot
+            write_message(self.writer, {"jsonrpc": "2.0", "id": rid,
+                                        "method": method,
+                                        "params": params if params is not None else {}})
+        return rid, slot
+
+    def request(self, method, params=None, timeout=15.0):
+        """Synchronous request (needs a thread pumping feed_response)."""
+        rid, slot = self.request_async(method, params)
+        if not slot["event"].wait(timeout):
+            self._pending.pop(rid, None)
+            raise TimeoutError("no answer to %s" % method)
+        return slot["response"]
+
+    def feed_response(self, msg):
+        """Call this for every incoming message carrying a response id."""
+        slot = self._pending.pop(msg.get("id"), None)
+        if slot is not None:
+            slot["response"] = msg
+            slot["event"].set()
+            return True
+        return False
+
+    def respond(self, rid, result=None, error=None):
+        """Answer the incoming request with id ``rid``."""
+        msg = {"jsonrpc": "2.0", "id": rid}
+        if error is not None:
+            msg["error"] = error
+        else:
+            msg["result"] = result
+        self.send(msg)

ldpy/lsp/server.py

@@ -0,0 +1,353 @@
+"""Serveur LSP Linked-Data Python — mince, par request-forwarding.
+
+Architecture (voir docs/explanation/tooling.md) :
+
+- ZERO dependency: home-made JSON-RPC/framing (ldpy/lsp/rpc.py), no pygls.
+- NATIVE layer: transpiler diagnostics (errors + scope warnings), hover on
+  the islands, semantic tokens for the islands (a precise complement to the
+  coloration TextMate, docs/how-to/use-vscode.md).
+- DELEGATED layer: for every .ldpy, a Python shadow document is kept up to
+  date on a REAL Python language server (pylsp, subprocess, not forked);
+  completion, definition, references, signatureHelp — and hover outside an
+  island — are forwarded to it with positions translated through the
+  LanguageMap, answers translated back (shadow URIs in Locations included).
+  Without pylsp installed, the server works in native-only mode.
+
+Lancement : python -m ldpy.lsp [--backend pylsp|none]
+"""
+
+import sys
+
+from ldpy.transpiler import transpile, LdpySyntaxError
+from ldpy.lsp.rpc import Endpoint, read_message, RpcClosed
+from ldpy.lsp import translate as tr
+from ldpy.transpiler.linemap import snap_breakpoint_lines
+
+
+def fmt_default():
+    """Default line length, without importing black."""
+    from ldpy.formatter import DEFAULT_LINE_LENGTH
+    return DEFAULT_LINE_LENGTH
+
+FORWARDED = {
+    "textDocument/completion",
+    "textDocument/definition",
+    "textDocument/references",
+    "textDocument/signatureHelp",
+    "textDocument/documentHighlight",
+}
+
+
+class Document:
+    """An open .ldpy document: text, version, transpilation result."""
+
+    __slots__ = ("uri", "text", "version", "result",
+                 "native_diags", "py_diags")
+
+    def __init__(self, uri, text, version):
+        self.uri = uri
+        self.text = text
+        self.version = version
+        self.result = None          # TranspileResult, or None on error
+        self.native_diags = []      # diagnostics du transpileur
+        self.py_diags = []          # backend diagnostics, already translated
+
+
+class LdpyServer:
+    """The language server: native layer plus delegation to the Python backend."""
+
+    def __init__(self, reader, writer, backend="pylsp", backend_argv=None,
+                 line_length=None):
+        self.endpoint = Endpoint(reader, writer)
+        self.docs = {}              # uri -> Document
+        self.backend_kind = backend
+        self.backend_argv = backend_argv
+        self.backend = None
+        self.line_length = line_length
+        self._shutdown = False
+
+    # ------------------------------------------------------------ backend
+
+    def _ensure_backend(self, root_uri=None):
+        if self.backend is not None or self.backend_kind == "none":
+            return self.backend
+        try:
+            from ldpy.lsp.backend import PythonBackend
+            self.backend = PythonBackend(argv=self.backend_argv,
+                                         root_uri=root_uri).start()
+            self.backend.diagnostics_handler = self._on_backend_diags
+        except Exception as e:
+            print("ldpy-lsp: backend indisponible (%s) — mode natif seul" % e,
+                  file=sys.stderr)
+            self.backend_kind = "none"
+        return self.backend
+
+    # ---------------------------------------------------------- documents
+
+    def _maps_by_uri(self):
+        return {u: d.result.map for u, d in self.docs.items() if d.result}
+
+    def _sync(self, doc, opened):
+        """Transpile, publish the diagnostics, sync the shadow."""
+        diags = []
+        try:
+            doc.result = transpile(doc.text, doc.uri)
+        except LdpySyntaxError as e:
+            doc.result = None
+            diags.append({
+                "range": {"start": {"line": e.line, "character": e.col},
+                          "end": {"line": e.line, "character": e.col + 1}},
+                "severity": 1, "source": "ldpy", "message": e.msg})
+        else:
+            for w in doc.result.warnings:
+                diags.append({
+                    "range": {"start": {"line": w.line, "character": w.col},
+                              "end": {"line": w.line, "character": w.col + 1}},
+                    "severity": 2, "source": "ldpy", "message": w.message})
+        doc.native_diags = diags
+        if doc.result is None:
+            doc.py_diags = []
+        self._publish(doc)
+        if doc.result and self.backend:
+            su = tr.shadow_uri(doc.uri)
+            if opened:
+                self.backend.open_shadow(su, doc.result.code, doc.version)
+            else:
+                self.backend.change_shadow(su, doc.result.code, doc.version)
+
+    def _publish(self, doc):
+        self.endpoint.notify(
+            "textDocument/publishDiagnostics",
+            {"uri": doc.uri,
+             "diagnostics": doc.native_diags + doc.py_diags})
+
+    def _on_backend_diags(self, shadow, diags):
+        """The backend's Python diagnostics, re-projected onto the .ldpy.
+        Those landing on synthetic text (the prelude) are dropped."""
+        doc = self.docs.get(tr.unshadow_uri(shadow))
+        if doc is None or doc.result is None:
+            return
+        lmap = doc.result.map
+        kept = []
+        for d in diags:
+            rng = d.get("range", {})
+            start = tr.pos_to_ldpy(lmap, rng.get("start", {}))
+            if start is None:
+                continue                     # prelude, or off the map
+            end = tr.pos_to_ldpy(lmap, rng.get("end", {})) or start
+            d = dict(d, range={"start": start, "end": end},
+                     source=d.get("source") or "python")
+            kept.append(d)
+        doc.py_diags = kept
+        self._publish(doc)
+
+    # ------------------------------------------------------------- boucle
+
+    def serve(self):
+        """Main loop: read stdin, dispatch, answer; leave on exit."""
+        while True:
+            try:
+                msg = read_message(self.endpoint.reader)
+            except RpcClosed:
+                break
+            if "id" in msg and ("result" in msg or "error" in msg):
+                self.endpoint.feed_response(msg)
+                continue
+            method = msg.get("method", "")
+            rid = msg.get("id")
+            params = msg.get("params") or {}
+            try:
+                if method == "exit":
+                    break
+                result = self._dispatch(method, params, rid)
+                if rid is not None:
+                    self.endpoint.respond(rid, result=result)
+            except Exception as e:                       # jamais fatal
+                if rid is not None:
+                    self.endpoint.respond(
+                        rid, error={"code": -32603, "message": str(e)})
+        if self.backend:
+            self.backend.stop()
+
+    # ------------------------------------------------------------ dispatch
+
+    def _dispatch(self, method, params, rid):
+        if method == "initialize":
+            self._ensure_backend(params.get("rootUri"))
+            return {
+                "capabilities": {
+                    "textDocumentSync": 1,               # complet
+                    "hoverProvider": True,
+                    "completionProvider": {
+                        "triggerCharacters": [".", ":", "<", "?", "/"]},
+                    "definitionProvider": True,
+                    "documentFormattingProvider": self._can_format(),
+                    "referencesProvider": True,
+                    "signatureHelpProvider": {
+                        "triggerCharacters": ["(", ","]},
+                    "semanticTokensProvider": {
+                        "legend": {"tokenTypes": tr.TOKEN_TYPES,
+                                   "tokenModifiers": []},
+                        "full": True},
+                    # our own extension, announced so the client can detect
+                    # it instead of assuming it (record vscode/103)
+                    "experimental": {"ldpyBreakpointLines": True},
+                },
+                "serverInfo": {"name": "ldpy-lsp", "version": "0.2.0"},
+            }
+        if method in ("initialized", "workspace/didChangeConfiguration",
+                      "$/setTrace", "$/cancelRequest"):
+            return None
+        if method == "shutdown":
+            self._shutdown = True
+            return None
+
+        if method == "textDocument/didOpen":
+            td = params["textDocument"]
+            doc = Document(td["uri"], td["text"], td.get("version", 1))
+            self.docs[doc.uri] = doc
+            self._sync(doc, opened=True)
+            return None
+        if method == "textDocument/didChange":
+            td = params["textDocument"]
+            doc = self.docs.get(td["uri"])
+            if doc is None:
+                return None
+            doc.text = params["contentChanges"][-1]["text"]
+            doc.version = td.get("version", doc.version + 1)
+            self._sync(doc, opened=False)
+            return None
+        if method == "textDocument/didClose":
+            uri = params["textDocument"]["uri"]
+            self.docs.pop(uri, None)
+            if self.backend:
+                self.backend.close_shadow(tr.shadow_uri(uri))
+            self.endpoint.notify("textDocument/publishDiagnostics",
+                                 {"uri": uri, "diagnostics": []})
+            return None
+
+        if method == "textDocument/formatting":
+            return self._format(params)
+
+        if method == "ldpy/breakpointLines":
+            # Snap breakpoint lines onto those that really bind (inside a
+            # multi-line island -> the island's first line). The extension
+            # then moves the dot, instead of leaving the user with a
+            # breakpoint that never fires.
+            lines = list(params.get("lines") or [])
+            doc = self.docs.get(params["textDocument"]["uri"])
+            if doc is None or doc.result is None:
+                return {"lines": lines}
+            return {"lines": snap_breakpoint_lines(doc.result.map, lines)}
+
+        if method == "textDocument/semanticTokens/full":
+            doc = self.docs.get(params["textDocument"]["uri"])
+            if doc is None or doc.result is None:
+                return {"data": []}
+            return {"data": tr.semantic_tokens(doc.result.map)}
+
+        if method == "textDocument/hover":
+            return self._hover(params)
+
+        if method in FORWARDED:
+            return self._forward(method, params)
+
+        if rid is not None:
+            return None
+        return None
+
+    # ------------------------------------------------------------- natives
+
+    def _can_format(self):
+        """The formatter delegates Python to black (extra `[format]`): we
+        only announce the capability when it is actually available."""
+        try:
+            from ldpy.formatter import _black
+            _black()
+            return True
+        except Exception:
+            return False
+
+    def _format(self, params):
+        """`textDocument/formatting`: one edit replacing everything.
+
+        A faulty document is not formatted — we then return NO edit rather
+        than invented text; the diagnostics already say why."""
+        doc = self.docs.get(params["textDocument"]["uri"])
+        if doc is None:
+            return None
+        from ldpy.formatter import format_source, FormatterUnavailable
+        opts = params.get("options") or {}
+        width = (self.line_length
+                 or opts.get("ldpyLineLength")
+                 or fmt_default())
+        try:
+            new = format_source(doc.text, doc.uri, int(width))
+        except (LdpySyntaxError, FormatterUnavailable):
+            return None
+        if new == doc.text:
+            return []
+        lines = doc.text.split("\n")
+        end = {"line": len(lines) - 1, "character": len(lines[-1])}
+        return [{"range": {"start": {"line": 0, "character": 0}, "end": end},
+                 "newText": new}]
+
+    def _hover(self, params):
+        doc = self.docs.get(params["textDocument"]["uri"])
+        if doc is None or doc.result is None:
+            return None
+        pos = params["position"]
+        seg = tr.island_at(doc.result.map, pos["line"], pos["character"])
+        if seg is not None:
+            gl0, gc0, gl1, gc1 = seg.gen
+            lines = doc.result.code.split("\n")[gl0:gl1 + 1]
+            if len(lines) == 1:
+                excerpt = lines[0][gc0:gc1]
+            else:
+                lines[0] = lines[0][gc0:]
+                lines[-1] = lines[-1][:gc1]
+                excerpt = "\n".join(lines)
+            sl0, sc0, sl1, sc1 = seg.src
+            return {"contents": {"kind": "markdown", "value":
+                    "**%s island**\n```python\n%s\n```" % (
+                        seg.kind.split(":", 1)[1], excerpt)},
+                    "range": {"start": {"line": sl0, "character": sc0},
+                              "end": {"line": sl1, "character": sc1}}}
+        return self._forward("textDocument/hover", params)
+
+    # --------------------------------------------------------- delegation
+
+    def _forward(self, method, params):
+        doc = self.docs.get(params.get("textDocument", {}).get("uri", ""))
+        if doc is None or doc.result is None or not self.backend \
+                or not self.backend.alive():
+            return None
+        lmap = doc.result.map
+        fwd = dict(params)
+        fwd["textDocument"] = {"uri": tr.shadow_uri(doc.uri)}
+        if "position" in params:
+            p = tr.pos_to_py(lmap, params["position"])
+            if p is None:
+                return None
+            fwd["position"] = p
+        raw = self.backend.forward(method, fwd)
+        return tr.translate_result(raw, lmap, self._maps_by_uri())
+
+
+def main(argv=None):
+    import argparse
+    parser = argparse.ArgumentParser(prog="ldpy.lsp")
+    parser.add_argument("--backend", default="pylsp",
+                        choices=["pylsp", "none"],
+                        help="delegated Python server (default: pylsp)")
+    parser.add_argument("--line-length", type=int, default=None,
+                        help="formatter line length "
+                             "(default: black's own)")
+    args = parser.parse_args(argv)
+    server = LdpyServer(sys.stdin.buffer, sys.stdout.buffer,
+                        backend=args.backend, line_length=args.line_length)
+    server.serve()
+
+
+if __name__ == "__main__":
+    main()