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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: linked-data-python
-Version: 0.6.2
+Version: 0.6.4
 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.2 → linked_data_python-0.6.4}/ldpy/lsp/islanddoc.py

@@ -45,11 +45,13 @@ ISLANDS = {
     # -- declarations -------------------------------------------------------
 
     "prefix": IslandDoc(
-        "(declaration) @prefix ex: <IRI> .",
+        "(declaration) @prefix ex: <IRI> [as EX] .",
         "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.",
+        "A prefix is lexical: `ex:` on its own is never a value. When the "
+        "code needs the Namespace as an OBJECT — to `bind()` it on a graph, "
+        "to export it, to put it in a registry — `as EX` binds that object "
+        "to a Python name too. Declaring the prefix again in a deeper block "
+        "shadows it, the way a Python name would.",
         _DECLS, "prefix-bind-a-prefix"),
 
     "base": IslandDoc(
@@ -69,7 +71,9 @@ ISLANDS = {
         "(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.",
+        "and binds it to NAME; `global` and `nonlocal` widen the scope. "
+        "Either way the graph inherits the block's prefixes, so it "
+        "serialises with them.",
         _CURRENT, "graph-designate-or-create"),
 
     "bindings-decl": IslandDoc(

{linked_data_python-0.6.2 → linked_data_python-0.6.4}/ldpy/pygments_lexer.py

@@ -254,6 +254,10 @@ _NO_CURRENT_GRAPH = re.compile(r"sans graphe courant")
 #: input from looping.
 _MAX_SYNTHETIC = 24
 
+#: `as EX` closing a prefix declaration (record ldpy/027).
+_PREFIX_AS_RE = re.compile(
+    r"(>)(\s+)(as)(\s+)([A-Za-z_]\w*)(?=\s*\.)")
+
 #: Namespace of the synthetic prefixes. Never resolved — the map is thrown
 #: away after the tokens are read — but it has to be a legal IRI.
 _SYNTHETIC_NS = "urn:x-ldpy-highlight:"
@@ -400,10 +404,26 @@ class LdpyLexer(Lexer):
 
     # -- the ldpy-specific regions of an island body -------------------------
 
+    def _emit_prefix_as(self, text, m):
+        """The `as EX` of a prefix declaration: a keyword and a Python name."""
+        def emit(offset):
+            yield offset + m.start(3), Keyword, m.group(3)
+            yield offset + m.end(3), Text, m.group(4)
+            yield offset + m.start(5), Name.Variable, m.group(5)
+        return emit
+
     def _regions(self, text, flavour, is_query=False):
         """Locate what no Turtle or SPARQL lexer can read: interpolations and
         nested islands. Each becomes a (start, end, emit) region."""
         regions = []
+        if flavour == "turtle":
+            # `@prefix ex: <IRI> as EX .` (record ldpy/027): Turtle's own
+            # lexer knows the directive but not the clause, and would mark it
+            # Error. Mask it and emit it ourselves.
+            m = _PREFIX_AS_RE.search(text)
+            if m:
+                regions.append((m.start(3), m.end(5),
+                                self._emit_prefix_as(text, m)))
         i, n = 0, len(text)
         while i < n:
             c = text[i]

{linked_data_python-0.6.2 → linked_data_python-0.6.4}/ldpy/runtime.py

@@ -708,6 +708,30 @@ def new_graph(namespaces, base, identifier=None):
     return g
 
 
+def designate(namespaces, graph):
+    """'@graph EXPR' — the designated graph inherits the block's prefixes.
+
+    A graph CREATED by '@graph as g' already serialises with the prefixes in
+    scope (:func:`new_graph`); a graph merely DESIGNATED did not, so the same
+    block writing the same prefixed names into two graphs produced two
+    different serialisations. That was an inconsistency rather than a
+    decision, and record ldpy/027 settles it: both inherit.
+
+    The bindings are added to the graph's OWN manager, never by swapping it
+    for the shared cached one — a designated graph belongs to the caller and
+    may already carry bindings that matter. Anything that is not a graph, or
+    a backend without a namespace manager, passes through untouched: the
+    declaration's job is to designate, and it must not fail on the shape of
+    what it is given.
+    """
+    if namespaces:
+        try:
+            _backend.bind_namespaces(graph, namespaces)
+        except (AttributeError, TypeError):
+            pass                    # not a graph, or no binding support
+    return graph
+
+
 def add_to(graph, *triples, bindings=None):
     """'+{ ... }': instantiate and add to the current graph (record ldpy/014).
     A triple with a term still unbound is dropped — one cannot write an

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

@@ -1320,6 +1320,7 @@ class Transpiler:
         if end is None:
             return False
         k = self._skip_ws_ahead(end)
+        as_name, k = self._prefix_as_clause(k)
         if k >= self.n or t[k] != ".":
             return False
         # consommation effective
@@ -1348,9 +1349,40 @@ class Transpiler:
                                 scope_mode)
             gen = "__namespaces__[%r] = %s.Namespace(%r)" % (
                 prefix, RUNTIME_ALIAS, resolved)
+            if as_name:
+                # `as EX` binds the Namespace OBJECT to a Python name, for the
+                # code that needs it to survive the block (record ldpy/027).
+                gen = "__namespaces__[%r] = %s = %s.Namespace(%r)" % (
+                    prefix, as_name, RUNTIME_ALIAS, resolved)
+                if scope_mode:
+                    gen = "%s %s; %s" % (scope_mode, as_name, gen)
         self._end_island(kind, mark, gen)
         return True
 
+    def _prefix_as_clause(self, k):
+        """`as NAME` before a @prefix declaration's closing '.', or nothing.
+
+        `@prefix` is lexical and yields no Python value, which the corpus
+        study showed to be its most attested limit: code that must keep the
+        `Namespace` as an OBJECT — to `g.bind()` it, to export it, to put it
+        in a registry — had no translation at all (record ldpy/027). `as EX`
+        binds that object, without making a bare `ex:` a value (records
+        ldpy/002 and 004 refuse that, and still do).
+
+        Returns `(name, index after the clause)`; `(None, k)` when absent.
+        """
+        t = self.text
+        if t[k:k + 2] != "as":
+            return None, k
+        if k + 2 < self.n and _name_char(t[k + 2]):
+            return None, k                      # `assets`, not `as`
+        j = self._skip_ws_ahead(k + 2)
+        m = _PYNAME_RE.match(t, j)
+        if not m or j == k + 2:
+            self._error("nom Python attendu après 'as' dans la "
+                        "déclaration @prefix")
+        return m.group(0), self._skip_ws_ahead(m.end())
+
     def _prefix_firi_decl(self, j, prefix, scope_mode=None):
         """Consomme `@prefix p: f<...> .` (self.i sur '@', j sur 'f').
         Sans interpolation : déclaration statique ordinaire. Avec : préfixe
@@ -1360,6 +1392,10 @@ class Transpiler:
         self._take(j - self.i)              # '@prefix p:' + blancs
         parts = self._take_firi_parts()
         self._g_ws()
+        as_name, k = self._prefix_as_clause(self.i)
+        if as_name:
+            self._take(k - self.i)
+            self._g_ws()
         if self._peek() != ".":
             self._error("'.' attendu pour clore la déclaration @prefix")
         self._take(1)
@@ -1379,6 +1415,11 @@ class Transpiler:
                                 scope_mode)
             gen = "__namespaces__[%r] = %s.Namespace(%r)" % (
                 prefix, RUNTIME_ALIAS, resolved)
+            if as_name:
+                gen = "__namespaces__[%r] = %s = %s.Namespace(%r)" % (
+                    prefix, as_name, RUNTIME_ALIAS, resolved)
+                if scope_mode:
+                    gen = "%s %s; %s" % (scope_mode, as_name, gen)
         else:
             # global/nonlocal : réutiliser la variable de la liaison cible si
             # elle est dynamique — c'est elle que les usages du dehors lisent
@@ -1392,8 +1433,14 @@ class Transpiler:
             gen = "%s = %s.Namespace(%s.firi(%s)); __namespaces__[%r] = %s" % (
                 var, RUNTIME_ALIAS, RUNTIME_ALIAS,
                 self._firi_args(parts), prefix, var)
+            if as_name:
+                # `as EX` on a DYNAMIC prefix binds the Namespace built from
+                # the IRI resolved at that point — the same object the
+                # prefix itself uses, so the two can never disagree.
+                gen += "; %s = %s" % (as_name, var)
             if scope_mode:
-                gen = "%s %s; %s" % (scope_mode, var, gen)
+                names = var if not as_name else "%s, %s" % (var, as_name)
+                gen = "%s %s; %s" % (scope_mode, names, gen)
         self._end_island("prefix", mark, gen)
         return True
 
@@ -1579,7 +1626,10 @@ class Transpiler:
                     self._error("expression attendue après '@graph'")
                 if "\n" in expr:
                     self._error("l'expression de '@graph' tient sur sa ligne")
-                rhs = "(%s)" % expr
+                # The designated graph inherits the block's prefixes, exactly
+                # as a created one does (record ldpy/027).
+                rhs = "%s.designate(__namespaces__, (%s))" % (
+                    RUNTIME_ALIAS, expr)
         self._graph_ws_inline()
         if self._peek() not in "\n\r#;" and self._peek() != "":
             self._error("fin de ligne attendue après la déclaration @graph")

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "linked-data-python"
-version = "0.6.2"
+version = "0.6.4"
 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.2 → linked_data_python-0.6.4}/tests/test_current_graph.py

@@ -288,3 +288,46 @@ def test_compound_suite_does_not_capture_python(run):
         """))
     assert g["n"] == 5 and g["d"] == {"a": 1}
     assert g["f"]("x") == "x" and g["keys"] == {"b"}
+
+
+# --------------------------------------------------------------- record 027
+# A graph CREATED by `@graph as g` already carried the block's prefixes; a
+# graph merely DESIGNATED carried none, so the same block writing the same
+# prefixed names into two graphs serialised them differently. The corpus
+# study met this as nineteen hand-written `g.bind()` calls in one function.
+
+def test_a_designated_graph_inherits_the_block_prefixes(run):
+    ns, _ = run("from rdflib import Graph\n"
+                "@prefix ex: <http://example.org/ns#> .\n"
+                "mine = Graph()\n"
+                "@graph mine\n"
+                "+{ ex:a ex:p 1 }\n")
+    assert ("ex", URIRef("http://example.org/ns#")) in list(
+        ns["mine"].namespaces())
+
+
+def test_created_and_designated_serialise_alike(run):
+    """The point of the fix: two graphs the same block fills the same way
+    must not differ in their serialisation."""
+    ns, _ = run("from rdflib import Graph\n"
+                "@prefix ex: <http://example.org/ns#> .\n"
+                "@graph as made\n"
+                "+{ ex:a ex:p 1 }\n"
+                "given = Graph()\n"
+                "@graph given\n"
+                "+{ ex:a ex:p 1 }\n")
+    assert "@prefix ex:" in ns["made"].serialize(format="turtle")
+    assert "@prefix ex:" in ns["given"].serialize(format="turtle")
+
+
+def test_designating_keeps_bindings_the_caller_already_had(run):
+    """A designated graph belongs to its caller: the block's prefixes are
+    ADDED to its own manager, never swapped for a shared one."""
+    ns, _ = run("from rdflib import Graph, Namespace\n"
+                "@prefix ex: <http://example.org/ns#> .\n"
+                "mine = Graph()\n"
+                'mine.bind("mine", Namespace("http://mine.example/"))\n'
+                "@graph mine\n"
+                "+{ ex:a ex:p 1 }\n")
+    got = {p for p, _ in ns["mine"].namespaces()}
+    assert "ex" in got and "mine" in got

{linked_data_python-0.6.2 → linked_data_python-0.6.4}/tests/test_prefix_scoping.py

@@ -300,3 +300,71 @@ def test_never_declared_prefix_gives_no_warning():
     r = transpile("d = {foo:bar}\nx = arr[i:j]\n")
     assert r.warnings == []
     assert r.code == "d = {foo:bar}\nx = arr[i:j]\n"
+
+# --------------------------------------------------------------- record 027
+# `@prefix` is lexical and yields no Python value, which the corpus study
+# showed to be its most attested limit: code that must keep the Namespace as
+# an OBJECT — to `g.bind()` it, to export it, to put it in a registry — had
+# no translation at all. `as EX` binds that object. A bare `ex:` is still
+# never a value (records ldpy/002 and 004).
+
+def test_as_binds_the_namespace_object(run):
+    ns, _ = run("@prefix ex: <http://example.org/ns#> as EX .\n"
+                "iri = EX.Thing\n"
+                "prefixed = ex:Thing\n")
+    assert str(ns["EX"]) == "http://example.org/ns#"
+    assert ns["iri"] == ns["prefixed"]
+
+
+def test_as_serves_the_three_forms_the_corpus_needed(run):
+    ns, _ = run("from rdflib import Graph\n"
+                "@prefix ex: <http://example.org/ns#> as EX .\n"
+                "g = Graph()\n"
+                "g.bind('ex', EX)\n"
+                "registry = {'ex': EX}\n"
+                "exported = EX\n")
+    assert ("ex", URIRef("http://example.org/ns#")) in list(
+        ns["g"].namespaces())
+    assert ns["registry"]["ex"] is ns["exported"]
+
+
+def test_the_prefix_still_works_without_as(run):
+    ns, _ = run("@prefix ex: <http://example.org/ns#> .\n"
+                "t = ex:Thing\n")
+    assert str(ns["t"]) == "http://example.org/ns#Thing"
+    assert "EX" not in ns
+
+
+def test_as_needs_a_name():
+    with pytest.raises(LdpySyntaxError) as e:
+        transpile("@prefix ex: <http://example.org/> as .\n", "t.ldpy")
+    assert "as" in e.value.msg
+
+
+def test_a_prefix_named_as_something_is_not_an_as_clause(run):
+    """`as` must be a whole word: a declaration is not broken by an IRI
+    followed by nothing, nor by a name that merely starts with 'as'."""
+    ns, _ = run("@prefix ex: <http://example.org/ns#> as assets .\n"
+                "t = ex:Thing\n")
+    assert str(ns["assets"]) == "http://example.org/ns#"
+
+
+def test_as_works_on_a_dynamic_prefix_too(run):
+    """`@prefix p: f<…> as P .` — the form the corpus actually needed first.
+    Every IRI of the region that motivated `as` is computed at run time, so
+    `as` on the static form alone would not have covered its own use case."""
+    ns, _ = run("host = 'example.org'\n"
+                "@prefix dyn: f<http://{host}/ns#> as DYN .\n"
+                "a = DYN['x']\n"
+                "b = dyn:x\n")
+    assert str(ns["DYN"]) == "http://example.org/ns#"
+    assert ns["a"] == ns["b"]
+
+
+def test_a_dynamic_as_name_follows_the_scope_modifier(run):
+    ns, _ = run("host = 'example.org'\n"
+                "def f():\n"
+                "    global @prefix dyn: f<http://{host}/ns#> as DYN .\n"
+                "f()\n"
+                "seen = str(DYN)\n")
+    assert ns["seen"] == "http://example.org/ns#"