lean-runtime 4.25.0__tar.gz → 4.26.0__tar.gz

{lean_runtime-4.25.0 → lean_runtime-4.26.0}/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## Unreleased
 
+## 4.26.0 - 2026-08-26
+
+- Stop `status` claiming a download is required for core-only files. A lock
+  without packages runs straight on the toolchain and never materializes an
+  environment in the store, so readiness and cost are now judged by the
+  toolchain alone: `status` reports `environment ready locally` and
+  `Download none` once the toolchain is installed, and `status --probe`
+  prices it as zero instead of `unknown`. Previously the store directory that
+  `check` never creates kept the row at `not local · Download required`.
+
 ## 4.25.0 - 2026-08-26
 
 - Pin the Elan build that automatic bootstrap installs. Bootstrap now

{lean_runtime-4.25.0/lean_runtime.egg-info → lean_runtime-4.26.0}/PKG-INFO

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

{lean_runtime-4.25.0 → lean_runtime-4.26.0}/lean_runtime/runtime.py

@@ -569,8 +569,14 @@ class Runtime:
         """Report what opening a lock would cost, without acquiring anything."""
         environment_id = environment_identity(lock, build_profile)
         destination = self.store.environment_path(environment_id)
-        ready = destination.is_dir()
-        sparse = (destination / "workspace" / ".lean-runtime" / "capsule.json").is_file()
+        # A lock without packages runs straight on the toolchain: no environment
+        # is ever materialized in the store, so only the toolchain can cost anything.
+        core_only = not lock.packages
+        ready = core_only or destination.is_dir()
+        sparse = (
+            not core_only
+            and (destination / "workspace" / ".lean-runtime" / "capsule.json").is_file()
+        )
         libraries: list[dict[str, Any]] = []
         environment_download: int | None = 0 if ready and not sparse else None
         if not ready or sparse:
@@ -659,6 +665,15 @@ class Runtime:
     ) -> bool:
         """Return whether a lock and import closure can check without acquisition."""
 
+        if not lock.packages:
+            # Core-only locks never touch the environment store; the toolchain is
+            # the whole environment. Do not call it ready for an external import,
+            # though: discovery uses this result for local-first ordering, and an
+            # installed core toolchain must not outrank the package that provides
+            # (for example) Mathlib.
+            core_roots = {"Init", "Lean", "Std"}
+            imports_are_core = all(module.split(".", 1)[0] in core_roots for module in import_roots)
+            return imports_are_core and self._toolchain_installed(lock.toolchain)
         environment_id = environment_identity(lock)
         if not self.store.environment_path(environment_id).is_dir():
             return False

{lean_runtime-4.25.0 → lean_runtime-4.26.0/lean_runtime.egg-info}/PKG-INFO

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

{lean_runtime-4.25.0 → lean_runtime-4.26.0}/pyproject.toml

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

{lean_runtime-4.25.0 → lean_runtime-4.26.0}/tests/test_cli.py

@@ -528,6 +528,43 @@ def test_standalone_status_reports_plan_not_selection_and_availability(
     assert data["probe"] is None
 
 
+def test_core_only_status_needs_no_download_once_the_toolchain_is_installed(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str], monkeypatch: pytest.MonkeyPatch
+) -> None:
+    # A core-only file never materializes a store environment, so status must
+    # judge it by the toolchain alone rather than by a store directory that
+    # `check` will never create.
+    source = tmp_path / "Core.lean"
+    source.write_text("example : True := by trivial\n")
+    monkeypatch.setattr("lean_runtime.cli.Runtime._toolchain_installed", lambda _self, _t: True)
+    assert main(["--home", str(tmp_path / "home"), "status", str(source)]) == 0
+    output = capsys.readouterr().out
+    assert "Imports      none (core Lean only)" in output
+    assert "environment ready locally · toolchain installed" in output
+    assert "Download     none: core-" in output
+    assert "required" not in output
+
+    assert main(["--home", str(tmp_path / "home"), "status", str(source), "--probe"]) == 0
+    output = capsys.readouterr().out
+    assert "Download     none: environment and toolchain are already local" in output
+
+    assert main(["--home", str(tmp_path / "home"), "status", str(source), "--json"]) == 0
+    data = json.loads(capsys.readouterr().out)["data"]
+    assert data["availability"][data["planned_first"]]["local"] is True
+
+
+def test_core_only_status_still_needs_the_toolchain_when_it_is_missing(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str], monkeypatch: pytest.MonkeyPatch
+) -> None:
+    source = tmp_path / "Core.lean"
+    source.write_text("example : True := by trivial\n")
+    monkeypatch.setattr("lean_runtime.cli.Runtime._toolchain_installed", lambda _self, _t: False)
+    assert main(["--home", str(tmp_path / "home"), "status", str(source)]) == 0
+    output = capsys.readouterr().out
+    assert "environment not local · toolchain not installed" in output
+    assert "Download     required for core-" in output
+
+
 def test_status_reports_unowned_file_beneath_declarative_project_as_standalone(
     tmp_path: Path, capsys: pytest.CaptureFixture[str]
 ) -> None:

{lean_runtime-4.25.0 → lean_runtime-4.26.0}/tests/test_runtime.py

@@ -274,3 +274,68 @@ def test_full_environment_build_installs_a_lake_capable_toolchain(tmp_path: Path
     environment = runtime.open_toolchain("v4.32.2")
     environment.build(("Demo",))
     assert toolchains.full_installs == ["leanprover/lean4:v4.32.2"]
+
+
+class InstalledToolchains(FakeToolchains):
+    def __init__(self, home: Path, installed: str) -> None:
+        super().__init__(home)
+        self.installed = installed
+
+    def is_available_locally(self, toolchain: str) -> bool:
+        return toolchain == self.installed
+
+
+def _core_lock(toolchain: str) -> EnvironmentLock:
+    return EnvironmentLock(
+        toolchain=toolchain,
+        spec_digest="spec_" + "c" * 64,
+        root_lakefile='name = "core"\n',
+        root_module="",
+        manifest={"packages": []},
+        packages=(),
+    )
+
+
+def test_core_lock_is_ready_locally_once_its_toolchain_is_installed(tmp_path: Path) -> None:
+    # Core-only checks run straight on the toolchain and never materialize an
+    # environment in the store, so the store must not decide their readiness.
+    runtime = Runtime(
+        home=tmp_path / "home",
+        toolchains=InstalledToolchains(tmp_path, "leanprover/lean4:v4.32.2"),  # type: ignore[arg-type]
+        libraries=[],
+    )
+    assert runtime.exact_ready_locally(_core_lock("leanprover/lean4:v4.32.2")) is True
+    assert (
+        runtime.exact_ready_locally(
+            _core_lock("leanprover/lean4:v4.32.2"), import_roots=("Lean.Elab", "Std.Data.HashMap")
+        )
+        is True
+    )
+    assert (
+        runtime.exact_ready_locally(
+            _core_lock("leanprover/lean4:v4.32.2"), import_roots=("Mathlib",)
+        )
+        is False
+    )
+    assert runtime.exact_ready_locally(_core_lock("leanprover/lean4:v4.31.0")) is False
+
+
+def test_core_lock_plan_costs_nothing_once_its_toolchain_is_installed(tmp_path: Path) -> None:
+    runtime = Runtime(
+        home=tmp_path / "home",
+        toolchains=InstalledToolchains(tmp_path, "leanprover/lean4:v4.32.2"),  # type: ignore[arg-type]
+        libraries=[],
+    )
+    plan = runtime.plan_exact(_core_lock("leanprover/lean4:v4.32.2"))
+    assert plan["environment_ready"] is True
+    assert plan["environment_download_bytes"] == 0
+    assert plan["toolchain_download_bytes"] == 0
+    assert plan["download_bytes"] == 0
+    assert plan["download_bytes_complete"] is True
+    assert plan["libraries"] == []
+
+    missing = runtime.plan_exact(_core_lock("leanprover/lean4:v4.31.0"))
+    assert missing["environment_ready"] is True
+    assert missing["environment_download_bytes"] == 0
+    assert missing["toolchain_installed"] is False
+    assert missing["download_bytes_complete"] is False