lean-interact 0.1.0__tar.gz → 0.2.0__tar.gz

lean_interact-0.2.0/.devcontainer/devcontainer.json

@@ -0,0 +1,25 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/python
+{
+  "name": "Python 3",
+  // Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
+  "image": "mcr.microsoft.com/devcontainers/python:1-3.12-bullseye",
+  "features": {
+    "ghcr.io/va-h/devcontainers-features/uv:1": {
+      "shellautocompletion": true,
+      "version": "latest"
+    }
+  },
+
+  // Use 'forwardPorts' to make a list of ports inside the container available locally.
+  // "forwardPorts": [],
+
+  // Use 'postCreateCommand' to run commands after the container is created.
+  "postCreateCommand": "uv pip install -e . && uv sync --dev && uv run install-lean",
+
+  // Configure tool-specific properties.
+  // "customizations": {},
+
+  // Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
+  "remoteUser": "root"
+}

{lean_interact-0.1.0 → lean_interact-0.2.0}/.github/workflows/ci.yml

@@ -12,8 +12,7 @@ jobs:
       - name: Install elan
         run: |
           set -o pipefail
-          curl -sSfL https://github.com/leanprover/elan/releases/download/v3.1.1/elan-x86_64-unknown-linux-gnu.tar.gz | tar xz
-          ./elan-init -y --default-toolchain none
+          curl https://raw.githubusercontent.com/leanprover/elan/master/elan-init.sh -sSf | sh -s -- -y --default-toolchain none
           echo "$HOME/.elan/bin" >> $GITHUB_PATH
 
       - name: Set up Python

lean_interact-0.2.0/.github/workflows/publish-to-pypi.yml

@@ -0,0 +1,21 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - v*
+
+jobs:
+  pypi:
+    name: Publish to PyPI
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/lean-interact
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v3
+      - run: uv build
+      - run: uv publish --trusted-publishing always

{lean_interact-0.1.0 → lean_interact-0.2.0}/.gitignore

@@ -1,13 +1,14 @@
+# Lean
 build
 lake-packages/*
 lakefile.olean
 .lake
-test/Mathlib/.lake
-test/*.olean
-test/*.olean.tmp
+src/cache
 cache
-sandbox*
 
 # Python
 .venv
 __pycache__
+
+sandbox*
+.vscode

{lean_interact-0.1.0 → lean_interact-0.2.0}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 LeanDojo Team
+Copyright (c) 2025
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{lean_interact-0.1.0 → lean_interact-0.2.0}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: lean-interact
-Version: 0.1.0
+Version: 0.2.0
 Summary: LeanInteract is a Python package that allows you to interact with the Lean theorem prover.
 Author-email: Auguste Poiroux <auguste.poiroux@epfl.ch>
 License: MIT License
         
-        Copyright (c) 2023 LeanDojo Team
+        Copyright (c) 2025
         
         Permission is hereby granted, free of charge, to any person obtaining a copy
         of this software and associated documentation files (the "Software"), to deal
@@ -27,7 +27,7 @@ License: MIT License
 License-File: LICENSE
 Keywords: Lean,REPL,autoformalization,theorem proving
 Requires-Python: >=3.10
-Requires-Dist: packaging>=24.2
+Requires-Dist: gitpython>=3.1.44
 Requires-Dist: pexpect>=4.9.0
 Requires-Dist: psutil>=6.1.0
 Requires-Dist: requests>=2.32.3
@@ -38,57 +38,46 @@ Description-Content-Type: text/markdown
 
 **LeanInteract** is a Python package designed to seamlessly interact with Lean 4 through the [Lean REPL](https://github.com/leanprover-community/repl).
 
-> [!NOTE]
-> This tool is still experimental and has been primarily tested on Linux. Compatibility with macOS is not guaranteed. Windows is not supported at the moment. Please report any issues you encounter.
-
 ## Key Features
 
+- **🔗 Interactivity**: Execute Lean code and files directly from Python, and iterate on environment states.
 - **🚀 Ease of Use**: LeanInteract abstracts the complexities of Lean setup and interaction, enabling quick experimentation.
-- **🔗 Interactivity**: Execute Lean code, files, tactics, and (partial) proofs directly from Python. Easily iterate through environment and proof states.
-- **🔧 Compatibility**: Supports Lean versions from `v4.7.0-rc1` to `v4.16.0-rc2`.
+  - Automatically downloads and builds Lean REPL versions for you. Versions are cached for fast reuse.
+- **🔧 Compatibility**: Supports all Lean versions between `v4.7.0-rc1` and `v4.18.0-rc1`.
   - Ensures compatibility with various Lean projects and machine learning benchmarks.
-  - Need older versions? Open an issue [here](https://github.com/augustepoiroux/repl).
-- **🔄 Up-to-date**: LeanInteract is a lightweight wrapper around [Lean REPL](https://github.com/leanprover-community/repl), ensuring it stays current with the latest Lean versions and features.
-- **📥 Automatic Setup**: Automatically downloads and builds Lean REPL versions for you. Versions are cached for fast reuse.
 - **📦 Temporary Projects**: Easily instantiate temporary Lean environments with dependencies.
-  - Useful for experimenting and interacting with benchmarks like [ProofNet](https://github.com/zhangir-azerbayev/ProofNet) and [MiniF2F](https://github.com/yangky11/miniF2F-lean4) without manual setup.
-
-## Similar tools
-
-We recommend checking out these tools:
+  - Useful for experimenting and interacting with benchmarks depending on [Mathlib](https://github.com/leanprover-community/mathlib4) like [ProofNet#](https://huggingface.co/datasets/PAug/ProofNetSharp) and [MiniF2F](https://github.com/yangky11/miniF2F-lean4) without manually setting up a Lean project.
 
-- **[PyPantograph](https://github.com/lenianiva/PyPantograph)**: Based on Pantograph, offering more options for proof interactions than Lean REPL.
-- **[LeanDojo](https://github.com/lean-dojo/LeanDojo)**: Parses Lean projects to create datasets and interact with theorems to prove them.
-- **[leanclient](https://github.com/oOo0oOo/leanclient)**: Interact with the Lean LSP server.
-
-LeanInteract is inspired by:
+## Installation and Setup
 
-- **[pylean](https://github.com/zhangir-azerbayev/repl)**
-- **[lean4_jupyter](https://github.com/utensil/lean4_jupyter)**
+You can install the LeanInteract package using the following command:
 
-## Installation and Setup
+```bash
+pip install lean-interact
+```
 
 Requirements:
 
 - Python >= 3.10
 - git
 - [Lean 4](https://leanprover-community.github.io/get_started.html)
+  - Tip: the `install-lean` command can install Lean 4 for you after installing LeanInteract.
 
-If the requirements are met, install the LeanInteract package:
-
-```bash
-pip install lean-interact
-```
+> [!NOTE]
+> This tool is still experimental and has been primarily tested on Linux. Compatibility with macOS is not guaranteed. For Windows, use WSL.
+> Please report any issues you encounter.
 
 ## Script examples
 
-In the `examples` directory, you will find various scripts demonstrating how to use LeanInteract:
+In the `examples` directory, you will find a few scripts demonstrating how to use LeanInteract. We recommend [uv](https://github.com/astral-sh/uv) to run these scripts (`uv run <script>.py`).
 
-- `minif2f_deepseek_prover_v1_5.py`: use [DeepSeek-Prover-V1.5](https://arxiv.org/abs/2408.08152) to prove theorems from the [MiniF2F](https://github.com/yangky11/miniF2F-lean4) benchmark.
-- `proofnetsharp_type_check.py`: type check theorems from the [ProofNet#](https://github.com/zhangir-azerbayev/ProofNet) benchmark.
-- `proofnetsharp_false_theorems.py`: find theorems that can be proven false from the [ProofNet#](https://github.com/zhangir-azerbayev/ProofNet) benchmark.
-- `proofnet_metric_beq_plus.py`: run a simple [BEq](https://openreview.net/forum?id=hUb2At2DsQ) checker on the ProofNet-Metric benchmark.
-- `improving_autoformalization_using_type_checking.py`: an implementation of the sampling method used in [Improving Autoformalization using Type Checking](https://arxiv.org/abs/2406.07222).
+- `beq_plus.py`: run the autoformalization [BEq+](https://arxiv.org/abs/2406.07222) metric on the [ProofNetVerif](https://huggingface.co/datasets/PAug/ProofNetVerif) benchmark.
+- `type_check.py`: optimize type checking of formal statements using environment states.
+
+Soon to be added:
+
+- `proof_generation_and_autoformalization.py`: use [DeepSeek-Prover-V1.5](https://arxiv.org/abs/2408.08152), [Goedel-Prover](https://goedel-lm.github.io/), and other models to prove theorems from the [MiniF2F](https://github.com/yangky11/miniF2F-lean4) and [ProofNet#](https://huggingface.co/datasets/PAug/ProofNetSharp) benchmarks.
+- `statement_autoformalization_sampling.py`: an implementation of the sampling-based statement autoformalization method used in [Improving Autoformalization using Type Checking](https://arxiv.org/abs/2406.07222).
 
 ## Usage
 
@@ -97,7 +86,7 @@ In the `examples` directory, you will find various scripts demonstrating how to
 ```python
 from lean_interact import LeanREPLConfig, LeanServer
 
-config = LeanREPLConfig() # download and build Lean REPL
+config = LeanREPLConfig(verbose=True) # download and build Lean REPL
 server = LeanServer(config) # start Lean REPL
 server.run_code("theorem ex (n : Nat) : n = 5 → n = 5 := sorry")
 ```
@@ -119,50 +108,7 @@ server.run_code("theorem ex (n : Nat) : n = 5 → n = 5 := sorry")
 
 </details>
 
-You can then iterate on the proof state by executing tactics:
-
-```python
-server.run_tactic("intro h", proof_state=0)
-```
-
-<details>
-<summary>Output</summary>
-
-```json
-{"proofState": 1, "goals": ["n : Nat\nh : n = 5\n⊢ n = 5"]}
-```
-
-</details>
-
-```python
-server.run_tactic("exact h", proof_state=1)
-```
-
-<details>
-<summary>Output</summary>
-
-```json
-{"proofState": 2, "goals": []}
-```
-
-</details>
-
-Or by running the entire proof:
-
-```python
-server.run_proof("intro h\nexact h", proof_state=0)
-```
-
-<details>
-<summary>Output</summary>
-
-```json
-{"proofState": 3, "goals": []}
-```
-
-</details>
-
-You can also iterate on the environment:
+Iterate on the environment state:
 
 ```python
 server.run_code("theorem ex2 (x : Nat) : x = 5 → x = 5 := by\n  exact ex x", env=0)
@@ -180,19 +126,25 @@ server.run_code("theorem ex2 (x : Nat) : x = 5 → x = 5 := by\n  exact ex x", e
 > [!NOTE]
 > The initial invocation of `LeanREPLConfig` might take some time as it downloads and builds Lean REPL. Future executions with identical parameters will be significantly quicker due to caching.
 
-### Using a specific Lean version
+### Specific Lean version
 
 ```python
 config = LeanREPLConfig(lean_version="v4.7.0")
 ```
 
-### Using an existing Lean project directory
+### Existing Lean projects
+
+```python
+config = LeanREPLConfig(project=LocalProject("path/to/your/project"))
+```
+
+or
 
 ```python
-config = LeanREPLConfig(project_dir="path/to/your/project")
+config = LeanREPLConfig(project=GitProject("https://github.com/yangky11/lean4-example"))
 ```
 
-You can then use `run_code`, `run_tactic` and `run_file` as usual:
+You can then use `run_code` and `run_file` as usual:
 
 ```python
 server = LeanServer(config)
@@ -200,28 +152,28 @@ server.run_file("file.lean")
 ```
 
 > [!IMPORTANT]
-> Ensure the project in `project_dir` has been *successfully* built with `lake build` before using the REPL.
+> Ensure the project can be *successfully* built with `lake build` before using LeanInteract.
 
-### Using a temporary project with dependencies
+### Temporary project with dependencies
 
 ```python
-config = LeanREPLConfig(lean_version="v4.7.0", require=[LeanRequire(
+config = LeanREPLConfig(lean_version="v4.7.0", project=TempRequireProject([LeanRequire(
     name="mathlib",
     git="https://github.com/leanprover-community/mathlib4.git",
     rev="v4.7.0"
-)])
+)]))
 ```
 
 Mathlib being a frequent requirement, a shortcut is available:
 
 ```python
-config = LeanREPLConfig(lean_version="v4.7.0", require="mathlib")
+config = LeanREPLConfig(lean_version="v4.7.0", project=TempRequireProject("mathlib"))
 ```
 
-You can then use Mathlib:
+You can then use Mathlib as follows:
 
 ```python
-server = LeanServer(config_readme_mathlib)
+server = LeanServer(config)
 server.run_code("""import Mathlib
 theorem ex_mathlib (x : ℝ) (y : ℚ) :\n  ( Irrational x ) -> Irrational ( x + y ) := sorry""")
 ```
@@ -246,9 +198,100 @@ theorem ex_mathlib (x : ℝ) (y : ℚ) :\n  ( Irrational x ) -> Irrational ( x +
 > [!NOTE]
 >
 > - Mathlib is a large library and may take some time to download and build.
-> - Mathlib, and other libraries, are not available for all Lean versions. An error will be raised if the Lean version you are using does not support Mathlib. You can always specify a different version with the `lean_version` parameter if you know a compatible version.
 > - A separate cache is used for each unique set of dependencies.
 
+### Fine-grained temporary project
+
+For more control over the temporary project, you can use `TemporaryProject` to specify the content of the lakefile.
+
+```python
+config = LeanREPLConfig(lean_version="v4.18.0-rc1", project=TemporaryProject("""
+import Lake
+open Lake DSL
+
+package "dummy" where
+  version := v!"0.1.0"
+
+@[default_target]
+lean_exe "dummy" where
+  root := `Main
+
+require mathlib from git
+  "https://github.com/leanprover-community/mathlib4.git" @ "v4.18.0-rc1"
+"""))
+```
+
+### Tactic and proof modes (experimental)
+
+```python
+server.run_code("theorem ex (n : Nat) : n = 5 → n = 5 := sorry")
+```
+
+<details>
+<summary>Output</summary>
+
+```json
+{"sorries": [{"proofState": 0,
+   "pos": {"line": 1, "column": 40},
+   "goal": "n : Nat\n⊢ n = 5 → n = 5",
+   "endPos": {"line": 1, "column": 45}}],
+ "messages": [{"severity": "warning",
+   "pos": {"line": 1, "column": 8},
+   "endPos": {"line": 1, "column": 10},
+   "data": "declaration uses 'sorry'"}],
+ "env": 0}
+```
+
+</details>
+
+You can then iterate on the proof state by executing tactics:
+
+```python
+server.run_tactic("intro h", proof_state=0)
+```
+
+<details>
+<summary>Output</summary>
+
+```json
+{"proofState": 1, "goals": ["n : Nat\nh : n = 5\n⊢ n = 5"]}
+```
+
+</details>
+
+```python
+server.run_tactic("exact h", proof_state=1)
+```
+
+<details>
+<summary>Output</summary>
+
+```json
+{"proofState": 2, "goals": []}
+```
+
+</details>
+
+or by running the entire/partial proofs:
+
+```python
+server.run_proof("intro h\nexact h", proof_state=0)
+```
+
+<details>
+<summary>Output</summary>
+
+```json
+{"proofState": 3, "goals": []}
+```
+
+</details>
+
+## Helper Commands
+
+- `install_lean`: Installs Lean 4 version manager `elan`.
+- `clear_lean_cache`: Removes all Lean REPL versions and temporary projects in the package cache. This can help resolve some issues. If it does, please open an issue.
+
 ## Advanced options
 
 ### LeanServer
@@ -256,18 +299,25 @@ theorem ex_mathlib (x : ℝ) (y : ℚ) :\n  ( Irrational x ) -> Irrational ( x +
 Two versions of Lean servers are available:
 
 - **`LeanServer`**: A wrapper around Lean REPL. Interact with it using `run_code`, `run_file`, and `run_tactic` methods.
-- **`AutoLeanServer`**: An experimental subclass of `LeanServer` monitoring memory usage to limit *out of memory* crashes in multiprocessing contexts. Additionally, since Lean REPL retains all environment and proof states,  `AutoLeanServer` regularly clears the REPL's memory to prevent crashes. Use the `add_to_session_cache` attribute in various methods to prevent selected environment/proof states to be cleared.
+- **`AutoLeanServer`**: An experimental subclass of `LeanServer` automatically recovering from crashes and timeouts. It also monitors memory usage to limit *out of memory* crashes in multiprocessing contexts. Use the `add_to_session_cache` attribute available in various methods to prevent selected environment/proof states to be cleared.
 
 > [!TIP]
 >
-> - To run multiple requests in parallel, we recommend using multiprocessing with one `AutoLeanServer` instance per process.
+> - To run multiple requests in parallel, we recommend using multiprocessing with one global `LeanREPLConfig` instance, and one `AutoLeanServer` instance per process.
 > - Make sure to instantiate `LeanREPLConfig` before starting the processes to avoid conflicts during Lean REPL's download and build.
 > - While `AutoLeanServer` can help prevent crashes, it is not a complete solution. If you encounter crashes, consider reducing the number of parallel processes or increasing the memory available to your system.
 
-### Helper Methods and Variables
+### Custom Lean REPL
 
-- `clear_cache()`: Removes all Lean REPL versions and temporary projects in the package cache. This can help resolve some issues. If it does, please open an issue.
+To use a forked Lean REPL project, specify the git repository using the `repl_git` parameter in the `LeanREPLConfig`. Your fork should have a similar versioning format to <https://github.com/augustepoiroux/repl> (i.e. having a branch with commits for each Lean version). For assistance, feel free to contact [us](mailto:auguste.poiroux@epfl.ch).
 
-### Custom Lean REPL
+## Similar tools
+
+We recommend checking out these tools:
+
+- **[PyPantograph](https://github.com/lenianiva/PyPantograph)**: Based on Pantograph, offering more options for proof interactions than Lean REPL.
+- **[LeanDojo](https://github.com/lean-dojo/LeanDojo)**: Parses Lean projects to create datasets and interact with proof states.
+- **[itp-interface](https://github.com/trishullab/itp-interface)**: A Python interface for interacting and extracting data from Lean 4 and Coq.
+- **[leanclient](https://github.com/oOo0oOo/leanclient)**: Interact with the Lean LSP server.
 
-To use a forked Lean REPL project, specify the git repository using the `repl_git` parameter in the `LeanREPLConfig`. Your fork should have a similar format to <https://github.com/augustepoiroux/repl>. For assistance, feel free to contact [us](mailto:auguste.poiroux@epfl.ch).
+LeanInteract is inspired by **[pylean](https://github.com/zhangir-azerbayev/repl)** and **[lean4_jupyter](https://github.com/utensil/lean4_jupyter)**.