linked-data-python 0.6.3__tar.gz → 0.6.5__tar.gz

{linked_data_python-0.6.3 → linked_data_python-0.6.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: linked-data-python
-Version: 0.6.3
+Version: 0.6.5
 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.3 → linked_data_python-0.6.5}/ldpy/runtime.py

@@ -602,7 +602,21 @@ class Bindings(dict):
 def as_bindings_iter(iterable):
     """'for @bindings in ...' (record ldpy/017): every element becomes the
     current bindings of the body. An m{ ... } yields its solutions (anonymous
-    variables excluded); any other iterable must produce mappings."""
+    variables excluded); any other iterable must produce mappings or
+    namedtuple-like rows.
+
+    Two duck-typed shapes are accepted for a row, and both are needed because
+    CPython and MicroPython expose different halves of the namedtuple API:
+
+    - `_fields`, a sequence of names in value order — CPython's
+      `collections.namedtuple`, a `pandas.DataFrame.itertuples()` row, and
+      ldpy's own Row from `m{ }` (record ldpy/016);
+    - `_asdict()`, when `_fields` is absent — this is the ONLY one
+      MicroPython's `collections.namedtuple` exposes, and only when the
+      firmware was built with `MICROPY_PY_COLLECTIONS_NAMEDTUPLE__ASDICT`.
+      Keying off `_fields` alone would have left `for @bindings` broken on
+      device, in a file record ldpy/026 requires to emit the same code on
+      both backends."""
     if isinstance(iterable, Match):
         for sm in iterable.solutions():
             b = Bindings()
@@ -617,10 +631,17 @@ def as_bindings_iter(iterable):
             yield item
         elif hasattr(item, "items"):
             yield Bindings(item)
+        elif hasattr(item, "_fields"):
+            b = Bindings()
+            b.update(zip(item._fields, item))
+            yield b
+        elif hasattr(item, "_asdict"):
+            # MicroPython's namedtuple: no _fields, _asdict() instead.
+            yield Bindings(item._asdict())
         else:
             raise TypeError(
-                "for @bindings in ...: the iterable must produce mappings, "
-                "got %s" % type(item).__name__)
+                "for @bindings in ...: the iterable must produce mappings "
+                "or namedtuple-like rows, got %s" % type(item).__name__)
 
 
 _EXPR_CLASS = None
@@ -732,6 +753,24 @@ def designate(namespaces, graph):
     return graph
 
 
+def bind_prefix(graph, prefix, ns):
+    """'@prefix' declared while a graph is current — bind it there too.
+
+    :func:`designate` binds the prefixes in scope at the moment of
+    designation. A prefix declared AFTER, while that same graph is still the
+    current one, is in scope for it just as much: binding it here is what
+    makes the two orders serialise alike, instead of making the position of a
+    declaration a trap (record ldpy/027).
+
+    Same tolerance as :func:`designate`: anything that is not a graph, or a
+    backend without a namespace manager, passes through untouched.
+    """
+    try:
+        _backend.bind_namespaces(graph, {prefix: ns})
+    except (AttributeError, TypeError):
+        pass                        # not a graph, or no binding support
+
+
 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.3 → linked_data_python-0.6.5}/ldpy/sparql.py

@@ -360,6 +360,47 @@ def DATATYPE(t):
     return t.datatype or XSD.string
 
 
+def STRLANG(t, lang):
+    """STRLANG(lexical form, language tag).
+
+    The way to give a bound variable a language tag: `?v@en` is refused —
+    a variable is already bound to a COMPLETE term, so there is nothing to
+    interpret (record ldpy/027) — whereas STRLANG says explicitly to take
+    the lexical form and read it as a tagged literal.
+
+    SPARQL 1.1 wants a plain literal with no tag and no datatype, and gives
+    no result otherwise; here that is an error, which is what the rest of
+    this module does with an argument of the wrong shape.
+    """
+    if not isinstance(t, Literal):
+        raise SparqlError("STRLANG wants a literal as its first argument")
+    if t.language or (t.datatype and t.datatype != XSD.string):
+        raise SparqlError(
+            "STRLANG wants a plain literal: %r already carries a %s"
+            % (str(t), "language tag" if t.language else "datatype"))
+    tag = str(lang)
+    if not tag:
+        raise SparqlError("STRLANG wants a non-empty language tag")
+    return Literal(str(t), lang=tag)
+
+
+def STRDT(t, dt):
+    """STRDT(lexical form, datatype IRI).
+
+    The counterpart of :func:`STRLANG` for `?v^^dt`, refused for the same
+    reason (record ldpy/027).
+    """
+    if not isinstance(t, Literal):
+        raise SparqlError("STRDT wants a literal as its first argument")
+    if t.language or (t.datatype and t.datatype != XSD.string):
+        raise SparqlError(
+            "STRDT wants a plain literal: %r already carries a %s"
+            % (str(t), "language tag" if t.language else "datatype"))
+    if not isinstance(dt, URIRef):
+        raise SparqlError("STRDT wants an IRI as its datatype")
+    return Literal(str(t), datatype=dt)
+
+
 def IRI(t, base=None):
     """IRI(str) — resolved against the lexical base of the call site."""
     s = str(t)

{linked_data_python-0.6.3 → linked_data_python-0.6.5}/ldpy/transpiler/core.py

@@ -1356,9 +1356,25 @@ class Transpiler:
                     prefix, as_name, RUNTIME_ALIAS, resolved)
                 if scope_mode:
                     gen = "%s %s; %s" % (scope_mode, as_name, gen)
+        if kind == "prefix":
+            gen = self._bind_on_current_graph(gen, prefix)
         self._end_island(kind, mark, gen)
         return True
 
+    def _bind_on_current_graph(self, gen, prefix):
+        """Lie aussi le préfixe sur le graphe courant, s'il y en a un.
+
+        `@graph` lie les préfixes en portée au moment de la désignation. Un
+        préfixe déclaré APRÈS, tant que ce graphe reste courant, est en
+        portée pour lui tout autant : le lier ici est ce qui fait que les
+        deux ordres d'écriture sérialisent pareil, au lieu de faire de la
+        position d'une déclaration un piège (fiche 027).
+        """
+        if not self._graph_var:
+            return gen
+        return gen + "; %s.bind_prefix(%s, %r, __namespaces__[%r])" % (
+            RUNTIME_ALIAS, self._graph_var, prefix, prefix)
+
     def _prefix_as_clause(self, k):
         """`as NAME` before a @prefix declaration's closing '.', or nothing.
 
@@ -1392,6 +1408,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)
@@ -1411,6 +1431,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
@@ -1424,8 +1449,15 @@ 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)
+        gen = self._bind_on_current_graph(gen, prefix)
         self._end_island("prefix", mark, gen)
         return True
 
@@ -1965,10 +1997,36 @@ class Transpiler:
         if not m:
             self._error("nom de variable attendu après '%s'" % sigil)
         name = self._take(len(m.group(0)))
+        self._refuse_suffix_on_variable(sigil, name)
         if self._match_vars is not None and name not in self._match_vars:
             self._match_vars.append(name)
         return "%s.Variable(%r)" % (RUNTIME_ALIAS, name)
 
+    def _refuse_suffix_on_variable(self, sigil, name):
+        """`?v@en` and `?v^^xsd:int` are refused, and say why.
+
+        Sticking an RDF suffix on an *interpolation* is meaningful — the
+        Python value is the lexical form, and the suffix says how to read
+        it.  Sticking one on a variable is not: a variable is already bound
+        to a complete term, and there is nothing left to interpret.  Record
+        027 closes the question — the language refuses rather than coerces
+        — so the refusal has to name itself; before this, the parser only
+        complained that the island's closing brace was missing."""
+        c = self._peek()
+        m = _LANGTAG_RE.match(self.text, self.i)
+        if c == "@" and m:
+            what, written, advice = "de langue", m.group(0), "@en"
+        elif c == "^" and self._peek(1) == "^":
+            what, written, advice = "de type", "^^...", "^^xsd:string"
+        else:
+            return
+        self._error(
+            "suffixe %s interdit sur une variable : '%s%s%s' — une variable "
+            "est déjà liée à un terme complet, il n'y a rien à interpréter. "
+            "Pour construire un littéral, coller le suffixe à une "
+            "interpolation : '{expr}%s' (fiche 027)"
+            % (what, sigil, name, written, advice))
+
     def _g_node(self, triples, gctx):
         """Records the term as a `part` of the island, then parses it.
 
@@ -2320,6 +2378,11 @@ class Transpiler:
         "STRBEFORE", "STRAFTER", "REPLACE", "REGEX", "ABS", "ROUND", "CEIL",
         "FLOOR", "SAMETERM", "ISIRI", "ISURI", "ISBLANK", "ISLITERAL",
         "ISNUMERIC", "LANGMATCHES", "ENCODE_FOR_IRI",
+        # STRLANG / STRDT : la façon de dire explicitement ce que `?v@en` et
+        # `?v^^dt` ne disent pas — une variable est liée à un terme complet,
+        # le suffixe est donc refusé (fiche 027) et ces deux-ci sont le
+        # chemin propre, en SPARQL standard.
+        "STRLANG", "STRDT",
     ))
 
     def _take_enode(self):

{linked_data_python-0.6.3 → linked_data_python-0.6.5}/linked_data_python.egg-info/PKG-INFO

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

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

@@ -213,6 +213,60 @@ def test_for_bindings_nested_masking(run):
     assert g["a"] == Literal(2) and g["b"] == Literal(1)
 
 
+def test_for_bindings_over_namedtuples(run):
+    g, _ = run(textwrap.dedent("""\
+        from collections import namedtuple
+        @prefix ex: <http://e/> .
+        @graph as g
+        Row = namedtuple("Row", ["id", "value"])
+        rows = [Row("a", 1), Row("b", 2)]
+        for @bindings in rows:
+            +{ ex:{?id} ex:value ?value }
+        n = len(g)
+        """))
+    assert g["n"] == 2
+    assert (URIRef("http://e/a"), URIRef("http://e/value"), Literal(1)) in g["g"]
+    assert (URIRef("http://e/b"), URIRef("http://e/value"), Literal(2)) in g["g"]
+
+
+def test_for_bindings_over_rows_of_match(run):
+    g, _ = run(textwrap.dedent("""\
+        @prefix ex: <http://e/> .
+        @graph as src
+        +{ ex:c1 ex:reading 10 . ex:c2 ex:reading 25 }
+        @graph as out
+        rows = list(m{ ?s ex:reading ?v }(src))
+        for @bindings in rows:
+            +{ ?s ex:hasValue e{ ?v * 2 } }
+        vals = sorted(int(o) for s, o in m{ ?s ex:hasValue ?o }(out))
+        """))
+    assert g["vals"] == [20, 50]
+
+
+def test_for_bindings_over_a_micropython_style_row(run):
+    """MicroPython's `collections.namedtuple` exposes `_asdict()` and NOT
+    `_fields` — the reverse of CPython. `runtime.py` emits the same code on
+    both backends (record ldpy/026), so the row shape of the smaller one has
+    to be accepted too, or `for @bindings` is broken on device."""
+    g, _ = run(textwrap.dedent("""\
+        @prefix ex: <http://e/> .
+        @graph as g
+
+        class URow:                      # ce que voit MicroPython
+            def __init__(self, **kw):
+                self._d = kw
+            def _asdict(self):
+                return dict(self._d)
+
+        rows = [URow(id="a", value=1), URow(id="b", value=2)]
+        for @bindings in rows:
+            +{ ex:{?id} ex:value ?value }
+        n = len(g)
+        """))
+    assert g["n"] == 2
+    assert (URIRef("http://e/a"), URIRef("http://e/value"), Literal(1)) in g["g"]
+
+
 def test_for_bindings_non_mapping_raises(run):
     g, r = run("collected = []\n")
     src = "for @bindings in [1]:\n    pass\n"

{linked_data_python-0.6.3 → linked_data_python-0.6.5}/tests/test_current_graph.py

@@ -320,6 +320,58 @@ def test_created_and_designated_serialise_alike(run):
     assert "@prefix ex:" in ns["given"].serialize(format="turtle")
 
 
+def test_a_prefix_declared_after_the_designation_binds_too(run):
+    """The position of a declaration is not a trap: as long as the graph is
+    the current one, a prefix declared after `@graph` is in scope for it and
+    binds there, exactly like those declared before."""
+    ns, _ = run("from rdflib import Graph\n"
+                "before = 1\n"
+                "@prefix a: <http://a/> .\n"
+                "mine = Graph()\n"
+                "@graph mine\n"
+                "@prefix b: <http://b/> .\n"
+                "+{ a:s a:p a:o . b:s b:p b:o }\n")
+    got = {p for p, _ in ns["mine"].namespaces()}
+    assert "a" in got and "b" in got
+
+
+def test_both_declaration_orders_serialise_alike(run):
+    """The reason the previous test matters: swapping the two lines must not
+    change what comes out of the serialiser."""
+    src = ("from rdflib import Graph\n"
+           "mine = Graph()\n"
+           "%s"
+           "+{ late:s late:p late:o }\n")
+    ns_before, _ = run(src % ("@prefix late: <http://late/> .\n"
+                              "@graph mine\n"))
+    ns_after, _ = run(src % ("@graph mine\n"
+                             "@prefix late: <http://late/> .\n"))
+    assert (ns_before["mine"].serialize(format="turtle")
+            == ns_after["mine"].serialize(format="turtle"))
+
+
+def test_a_dynamic_prefix_declared_after_the_designation_binds_too(run):
+    """Same rule for the f-IRI form, which goes through its own emission
+    path and would otherwise drift from the static one."""
+    ns, _ = run("from rdflib import Graph\n"
+                "mine = Graph()\n"
+                "host = 'example.org'\n"
+                "@graph mine\n"
+                "@prefix dyn: f<http://{host}/ns#> .\n"
+                "+{ dyn:a dyn:p 1 }\n")
+    assert ("dyn", URIRef("http://example.org/ns#")) in list(
+        ns["mine"].namespaces())
+
+
+def test_no_current_graph_means_no_binding_call(run):
+    """A prefix declared with no graph in scope emits nothing extra — the
+    check is on the generated code, so the common case stays untouched."""
+    code = T("""
+        @prefix ex: <http://example.org/ns#> .
+        """).code
+    assert "bind_prefix" not in code
+
+
 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."""

{linked_data_python-0.6.3 → linked_data_python-0.6.5}/tests/test_debug_stepping.py

@@ -220,7 +220,14 @@ def test_pas_entrant_dans_une_fonction_ldpy(traces):
     """`step in` sur `build(3)` entre dans le corps ldpy de la fonction, et
     `step out` en ressort — le tout en coordonnées .ldpy."""
     stops = traces["fonction"]
-    assert [st.line for st in stops][:3] == [4, 3, 4]
+    lignes = [st.line for st in stops][:3]
+    assert lignes[:2] == [4, 3]
+    # Sortir de `build` rend la main SUR la ligne d'appel (4) à partir de
+    # CPython 3.11 ; sur 3.10 la ligne courante a déjà avancé (5). Les deux
+    # sont des arrêts sur une région .ldpy et le geste a bien changé de
+    # région : l'invariant de la fiche 103 tient des deux côtés. Ce qui est
+    # propre à ldpy, et donc ce que ce test doit serrer, c'est la PROFONDEUR.
+    assert lignes[2] in (4, 5)
     assert stops[1].depth == stops[0].depth + 1
     assert stops[2].depth == stops[0].depth
 

{linked_data_python-0.6.3 → linked_data_python-0.6.5}/tests/test_islands_terms.py

@@ -182,3 +182,66 @@ def test_datatype_interpolation_unclosed_is_an_error(run, prefixes):
     from ldpy.transpiler import LdpySyntaxError
     with pytest.raises(LdpySyntaxError):
         run(prefixes + "dt = xsd:date\nx = \"1\"^^{dt\n")
+
+
+# --------------------------------------------------------------- record 027
+# `{expr}@en` is meaningful — the Python value is the lexical form and the
+# suffix says how to read it.  `?v@en` is not: a variable is already bound to
+# a complete term.  Maxime closed the question on 2026-09-03 (refuse, do not
+# coerce); what this checks is that the refusal names itself, since before it
+# the parser only complained about a missing closing brace.
+
+def test_language_suffix_on_a_variable_is_refused(prefixes):
+    import pytest
+    from ldpy.transpiler import LdpySyntaxError
+    with pytest.raises(LdpySyntaxError) as exc:
+        transpile(prefixes + "@graph as g\n+{ ex:s ex:p ?v@fr-BE }\n")
+    assert "?v@fr-BE" in str(exc.value)
+    assert "{expr}@en" in str(exc.value)
+
+
+def test_datatype_suffix_on_a_variable_is_refused(prefixes):
+    import pytest
+    from ldpy.transpiler import LdpySyntaxError
+    with pytest.raises(LdpySyntaxError) as exc:
+        transpile(prefixes + "@graph as g\n+{ ex:s ex:p ?v^^xsd:integer }\n")
+    assert "suffixe de type" in str(exc.value)
+
+
+def test_the_refusal_reaches_every_island_that_binds_variables(prefixes):
+    import pytest
+    from ldpy.transpiler import LdpySyntaxError
+    for island in ("+{ ex:s ex:p ?v@en }", "-{ ex:s ex:p ?v@en }",
+                   "for b in m{ ?s ex:p ?v@en }: pass"):
+        with pytest.raises(LdpySyntaxError):
+            transpile(prefixes + "@graph as g\n" + island + "\n")
+
+
+def test_strlang_is_the_way_the_refusal_leaves_open(run, prefixes):
+    """The refusal above is only defensible if saying it explicitly is
+    possible. STRLANG and STRDT are that way, in `+{ }` and `-{ }`; they need
+    a `@bindings` in scope, like any `e{ }` used as a term there."""
+    g, _ = run(prefixes + "@graph as g\n@bindings as b\n"
+               '+{ ex:s ex:p e{ STRLANG("bonjour", "en") } }\n'
+               '+{ ex:s ex:q e{ STRDT("42", xsd:integer) } }\n')
+    got = {t[2] for t in g["g"]}
+    assert Literal("bonjour", lang="en") in got
+    assert Literal("42", datatype=XSD.integer) in got
+
+
+def test_strlang_in_a_match_island_stays_refused(prefixes):
+    """`e{ }` as a matching filter is out of scope by decision, not by
+    omission (record ldpy/017) — adding STRLANG did not open that door."""
+    import pytest
+    from ldpy.transpiler import LdpySyntaxError
+    with pytest.raises(LdpySyntaxError) as exc:
+        transpile(prefixes + "@graph as g\n"
+                  'for b in m{ ?s ex:p e{ STRLANG(?v, "en") } }: pass\n')
+    assert "017" in str(exc.value) or "hors périmètre" in str(exc.value)
+
+
+def test_a_bare_variable_and_a_suffixed_interpolation_still_work(run, prefixes):
+    g, _ = run(prefixes + "@graph as g\nv = 'x'\n"
+               "+{ ex:s ex:p {v}@en }\n"
+               "-{ ex:s ex:q ?any }\n")
+    assert list(g["g"])[0][2] == Literal("x", lang="en")

{linked_data_python-0.6.3 → linked_data_python-0.6.5}/tests/test_prefix_scoping.py

@@ -347,3 +347,24 @@ def test_a_prefix_named_as_something_is_not_an_as_clause(run):
     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#"

{linked_data_python-0.6.3 → linked_data_python-0.6.5}/tests/test_sparql_expr.py

@@ -12,9 +12,10 @@ from ldpy.sparql import SparqlError
 P = "@prefix ex: <http://example.org/ns#> .\n"
 
 
-def make(src):
+def make(src, prefixes=""):
     g = {"__name__": "t"}
-    exec(compile(transpile(P + src, "<t>").code, "<t>", "exec"), g)
+    exec(compile(transpile(P + prefixes + src, "<t>").code, "<t>", "exec"),
+         g)
     return g
 
 
@@ -155,6 +156,35 @@ def test_lang_builtins():
     assert g["m"].ebv(v=v) is True
 
 
+def test_strlang_and_strdt_build_the_term_a_suffix_cannot():
+    """`?v@en` and `?v^^dt` are refused — a variable is already bound to a
+    complete term (record ldpy/027). STRLANG and STRDT are the explicit way
+    to say what the suffix cannot, and they are standard SPARQL 1.1."""
+    g = make('a = e{ STRLANG(?v, "en") }\n'
+             "b = e{ STRDT(?v, xsd:integer) }\n",
+             prefixes='@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .\n')
+    assert g["a"](v=Literal("hello")) == Literal("hello", lang="en")
+    assert g["b"](v=Literal("42")) == Literal("42", datatype=XSD.integer)
+
+
+def test_strlang_and_strdt_refuse_a_term_that_is_already_complete():
+    """SPARQL 1.1 gives no result for an argument that already carries a tag
+    or a datatype; here that is an error, like the rest of this module."""
+    g = make('a = e{ STRLANG(?v, "en") }\nb = e{ STRDT(?v, ex:dt) }\n')
+    with pytest.raises(SparqlError):
+        g["a"](v=Literal("hello", lang="fr"))
+    with pytest.raises(SparqlError):
+        g["b"](v=Literal("42", datatype=XSD.integer))
+    with pytest.raises(SparqlError):
+        g["a"](v=URIRef("http://example.org/ns#s"))
+
+
+def test_strlang_refuses_an_empty_tag():
+    g = make('a = e{ STRLANG(?v, ?t) }\n')
+    with pytest.raises(SparqlError):
+        g["a"](v=Literal("hello"), t=Literal(""))
+
+
 def test_numeric_builtins():
     g = make("r = e{ ROUND(?x) + CEIL(?y) + FLOOR(?y) + ABS(-?x) }\n")
     assert g["r"](x=2.5, y=1.2) == Literal(2.5 + 0.5 + 2 + 1 + 2.5 - 0.5) \