lean-python 0.1.0__py3-none-any.whl

lean_python/sync.py

@@ -0,0 +1,265 @@
+"""``lean-py sync``: check the Lean blocks of a package and generate their Python modules."""
+
+import ast
+import importlib
+import json
+import os
+import pathlib
+import re
+import shutil
+import subprocess
+import sys
+
+from lean_python import embed, models
+
+LAKEFILE = """name = "lean-python-workspace"
+defaultTargets = ["LeanPythonEmbed"]
+
+[[lean_lib]]
+name = "LeanPythonEmbed"
+
+[[lean_lib]]
+name = "LeanPythonModels"
+"""
+
+_LAKE_ERROR = re.compile(r"^(error|warning): (?:\./)*(LeanPython(?:Embed|Models)/[^:]+\.lean):(\d+):(\d+): (.*)$")
+
+
+class SyncError(Exception):
+    def __init__(self, msg, code=254):
+        super().__init__(msg)
+        self.code = code
+
+
+def project_root(pkg_dir):
+    p = pkg_dir.resolve()
+    for d in [p, *p.parents]:
+        if (d / "pyproject.toml").exists():
+            return d
+    return p.parent
+
+
+def record_blocks(pkg_dir):
+    """Imports every module of the package and returns the blocks their `lean(...)` calls define."""
+    pkg_dir = pkg_dir.resolve()
+    pkg = pkg_dir.name
+    sys.path.insert(0, str(pkg_dir.parent))
+    embed._recording = []
+    errors = []
+    try:
+        for path in sorted(pkg_dir.rglob("*.py")):
+            rel = path.relative_to(pkg_dir)
+            if rel.parts[0] == "_lean" or "__pycache__" in rel.parts or rel.name == "__main__.py":
+                continue
+            parts = [pkg, *rel.with_suffix("").parts]
+            if parts[-1] == "__init__":
+                parts = parts[:-1]
+            name = ".".join(parts)
+            try:
+                importlib.import_module(name)
+            except Exception as e:  # noqa: BLE001
+                errors.append(f"{name}: {type(e).__name__}: {e}")
+        return list(embed._recording), errors
+    finally:
+        embed._recording = None
+
+
+def resolve_use(block, use, by_name):
+    q = use if ":" in use else f"{block.module}:{use}"
+    b = by_name.get(q)
+    if b is None:
+        raise SyncError(f"{block.file}:{block.line}: lean block {block.name!r} uses unknown block {use!r}", 252)
+    return b
+
+
+def block_file(block, by_name):
+    imports = list(block.imports)
+    opens = []
+    if block.models:
+        for module in models.modules_source(list(block.models)):
+            ns = models.dotted(models.models_namespace(module))
+            imports.append(ns)
+            opens.append(ns)
+    for use in block.uses:
+        other = resolve_use(block, use, by_name)
+        ns = models.dotted(other.lean_module)
+        imports.append(ns)
+        opens.append(ns)
+    ns = models.dotted(block.lean_module)
+    head = "".join(f"import {i}\n" for i in dict.fromkeys(imports))
+    head += f"\nnamespace {ns}\n"
+    head += "".join(f"open {o}\n" for o in opens)
+    head += "\n"
+    return head, head + block.source + f"\n\nend {ns}\n"
+
+
+def source_line(block):
+    """The line of the Python file where the block's source string starts."""
+    try:
+        tree = ast.parse(pathlib.Path(block.file).read_text())
+    except (OSError, SyntaxError):
+        return block.line
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Call) and node.lineno <= block.line <= (node.end_lineno or node.lineno):
+            args = [*node.args, *(k.value for k in node.keywords if k.arg == "source")]
+            for a in args:
+                if isinstance(a, ast.Constant) and a.value == block.source:
+                    return a.lineno
+    return block.line
+
+
+def map_error(line, offsets):
+    m = _LAKE_ERROR.match(line.strip())
+    if not m:
+        return None
+    sev, path, ln, col, msg = m.groups()
+    info = offsets.get(path)
+    if info is None:
+        return f"{path}:{ln}:{col}: {sev}: {msg}"
+    block, head_lines, start = info
+    k = int(ln) - head_lines
+    if k < 1:
+        return f"{block.file}:{block.line}: {sev}: (lean block {block.name}, Lean {ln}:{col}) {msg}"
+    return f"{block.file}:{start + k - 1}: {sev}: (lean block {block.name}, Lean {k}:{col}) {msg}"
+
+
+def lake_messages(output, offsets):
+    """The messages of a Lake build mapped to the Python files, with their continuation lines."""
+    out = []
+    lines = output.splitlines()
+    i = 0
+    while i < len(lines):
+        mapped = map_error(lines[i], offsets)
+        i += 1
+        if mapped is None:
+            continue
+        body = [mapped]
+        while (
+            i < len(lines)
+            and lines[i].strip()
+            and map_error(lines[i], offsets) is None
+            and (
+                lines[i].startswith(" ")
+                or not re.match(r"^(✖|✔|⣿|trace:|info:|error:|warning:|Some required|- )", lines[i])
+            )
+        ):
+            body.append(lines[i])
+            i += 1
+        out.append("\n".join(body))
+    return out
+
+
+def sync_package(pkg_dir, cli=None, out=sys.stderr):
+    pkg_dir = pathlib.Path(pkg_dir).resolve()
+    cli = cli or os.environ.get("LEAN_PYTHON_CLI") or shutil.which("lean-python")
+    if cli is None:
+        raise SyncError("the Lean CLI `lean-python` is not on PATH (set LEAN_PYTHON_CLI)", 255)
+    gv = subprocess.run([cli, "--generator-version"], check=True, capture_output=True, text=True).stdout.strip()
+    if gv != embed.GENERATOR_VERSION:
+        raise SyncError(f"{cli} generates version {gv}, this package expects {embed.GENERATOR_VERSION}", 255)
+
+    blocks, import_errors = record_blocks(pkg_dir)
+    for e in import_errors:
+        print(f"lean-py: warning: importing {e}", file=out)
+    by_name = {}
+    for b in blocks:
+        if b.qualname in by_name:
+            raise SyncError(f"{b.file}:{b.line}: lean block {b.name!r} is defined twice in {b.module}", 252)
+        by_name[b.qualname] = b
+
+    root = project_root(pkg_dir)
+    ws = root / ".lean-python" / "workspace"
+    for d in ("LeanPythonEmbed", "LeanPythonModels"):
+        shutil.rmtree(ws / d, ignore_errors=True)
+    ws.mkdir(parents=True, exist_ok=True)
+    (ws / "lakefile.toml").write_text(LAKEFILE)
+
+    model_modules = {}
+    for b in blocks:
+        if b.models:
+            model_modules.update(models.modules_source(list(b.models)))
+    offsets = {}
+    for module, src in model_modules.items():
+        p = ws / pathlib.Path(*models.models_namespace(module)).with_suffix(".lean")
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text(src)
+    for b in blocks:
+        head, text = block_file(b, by_name)
+        rel = pathlib.Path(*b.lean_module).with_suffix(".lean")
+        p = ws / rel
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text(text)
+        offsets[str(rel)] = (b, head.count("\n"), source_line(b))
+    (ws / "LeanPythonEmbed.lean").write_text(
+        "".join(f"import {models.dotted(b.lean_module)}\n" for b in blocks) or "\n"
+    )
+    (ws / "LeanPythonModels.lean").write_text(
+        "".join(f"import {models.dotted(models.models_namespace(m))}\n" for m in model_modules) or "\n"
+    )
+
+    r = subprocess.run(
+        ["lake", "build", "LeanPythonEmbed", "LeanPythonModels"], cwd=ws, capture_output=True, text=True, check=False
+    )
+    failed = r.returncode != 0
+    messages = lake_messages(r.stdout + r.stderr, offsets)
+    for m in messages:
+        if failed or ": warning:" in m.split("\n")[0]:
+            print(f"lean-py: {m}", file=out)
+    if failed:
+        if not messages:
+            print(r.stdout + r.stderr, file=out)
+        raise SyncError("lake build failed", 254)
+
+    out_dir = pkg_dir / "_lean"
+    shutil.rmtree(out_dir, ignore_errors=True)
+    out_dir.mkdir()
+    jobs = []
+    for b in blocks:
+        type_modules = [
+            {"namespace": ".".join(models.models_namespace(m)), "module": m, "adopt": True}
+            for m in (models.modules_source(list(b.models)) if b.models else {})
+        ]
+        for use in b.uses:
+            other = resolve_use(b, use, by_name)
+            type_modules.append(
+                {"namespace": ".".join(other.lean_module), "module": f"{other.top_package}._lean.{other.stem}"}
+            )
+        jobs.append(
+            {
+                "module": ".".join(b.lean_module),
+                "namespace": ".".join(b.lean_module),
+                "output_file": str(out_dir / f"{b.stem}.py"),
+                "type_modules": type_modules,
+            }
+        )
+    batch = ws / "batch.json"
+    batch.write_text(json.dumps(jobs))
+    r = subprocess.run(
+        [
+            cli,
+            "module",
+            "generate",
+            "--batch",
+            str(batch),
+            "--search-path",
+            str(ws / ".lake/build/lib/lean"),
+            "--output",
+            "json",
+        ],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if r.returncode != 0:
+        print(r.stderr + r.stdout, file=out)
+        raise SyncError("lean-python module generate failed", r.returncode)
+    summaries = json.loads(r.stdout)
+    for s in summaries:
+        for sk in s.get("skipped", []):
+            print(f"lean-py: skipped {sk['name']}: {sk['reason']}", file=out)
+    (out_dir / "__init__.py").write_text('"""Python modules generated by `lean-py sync`. Do not edit."""\n')
+    registry = {}
+    for b in blocks:
+        registry[b.qualname] = embed.block_key(b)
+    (out_dir / "blocks.json").write_text(json.dumps(registry, indent=2, sort_keys=True) + "\n")
+    print(f"lean-py: {len(blocks)} blocks of {pkg_dir.name} checked and generated", file=out)

lean_python/types.py

@@ -0,0 +1,33 @@
+"""Python types of Lean's scalar types, as ``Annotated`` aliases with annotated-types constraints."""
+
+from typing import Annotated
+
+from annotated_types import Ge, Le, MaxLen, MinLen
+
+Nat = Annotated[int, Ge(0)]
+UInt8 = Annotated[int, Ge(0), Le(2**8 - 1)]
+UInt16 = Annotated[int, Ge(0), Le(2**16 - 1)]
+UInt32 = Annotated[int, Ge(0), Le(2**32 - 1)]
+UInt64 = Annotated[int, Ge(0), Le(2**64 - 1)]
+USize = UInt64
+Int8 = Annotated[int, Ge(-(2**7)), Le(2**7 - 1)]
+Int16 = Annotated[int, Ge(-(2**15)), Le(2**15 - 1)]
+Int32 = Annotated[int, Ge(-(2**31)), Le(2**31 - 1)]
+Int64 = Annotated[int, Ge(-(2**63)), Le(2**63 - 1)]
+ISize = Int64
+Char = Annotated[str, MinLen(1), MaxLen(1)]
+
+__all__ = [
+    "Char",
+    "ISize",
+    "Int8",
+    "Int16",
+    "Int32",
+    "Int64",
+    "Nat",
+    "UInt8",
+    "UInt16",
+    "UInt32",
+    "UInt64",
+    "USize",
+]

lean_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,231 @@
+Metadata-Version: 2.5
+Name: lean-python
+Version: 0.1.0
+Summary: Run Lean 4 code as Python: a runtime for code generated from Lean's IR, Lean blocks in Python files, and pydantic models for Lean types
+Project-URL: Repository, https://github.com/conao3/lean-py
+License-Expression: Apache-2.0
+License-File: LICENSE
+Classifier: Framework :: Pydantic :: 2
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Compilers
+Requires-Python: >=3.12
+Requires-Dist: pydantic>=2.11
+Description-Content-Type: text/markdown
+
+# lean-py
+
+Write and prove functions in Lean 4, run them as Python, and pass pydantic models across.
+
+```python
+from pydantic import BaseModel, Field
+from lean_python import lean
+
+
+class LineItem(BaseModel):
+    sku: str
+    qty: int = Field(ge=1)
+    unitPrice: int = Field(ge=0)
+
+
+pricing = lean("pricing", r"""
+inductive Discount where
+  | none
+  | percent (p : Nat) (h : p ≤ 100)
+  | fixed (amount : Nat)
+
+def subtotal (items : List LineItem) : Nat :=
+  items.foldl (fun acc i => acc + i.qty * i.unitPrice) 0
+
+def total (items : List LineItem) (d : Discount) : Nat :=
+  match d with
+  | .none => subtotal items
+  | .percent p _ => subtotal items - subtotal items * p / 100
+  | .fixed a => subtotal items - a
+
+theorem total_le (items : List LineItem) (d : Discount) : total items d ≤ subtotal items := by
+  unfold total; split <;> omega
+""", models=[LineItem])
+
+items = [LineItem(sku="a", qty=2, unitPrice=100)]
+pricing.total(items, pricing.Discount.percent(p=10))  # 180
+pricing.Discount.percent(p=150)                       # pydantic.ValidationError: p: Input should be less than or equal to 100
+```
+
+- `lean-py sync` checks the proofs with Lake and compiles the Lean code from Lean's IR to plain
+  Python. The generated modules are written to `<package>/_lean/` and ship with your package; running
+  them needs only the `lean-python` wheel (and pydantic), not Lean.
+- The generated Python computes what the C backend computes: a diff test runs the same Lean
+  programs natively and as Python and compares the output byte for byte. Reference counting is
+  kept, so `Array` updates happen in place as in C.
+- Lean structures and inductive types become pydantic models. A proof field (`h : p ≤ 100`) becomes
+  a validator that runs a decision procedure compiled from the proposition, so every value that
+  reaches Lean satisfies the invariants the proofs rely on; a comparison with a constant also becomes
+  an annotated-types constraint (`Le(100)`), checked by pydantic-core and shown in the JSON Schema. The JSON of the models is the JSON of
+  Lean's `deriving ToJson, FromJson`.
+- Your own pydantic models can be used from Lean (`models=[...]`). Their field constraints
+  (`ge`, `gt`, `le`, `lt`, `min_length`, `max_length`) become proof fields that Lean proofs may assume.
+- The models work wherever pydantic does: `TypeAdapter`, `model_validate_json`, JSON Schema, FastAPI
+  request and response types.
+
+## Install
+
+The Python package and the Lean CLI:
+
+```sh
+uv add lean-python                            # the runtime, lean(), lean-py sync
+nix profile install github:conao3/lean-py     # the Lean CLI `lean-python`
+```
+
+`lean-py sync` also needs `lake` and the Lean toolchain of `lean-toolchain` (v4.35.0) on `PATH`.
+
+## Lean blocks
+
+`lean(name, source, *, imports=(), uses=(), models=())` defines a Lean block of the calling module
+(which must belong to a package). The block's definitions are in the namespace
+`LeanPythonEmbed.<module>.<name>`; the returned module exposes them under their names relative to it
+(`Discount.percent`, `total`).
+
+```sh
+lean-py sync --package src/myapp
+```
+
+imports every module of the package, writes each block to a Lake workspace in
+`.lean-python/workspace/`, builds it, and generates `src/myapp/_lean/<module>__<name>.py` and
+`src/myapp/_lean/blocks.json`. Lean errors point at the Python file:
+
+```
+lean-py: src/myapp/m.py:6: error: (lean block m, Lean 4:28) Tactic `rfl` failed: ...
+```
+
+Add `.lean-python/` to `.gitignore` and commit `<package>/_lean/`.
+
+At run time `lean(...)` compares a hash of the block (its source, imports, uses, the Lean structures
+of its models and the generator version) with `blocks.json` and raises `LeanBlockStale` when the
+block changed since the last sync. With `LEAN_PYTHON_AUTO_SYNC=1` it runs `lean-py sync` instead.
+
+- `imports=["Std.Data.HashMap"]`: Lean modules to import.
+- `uses=["geometry"]`: other blocks of the module (or `"pkg.mod:name"`), imported and opened; their
+  types are shared, not generated again.
+- `models=[LineItem]`: pydantic models available as Lean structures (below).
+
+## Values
+
+| Lean | Python |
+|---|---|
+| `Nat` | `int` (`lean_python.types.Nat` = `Annotated[int, Ge(0)]`) |
+| `Int` | `int` |
+| `UInt8` … `UInt64`, `USize`, `Int8` … `Int64` | `int` with the range as `Ge`/`Le` |
+| `Fin n` | `Annotated[int, Ge(0), Lt(n)]` |
+| `Bool` | `bool` |
+| `Char` | `str` of one character |
+| `String` | `str` |
+| `Float`, `Float32` | `float` |
+| `Unit` | `None` |
+| `Option α` | `α \| None` |
+| `List α`, `Array α` | `list[α]` |
+| `α × β` | `tuple[α, β]` |
+| `{x : α // p x}` | `Annotated[α, AfterValidator(p)]` |
+| structure | a frozen, strict pydantic model |
+| inductive type, constructors without arguments | `enum.StrEnum` |
+| other inductive type | a model per constructor, subclasses of the type's class |
+| `IO α` | `α`; an `IO.Error` is raised as `LeanIOError` (an `OSError`) |
+
+Arguments are checked while they are converted (`pub.double(-1)` raises `ValidationError` with the
+location of the bad value). Constants are functions without arguments (`answer()`).
+
+Constructors and structures take keyword arguments (`Shape.rect(width=1, height=2)`); unnamed
+constructor arguments are `a0`, `a1`, …. Inductive values work with `match`:
+
+```python
+match shape:
+    case geometry.Shape.rect(width=w, height=h):
+        ...
+```
+
+### JSON
+
+The JSON of a generated model is the JSON of Lean's derived `ToJson`: a structure is an object, a
+constructor without arguments is its name (`"dot"`), a constructor with named arguments is
+`{"rect": {"width": 1, "height": 2}}`, with unnamed arguments `{"num": 7}` or `{"pair": [1, "x"]}`.
+`tests/test_json.py` compares the generated models with a native Lean program that prints `toJson`.
+
+### Your pydantic models in Lean
+
+`models=[LineItem]` writes a Lean structure for each model (and the models its fields use) to the
+namespace `LeanPythonModels.<python module>`, opened in the block:
+
+```lean
+structure LineItem where
+  sku : String
+  qty : Nat
+  qty_ge : 1 ≤ qty
+  unitPrice : Nat
+```
+
+`int` with a lower bound of at least 0 becomes `Nat`; the other bounds and `min_length`/`max_length`
+become proof fields. Field types: `int`, `bool`, `str`, `float`, `list[T]`, `tuple[...]`, `T | None`,
+other models, enums (an inductive type `LeanPythonModels.<module>.<Enum>` with a constructor per
+member), `Literal["a", "b"]` (`LeanPythonLiterals.<module>.<Model>_<field>`), and unions of models
+(`LeanPythonUnions.<module>.<Model>_<field>`, a constructor per model holding it as `val`). `multiple_of`, `pattern` and validators are not assumed in Lean; the structure's
+docstring lists them. Generated functions take and return your classes; values that did not go
+through validation (`model_construct`) are checked again on the way to Lean.
+
+## The CLI
+
+```
+lean-python module generate --module-name <Name> [--roots <Name> ...] [--namespace <Name>]
+  [--search-path <dir> ...] [--output-file <path>] [--internal-only] [--output json|text]
+  [--type-module <Name>=<module> ...] [--model-module <Name>=<module> ...] [--batch <file>]
+lean-python --version | --generator-version | help
+```
+
+`module generate` writes one Python module with the IR of the roots and of everything they call
+(Init and Std included), and public functions and types for the roots. Definitions it cannot expose
+(polymorphic functions, functions over functions) are reported as skipped. Exit codes: 0 success,
+252 invalid parameters, 254 input that cannot be converted, 255 other errors.
+
+## Performance
+
+`make bench` (CPython 3.14, x86_64; the native column is the C backend):
+
+| workload | n | Python (s) | native C (s) |
+|---|---|---|---|
+| `Array.push`, `set!`, sum | 10⁴ | 0.017 | 0.005 |
+| `Array.push`, `set!`, sum | 10⁵ | 0.179 | 0.006 |
+| `Array.push`, `set!`, sum | 10⁶ | 1.796 | 0.017 |
+| `fib` (loop) | 10⁵ | 0.176 | 0.074 |
+| `naiveFib` | 25 | 0.149 | 0.005 |
+| `String.push` | 10⁴ | 0.012 | 0.005 |
+| `String.push` | 10⁵ | 0.227 | 0.006 |
+| `Array.qsort` | 10⁵ | 1.929 | 0.020 |
+
+Passing 10⁴ models to a Lean function takes 0.036 s (pydantic's `TypeAdapter(list[Model])` validates
+10⁴ dicts in 0.009 s).
+
+## Development
+
+```sh
+nix develop -c make check   # treefmt, the diff tests against the C backend, pytest
+nix develop -c make bench
+```
+
+- `LeanPython/EmitPy.lean`: IR → Python. `LeanPython/Marshal.lean`, `LeanPython/Generate.lean`: public
+  types and functions. `Main.lean`: the CLI.
+- `src/lean_python/runtime.py`, `io_externs.py`: the runtime (`lean_*` are the C names of Lean's
+  externs). `marshal.py`, `types.py`: pydantic types. `embed.py`, `sync.py`, `models.py`, `cli.py`:
+  `lean(...)` and `lean-py sync`.
+- `LeanPythonTest/`: Lean programs of the tests; `test-diff.sh` runs `Vectors` and `Io` natively and
+  as Python.
+
+## Limitations
+
+- Polymorphic functions, functions taking or returning functions, `Thunk`/`Task`/`IO.Ref`/
+  `ByteArray` in public signatures are not exposed (they still run inside Lean code).
+- `Task`s run synchronously.
+- Building a `String` with `String.push` copies the string each time (Python `bytes`), so it grows
+  quadratically.
+- Python's own functions are not verified in Lean yet.
+
+## License
+
+Apache-2.0

lean_python-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+lean_python/__init__.py,sha256=w09gaS4QGgFS0pM8Y3aSVMfQm-iHgEG_Sm_RqwKh--I,182
+lean_python/cli.py,sha256=ERwAkhhFJV32BqS3-lDHPYi0UiCbydyEFI0ZlHobmsk,1559
+lean_python/embed.py,sha256=WBEWYN7r3xFbSNLgvRRfn-6qhcR5Q1h1ge8KwQ5yyfE,3996
+lean_python/io.py,sha256=l7LErXI_DhACZf9Jaef3r5Stqh4PdUk-bCNTo91BLE0,356
+lean_python/io_externs.py,sha256=lI7oK7WTMjYV1JxaNzEnscVMunME_5SYoGDz3Qq1GSM,29807
+lean_python/marshal.py,sha256=WIY3yJtnIMvym8_jraY8F1tW8x1iYqRkcS4W_FGWwLM,20778
+lean_python/models.py,sha256=wunIZ9hOG-8H3shdRClLN7pR6Kmofo9zlPcL3Hr0rq0,10940
+lean_python/runtime.py,sha256=Fr3R6x-kZUW2H1_NwbwI_LI97OUmMQ8Q0smnPKyyAAc,28439
+lean_python/sync.py,sha256=JKJj3IWQlrqjTvK_-puPuF1Nt0LMumywUilUJANqhfc,9304
+lean_python/types.py,sha256=qOhcwe1lYGD17OHW_A4LzfGi2bcPovTANTggaJwG-FM,843
+lean_python-0.1.0.dist-info/METADATA,sha256=7IosM2WL2AjIjMM0CYy015gHPmkViqxr_vT075QI1gw,9775
+lean_python-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+lean_python-0.1.0.dist-info/entry_points.txt,sha256=BD86jsJKikYcvsZse4ysbLvvN7TuGogwmiUZZwu7FBo,49
+lean_python-0.1.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+lean_python-0.1.0.dist-info/RECORD,,

lean_python-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

lean_python-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lean-py = lean_python.cli:main