lean-python 0.1.0__py3-none-any.whl

lean_python/__init__.py

@@ -0,0 +1,6 @@
+"""lean-python: Lean 4 code compiled to Python."""
+
+from lean_python.embed import LeanBlockStale, lean
+from lean_python.types import Nat
+
+__all__ = ["LeanBlockStale", "Nat", "lean"]

lean_python/cli.py

@@ -0,0 +1,50 @@
+"""``lean-py``: the command line of the Python package.
+
+usage: lean-py sync --package <dir> [--lean-python <path>]
+"""
+
+import argparse
+import os
+import sys
+
+USAGE = """usage: lean-py <command> [parameters]
+
+commands:
+  sync   Check the Lean blocks of a package and generate their Python modules
+
+lean-py sync
+  --package <dir>        The Python package (the directory with __init__.py) (required)
+  --lean-python <path>   The Lean CLI (default: $LEAN_PYTHON_CLI, then `lean-python` on PATH)
+
+exit codes: 0 success, 252 invalid parameters, 254 input that cannot be converted, 255 other errors
+"""
+
+
+def main(argv=None):
+    argv = sys.argv[1:] if argv is None else argv
+    if not argv or argv[0] in ("help", "--help", "-h"):
+        print(USAGE, end="")
+        return 0
+    if argv[0] != "sync":
+        print(f"lean-py: unknown command {argv[0]!r} (see `lean-py help`)", file=sys.stderr)
+        return 252
+    p = argparse.ArgumentParser(prog="lean-py sync", add_help=False, exit_on_error=False)
+    p.add_argument("--package", required=True)
+    p.add_argument("--lean-python")
+    try:
+        args = p.parse_args(argv[1:])
+    except (argparse.ArgumentError, SystemExit) as e:
+        print(f"lean-py: {e}", file=sys.stderr)
+        return 252
+    from lean_python import sync
+
+    try:
+        sync.sync_package(args.package, cli=args.lean_python or os.environ.get("LEAN_PYTHON_CLI"))
+    except sync.SyncError as e:
+        print(f"lean-py: {e}", file=sys.stderr)
+        return e.code
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

lean_python/embed.py

@@ -0,0 +1,131 @@
+"""``lean(name, source)``: Lean code in a Python module.
+
+``lean-py sync`` checks the proofs of every block of a package with Lake and writes the Python it
+generates to ``<package>/_lean/``. At run time ``lean(...)`` only imports that module, after
+checking that it was generated from the same source; Lean is not needed to run the package.
+"""
+
+import hashlib
+import importlib
+import json
+import os
+import subprocess
+import sys
+import typing
+from dataclasses import dataclass, field
+
+GENERATOR_VERSION = "1"
+
+
+class LeanBlockStale(RuntimeError):
+    """The generated module of a block is missing or was generated from a different source."""
+
+
+@dataclass
+class Block:
+    module: str
+    name: str
+    source: str
+    imports: tuple
+    uses: tuple
+    models: tuple
+    file: str
+    line: int
+    key: str = field(default="")
+
+    @property
+    def qualname(self):
+        return f"{self.module}:{self.name}"
+
+    @property
+    def stem(self):
+        return "__".join([*self.module.split("."), self.name])
+
+    @property
+    def lean_module(self):
+        return ["LeanPythonEmbed", *self.module.split("."), self.name]
+
+    @property
+    def top_package(self):
+        return self.module.split(".")[0]
+
+
+def block_key(block):
+    from lean_python import models
+
+    model_sources = models.modules_source(list(block.models)) if block.models else {}
+    data = {
+        "module": block.module,
+        "name": block.name,
+        "source": block.source,
+        "imports": list(block.imports),
+        "uses": list(block.uses),
+        "models": model_sources,
+        "generator": GENERATOR_VERSION,
+    }
+    return hashlib.sha256(json.dumps(data, sort_keys=True).encode()).hexdigest()
+
+
+_recording = None
+_registries = {}
+
+
+class _Placeholder:
+    """What `lean(...)` returns while `lean-py sync` records the blocks: names are `Any`."""
+
+    def __getattr__(self, name):
+        return typing.Any
+
+
+def _registry(pkg):
+    reg = _registries.get(pkg)
+    if reg is None:
+        try:
+            base = sys.modules[pkg].__path__[0]
+        except (KeyError, AttributeError, IndexError):
+            raise LeanBlockStale(f"lean(...) must be called from a module of a package (got {pkg!r})") from None
+        path = os.path.join(base, "_lean", "blocks.json")
+        try:
+            with open(path, encoding="utf-8") as f:
+                reg = json.load(f)
+        except FileNotFoundError:
+            reg = {}
+        _registries[pkg] = reg
+    return reg
+
+
+def lean(name, source, *, imports=(), uses=(), models=()):
+    """Defines the Lean block ``name`` of the calling module; returns its generated module."""
+    frame = sys._getframe(1)
+    block = Block(
+        module=frame.f_globals["__name__"],
+        name=name,
+        source=source,
+        imports=tuple(imports),
+        uses=tuple(uses),
+        models=tuple(models),
+        file=frame.f_code.co_filename,
+        line=frame.f_lineno,
+    )
+    if _recording is not None:
+        _recording.append(block)
+        return _Placeholder()
+    block.key = block_key(block)
+    pkg = block.top_package
+    if _registry(pkg).get(block.qualname) != block.key:
+        if os.environ.get("LEAN_PYTHON_AUTO_SYNC") == "1":
+            r = subprocess.run(
+                [sys.executable, "-m", "lean_python.cli", "sync", "--package", sys.modules[pkg].__path__[0]],
+                check=False,
+                env={**os.environ, "LEAN_PYTHON_AUTO_SYNC": "0"},
+            )
+            if r.returncode != 0:
+                raise LeanBlockStale(f"`lean-py sync` of {pkg} failed (exit {r.returncode})")
+            _registries.pop(pkg, None)
+            importlib.invalidate_caches()
+        if _registry(pkg).get(block.qualname) != block.key:
+            raise LeanBlockStale(
+                f"the Lean block {name!r} of {block.module} has changed since `lean-py sync` generated it;"
+                " run `lean-py sync` (or set LEAN_PYTHON_AUTO_SYNC=1)"
+            )
+    return importlib.import_module(f"{pkg}._lean.{block.stem}")

lean_python/io.py

@@ -0,0 +1,15 @@
+"""Running a Lean `main`-like IO action."""
+
+import sys
+
+from lean_python.io_externs import lean_io_result_show_error
+
+
+def run_main(f):
+    """Runs the IR function of an `IO Unit` action as Lean's C `main` does; returns the exit code."""
+    r = f()
+    sys.stdout.flush()
+    if r.tag == 0:
+        return 0
+    lean_io_result_show_error(r)
+    return 1