lean-interact 0.4.1__tar.gz → 0.5.1__tar.gz

lean_interact-0.5.1/.github/workflows/ci.yml

@@ -0,0 +1,62 @@
+name: CI
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    name: Test on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        python-version: ['3.10']
+
+    steps:
+      - name: Configure Windows for long paths
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: |
+          # Enable long paths in registry
+          New-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\FileSystem" -Name "LongPathsEnabled" -Value 1 -PropertyType DWORD -Force
+          # Configure Git for long paths
+          git config --system core.longpaths true
+
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install .
+
+      - name: Install Lean (Linux/macOS)
+        if: runner.os != 'Windows'
+        run: |
+          install-lean
+          echo "$HOME/.elan/bin" >> $GITHUB_PATH
+
+      - name: Install Lean (Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: |
+          install-lean
+          echo "$env:USERPROFILE\.elan\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+
+      - name: Run tests (Linux/macOS)
+        if: runner.os != 'Windows'
+        run: python -m unittest discover -s ./tests
+        env:
+          PYTHONIOENCODING: utf-8
+
+      - name: Run tests (Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: python -m unittest discover -s ./tests
+        env:
+          PYTHONIOENCODING: utf-8

{lean_interact-0.4.1 → lean_interact-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-interact
-Version: 0.4.1
+Version: 0.5.1
 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
@@ -29,7 +29,6 @@ Keywords: Lean,REPL,autoformalization,theorem proving
 Requires-Python: >=3.10
 Requires-Dist: filelock>=3.18.0
 Requires-Dist: gitpython>=3.1.44
-Requires-Dist: pexpect>=4.9.0
 Requires-Dist: psutil>=6.1.0
 Requires-Dist: pydantic>=2.11.1
 Requires-Dist: requests>=2.32.3
@@ -38,7 +37,8 @@ Description-Content-Type: text/markdown
 
 # LeanInteract
 
-[![PyPI version](https://badge.fury.io/py/lean-interact.svg)](https://badge.fury.io/py/lean-interact)
+[![PyPI version](https://img.shields.io/pypi/v/lean-interact.svg)](https://pypi.org/project/lean-interact/)
+[![PyPI downloads](https://img.shields.io/pepy/dt/lean-interact.svg)](https://pypi.org/project/lean-interact/)
 [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
@@ -48,6 +48,7 @@ Description-Content-Type: text/markdown
 
 - **🔗 Interactivity**: Execute Lean code and files directly from Python.
 - **🚀 Ease of Use**: LeanInteract abstracts the complexities of Lean setup and interaction.
+- **💻 Cross-platform**: Works on Windows, macOS, and Linux operating systems.
 - **🔧 Compatibility**: Supports all Lean versions between `v4.7.0-rc1` and `v4.19.0-rc2`.
   - We backport the latest features of Lean REPL to older versions of Lean.
 - **📦 Temporary Projects**: Easily instantiate temporary Lean environments.
@@ -480,6 +481,22 @@ Common issues and their solutions:
 
 3. **Long waiting times during first run**: This is expected as Lean REPL is being downloaded and built. Additionally, if you are importing Mathlib it will take even more time. Subsequent runs will be much faster.
 
+4. **(Windows) Path too long error**: Windows has a maximum path length limitation of 260 characters.
+If you get an error similar to the following one, you are likely affected by this problem:
+
+    ```
+    error: external command 'git' exited with code 128
+    ERROR    Failed during Lean project setup: Command '['lake', 'update']' returned non-zero exit status 1.
+    ```
+
+    To resolve this, you can enable long paths in Windows 10 and later versions. For more information, refer to the [Microsoft documentation](https://learn.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation).
+    Alternatively, run the following command in a terminal with administrator privileges:
+
+    ```bash
+    New-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\FileSystem" -Name LongPathsEnabled -Value 1 -PropertyType DWord -Force
+    git config --system core.longpaths true
+    ```
+
 ## Contributing
 
 Contributions are welcome! Here's how you can help:

{lean_interact-0.4.1 → lean_interact-0.5.1}/README.md

@@ -1,6 +1,7 @@
 # LeanInteract
 
-[![PyPI version](https://badge.fury.io/py/lean-interact.svg)](https://badge.fury.io/py/lean-interact)
+[![PyPI version](https://img.shields.io/pypi/v/lean-interact.svg)](https://pypi.org/project/lean-interact/)
+[![PyPI downloads](https://img.shields.io/pepy/dt/lean-interact.svg)](https://pypi.org/project/lean-interact/)
 [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
@@ -10,6 +11,7 @@
 
 - **🔗 Interactivity**: Execute Lean code and files directly from Python.
 - **🚀 Ease of Use**: LeanInteract abstracts the complexities of Lean setup and interaction.
+- **💻 Cross-platform**: Works on Windows, macOS, and Linux operating systems.
 - **🔧 Compatibility**: Supports all Lean versions between `v4.7.0-rc1` and `v4.19.0-rc2`.
   - We backport the latest features of Lean REPL to older versions of Lean.
 - **📦 Temporary Projects**: Easily instantiate temporary Lean environments.
@@ -442,6 +444,22 @@ Common issues and their solutions:
 
 3. **Long waiting times during first run**: This is expected as Lean REPL is being downloaded and built. Additionally, if you are importing Mathlib it will take even more time. Subsequent runs will be much faster.
 
+4. **(Windows) Path too long error**: Windows has a maximum path length limitation of 260 characters.
+If you get an error similar to the following one, you are likely affected by this problem:
+
+    ```
+    error: external command 'git' exited with code 128
+    ERROR    Failed during Lean project setup: Command '['lake', 'update']' returned non-zero exit status 1.
+    ```
+
+    To resolve this, you can enable long paths in Windows 10 and later versions. For more information, refer to the [Microsoft documentation](https://learn.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation).
+    Alternatively, run the following command in a terminal with administrator privileges:
+
+    ```bash
+    New-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\FileSystem" -Name LongPathsEnabled -Value 1 -PropertyType DWord -Force
+    git config --system core.longpaths true
+    ```
+
 ## Contributing
 
 Contributions are welcome! Here's how you can help:

{lean_interact-0.4.1 → lean_interact-0.5.1}/examples/beq_plus.py

@@ -156,14 +156,14 @@ def beql(
         except ValueError:
             if verbose:
                 console.print("Invalid theorems encountered, skipping this pair.")
-            continue
+            break
 
         formal_code = formal_1_code + formal_2_code
         # Preliminary check to ensure the formalization is well-typed.
         if check_proof_sub(server, formal_code, context_env, formal_2_start_line, "sorry", timeout_per_proof) is None:
             if verbose:
                 console.print("Ill-typed formalization encountered, skipping this pair.")
-            continue
+            break
 
         proof_exact = check_proof_sub(
             server, formal_code, context_env, formal_2_start_line, "exact?", timeout_per_proof
@@ -173,6 +173,8 @@ def beql(
             if verbose:
                 console.print("Proof exact")
                 console.print(Syntax(proof_exact, "lean4"))
+        else:
+            break
 
     return res[0] and res[1]
 
@@ -229,13 +231,13 @@ def beq_plus(
         except ValueError:
             if verbose:
                 console.print("Invalid theorem encountered, skipping this pair.")
-            continue
+            break
 
         formal_code = formal_1_code + formal_2_code
         if check_proof_sub(server, formal_code, context_env, formal_2_start_line, "sorry", timeout_per_proof) is None:
             if verbose:
                 console.print("Ill-typed formalization encountered, skipping this pair.")
-            continue
+            break
 
         # 1. Use BEqL
         proof_exact = check_proof_sub(
@@ -322,6 +324,9 @@ def beq_plus(
                     console.print(Syntax(proof_convert, "lean4"))
                 break
 
+        if not res[i]:
+            break
+
     return res[0] and res[1]
 
 
@@ -382,22 +387,35 @@ open scoped BigOperators"""
     ]
 
     console.print(f"{metric.__name__} metric on examples:")
+    counter_equivalent = 0
     for formalization_1, formalization_2 in formalization_pairs:
         console.print()
         console.rule()
         console.print("Comparing formalizations:")
         console.print(Syntax(formalization_1, "lean4"))
         console.print(Syntax(formalization_2, "lean4"))
-        console.print(
-            f"Proved equivalent: {metric(formalization_1, formalization_2, src_header, repl_config, timeout_per_proof=DEFAULT_TIMEOUT, verbose=True)}"
+        equivalent = metric(
+            formalization_1,
+            formalization_2,
+            src_header,
+            repl_config,
+            timeout_per_proof=DEFAULT_TIMEOUT,
+            verbose=True,
         )
+        counter_equivalent += equivalent
+        if equivalent:
+            console.print("[green]Proved equivalent[/]")
+        else:
+            console.print("[red]Equivalence not proven[/]")
+    console.print()
+    console.print(f"Total proved equivalent: {counter_equivalent}/{len(formalization_pairs)}")
 
 
-def proofnetverif(metric):
+def proofnetverif(metric, n_samples=100):
     repl_config = LeanREPLConfig(lean_version="v4.8.0", project=TempRequireProject("mathlib"), verbose=True)
 
     dataset = load_dataset("PAug/ProofNetVerif", split="valid")
-    dataset = dataset.shuffle(seed=42).select(range(100))
+    dataset = dataset.shuffle(seed=42).select(range(n_samples))
 
     metric_results = []
     for example in tqdm(dataset, desc=f"`{metric.__name__}` metric on ProofNetVerif dataset"):

{lean_interact-0.4.1 → lean_interact-0.5.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lean-interact"
-version = "0.4.1"
+version = "0.5.1"
 description = "LeanInteract is a Python package that allows you to interact with the Lean theorem prover."
 keywords = ["Lean", "theorem proving", "autoformalization", "REPL"]
 license = { file = "LICENSE" }
@@ -10,7 +10,6 @@ requires-python = ">=3.10"
 dependencies = [
     "filelock>=3.18.0",
     "gitpython>=3.1.44",
-    "pexpect>=4.9.0",
     "psutil>=6.1.0",
     "pydantic>=2.11.1",
     "requests>=2.32.3",

{lean_interact-0.4.1 → lean_interact-0.5.1}/src/lean_interact/config.py

@@ -58,8 +58,12 @@ class LocalProject(BaseProject):
         stderr = None if verbose else subprocess.DEVNULL
 
         with FileLock(f"{self.directory}.lock"):
-            # check that the project is buildable
-            subprocess.run(["lake", "build"], cwd=self.directory, check=True, stdout=stdout, stderr=stderr)
+            try:
+                subprocess.run(["lake", "exe", "cache", "get"], cwd=self.directory, check=False, stdout=stdout, stderr=stderr)
+                subprocess.run(["lake", "build"], cwd=self.directory, check=True, stdout=stdout, stderr=stderr)
+            except subprocess.CalledProcessError as e:
+                logger.error("Failed to build local project: %s", e)
+                raise
 
 
 @dataclass(frozen=True)
@@ -70,8 +74,15 @@ class GitProject(BaseProject):
     rev: str | None = None
 
     def _get_directory(self, cache_dir: str, lean_version: str | None = None) -> str:
-        repo_name = "/".join(self.url.split("/")[-2:]).replace(".git", "")
-        return os.path.join(cache_dir, "git_projects", repo_name, self.rev or "latest")
+        repo_parts = self.url.split("/")
+        if len(repo_parts) >= 2:
+            owner = repo_parts[-2]
+            repo = repo_parts[-1].replace(".git", "")
+            return os.path.join(cache_dir, "git_projects", owner, repo, self.rev or "latest")
+        else:
+            # Fallback for malformed URLs
+            repo_name = self.url.replace(".git", "").split("/")[-1]
+            return os.path.join(cache_dir, "git_projects", repo_name, self.rev or "latest")
 
     def _instantiate(self, cache_dir: str, lean_version: str, verbose: bool = True):
         """Instantiate the git project."""
@@ -91,8 +102,12 @@ class GitProject(BaseProject):
 
             repo.submodule_update(init=True, recursive=True)
 
-            # check that the project is buildable
-            subprocess.run(["lake", "build"], cwd=project_dir, check=True, stdout=stdout, stderr=stderr)
+            try:
+                subprocess.run(["lake", "exe", "cache", "get"], cwd=project_dir, check=False, stdout=stdout, stderr=stderr)
+                subprocess.run(["lake", "build"], cwd=project_dir, check=True, stdout=stdout, stderr=stderr)
+            except subprocess.CalledProcessError as e:
+                logger.error("Failed to build the git project: %s", e)
+                raise
 
 
 @dataclass(frozen=True)
@@ -117,8 +132,8 @@ class BaseTempProject(BaseProject):
 
         # Lock the temporary project directory during setup
         with FileLock(f"{tmp_project_dir}.lock"):
-            # check if the Lean project is already built
-            if not os.path.exists(os.path.join(tmp_project_dir, "lakefile.lean")):
+            # check if the Lean project already exists
+            if not os.path.exists(os.path.join(tmp_project_dir, "lake-manifest.json")):
                 # clean the content of the folder in case of a previous aborted build
                 shutil.rmtree(tmp_project_dir, ignore_errors=True)
                 os.makedirs(tmp_project_dir, exist_ok=True)
@@ -127,16 +142,31 @@ class BaseTempProject(BaseProject):
                 cmd_init = ["lake", f"+{lean_version}", "init", "dummy", "exe.lean"]
                 if lean_version.startswith("v4") and int(lean_version.split(".")[1]) <= 7:
                     cmd_init = ["lake", f"+{lean_version}", "init", "dummy", "exe"]
-                subprocess.run(cmd_init, cwd=tmp_project_dir, check=True, stdout=stdout, stderr=stderr)
+
+                try:
+                    subprocess.run(cmd_init, cwd=tmp_project_dir, check=True, stdout=stdout, stderr=stderr)
+                except subprocess.CalledProcessError as e:
+                    logger.error("Failed to initialize Lean project: %s", e)
+                    raise
 
                 # Create or modify the lakefile
                 self._modify_lakefile(tmp_project_dir, lean_version)
 
                 logger.info("Preparing Lean environment with dependencies (may take a while the first time)...")
-                subprocess.run(["lake", "update"], cwd=tmp_project_dir, check=True, stdout=stdout, stderr=stderr)
-                # in case mathlib is used as a dependency, we try to get the cache
-                subprocess.run(["lake", "exe", "cache", "get"], cwd=tmp_project_dir, stdout=stdout, stderr=stderr)
-                subprocess.run(["lake", "build"], cwd=tmp_project_dir, check=True, stdout=stdout, stderr=stderr)
+
+                # Run lake commands with appropriate platform handling
+                try:
+                    subprocess.run(["lake", "update"], cwd=tmp_project_dir, check=True, stdout=stdout, stderr=stderr)
+                    # in case mathlib is used as a dependency, we try to get the cache
+                    subprocess.run(
+                        ["lake", "exe", "cache", "get"], cwd=tmp_project_dir, check=False, stdout=stdout, stderr=stderr
+                    )
+                    subprocess.run(["lake", "build"], cwd=tmp_project_dir, check=True, stdout=stdout, stderr=stderr)
+                except subprocess.CalledProcessError as e:
+                    logger.error("Failed during Lean project setup: %s", e)
+                    # delete the project directory to avoid conflicts
+                    shutil.rmtree(tmp_project_dir, ignore_errors=True)
+                    raise
 
     def _get_hash_content(self, lean_version: str) -> str:
         """Return a unique hash for the project content."""
@@ -159,7 +189,7 @@ class TemporaryProject(BaseTempProject):
 
     def _modify_lakefile(self, project_dir: str, lean_version: str) -> None:
         """Write the content to the lakefile."""
-        with open(os.path.join(project_dir, "lakefile.lean"), "w") as f:
+        with open(os.path.join(project_dir, "lakefile.lean"), "w", encoding="utf-8") as f:
             f.write(self.content)
 
 
@@ -173,15 +203,26 @@ class TempRequireProject(BaseTempProject):
     [MiniF2F](https://github.com/yangky11/miniF2F-lean4)) without having to manually set up a Lean project.
     """
 
-    require: Literal["mathlib"] | list[LeanRequire]
+    require: Literal["mathlib"] | LeanRequire | list[LeanRequire | Literal["mathlib"]]
 
     def _normalize_require(self, lean_version: str) -> list[LeanRequire]:
         """Normalize the require field to always be a list."""
         require = self.require
-        if require == "mathlib":
-            return [LeanRequire("mathlib", "https://github.com/leanprover-community/mathlib4.git", lean_version)]
-        assert isinstance(require, list)
-        return sorted(require, key=lambda x: x.name)
+        if not isinstance(require, list):
+            require = [require]
+
+        normalized_require: list[LeanRequire] = []
+        for req in require:
+            if req == "mathlib":
+                normalized_require.append(
+                    LeanRequire("mathlib", "https://github.com/leanprover-community/mathlib4.git", lean_version)
+                )
+            elif isinstance(req, LeanRequire):
+                normalized_require.append(req)
+            else:
+                raise ValueError(f"Invalid requirement type: {type(req)}")
+
+        return sorted(normalized_require, key=lambda x: x.name)
 
     def _get_hash_content(self, lean_version: str) -> str:
         """Return a unique hash based on dependencies."""
@@ -191,7 +232,7 @@ class TempRequireProject(BaseTempProject):
     def _modify_lakefile(self, project_dir: str, lean_version: str) -> None:
         """Add requirements to the lakefile."""
         require = self._normalize_require(lean_version)
-        with open(os.path.join(project_dir, "lakefile.lean"), "a") as f:
+        with open(os.path.join(project_dir, "lakefile.lean"), "a", encoding="utf-8") as f:
             for req in require:
                 f.write(f'\n\nrequire {req.name} from git\n  "{req.git}"' + (f' @ "{req.rev}"' if req.rev else ""))
 
@@ -208,16 +249,18 @@ class LeanREPLConfig:
         verbose: bool = False,
     ):
         """
-        Configuration class used to specify the Lean environment we wish to use.
+        Initialize the Lean REPL configuration.
 
         Args:
-            lean_version: Lean version you want to use with the REPL.
-                If `None`, `LeanREPLConfig` will try to infer `lean_version` from `project`, otherwise
-                the latest version available in the Lean REPL repository will be used.
-            project: Source configuration for the Lean project. Use one of:
-                - `LocalProject`: A directory where a local Lean project is stored.
-                - `GitProject`: A git repository with a Lean project.
-                - `TemporaryProject`: A temporary Lean project with a custom lakefile that will be created.
+            lean_version:
+                The Lean version you want to use.
+                Default is `None`, which means the latest version compatible with the project will be selected.
+            project:
+                The project you want to use. There are 4 options:
+                - `None`: The project will only depend on Lean and its standard library.
+                - `LocalProject`: An existing local Lean project.
+                - `GitProject`: A git repository with a Lean project that will be cloned.
+                - `TemporaryProject`: A temporary Lean project with a custom lakefile.lean that will be created.
                 - `TempRequireProject`: A temporary Lean project with dependencies that will be created.
             repl_rev:
                 The REPL version you want to use. It is not recommended to change this value unless you know what you are doing.
@@ -228,6 +271,7 @@ class LeanREPLConfig:
                 Default is inside the package directory.
             memory_hard_limit_mb:
                 The maximum memory usage in MB for the Lean server. Setting this value too low may lead to more command processing failures.
+                Only available on Linux platforms.
                 Default is `None`, which means no limit.
             verbose:
                 Whether to print additional information during the setup process.
@@ -236,14 +280,21 @@ class LeanREPLConfig:
         self.project = project
         self.repl_git = repl_git
         self.repl_rev = repl_rev
-        self.cache_dir = cache_dir
+        self.cache_dir = os.path.normpath(cache_dir)
         self.memory_hard_limit_mb = memory_hard_limit_mb
 
         self.verbose = verbose
         self._stdout = None if self.verbose else subprocess.DEVNULL
         self._stderr = None if self.verbose else subprocess.DEVNULL
 
-        self.repo_name = "/".join(self.repl_git.split("/")[-2:]).replace(".git", "")
+        repo_parts = self.repl_git.split("/")
+        if len(repo_parts) >= 2:
+            owner = repo_parts[-2]
+            repo = repo_parts[-1].replace(".git", "")
+            self.repo_name = os.path.join(owner, repo)
+        else:
+            self.repo_name = self.repl_git.replace(".git", "")
+
         self.cache_clean_repl_dir = os.path.join(self.cache_dir, self.repo_name, "repl_clean_copy")
 
         # check if lake is installed
@@ -322,10 +373,13 @@ class LeanREPLConfig:
                 f"Please open an issue on GitHub if you think this is a bug."
             )
 
-            # build the repl
-            subprocess.run(
-                ["lake", "build"], cwd=self._cache_repl_dir, check=True, stdout=self._stdout, stderr=self._stderr
-            )
+            try:
+                subprocess.run(
+                    ["lake", "build"], cwd=self._cache_repl_dir, check=True, stdout=self._stdout, stderr=self._stderr
+                )
+            except subprocess.CalledProcessError as e:
+                logger.error("Failed to build the REPL: %s", e)
+                raise
 
     def _get_available_lean_versions_sha(self) -> list[tuple[str, str]]:
         """
@@ -344,5 +398,15 @@ class LeanREPLConfig:
         """
         return [commit[0] for commit in self._get_available_lean_versions_sha()]
 
+    @property
+    def working_dir(self) -> str:
+        """Get the working directory for the Lean environment."""
+        return self._working_dir
+
+    @property
+    def cache_repl_dir(self) -> str:
+        """Get the cache directory for the Lean REPL."""
+        return self._cache_repl_dir
+
     def is_setup(self) -> bool:
         return hasattr(self, "_working_dir")

{lean_interact-0.4.1 → lean_interact-0.5.1}/src/lean_interact/interface.py

@@ -254,7 +254,7 @@ class CommandResponse(BaseREPLResponse):
 
     env: int
     tactics: list[Tactic] = Field(default_factory=list)
-    infotree: dict | None = None
+    infotree: list | None = None
 
 
 class ProofStepResponse(BaseREPLResponse):