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

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

@@ -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 → linked_data_python-0.6.1}/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

linked_data_python-0.6.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"]

{linked_data_python-0.5.2 → linked_data_python-0.6.1}/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

{linked_data_python-0.5.2 → linked_data_python-0.6.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):

{linked_data_python-0.5.2 → linked_data_python-0.6.1}/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
 

{linked_data_python-0.5.2 → linked_data_python-0.6.1}/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 → linked_data_python-0.6.1/linked_data_python.egg-info}/PKG-INFO

@@ -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 → linked_data_python-0.6.1}/linked_data_python.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ README.md
 pyproject.toml
 ldpy/__init__.py
 ldpy/__main__.py
+ldpy/backend.py
 ldpy/build.py
 ldpy/console.py
 ldpy/debug.py
@@ -64,4 +65,5 @@ tests/test_scope_modifiers.py
 tests/test_semantics.py
 tests/test_sourcemap_v3.py
 tests/test_sparql_expr.py
-tests/test_sparql_island.py
+tests/test_sparql_island.py
+tests/test_target_micropython.py

{linked_data_python-0.5.2 → linked_data_python-0.6.1}/pyproject.toml

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

@@ -20,13 +20,21 @@ def blocks(lang):
     for path in DOCS:
         text = open(path, encoding="utf-8").read()
         for i, m in enumerate(FENCE.finditer(text)):
-            if m.group(1) == lang:
+            if m.group(1) == lang and not _is_snippet(m.group(2)):
                 out.append(pytest.param(
                     m.group(2),
                     id="%s#%d" % (os.path.relpath(path, REPO), i)))
     return out
 
 
+def _is_snippet(code):
+    """A block that only includes a file (``--8<-- "..."``) has no code of its
+    own: mkdocs substitutes the file at build time, and that file is tested
+    where it lives — see ``test_the_tour_runs``."""
+    return all(line.strip().startswith("--8<--") or not line.strip()
+               for line in code.split("\n"))
+
+
 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
@@ -46,6 +54,18 @@ def test_python_snippets_run(code):
     exec(compile(code, "<docs>", "exec"), {"__name__": "docs"})
 
 
+def test_the_tour_runs():
+    """``docs/tutorials/tour.ldpy`` is a tutorial in the shape of a program:
+    its comments teach, and each section asserts what it claims. Running it is
+    therefore the whole check — and the page that shows it includes this very
+    file, so the two cannot drift."""
+    from ldpy.transpiler import transpile
+    path = os.path.join(REPO, "docs", "tutorials", "tour.ldpy")
+    source = open(path, encoding="utf-8").read()
+    exec(compile(transpile(source, path).code, path, "exec"),
+         {"__name__": "tour"})
+
+
 # --------------------------------------------------------------------------
 # The same snippets, typed into the interactive console.
 #

linked_data_python-0.6.1/tests/test_target_micropython.py

@@ -0,0 +1,134 @@
+"""The micropython target and the backend behind the façade.
+
+Two optionals, on two axes (record ldpy/026):
+
+* the BACKEND — rdflib on the host, urdflib on a device — is chosen by
+  `ldpy.backend` from what is importable, and the generated code is the
+  same on both;
+* SPARQL QUERIES (`s{ }`) are a capability of the rdflib backend only.
+  `--target micropython` refuses them at build time, on the host, where the
+  message can be read; `e{ }` and `m{ }` are pure Python over the terms and
+  stay.
+
+The last test runs the emitted code on a real MicroPython, when one built
+with urdflib is at hand (LDPY_MICROPYTHON, or `micropython` on the PATH).
+"""
+
+import os
+import shutil
+import subprocess
+import sys
+
+import pytest
+
+from ldpy import backend
+from ldpy.transpiler import transpile, LdpySyntaxError
+from ldpy.build import bundle_device_runtime, DEVICE_RUNTIME
+
+P = "@prefix ex: <http://example.org/> .\n"
+
+
+def test_backend_is_rdflib_on_the_host():
+    assert backend.NAME == "rdflib" and backend.HAS_SPARQL
+    from ldpy import runtime
+    assert runtime.URIRef("http://x") == backend.URIRef("http://x")
+    assert isinstance(runtime.new_graph({}, None), backend.Graph)
+
+
+def test_target_refuses_a_sparql_query_at_build_time():
+    src = P + "@graph as g\nq = s{ SELECT ?s WHERE { ?s ?p ?o } }\n"
+    transpile(src)                                    # the host accepts it
+    with pytest.raises(LdpySyntaxError) as e:
+        transpile(src, target="micropython")
+    assert "s{ } is not available on the micropython target" in str(e.value)
+    assert "m{ }" in str(e.value)                     # and says what to use
+
+
+def test_target_keeps_expressions_patterns_and_graphs():
+    src = (P + "@graph as g\n+{ ex:a ex:p 1 }\n"
+           "adult = e{ ?age >= 18 }\n"
+           "rows = m{ ?s ex:p ?o }\n"
+           "h = g{ ex:b ex:q 2 }\n")
+    assert transpile(src, target="micropython").code == transpile(src).code, \
+        "the target changes what is refused, not what is emitted"
+
+
+def test_unknown_target_is_an_error():
+    with pytest.raises(ValueError):
+        transpile("x = 1\n", target="esp8266")
+
+
+def test_device_bundle_is_the_runtime_without_the_transpiler(tmp_path):
+    written = bundle_device_runtime(str(tmp_path))
+    names = sorted(os.path.basename(p) for p in written)
+    assert names == sorted(("__init__.py",) + DEVICE_RUNTIME)
+    init = (tmp_path / "ldpy" / "__init__.py").read_text()
+    assert "transpiler" not in init.replace("the transpiler is not here", "")
+    for name in DEVICE_RUNTIME:
+        assert (tmp_path / "ldpy" / name).read_bytes() == \
+            open(os.path.join(os.path.dirname(backend.__file__), name),
+                 "rb").read()
+
+
+def test_device_runtime_imports_no_rdflib_module_by_name():
+    """What ships to the device must reach rdflib only through the backend."""
+    here = os.path.dirname(backend.__file__)
+    for name in ("runtime.py", "sparql.py"):
+        text = open(os.path.join(here, name), encoding="utf-8").read()
+        code = "\n".join(l for l in text.splitlines()
+                         if not l.strip().startswith("#"))
+        assert "import rdflib" not in code and "from rdflib" not in code, name
+
+
+# ---------------------------------------------------------------- device
+
+def _micropython():
+    exe = os.environ.get("LDPY_MICROPYTHON") or shutil.which("micropython")
+    if not exe:
+        return None
+    probe = subprocess.run([exe, "-c", "import urdflib"], capture_output=True)
+    return exe if probe.returncode == 0 else None
+
+
+DEVICE_PROGRAM = P + '''\
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+
+@graph as g
+for i in range(3):
+    +{ f<http://example.org/obs/{i}> a ex:Observation ;
+           ex:value {i * 1.5}^^xsd:double ;
+           ex:label {"n%d" % i}@en }
+big = e{ ?v >= 1.5 }
+kept = sorted(str(s) for s, v in m{ ?s ex:value ?v } if big({"v": v}))
+print(len(g), kept)
+print(sorted(str(o) + "@" + str(o.language) for s, o in m{ ?s ex:label ?o }))
+print(sorted(row.s.n3() for row in m{ ?s ex:value ?v } if row.v.toPython() > 1))
+ttl = g.serialize(format="turtle")
+print("@prefix ex:" in ttl, "ex:Observation" in ttl)
+'''
+
+
+@pytest.mark.skipif(_micropython() is None,
+                    reason="no MicroPython with urdflib (LDPY_MICROPYTHON)")
+def test_the_same_program_runs_on_micropython(tmp_path):
+    """Transpile on the host, run on the device — mode 1 of record
+    micropython/304 — and get the answer the host gets."""
+    out = tmp_path / "build"
+    out.mkdir()
+    bundle_device_runtime(str(out))
+    result = transpile(DEVICE_PROGRAM, "device.ldpy", target="micropython")
+    (out / "device.py").write_text(result.code)
+
+    host = subprocess.run([sys.executable, "-c", result.code],
+                          capture_output=True, text=True, check=True)
+    env = dict(os.environ, MICROPYPATH=str(out))
+    device = subprocess.run([_micropython(), str(out / "device.py")],
+                            capture_output=True, text=True, env=env)
+    assert device.returncode == 0, device.stderr
+    assert device.stdout == host.stdout
+    assert host.stdout.splitlines() == [
+        "9 ['http://example.org/obs/1', 'http://example.org/obs/2']",
+        "['n0@en', 'n1@en', 'n2@en']",
+        "['<http://example.org/obs/1>', '<http://example.org/obs/2>']",
+        "True True",
+    ]