linked-data-python 0.6.3__py3-none-any.whl → 0.6.5__py3-none-any.whl

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

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)

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.dist-info → linked_data_python-0.6.5.dist-info}/METADATA

@@ -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.dist-info → linked_data_python-0.6.5.dist-info}/RECORD

@@ -7,8 +7,8 @@ ldpy/debug.py,sha256=JUuzeKc8ya4SG30AxaUVeihTEbzySo1cS0sU0s78Mv0,10493
 ldpy/formatter.py,sha256=VaDPECxhivsMe8jnX_fOL7BUyLEu5r4xREdr4Hav-0c,12695
 ldpy/importer.py,sha256=QXAhSujPN6rFMJSQuj0UsWyI4CajirKt1SOrykJ_fUw,3670
 ldpy/pygments_lexer.py,sha256=fmqYytdnovqfXemuKE5lg4XG1iub-hui9otXERBWELw,26217
-ldpy/runtime.py,sha256=jOFR8lg4tVOP-H_2-cO-Q5SEyW7iz1y0nmZ3QkSlThU,40736
-ldpy/sparql.py,sha256=yPe-ZR1tpY--nM6q5LYXyXP7zlkE4gqhIRYAKwfpTBg,14851
+ldpy/runtime.py,sha256=6ZUkj33xvqvmNd0D3-a8py9DA58EKi88iByryZQ00G0,42586
+ldpy/sparql.py,sha256=dIG72ieecoP_pm6m0SYR76HNXWgTK0AjMDcU7DovH0Y,16549
 ldpy/lsp/__init__.py,sha256=rK5GYOITi9PN09-WVlJ2aPKodW8dWTpgI_X6dFbP1zA,542
 ldpy/lsp/__main__.py,sha256=MIp4ktqaoWZCNIMfv14bSC9pqK86JBS5XVjd1Z3c24o,72
 ldpy/lsp/backend.py,sha256=8DnSGaBk1dsIMOBo7D1WQxxF3MZjJbYd78jp4ucWORY,5375
@@ -18,12 +18,12 @@ 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=ySjfXkKKuKGFKwwlzgbm19f3wVWE1ecZL10pSy63xBo,118921
+ldpy/transpiler/core.py,sha256=y2QfOLZCXjwLFb4uZNCWMPmHbBkTZ3MZXrkD3dnahP0,122190
 ldpy/transpiler/errors.py,sha256=zEEwsNvC2Tawq8jIYls7hrbcWSvQtd7eo89k_SKp0k0,1142
 ldpy/transpiler/linemap.py,sha256=ecLlCUkD4-6QQtUjGfAL28ql7LPITTS4fjLcDIbAwpQ,11386
-linked_data_python-0.6.3.dist-info/licenses/LICENSE.md,sha256=R6KjQ098eAFd2k5mKaSRJqMH1LhY4o7xkHrKT5vjRfs,1074
-linked_data_python-0.6.3.dist-info/METADATA,sha256=xtxE9wzvbhj1pnknzO3JZb0Pa9Y0ECyUZHDrnJzKyTY,7974
-linked_data_python-0.6.3.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-linked_data_python-0.6.3.dist-info/entry_points.txt,sha256=n8Vs52oH81BrKOe1DNUvdFLSOlEufRMpK2waPFa6aYk,224
-linked_data_python-0.6.3.dist-info/top_level.txt,sha256=dkG_F4jYkh6CS6gdpQeV_gKW3yaJBvl1ukUu0zo2KA8,5
-linked_data_python-0.6.3.dist-info/RECORD,,
+linked_data_python-0.6.5.dist-info/licenses/LICENSE.md,sha256=R6KjQ098eAFd2k5mKaSRJqMH1LhY4o7xkHrKT5vjRfs,1074
+linked_data_python-0.6.5.dist-info/METADATA,sha256=RM5C2uEatJaty4CIMyEVgPpS7e3q_Zt9iQoSDOAYH90,7974
+linked_data_python-0.6.5.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+linked_data_python-0.6.5.dist-info/entry_points.txt,sha256=n8Vs52oH81BrKOe1DNUvdFLSOlEufRMpK2waPFa6aYk,224
+linked_data_python-0.6.5.dist-info/top_level.txt,sha256=dkG_F4jYkh6CS6gdpQeV_gKW3yaJBvl1ukUu0zo2KA8,5
+linked_data_python-0.6.5.dist-info/RECORD,,