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

ldpy/__init__.py

@@ -11,7 +11,19 @@ package but is no longer imported by default.
 from ldpy.transpiler import transpile, LdpySyntaxError, LdpyWarning
 from ldpy.importer import install, uninstall, install_excepthook
 
-__version__ = "0.1.0.dev0"
+#: Read from the installed distribution rather than written here: two copies
+#: of a version number drift, and this one had — a 0.2.0 install announced
+#: itself as 0.1.0.dev0 in the editor status bar. The fallback covers a source
+#: tree that was never installed.
+try:
+    from importlib.metadata import PackageNotFoundError, version as _version
+    try:
+        __version__ = _version("linked-data-python")
+    except PackageNotFoundError:                      # pragma: no cover
+        __version__ = "0.0.0+unknown"
+    del _version, PackageNotFoundError
+except ImportError:                                   # pragma: no cover
+    __version__ = "0.0.0+unknown"
 __date__ = "2026-08-26"
 
 

ldpy/debug.py

@@ -211,9 +211,13 @@ def main(argv=None):
 
     if args.breakpoints:
         lines = [int(x) for x in args.breakpoints.split(",") if x.strip()]
+        # ABSOLUTE paths: this output crosses a process boundary, and a
+        # relative path means nothing to a reader that does not share our
+        # working directory. An editor turning ".ldpy-build/x.py" into a URI
+        # gets "/.ldpy-build/x.py", rooted at the filesystem root.
         print(json.dumps({
-            "shadow": py_path,
-            "map": map_path,
+            "shadow": os.path.abspath(py_path),
+            "map": os.path.abspath(map_path),
             "breakpoints": dict(zip(
                 lines, translate_breakpoints(result.map, lines)))}))
         return 0

ldpy/lsp/backend.py

@@ -12,6 +12,18 @@ import threading
 
 from ldpy.lsp.rpc import Endpoint, read_message, RpcClosed
 
+#: The backend judges GENERATED code. Style findings (line length, blank
+#: lines, continuation indents, semicolons…) describe the transpiler's
+#: output, not the user's source; re-projected onto the .ldpy they underline
+#: whole islands (record vscode/107). The shadow therefore opts out of every
+#: style plugin; semantic analyses (pyflakes' undefined names, unused
+#: imports) stay on.
+STYLE_PLUGINS = ("autopep8", "flake8", "mccabe", "pycodestyle",
+                 "pydocstyle", "pylint", "yapf")
+
+SHADOW_SETTINGS = {"pylsp": {"plugins": {
+    name: {"enabled": False} for name in STYLE_PLUGINS}}}
+
 
 class PythonBackend:
     """Lifecycle and delegation to `python -m pylsp` (or another argv)."""
@@ -45,6 +57,8 @@ class PythonBackend:
             }},
         }, timeout=30.0)
         self.endpoint.notify("initialized", {})
+        self.endpoint.notify("workspace/didChangeConfiguration",
+                             {"settings": SHADOW_SETTINGS})
         return self
 
     def _pump(self):

ldpy/lsp/hover.py

@@ -0,0 +1,62 @@
+"""Rendering the hover panel — record vscode/108.
+
+Three blocks separated by rules, in the shape Python tooling has taught
+people to read: a signature line, the description with a link to the
+documentation, and the Python the transpiler produced. The translation can
+be turned off (`ldpy.hover.showTranslation`); the first two blocks are what
+tells you *what you are looking at*, so they always show.
+
+Kept apart from `server.py`: rendering is a function of strings, and it is
+tested as one.
+"""
+
+from ldpy.lsp import islanddoc
+
+RULE = "\n\n---\n\n"
+
+
+def format_python(code, line_length=88):
+    """`code` through black, or unchanged when black cannot take it.
+
+    What a hover shows is a FRAGMENT: the expression one term became, or the
+    head of a statement the source splits in two (`for @bindings in`). Those
+    are not modules, and black rightly refuses them. Showing the generated
+    text as it stands beats showing nothing, so a refusal is silent.
+
+    black normalises what it accepts — quotes above all — so the block is the
+    translation *formatted*, not a byte-for-byte extract of the generated
+    file. `ldpy -t` remains the place to read that.
+    """
+    code = code.strip()
+    if not code:
+        return code
+    try:
+        import black
+    except ImportError:                                   # pragma: no cover
+        return code
+    try:
+        return black.format_str(
+            code, mode=black.Mode(line_length=line_length)).rstrip("\n")
+    except Exception:
+        return code
+
+
+def render(kind, code, line_length=88, show_translation=True):
+    """The markdown of a hover over an island element.
+
+    `kind` is an island kind (with or without the `island:` prefix), `code`
+    the Python it became. An unknown kind still renders: the table can lag
+    the transpiler by a commit, and a hover must degrade rather than vanish.
+    """
+    doc = islanddoc.get(kind)
+    blocks = []
+    if doc is None:
+        short = kind[len("island:"):] if kind.startswith("island:") else kind
+        blocks.append("```ldpy\n(%s island)\n```" % short)
+    else:
+        blocks.append("```ldpy\n%s\n```" % doc.signature)
+        blocks.append("%s [Documentation](%s)" % (doc.summary, doc.url))
+    if show_translation and code and code.strip():
+        blocks.append("```python\n%s\n```"
+                      % format_python(code, line_length))
+    return RULE.join(blocks)

ldpy/lsp/islanddoc.py

@@ -0,0 +1,215 @@
+"""What each island IS, in the three lines a hover shows — record vscode/108.
+
+Per island kind: a signature line in the shape Python tooling uses, a short
+prose description, and the documentation page (with anchor) that explains it.
+Nothing here knows about LSP; `server.py` renders it, `pygments_lexer.py` and
+the semantic tokens name the same kinds.
+
+The table is CLOSED: `tests/test_islanddoc.py` fails when the transpiler grows
+a kind with no entry here, and when an anchor no longer exists under `docs/`.
+That second test is what keeps the links from rotting silently — a dead link
+in a hover is worse than no link, because nothing ever reports it.
+"""
+
+DOCS = "https://linked-data-python.readthedocs.io/en/latest/"
+
+
+class IslandDoc:
+    """Signature, description and documentation target of one island kind."""
+
+    __slots__ = ("signature", "summary", "page", "anchor")
+
+    def __init__(self, signature, summary, page, anchor):
+        self.signature = signature
+        self.summary = summary
+        self.page = page            # path under docs/, with the .md suffix
+        self.anchor = anchor
+
+    @property
+    def url(self):
+        """The published URL — mkdocs serves `x/y.md` as `x/y/`."""
+        return "%s%s/#%s" % (DOCS, self.page[:-len(".md")], self.anchor)
+
+
+_TERMS = "reference/language/terms.md"
+_DECLS = "reference/language/declarations.md"
+_GRAPHS = "reference/language/graphs.md"
+_CURRENT = "reference/language/current-graph.md"
+_QUERY = "reference/language/querying.md"
+_BINDINGS = "reference/language/bindings.md"
+_SPARQL_EXPR = "reference/sparql-expressions.md"
+
+
+ISLANDS = {
+
+    # -- declarations -------------------------------------------------------
+
+    "prefix": IslandDoc(
+        "(declaration) @prefix ex: <IRI> .",
+        "Binds `ex:` to a namespace IRI for the rest of the enclosing block. "
+        "A prefix is lexical: it has no run-time object, and `ex:` on its own "
+        "is never a value. Declaring it again in a deeper block shadows it, "
+        "the way a Python name would.",
+        _DECLS, "prefix-bind-a-prefix"),
+
+    "base": IslandDoc(
+        "(declaration) @base <IRI> .",
+        "Sets the base against which relative IRIs are resolved for the rest "
+        "of the block, so that `<sensor/1>` means `<IRI>sensor/1`.",
+        _DECLS, "base-set-the-base-iri"),
+
+    "import": IslandDoc(
+        "(declaration) from MODULE import ex:, unit: as u:",
+        "Imports prefixes declared by another module, optionally renaming "
+        "them. The module is imported as usual; what travels is the prefix "
+        "bindings, which have no value to import by ordinary means.",
+        _DECLS, "prefixes-across-modules"),
+
+    "graph-decl": IslandDoc(
+        "(declaration) @graph EXPR | @graph as NAME -> Graph",
+        "Designates the current graph for the block — the one `+{ }`, `-{ }` "
+        "and a receiver-less `m{ }` act on. `as NAME` creates a fresh graph "
+        "and binds it to NAME; `global` and `nonlocal` widen the scope.",
+        _CURRENT, "graph-designate-or-create"),
+
+    "bindings-decl": IslandDoc(
+        "(declaration) @bindings EXPR | @bindings as NAME -> Bindings",
+        "Designates the current bindings: the mapping that gives `?name` its "
+        "value in the enclosing block. Any mapping will do, and `as NAME` "
+        "creates an empty one.",
+        _BINDINGS, "bindings-the-current-bindings"),
+
+    "for-bindings": IslandDoc(
+        "(statement) for @bindings [as NAME] in ITER:",
+        "Loops over an iterable of mappings, making each row the current "
+        "bindings for the body. A `csv.DictReader` and the solutions of "
+        "`m{ }` are both iterables of mappings, so both drive this loop.",
+        _BINDINGS, "for-bindings-in-iter-the-loop-that-carries-them"),
+
+    "for-bindings-close": IslandDoc(
+        "(statement) the ':' closing a for @bindings header",
+        "The end of a `for @bindings` header. It is mapped on its own "
+        "because the header is rewritten in two pieces, around the iterable "
+        "that stays verbatim Python.",
+        _BINDINGS, "for-bindings-in-iter-the-loop-that-carries-them"),
+
+    # -- graphs and the current graph ---------------------------------------
+
+    "graph": IslandDoc(
+        "(expression) g{ ... } -> Graph",
+        "Builds an RDF graph from Turtle written in place. `{expr}` "
+        "interpolates a Python value in term position, and each occurrence "
+        "is evaluated once. The braces are an expression, so a `g{ }` goes "
+        "anywhere a value goes — a default argument, a comprehension, a "
+        "return.",
+        _GRAPHS, "turtle-inside-the-braces"),
+
+    "addto": IslandDoc(
+        "(statement) +{ ... } [ (GRAPH) ]",
+        "Adds the triples to the current graph. `?name` takes its value from "
+        "the current bindings, and a triple with an unbound variable is "
+        "dropped rather than written half-way. A trailing `(g)` names "
+        "another receiver.",
+        _CURRENT, "and-write-to-it"),
+
+    "removefrom": IslandDoc(
+        "(statement) -{ ... } [ (GRAPH) ]",
+        "Removes from the current graph every triple matching the pattern. "
+        "An unbound variable is a wildcard here, not a hole: this is a "
+        "SPARQL `DELETE WHERE`, not a list of triples to subtract.",
+        _CURRENT, "and-write-to-it"),
+
+    # -- reading ------------------------------------------------------------
+
+    "match": IslandDoc(
+        "(expression) m{ ... } -> Solutions",
+        "Matches a basic graph pattern against the current graph, lazily. "
+        "Iterating yields a bare term when one variable is projected and a "
+        "tuple otherwise; `.one()`, `.first()`, `.count()` and `bool()` are "
+        "the usual reductions. A `(graph)` suffix names another source.",
+        _QUERY, "m-match-a-basic-graph-pattern"),
+
+    "sparql": IslandDoc(
+        "(expression) s{ ... } -> Query",
+        "A SPARQL query or update, parsed when the file is transpiled rather "
+        "than at run time. `{expr}` in term position becomes an initial "
+        "binding — never string pasting, so nothing here can be injected. "
+        "Call it on a graph to run it; `.execute()` runs an update.",
+        _QUERY, "s-a-sparql-query"),
+
+    # -- terms --------------------------------------------------------------
+
+    "iri": IslandDoc(
+        "(term) <IRI> -> URIRef",
+        "An absolute IRI, or a relative one resolved against the `@base` in "
+        "scope.",
+        _TERMS, "iris"),
+
+    "pname": IslandDoc(
+        "(term) ex:local -> URIRef",
+        "A prefixed name: the local part is appended to the IRI bound to "
+        "`ex:`. Turtle's character set applies inside an island, so "
+        "`o-pizza:topping` and `ex:café` are names here although neither is "
+        "a legal Python expression. `ex:{expr}` computes the local part.",
+        _TERMS, "prefixed-names-exlocal"),
+
+    "literal": IslandDoc(
+        "(term) \"...\"@lang | \"...\"^^dt -> Literal",
+        "An RDF literal carrying a language tag or a datatype. The quoted "
+        "part may be an f-string, and `{expr}` may supply the datatype "
+        "itself.",
+        _TERMS, "rdf-literals-lang-dt"),
+
+    "var": IslandDoc(
+        "(term) ?name | $name -> Variable",
+        "A SPARQL variable. In a pattern it is what gets matched and "
+        "projected; in `g{ }` or `+{ }` it takes its value from the current "
+        "bindings, and leaves the triple out when it has none.",
+        _TERMS, "variables-name-name"),
+
+    "firi": IslandDoc(
+        "(term) f<...{expr}...> -> URIRef",
+        "A formatted IRI: the braces interpolate as in an f-string, the "
+        "result is percent-encoded and then resolved against `@base`. "
+        "Encoding first is what keeps a space or a slash in a value from "
+        "changing the IRI's structure.",
+        _TERMS, "formatted-iris-f"),
+
+    "fnode": IslandDoc(
+        "(term) f{expr} | ?{expr} -> Node",
+        "Coerces any Python value into an RDF term, by the coercion policy "
+        "in scope. Two spellings of one operation: `?{ }` reads better in "
+        "term position, `f{ }` beside `f<...>`.",
+        _TERMS, "formatted-nodes-fexpr-expr"),
+
+    "bnode": IslandDoc(
+        "(term) _:{expr} -> BNode",
+        "A blank node whose identity is its data: the same value gives the "
+        "same node anywhere in the program, so two rows that share a key "
+        "join without inventing an IRI for them.",
+        _GRAPHS, "data-keyed-blank-nodes-_expr"),
+
+    # -- deferred evaluation ------------------------------------------------
+
+    "enode": IslandDoc(
+        "(expression) e{ ... } -> Expr",
+        "A deferred SPARQL expression. It is not evaluated where it is "
+        "written, but against the bindings in force when the island holding "
+        "it is instantiated — once per row of a `for @bindings` loop. "
+        "`{python}` holes are evaluated where they are written.",
+        _BINDINGS, "e-in-term-position"),
+
+    "eiri": IslandDoc(
+        "(expression) e<...{?var}...> -> Expr",
+        "A deferred IRI: `f<...>`'s interpolation, except that the holes are "
+        "SPARQL expressions re-evaluated for each set of bindings.",
+        _SPARQL_EXPR, "deferred-iris-e"),
+}
+
+
+def get(kind):
+    """The entry for an island kind, `island:` prefix optional; None if the
+    kind is unknown — a hover must degrade, never raise."""
+    if kind.startswith("island:"):
+        kind = kind[len("island:"):]
+    return ISLANDS.get(kind)

ldpy/lsp/server.py

@@ -21,6 +21,7 @@ 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.lsp import hover as hv
 from ldpy.transpiler.linemap import snap_breakpoint_lines
 
 
@@ -29,6 +30,28 @@ def fmt_default():
     from ldpy.formatter import DEFAULT_LINE_LENGTH
     return DEFAULT_LINE_LENGTH
 
+
+def _ldpy_version():
+    """The installed package version — never duplicated here."""
+    from ldpy import __version__
+    return __version__
+
+def _setting(settings, *path, default=None):
+    """Read a nested setting, whether the client sends the whole tree
+    (`{"ldpy": {"hover": ...}}`) or just our section (`{"hover": ...}`).
+    Clients differ on this and both spellings are legitimate."""
+    for root in (settings, (settings or {}).get("ldpy")):
+        node = root
+        for key in path:
+            if not isinstance(node, dict) or key not in node:
+                node = None
+                break
+            node = node[key]
+        if node is not None:
+            return node
+    return default
+
+
 FORWARDED = {
     "textDocument/completion",
     "textDocument/definition",
@@ -64,6 +87,9 @@ class LdpyServer:
         self.backend_argv = backend_argv
         self.backend = None
         self.line_length = line_length
+        # `ldpy.hover.showTranslation` — the generated Python in the hover.
+        # On by default: it is the point of the feature (record vscode/108).
+        self.hover_translation = True
         self._shutdown = False
 
     # ------------------------------------------------------------ backend
@@ -123,13 +149,20 @@ class LdpyServer:
 
     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."""
+        Those landing on synthetic text (the prelude) are dropped, and so is
+        everything a style linter says about the shadow: it judges GENERATED
+        code (record vscode/107). The backend is asked not to compute style
+        at all (SHADOW_SETTINGS); this filter covers a backend that does not
+        honour the configuration."""
+        from ldpy.lsp.backend import STYLE_PLUGINS
         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:
+            if d.get("source") in STYLE_PLUGINS:
+                continue
             rng = d.get("range", {})
             start = tr.pos_to_ldpy(lmap, rng.get("start", {}))
             if start is None:
@@ -173,6 +206,7 @@ class LdpyServer:
 
     def _dispatch(self, method, params, rid):
         if method == "initialize":
+            self._apply_settings(params.get("initializationOptions"))
             self._ensure_backend(params.get("rootUri"))
             return {
                 "capabilities": {
@@ -185,18 +219,18 @@ class LdpyServer:
                     "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"},
+                "serverInfo": {"name": "ldpy-lsp", "version": _ldpy_version()},
             }
-        if method in ("initialized", "workspace/didChangeConfiguration",
-                      "$/setTrace", "$/cancelRequest"):
+        if method == "workspace/didChangeConfiguration":
+            # a live toggle: no restart, and no re-transpilation either —
+            # only the rendering of the next hover changes
+            self._apply_settings(params.get("settings"))
+            return None
+        if method in ("initialized", "$/setTrace", "$/cancelRequest"):
             return None
         if method == "shutdown":
             self._shutdown = True
@@ -240,12 +274,6 @@ class LdpyServer:
                 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)
 
@@ -292,28 +320,49 @@ class LdpyServer:
         return [{"range": {"start": {"line": 0, "character": 0}, "end": end},
                  "newText": new}]
 
+    def _apply_settings(self, settings):
+        """Client configuration, from `initialize` or a later change."""
+        value = _setting(settings, "hover", "showTranslation")
+        if isinstance(value, bool):
+            self.hover_translation = value
+
+    def _gen_text(self, doc, gen):
+        """The generated Python covered by a map range."""
+        gl0, gc0, gl1, gc1 = gen
+        lines = doc.result.code.split("\n")[gl0:gl1 + 1]
+        if not lines:
+            return ""
+        if len(lines) == 1:
+            return lines[0][gc0:gc1]
+        lines[0] = lines[0][gc0:]
+        lines[-1] = lines[-1][:gc1]
+        return "\n".join(lines)
+
     def _hover(self, params):
+        """Native on an island, delegated on the Python around it.
+
+        Inside an island we answer on the SMALLEST described element under
+        the cursor (record vscode/108): hovering a prefixed name in a
+        forty-line `g{ }` should explain that name, not dump the whole
+        translated block."""
         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)
+        if seg is None:
+            return self._forward("textDocument/hover", params)
+        kind, src, code = tr.island_target(seg, pos["line"],
+                                           pos["character"])
+        if code is None:
+            code = self._gen_text(doc, seg.gen)
+        width = self.line_length or fmt_default()
+        sl0, sc0, sl1, sc1 = src
+        return {"contents": {"kind": "markdown",
+                             "value": hv.render(kind, code, width,
+                                                self.hover_translation)},
+                "range": {"start": {"line": sl0, "character": sc0},
+                          "end": {"line": sl1, "character": sc1}}}
 
     # --------------------------------------------------------- delegation
 

ldpy/lsp/translate.py

@@ -109,6 +109,7 @@ _KIND_TO_TYPE = {
     "island:pname": 2,                          # type
     "island:var": 3,                            # variable
     "island:firi": 4, "island:fnode": 4,        # macro
+    "island:bnode": 4,                          # macro (_:{expr})
     "island:graph": 4,                          # macro (région entière)
     # fiches 013-019
     "island:import": 5,                         # keyword (prefix import)
@@ -138,3 +139,33 @@ def semantic_tokens(lmap):
         data.extend([dline, dcol, length, ttype, 0])
         prev_line, prev_col = line, col
     return data
+
+
+def island_target(seg, line, character):
+    """The smallest DESCRIBED element of an island covering a position.
+
+    A composite island (`g{ }`, `m{ }`, `+{ }`, ...) records the terms it
+    contains as `parts` (record vscode/108). A hover wants the innermost one
+    — that is what the eye is on — and falls back to the island itself when
+    the position is on the notation rather than on a term, or when the island
+    has no parts at all.
+
+    Returns `(kind, src, gen_text)`; `gen_text` is None for the island
+    itself, whose generated text is read off the map's positions instead.
+    """
+    best = None
+    for kind, src, gen in getattr(seg, "parts", None) or ():
+        sl0, sc0, sl1, sc1 = src
+        if not (sl0, sc0) <= (line, character) < (sl1, sc1):
+            continue
+        if best is None or _span(src) < _span(best[1]):
+            best = (kind, src, gen)
+    if best is not None:
+        return best
+    return (seg.kind, seg.src, None)
+
+
+def _span(src):
+    """A rough size, to pick the innermost of two nested spans."""
+    sl0, sc0, sl1, sc1 = src
+    return (sl1 - sl0, sc1 - sc0)

ldpy/runtime.py

@@ -38,6 +38,12 @@ except ImportError:  # MicroPython
     def _urljoin(base, rel):
         return base + rel
 
+try:
+    from types import MappingProxyType as _MappingProxy
+except ImportError:  # MicroPython
+    def _MappingProxy(d):
+        return dict(d)
+
 import re
 _SCHEME_RE = re.compile(r"^[A-Za-z][A-Za-z0-9+.\-]*:")
 
@@ -248,11 +254,52 @@ def dtype(value):
 
 def pname(ns, *parts):
     """A dynamic prefixed name (record ldpy/013): concatenates the namespace
-    IRI (imported prefix, or computed IRI) and the local part."""
+    IRI (imported prefix, or computed IRI) and the local part.
+
+    A part that is a Variable or a deferred expression makes the WHOLE name
+    deferred (record ldpy/017). `ex:{?id}` used to yield `ex:id` — the same
+    IRI on every row, with no error, which is the trap of forging an IRI
+    from a column. It now resolves against the current bindings like any
+    other deferred term: unbound, the triple is dropped rather than written
+    wrong. `ex:{expr}` on an ordinary value stays immediate and needs no
+    bindings — a Variable is a str subclass, hence the exact type test.
+    """
+    cls = _expr_class()
+    for p in parts:
+        tp = type(p)
+        if tp is Variable or (cls and tp is cls):
+            return _deferred_pname(ns, parts)
     return rdflib.URIRef(
         str(ns) + "".join(p if isinstance(p, str) else str(p) for p in parts))
 
 
+def _deferred_pname(ns, parts):
+    """`ex:{?v}` — the prefixed name as a deferred expression.
+
+    Concatenation, exactly as in the immediate case: no percent-encoding,
+    because the namespace and the shape of the local part are yours. To mint
+    an IRI from data that may hold spaces or slashes, use `e<...{?v}>`,
+    which encodes."""
+    from ldpy.sparql import Expression, var
+
+    def build(sm):
+        out = [str(ns)]
+        for p in parts:
+            tp = type(p)
+            if tp is Variable:
+                out.append(str(var(sm, str(p))))
+            elif isinstance(p, Expression):
+                out.append(str(p(sm)))
+            else:
+                out.append(p if isinstance(p, str) else str(p))
+        return rdflib.URIRef("".join(out))
+
+    src = str(ns) + "".join(
+        "?%s" % p if type(p) is Variable
+        else (p if type(p) is str else repr(p)) for p in parts)
+    return Expression(build, src)
+
+
 def firi(*parts, base=None):
     """A formatted IRI: concatenate str(part), then resolve against base if relative."""
     iri = "".join(p if isinstance(p, str) else str(p) for p in parts)
@@ -421,8 +468,12 @@ class Bindings(dict):
     Everything Python can do to a dict works: b[?x] = v, update, del, **b,
     iteration over the keys."""
 
+    #: fallback when __init__ was bypassed (dict.copy, unpickling…)
+    _raw = {}
+
     def __init__(self, mapping=None):
         dict.__init__(self)
+        self._raw = {}
         if mapping is not None:
             if not hasattr(mapping, "items"):
                 raise TypeError(
@@ -431,14 +482,32 @@ class Bindings(dict):
             for k, v in mapping.items():
                 self[k] = v
 
+    @property
+    def raw(self):
+        """The values as they ARRIVED, before coercion (record ldpy/012,
+        point 22).
+
+        `b["v"]` is an RDF term, and a term does not compare equal to the
+        Python value it came from — `Literal("") != ""` is True, and
+        `if row["col"] != "":` is the commonest guard of a CSV-to-RDF
+        script. `b.raw["col"]` gives that guard its Python value back,
+        while `b["col"]` stays the term the islands instantiate against.
+
+        Read-only: write through `b[key]`, which coerces and records both.
+        """
+        return _MappingProxy(self._raw)
+
     def __setitem__(self, key, value):
-        dict.__setitem__(self, str(key), node(value, field=str(key)))
+        k = str(key)
+        self._raw[k] = value
+        dict.__setitem__(self, k, node(value, field=k))
 
     def __getitem__(self, key):
         return dict.__getitem__(self, str(key))
 
     def __delitem__(self, key):
         dict.__delitem__(self, str(key))
+        self._raw.pop(str(key), None)
 
     def __contains__(self, key):
         return dict.__contains__(self, str(key))
@@ -466,6 +535,7 @@ def as_bindings_iter(iterable):
             for k, v in sm.items():
                 if not str(k).startswith("__bn"):
                     dict.__setitem__(b, str(k), v)      # already terms
+                    b._raw[str(k)] = v                  # raw == the term here
             yield b
         return
     for item in iterable:

ldpy/transpiler/core.py

@@ -35,6 +35,14 @@ KEYWORDS = frozenset((
 ))
 # mots-clés « valeurs » : terminent un opérande
 VALUE_KEYWORDS = frozenset(("False", "None", "True"))
+# mots-clés qui ouvrent une instruction composée : leur ':' de profondeur 0
+# ouvre une SUITE, position d'instruction (fiche 012, point 12). `match` et
+# `case` sont des mots-clés SOUPLES — un `match: int = 0` reste une annotation,
+# mais rien n'y suit un ':' qu'un îlot pourrait revendiquer.
+COMPOUND_KEYWORDS = frozenset((
+    "async", "case", "class", "def", "elif", "else", "except", "finally",
+    "for", "if", "match", "try", "while", "with",
+))
 
 STRING_PREFIXES = frozenset((
     "", "r", "b", "u", "f", "rb", "br", "rf", "fr",
@@ -165,6 +173,47 @@ class TranspileResult:
         self.warnings = warnings    # list[LdpyWarning]
 
 
+_BOOL_RE = re.compile(r"(?:true|false|True|False)\s*$")
+_STRING_START_RE = re.compile(r"[rbfuRBFU]{0,2}[\"']")
+
+
+def _term_kind(text):
+    """The island kind of a term, from the source it was written as.
+
+    `_g_node` dispatches on exactly these leading characters, so the two stay
+    in step, and `tests/test_hover_parts.py` pins each form against the kind
+    the SAME term gets outside an island, where the transpiler labels it
+    itself. None means "no hover of its own": a `[ ]` or `( )` whose contents
+    are recorded one by one anyway, a `{python}` hole, a labelled blank node
+    — for those the island's own hover is the honest answer.
+
+    Order matters twice over: `f"x"@en` is a literal and not a formatted
+    node, and `foo:bar` is a prefixed name and not anything beginning with f.
+    """
+    t = text.lstrip()
+    if t.startswith("_:{"):
+        return "bnode"
+    if t.startswith("_:"):
+        return None                     # labelled: no island kind of its own
+    if t[:1] == "<":
+        return "iri"
+    if t[:1] in "[({":
+        return None
+    if _STRING_START_RE.match(t):
+        return "literal"                # incl. f"..."@en, r"...", b"..."
+    if t[:1] in "?$":
+        return "fnode" if t[1:2] == "{" else "var"
+    if t[:1] == "f" and t[1:2] in "<{":
+        return "firi" if t[1:2] == "<" else "fnode"
+    if t[:1] == "e" and t[1:2] in "{<":
+        return "enode" if t[1:2] == "{" else "eiri"
+    if t[:1].isdigit() or (t[:1] in "+-." and t[1:2].isdigit()):
+        return "literal"
+    if _BOOL_RE.match(t):
+        return "literal"                # Turtle's true/false: a Literal
+    return "pname"
+
+
 class Transpiler:
     """Une instance par fichier. Usage : Transpiler(src, filename).run()."""
 
@@ -199,6 +248,10 @@ class Transpiler:
         # que Python possède, et où aucun terme RDF ne peut vivre.
         self._lambda_depth = None
         self._after_def = False     # on vient de lire 'def' : le '(' suivant
+        # la ligne logique a commencé par un mot-clé d'instruction composée :
+        # son ':' de profondeur 0 ouvre une SUITE, donc une position
+        # d'instruction (fiche 012, point 12).
+        self._compound_header = False
         self.operand = True         # un opérande peut commencer ici
         self.stmt_start = True      # début de ligne logique (hors espaces)
         self.after_dot = False
@@ -207,6 +260,7 @@ class Transpiler:
         # une instruction moins indentée dépile et restaure.
         self._scope_stack = []
         self._retired = {}          # préfixe sorti de portée -> ligne de décl.
+        self._shadowed = set()      # préfixe aussi nom Python : averti une fois
         self._prefix_col = {}       # préfixe -> indentation de sa déclaration
         # préfixes dynamiques (fiche 013)
         self._ns_counter = 0        # variables fraîches _ldpy_ns*
@@ -215,6 +269,10 @@ class Transpiler:
         self._graph_var = None      # variable Python du graphe courant, ou None
         # îlot de motif (fiche 016) : collecte des variables projetées
         self._match_vars = None
+        # terms of the island being parsed, and the finished list waiting
+        # for the `_end_island` that closes it (record vscode/108)
+        self._parts = None
+        self._pending_parts = None
         # binding courant (fiche 017)
         self._bindings_var = None
 
@@ -280,7 +338,9 @@ class Transpiler:
             sl, sc, gl, gc = mark
             self.map.add("island:" + kind,
                          (sl, sc, self.src_line, self.src_col),
-                         (gl, gc, self.gen_line, self.gen_col))
+                         (gl, gc, self.gen_line, self.gen_col),
+                         self._pending_parts)
+        self._pending_parts = None
         self.uses_runtime = True
         self.operand = False
         self.stmt_start = False
@@ -357,6 +417,7 @@ class Transpiler:
                 if self.depth == 0:
                     self.stmt_start = True
                     self.operand = True
+                    self._compound_header = False
                 self.after_dot = False
             elif c in " \t\r":
                 self._copy(1)
@@ -427,17 +488,25 @@ class Transpiler:
                     self._copy(1)
                 self.stmt_start = False
             elif c == ":":
-                if self._lambda_depth == self.depth:
+                lam = self._lambda_depth == self.depth
+                if lam:
                     self._lambda_depth = None       # fin des paramètres
                 self._copy(1)
                 self.operand = True
-                self.stmt_start = False
+                # `if c: +{ ... }` — le ':' d'une instruction composée ouvre
+                # une suite, qui est une position d'instruction au même titre
+                # qu'un début de ligne (fiche 012, point 12). Pas celui d'une
+                # annotation (`x: int`) ni d'un lambda, qui n'ouvrent rien.
+                self.stmt_start = (self._compound_header and self.depth == 0
+                                   and not lam)
+                self._compound_header = False
                 self.after_dot = False
             elif c == ";":
                 self._copy(1)
                 self.operand = True
                 if self.depth == 0:
                     self.stmt_start = True
+                    self._compound_header = False
             else:
                 # opérateurs, ponctuation, identifiants unicode
                 if c.isidentifier():
@@ -713,11 +782,30 @@ class Transpiler:
                 self._warn("le préfixe '%s:' est hors de portée ici (sa "
                            "déclaration est dans un bloc terminé) ; le texte "
                            "est laissé tel quel" % name)
+        # un préfixe déclaré qui sert AUSSI de nom Python : `{ex:b}` devient
+        # alors un ensemble d'IRI là où Python lisait un dict (fiche 002).
+        # Savoir où Python affecte un nom demanderait de le parser ; on s'en
+        # tient à l'approximation retenue le 2026-08-29 — le nom en tête
+        # d'instruction, suivi de '=' (hors '==') ou de ','.
+        if self.stmt_start and self.depth == 0 and not self._sub \
+                and name in self.prefixes and name not in self._shadowed:
+            j = self._skip_ws_ahead(m.end())
+            nx, nx2 = (t[j:j + 1], t[j + 1:j + 2])
+            if (nx == "=" and nx2 != "=") or nx == ",":
+                self._shadowed.add(name)
+                self._warn("'%s' est à la fois un préfixe déclaré et un nom "
+                           "Python : dans `{%s:x}` et `a[%s:x]`, le nom "
+                           "préfixé l'emporte sur la lecture Python. Écrire "
+                           "`{%s: x}` avec une espace force le dict."
+                           % (name, name, name, name))
 
         if name == "lambda":
             self._lambda_depth = self.depth
         elif name == "def":
             self._after_def = True
+        if self.stmt_start and self.depth == 0 \
+                and name in COMPOUND_KEYWORDS:
+            self._compound_header = True
         self._copy(len(name))
         if name in KEYWORDS:
             self.operand = name not in VALUE_KEYWORDS
@@ -937,10 +1025,13 @@ class Transpiler:
         if all(p[0] for p in parts):
             local = "".join(p[1] for p in parts)
             return "%s.URIRef(%r)" % (RUNTIME_ALIAS, ns + local)
+        # `ex:{expr}` EST un nom préfixé, pas une IRI formatée : même
+        # concaténation, mais `pname` diffère l'évaluation quand la partie
+        # locale porte une variable (fiche 017).
         args = [repr(ns)]
         for is_static, val in parts:
             args.append(repr(val) if is_static else "(%s)" % val)
-        return "%s.firi(%s)" % (RUNTIME_ALIAS, ", ".join(args))
+        return "%s.pname(%s)" % (RUNTIME_ALIAS, ", ".join(args))
 
     # ------------------------------------------------------------------
     # import de préfixes (fiche 013)
@@ -1624,6 +1715,24 @@ class Transpiler:
     # ------------------------------------------------------------------
 
     def _g_parse_triples(self):
+        """Collects the island's terms as `parts` while parsing it.
+
+        Saved and restored around the call, because an interpolation can
+        hold another island: `g{ ex:p f{ g{ ... } } }` runs a whole inner
+        island — `_end_island` included — in the middle of the outer one.
+        The finished list waits in `_pending_parts` for the `_end_island`
+        that closes THIS island; an inner island finds it None and attaches
+        nothing, which is what keeps the two from stealing each other's
+        terms.
+        """
+        saved = self._parts
+        self._parts = []
+        try:
+            return self._g_parse_triples_inner()
+        finally:
+            self._pending_parts, self._parts = self._parts, saved
+
+    def _g_parse_triples_inner(self):
         """Corps d'îlot de graphe : self.i juste après le '{' ouvrant.
         Consomme jusqu'au '}' fermant inclus ; retourne (triples, gctx)."""
         gctx = _GraphCtx()
@@ -1704,6 +1813,22 @@ class Transpiler:
             return
 
     def _g_verb(self, triples, gctx):
+        """Records the predicate as a `part`, then parses it — the sibling
+        of the wrapper on `_g_node`, for the position `_g_node` never sees."""
+        if self._parts is None or self._sub:
+            return self._g_verb_inner(triples, gctx)
+        sl, sc, i0 = self.src_line, self.src_col, self.i
+        gen = self._g_verb_inner(triples, gctx)
+        # `a` is Turtle's rdf:type shorthand, not a prefixed name: no kind
+        # of its own, so the island's hover answers for it
+        kind = (None if self.text[i0:self.i].strip() == "a"
+                else _term_kind(self.text[i0:self.i]))
+        if kind is not None:
+            self._parts.append(
+                (kind, (sl, sc, self.src_line, self.src_col), gen))
+        return gen
+
+    def _g_verb_inner(self, triples, gctx):
         t = self.text
         c = self._peek()
         if c == "a" and not (_name_char(self._peek(1)) or self._peek(1) == ":"):
@@ -1755,6 +1880,23 @@ class Transpiler:
         return "%s.Variable(%r)" % (RUNTIME_ALIAS, name)
 
     def _g_node(self, triples, gctx):
+        """Records the term as a `part` of the island, then parses it.
+
+        `_g_parse_triples` opens the list; everything a composite island
+        contains comes through here, so this one wrapper gives `g{ }`,
+        `m{ }`, `+{ }` and `-{ }` a hover per term (record vscode/108)
+        without touching the flat language map."""
+        if self._parts is None or self._sub:
+            return self._g_node_inner(triples, gctx)
+        sl, sc, i0 = self.src_line, self.src_col, self.i
+        gen, composite = self._g_node_inner(triples, gctx)
+        kind = _term_kind(self.text[i0:self.i])
+        if kind is not None:
+            self._parts.append(
+                (kind, (sl, sc, self.src_line, self.src_col), gen))
+        return gen, composite
+
+    def _g_node_inner(self, triples, gctx):
         """Parse un nœud de graphe. Retourne (expr, is_composite) ;
         is_composite vrai pour [..], (..) qui peuvent être sujets sans props."""
         t = self.text
@@ -2485,7 +2627,8 @@ class _Term(str):
 def _maybe_impure(expr, gctx):
     """f-IRI et nom prefixe : impurs seulement s'ils portent une interpolation
     (sinon le transpileur a deja produit une URIRef constante)."""
-    if expr.startswith(RUNTIME_ALIAS + ".firi("):
+    if expr.startswith(RUNTIME_ALIAS + ".firi(") \
+            or expr.startswith(RUNTIME_ALIAS + ".pname("):
         return _impure(expr, gctx)
     return expr
 

ldpy/transpiler/linemap.py

@@ -12,14 +12,23 @@ import json
 
 
 class Segment:
-    """One source/generated correspondence segment (copy, island:*, synthetic)."""
+    """One source/generated correspondence segment (copy, island:*, synthetic).
 
-    __slots__ = ("kind", "src", "gen")
+    A composite island (`g{ }`, `m{ }`, `+{ }`, `-{ }`) also carries `parts`:
+    the terms written inside it, as `(kind, src, gen_text)` (record
+    vscode/108). They are deliberately NOT segments of their own — the map is
+    a flat, ordered list that breakpoint snapping, the source map and request
+    forwarding all walk, and nesting spans inside it would change what those
+    three answer. Parts are read by the hover and by nothing else.
+    """
 
-    def __init__(self, kind, src, gen):
+    __slots__ = ("kind", "src", "gen", "parts")
+
+    def __init__(self, kind, src, gen, parts=None):
         self.kind = kind
         self.src = src  # (line0, col0, line1, col1), or None for synthetic
         self.gen = gen  # (line0, col0, line1, col1)
+        self.parts = parts or []
 
     def __repr__(self):
         return "Segment(%r, src=%r, gen=%r)" % (self.kind, self.src, self.gen)
@@ -29,6 +38,9 @@ class Segment:
         d = {"kind": self.kind, "gen": list(self.gen)}
         if self.src is not None:
             d["src"] = list(self.src)
+        if self.parts:
+            d["parts"] = [{"kind": k, "src": list(s), "gen": g}
+                          for k, s, g in self.parts]
         return d
 
 
@@ -60,12 +72,12 @@ class LanguageMap:
         self.generated_name = generated_name
         self.segments = []  # ordered by increasing gen AND src positions
 
-    def add(self, kind, src, gen):
+    def add(self, kind, src, gen, parts=None):
         """Add a segment (segments empty on both sides are ignored)."""
         # ignore segments that are empty on both sides
         if src is not None and src[:2] == src[2:] and gen[:2] == gen[2:]:
             return
-        self.segments.append(Segment(kind, src, gen))
+        self.segments.append(Segment(kind, src, gen, parts))
 
     # -- traduction ---------------------------------------------------------
 
@@ -123,7 +135,10 @@ class LanguageMap:
         m = cls(d.get("source", "<ldpy>"), d.get("generated"))
         for sd in d.get("segments", []):
             src = tuple(sd["src"]) if "src" in sd else None
-            m.segments.append(Segment(sd["kind"], src, tuple(sd["gen"])))
+            parts = [(pd["kind"], tuple(pd["src"]), pd["gen"])
+                     for pd in sd.get("parts", ())]
+            m.segments.append(
+                Segment(sd["kind"], src, tuple(sd["gen"]), parts))
         return m
 
     @classmethod

{linked_data_python-0.2.0.dist-info → linked_data_python-0.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: linked-data-python
-Version: 0.2.0
+Version: 0.5.1
 Summary: Python extended with Semantic Web primitives: IRIs, RDF literals and Turtle-notation graphs as expressions, transpiled by island parsing.
 Author-email: Maxime Lefrançois <maxime.lefrancois@emse.fr>
 License: MIT
@@ -96,31 +96,31 @@ From Python: `import ldpy; ldpy.install()` then `import yourmodule` finds
 
 ## Documentation
 
-Read it at [`docs/`](docs/README.md) — start with the
-[home page](docs/README.md) for an overview, then:
+Read it at **<https://linked-data-python.readthedocs.io/>** — start with the
+home page for an overview, then:
 
-- **Tutorials** — [first steps](docs/tutorials/getting-started.md), then
-  [build a knowledge graph](docs/tutorials/build-a-knowledge-graph.md) from
+- **Tutorials** — [first steps](https://linked-data-python.readthedocs.io/en/latest/tutorials/getting-started/), then
+  [build a knowledge graph](https://linked-data-python.readthedocs.io/en/latest/tutorials/build-a-knowledge-graph/) from
   tabular data.
-- **How-to guides** — [run & import](docs/how-to/run-and-import.md),
-  [build graphs from tables](docs/how-to/build-graphs-from-tables.md),
-  [read and query](docs/how-to/query-a-graph.md),
-  [migrate from rdflib](docs/how-to/migrate-from-rdflib.md),
-  [VS Code](docs/how-to/use-vscode.md), [debugging](docs/how-to/debug.md),
-  [language server](docs/how-to/language-server.md),
-  [highlighting](docs/how-to/highlight-ldpy.md).
-- **Reference** — [the language](docs/reference/language/index.md), one page
-  per island family; [SPARQL expressions](docs/reference/sparql-expressions.md);
-  [CLI](docs/reference/cli.md); [Python API](docs/reference/api.md);
-  [language map formats](docs/reference/language-map.md).
-- **Explanation** — [why](docs/explanation/why.md),
-  [what real RDF code does](docs/explanation/what-real-code-does.md) (the
+- **How-to guides** — [run & import](https://linked-data-python.readthedocs.io/en/latest/how-to/run-and-import/),
+  [build graphs from tables](https://linked-data-python.readthedocs.io/en/latest/how-to/build-graphs-from-tables/),
+  [read and query](https://linked-data-python.readthedocs.io/en/latest/how-to/query-a-graph/),
+  [migrate from rdflib](https://linked-data-python.readthedocs.io/en/latest/how-to/migrate-from-rdflib/),
+  [VS Code](https://linked-data-python.readthedocs.io/en/latest/how-to/use-vscode/), [debugging](https://linked-data-python.readthedocs.io/en/latest/how-to/debug/),
+  [language server](https://linked-data-python.readthedocs.io/en/latest/how-to/language-server/),
+  [highlighting](https://linked-data-python.readthedocs.io/en/latest/how-to/highlight-ldpy/).
+- **Reference** — [the language](https://linked-data-python.readthedocs.io/en/latest/reference/language/), one page
+  per island family; [SPARQL expressions](https://linked-data-python.readthedocs.io/en/latest/reference/sparql-expressions/);
+  [CLI](https://linked-data-python.readthedocs.io/en/latest/reference/cli/); [Python API](https://linked-data-python.readthedocs.io/en/latest/reference/api/);
+  [language map formats](https://linked-data-python.readthedocs.io/en/latest/reference/language-map/).
+- **Explanation** — [why](https://linked-data-python.readthedocs.io/en/latest/explanation/why/),
+  [what real RDF code does](https://linked-data-python.readthedocs.io/en/latest/explanation/what-real-code-does/) (the
   corpus study that drove the language's second wave),
-  [designing the syntax](docs/explanation/designing-the-syntax.md),
-  [island parsing](docs/explanation/island-parsing.md),
-  [emission & semantics](docs/explanation/emission-and-semantics.md),
-  [tooling](docs/explanation/tooling.md),
-  [how this is tested](docs/explanation/how-it-is-tested.md).
+  [designing the syntax](https://linked-data-python.readthedocs.io/en/latest/explanation/designing-the-syntax/),
+  [island parsing](https://linked-data-python.readthedocs.io/en/latest/explanation/island-parsing/),
+  [emission & semantics](https://linked-data-python.readthedocs.io/en/latest/explanation/emission-and-semantics/),
+  [tooling](https://linked-data-python.readthedocs.io/en/latest/explanation/tooling/),
+  [how this is tested](https://linked-data-python.readthedocs.io/en/latest/explanation/how-it-is-tested/).
 
 Every `ldpy` and `python` block in the documentation is executed by the test
 suite, and its assertions are the test.

linked_data_python-0.5.1.dist-info/RECORD

@@ -0,0 +1,28 @@
+ldpy/__init__.py,sha256=IyuzHrp5OtuGO_NrrdmMUQW6bTYcyS5uob7CeoXg8mY,1943
+ldpy/__main__.py,sha256=YKTEjmNQuh_0p-KiEus9HngFs_ZDmS56RXzHTspiWVI,3077
+ldpy/build.py,sha256=495F9KyFMar-hTCuaQkF3FvzWQX4mE9H0U0V-JuRDmA,3394
+ldpy/console.py,sha256=1FrroxoTTWG7fIBzaDQvOxPGj6NkyXJDJhhl5RXyE_0,4204
+ldpy/debug.py,sha256=5o8oVYIbFk6rB9-ShTIfym_bhVG3imTw_l0taJZ9qH0,9462
+ldpy/formatter.py,sha256=VaDPECxhivsMe8jnX_fOL7BUyLEu5r4xREdr4Hav-0c,12695
+ldpy/importer.py,sha256=QXAhSujPN6rFMJSQuj0UsWyI4CajirKt1SOrykJ_fUw,3670
+ldpy/pygments_lexer.py,sha256=mcQ0u9nZjLnSWpqzcxd6bZjk69LfKSNTsf9A3rqfhhk,25320
+ldpy/runtime.py,sha256=2xugLVjgtbay9GAsC_QGVFBeaXSRbja7xEkl2ZbYDQ4,36040
+ldpy/sparql.py,sha256=CHSB4v5lEuVQKRPuwcM8xI3jN2FVHkmPVb675QkAD9Y,14770
+ldpy/lsp/__init__.py,sha256=rK5GYOITi9PN09-WVlJ2aPKodW8dWTpgI_X6dFbP1zA,542
+ldpy/lsp/__main__.py,sha256=MIp4ktqaoWZCNIMfv14bSC9pqK86JBS5XVjd1Z3c24o,72
+ldpy/lsp/backend.py,sha256=8DnSGaBk1dsIMOBo7D1WQxxF3MZjJbYd78jp4ucWORY,5375
+ldpy/lsp/hover.py,sha256=zSJ0PpU3kTJDXcwI2zSDCbsKrT-eNTt2RlvmEPRoV-M,2407
+ldpy/lsp/islanddoc.py,sha256=vxxRKEcywBH31c8XgykEoC8fZfvbHok1NH-rPc-0Sy0,9540
+ldpy/lsp/rpc.py,sha256=-TF_9U8dum23Pi4O1FZLogwoZgrGrt14J5BFB1OYVZw,3554
+ldpy/lsp/server.py,sha256=PAMMookGUn00vAW_-a5BGy3qkVe9PoUdfzAzpdlvoF8,16359
+ldpy/lsp/translate.py,sha256=HU9fBP_xWyYLih6QwQfSoyfF-MH-oInFcPX3o8Vc2GI,6116
+ldpy/transpiler/__init__.py,sha256=9mQx0e47ixz0iMqSbCBbtGiwJ7PLxTcsVSIp6KNTMG4,504
+ldpy/transpiler/core.py,sha256=4_YXbLLdtZfRTLb3ySprsnS_LXqiGfxZXqZvnXWT5T8,113482
+ldpy/transpiler/errors.py,sha256=zEEwsNvC2Tawq8jIYls7hrbcWSvQtd7eo89k_SKp0k0,1142
+ldpy/transpiler/linemap.py,sha256=ecLlCUkD4-6QQtUjGfAL28ql7LPITTS4fjLcDIbAwpQ,11386
+linked_data_python-0.5.1.dist-info/licenses/LICENSE.md,sha256=R6KjQ098eAFd2k5mKaSRJqMH1LhY4o7xkHrKT5vjRfs,1074
+linked_data_python-0.5.1.dist-info/METADATA,sha256=zC_1FxXgKCcqGYOcqNzUQkVVJ40m8HMKH-GzbMPsfWU,7974
+linked_data_python-0.5.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+linked_data_python-0.5.1.dist-info/entry_points.txt,sha256=n8Vs52oH81BrKOe1DNUvdFLSOlEufRMpK2waPFa6aYk,224
+linked_data_python-0.5.1.dist-info/top_level.txt,sha256=dkG_F4jYkh6CS6gdpQeV_gKW3yaJBvl1ukUu0zo2KA8,5
+linked_data_python-0.5.1.dist-info/RECORD,,

linked_data_python-0.2.0.dist-info/RECORD

@@ -1,26 +0,0 @@
-ldpy/__init__.py,sha256=ieLv4_enuK-Z6O-In0kp1zol08BsQwj2Ky1-wqb8Blo,1302
-ldpy/__main__.py,sha256=YKTEjmNQuh_0p-KiEus9HngFs_ZDmS56RXzHTspiWVI,3077
-ldpy/build.py,sha256=495F9KyFMar-hTCuaQkF3FvzWQX4mE9H0U0V-JuRDmA,3394
-ldpy/console.py,sha256=1FrroxoTTWG7fIBzaDQvOxPGj6NkyXJDJhhl5RXyE_0,4204
-ldpy/debug.py,sha256=mG8Dku-0erfJoBB9yYxI4eEuUipIpMsirLp6DfGx34k,9138
-ldpy/formatter.py,sha256=VaDPECxhivsMe8jnX_fOL7BUyLEu5r4xREdr4Hav-0c,12695
-ldpy/importer.py,sha256=QXAhSujPN6rFMJSQuj0UsWyI4CajirKt1SOrykJ_fUw,3670
-ldpy/pygments_lexer.py,sha256=mcQ0u9nZjLnSWpqzcxd6bZjk69LfKSNTsf9A3rqfhhk,25320
-ldpy/runtime.py,sha256=k1k_DfblW4Dxacu4BkZpfuEPV1mMN83PkLtML9SAoms,33390
-ldpy/sparql.py,sha256=CHSB4v5lEuVQKRPuwcM8xI3jN2FVHkmPVb675QkAD9Y,14770
-ldpy/lsp/__init__.py,sha256=rK5GYOITi9PN09-WVlJ2aPKodW8dWTpgI_X6dFbP1zA,542
-ldpy/lsp/__main__.py,sha256=MIp4ktqaoWZCNIMfv14bSC9pqK86JBS5XVjd1Z3c24o,72
-ldpy/lsp/backend.py,sha256=c5Jx1fZ1ZhoYet9__RB1mUqFUtcCl63tO8vgnv8iMII,4644
-ldpy/lsp/rpc.py,sha256=-TF_9U8dum23Pi4O1FZLogwoZgrGrt14J5BFB1OYVZw,3554
-ldpy/lsp/server.py,sha256=Xpl1ApcNlauLjEiabITOTJ6i8aVGDdPB7SgPxK2ePJs,14329
-ldpy/lsp/translate.py,sha256=_xDnKrJdx02puRkcuzhGwCLdEByuvhTfSIc9dAFR6a8,4931
-ldpy/transpiler/__init__.py,sha256=9mQx0e47ixz0iMqSbCBbtGiwJ7PLxTcsVSIp6KNTMG4,504
-ldpy/transpiler/core.py,sha256=s0jzTHSsazF7Xm-32q_Km6dKCxyjWEucmyVqd0eTP1s,106350
-ldpy/transpiler/errors.py,sha256=zEEwsNvC2Tawq8jIYls7hrbcWSvQtd7eo89k_SKp0k0,1142
-ldpy/transpiler/linemap.py,sha256=6b7y0nNmgnAMr_bqomgty7V0RgWPXFAp_8BZE4VYqzc,10580
-linked_data_python-0.2.0.dist-info/licenses/LICENSE.md,sha256=R6KjQ098eAFd2k5mKaSRJqMH1LhY4o7xkHrKT5vjRfs,1074
-linked_data_python-0.2.0.dist-info/METADATA,sha256=iHtvFy2zY921K5YLqF2vk13DGasgPwV2bSQPMdRGcgg,6985
-linked_data_python-0.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-linked_data_python-0.2.0.dist-info/entry_points.txt,sha256=n8Vs52oH81BrKOe1DNUvdFLSOlEufRMpK2waPFa6aYk,224
-linked_data_python-0.2.0.dist-info/top_level.txt,sha256=dkG_F4jYkh6CS6gdpQeV_gKW3yaJBvl1ukUu0zo2KA8,5
-linked_data_python-0.2.0.dist-info/RECORD,,