linked-data-python 0.5.1__tar.gz → 0.6.0__tar.gz

{linked_data_python-0.5.1/linked_data_python.egg-info → linked_data_python-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: linked-data-python
-Version: 0.5.1
+Version: 0.6.0
 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.1 → linked_data_python-0.6.0}/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.0/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.1 → linked_data_python-0.6.0}/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.1 → linked_data_python-0.6.0}/ldpy/console.py

@@ -70,6 +70,12 @@ class LdpyConsole(code.InteractiveConsole):
         self._prefixes = dict(prefixes or {})
         self._prefix_cols = {k: 0 for k in self._prefixes}
         self._base = base
+        # The current graph and the current bindings are declarations too:
+        # like @prefix, a top-level @graph must survive to the next entry
+        # (otherwise `+{ ... }` after `@graph as g` sees no graph at all).
+        self._graph_var = None
+        self._bindings_var = None
+        self._counter = 0
 
     def runsource(self, source, filename=None, symbol="single"):
         """Transpile then compile one entry; True = incomplete entry
@@ -79,6 +85,10 @@ class LdpyConsole(code.InteractiveConsole):
         t.prefixes = dict(self._prefixes)
         t._prefix_col = dict(self._prefix_cols)
         t.base = self._base
+        t._graph_var = self._graph_var
+        t._bindings_var = self._bindings_var
+        # fresh names must not collide with those of the previous entries
+        t._ns_counter = self._counter
         try:
             result = t.run()
         except LdpySyntaxError as e:
@@ -98,6 +108,9 @@ class LdpyConsole(code.InteractiveConsole):
         self._prefixes = dict(t.prefixes)
         self._prefix_cols = dict(t._prefix_col)
         self._base = t.base
+        self._graph_var = t._graph_var
+        self._bindings_var = t._bindings_var
+        self._counter = t._ns_counter
         for w in result.warnings:
             self.write(str(w) + "\n")
         self.runcode(code_obj)

{linked_data_python-0.5.1 → linked_data_python-0.6.0}/ldpy/debug.py

@@ -92,11 +92,30 @@ def probe():
 #: re-exported: debug tooling looks for them here (pure functions, defined
 #: alongside the map in ldpy/transpiler/linemap.py)
 __all__ = ["stepping_rules", "probe", "package_dir", "load_map",
+           "shadow_rel",
            "translate_breakpoints", "translate_frames",
            "snap_breakpoint_line", "snap_breakpoint_lines",
            "run_direct", "main"]
 
 
+def shadow_rel(source, root=None):
+    """Path of the shadow inside the output directory.
+
+    Without a root, the basename: the shadow sits beside the source, and two
+    files never meet. With one — a workspace whose whole build is gathered in
+    a single directory — the tree is mirrored, which is what keeps `a/m.ldpy`
+    and `b/m.ldpy` from writing the same `m.py`. A source outside the root
+    falls back to its basename rather than climbing out of the output
+    directory with `../`."""
+    name = os.path.basename(source)
+    if not root:
+        return name
+    rel = os.path.relpath(os.path.abspath(source), os.path.abspath(root))
+    if rel.startswith(os.pardir + os.sep) or rel == os.pardir:
+        return name
+    return rel
+
+
 def load_map(map_path):
     """Load a LanguageMap from a .ldpy.map file (JSON)."""
     with open(map_path, "r", encoding="utf-8") as f:
@@ -167,6 +186,10 @@ def main(argv=None):
                              "straight in the .ldpy)")
     parser.add_argument("-o", "--out", default=DEFAULT_OUT,
                         help="shadow directory (default: %(default)s)")
+    parser.add_argument("--root", metavar="DIR",
+                        help="tree root the shadow mirrors: the .py is "
+                             "written at OUT/<path of the source relative "
+                             "to DIR> (default: OUT/<basename>)")
     parser.add_argument("--listen", metavar="HOTE:PORT",
                         help="start debugpy listening (e.g. 127.0.0.1:5678)")
     parser.add_argument("--wait-for-client", action="store_true",
@@ -201,8 +224,7 @@ def main(argv=None):
 
     try:
         py_path, map_path, result = build_file(
-            args.source, args.out,
-            rel=os.path.basename(args.source))
+            args.source, args.out, rel=shadow_rel(args.source, args.root))
     except LdpySyntaxError as e:
         print(str(e), file=sys.stderr)
         return 1