lean-runtime 2.0.0__tar.gz → 2.0.2__tar.gz

{lean_runtime-2.0.0 → lean_runtime-2.0.2}/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 2.0.2
+
+- Remove staged environments safely when Git-for-Windows leaves source pack
+  files read-only or briefly locked.
+- Preserve the primary environment-build diagnostic when staging cleanup also
+  fails.
+- Show the failed phase, command, exit code, and captured tool output when a
+  verbose CLI materialization fails.
+
+## 2.0.1
+
+- Enable Git's long-path support for every Runtime-managed source operation so
+  Mathlib environments can be prepared and materialized on Windows.
+- Preserve the primary Git diagnostic when cleanup of a failed Windows source
+  checkout also encounters locked files.
+
 ## 2.0.0
 
 Version 2 gives the public interface the language used by Lean users rather

{lean_runtime-2.0.0/lean_runtime.egg-info → lean_runtime-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-runtime
-Version: 2.0.0
+Version: 2.0.2
 Summary: Run Lean 4 proofs from Python or standalone files
 Author: Alejandro Radisic
 License-Expression: Apache-2.0

lean_runtime-2.0.2/lean_runtime/_git.py

@@ -0,0 +1,13 @@
+"""Internal construction of portable Git commands."""
+
+from __future__ import annotations
+
+
+def git_command(*arguments: str) -> list[str]:
+    """Return a Git command that can materialize Lean's deep source trees.
+
+    ``core.longpaths`` is meaningful on Git for Windows and harmless on other
+    platforms. Supplying it per invocation avoids mutable global Git settings.
+    """
+
+    return ["git", "-c", "core.longpaths=true", *arguments]

lean_runtime-2.0.2/lean_runtime/_paths.py

@@ -0,0 +1,38 @@
+"""Internal cross-platform filesystem operations."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import stat
+import time
+from collections.abc import Callable
+from pathlib import Path
+from types import TracebackType
+from typing import Any
+
+
+def _retry_writable(
+    function: Callable[..., Any],
+    path: str,
+    _error: tuple[type[BaseException], BaseException, TracebackType | None],
+) -> None:
+    """Clear Git-for-Windows read-only attributes and retry one removal."""
+
+    os.chmod(path, stat.S_IWRITE)
+    function(path)
+
+
+def remove_tree(path: Path) -> None:
+    """Remove a tree containing Git packs, tolerating transient Windows locks."""
+
+    for attempt in range(4):
+        try:
+            shutil.rmtree(path, onerror=_retry_writable)
+            return
+        except PermissionError:
+            if not path.exists():
+                return
+            if attempt == 3:
+                raise
+            time.sleep(0.05 * (2**attempt))

{lean_runtime-2.0.0 → lean_runtime-2.0.2}/lean_runtime/bundles.py

@@ -19,6 +19,8 @@ from datetime import datetime, timezone
 from pathlib import Path, PurePosixPath
 from typing import Any
 
+from ._git import git_command
+from ._paths import remove_tree
 from .backends import Backend
 from .errors import EnvironmentError
 from .events import EventEmitter
@@ -281,7 +283,7 @@ def _verify_package(root: Path, package: LockedPackage) -> None:
     observed: list[str] = []
     for revision in ("HEAD", "HEAD^{tree}"):
         result = subprocess.run(
-            ["git", "-C", str(root), "rev-parse", revision],
+            git_command("-C", str(root), "rev-parse", revision),
             text=True,
             capture_output=True,
             check=False,
@@ -292,15 +294,14 @@ def _verify_package(root: Path, package: LockedPackage) -> None:
     if observed != [package.revision.lower(), package.tree_hash.lower()]:
         raise EnvironmentError(f"bundled package source mismatch: {package.name}")
     status = subprocess.run(
-        [
-            "git",
+        git_command(
             "-C",
             str(root),
             "status",
             "--porcelain=v1",
             "--untracked-files=all",
             "--ignored=no",
-        ],
+        ),
         text=True,
         capture_output=True,
         check=False,
@@ -667,7 +668,7 @@ class EnvironmentBundles:
                     stage.replace(destination)
                 finally:
                     if stage.exists():
-                        shutil.rmtree(stage)
+                        remove_tree(stage)
         if name:
             self.store.set_alias(name, environment_id)
         self.events.emit(

{lean_runtime-2.0.0 → lean_runtime-2.0.2}/lean_runtime/cli.py

@@ -50,6 +50,19 @@ def _progress(event: RuntimeEvent) -> None:
     print(f"lean-runtime: {event.kind}{package}: {event.message}", file=sys.stderr)
 
 
+def _print_operation_failure(exc: ResolutionError | MaterializationError, *, verbose: bool) -> None:
+    print(f"lean-runtime: {exc}", file=sys.stderr)
+    if not verbose:
+        return
+    print(f"phase: {exc.phase}", file=sys.stderr)
+    if exc.command:
+        print("command: " + " ".join(exc.command), file=sys.stderr)
+    if exc.exit_code is not None:
+        print(f"exit code: {exc.exit_code}", file=sys.stderr)
+    if exc.output:
+        print(exc.output.rstrip(), file=sys.stderr)
+
+
 def _cli_source_name(path: Path) -> str:
     if path.is_absolute():
         return path.name
@@ -643,7 +656,7 @@ def main(argv: list[str] | None = None) -> int:
                 )
             )
         else:
-            print(f"lean-runtime: {exc}", file=sys.stderr)
+            _print_operation_failure(exc, verbose=args.verbose)
         return 2
     except (LeanRuntimeError, OSError, UnicodeError, ValueError, json.JSONDecodeError) as exc:
         if getattr(args, "json", False):

{lean_runtime-2.0.0 → lean_runtime-2.0.2}/lean_runtime/environments.py

@@ -6,7 +6,6 @@ import asyncio
 import json
 import os
 import re
-import shutil
 import subprocess
 import tempfile
 import threading
@@ -20,6 +19,8 @@ from datetime import datetime, timezone
 from pathlib import Path, PurePosixPath
 from typing import Any, Generic, TextIO, TypeVar, cast
 
+from ._git import git_command
+from ._paths import remove_tree
 from .backends import Backend, BackendResult, InteractiveProcess, InteractiveTextReader
 from .diagnostics import error_diagnostic, parse_diagnostics
 from .errors import EnvironmentError, MaterializationError, PolicyError
@@ -558,7 +559,7 @@ class Environment:
 
         def cleanup() -> None:
             if instance.exists():
-                shutil.rmtree(instance)
+                remove_tree(instance)
             with suppress(OSError):
                 job_parent.rmdir()
 
@@ -846,7 +847,7 @@ class Environment:
             return result
         finally:
             if instance.exists():
-                shutil.rmtree(instance)
+                remove_tree(instance)
             with suppress(OSError):
                 job_parent.rmdir()
 
@@ -1106,7 +1107,10 @@ class EnvironmentManager:
             )
         finally:
             if stage.exists():
-                shutil.rmtree(stage)
+                # Preserve a build/materialization diagnostic if cleanup of
+                # Git's read-only pack files also fails on Windows.
+                with suppress(OSError):
+                    remove_tree(stage)
 
     def _ensure_sources(self, lock: EnvironmentLock) -> None:
         """Acquire exact locked sources without invoking Lake resolution."""
@@ -1138,18 +1142,17 @@ class EnvironmentManager:
             ) as raw:
                 checkout = Path(raw)
                 commands = [
-                    ["git", "init", "-q"],
-                    ["git", "remote", "add", "origin", package.url],
-                    [
-                        "git",
+                    git_command("init", "-q"),
+                    git_command("remote", "add", "origin", package.url),
+                    git_command(
                         "fetch",
                         "--depth",
                         "1",
                         "--filter=blob:none",
                         "origin",
                         package.revision,
-                    ],
-                    ["git", "checkout", "--detach", "FETCH_HEAD"],
+                    ),
+                    git_command("checkout", "--detach", "FETCH_HEAD"),
                 ]
                 for command in commands:
                     completed = subprocess.run(
@@ -1168,7 +1171,7 @@ class EnvironmentManager:
                             output=completed.stdout + completed.stderr,
                         )
                 tree = subprocess.run(
-                    ["git", "rev-parse", "HEAD^{tree}"],
+                    git_command("rev-parse", "HEAD^{tree}"),
                     cwd=checkout,
                     text=True,
                     capture_output=True,

{lean_runtime-2.0.0 → lean_runtime-2.0.2}/lean_runtime/programs.py

@@ -10,7 +10,6 @@ from __future__ import annotations
 import hashlib
 import os
 import re
-import shutil
 import tempfile
 import uuid
 from collections.abc import Mapping, Sequence
@@ -20,6 +19,7 @@ from datetime import datetime, timezone
 from pathlib import Path, PurePosixPath
 from typing import Any, cast
 
+from ._paths import remove_tree
 from .backends import Backend, BackendResult, InteractiveProcess
 from .bundles import (
     INDEX_MEDIA_TYPE,
@@ -238,7 +238,7 @@ class ReadyProgram:
 
         def cleanup() -> None:
             if instance.exists():
-                shutil.rmtree(instance)
+                remove_tree(instance)
             with suppress(OSError):
                 job_parent.rmdir()
 
@@ -347,7 +347,7 @@ class ProgramManager:
                     stage.replace(destination)
                 finally:
                     if stage.exists():
-                        shutil.rmtree(stage)
+                        remove_tree(stage)
         self.events.emit(
             "program.created", "Created executable program", program_id=manifest.program_id
         )
@@ -534,7 +534,7 @@ class ProgramManager:
                     stage.replace(destination)
                 finally:
                     if stage.exists():
-                        shutil.rmtree(stage)
+                        remove_tree(stage)
         return self.open(manifest.program_id)
 
 

{lean_runtime-2.0.0 → lean_runtime-2.0.2}/lean_runtime/projects.py

@@ -13,6 +13,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
+from ._git import git_command
 from .errors import ProjectError
 from .models import ExecutionResult, ProjectProvenance
 from .policies import ExecutionPolicy
@@ -31,7 +32,7 @@ def _file_digest(path: Path) -> str | None:
 
 def _git(root: Path, *arguments: str) -> str | None:
     result = subprocess.run(
-        ["git", "-C", str(root), *arguments],
+        git_command("-C", str(root), *arguments),
         text=True,
         capture_output=True,
         check=False,

{lean_runtime-2.0.0 → lean_runtime-2.0.2}/lean_runtime/references.py

@@ -17,6 +17,7 @@ if sys.version_info >= (3, 11):
 else:  # pragma: no cover - exercised by the Python 3.10 CI job
     import tomli as tomllib
 
+from ._git import git_command
 from .errors import ResolutionError, SpecificationError
 from .specs import GitPackage
 from .toolchains import ToolchainManager, normalize_toolchain
@@ -126,7 +127,7 @@ class DiscoveredPackage:
 def _run_git(arguments: list[str], *, cwd: Path | None = None, timeout: float = 120) -> str:
     try:
         process = subprocess.run(
-            ["git", *arguments],
+            git_command(*arguments),
             cwd=cwd,
             text=True,
             capture_output=True,
@@ -137,7 +138,7 @@ def _run_git(arguments: list[str], *, cwd: Path | None = None, timeout: float =
         raise ResolutionError(
             "package-reference Git operation timed out",
             phase="package-discovery",
-            command=("git", *arguments),
+            command=tuple(git_command(*arguments)),
             exit_code=124,
             output=str(exc.stdout or "") + str(exc.stderr or ""),
         ) from exc
@@ -145,7 +146,7 @@ def _run_git(arguments: list[str], *, cwd: Path | None = None, timeout: float =
         raise ResolutionError(
             "could not acquire package-reference metadata",
             phase="package-discovery",
-            command=("git", *arguments),
+            command=tuple(git_command(*arguments)),
             exit_code=process.returncode,
             output=process.stdout + process.stderr,
         )

{lean_runtime-2.0.0 → lean_runtime-2.0.2}/lean_runtime/resolver.py

@@ -11,6 +11,7 @@ from dataclasses import replace
 from pathlib import Path
 from typing import Any
 
+from ._git import git_command
 from .backends import Backend
 from .errors import ResolutionError
 from .events import EventEmitter
@@ -27,7 +28,7 @@ _COMMIT = re.compile(r"[0-9a-fA-F]{40}")
 
 def _git(path: Path, *arguments: str) -> str:
     process = subprocess.run(
-        ["git", "-C", str(path), *arguments],
+        git_command("-C", str(path), *arguments),
         text=True,
         capture_output=True,
         check=False,
@@ -36,7 +37,7 @@ def _git(path: Path, *arguments: str) -> str:
         raise ResolutionError(
             f"could not inspect resolved Git package at {path}",
             phase="lock-validation",
-            command=("git", "-C", str(path), *arguments),
+            command=tuple(git_command("-C", str(path), *arguments)),
             exit_code=process.returncode,
             output=process.stdout + process.stderr,
         )
@@ -144,7 +145,7 @@ class EnvironmentResolver:
                 pinned.append(package)
                 continue
             reference = f"refs/tags/{package.rev}"
-            command = ["git", "ls-remote", package.url, reference, f"{reference}^{{}}"]
+            command = git_command("ls-remote", package.url, reference, f"{reference}^{{}}")
             process = self.backend.execute(
                 command,
                 cwd=self.store.home,

{lean_runtime-2.0.0 → lean_runtime-2.0.2}/lean_runtime/store.py

@@ -17,6 +17,8 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
+from ._git import git_command
+from ._paths import remove_tree
 from .errors import EnvironmentError
 from .lockfiles import EnvironmentLock
 from .locking import FileLock
@@ -271,7 +273,7 @@ class EnvironmentStore:
         observed = []
         for arguments in commands:
             process = subprocess.run(
-                ["git", "-C", str(source), *arguments],
+                git_command("-C", str(source), *arguments),
                 text=True,
                 capture_output=True,
                 check=False,
@@ -298,8 +300,7 @@ class EnvironmentStore:
             parent.mkdir(parents=True, exist_ok=True)
             stage = parent / f".staging-{os.getpid()}-{uuid.uuid4().hex}"
             try:
-                command = [
-                    "git",
+                command = git_command(
                     "clone",
                     "--quiet",
                     "--no-local",
@@ -308,7 +309,7 @@ class EnvironmentStore:
                     "--no-tags",
                     checkout.resolve().as_uri(),
                     str(stage),
-                ]
+                )
                 process = subprocess.run(
                     command,
                     text=True,
@@ -322,15 +323,14 @@ class EnvironmentStore:
                         + process.stderr
                     )
                 remote = subprocess.run(
-                    [
-                        "git",
+                    git_command(
                         "-C",
                         str(stage),
                         "remote",
                         "set-url",
                         "origin",
                         str(metadata["url"]),
-                    ],
+                    ),
                     text=True,
                     capture_output=True,
                     check=False,
@@ -346,7 +346,10 @@ class EnvironmentStore:
                 stage.replace(destination)
             finally:
                 if stage.exists():
-                    shutil.rmtree(stage)
+                    # Failed Git checkouts can leave locked pack files on
+                    # Windows. Cleanup must not mask the actionable Git error.
+                    with suppress(OSError):
+                        remove_tree(stage)
         return destination
 
     def environment_path(self, environment_id: str) -> Path:
@@ -554,7 +557,7 @@ class EnvironmentStore:
                         ):
                             retained.append(path.name)
                             continue
-                        shutil.rmtree(path)
+                        remove_tree(path)
                         usage.unlink(missing_ok=True)
                         removed.append(path.name)
         return CleanupReport(tuple(candidates), tuple(removed), tuple(retained), dry_run)

{lean_runtime-2.0.0 → lean_runtime-2.0.2/lean_runtime.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-runtime
-Version: 2.0.0
+Version: 2.0.2
 Summary: Run Lean 4 proofs from Python or standalone files
 Author: Alejandro Radisic
 License-Expression: Apache-2.0

{lean_runtime-2.0.0 → lean_runtime-2.0.2}/lean_runtime.egg-info/SOURCES.txt

@@ -25,6 +25,8 @@ docs/v1-precision.md
 examples/mathlib.toml
 lean_runtime/__init__.py
 lean_runtime/__main__.py
+lean_runtime/_git.py
+lean_runtime/_paths.py
 lean_runtime/backends.py
 lean_runtime/bundles.py
 lean_runtime/cli.py
@@ -86,9 +88,11 @@ tests/test_environment_integration.py
 tests/test_events_health.py
 tests/test_facade.py
 tests/test_frontmatter.py
+tests/test_git.py
 tests/test_interactive.py
 tests/test_lockfiles.py
 tests/test_multifile.py
+tests/test_paths.py
 tests/test_prebuilt_policy.py
 tests/test_programs.py
 tests/test_projects.py

{lean_runtime-2.0.0 → lean_runtime-2.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lean-runtime"
-version = "2.0.0"
+version = "2.0.2"
 description = "Run Lean 4 proofs from Python or standalone files"
 readme = "README.md"
 requires-python = ">=3.10"

{lean_runtime-2.0.0 → lean_runtime-2.0.2}/tests/test_cli.py

@@ -4,7 +4,8 @@ import json
 from pathlib import Path
 
 from lean_runtime.bundles import PortableCopyInfo
-from lean_runtime.cli import main, parser
+from lean_runtime.cli import _print_operation_failure, main, parser
+from lean_runtime.errors import MaterializationError
 from lean_runtime.models import ExecutionResult
 from lean_runtime.verification import VerificationCheck, VerificationReport
 
@@ -34,6 +35,26 @@ def test_removed_v1_commands_are_absent() -> None:
     assert commands.isdisjoint(removed)
 
 
+def test_verbose_materialization_failure_includes_tool_output(capsys) -> None:
+    failure = MaterializationError(
+        "environment build failed",
+        phase="build",
+        command=("lake", "build"),
+        exit_code=1,
+        output="specific compiler failure\n",
+    )
+
+    _print_operation_failure(failure, verbose=True)
+
+    assert capsys.readouterr().err == (
+        "lean-runtime: environment build failed\n"
+        "phase: build\n"
+        "command: lake build\n"
+        "exit code: 1\n"
+        "specific compiler failure\n"
+    )
+
+
 def test_check_file_cli_json_result(monkeypatch, tmp_path: Path, capsys) -> None:
     source = tmp_path / "Main.lean"
     source.write_text("example : True := by trivial")

lean_runtime-2.0.2/tests/test_git.py

@@ -0,0 +1,12 @@
+from lean_runtime._git import git_command
+
+
+def test_git_commands_enable_windows_long_paths_without_global_configuration() -> None:
+    assert git_command("clone", "source", "destination") == [
+        "git",
+        "-c",
+        "core.longpaths=true",
+        "clone",
+        "source",
+        "destination",
+    ]

lean_runtime-2.0.2/tests/test_paths.py

@@ -0,0 +1,25 @@
+from pathlib import Path
+
+from lean_runtime._paths import remove_tree
+
+
+def test_remove_tree_retries_transient_permission_errors(tmp_path: Path, monkeypatch) -> None:
+    target = tmp_path / "tree"
+    target.mkdir()
+    calls = 0
+
+    def flaky_rmtree(path: Path, *, onerror) -> None:
+        nonlocal calls
+        calls += 1
+        if calls == 1:
+            raise PermissionError("Git pack is briefly locked")
+        assert onerror is not None
+        path.rmdir()
+
+    monkeypatch.setattr("lean_runtime._paths.shutil.rmtree", flaky_rmtree)
+    monkeypatch.setattr("lean_runtime._paths.time.sleep", lambda _seconds: None)
+
+    remove_tree(target)
+
+    assert calls == 2
+    assert not target.exists()

{lean_runtime-2.0.0 → lean_runtime-2.0.2}/tests/test_store.py

@@ -197,3 +197,33 @@ def test_source_snapshot_is_shallow_and_detects_content_changes(tmp_path: Path)
             revision=revision,
             tree_hash=tree_hash,
         )
+
+
+def test_source_snapshot_preserves_git_error_when_cleanup_also_fails(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    checkout = tmp_path / "checkout"
+    checkout.mkdir()
+    store = EnvironmentStore(tmp_path / "store")
+    source_id = "source_" + "2" * 64
+    metadata = {
+        "source_id": source_id,
+        "url": "https://example.test/package",
+        "revision": "a" * 40,
+        "tree_hash": "b" * 40,
+    }
+
+    def failed_clone(command: list[str], **_kwargs: object) -> subprocess.CompletedProcess[str]:
+        Path(command[-1]).mkdir()
+        return subprocess.CompletedProcess(command, 1, "", "Filename too long")
+
+    def failed_cleanup(_path: Path, *, onerror) -> None:
+        assert onerror is not None
+        raise PermissionError("pack file is locked")
+
+    monkeypatch.setattr("lean_runtime.store.subprocess.run", failed_clone)
+    monkeypatch.setattr("lean_runtime._paths.shutil.rmtree", failed_cleanup)
+    monkeypatch.setattr("lean_runtime._paths.time.sleep", lambda _seconds: None)
+
+    with pytest.raises(EnvironmentError, match="Filename too long"):
+        store.publish_source(checkout, source_id, metadata)