linked-data-python 0.5.2__py3-none-any.whl → 0.6.1__py3-none-any.whl

ldpy/__main__.py

@@ -30,6 +30,9 @@ def main(argv=None):
                         help="open the interactive console after the script.")
     parser.add_argument("-m", "--map", action="store_true",
                         help="also write the language map (<source>.map).")
+    parser.add_argument("--target", choices=["micropython"], default=None,
+                        help="transpile for a device: s{ } is refused here, "
+                             "at build time, where the message can be read.")
     parser.add_argument("source", nargs="?",
                         help=".ldpy (or .py) file to run.")
     args = parser.parse_args(argv)
@@ -45,7 +48,7 @@ def main(argv=None):
     with open(args.source, "r", encoding="utf-8") as f:
         source = f.read()
     try:
-        result = transpile(source, args.source)
+        result = transpile(source, args.source, target=args.target)
     except LdpySyntaxError as e:
         print(str(e), file=sys.stderr)
         return 1

ldpy/backend.py

@@ -0,0 +1,90 @@
+"""The RDF backend of the façade: rdflib on CPython, urdflib on MicroPython.
+
+The generated code never touches rdflib: it goes through `ldpy.runtime`,
+and `ldpy.runtime` takes its terms and graphs from HERE. So this module is
+the one place that knows which library is underneath — and the contract a
+backend must meet is exactly its public names (record urdflib/306 measures
+them with `urdflib/tools/api_gap.py`).
+
+Two backends:
+
+* **rdflib**, whenever it imports — the default on CPython, and the only one
+  with a SPARQL engine (`s{ }`);
+* **urdflib**, the MicroPython C module of the linked-data-python
+  organisation, when rdflib is absent. It has the terms and the graphs;
+  `Namespace`, `RDF` and `XSD` are pure Python and provided here.
+
+The two are not exclusive options of the same kind: the backend is chosen
+by what is importable, and SPARQL queries are a capability of one backend.
+`e{ }` expressions (ldpy.sparql) are pure Python over the terms, and run on
+both.
+"""
+
+try:
+    import rdflib as _lib
+    from rdflib import RDF, XSD, BNode, Literal, Namespace, Variable
+    from rdflib.term import Node
+    URIRef = _lib.URIRef
+    Graph = _lib.Graph
+    NAME = "rdflib"
+    HAS_SPARQL = True
+    HAS_NAMESPACE_MANAGER = True
+except ImportError:                                  # MicroPython
+    import urdflib as _lib
+    from urdflib import BNode, Literal, Node, URIRef, Variable, Graph
+    NAME = "urdflib"
+    HAS_SPARQL = False
+    HAS_NAMESPACE_MANAGER = False
+
+    class Namespace(str):
+        """A namespace IRI whose attributes and items are terms — rdflib's
+        Namespace, reduced to what the emitted code uses."""
+
+        def __getattr__(self, name):
+            if name.startswith("__"):
+                raise AttributeError(name)
+            return URIRef(self + name)
+
+        def __getitem__(self, name):
+            return URIRef(self + name)
+
+        def term(self, name):
+            return URIRef(self + name)
+
+    RDF = Namespace("http://www.w3.org/1999/02/22-rdf-syntax-ns#")
+    XSD = Namespace("http://www.w3.org/2001/XMLSchema#")
+
+
+def new_graph(base=None, identifier=None):
+    """A graph of the backend. rdflib's takes a base, urdflib's does not
+    (a base is a lexical matter, resolved by the transpiler already)."""
+    if NAME == "rdflib":
+        return Graph(base=base, identifier=identifier)
+    return Graph(identifier=identifier) if identifier is not None else Graph()
+
+
+def bind_namespaces(graph, namespaces):
+    """Give `graph` the serialisation prefixes of `namespaces` (a dict
+    prefix -> namespace IRI). On rdflib the runtime shares a cached
+    NamespaceManager instead (record ldpy/021); this is the plain path."""
+    for prefix, ns in namespaces.items():
+        graph.bind(prefix, str(ns))
+
+
+def prepare_sparql(text, namespaces, update=False):
+    """A prepared SPARQL query or update — rdflib's engine, or an error
+    that says which backend is missing it."""
+    if not HAS_SPARQL:
+        raise RuntimeError(
+            "s{ } needs a SPARQL engine, and the %s backend has none: "
+            "transpile with target='micropython' to be told at build time, "
+            "and use m{ } and e{ } on the device" % NAME)
+    from rdflib.plugins.sparql import prepareQuery, prepareUpdate
+    return (prepareUpdate if update else prepareQuery)(
+        text, initNs=dict(namespaces))
+
+
+__all__ = ["NAME", "HAS_SPARQL", "HAS_NAMESPACE_MANAGER",
+           "URIRef", "BNode", "Literal", "Variable", "Node", "Graph",
+           "Namespace", "RDF", "XSD",
+           "new_graph", "bind_namespaces", "prepare_sparql"]

ldpy/build.py

@@ -16,7 +16,35 @@ from ldpy.transpiler import transpile, LdpySyntaxError
 DEFAULT_OUT = ".ldpy-build"
 
 
-def build_file(src_path, out_dir, rel=None):
+#: What a device needs of ldpy at run time, and nothing else: the façade,
+#: its backend, and the expressions of e{ }. The transpiler stays on the
+#: host. `ldpy/__init__.py` is NOT copied — it imports the transpiler and
+#: the import hook — and is replaced by the docstring below.
+DEVICE_RUNTIME = ("runtime.py", "backend.py", "sparql.py")
+DEVICE_INIT = ('"""ldpy runtime for a device: what `import ldpy.runtime as '
+               '_ldpy_` needs.\n\nWritten by `python -m ldpy.build --target '
+               'micropython`; the transpiler is not here.\n"""\n')
+
+
+def bundle_device_runtime(out_dir):
+    """Copy the device runtime into <out_dir>/ldpy/, so that the emitted
+    files and what they import travel together. Returns the paths."""
+    here = os.path.dirname(os.path.abspath(__file__))
+    dst = os.path.join(out_dir, "ldpy")
+    os.makedirs(dst, exist_ok=True)
+    written = []
+    with open(os.path.join(dst, "__init__.py"), "w", encoding="utf-8") as f:
+        f.write(DEVICE_INIT)
+    written.append(os.path.join(dst, "__init__.py"))
+    for name in DEVICE_RUNTIME:
+        with open(os.path.join(here, name), "rb") as fi, \
+                open(os.path.join(dst, name), "wb") as fo:
+            fo.write(fi.read())
+        written.append(os.path.join(dst, name))
+    return written
+
+
+def build_file(src_path, out_dir, rel=None, target=None):
     """Transpile one file; returns (py_path, map_path, result)."""
     with open(src_path, "r", encoding="utf-8") as f:
         source = f.read()
@@ -24,7 +52,7 @@ def build_file(src_path, out_dir, rel=None):
     stem = rel[:-5] if rel.endswith(".ldpy") else rel
     py_path = os.path.join(out_dir, stem + ".py")
     map_path = os.path.join(out_dir, stem + ".ldpy.map")
-    result = transpile(source, src_path)
+    result = transpile(source, src_path, target=target)
     result.map.generated_name = py_path
     os.makedirs(os.path.dirname(py_path) or ".", exist_ok=True)
     with open(py_path, "w", encoding="utf-8") as f:
@@ -37,7 +65,7 @@ def build_file(src_path, out_dir, rel=None):
     return py_path, map_path, result
 
 
-def build_tree(root, out_dir):
+def build_tree(root, out_dir, target=None):
     """Recursively transpile every .ldpy under root. Plain .py files are
     copied as they are (a mixed package must stay importable)."""
     built, errors = [], []
@@ -49,7 +77,7 @@ def build_tree(root, out_dir):
             rel = os.path.relpath(src, root)
             if name.endswith(".ldpy"):
                 try:
-                    built.append(build_file(src, out_dir, rel))
+                    built.append(build_file(src, out_dir, rel, target))
                 except LdpySyntaxError as e:
                     errors.append(e)
             elif name.endswith(".py"):
@@ -68,16 +96,23 @@ def main(argv=None):
     parser.add_argument("source", help=".ldpy file or directory")
     parser.add_argument("-o", "--out", default=DEFAULT_OUT,
                         help="output directory (default: %(default)s)")
+    parser.add_argument("--target", choices=["micropython"], default=None,
+                        help="build for a device: s{ } is refused, and the "
+                             "ldpy runtime is copied next to the output")
     args = parser.parse_args(argv)
 
+    if args.target == "micropython":
+        os.makedirs(args.out, exist_ok=True)
+        bundle_device_runtime(args.out)
     if os.path.isdir(args.source):
-        built, errors = build_tree(args.source, args.out)
+        built, errors = build_tree(args.source, args.out, args.target)
         for e in errors:
             print(str(e), file=sys.stderr)
         print("%d file(s) transpiled into %s" % (len(built), args.out))
         return 1 if errors else 0
     try:
-        py_path, _, result = build_file(args.source, args.out)
+        py_path, _, result = build_file(args.source, args.out,
+                                        target=args.target)
     except LdpySyntaxError as e:
         print(str(e), file=sys.stderr)
         return 1

ldpy/runtime.py

@@ -1,35 +1,33 @@
 """Runtime Linked-Data Python v2.
 
 The code generated by the transpiler imports this module under the reserved
-alias `_ldpy_` and uses ONLY this facade — never rdflib directly. rdflib is
-the default backend; the facade allows an alternative one (urdflib / a
-MicroPython implementation) without changing the generated code.
+alias `_ldpy_` and uses ONLY this facade — never an RDF library directly.
+The library underneath is chosen by `ldpy.backend`: rdflib on the host,
+urdflib on a MicroPython device. The generated code is the same on both.
 
 Emission and runtime choices are explained in docs/explanation/.
 """
 
-import itertools
-
-import rdflib
-from rdflib import RDF, BNode, Literal, Variable, Namespace
-from rdflib.term import Node
+from ldpy import backend as _backend
+from ldpy.backend import RDF, BNode, Literal, Variable, Namespace, Node
+from ldpy.backend import URIRef as _URIRef, Graph as _Graph
 
 _URI_CACHE = {}
 
 
 def URIRef(value, base=None):
-    """rdflib.URIRef with a cache (key = the string). The IRIs emitted by the
-    transpiler are CONSTANTS of the program: without a cache, every turn of a
-    loop over a g{...} rebuilt them (see OPTIMIZATION.md). The cache is
-    bounded by the text of the programs; a 1M-entry guard covers dynamic uses
-    through the API."""
+    """The backend's URIRef with a cache (key = the string). The IRIs emitted
+    by the transpiler are CONSTANTS of the program: without a cache, every
+    turn of a loop over a g{...} rebuilt them (see OPTIMIZATION.md). The
+    cache is bounded by the text of the programs; a 1M-entry guard covers
+    dynamic uses through the API."""
     if base is not None:
-        return rdflib.URIRef(value, base)
+        return _URIRef(value, base)
     u = _URI_CACHE.get(value)
     if u is None:
-        if len(_URI_CACHE) > 1_000_000:
-            return rdflib.URIRef(value)
-        u = _URI_CACHE.setdefault(value, rdflib.URIRef(value))
+        if len(_URI_CACHE) > 1000000:
+            return _URIRef(value)
+        u = _URI_CACHE.setdefault(value, _URIRef(value))
     return u
 
 try:
@@ -152,7 +150,7 @@ def _bnode_cached(label, _cache={}):
     return b
 
 
-_PASSTHROUGH = frozenset((rdflib.URIRef, Literal, BNode, Variable, bn))
+_PASSTHROUGH = frozenset((_URIRef, Literal, BNode, Variable, bn))
 
 
 _COERCION_STACK = []
@@ -210,11 +208,11 @@ class Coercion:
 
 def _apply_conv(conv, value):
     """Apply a Coercion conversion: datatype, IRI, or function."""
-    if conv is rdflib.URIRef or conv is URIRef:
-        return rdflib.URIRef(str(value))
+    if conv is _URIRef or conv is URIRef:
+        return _URIRef(str(value))
     if conv is Literal:
         return Literal(value)
-    if isinstance(conv, rdflib.URIRef):        # un datatype (XSD.integer, ...)
+    if isinstance(conv, _URIRef):              # un datatype (XSD.integer, ...)
         return Literal(value, datatype=conv)
     return node(conv(value))
 
@@ -245,7 +243,7 @@ def dtype(value):
     A datatype is ALWAYS an IRI: unlike node(), a string is therefore read as
     an IRI and not as a literal. Also accepts an object exposing its IRI
     through str() (URIRef, a DefinedNamespace term)."""
-    if type(value) is rdflib.URIRef:
+    if type(value) is _URIRef:
         return value
     if isinstance(value, str):
         return URIRef(value)
@@ -269,7 +267,7 @@ def pname(ns, *parts):
         tp = type(p)
         if tp is Variable or (cls and tp is cls):
             return _deferred_pname(ns, parts)
-    return rdflib.URIRef(
+    return _URIRef(
         str(ns) + "".join(p if isinstance(p, str) else str(p) for p in parts))
 
 
@@ -292,7 +290,7 @@ def _deferred_pname(ns, parts):
                 out.append(str(p(sm)))
             else:
                 out.append(p if isinstance(p, str) else str(p))
-        return rdflib.URIRef("".join(out))
+        return _URIRef("".join(out))
 
     src = str(ns) + "".join(
         "?%s" % p if type(p) is Variable
@@ -308,7 +306,19 @@ def firi(*parts, base=None):
     return URIRef(iri)
 
 
-_graph_ids = itertools.count()
+class _Counter:
+    """itertools.count(), which MicroPython does not ship."""
+    __slots__ = ("n",)
+
+    def __init__(self):
+        self.n = 0
+
+    def __next__(self):
+        self.n += 1
+        return self.n - 1
+
+
+_graph_ids = _Counter()
 _NM_CACHE = {}
 
 
@@ -320,14 +330,14 @@ def _nm_for(namespaces):
     produced — the same sharing pattern as instantiateBGP. The cache is
     invalidated by a snapshot of the content (identity alone is not enough:
     block scope obliges)."""
-    if not namespaces:
+    if not namespaces or not _backend.HAS_NAMESPACE_MANAGER:
         return None
     key = id(namespaces)
     snap = tuple(sorted((p, str(u)) for p, u in namespaces.items()))
     hit = _NM_CACHE.get(key)
     if hit is not None and hit[0] == snap:
         return hit[1]
-    holder = rdflib.Graph()
+    holder = _Graph()
     nm = holder.namespace_manager
     for prefix, ns in namespaces.items():
         nm.bind(prefix, ns, replace=True)
@@ -335,7 +345,14 @@ def _nm_for(namespaces):
     return nm
 
 
-class _EmittedGraph(rdflib.Graph):
+def _new_emitted(base):
+    """A fresh emitted graph with the next identifier — lazy over rdflib,
+    eager over urdflib (the class is chosen once, below)."""
+    return _EMITTED(base=base,
+                    identifier=_URIRef("urn:x-ldpy:g%d" % next(_graph_ids)))
+
+
+class _EmittedGraph(_Graph):
     """The graph emitted by g{...}, materialised LAZILY.
 
     The triples wait in a list; the store is only populated on the first real
@@ -392,9 +409,7 @@ class _EmittedGraph(rdflib.Graph):
         pending = self._pending
         if pending is None:
             pending = list(super().__iter__())
-        g = _EmittedGraph(base=self.base,
-                          identifier=rdflib.URIRef("urn:x-ldpy:g%d"
-                                                   % next(_graph_ids)))
+        g = _new_emitted(self.base)
         nm = self._Graph__namespace_manager
         if nm is not None:
             g.namespace_manager = nm
@@ -419,9 +434,7 @@ class _EmittedGraph(rdflib.Graph):
 
     def _merged(self, left, right):
         """Nouveau graphe paresseux contenant left puis right (listes)."""
-        g = _EmittedGraph(base=self.base,
-                          identifier=rdflib.URIRef("urn:x-ldpy:g%d"
-                                                   % next(_graph_ids)))
+        g = _new_emitted(self.base)
         nm = self._Graph__namespace_manager
         if nm is not None:
             g.namespace_manager = nm
@@ -435,7 +448,7 @@ class _EmittedGraph(rdflib.Graph):
         O(total) instead of O(n²) store insertions; deduplication (union
         semantics) is still guaranteed at flush time."""
         pending = self._pending
-        if pending is not None and isinstance(other, rdflib.Graph):
+        if pending is not None and isinstance(other, _Graph):
             if type(other) is _EmittedGraph and other._pending is not None:
                 return self._merged(pending, other._pending)
             return self._merged(pending, list(other))
@@ -446,7 +459,7 @@ class _EmittedGraph(rdflib.Graph):
         boucle d'accumulation `g = g{ } ; g += g{…}` reste O(total) en
         store insertions instead of paying one per turn."""
         pending = self._pending
-        if pending is not None and isinstance(other, rdflib.Graph):
+        if pending is not None and isinstance(other, _Graph):
             if type(other) is _EmittedGraph and other._pending is not None:
                 self._pending = pending + other._pending
             else:
@@ -457,11 +470,72 @@ class _EmittedGraph(rdflib.Graph):
     def __radd__(self, other):
         """Graph() + g{...} (and therefore sum(...)) with no materialisation."""
         pending = self._pending
-        if pending is not None and isinstance(other, rdflib.Graph):
+        if pending is not None and isinstance(other, _Graph):
             return self._merged(list(other), pending)
         return NotImplemented
 
 
+class _EagerEmittedGraph(_Graph):
+    """The graph emitted by g{...} over urdflib: EAGER. The laziness
+    above rides on rdflib's private store attribute; a C graph has none,
+    and adds in place at C speed, so the triples go straight in. The
+    algebra the emitted code relies on stays: g1 + g2, g += x, g{ }(b)."""
+
+    def __init__(self, base=None, identifier=None):
+        _Graph.__init__(self, identifier=identifier) if identifier is not None \
+            else _Graph.__init__(self)
+        self.base = base
+        self._pending = None
+        self._Graph__namespace_manager = None
+        self._nm_namespaces = None
+
+    @property
+    def namespace_manager(self):
+        return self._Graph__namespace_manager
+
+    @namespace_manager.setter
+    def namespace_manager(self, nm):
+        self._Graph__namespace_manager = nm
+
+    def _fill(self, triples):
+        for tr in triples:
+            self.add(tr)
+        return self
+
+    def __call__(self, bindings=None):
+        g = _new_emitted(self.base)
+        term0 = _materializer(bindings if bindings is not None else {},
+                              keep_vars=False)
+        bm = {}
+
+        def term(x):
+            v = term0(x)
+            if type(v) is BNode:
+                b = bm.get(v)
+                if b is None:
+                    b = bm[v] = BNode()
+                return b
+            return v
+
+        return g._fill(tr for tr in
+                       ((term(s), term(p), term(o)) for s, p, o in self)
+                       if tr[0] is not None and tr[1] is not None
+                       and tr[2] is not None)
+
+    def __add__(self, other):
+        return _new_emitted(self.base)._fill(self)._fill(other)
+
+    def __iadd__(self, other):
+        return self._fill(other)
+
+    def __radd__(self, other):
+        return _new_emitted(self.base)._fill(other)._fill(self)
+
+
+#: The emitted-graph class of this backend: a C graph has no store hook.
+_EMITTED = _EmittedGraph if _backend.NAME == "rdflib" else _EagerEmittedGraph
+
+
 class Bindings(dict):
     """The current bindings (record ldpy/017): a dict with str or Variable
     keys (normalised to str), values coerced into RDF terms on assignment.
@@ -625,10 +699,12 @@ def _materializer(bindings=None, keep_vars=True):
 def new_graph(namespaces, base, identifier=None):
     """A graph created by '@graph as g' (record ldpy/014): a plain
     rdflib.Graph, with the serialisation bindings of the prefixes in scope."""
-    g = rdflib.Graph(base=base, identifier=identifier)
+    g = _backend.new_graph(base=base, identifier=identifier)
     nm = _nm_for(namespaces)
     if nm is not None:
         g.namespace_manager = nm
+    elif namespaces and not _backend.HAS_NAMESPACE_MANAGER:
+        _backend.bind_namespaces(g, namespaces)
     return g
 
 
@@ -682,21 +758,25 @@ def graph(namespaces, base, *triples, bindings=None):
     With no bindings, a g{ } with variables or e{ } stays a template; with
     the current bindings in scope, it is instantiated (record ldpy/017) — a
     triple with a term still unbound is dropped."""
-    g = _EmittedGraph(base=base,
-                      identifier=rdflib.URIRef("urn:x-ldpy:g%d"
-                                               % next(_graph_ids)))
+    g = _new_emitted(base)
     nm = _nm_for(namespaces)
     if nm is not None:
         g.namespace_manager = nm
+    elif namespaces and not _backend.HAS_NAMESPACE_MANAGER:
+        _backend.bind_namespaces(g, namespaces)
     _term = _materializer(bindings, keep_vars=(bindings is None))
     if bindings is None:
-        g._pending = [(_term(s), _term(p), _term(o)) for s, p, o in triples]
+        pending = [(_term(s), _term(p), _term(o)) for s, p, o in triples]
     else:
-        g._pending = [tr for tr in
-                      ((_term(s), _term(p), _term(o))
-                       for s, p, o in triples)
-                      if tr[0] is not None and tr[1] is not None
-                      and tr[2] is not None]
+        pending = [tr for tr in
+                   ((_term(s), _term(p), _term(o))
+                    for s, p, o in triples)
+                   if tr[0] is not None and tr[1] is not None
+                   and tr[2] is not None]
+    if _backend.NAME == "rdflib":
+        g._pending = pending
+    else:
+        g._fill(pending)
     return g
 
 
@@ -728,6 +808,51 @@ class Row(tuple):
             for i, f in enumerate(self._fields))
 
 
+class _RowSeq:
+    """The same Row for MicroPython, which cannot subclass tuple with
+__new__: a small sequence that unpacks, compares to a tuple, and
+answers to names and variables."""
+
+    __slots__ = ("_values", "_fields")
+
+    def __init__(self, values, fields):
+        self._values = tuple(values)
+        self._fields = fields
+
+    def __iter__(self):
+        return iter(self._values)
+
+    def __len__(self):
+        return len(self._values)
+
+    def __eq__(self, other):
+        return self._values == (other._values if isinstance(other, _RowSeq)
+                                else other)
+
+    def __hash__(self):
+        return hash(self._values)
+
+    def __getattr__(self, name):
+        try:
+            return self._values[self._fields.index(name)]
+        except ValueError:
+            raise AttributeError(name)
+
+    def __getitem__(self, key):
+        if isinstance(key, (str, Variable)):
+            return self._values[self._fields.index(str(key))]
+        return self._values[key]
+
+    def __repr__(self):
+        return "Row(%s)" % ", ".join(
+            "%s=%r" % (f, v) for f, v in zip(self._fields, self._values))
+
+
+#: The row class of this Python: tuple-based, unless tuple cannot be
+#: subclassed with __new__ (MicroPython).
+_ROW = Row if hasattr(tuple, "__new__") else _RowSeq
+
+
 def _match_prepare(patterns, bindings):
     """Patterns ready for matching: bn -> an anonymous variable shared by
     index, slot -> a value, variables bound by the bindings -> a term."""
@@ -822,7 +947,7 @@ class Match:
         else:
             vs = [Variable(x) for x in proj]
             for sm in self.solutions():
-                yield Row((sm.get(x) for x in vs), list(proj))
+                yield _ROW((sm.get(x) for x in vs), list(proj))
 
     def __bool__(self):
         for _ in self.solutions():
@@ -875,9 +1000,7 @@ def _prepare_sparql(text, namespaces, update):
     hit = _SPARQL_CACHE.get(key)
     if hit is not None:
         return hit
-    from rdflib.plugins.sparql import prepareQuery, prepareUpdate
-    prep = (prepareUpdate if update else prepareQuery)(
-        text, initNs=dict(namespaces))
+    prep = _backend.prepare_sparql(text, namespaces, update)
     if len(_SPARQL_CACHE) >= _SPARQL_CACHE_MAX:
         _SPARQL_CACHE.pop(next(iter(_SPARQL_CACHE)))
     _SPARQL_CACHE[key] = prep
@@ -962,8 +1085,9 @@ def instantiateBGP(input, solutionMappings, initialGraph=None):
 
     Carried over from v1 (ldpy/ldpy.py), functionally unchanged."""
     if initialGraph is None:
-        initialGraph = rdflib.Graph(base=input.base)
-    initialGraph.namespace_manager = input.namespace_manager
+        initialGraph = _backend.new_graph(base=input.base)
+    if _backend.HAS_NAMESPACE_MANAGER:
+        initialGraph.namespace_manager = input.namespace_manager
     if solutionMappings is None:
         return initialGraph
     if isinstance(solutionMappings, dict):

ldpy/sparql.py

@@ -11,14 +11,14 @@ later, against a *solution mapping*:
 The semantics follow SPARQL 1.1: numeric promotion (integer < decimal <
 float < double, integer division -> decimal), errors PROPAGATED (unbound
 variable, incomparable types) and absorbed by ``||``/``&&``/``IF``/
-``COALESCE`` per SPARQL's three-valued truth table. No rdflib parser is used;
-rdflib only serves as the data model.
+``COALESCE`` per SPARQL's three-valued truth table. No parser of any RDF
+library is used: the terms come from ``ldpy.backend`` — rdflib or urdflib —
+so these expressions run on a device as well as on the host.
 """
 
 import re as _re
 
-from rdflib import BNode, Literal, URIRef, Variable, XSD
-from rdflib.term import Node
+from ldpy.backend import BNode, Literal, URIRef, Variable, XSD, Node
 
 from ldpy.runtime import node as _node
 

ldpy/transpiler/core.py

@@ -217,7 +217,18 @@ def _term_kind(text):
 class Transpiler:
     """Une instance par fichier. Usage : Transpiler(src, filename).run()."""
 
-    def __init__(self, text, filename="<ldpy>", emit_prelude=True):
+    #: The targets a programme can be transpiled for. `None` is the host;
+    #: "micropython" is a device whose backend has no SPARQL engine, so
+    #: s{ } is refused HERE, at build time on the host, where the message
+    #: can be read — not on the device, at the first query.
+    TARGETS = (None, "micropython")
+
+    def __init__(self, text, filename="<ldpy>", emit_prelude=True,
+                 target=None):
+        if target not in self.TARGETS:
+            raise ValueError("unknown target %r (one of %s)"
+                             % (target, ", ".join(repr(t) for t in self.TARGETS)))
+        self.target = target
         self.text = text
         self.emit_prelude = emit_prelude
         self.n = len(text)
@@ -2090,6 +2101,11 @@ class Transpiler:
         transpilation (l'oracle, fiche 015)."""
         mark = self._begin_island()
         isl_line, isl_col = self.src_line, self.src_col
+        if self.target == "micropython":
+            self._error("s{ } is not available on the micropython target: "
+                        "a SPARQL query needs rdflib's engine, which the "
+                        "device does not have — write the pattern with "
+                        "m{ } and the filter with e{ }", incomplete=False)
         self._take(2)                                   # s{
         t = self.text
         pieces = []
@@ -2697,9 +2713,10 @@ class _GraphCtx:
         return "%s.bn(%d)" % (RUNTIME_ALIAS, self.labels[label])
 
 
-def transpile(source, filename="<ldpy>"):
+def transpile(source, filename="<ldpy>", target=None):
     """Transpile un source Linked-Data Python en Python.
 
+    `target` : None (l'hôte) ou "micropython" — voir Transpiler.TARGETS.
     Retourne un TranspileResult(code, map, prefixes, base, warnings).
     """
-    return Transpiler(source, filename).run()
+    return Transpiler(source, filename, target=target).run()

{linked_data_python-0.5.2.dist-info → linked_data_python-0.6.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: linked-data-python
-Version: 0.5.2
+Version: 0.6.1
 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.2.dist-info → linked_data_python-0.6.1.dist-info}/RECORD

@@ -1,13 +1,14 @@
 ldpy/__init__.py,sha256=IyuzHrp5OtuGO_NrrdmMUQW6bTYcyS5uob7CeoXg8mY,1943
-ldpy/__main__.py,sha256=YKTEjmNQuh_0p-KiEus9HngFs_ZDmS56RXzHTspiWVI,3077
-ldpy/build.py,sha256=495F9KyFMar-hTCuaQkF3FvzWQX4mE9H0U0V-JuRDmA,3394
+ldpy/__main__.py,sha256=J1drZdQZ5jSAE5ri_NFB43jzkUuMgWHp-KL0Mjhbrhc,3328
+ldpy/backend.py,sha256=SffPO4UQT_1p1JPhNiBtdlbNYNmpMySUPiLXvgR0Z2k,3585
+ldpy/build.py,sha256=llHQ-7ndgg_yeMKukexrEsu0cAIFFU0JQSaL5_ywQss,5170
 ldpy/console.py,sha256=vMSnFFoOIOcanw6_niNxqgrt-F4gzMOrD1GopkXru5s,4837
 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=mcQ0u9nZjLnSWpqzcxd6bZjk69LfKSNTsf9A3rqfhhk,25320
-ldpy/runtime.py,sha256=InXxP1kwxrtozYZAqW6J-fmmUYiI_ykFswvZ_mK5TTY,36000
-ldpy/sparql.py,sha256=CHSB4v5lEuVQKRPuwcM8xI3jN2FVHkmPVb675QkAD9Y,14770
+ldpy/runtime.py,sha256=vkk9HQvUpi6pET0S4EqH1sA3797eA89NeTzHz9dLT_w,39632
+ldpy/sparql.py,sha256=yPe-ZR1tpY--nM6q5LYXyXP7zlkE4gqhIRYAKwfpTBg,14851
 ldpy/lsp/__init__.py,sha256=rK5GYOITi9PN09-WVlJ2aPKodW8dWTpgI_X6dFbP1zA,542
 ldpy/lsp/__main__.py,sha256=MIp4ktqaoWZCNIMfv14bSC9pqK86JBS5XVjd1Z3c24o,72
 ldpy/lsp/backend.py,sha256=8DnSGaBk1dsIMOBo7D1WQxxF3MZjJbYd78jp4ucWORY,5375
@@ -17,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=XiRuq9YbFnvNiWo4kio0Rd5a6KsC4Om-1NIMIAbaK5M,113824
+ldpy/transpiler/core.py,sha256=LaZT8hE4jocIcTLyb2kc_mFtwu8QTSm0FhOMNetY_2k,114831
 ldpy/transpiler/errors.py,sha256=zEEwsNvC2Tawq8jIYls7hrbcWSvQtd7eo89k_SKp0k0,1142
 ldpy/transpiler/linemap.py,sha256=ecLlCUkD4-6QQtUjGfAL28ql7LPITTS4fjLcDIbAwpQ,11386
-linked_data_python-0.5.2.dist-info/licenses/LICENSE.md,sha256=R6KjQ098eAFd2k5mKaSRJqMH1LhY4o7xkHrKT5vjRfs,1074
-linked_data_python-0.5.2.dist-info/METADATA,sha256=6zP3Q2bhARECaLwSWW77SOhSE9mbmtqXzefvYM_zu_c,7974
-linked_data_python-0.5.2.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-linked_data_python-0.5.2.dist-info/entry_points.txt,sha256=n8Vs52oH81BrKOe1DNUvdFLSOlEufRMpK2waPFa6aYk,224
-linked_data_python-0.5.2.dist-info/top_level.txt,sha256=dkG_F4jYkh6CS6gdpQeV_gKW3yaJBvl1ukUu0zo2KA8,5
-linked_data_python-0.5.2.dist-info/RECORD,,
+linked_data_python-0.6.1.dist-info/licenses/LICENSE.md,sha256=R6KjQ098eAFd2k5mKaSRJqMH1LhY4o7xkHrKT5vjRfs,1074
+linked_data_python-0.6.1.dist-info/METADATA,sha256=SM4kVwA-gnxAZdihLeDPLR3Sys8n0iauEh40yw-8g_4,7974
+linked_data_python-0.6.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+linked_data_python-0.6.1.dist-info/entry_points.txt,sha256=n8Vs52oH81BrKOe1DNUvdFLSOlEufRMpK2waPFa6aYk,224
+linked_data_python-0.6.1.dist-info/top_level.txt,sha256=dkG_F4jYkh6CS6gdpQeV_gKW3yaJBvl1ukUu0zo2KA8,5
+linked_data_python-0.6.1.dist-info/RECORD,,