linked-data-python 0.6.0__tar.gz → 0.6.2__tar.gz

{linked_data_python-0.6.0 → linked_data_python-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: linked-data-python
-Version: 0.6.0
+Version: 0.6.2
 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

{linked_data_python-0.6.0 → linked_data_python-0.6.2}/ldpy/lsp/islanddoc.py

@@ -134,7 +134,9 @@ ISLANDS = {
         "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.",
+        "Calling it on a graph gives a LAZY query; `.execute()` is what "
+        "forces it — for an update, and for any query whose rdflib `Result` "
+        "you then call a method on.",
         _QUERY, "s-a-sparql-query"),
 
     # -- terms --------------------------------------------------------------
@@ -169,10 +171,10 @@ ISLANDS = {
 
     "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.",
+        "A formatted IRI: the braces interpolate as in an f-string, and the "
+        "result is resolved against `@base` if it is relative. It does NOT "
+        "percent-encode — the shape of the IRI is yours. To mint one from "
+        "data that may hold a space or a slash, use `e<...>`, which encodes.",
         _TERMS, "formatted-iris-f"),
 
     "fnode": IslandDoc(
@@ -202,7 +204,9 @@ ISLANDS = {
     "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 expressions re-evaluated for each set of bindings — and that "
+        "it percent-encodes what it interpolates. This is the form for "
+        "minting an IRI from a data column.",
         _SPARQL_EXPR, "deferred-iris-e"),
 }
 

{linked_data_python-0.6.0 → linked_data_python-0.6.2}/ldpy/transpiler/core.py

@@ -592,6 +592,40 @@ class Transpiler:
     # chaînes et littéraux RDF
     # ------------------------------------------------------------------
 
+    # Island sigils that open with a brace or a chevron.  A hole beginning
+    # with one of these is an island the scanner will never reach.
+    _HOLE_ISLANDS = ("_:{", "g{", "m{", "s{", "e{", "e<", "f{", "f<", "?{")
+
+    def _island_in_fstring_hole(self, tok_start, end):
+        """The island opener written inside an f-string hole, or None.
+
+        The scanner does not descend into f-string interpolation holes: an
+        island written there would be copied verbatim into the generated
+        Python, which then fails with a message from CPython's f-string
+        parser that names nothing (record ldpy/012). Refusing it here, by
+        name, costs one scan of the token and turns a baffling failure into
+        an actionable one.
+        """
+        tok = self.text[tok_start:end]
+        if "f" not in tok[:3].lower() or "{" not in tok:
+            return None
+        i, n = 0, len(tok)
+        while i < n:
+            if tok[i] != "{":
+                i += 1
+                continue
+            if tok[i + 1:i + 2] == "{":         # '{{' is an escaped brace
+                i += 2
+                continue
+            j = i + 1
+            while j < n and tok[j] in " \t":
+                j += 1
+            for opener in self._HOLE_ISLANDS:
+                if tok.startswith(opener, j):
+                    return opener
+            i += 1
+        return None
+
     def _handle_string(self, start, prefix_start=None):
         """start : indice du guillemet. prefix_start : indice du préfixe de
         chaîne (r/b/f/u) déjà repéré, sinon None."""
@@ -607,6 +641,12 @@ class Transpiler:
         if suffix is None and t[end:end + 2] == "^^":
             suffix = ("datatype", None, end + 2)
         if suffix is None:
+            opener = self._island_in_fstring_hole(tok_start, end)
+            if opener is not None:
+                self._error(
+                    "îlot '%s' dans un trou d'f-string : le scanner n'y "
+                    "descend pas. Sortez la lecture dans une variable "
+                    "au-dessus de l'f-string." % opener)
             self._copy(end - self.i)
             self.operand = False
             self.stmt_start = False
@@ -2124,6 +2164,14 @@ class Transpiler:
             elif c in "\"'":
                 end = self._string_end(self.i)
                 pieces.append(self._take(end - self.i))
+            elif c == "<" and self._iriref_end(self.i) is not None:
+                # A full IRI is a token, not punctuation: its '#' is part of
+                # the IRI, not a comment. Without this the fragment of
+                # <http://example.org/ns#X> — the most ordinary shape an IRI
+                # takes in RDF — swallowed the rest of the line, closing
+                # brace included. `<` that does NOT open an IRI is SPARQL's
+                # less-than, and falls through to the single-character case.
+                pieces.append(self._take(self._iriref_end(self.i) - self.i))
             elif c == "#":
                 j = t.find("\n", self.i)
                 pieces.append(self._take((j if j != -1 else self.n) - self.i))

{linked_data_python-0.6.0 → linked_data_python-0.6.2}/linked_data_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: linked-data-python
-Version: 0.6.0
+Version: 0.6.2
 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

{linked_data_python-0.6.0 → linked_data_python-0.6.2}/linked_data_python.egg-info/SOURCES.txt

@@ -52,6 +52,7 @@ tests/test_identity.py
 tests/test_import_hook.py
 tests/test_islanddoc.py
 tests/test_islands_terms.py
+tests/test_lexing.py
 tests/test_linemap.py
 tests/test_lsp_rpc.py
 tests/test_lsp_server.py

{linked_data_python-0.6.0 → linked_data_python-0.6.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "linked-data-python"
-version = "0.6.0"
+version = "0.6.2"
 description = "Python extended with Semantic Web primitives: IRIs, RDF literals and Turtle-notation graphs as expressions, transpiled by island parsing."
 readme = "README.md"
 license = { text = "MIT" }

{linked_data_python-0.6.0 → linked_data_python-0.6.2}/tests/test_docs.py

@@ -20,13 +20,21 @@ def blocks(lang):
     for path in DOCS:
         text = open(path, encoding="utf-8").read()
         for i, m in enumerate(FENCE.finditer(text)):
-            if m.group(1) == lang:
+            if m.group(1) == lang and not _is_snippet(m.group(2)):
                 out.append(pytest.param(
                     m.group(2),
                     id="%s#%d" % (os.path.relpath(path, REPO), i)))
     return out
 
 
+def _is_snippet(code):
+    """A block that only includes a file (``--8<-- "..."``) has no code of its
+    own: mkdocs substitutes the file at build time, and that file is tested
+    where it lives — see ``test_the_tour_runs``."""
+    return all(line.strip().startswith("--8<--") or not line.strip()
+               for line in code.split("\n"))
+
+
 def test_docs_exist_and_cover_diataxis():
     rels = {os.path.relpath(p, os.path.join(REPO, "docs")) for p in DOCS}
     assert "README.md" in rels
@@ -46,6 +54,18 @@ def test_python_snippets_run(code):
     exec(compile(code, "<docs>", "exec"), {"__name__": "docs"})
 
 
+def test_the_tour_runs():
+    """``docs/tutorials/tour.ldpy`` is a tutorial in the shape of a program:
+    its comments teach, and each section asserts what it claims. Running it is
+    therefore the whole check — and the page that shows it includes this very
+    file, so the two cannot drift."""
+    from ldpy.transpiler import transpile
+    path = os.path.join(REPO, "docs", "tutorials", "tour.ldpy")
+    source = open(path, encoding="utf-8").read()
+    exec(compile(transpile(source, path).code, path, "exec"),
+         {"__name__": "tour"})
+
+
 # --------------------------------------------------------------------------
 # The same snippets, typed into the interactive console.
 #

linked_data_python-0.6.2/tests/test_lexing.py

@@ -0,0 +1,53 @@
+"""Lexical guards on the boundary between Python and the islands.
+
+What is pinned here is not what the transpiler produces but what it REFUSES,
+and how: a construct the scanner cannot see must fail by name, not by leaving
+CPython to complain about something else.
+"""
+
+import pytest
+
+from ldpy.transpiler import transpile, LdpySyntaxError
+
+# CPython then rejected with a message naming nothing. Found by the corpus
+# study; refused by name since 0.5.1.
+
+def test_an_island_in_an_fstring_hole_is_refused_by_name():
+    src = ('@prefix ex: <http://example.org/> .\n'
+           '@graph as g\n'
+           't = f"{m{ ?s ex:p ?o }.first()}"\n')
+    with pytest.raises(LdpySyntaxError) as e:
+        transpile(src, "t.ldpy")
+    assert "f-string" in e.value.msg and "m{" in e.value.msg
+    assert e.value.line == 2                      # 0-based: the third line
+
+
+@pytest.mark.parametrize("hole", ["g{ ex:a ex:b 1 }", "s{ SELECT ?s WHERE {} }",
+                                  "e{ ?a }", "f<a/{x}>", "_:{1}", "?{1}"])
+def test_every_brace_island_is_caught_in_a_hole(hole):
+    src = ('@prefix ex: <http://example.org/> .\n'
+           '@graph as g\n'
+           't = f"{%s}"\n' % hole)
+    with pytest.raises(LdpySyntaxError):
+        transpile(src, "t.ldpy")
+
+
+def test_an_ordinary_fstring_is_untouched():
+    """The guard must not cost a plain f-string, nor an escaped brace, nor a
+    dict display inside a hole."""
+    src = ('xs = [1, 2]\n'
+           'a = f"{len(xs)} results"\n'
+           'b = f"{{literal braces}}"\n'
+           'c = f"{ {k: v for k, v in []} }"\n'
+           'd = f"{xs!r:>10}"\n')
+    code = transpile(src, "t.ldpy").code
+    assert 'f"{len(xs)} results"' in code
+    assert 'f"{{literal braces}}"' in code
+
+
+def test_an_island_outside_a_hole_still_works():
+    """A comprehension over an island is fine — only the hole is blind."""
+    src = ('@prefix ex: <http://example.org/> .\n'
+           '@graph as g\n'
+           'xs = [s for s in m{ ?s ex:p ?o }]\n')
+    assert "_ldpy_.match(" in transpile(src, "t.ldpy").code

{linked_data_python-0.6.0 → linked_data_python-0.6.2}/tests/test_sparql_island.py

@@ -159,3 +159,51 @@ def test_update_par_execute_public(run):
     g, _ = run(DATA + "s{ INSERT { ?s ex:seen 1 } WHERE { ?s a ex:Sensor } }"
                       ".execute()\n")
     assert len(g["g"]) > 2
+
+
+# --------------------------------------------------------------- record 012
+# A '#' inside a full IRI was read as the start of a comment, so the rest of
+# the line — closing brace included — was swallowed. The most ordinary shape
+# an IRI takes in RDF, and only `s{ }` had the defect: `m{ }` and `g{ }`
+# parse IRIs as terms and never saw it. Found by the corpus study.
+
+def test_a_hash_inside_a_full_iri_is_not_a_comment():
+    src = ("@graph as g\n"
+           "q = s{ SELECT ?s WHERE { ?s <http://example.org/ns#X> ?o } }\n")
+    code = transpile(src, "t.ldpy").code
+    assert "http://example.org/ns#X" in code
+
+
+def test_the_same_iri_in_the_other_islands_never_broke():
+    """The regression guard is on `s{ }`, but pin the siblings too: the fix
+    must not have been needed there, and must not change them."""
+    src = ("@graph as g\n"
+           "m1 = m{ ?s <http://example.org/ns#X> ?o }\n"
+           "g1 = g{ <http://example.org/ns#A> <http://example.org/ns#p> 1 }\n")
+    code = transpile(src, "t.ldpy").code
+    assert code.count("http://example.org/ns#") == 3
+
+
+def test_a_real_comment_is_still_a_comment():
+    src = ("@prefix ex: <http://example.org/ns#> .\n"
+           "@graph as g\n"
+           "q = s{ SELECT ?s WHERE { ?s ex:v ?v }  # a real comment\n"
+           "     }\n")
+    assert "a real comment" in transpile(src, "t.ldpy").code
+
+
+def test_less_than_is_still_an_operator():
+    """`<` that does not open an IRI is SPARQL's less-than. The fix keys on
+    `_iriref_end`, so it must leave FILTER(?v < 5) alone."""
+    src = ("@prefix ex: <http://example.org/ns#> .\n"
+           "@graph as g\n"
+           "q = s{ SELECT ?s WHERE { ?s ex:v ?v . FILTER(?v < 5 && ?v > 1) } }\n")
+    code = transpile(src, "t.ldpy").code
+    assert "?v < 5 && ?v > 1" in code
+
+
+def test_a_hash_inside_a_string_is_not_a_comment_either():
+    src = ("@prefix ex: <http://example.org/ns#> .\n"
+           "@graph as g\n"
+           'q = s{ SELECT ?s WHERE { ?s ex:v "a#b" } }\n')
+    assert 'a#b' in transpile(src, "t.ldpy").code