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

ldpy/debug.py

@@ -0,0 +1,235 @@
+"""Debugging .ldpy files (docs/explanation/tooling.md).
+
+Principle: NO DAP adapter to write. Two modes:
+
+- **direct** (`--run`, record ldpy/011): the .ldpy is compiled in source
+  coordinates (compile_mapped) and run IN this process. Started under
+  debugpy (by the VS Code extension: `python -m debugpy … -m ldpy.debug
+  --run f.ldpy`), breakpoints set in the .ldpy bind directly — no shadow,
+  no translation;
+- **shadow**: `ldpy.build` materialises a real Python file and its maps;
+  debugpy (or any Python tool) runs on it as it is
+  (`python -m ldpy.debug file.ldpy [--listen H:P] [-- args]`), and
+  `--breakpoints` translates .ldpy lines <-> shadow lines for tooling.
+
+The direct mode leaves three frames of THIS module below the user's own.
+`stepping_rules()` tells the debugger to ignore them (record vscode/103);
+`--probe` publishes them so the VS Code extension need not restate them.
+"""
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+
+from ldpy.build import build_file, DEFAULT_OUT
+from ldpy.transpiler import LdpySyntaxError, transpile
+from ldpy.transpiler.linemap import (LanguageMap, compile_mapped,
+                                     snap_breakpoint_line,
+                                     snap_breakpoint_lines)
+
+
+# ---------------------------------------------------------------------------
+# Stepping filters (record vscode/103)
+#
+# The invariant: every debugger stop selects a region of the .ldpy file.
+# Two things break it — the LAUNCHER frames (this module, below the user's)
+# and, when nobody asked for them, the RUNTIME ones (stepping into
+# `_ldpy_.graph(...)` lands in runtime.py). Both are settled by the protocol's
+# `rules`: pydevd reads them from the DAP `launch`/`attach` request (the
+# PYDEVD_FILTERS environment variable, on the other hand, is overwritten by
+# that request — measured, do not rely on it).
+#
+# The policy, in two tiers:
+#   - the launcher is ALWAYS hidden: it is plumbing, never code anyone
+#     wants to look at;
+#   - the rest of the package only under `justMyCode` (the default).
+#     `justMyCode: false` is the explicit request to see everything: a step
+#     in then descends into the runtime, which is the intended behaviour.
+# ---------------------------------------------------------------------------
+
+#: Modules that are only the launcher: never visible, whatever the mode.
+LAUNCHER_FILES = ("debug.py", "__main__.py")
+
+
+def package_dir():
+    """Directory of the installed ldpy package (the one running this code)."""
+    return os.path.dirname(os.path.abspath(__file__))
+
+
+def stepping_rules(just_my_code=True, package=None):
+    """The DAP `rules` that hold the invariant of record vscode/103.
+
+    Shape debugpy expects: a list of {"path": glob, "include": bool}, first
+    premier motif qui matche gagnant."""
+    pkg = package or package_dir()
+    rules = [{"path": os.path.join(pkg, name), "include": False}
+             for name in LAUNCHER_FILES]
+    if just_my_code:
+        rules.append({"path": os.path.join(pkg, "**"), "include": False})
+    return rules
+
+
+def probe():
+    """What a debug client needs in order to launch ldpy correctly.
+
+    The VS Code extension calls `python -m ldpy.debug --probe`: a single
+    process gives it proof that the package is importable, its version, and
+    the stepping rules — which thus stay described in ONE place."""
+    import ldpy
+    return {
+        "package": package_dir(),
+        "version": getattr(ldpy, "__version__", None),
+        "python": sys.executable,
+        "rules": {
+            "justMyCode": stepping_rules(True),
+            "all": stepping_rules(False),
+        },
+    }
+
+
+#: re-exported: debug tooling looks for them here (pure functions, defined
+#: alongside the map in ldpy/transpiler/linemap.py)
+__all__ = ["stepping_rules", "probe", "package_dir", "load_map",
+           "translate_breakpoints", "translate_frames",
+           "snap_breakpoint_line", "snap_breakpoint_lines",
+           "run_direct", "main"]
+
+
+def load_map(map_path):
+    """Load a LanguageMap from a .ldpy.map file (JSON)."""
+    with open(map_path, "r", encoding="utf-8") as f:
+        return LanguageMap.from_json(f.read())
+
+
+def translate_breakpoints(lmap, lines_1based):
+    """.ldpy breakpoint lines (1-based) -> shadow lines (1-based).
+
+    A line with no counterpart (a comment inside a collapsed island…) snaps
+    to the generated line of the region containing it, else None."""
+    out = []
+    for line in lines_1based:
+        pos = lmap.to_gen(line - 1, 0)
+        if pos is None:
+            # inside a multi-line island: snap to its start
+            for seg in lmap.segments:
+                if seg.src and seg.src[0] <= line - 1 <= seg.src[2]:
+                    pos = (seg.gen[0], seg.gen[1])
+                    break
+        out.append(pos[0] + 1 if pos else None)
+    return out
+
+
+def translate_frames(lmap, lines_1based):
+    """Shadow lines (1-based) -> .ldpy lines (1-based), for stack frames."""
+    out = []
+    for line in lines_1based:
+        src = lmap.src_line_for_gen_line(line - 1)
+        out.append(src + 1 if src is not None else None)
+    return out
+
+
+def run_direct(source_path, script_args):
+    """Direct mode: compile the .ldpy in source coordinates and run it right
+    here. Under debugpy, .ldpy breakpoints bind with no translation."""
+    import ldpy
+    src_path = os.path.abspath(source_path)
+    with open(src_path, "r", encoding="utf-8") as f:
+        source = f.read()
+    try:
+        result = transpile(source, src_path)
+    except LdpySyntaxError as e:
+        print(str(e), file=sys.stderr)
+        return 1
+    for w in result.warnings:
+        print(str(w), file=sys.stderr)
+    ldpy.install()
+    from ldpy.importer import MAPS
+    MAPS[src_path] = result.map
+    code = compile_mapped(result.code, result.map, src_path)
+    sys.argv = [src_path] + list(script_args)
+    g = {"__name__": "__main__", "__file__": src_path}
+    exec(code, g)
+    return 0
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(
+        prog="ldpy.debug",
+        description="Run a .ldpy in debuggable mode: --run (direct, source "
+                    "coordinates) or through its Python shadow, "
+                    "under debugpy when --listen is given.")
+    parser.add_argument("source", nargs="?", help="fichier .ldpy")
+    parser.add_argument("--run", action="store_true",
+                        help="run directly in this process, code compiled "
+                             "in .ldpy coordinates (for debugpy: breakpoints "
+                             "straight in the .ldpy)")
+    parser.add_argument("-o", "--out", default=DEFAULT_OUT,
+                        help="shadow directory (default: %(default)s)")
+    parser.add_argument("--listen", metavar="HOTE:PORT",
+                        help="start debugpy listening (e.g. 127.0.0.1:5678)")
+    parser.add_argument("--wait-for-client", action="store_true",
+                        help="wait for the debugger to attach before starting")
+    parser.add_argument("--probe", action="store_true",
+                        help="print {package, version, rules} as JSON and "
+                             "exit — for the VS Code extension")
+    parser.add_argument("--breakpoints", metavar="L1,L2,...",
+                        help=".ldpy lines: print their shadow lines "
+                             "(JSON) and exit — for tooling")
+    parser.add_argument("args", nargs="*",
+                        help="arguments passed to the script (after `--`)")
+    # argparse handles "--" poorly before a nargs="*": split it by hand
+    if argv is None:
+        argv = sys.argv[1:]
+    script_args = []
+    if "--" in argv:
+        cut = argv.index("--")
+        script_args = argv[cut + 1:]
+        argv = argv[:cut]
+    args = parser.parse_args(argv)
+    args.args = args.args + script_args
+
+    if args.probe:
+        print(json.dumps(probe()))
+        return 0
+    if not args.source:
+        parser.error("a .ldpy file is required")
+
+    if args.run:
+        return run_direct(args.source, args.args)
+
+    try:
+        py_path, map_path, result = build_file(
+            args.source, args.out,
+            rel=os.path.basename(args.source))
+    except LdpySyntaxError as e:
+        print(str(e), file=sys.stderr)
+        return 1
+    for w in result.warnings:
+        print(str(w), file=sys.stderr)
+
+    if args.breakpoints:
+        lines = [int(x) for x in args.breakpoints.split(",") if x.strip()]
+        print(json.dumps({
+            "shadow": py_path,
+            "map": map_path,
+            "breakpoints": dict(zip(
+                lines, translate_breakpoints(result.map, lines)))}))
+        return 0
+
+    cmd = [sys.executable]
+    if args.listen:
+        cmd += ["-m", "debugpy", "--listen", args.listen]
+        if args.wait_for_client:
+            cmd += ["--wait-for-client"]
+    cmd += [py_path] + args.args
+
+    env = dict(os.environ)
+    repo = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    env["PYTHONPATH"] = repo + os.pathsep + env.get("PYTHONPATH", "")
+    return subprocess.call(cmd, env=env)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

ldpy/formatter.py

@@ -0,0 +1,329 @@
+"""Formateur (pretty printer) des fichiers .ldpy — fiche ldpy/024.
+
+The principle is the highlighter's (record ldpy/023): **the formatter is the
+transpiler**. We transpile to get the language map, which says exactly where
+the islands are in the SOURCE; we replace each one with a stand-in that is
+valid Python in its place; we hand the result to `black`, which is the Python
+formatter; we put the islands back where the stand-ins landed.
+
+Two consequences serve as the contract, and are tested:
+
+- **host transparency** — a file with no island is formatted *exactly* as
+  `black` would format it. The formatter has no opinion about Python;
+- **the meaning does not move** — the AST of the transpiled Python is the
+  same before and after formatting. A formatter that changes what the
+  un formateur.
+
+What the formatter does TO THE ISLANDS is deliberately modest (the body is
+copied verbatim, only the edges are normalised): see record ldpy/024, section
+"what the formatter does not do".
+
+`black` is an OPTIONAL dependency (extra `[format]`): nothing in ldpy imports
+it outside this module, and its absence gives an actionable message.
+"""
+
+import argparse
+import os
+import re
+import sys
+
+from ldpy.transpiler import transpile
+
+DEFAULT_LINE_LENGTH = 88
+
+
+class FormatterUnavailable(RuntimeError):
+    """`black` is not installed in this interpreter."""
+
+
+def _black():
+    """The Python engine, loaded on demand.
+
+    The single coupling point: changing it (for ruff format, say) touches
+    this function and `_format_python`, nothing else."""
+    try:
+        import black
+    except ImportError as e:                                # pragma: no cover
+        raise FormatterUnavailable(
+            "the ldpy formatter delegates Python to black, which is not "
+            "installed — `pip install linked-data-python[format]`") from e
+    return black
+
+
+def _format_python(text, line_length):
+    black = _black()
+    return black.format_str(text, mode=black.Mode(line_length=line_length))
+
+
+# ---------------------------------------------------------------------------
+# Offsets: the map speaks in (line, column), text speaks in offsets
+# ---------------------------------------------------------------------------
+
+def _line_starts(text):
+    starts = [0]
+    for i, c in enumerate(text):
+        if c == "\n":
+            starts.append(i + 1)
+    return starts
+
+
+def _offset(starts, line, col):
+    return starts[line] + col
+
+
+# ---------------------------------------------------------------------------
+# Masking: a stand-in that is valid Python in place of each island
+# ---------------------------------------------------------------------------
+
+#: Islands sit in an expression or a statement position, except in two cases
+#: where the stand-in must carry the syntactic shape of the original so that
+#: `black` treats it the same (an import earns its blank line, a bare name
+def _substitute(kind, name):
+    if kind == "for-bindings":
+        # `for @bindings [as b] in` -> the matching loop header
+        return "for %s in" % name
+    if kind == "import":
+        # `from m import a, ex:, unit: as u:` -> une VRAIE instruction
+        # so that black handles the blank lines of the import block
+        return "import %s" % name
+    return name
+
+
+def _padded(name, text, line_length):
+    """Pad `name` so that the stand-in WEIGHS what the island weighs.
+
+    This is the masking doctrine of record ldpy/023: a stand-in of the same
+    length lets the delegated engine decide as it would have decided on the
+    real text. Here what is at stake is line breaking — a short stand-in
+    would make black believe everything fits on one line, and the island put
+    back would overflow.
+
+    A MULTI-LINE island cannot, by construction, fit on one line: we give it
+    a weight beyond the limit, which keeps the break the author wrote.
+    """
+    width = max(len(l) for l in text.split("\n"))
+    if "\n" in text:
+        width = max(width, line_length + 1)
+    return name + "_" * max(0, width - len(name))
+
+
+#: An island whose text is already valid Python and has nothing to mask: the
+#: ":" closing a `for @bindings in ... :`.
+_TRANSPARENT = ("for-bindings-close",)
+
+
+class _Island:
+    __slots__ = ("kind", "text", "column", "name", "substitute")
+
+    def __init__(self, kind, text, column, name, line_length):
+        self.kind = kind
+        self.text = text
+        self.column = column          # start column in the SOURCE
+        self.name = name
+        self.substitute = _substitute(kind, _padded(name, text, line_length))
+
+
+def _fresh_names(source, count):
+    """`count` identifiants uniques absents du source.
+
+    We prefix with `_L` and lengthen as long as a name appears in the text:
+    masking has to be reversible, so stand-ins must never collide with a name
+    of the user's."""
+    prefix = "_L"
+    while any(("%s%d" % (prefix, i)) in source for i in range(count)):
+        prefix += "_"
+    return ["%s%d" % (prefix, i) for i in range(count)]
+
+
+def _mask(source, lmap, line_length=DEFAULT_LINE_LENGTH):
+    """Returns (masked text, island list) — the masked text is Python."""
+    starts = _line_starts(source)
+    segments = [s for s in lmap.segments
+                if s.kind.startswith("island:") and s.src is not None
+                and s.kind[len("island:"):] not in _TRANSPARENT]
+    names = _fresh_names(source, len(segments))
+    out = []
+    islands = []
+    cursor = 0
+    for seg, name in zip(segments, names):
+        kind = seg.kind[len("island:"):]
+        a = _offset(starts, seg.src[0], seg.src[1])
+        b = _offset(starts, seg.src[2], seg.src[3])
+        if a < cursor:                       # nested island: already covered
+            continue
+        island = _Island(kind, source[a:b], seg.src[1], name, line_length)
+        out.append(source[cursor:a])
+        out.append(island.substitute)
+        islands.append(island)
+        cursor = b
+    out.append(source[cursor:])
+    return "".join(out), islands
+
+
+# ---------------------------------------------------------------------------
+# Island normalisation: the EDGES only (record ldpy/024)
+# ---------------------------------------------------------------------------
+
+_OPENER = re.compile(r"^[a-zA-Z+\-]?\{")
+#: `@prefix ex: <...> .` / `@base <...> .` — grammaire close, sans espace
+#: possible inside the terms, so it normalises without risk.
+_DECL = re.compile(r"^@(prefix|base)\s+((?:\S+:)\s+)?(<[^>\s]*>)\s*\.$")
+
+
+def _normalize_island(text):
+    """Normalise an island's edges, without touching its body.
+
+    What is taken in hand: trailing whitespace, the padding right after `{`
+    and right before `}`, and the declarations whose grammar is closed
+    (`@prefix`, `@base`, `@graph`, `@bindings`, prefix imports). The body of a
+    graph or a query is copied CHARACTER FOR CHARACTER: see record ldpy/024.
+    """
+    text = "\n".join(l.rstrip() for l in text.split("\n"))
+
+    m = _DECL.match(text)
+    if m:
+        pieces = ["@" + m.group(1)]
+        if m.group(2):
+            pieces.append(m.group(2).strip())
+        pieces += [m.group(3), "."]
+        return " ".join(pieces)
+
+    if text.startswith(("@graph", "@bindings", "from ")) \
+            and not re.search(r"[{}'\"]", text):
+        # no interpolation and no literal: the blanks there are only padding,
+        # and the comma of an import list normalises
+        text = re.sub(r"\s+", " ", text).strip()
+        return re.sub(r"\s*,\s*", ", ", text)
+
+    m = _OPENER.match(text)
+    if m and text.endswith("}") and len(text) > len(m.group(0)):
+        open_, body = m.group(0), text[len(m.group(0)):-1]
+        if not body.strip():
+            return open_ + " }"
+        first, *rest = body.split("\n")
+        if rest:
+            rest[-1] = rest[-1].rstrip()
+            body = "\n".join([" " + first.strip() if first.strip() else first]
+                             + rest)
+            return open_ + body + (" }" if rest[-1] else "}")
+        return open_ + " " + body.strip() + " }"
+    return text
+
+
+def _reindent(text, from_column, to_column):
+    """Shift the continuation lines of a multi-line island.
+
+    The shift preserves the alignment the author wanted; we never let it
+    jamais passer sous la colonne 0."""
+    if "\n" not in text or from_column == to_column:
+        return text
+    delta = to_column - from_column
+    first, *rest = text.split("\n")
+    if delta > 0:
+        rest = [(" " * delta + l) if l.strip() else l for l in rest]
+    else:
+        keep = min([len(l) - len(l.lstrip()) for l in rest if l.strip()],
+                   default=0)
+        cut = min(-delta, keep)
+        rest = [l[cut:] if l.strip() else l for l in rest]
+    return "\n".join([first] + rest)
+
+
+def _unmask(formatted, islands):
+    """Put each island back in place of its stand-in."""
+    for island in islands:
+        idx = formatted.find(island.substitute)
+        if idx < 0:                                        # pragma: no cover
+            raise RuntimeError(
+                "stand-in %r not found after formatting — please report this "
+                "file as a formatter defect" % island.substitute)
+        column = idx - formatted.rfind("\n", 0, idx) - 1
+        text = _reindent(_normalize_island(island.text),
+                         island.column, column)
+        formatted = (formatted[:idx] + text
+                     + formatted[idx + len(island.substitute):])
+    return formatted
+
+
+# ---------------------------------------------------------------------------
+# API
+# ---------------------------------------------------------------------------
+
+def format_source(source, filename="<ldpy>",
+                  line_length=DEFAULT_LINE_LENGTH):
+    """Format a .ldpy source and return the formatted text.
+
+    Raises `LdpySyntaxError` if the source does not transpile (we do not
+    format what we do not understand) and `FormatterUnavailable` if black is missing."""
+    result = transpile(source, filename)
+    masked, islands = _mask(source, result.map, line_length)
+    return _unmask(_format_python(masked, line_length), islands)
+
+
+def format_file(path, line_length=DEFAULT_LINE_LENGTH, write=False):
+    """Format one file; returns (formatted text, changed)."""
+    with open(path, "r", encoding="utf-8") as f:
+        source = f.read()
+    formatted = format_source(source, path, line_length)
+    changed = formatted != source
+    if write and changed:
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(formatted)
+    return formatted, changed
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(
+        prog="ldpy-format",
+        description="Format .ldpy files: black for the Python, edges "
+                    "normalised for the islands (record ldpy/024).")
+    parser.add_argument("paths", nargs="+",
+                        help=".ldpy files or directories to walk")
+    parser.add_argument("-l", "--line-length", type=int,
+                        default=DEFAULT_LINE_LENGTH,
+                        help="line length (default: %(default)s)")
+    parser.add_argument("--check", action="store_true",
+                        help="write nothing; exit 1 if a file is not "
+                             "formatted")
+    parser.add_argument("--diff", action="store_true",
+                        help="print the diff instead of writing")
+    args = parser.parse_args(sys.argv[1:] if argv is None else argv)
+
+    files = []
+    for p in args.paths:
+        if os.path.isdir(p):
+            for root, _, names in os.walk(p):
+                files += [os.path.join(root, n) for n in sorted(names)
+                          if n.endswith(".ldpy")]
+        else:
+            files.append(p)
+
+    from ldpy.transpiler import LdpySyntaxError
+    changed_any = False
+    status = 0
+    for path in files:
+        try:
+            formatted, changed = format_file(
+                path, args.line_length,
+                write=not (args.check or args.diff))
+        except (LdpySyntaxError, FormatterUnavailable) as e:
+            print("%s : %s" % (path, e), file=sys.stderr)
+            status = 2
+            continue
+        changed_any = changed_any or changed
+        if args.diff and changed:
+            import difflib
+            with open(path, encoding="utf-8") as f:
+                before = f.read()
+            sys.stdout.writelines(difflib.unified_diff(
+                before.splitlines(True), formatted.splitlines(True),
+                path, path + " (formatted)"))
+        elif changed:
+            print("reformatted %s" % path)
+    if args.check and changed_any:
+        return 1
+    return status
+
+
+if __name__ == "__main__":                                 # pragma: no cover
+    sys.exit(main())

ldpy/importer.py

@@ -0,0 +1,110 @@
+"""Import hook for .ldpy modules (standard importlib, no `ideas` package).
+
+Usage :
+    import ldpy ; ldpy.install()
+    import monmodule        # trouve monmodule.ldpy sur sys.path
+
+The .ldpy modules are compiled in SOURCE coordinates (compile_mapped,
+fiche ldpy/011) : tracebacks, pdb et debugpy pointent
+straight at the .ldpy lines. The LanguageMap of each imported module is
+kept in MAPS (key: path of the .ldpy file) for tooling."""
+
+import sys
+import os
+import importlib.abc
+import importlib.machinery
+import importlib.util
+
+from ldpy.transpiler import transpile
+
+MAPS = {}   # chemin .ldpy -> LanguageMap
+CODES = {}  # .ldpy path -> generated Python source
+
+
+class LdpyLoader(importlib.abc.SourceLoader):
+    """Loader for .ldpy modules: transpile, then compile the source."""
+
+    def __init__(self, fullname, path):
+        self.fullname = fullname
+        self.path = path
+
+    def get_filename(self, fullname):
+        """Path of the .ldpy file (importlib API)."""
+        return self.path
+
+    def get_data(self, path):
+        """Raw bytes of the source file (importlib API)."""
+        with open(path, "rb") as f:
+            return f.read()
+
+    def source_to_code(self, data, path, *, _optimize=-1):
+        """Transpile the ldpy source, then compile it in SOURCE
+        coordinates (compile_mapped, record ldpy/011): tracebacks, pdb and
+        debugpy point straight at the .ldpy lines. The LanguageMap is kept
+        for tooling."""
+        source = data.decode("utf-8") if isinstance(data, bytes) else data
+        result = transpile(source, path)
+        for w in result.warnings:
+            print(str(w), file=sys.stderr)
+        MAPS[path] = result.map
+        CODES[path] = result.code
+        from ldpy.transpiler.linemap import compile_mapped
+        return compile_mapped(result.code, result.map, path,
+                              dont_inherit=True, optimize=_optimize)
+
+
+class LdpyFinder(importlib.abc.MetaPathFinder):
+    """sys.meta_path finder: resolves `import mod` to `mod.ldpy`."""
+
+    def find_spec(self, fullname, path=None, target=None):
+        """Look for <name>.ldpy on sys.path (or on the package path)."""
+        name = fullname.rpartition(".")[2]
+        for entry in (path if path is not None else sys.path):
+            if not isinstance(entry, str):
+                continue
+            base = entry or "."
+            candidate = os.path.join(base, name + ".ldpy")
+            if os.path.isfile(candidate):
+                loader = LdpyLoader(fullname, candidate)
+                return importlib.util.spec_from_file_location(
+                    fullname, candidate, loader=loader)
+        return None
+
+
+_finder = None
+
+
+def install():
+    """Installe le finder .ldpy (idempotent)."""
+    global _finder
+    if _finder is None:
+        _finder = LdpyFinder()
+        sys.meta_path.append(_finder)
+    return _finder
+
+
+def uninstall():
+    """Remove the .ldpy finder from sys.meta_path."""
+    global _finder
+    if _finder is not None:
+        try:
+            sys.meta_path.remove(_finder)
+        except ValueError:
+            pass
+        _finder = None
+
+
+def translate_lineno(path, gen_line_1based):
+    """Generated line (1-based) -> .ldpy source line (1-based), or None."""
+    lmap = MAPS.get(path)
+    if lmap is None:
+        return None
+    src = lmap.src_line_for_gen_line(gen_line_1based - 1)
+    return None if src is None else src + 1
+
+
+def install_excepthook():
+    """OBSOLETE (kept for compatibility): since the remapped compilation
+    (record ldpy/011), code objects already carry the .ldpy line numbers —
+    tracebacks are right without rewriting. Does nothing."""
+    return sys.excepthook

ldpy/lsp/__init__.py

@@ -0,0 +1,11 @@
+"""Language server Linked-Data Python (architecture : docs/explanation/tooling.md).
+
+Milestone 2 (implemented): native transpiler diagnostics AND the backend's
+Python diagnostics re-projected, hover (islands natively, the rest delegated),
+semantic tokens for the islands, request forwarding to pylsp for completion,
+definition, references and signatureHelp — positions translated both ways
+through the LanguageMap.
+
+Lancement : python -m ldpy.lsp [--backend pylsp|none]
+(the server has no dependency; pylsp is optional, for delegation)
+"""

ldpy/lsp/__main__.py

@@ -0,0 +1,4 @@
+from ldpy.lsp.server import main
+
+if __name__ == "__main__":
+    main()