linked-data-python 0.0.4__py3-none-any.whl → 0.2.0__py3-none-any.whl

ldpy/__init__.py

@@ -1,11 +1,35 @@
-from ldpy.rewriter.IndentedStringWriter import IndentedStringWriter
-from ldpy.rewriter.MultiChannelTokenStream import MultiChannelTokenStream
-from ldpy.rewriter.antlr.LDPythonLexer import LDPythonLexer
-from ldpy.rewriter.antlr.LDPythonParser import LDPythonParser
-from ldpy.rewriter.antlr.LDPythonVisitor import LDPythonVisitor
-from ldpy.rewriter.LDPythonRewriter import LDPythonRewriter
-from ldpy.rewriter.LDPythonRewriter import LDPythonRewriter
-from ldpy.ldpy import transform_source, config
-
-__version__ = "0.0.4"
-__date__ = "2023-03-23"
+"""Linked-Data Python (ldpy) v2.
+
+An "island parsing" transpiler: Python is copied through untouched, the RDF
+islands (@prefix, @base, IRIs, prefixed names, RDF literals, variables,
+graphs g{...}) are rewritten into Python expressions built on ldpy.runtime.
+
+The historical ANTLR chain (v1) is still reachable through the ldpy.rewriter
+package but is no longer imported by default.
+"""
+
+from ldpy.transpiler import transpile, LdpySyntaxError, LdpyWarning
+from ldpy.importer import install, uninstall, install_excepthook
+
+__version__ = "0.1.0.dev0"
+__date__ = "2026-08-26"
+
+
+def transform_source(source, filename="<ldpy>"):
+    """Simplified v1 compatibility: returns (python_code, prefixes, map)."""
+    result = transpile(source, filename)
+    return result.code, result.prefixes, result.map
+
+
+def Coercion(rules):
+    """Politique de conversion Python -> RDF (fiche 020) — voir
+    ldpy.runtime.Coercion; exposed here as public API."""
+    from ldpy.runtime import Coercion as _C
+    return _C(rules)
+
+
+def instantiateBGP(input, solutionMappings, initialGraph=None):
+    """Instantiate a graph template with solution mappings
+    (re-export of ldpy.runtime.instantiateBGP, v1 compatibility)."""
+    from ldpy.runtime import instantiateBGP as _f
+    return _f(input, solutionMappings, initialGraph)

ldpy/__main__.py

@@ -1,257 +1,82 @@
-#
-# The MIT License (MIT)
-#
-# Copyright (c) 2022 by Maxime Lefrançois
-#
-# Permission is hereby granted, free of charge, to any person
-# obtaining a copy of this software and associated documentation
-# files (the "Software"), to deal in the Software without
-# restriction, including without limitation the rights to use,
-# copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the
-# Software is furnished to do so, subject to the following
-# conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-# OTHER DEALINGS IN THE SOFTWARE.
-#
-# Project      : ldpython-parser; Linked-Data Python to Python/Micropython Rewriter
-#                https://gitlab.com/coswot/linked-data-python/ldpy
-# Developed by : Maxime Lefrançois, maxime.lefrancois@emse.fr
-#
-"""ldpy extends the Python syntax with primitives from the Semantic Web such as namespaces, RDF terms, and RDF graphs.
+"""ldpy — command-line execution.
 
-If no source is given, ldpy will start an interactive console.
+Usage :
+    python -m ldpy source.ldpy       # transpile and run
+    python -m ldpy -s source.ldpy    # also print the transformed code
+    python -m ldpy -t source.ldpy    # transpile seulement (stdout)
 """
+
+import argparse
 import os
 import sys
-import platform
-import argparse
-import ldpy
-from importlib import import_module
-import types
-from code import InteractiveConsole
-import readline
-
-# include a subset of the arguments from https://github.com/aroberge/ideas/blob/master/ideas/__main__.py
-parser = argparse.ArgumentParser(
-    formatter_class=argparse.RawDescriptionHelpFormatter,
-    description=__doc__,
-)
-
-parser.add_argument(
-    "-v",
-    "--version",
-    help="only displays the current version.",
-    action="store_true",
-)
-
-parser.add_argument(
-    "-l",
-    '--debug-lexer',
-    dest='lexer',
-    action='store_true',
-    default=False,
-    help='print the lexer output'
-)
-
-parser.add_argument(
-    '-p',
-    '--debug-parser',
-    dest='parser',
-    action='store_true',
-    default=False,
-    help='print the parser output'
-)
-
-parser.add_argument(
-    "-s",
-    "--show_changes",
-    action="store_true",
-    help="""shows the transformed code before it is executed.""",
-)
-
-parser.add_argument(
-    "-i", 
-    action="store_true",
-    help="""starts the interactive console after executing a source"""
-)
-
-group = parser.add_mutually_exclusive_group(required=False)
-
-group.add_argument(
-    "-m",
-    "--module",
-    dest="module",
-    type=str,
-    help="""Run library module as a script. The module may be a .ldpy or a .py file.""",
-)  
 
-group.add_argument(
-    "source",
-    nargs="?",
-    help="""Program read from script file. The file extension may be .ldpy or .py.""",
-)
-
-class LdpyConsole(InteractiveConsole):
-    
-    def __init__(self, show_changes=False, locals=None):
-        sys.ps1 = "ldpy> "
-        sys.ps2 ="  ... "
-        if locals is None:
-            locals={"__name__": "__console__", 
-                    "__doc__": None, 
-                    "__base__": None, 
-                    "__namespaces__": dict()}
-        locals["__debug_ldpy__"] = show_changes
-        InteractiveConsole.__init__(self, locals, filename="<ldpy console>")
-        self.resetldpybuffer()
-        self.push("import rdflib")
-
-    def resetldpybuffer(self):
-        self.ldpybuffer = []
-
-    def push(self, line):
-        """Push a ldpy line to the interpreter.
-
-        The line should not have a trailing newline; it may have
-        internal newlines.  The line is appended to a buffer and the
-        interpreter's runsource() method is called with the
-        concatenated contents of the buffer as source.  If this
-        indicates that the command was executed or invalid, the buffer
-        is reset; otherwise, the command is incomplete, and the buffer
-        is left as it was after the line was appended.  The return
-        value is 1 if more input is required, 0 if the line was dealt
-        with in some way (this is the same as runsource()).
-
-        """
-        self.ldpybuffer.append(line)
-        ldpysource = "\n".join(self.ldpybuffer)
-        
-        try:
-            namespaces = self.locals.get("__namespaces__", dict())
-            transformed_source, namespaces, linemap = ldpy.transform_source(ldpysource, self.filename, namespaces)
-            self.locals["__namespaces__"] = namespaces
-        except SyntaxError as ex:
-            if "mismatched input '<EOF>' expecting" in ex.msg:
-                return True
-            self.write(ex.msg + "\n")
-            self.resetldpybuffer()
-            return False
-        self.resetldpybuffer()
-
-        if self.locals["__debug_ldpy__"]:
-            print("", file=sys.stderr)
-            for transformed_line in transformed_source.split("\n"):
-                print("ldpy>>> " + transformed_line, file=sys.stderr)
-
-        for line in transformed_source.split("\n"):
-            self.buffer.append(line)
-            source = "\n".join(self.buffer)
-            more = self.runsource(source, self.filename)
-            if not more:
-                self.resetbuffer()
-        return more
-    
-    def interact(self):
-        from rdflib import __version__ as rdflib_version
-        BANNER = (
-            f">>> ldpy interactive console version {ldpy.__version__}. "
-            + f"[rdflib version {rdflib_version}, "
-            + f"Python version: {platform.python_version()}]"
-        )
-        InteractiveConsole.interact(self, banner=BANNER)
-
-def rewrite_traceback(tb, linemap):
-    if not tb:
-        return None
-    tb_frame = tb.tb_frame
-    if "__name__" in tb_frame.f_globals:
-        name = tb_frame.f_globals["__name__"]
-        if name == 'importlib' or name == 'importlib._bootstrap' or name == 'ideas.import_hook':
-            return rewrite_traceback(tb.tb_next, linemap)
-    tb_lineno = tb.tb_lineno
-    tb_lasti = tb.tb_lasti
-    if "__file__" in tb_frame.f_locals and tb_frame.f_locals["__file__"].endswith(".ldpy"):
-        file = tb_frame.f_locals["__file__"]
-        if file in linemap:
-            linemap_for_file = linemap[file]
-            tb_lineno = linemap_for_file[tb_lineno-4] # -4 because hook source_init contains three lines, and index starts at 0
-        ## it would be nice to have a second tb with the transformed .py source, but it's not possible to instantiate the builtin Frame type
-        # one could update the __file__ local attribute as follows
-        # tb_frame.f_locals["__file__"] = tb_frame.f_locals["__file__"][:-5] + ".py"
-        # and add the the traceback without changing the lineno
-    return types.TracebackType(rewrite_traceback(tb.tb_next, linemap), tb_frame, tb_lasti, tb_lineno)
+import ldpy
+from ldpy.transpiler import transpile, LdpySyntaxError
+from ldpy.transpiler.linemap import compile_mapped
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(
+        prog="ldpy",
+        description="ldpy extends Python syntax with Semantic Web "
+                    "primitives (IRIs, RDF literals, graphs).")
+    parser.add_argument("-v", "--version", action="store_true",
+                        help="print the version and exit.")
+    parser.add_argument("-s", "--show-changes", action="store_true",
+                        help="print the transformed code before running it.")
+    parser.add_argument("-t", "--transpile-only", action="store_true",
+                        help="write the transformed code to stdout, do not run.")
+    parser.add_argument("-i", "--interactive", action="store_true",
+                        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("source", nargs="?",
+                        help=".ldpy (or .py) file to run.")
+    args = parser.parse_args(argv)
 
-def main() -> None:
-    args = parser.parse_args()
     if args.version:
-        print(f"\nldpy version {ldpy.__version__}")
-        return
-    if args.source is None and args.module is None:
-        """Starts a special console that works with ldpy."""
-        c = LdpyConsole(show_changes=args.show_changes)
-        c.interact()
-
-    ldpy.config.debug_ldpy = args.show_changes
-    ldpy.config.debug_lexer = args.lexer
-    ldpy.config.debug_parser = args.parser
-
-    if args.source is not None:
-        filename = args.source
-        if not (filename.endswith(".py") or filename.endswith(".ldpy")):
-            raise ValueError("ldpy file argument must end with .py or .ldpy")
-        with open(args.source) as f:
-            source = f.read()
-        if filename.endswith(".ldpy"):
-            source, namespaces, linemap = ldpy.transform_source(source, filename)
-            source = "import rdflib\n__base__ = None\n__namespaces__ = dict()\n" + source
-            directory = os.path.dirname(filename)
-            ldpyname = os.path.basename(filename)
-            pyname = os.path.splitext(ldpyname)[0] + ".py" 
-            os.makedirs(os.path.join(directory, "__ldpycache__"), exist_ok=True)
-            with open(os.path.join(directory, "__ldpycache__", pyname), 'w') as f:
-                f.write(source)
-            ldpy.config.linemap[filename] = linemap
-        try:
-            code = compile(source, filename, "exec")
-            _locals = dict(__file__=filename)
-            exec(code, _locals)
-        except Exception as exc:
-            linemap = ldpy.config.linemap
-            tb = exc.__traceback__
-            tb = rewrite_traceback(tb, linemap)
-            raise exc.with_traceback(tb)            
-        
-        
-    if args.module is not None:
-        name = args.module
-        if "/" in name or name.endswith(".py") or name.endswith(".ldpy"):
-            raise ValueError(f"ldpy argument --module must be a valid module name (path.to.my_script). got '{args.module}'")
-        try:
-            module = import_module(name)
-            _locals = module.__dict__
-        except ModuleNotFoundError as exc:
-            print(f"{exc.__class__.__name__}: {exc.msg}", file=sys.stderr)
-            _locals = dict()
-        except Exception as exc:
-            linemap = ldpy.config.linemap
-            tb = exc.__traceback__
-            tb = rewrite_traceback(tb, linemap)
-            raise exc.with_traceback(tb)
-        
-    if sys.flags.interactive or args.i:
-        """Starts a special console that works with ldpy."""
-        c = LdpyConsole(show_changes=args.show_changes, locals=_locals)
-        c.interact()
-
-main()
+        print("ldpy " + ldpy.__version__)
+        return 0
+    if not args.source:
+        from ldpy.console import interact
+        interact()
+        return 0
+
+    with open(args.source, "r", encoding="utf-8") as f:
+        source = f.read()
+    try:
+        result = transpile(source, args.source)
+    except LdpySyntaxError as e:
+        print(str(e), file=sys.stderr)
+        return 1
+    for w in result.warnings:
+        print(str(w), file=sys.stderr)
+    if args.map:
+        with open(args.source + ".map", "w", encoding="utf-8") as f:
+            f.write(result.map.to_json(indent=1))
+    if args.transpile_only:
+        sys.stdout.write(result.code)
+        return 0
+    if args.show_changes:
+        print("ldpy>>> ======== transformed code ========", file=sys.stderr)
+        for lineno, line in enumerate(result.code.split("\n"), 1):
+            print("ldpy>>> %3d: %s" % (lineno, line), file=sys.stderr)
+        print("ldpy>>> =================================", file=sys.stderr)
+
+    ldpy.install()
+    from ldpy.importer import MAPS
+    src_path = os.path.abspath(args.source)
+    MAPS[args.source] = MAPS[src_path] = result.map
+    # remapped compilation: tracebacks, pdb and debugpy all speak in
+    # .ldpy coordinates (record ldpy/011)
+    code = compile_mapped(result.code, result.map, src_path)
+    g = {"__name__": "__main__", "__file__": src_path}
+    exec(code, g)
+    if args.interactive:
+        from ldpy.console import interact
+        interact(locals=g, prefixes=result.prefixes, base=result.base)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

ldpy/build.py

@@ -0,0 +1,91 @@
+"""Materialisation: transpile .ldpy files into a shadow directory.
+
+`python -m ldpy.build src/ -o .ldpy-build` mirrors the tree and writes:
+  - <module>.py        (generated code)
+  - <module>.ldpy.map  (language map JSON)
+
+This is the base of debugging (debugpy runs on the shadow .py files) and of
+language server (voir docs/explanation/tooling.md)."""
+
+import os
+import sys
+import argparse
+
+from ldpy.transpiler import transpile, LdpySyntaxError
+
+DEFAULT_OUT = ".ldpy-build"
+
+
+def build_file(src_path, out_dir, rel=None):
+    """Transpile one file; returns (py_path, map_path, result)."""
+    with open(src_path, "r", encoding="utf-8") as f:
+        source = f.read()
+    rel = rel or os.path.basename(src_path)
+    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.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:
+        f.write(result.code)
+    with open(map_path, "w", encoding="utf-8") as f:
+        f.write(result.map.to_json(indent=1))
+    # Source Map v3: for standard tooling
+    with open(py_path + ".map", "w", encoding="utf-8") as f:
+        f.write(result.map.to_sourcemap_v3_json())
+    return py_path, map_path, result
+
+
+def build_tree(root, out_dir):
+    """Recursively transpile every .ldpy under root. Plain .py files are
+    copied as they are (a mixed package must stay importable)."""
+    built, errors = [], []
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [d for d in dirnames
+                       if d not in (DEFAULT_OUT, "__pycache__", ".git")]
+        for name in filenames:
+            src = os.path.join(dirpath, name)
+            rel = os.path.relpath(src, root)
+            if name.endswith(".ldpy"):
+                try:
+                    built.append(build_file(src, out_dir, rel))
+                except LdpySyntaxError as e:
+                    errors.append(e)
+            elif name.endswith(".py"):
+                dst = os.path.join(out_dir, rel)
+                os.makedirs(os.path.dirname(dst) or ".", exist_ok=True)
+                with open(src, "rb") as fi, open(dst, "wb") as fo:
+                    fo.write(fi.read())
+    return built, errors
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(
+        prog="ldpy.build",
+        description="Transpile .ldpy files into a shadow directory "
+                    "(.py + .ldpy.map).")
+    parser.add_argument("source", help=".ldpy file or directory")
+    parser.add_argument("-o", "--out", default=DEFAULT_OUT,
+                        help="output directory (default: %(default)s)")
+    args = parser.parse_args(argv)
+
+    if os.path.isdir(args.source):
+        built, errors = build_tree(args.source, args.out)
+        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)
+    except LdpySyntaxError as e:
+        print(str(e), file=sys.stderr)
+        return 1
+    for w in result.warnings:
+        print(str(w), file=sys.stderr)
+    print(py_path)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

ldpy/console.py

@@ -0,0 +1,116 @@
+"""Console interactive Linked-Data Python .
+
+The point of the `ideas` package in v1 was to enter the interpreter and type
+ldpy directly. This console does it without `ideas`: every entry is
+transpiled then compiled; the state of top-level @prefix/@base persists from
+one entry to the next (declarations made inside a block die with the entry —
+block scope obliges).
+
+    $ python -m ldpy                      # console
+    $ python -m ldpy -i script.ldpy       # run, then open the console
+"""
+
+import atexit
+import code
+import codeop
+import os
+import sys
+
+import ldpy
+from ldpy.transpiler import LdpySyntaxError
+from ldpy.transpiler.core import Transpiler, PRELUDE
+
+HISTORY_FILE = os.path.join(os.path.expanduser("~"), ".ldpy_history")
+HISTORY_LENGTH = 1000
+
+
+def _setup_readline(locals):
+    """Line editing (arrows, Ctrl-A/E…), persistent history and Tab
+    completion on console names. A no-op if the readline module is missing
+    (Windows without pyreadline)."""
+    try:
+        import readline
+        import rlcompleter
+    except ImportError:
+        return
+    readline.set_completer(rlcompleter.Completer(locals).complete)
+    if "libedit" in (getattr(readline, "__doc__", "") or ""):
+        readline.parse_and_bind("bind ^I rl_complete")   # macOS libedit
+    else:
+        readline.parse_and_bind("tab: complete")
+    try:
+        readline.read_history_file(HISTORY_FILE)
+    except OSError:
+        pass
+    readline.set_history_length(HISTORY_LENGTH)
+
+    def _save():
+        try:
+            readline.write_history_file(HISTORY_FILE)
+        except OSError:
+            pass
+    atexit.register(_save)
+
+BANNER = ("ldpy %s — console Linked-Data Python (Python %s)\n"
+          "RDF islands are accepted: @prefix, <iri>, ex:name, g{ ... }, ?v")
+
+
+class LdpyConsole(code.InteractiveConsole):
+    """Interactive console: transpile every entry before compiling it;
+    top-level @prefix/@base persist between entries."""
+
+    def __init__(self, locals=None, filename="<console>",
+                 prefixes=None, base=None):
+        if locals is None:
+            locals = {"__name__": "__console__", "__doc__": None}
+        super().__init__(locals=locals, filename=filename)
+        # the runtime prelude is installed once and for all
+        if "__namespaces__" not in self.locals:
+            exec(PRELUDE, self.locals)
+        self._prefixes = dict(prefixes or {})
+        self._prefix_cols = {k: 0 for k in self._prefixes}
+        self._base = base
+
+    def runsource(self, source, filename=None, symbol="single"):
+        """Transpile then compile one entry; True = incomplete entry
+        (unclosed island or Python block), False = handled."""
+        filename = filename or self.filename
+        t = Transpiler(source, filename, emit_prelude=False)
+        t.prefixes = dict(self._prefixes)
+        t._prefix_col = dict(self._prefix_cols)
+        t.base = self._base
+        try:
+            result = t.run()
+        except LdpySyntaxError as e:
+            if getattr(e, "at_eof", False):
+                return True          # unclosed island: wait for more
+            self.write(str(e) + "\n")
+            return False
+        try:
+            code_obj = codeop.compile_command(result.code, filename, symbol)
+        except (SyntaxError, ValueError, OverflowError):
+            self.showsyntaxerror(filename)
+            return False
+        if code_obj is None:
+            return True              # Python incomplet (def, if, ...)
+        # the entry is complete: top-level declarations persist
+        t._unwind_scopes(0)
+        self._prefixes = dict(t.prefixes)
+        self._prefix_cols = dict(t._prefix_col)
+        self._base = t.base
+        for w in result.warnings:
+            self.write(str(w) + "\n")
+        self.runcode(code_obj)
+        return False
+
+
+def interact(locals=None, prefixes=None, base=None):
+    """Open the ldpy console (banner, Ctrl-D to leave)."""
+    console = LdpyConsole(locals=locals, prefixes=prefixes, base=base)
+    _setup_readline(console.locals)
+    banner = BANNER % (ldpy.__version__, sys.version.split()[0])
+    try:
+        console.interact(banner=banner, exitmsg="")
+    except SystemExit:
+        pass
+    return console