linked-data-python 0.5.1__tar.gz → 0.5.2__tar.gz

{linked_data_python-0.5.1/linked_data_python.egg-info → linked_data_python-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: linked-data-python
-Version: 0.5.1
+Version: 0.5.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.5.1 → linked_data_python-0.5.2}/ldpy/console.py

@@ -70,6 +70,12 @@ class LdpyConsole(code.InteractiveConsole):
         self._prefixes = dict(prefixes or {})
         self._prefix_cols = {k: 0 for k in self._prefixes}
         self._base = base
+        # The current graph and the current bindings are declarations too:
+        # like @prefix, a top-level @graph must survive to the next entry
+        # (otherwise `+{ ... }` after `@graph as g` sees no graph at all).
+        self._graph_var = None
+        self._bindings_var = None
+        self._counter = 0
 
     def runsource(self, source, filename=None, symbol="single"):
         """Transpile then compile one entry; True = incomplete entry
@@ -79,6 +85,10 @@ class LdpyConsole(code.InteractiveConsole):
         t.prefixes = dict(self._prefixes)
         t._prefix_col = dict(self._prefix_cols)
         t.base = self._base
+        t._graph_var = self._graph_var
+        t._bindings_var = self._bindings_var
+        # fresh names must not collide with those of the previous entries
+        t._ns_counter = self._counter
         try:
             result = t.run()
         except LdpySyntaxError as e:
@@ -98,6 +108,9 @@ class LdpyConsole(code.InteractiveConsole):
         self._prefixes = dict(t.prefixes)
         self._prefix_cols = dict(t._prefix_col)
         self._base = t.base
+        self._graph_var = t._graph_var
+        self._bindings_var = t._bindings_var
+        self._counter = t._ns_counter
         for w in result.warnings:
             self.write(str(w) + "\n")
         self.runcode(code_obj)

{linked_data_python-0.5.1 → linked_data_python-0.5.2}/ldpy/debug.py

@@ -92,11 +92,30 @@ def probe():
 #: 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",
+           "shadow_rel",
            "translate_breakpoints", "translate_frames",
            "snap_breakpoint_line", "snap_breakpoint_lines",
            "run_direct", "main"]
 
 
+def shadow_rel(source, root=None):
+    """Path of the shadow inside the output directory.
+
+    Without a root, the basename: the shadow sits beside the source, and two
+    files never meet. With one — a workspace whose whole build is gathered in
+    a single directory — the tree is mirrored, which is what keeps `a/m.ldpy`
+    and `b/m.ldpy` from writing the same `m.py`. A source outside the root
+    falls back to its basename rather than climbing out of the output
+    directory with `../`."""
+    name = os.path.basename(source)
+    if not root:
+        return name
+    rel = os.path.relpath(os.path.abspath(source), os.path.abspath(root))
+    if rel.startswith(os.pardir + os.sep) or rel == os.pardir:
+        return name
+    return rel
+
+
 def load_map(map_path):
     """Load a LanguageMap from a .ldpy.map file (JSON)."""
     with open(map_path, "r", encoding="utf-8") as f:
@@ -167,6 +186,10 @@ def main(argv=None):
                              "straight in the .ldpy)")
     parser.add_argument("-o", "--out", default=DEFAULT_OUT,
                         help="shadow directory (default: %(default)s)")
+    parser.add_argument("--root", metavar="DIR",
+                        help="tree root the shadow mirrors: the .py is "
+                             "written at OUT/<path of the source relative "
+                             "to DIR> (default: OUT/<basename>)")
     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",
@@ -201,8 +224,7 @@ def main(argv=None):
 
     try:
         py_path, map_path, result = build_file(
-            args.source, args.out,
-            rel=os.path.basename(args.source))
+            args.source, args.out, rel=shadow_rel(args.source, args.root))
     except LdpySyntaxError as e:
         print(str(e), file=sys.stderr)
         return 1

{linked_data_python-0.5.1 → linked_data_python-0.5.2}/ldpy/runtime.py

@@ -641,7 +641,6 @@ def add_to(graph, *triples, bindings=None):
         s2, p2, o2 = term(s), term(p), term(o)
         if s2 is not None and p2 is not None and o2 is not None:
             graph.add((s2, p2, o2))
-    return graph
 
 
 def remove_from(graph, *patterns, bindings=None):
@@ -665,13 +664,12 @@ def remove_from(graph, *patterns, bindings=None):
                     to_remove.add(inst)
         for tr in to_remove:
             graph.remove(tr)
-        return graph
+        return
     term = _materializer(bindings, keep_vars=True)
     for s, p, o in patterns:
         tr = tuple(None if isinstance(x, (Variable, bn)) else x
                    for x in (term(s), term(p), term(o)))
         graph.remove(tr)
-    return graph
 
 
 def graph(namespaces, base, *triples, bindings=None):

{linked_data_python-0.5.1 → linked_data_python-0.5.2}/ldpy/transpiler/core.py

@@ -345,13 +345,16 @@ class Transpiler:
         self.operand = False
         self.stmt_start = False
 
-    def _error(self, msg, line=None, col=None):
+    def _error(self, msg, line=None, col=None, incomplete=True):
         exc = LdpySyntaxError(msg, self.filename,
                               self.src_line if line is None else line,
                               self.src_col if col is None else col)
         # la console s'en sert pour distinguer « entrée incomplète » (îlot
-        # non fermé en fin de tampon) d'une vraie erreur de syntaxe
-        exc.at_eof = self.i >= self.n
+        # non fermé en fin de tampon) d'une vraie erreur de syntaxe.
+        # `incomplete=False` : erreur qu'une suite d'entrée ne répare pas
+        # (elle porte sur ce qui a déjà été lu), même si le curseur est en
+        # fin de tampon — sinon la console attendrait indéfiniment.
+        exc.at_eof = incomplete and self.i >= self.n
         raise exc
 
     def _warn(self, msg):
@@ -675,7 +678,7 @@ class Transpiler:
             if re.match(r"@(prefix|base|graph|bindings)\b", t[j:j + 10]):
                 self._close_copy()
                 self._take(m.end() - self.i)        # le mot-clé
-                while self._peek() in " \t":
+                while self._peek() in (" ", "\t"):
                     self._take(1)
                 if not self._try_prefix_or_base(scope_mode=name):
                     self._error("déclaration d'îlot attendue après "
@@ -1388,7 +1391,8 @@ class Transpiler:
             if not encl:
                 what = "prefix %s:" % name if kind == "prefix" else kind
                 self._error("nonlocal @%s : aucune déclaration englobante "
-                            "(comme le nonlocal de Python)" % what)
+                            "(comme le nonlocal de Python)" % what,
+                            incomplete=False)
             keep = encl[-1]
             target_col = self._scope_stack[keep][0]
             touched = [i for i in matches if i > keep]
@@ -1562,7 +1566,7 @@ class Transpiler:
         return self._take(m.end() - self.i)
 
     def _graph_ws_inline(self):
-        while self._peek() in " \t":
+        while self._peek() in (" ", "\t"):
             self._take(1)
 
     def _addremove_island(self, sign):
@@ -1581,7 +1585,7 @@ class Transpiler:
             self._error("'%s{ ... }' sans graphe courant : déclarez-le avec "
                         "'@graph <expression>' ou '@graph as g' (fiche 014), "
                         "ou donnez-le en suffixe — %s{ ... }(g)"
-                        % (sign, sign))
+                        % (sign, sign), incomplete=False)
         bvar = sfx_bindings if sfx_bindings else self._bindings_var
         fn = "add_to" if sign == "+" else "remove_from"
         args = [gvar]
@@ -2482,7 +2486,7 @@ class Transpiler:
             if word.upper() == "BOUND" and after == "(":
                 self._take(len(word) + 1)
                 self._e_ws()
-                if self._peek() not in "?$":
+                if self._peek() not in ("?", "$"):
                     self._error("BOUND attend une variable ?v")
                 self._take(1)
                 vm = _NAME_RE.match(t, self.i)

{linked_data_python-0.5.1 → linked_data_python-0.5.2/linked_data_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: linked-data-python
-Version: 0.5.1
+Version: 0.5.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.5.1 → linked_data_python-0.5.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "linked-data-python"
-version = "0.5.1"
+version = "0.5.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.5.1 → linked_data_python-0.5.2}/tests/test_console.py

@@ -94,3 +94,61 @@ def test_interactive_after_script(tmp_path):
     p = console("X\nex:b\n", args=("-i", str(script)))
     assert "URIRef('http://e/a')" in p.stdout   # les globals du script
     assert "URIRef('http://e/b')" in p.stdout   # et ses préfixes
+
+
+def test_current_graph_persists_across_entries():
+    """`@graph as g` then `+{ }` on the next line: the current graph is a
+    declaration like @prefix, it must survive the entry that declares it."""
+    p = console("@prefix ex: <http://e/> .\n"
+                "@graph as g\n"
+                "+{ ex:alice a ex:Person }\n"
+                "len(g)\n")
+    assert p.returncode == 0
+    assert "1" in results(p)
+
+
+def test_add_island_prints_nothing():
+    """`+{ }` is a statement: the console must not echo the graph."""
+    p = console("@prefix ex: <http://e/> .\n"
+                "@graph as g\n"
+                "+{ ex:alice a ex:Person }\n")
+    assert "Graph" not in p.stdout
+
+
+def test_current_bindings_persist_across_entries():
+    """`for @bindings as b in ...` names the bindings; the entries that
+    follow must still see the current graph declared before them."""
+    p = console("@prefix ex: <http://e/> .\n"
+                "@graph as g\n"
+                "for @bindings as b in [{\"n\": \"ana\"}]:\n"
+                "    +{ ex:p ex:name ?n }\n"
+                "\n"
+                "len(g)\n")
+    assert "1" in results(p)
+
+
+def test_add_without_current_graph_reports_at_once():
+    """An island that is complete but has no current graph is an error, not
+    an entry waiting to be finished: the console used to hang on it."""
+    p = console("@prefix ex: <http://e/> .\n"
+                "+{ ex:a ex:b ex:c }\n"
+                "'survivant'\n")
+    assert p.returncode == 0
+    assert "graphe courant" in p.stderr
+    assert "survivant" in p.stdout
+
+
+def test_graph_declaration_at_end_of_buffer():
+    """`@graph as g` with no trailing newline: the inline-whitespace scan
+    used to loop for ever on the empty string returned at end of text."""
+    from ldpy.transpiler.core import Transpiler
+    t = Transpiler("@graph as g", "<c>", emit_prelude=False)
+    assert t.run().code.startswith("g = ")
+
+
+def test_bound_at_end_of_buffer_is_an_error_not_a_crash():
+    from ldpy.transpiler import LdpySyntaxError
+    from ldpy.transpiler.core import Transpiler
+    import pytest
+    with pytest.raises(LdpySyntaxError):
+        Transpiler("e{ BOUND(", "<c>", emit_prelude=False).run()

{linked_data_python-0.5.1 → linked_data_python-0.5.2}/tests/test_debug.py

@@ -170,3 +170,44 @@ def test_cli_under_real_debugpy(tmp_path):
     p = run_debug(tmp_path, ["--listen", "127.0.0.1:0"])
     assert p.returncode == 0, p.stderr
     assert p.stdout.strip().endswith("2")
+
+
+# ------------------------------------------------- où le .py est matérialisé
+
+def test_shadow_rel_without_root_is_the_basename():
+    from ldpy.debug import shadow_rel
+    assert shadow_rel("/w/a/m.ldpy") == "m.ldpy"
+
+
+def test_shadow_rel_mirrors_the_tree_under_the_root():
+    from ldpy.debug import shadow_rel
+    assert shadow_rel(os.path.join("/w", "a", "m.ldpy"), "/w") == \
+        os.path.join("a", "m.ldpy")
+
+
+def test_shadow_rel_never_climbs_out_of_the_output_directory():
+    """A source outside the root would give '../…': the shadow would land
+    beside the build directory instead of inside it."""
+    from ldpy.debug import shadow_rel
+    assert shadow_rel("/elsewhere/m.ldpy", "/w") == "m.ldpy"
+
+
+def test_cli_root_keeps_same_named_files_apart(tmp_path):
+    """One build directory for the whole workspace: `a/m.ldpy` and
+    `b/m.ldpy` must not both write `m.py`."""
+    out = tmp_path / "build"
+    shadows = []
+    for folder in ("a", "b"):
+        d = tmp_path / folder
+        d.mkdir()
+        (d / "m.ldpy").write_text(SRC)
+        env = dict(os.environ, PYTHONPATH=REPO)
+        p = subprocess.run(
+            [sys.executable, "-m", "ldpy.debug", str(d / "m.ldpy"),
+             "-o", str(out), "--root", str(tmp_path), "--breakpoints", "2"],
+            capture_output=True, text=True, cwd=REPO, env=env, timeout=120)
+        assert p.returncode == 0, p.stderr
+        shadows.append(json.loads(p.stdout)["shadow"])
+    assert len(set(shadows)) == 2
+    assert all(os.path.isfile(s) for s in shadows)
+    assert os.path.basename(os.path.dirname(shadows[0])) == "a"

linked_data_python-0.5.2/tests/test_docs.py

@@ -0,0 +1,103 @@
+"""La documentation est exécutable : chaque bloc ``ldpy`` des pages de docs/
+est transpilé PUIS EXÉCUTÉ ; chaque bloc ``python`` est exécuté. Un snippet
+qui ne tourne pas ne peut pas rester dans la doc."""
+
+import glob
+import os
+import re
+
+import pytest
+
+REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+DOCS = sorted(glob.glob(os.path.join(REPO, "docs", "**", "*.md"),
+                        recursive=True))
+
+FENCE = re.compile(r"^```(\w+)\n(.*?)^```", re.M | re.S)
+
+
+def blocks(lang):
+    out = []
+    for path in DOCS:
+        text = open(path, encoding="utf-8").read()
+        for i, m in enumerate(FENCE.finditer(text)):
+            if m.group(1) == lang:
+                out.append(pytest.param(
+                    m.group(2),
+                    id="%s#%d" % (os.path.relpath(path, REPO), i)))
+    return out
+
+
+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
+    for quadrant in ("tutorials", "how-to", "reference", "explanation"):
+        assert any(r.startswith(quadrant + os.sep) for r in rels), quadrant
+
+
+@pytest.mark.parametrize("code", blocks("ldpy"))
+def test_ldpy_snippets_run(code):
+    from ldpy.transpiler import transpile
+    result = transpile(code, "<docs>")
+    exec(compile(result.code, "<docs>", "exec"), {"__name__": "docs"})
+
+
+@pytest.mark.parametrize("code", blocks("python"))
+def test_python_snippets_run(code):
+    exec(compile(code, "<docs>", "exec"), {"__name__": "docs"})
+
+
+# --------------------------------------------------------------------------
+# The same snippets, typed into the interactive console.
+#
+# The console transpiles ONE ENTRY AT A TIME: what a file keeps in a single
+# pass (the current @prefix, @graph, @bindings) has to survive from one entry
+# to the next. A doc snippet that runs as a file but not in the console is a
+# console bug, not a doc bug — hence this second pass over the same blocks.
+# --------------------------------------------------------------------------
+
+def _pasteable(code):
+    """A basic Python console (`code.InteractiveConsole`, what we build on)
+    ends a block on a blank line and has no bracketed paste. Blocks that
+    depend on either are out of scope here — CPython's own REPL is no
+    better."""
+    if '"""' in code or "'''" in code:
+        return False
+    lines = code.splitlines()
+    for i, line in enumerate(lines):
+        if line.strip():
+            continue
+        following = next((x for x in lines[i + 1:] if x.strip()), "")
+        if following.startswith((" ", "\t")):
+            return False            # blank line inside a block
+    return True
+
+
+def _console_output(code):
+    """Feed a snippet line by line, as one would type it; return everything
+    the console reported (errors and warnings)."""
+    import contextlib
+    import io
+    from ldpy.console import LdpyConsole
+
+    console = LdpyConsole()
+    reported = io.StringIO()
+    console.write = reported.write
+    lines = code.splitlines() + [""]
+    for line in lines:
+        # dedenting to column 0 closes the block above, as typing does
+        if console.buffer and line[:1] not in (" ", "\t", ""):
+            console.push("")
+        with contextlib.redirect_stdout(io.StringIO()), \
+                contextlib.redirect_stderr(reported):
+            console.push(line)
+    return reported.getvalue()
+
+
+@pytest.mark.parametrize("code", blocks("ldpy"))
+def test_ldpy_snippets_run_in_the_console(code):
+    if not _pasteable(code):
+        pytest.skip("block relies on paste, not on typing")
+    reported = _console_output(code)
+    errors = [ligne for ligne in reported.splitlines()
+              if ligne.strip() and "LdpyWarning" not in ligne]
+    assert not errors, "\n".join(errors)

linked_data_python-0.5.1/tests/test_docs.py

@@ -1,46 +0,0 @@
-"""La documentation est exécutable : chaque bloc ``ldpy`` des pages de docs/
-est transpilé PUIS EXÉCUTÉ ; chaque bloc ``python`` est exécuté. Un snippet
-qui ne tourne pas ne peut pas rester dans la doc."""
-
-import glob
-import os
-import re
-
-import pytest
-
-REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-DOCS = sorted(glob.glob(os.path.join(REPO, "docs", "**", "*.md"),
-                        recursive=True))
-
-FENCE = re.compile(r"^```(\w+)\n(.*?)^```", re.M | re.S)
-
-
-def blocks(lang):
-    out = []
-    for path in DOCS:
-        text = open(path, encoding="utf-8").read()
-        for i, m in enumerate(FENCE.finditer(text)):
-            if m.group(1) == lang:
-                out.append(pytest.param(
-                    m.group(2),
-                    id="%s#%d" % (os.path.relpath(path, REPO), i)))
-    return out
-
-
-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
-    for quadrant in ("tutorials", "how-to", "reference", "explanation"):
-        assert any(r.startswith(quadrant + os.sep) for r in rels), quadrant
-
-
-@pytest.mark.parametrize("code", blocks("ldpy"))
-def test_ldpy_snippets_run(code):
-    from ldpy.transpiler import transpile
-    result = transpile(code, "<docs>")
-    exec(compile(result.code, "<docs>", "exec"), {"__name__": "docs"})
-
-
-@pytest.mark.parametrize("code", blocks("python"))
-def test_python_snippets_run(code):
-    exec(compile(code, "<docs>", "exec"), {"__name__": "docs"})