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

{lean_interact-0.4.0 → lean_interact-0.4.1}/.github/workflows/ci.yml

@@ -9,12 +9,6 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v3
 
-      - name: Install elan
-        run: |
-          set -o pipefail
-          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
         uses: actions/setup-python@v4
         with:
@@ -24,6 +18,8 @@ jobs:
         run: |
           pip install --upgrade pip
           pip install .
+          install-lean
+          echo "$HOME/.elan/bin" >> $GITHUB_PATH
 
       - name: Run tests
         run: python -m unittest discover -s ./tests

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-interact
-Version: 0.4.0
+Version: 0.4.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
@@ -27,6 +27,7 @@ License: MIT License
 License-File: LICENSE
 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
@@ -97,11 +98,11 @@ Requirements:
 
 ## Script examples
 
-In the `examples` directory, you will find a few scripts demonstrating how to use LeanInteract.
+In the [`examples`](examples) directory, you will find a few scripts demonstrating how to use LeanInteract.
 
-- `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 on [MiniF2F](https://github.com/yangky11/miniF2F-lean4) and [ProofNet#](https://huggingface.co/datasets/PAug/ProofNetSharp) benchmarks.
-- `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 using environment states.
+- [`proof_generation_and_autoformalization.py`](examples/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 on [MiniF2F](https://github.com/yangky11/miniF2F-lean4) and [ProofNet#](https://huggingface.co/datasets/PAug/ProofNetSharp) benchmarks.
+- [`beq_plus.py`](examples/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`](examples/type_check.py): optimize type checking using environment states.
 
 ## Usage
 
@@ -334,7 +335,7 @@ CommandResponse(
 
 #### Fine-grained temporary project
 
-For more control over the temporary project, you can use `TemporaryProject` to specify the content of the lakefile.
+For more control over the temporary project, you can use `TemporaryProject` to specify the content of the lakefile (`.lean` format).
 
 ```python
 from lean_interact import TemporaryProject
@@ -392,7 +393,7 @@ response = server.run(FileCommand(path="myfile.lean", root_goals=True))
 
 ### ProofStep
 
-Work with proof tactics step by step:
+Work with proofs step by step using tactics:
 
 ```python
 from lean_interact import ProofStep
@@ -401,7 +402,7 @@ from lean_interact import ProofStep
 response = server.run(ProofStep(proof_state=0, tactic="intro h"))
 
 # Apply multiple tactics at once
-response = server.run(ProofStep(proof_state=0, tactic="intro h\nexact h"))
+response = server.run(ProofStep(proof_state=0, tactic="(\nintro h\nexact h)"))
 ```
 
 ### Environment Pickling
@@ -489,15 +490,13 @@ Contributions are welcome! Here's how you can help:
 4. Push to the branch: `git push origin feature-name`
 5. Submit a pull request
 
-Please ensure your code includes appropriate tests.
-
 ## Citation
 
 If you use LeanInteract in your research, please cite it as follows:
 
 ```bibtex
 @software{leaninteract,
-  author = {Poiroux, Auguste},
+  author = {Poiroux, Auguste and Kuncak, Viktor and Bosselut, Antoine},
   title = {LeanInteract: A Python Interface for Lean 4},
   url = {https://github.com/augustepoiroux/lean-interact},
   year = {2025}

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

@@ -60,11 +60,11 @@ Requirements:
 
 ## Script examples
 
-In the `examples` directory, you will find a few scripts demonstrating how to use LeanInteract.
+In the [`examples`](examples) directory, you will find a few scripts demonstrating how to use LeanInteract.
 
-- `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 on [MiniF2F](https://github.com/yangky11/miniF2F-lean4) and [ProofNet#](https://huggingface.co/datasets/PAug/ProofNetSharp) benchmarks.
-- `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 using environment states.
+- [`proof_generation_and_autoformalization.py`](examples/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 on [MiniF2F](https://github.com/yangky11/miniF2F-lean4) and [ProofNet#](https://huggingface.co/datasets/PAug/ProofNetSharp) benchmarks.
+- [`beq_plus.py`](examples/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`](examples/type_check.py): optimize type checking using environment states.
 
 ## Usage
 
@@ -297,7 +297,7 @@ CommandResponse(
 
 #### Fine-grained temporary project
 
-For more control over the temporary project, you can use `TemporaryProject` to specify the content of the lakefile.
+For more control over the temporary project, you can use `TemporaryProject` to specify the content of the lakefile (`.lean` format).
 
 ```python
 from lean_interact import TemporaryProject
@@ -355,7 +355,7 @@ response = server.run(FileCommand(path="myfile.lean", root_goals=True))
 
 ### ProofStep
 
-Work with proof tactics step by step:
+Work with proofs step by step using tactics:
 
 ```python
 from lean_interact import ProofStep
@@ -364,7 +364,7 @@ from lean_interact import ProofStep
 response = server.run(ProofStep(proof_state=0, tactic="intro h"))
 
 # Apply multiple tactics at once
-response = server.run(ProofStep(proof_state=0, tactic="intro h\nexact h"))
+response = server.run(ProofStep(proof_state=0, tactic="(\nintro h\nexact h)"))
 ```
 
 ### Environment Pickling
@@ -452,15 +452,13 @@ Contributions are welcome! Here's how you can help:
 4. Push to the branch: `git push origin feature-name`
 5. Submit a pull request
 
-Please ensure your code includes appropriate tests.
-
 ## Citation
 
 If you use LeanInteract in your research, please cite it as follows:
 
 ```bibtex
 @software{leaninteract,
-  author = {Poiroux, Auguste},
+  author = {Poiroux, Auguste and Kuncak, Viktor and Bosselut, Antoine},
   title = {LeanInteract: A Python Interface for Lean 4},
   url = {https://github.com/augustepoiroux/lean-interact},
   year = {2025}

{lean_interact-0.4.0 → lean_interact-0.4.1}/examples/proof_generation_and_autoformalization.py

@@ -97,7 +97,7 @@ def load_proofnetsharp_dataset(split: Literal["valid", "test"] = "valid") -> lis
 
 def check_context_proofs(args: tuple[int, LeanREPLConfig, int, tuple[str, str, list[str]]]) -> tuple[int, str | None]:
     """
-    Filter function to check if at least one proof is valid for a given context and formalization.
+    Filter function to check if at least one proof is valid for a given context and declaration to prove.
     """
     idx, repl_config, timeout_per_proof, context_proofs = args
     context_code, formalization_code, proofs = context_proofs

{lean_interact-0.4.0 → lean_interact-0.4.1}/examples/type_check.py

@@ -9,7 +9,7 @@
 # ///
 """
 This module provides functions to type-check Lean formalizations
-using sequential, parallel, and optimized batch methods.
+using sequential and optimized batch methods.
 """
 
 import json

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

@@ -1,6 +1,6 @@
 [project]
 name = "lean-interact"
-version = "0.4.0"
+version = "0.4.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" }
@@ -8,6 +8,7 @@ readme = "README.md"
 authors = [{ name = "Auguste Poiroux", email = "auguste.poiroux@epfl.ch" }]
 requires-python = ">=3.10"
 dependencies = [
+    "filelock>=3.18.0",
     "gitpython>=3.1.44",
     "pexpect>=4.9.0",
     "psutil>=6.1.0",

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

@@ -5,6 +5,7 @@ import subprocess
 from dataclasses import dataclass
 from typing import Literal
 
+from filelock import FileLock
 from git import GitCommandError, Repo
 
 from lean_interact.utils import (
@@ -55,8 +56,10 @@ class LocalProject(BaseProject):
         """Instantiate the local project."""
         stdout = None if verbose else subprocess.DEVNULL
         stderr = None if verbose else subprocess.DEVNULL
-        # check that the project is buildable
-        subprocess.run(["lake", "build"], cwd=self.directory, check=True, stdout=stdout, stderr=stderr)
+
+        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)
 
 
 @dataclass(frozen=True)
@@ -77,18 +80,19 @@ class GitProject(BaseProject):
 
         project_dir = self._get_directory(cache_dir)
 
-        # check if the git repository is already cloned
-        repo = Repo(project_dir) if os.path.exists(project_dir) else Repo.clone_from(self.url, project_dir)
+        with FileLock(f"{project_dir}.lock"):
+            # check if the git repository is already cloned
+            repo = Repo(project_dir) if os.path.exists(project_dir) else Repo.clone_from(self.url, project_dir)
 
-        if self.rev:
-            repo.git.checkout(self.rev)
-        else:
-            repo.git.pull()
+            if self.rev:
+                repo.git.checkout(self.rev)
+            else:
+                repo.git.pull()
 
-        repo.submodule_update(init=True, recursive=True)
+            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)
+            # check that the project is buildable
+            subprocess.run(["lake", "build"], cwd=project_dir, check=True, stdout=stdout, stderr=stderr)
 
 
 @dataclass(frozen=True)
@@ -111,26 +115,28 @@ class BaseTempProject(BaseProject):
 
         tmp_project_dir = self._get_directory(cache_dir, lean_version)
 
-        # check if the Lean project is already built
-        if not os.path.exists(os.path.join(tmp_project_dir, "lakefile.lean")):
-            # 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)
-
-            # initialize the Lean project
-            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)
-
-            # 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)
+        # 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")):
+                # 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)
+
+                # initialize the Lean project
+                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)
+
+                # 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)
 
     def _get_hash_content(self, lean_version: str) -> str:
         """Return a unique hash for the project content."""
@@ -263,62 +269,63 @@ class LeanREPLConfig:
     def _setup_repl(self) -> None:
         assert isinstance(self.repl_rev, str)
 
-        # check if the repl is already cloned
-        if not os.path.exists(self.cache_clean_repl_dir):
-            os.makedirs(self.cache_clean_repl_dir, exist_ok=True)
-            Repo.clone_from(self.repl_git, self.cache_clean_repl_dir)
+        # Lock the clean REPL directory during setup to prevent race conditions
+        with FileLock(f"{self.cache_clean_repl_dir}.lock", timeout=300):
+            # check if the repl is already cloned
+            if not os.path.exists(self.cache_clean_repl_dir):
+                os.makedirs(self.cache_clean_repl_dir, exist_ok=True)
+                Repo.clone_from(self.repl_git, self.cache_clean_repl_dir)
 
-        repo = Repo(self.cache_clean_repl_dir)
-        try:
-            repo.git.checkout(self.repl_rev)
-        except GitCommandError:
-            repo.remote().pull()
+            repo = Repo(self.cache_clean_repl_dir)
             try:
                 repo.git.checkout(self.repl_rev)
-            except GitCommandError as e:
-                raise ValueError(f"Lean REPL version `{self.repl_rev}` is not available.") from e
-
-        # check if the Lean version is available in the repository
-        lean_versions_sha = self._get_available_lean_versions_sha()
-        lean_versions_sha_dict = dict(lean_versions_sha)
-        if not lean_versions_sha:
-            raise ValueError("No Lean versions are available in the Lean REPL repository.")
-        if self.lean_version is None:
-            if (
-                self.project is None
-                or isinstance(self.project, TemporaryProject)
-                or isinstance(self.project, TempRequireProject)
-            ):
-                self.lean_version = lean_versions_sha[-1][0]
-            elif isinstance(self.project, LocalProject) or isinstance(self.project, GitProject):
-                # get the Lean version from the project
-                inferred_ver = get_project_lean_version(self.project._get_directory(self.cache_dir))
-                self.lean_version = inferred_ver if inferred_ver else lean_versions_sha[-1][0]
-        if self.lean_version not in lean_versions_sha_dict:
-            raise ValueError(
-                f"Lean version `{self.lean_version}` is required but not available in the Lean REPL repository."
-            )
+            except GitCommandError:
+                repo.remote().pull()
+                try:
+                    repo.git.checkout(self.repl_rev)
+                except GitCommandError as e:
+                    raise ValueError(f"Lean REPL version `{self.repl_rev}` is not available.") from e
+
+            # check if the Lean version is available in the repository
+            lean_versions_sha = self._get_available_lean_versions_sha()
+            lean_versions_sha_dict = dict(lean_versions_sha)
+            if not lean_versions_sha:
+                raise ValueError("No Lean versions are available in the Lean REPL repository.")
+            if self.lean_version is None:
+                if self.project is None or isinstance(self.project, (TemporaryProject, TempRequireProject)):
+                    self.lean_version = lean_versions_sha[-1][0]
+                elif isinstance(self.project, (LocalProject, GitProject)):
+                    # get the Lean version from the project
+                    inferred_ver = get_project_lean_version(self.project._get_directory(self.cache_dir))
+                    self.lean_version = inferred_ver if inferred_ver else lean_versions_sha[-1][0]
+            if self.lean_version not in lean_versions_sha_dict:
+                raise ValueError(
+                    f"Lean version `{self.lean_version}` is required but not available in the Lean REPL repository."
+                )
 
         # check if the repl revision is already in the cache
         self._cache_repl_dir = os.path.join(self.cache_dir, self.repo_name, f"repl_{self.repl_rev}_{self.lean_version}")
-        if not os.path.exists(self._cache_repl_dir):
-            # copy the repository to the version directory and checkout the required revision
-            os.makedirs(self._cache_repl_dir, exist_ok=True)
-            shutil.copytree(self.cache_clean_repl_dir, self._cache_repl_dir, dirs_exist_ok=True)
-            cached_repo = Repo(self._cache_repl_dir)
-            cached_repo.git.checkout(lean_versions_sha_dict[self.lean_version])
-
-        # check that the lean version is correct
-        assert self.lean_version == get_project_lean_version(self._cache_repl_dir), (
-            f"An error occured while preparing the Lean REPL. The requested Lean version `{self.lean_version}` "
-            f"does not match the fetched Lean version in the repository `{get_project_lean_version(self._cache_repl_dir)}`."
-            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
-        )
+
+        # Lock the version-specific REPL directory during setup
+        with FileLock(f"{self._cache_repl_dir}.lock", timeout=300):  # 5 minute timeout for long-running operations
+            if not os.path.exists(self._cache_repl_dir):
+                # copy the repository to the version directory and checkout the required revision
+                os.makedirs(self._cache_repl_dir, exist_ok=True)
+                shutil.copytree(self.cache_clean_repl_dir, self._cache_repl_dir, dirs_exist_ok=True)
+                cached_repo = Repo(self._cache_repl_dir)
+                cached_repo.git.checkout(lean_versions_sha_dict[self.lean_version])
+
+            # check that the lean version is correct
+            assert self.lean_version == get_project_lean_version(self._cache_repl_dir), (
+                f"An error occured while preparing the Lean REPL. The requested Lean version `{self.lean_version}` "
+                f"does not match the fetched Lean version in the repository `{get_project_lean_version(self._cache_repl_dir)}`."
+                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
+            )
 
     def _get_available_lean_versions_sha(self) -> list[tuple[str, str]]:
         """

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

@@ -67,7 +67,7 @@ class FileCommand(BaseREPLQuery, CommandOptions):
     path: Annotated[str, Field(min_length=1)]
 
 
-class ProofStep(BaseREPLQuery, REPLBaseModel):
+class ProofStep(BaseREPLQuery):
     """Proof step in the REPL.
     Attributes:
         proof_state: The proof state to start from.
@@ -161,8 +161,8 @@ class Sorry(REPLBaseModel):
         proof_state: The proof state associated to the sorry.
     """
 
-    start_pos: Annotated[Pos, Field(alias="pos")]
-    end_pos: Annotated[Pos, Field(alias="endPos")]
+    start_pos: Annotated[Pos | None, Field(alias="pos")] = None
+    end_pos: Annotated[Pos | None, Field(alias="endPos")] = None
     goal: str
     proof_state: Annotated[int | None, Field(alias="proofState")] = None
 

{lean_interact-0.4.0 → lean_interact-0.4.1}/src/lean_interact/server.py

@@ -9,6 +9,7 @@ from typing import overload
 
 import pexpect
 import psutil
+from filelock import FileLock
 
 from lean_interact.config import LeanREPLConfig
 from lean_interact.interface import (
@@ -132,10 +133,10 @@ class LeanServer:
             self.kill()
             raise ConnectionAbortedError(
                 "The Lean server closed unexpectedly. Possible reasons (not exhaustive):\n"
-                "- An uncaught exception in the Lean REPL (for example, an unexistent file has been requested)\n"
+                "- An uncaught exception in the Lean REPL (for example, an inexistent file has been requested)\n"
                 "- Not enough memory and/or compute available\n"
                 "- The cached Lean REPL is corrupted. In this case, clear the cache"
-                " using the `clear_cache` (`from pyleanrepl import clear_cache`) method."
+                " using the `clear-lean-cache` command."
             ) from e
 
         return self._parse_repl_output(raw_output, verbose)
@@ -260,28 +261,31 @@ class AutoLeanServer(LeanServer):
         Reload the session cache. This method should be called only after a restart of the Lean REPL.
         """
         for state_data in self._restart_persistent_session_cache.values():
-            if state_data.is_proof_state:
-                cmd = UnpickleProofState(unpickle_proof_state_from=state_data.pickle_file, env=state_data.repl_id)
-            else:
-                cmd = UnpickleEnvironment(unpickle_env_from=state_data.pickle_file)
-            result = self.run(
-                cmd,
-                verbose=verbose,
-                timeout=DEFAULT_TIMEOUT,
-                add_to_session_cache=False,
-            )
-            if isinstance(result, LeanError):
-                raise ValueError(
-                    f"Could not reload the session cache. The Lean server returned an error: {result.message}"
-                )
-            elif isinstance(result, CommandResponse):
-                state_data.repl_id = result.env
-            elif isinstance(result, ProofStepResponse):
-                state_data.repl_id = result.proof_state
-            else:
-                raise ValueError(
-                    f"Could not reload the session cache. The Lean server returned an unexpected response: {result}"
+            # Use file lock when accessing the pickle file to prevent cache invalidation
+            # from multiple concurrent processes
+            with FileLock(f"{state_data.pickle_file}.lock", timeout=60):
+                if state_data.is_proof_state:
+                    cmd = UnpickleProofState(unpickle_proof_state_from=state_data.pickle_file, env=state_data.repl_id)
+                else:
+                    cmd = UnpickleEnvironment(unpickle_env_from=state_data.pickle_file)
+                result = self.run(
+                    cmd,
+                    verbose=verbose,
+                    timeout=DEFAULT_TIMEOUT,
+                    add_to_session_cache=False,
                 )
+                if isinstance(result, LeanError):
+                    raise ValueError(
+                        f"Could not reload the session cache. The Lean server returned an error: {result.message}"
+                    )
+                elif isinstance(result, CommandResponse):
+                    state_data.repl_id = result.env
+                elif isinstance(result, ProofStepResponse):
+                    state_data.repl_id = result.proof_state
+                else:
+                    raise ValueError(
+                        f"Could not reload the session cache. The Lean server returned an unexpected response: {result}"
+                    )
 
     def restart(self, verbose: bool = False) -> None:
         super().restart()
@@ -295,7 +299,10 @@ class AutoLeanServer(LeanServer):
             env_id: The environment id to remove.
         """
         if (state_cache := self._restart_persistent_session_cache.pop(session_state_id, None)) is not None:
-            os.remove(state_cache.pickle_file)
+            pickle_file = state_cache.pickle_file
+            with FileLock(f"{pickle_file}.lock", timeout=60):
+                if os.path.exists(pickle_file):
+                    os.remove(pickle_file)
 
     def clear_session_cache(self, force: bool = False) -> None:
         """
@@ -338,18 +345,22 @@ class AutoLeanServer(LeanServer):
         else:
             request = PickleEnvironment(env=repl_id, pickle_to=pickle_file)
 
-        result = self.run(request, verbose=verbose, timeout=DEFAULT_TIMEOUT)
-        if isinstance(result, LeanError):
-            raise ValueError(
-                f"Could not store the result in the session cache. The Lean server returned an error: {result.message}"
+        # Use file lock when accessing the pickle file to prevent cache invalidation
+        # from multiple concurrent processes
+        with FileLock(f"{pickle_file}.lock", timeout=60):
+            result = self.run(request, verbose=verbose, timeout=DEFAULT_TIMEOUT)
+            if isinstance(result, LeanError):
+                raise ValueError(
+                    f"Could not store the result in the session cache. The Lean server returned an error: {result.message}"
+                )
+
+            self._restart_persistent_session_cache[self._state_counter] = _SessionState(
+                session_id=self._state_counter,
+                repl_id=repl_id,
+                pickle_file=pickle_file,
+                is_proof_state=is_proof_state,
             )
 
-        self._restart_persistent_session_cache[self._state_counter] = _SessionState(
-            session_id=self._state_counter,
-            repl_id=repl_id,
-            pickle_file=pickle_file,
-            is_proof_state=is_proof_state,
-        )
         return self._state_counter
 
     def _run_dict_backoff(self, request: dict, verbose: bool, timeout: float | None, restart_counter: int = 0) -> dict:

lean_interact-0.4.1/tests/test_concurrency.py

@@ -0,0 +1,163 @@
+import multiprocessing as mp
+import os
+import shutil
+import tempfile
+import time
+import unittest
+from unittest import mock
+
+from filelock import FileLock, Timeout
+
+from lean_interact import AutoLeanServer, LeanREPLConfig
+from lean_interact.config import BaseTempProject
+from lean_interact.interface import Command, CommandResponse
+from lean_interact.utils import DEFAULT_REPL_GIT_URL
+
+
+# Helper function for testing config creation in a separate process
+def create_config_process(cache_dir, lean_version="v4.18.0", verbose=False):
+    """Function that attempts to create a LeanREPLConfig instance."""
+    try:
+        # This should timeout if another process is already holding the lock
+        LeanREPLConfig(lean_version=lean_version, cache_dir=str(cache_dir), verbose=verbose)
+        return True
+    except Exception:
+        return False
+
+
+# Function to access/modify a cache file with locking
+def access_cache_file(file_path, process_id, timeout=1):
+    """Function to simulate a process accessing and modifying a cache file."""
+    try:
+        lock_path = f"{file_path}.lock"
+        with FileLock(lock_path, timeout=timeout):
+            # Read the file
+            try:
+                with open(file_path, "r", encoding="utf-8") as f:
+                    content = f.read()
+
+                # Modify the file (simulate updating cache)
+                with open(file_path, "w", encoding="utf-8") as f:
+                    f.write(f"{content} - Modified by process {process_id}")
+                time.sleep(timeout)
+                return True
+            except Exception as e:
+                print(f"Error in access_cache_file: {e}")
+                return False
+    except Timeout:
+        return False
+
+
+class TestFileLocks(unittest.TestCase):
+    """Tests for file locking functionality."""
+
+    def setUp(self):
+        self.temp_dir = tempfile.mkdtemp()
+
+    def tearDown(self):
+        # Clean up temporary directory
+        if os.path.exists(self.temp_dir):
+            shutil.rmtree(self.temp_dir)
+
+    def test_config_repl_setup_lock(self):
+        """Test that the REPL setup lock prevents concurrent access."""
+        # Create a temporary cache directory
+        cache_dir = os.path.join(self.temp_dir, "cache")
+        os.makedirs(cache_dir, exist_ok=True)
+
+        # Prepare the lock file path that would be used by LeanREPLConfig
+        repo_name = "/".join(DEFAULT_REPL_GIT_URL.split("/")[-2:]).replace(".git", "")
+        cache_clean_repl_dir = os.path.join(cache_dir, repo_name, "repl_clean_copy")
+        os.makedirs(os.path.dirname(cache_clean_repl_dir), exist_ok=True)
+        lock_file = f"{cache_clean_repl_dir}.lock"
+
+        # Acquire the lock that would be used by LeanREPLConfig
+        with FileLock(lock_file, timeout=0.1):
+            # Start a process that tries to create a LeanREPLConfig, which should try to acquire the same lock
+            ctx = mp.get_context("spawn")
+
+            p = ctx.Process(target=create_config_process, args=(cache_dir,))
+            p.start()
+            p.join(timeout=30)
+
+            # The process should have exited with a timeout exception
+            self.assertNotEqual(p.exitcode, 0, "Process should have failed to acquire the lock")
+
+    def test_temporary_project_lock(self):
+        """Test that the temporary project lock prevents concurrent access."""
+
+        # Create a temp project instance with a simple hash
+        class SimpleTestProject(BaseTempProject):
+            def _get_hash_content(self, lean_version: str) -> str:
+                """Return a fixed hash."""
+                return "test_hash"
+
+            def _modify_lakefile(self, project_dir: str, lean_version: str) -> None:
+                """Do nothing."""
+                pass
+
+        test_project = SimpleTestProject()
+
+        # Get the project directory and lock path
+        cache_dir = os.path.join(self.temp_dir, "cache")
+        os.makedirs(cache_dir, exist_ok=True)
+        project_dir = test_project._get_directory(str(cache_dir), "v4.18.0")
+        lock_file = f"{project_dir}.lock"
+
+        # Hold the lock to simulate another process using it
+        with FileLock(lock_file, timeout=0.1):
+            # Try to instantiate the project which should try to acquire the same lock
+            with self.assertRaises(Exception):
+                # Use a short timeout to avoid test hanging
+                with mock.patch("lean_interact.config.FileLock", return_value=FileLock(lock_file, timeout=0.1)):
+                    test_project._instantiate(str(cache_dir), "v4.18.0", verbose=False)
+
+
+def _worker(idx, result_queue, config):
+    try:
+        # Each process gets its own server instance
+        server = AutoLeanServer(config)
+        # Each process runs a simple Lean command
+        cmd = Command(cmd=f"def x{idx} := {idx}")
+        result = server.run(cmd)
+        # Return result type and env id
+        if isinstance(result, CommandResponse):
+            result_queue.put((idx, True, result.env))
+        else:
+            result_queue.put((idx, False, str(result)))
+    except Exception as e:
+        result_queue.put((idx, False, str(e)))
+
+
+class TestAutoLeanServerConcurrency(unittest.TestCase):
+    """Realistic concurrent use-cases for AutoLeanServer and LeanREPLConfig (no mocks)."""
+
+    @classmethod
+    def setUpClass(cls):
+        # Use a dedicated cache dir for concurrency tests
+        cls.cache_dir = tempfile.mkdtemp(prefix="lean_concurrency_cache_")
+        # Pre-instantiate config to avoid race in REPL setup
+        cls.config = LeanREPLConfig(cache_dir=cls.cache_dir, verbose=True)
+
+    @classmethod
+    def tearDownClass(cls):
+        shutil.rmtree(cls.cache_dir, ignore_errors=True)
+
+    def test_concurrent_autoleanserver(self):
+        """Test concurrent use of AutoLeanServer."""
+        num_proc = 4
+        ctx = mp.get_context("spawn")
+        result_queue = ctx.Queue()
+        procs = [ctx.Process(target=_worker, args=(i, result_queue, self.config)) for i in range(num_proc)]
+        for p in procs:
+            p.start()
+        for p in procs:
+            p.join(timeout=60)
+        results = [result_queue.get(timeout=5) for _ in range(num_proc)]
+        self.assertTrue(all(success for (_, success, _) in results), f"Failures: {results}")
+        env_ids = [env for (_, _, env) in results]
+        self.assertEqual(len(env_ids), num_proc)
+
+
+if __name__ == "__main__":
+    unittest.main()

{lean_interact-0.4.0 → lean_interact-0.4.1}/tests/test_server.py

@@ -433,6 +433,7 @@ class TestLeanServer(unittest.TestCase):
         # Get initial memory usage
         assert server._proc is not None
         server_process = psutil.Process(server._proc.pid)
+        time.sleep(1)  # Give the process time to start
         start_mem = server_process.memory_info().rss / (1024 * 1024)  # Convert to MB
 
         # Run code in separate thread to allow memory monitoring
@@ -462,12 +463,15 @@ class TestLeanServer(unittest.TestCase):
         # Monitor memory usage
         max_mem = start_mem
         while thread.is_alive():
-            current_mem = server_process.memory_info().rss / (1024 * 1024)
-            max_mem = max(max_mem, current_mem)
-            if current_mem > mem_limit:
-                server.kill()
-                raise MemoryError(f"Memory usage exceeded limit: {current_mem:.1f}MB > {mem_limit}MB")
-            time.sleep(1)
+            try:
+                current_mem = server_process.memory_info().rss / (1024 * 1024)
+                max_mem = max(max_mem, current_mem)
+                if current_mem > mem_limit:
+                    server.kill()
+                    raise MemoryError(f"Memory usage exceeded limit: {current_mem:.1f}MB > {mem_limit}MB")
+                time.sleep(1)
+            except psutil.NoSuchProcess:
+                break
 
         # Get result
         status, result = result_queue.get()

{lean_interact-0.4.0 → lean_interact-0.4.1}/uv.lock

@@ -228,6 +228,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/7b/8f/c4d9bafc34ad7ad5d8dc16dd1347ee0e507a52c3adb6bfa8887e1c6a26ba/executing-2.2.0-py2.py3-none-any.whl", hash = "sha256:11387150cad388d62750327a53d3339fad4888b39a6fe233c3afbb54ecffd3aa", size = 26702 },
 ]
 
+[[package]]
+name = "filelock"
+version = "3.18.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0a/10/c23352565a6544bdc5353e0b15fc1c563352101f30e24bf500207a54df9a/filelock-3.18.0.tar.gz", hash = "sha256:adbc88eabb99d2fec8c9c1b229b171f18afa655400173ddc653d5d01501fb9f2", size = 18075 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4d/36/2a115987e2d8c300a974597416d9de88f2444426de9571f4b59b2cca3acc/filelock-3.18.0-py3-none-any.whl", hash = "sha256:c401f4f8377c4464e6db25fff06205fd89bdd83b65eb0488ed1b160f780e21de", size = 16215 },
+]
+
 [[package]]
 name = "gitdb"
 version = "4.0.12"
@@ -351,9 +360,10 @@ wheels = [
 
 [[package]]
 name = "lean-interact"
-version = "0.3.2"
+version = "0.4.0"
 source = { editable = "." }
 dependencies = [
+    { name = "filelock" },
     { name = "gitpython" },
     { name = "pexpect" },
     { name = "psutil" },
@@ -369,6 +379,7 @@ dev = [
 
 [package.metadata]
 requires-dist = [
+    { name = "filelock", specifier = ">=3.18.0" },
     { name = "gitpython", specifier = ">=3.1.44" },
     { name = "pexpect", specifier = ">=4.9.0" },
     { name = "psutil", specifier = ">=6.1.0" },