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

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

@@ -2,6 +2,22 @@
 
 ## Unreleased
 
+## 4.27.0 - 2026-08-26
+
+- Fingerprint a project by what Lake compiles, not by everything beside the
+  lakefile. The workspace digest that keys header snapshots and provenance now
+  hashes `lakefile.toml`/`lakefile.lean`, `lean-toolchain`, `lake-manifest.json`,
+  and the `.lean` files under each declared target's module roots (the whole
+  tree, minus `.git` and `.lake`, when the lakefile is not declarative).
+  Previously every byte under the project root was read on each `check` and
+  `build`, so a lakefile above a data directory, a virtual environment, or an
+  unrelated monorepo made the first step of a check run for minutes with no
+  output. Digests change value once because of this.
+- Announce project fingerprinting as `project.fingerprint_started` and
+  `project.fingerprint_finished` events (phase `fingerprint`, with
+  `elapsed_ms`), so `--verbose` never goes silent between `check.started` and
+  the first Lake invocation.
+
 ## 4.26.0 - 2026-08-26
 
 - Stop `status` claiming a download is required for core-only files. A lock

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

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

{lean_runtime-4.26.0 → lean_runtime-4.27.0}/docs/reference/python-api.md

@@ -137,8 +137,11 @@ and lock identities, exact package commits and Git tree hashes, toolchain,
 platform, backend, policy, source digest, and start time.
 
 Mutable project results have no environment or lock identity. Their provenance
-instead records the canonical root, a workspace digest excluding `.git` and
-`.lake`, Lake configuration and manifest digests, and Git revision state.
+instead records the canonical root, a workspace digest of what Lake compiles
+(the lakefile, toolchain pin, manifest, and the `.lean` files under each
+declared target's module roots; the whole tree minus `.git` and `.lake` when the
+lakefile is not declarative), Lake configuration and manifest digests, and Git
+revision state.
 
 ## Work with Lake projects
 

{lean_runtime-4.26.0 → lean_runtime-4.27.0}/lean_runtime/project_execution.py

@@ -31,7 +31,7 @@ else:  # pragma: no cover - exercised by the Python 3.10 CI job
 from .errors import ProjectError
 from .import_syntax import IMPORT_STATEMENT
 from .locking import FileLock
-from .models import ExecutionResult, PhaseTiming
+from .models import ExecutionResult, PhaseTiming, ProjectProvenance
 from .policies import ExecutionPolicy
 from .project_sharing import project_sharing_enabled
 from .projects import ProjectContext
@@ -94,6 +94,26 @@ class ProjectExecutor:
     def __init__(self, runtime: Runtime) -> None:
         self.runtime = runtime
 
+    def _provenance(self, context: ProjectContext) -> ProjectProvenance:
+        """Fingerprint the project, announcing the work so large trees never look hung."""
+        self.runtime.events.emit(
+            "project.fingerprint_started",
+            f"Fingerprinting project sources: {context.root}",
+            phase="fingerprint",
+            root=str(context.root),
+        )
+        started = time.monotonic()
+        provenance = context.provenance()
+        elapsed = time.monotonic() - started
+        self.runtime.events.emit(
+            "project.fingerprint_finished",
+            f"Fingerprinted project sources in {elapsed:.2f}s",
+            phase="fingerprint",
+            root=str(context.root),
+            elapsed_ms=round(elapsed * 1000),
+        )
+        return provenance
+
     @staticmethod
     def _declares_dependencies(context: ProjectContext) -> bool:
         """Whether the lakefile requires packages Lake would have to fetch."""
@@ -202,7 +222,7 @@ class ProjectExecutor:
             context.toolchain, "lake", "env", "lean", relative
         )
         text = source.read_text(encoding="utf-8")
-        provenance = context.provenance()
+        provenance = self._provenance(context)
 
         def execute(selected_command: list[str]) -> ExecutionResult:
             return self.runtime._raw_result(
@@ -248,7 +268,7 @@ class ProjectExecutor:
             command = self.runtime.toolchains.command(
                 context.toolchain, "lake", "env", "lean", relative
             )
-            provenance = context.provenance()
+            provenance = self._provenance(context)
 
             def execute(selected_command: list[str]) -> ExecutionResult:
                 return self.runtime._raw_result(
@@ -368,7 +388,7 @@ class ProjectExecutor:
         )
         command = self.runtime.toolchains.command(context.toolchain, "lake", *lake_arguments)
         environment = self.runtime.lake_cache.environment(context)
-        project_provenance = context.provenance()
+        project_provenance = self._provenance(context)
         package_provenance = context.package_provenance()
         package_arguments = (
             (f"--packages={workspace.overrides_file}",) if workspace is not None else ()

{lean_runtime-4.26.0 → lean_runtime-4.27.0}/lean_runtime/projects.py

@@ -27,7 +27,6 @@ from ._git import git_command
 from .errors import ProjectError, ProjectNotFoundError
 from .models import ExecutionResult, PackageProvenance, ProjectProvenance
 from .policies import ExecutionPolicy
-from .store import source_snapshot_digest
 from .toolchains import normalize_toolchain
 
 if TYPE_CHECKING:
@@ -363,6 +362,28 @@ class ProjectContext:
         selected = Path(path).expanduser().resolve()
         if selected.suffix != ".lean":
             return None
+        roots = self.source_roots()
+        if roots is None:
+            return None
+        for source_root, root_parts in roots:
+            try:
+                relative = selected.relative_to(source_root)
+            except ValueError:
+                continue
+            relative_module = relative.with_suffix("").parts
+            if relative_module[: len(root_parts)] == root_parts:
+                return True
+        return False
+
+    def source_roots(self) -> tuple[tuple[Path, tuple[str, ...]], ...] | None:
+        """Return the module prefixes Lake compiles for this project.
+
+        Each entry pairs a resolved source directory with a module-name prefix
+        (``("Foo", "Bar")`` for ``Foo.Bar``). Declarative Lake files can be
+        inspected exactly without executing Lake; ``None`` means the project
+        format is not safely understood and callers should fall back to the
+        whole project tree.
+        """
         if self.lakefile.name != "lakefile.toml":
             return None
         try:
@@ -377,6 +398,7 @@ class ProjectContext:
             targets.extend((key, item) for item in entries)
         if not targets:
             return None
+        result: list[tuple[Path, tuple[str, ...]]] = []
         for target_kind, target in targets:
             src_dir = target.get("srcDir", ".")
             if not isinstance(src_dir, str):
@@ -389,21 +411,95 @@ class ProjectContext:
                 return None
             # `roots` selects library build roots; it does not restrict the
             # namespace of source modules belonging to a lean_lib target.
-            # Include the library name so sibling modules are still recognized.
+            # Include the library name so sibling modules are still recognized,
+            # and the leading module of each glob so `Foo.*` style globs count.
             name = target.get("name")
             if target_kind == "lean_lib" and isinstance(name, str) and name not in roots:
                 roots = [name, *roots]
+            globs = target.get("globs", [])
+            if not isinstance(globs, list) or not all(isinstance(glob, str) for glob in globs):
+                return None
+            for glob in globs:
+                prefix = glob.removesuffix(".*").removesuffix(".+")
+                if prefix and prefix not in roots:
+                    roots.append(prefix)
             source_root = (self.root / src_dir).resolve()
-            try:
-                relative = selected.relative_to(source_root)
-            except ValueError:
-                continue
-            relative_module = relative.with_suffix("").parts
             for root in roots:
                 root_parts = tuple(part for part in root.replace("`", "").split(".") if part)
-                if relative_module[: len(root_parts)] == root_parts:
-                    return True
-        return False
+                if root_parts and (source_root, root_parts) not in result:
+                    result.append((source_root, root_parts))
+        return tuple(result)
+
+    def source_digest(self) -> str:
+        """Hash only the content Lake compiles: configuration and module sources.
+
+        Unlike :func:`source_snapshot_digest`, which fingerprints a whole tree,
+        this ignores datasets, virtual environments, and anything else that
+        happens to live beside the lakefile. The digest still changes whenever
+        the lakefile, toolchain pin, manifest, or any owned ``.lean`` file
+        changes, which is what the header cache keys on.
+        """
+        digest = hashlib.sha256()
+
+        def add_file(path: Path) -> None:
+            try:
+                mode = path.stat().st_mode & 0o111
+                relative = path.relative_to(self.root).as_posix()
+                with path.open("rb") as handle:
+                    digest.update(b"file\0" + relative.encode() + b"\0")
+                    digest.update(str(mode).encode() + b"\0")
+                    for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+                        digest.update(chunk)
+            except OSError:
+                return
+
+        for name in ("lakefile.toml", "lakefile.lean", "lean-toolchain", "lake-manifest.json"):
+            candidate = self.root / name
+            if candidate.is_file() and not candidate.is_symlink():
+                add_file(candidate)
+        seen: set[Path] = set()
+        module_files, directories_to_walk = self._source_locations()
+        for path in module_files:
+            if path.is_file() and not path.is_symlink():
+                seen.add(path)
+                add_file(path)
+        for start in directories_to_walk:
+            for directory, directories, filenames in os.walk(start, followlinks=False):
+                current = Path(directory)
+                directories[:] = sorted(
+                    name
+                    for name in directories
+                    if name not in {".git", ".lake"} and not (current / name).is_symlink()
+                )
+                for name in sorted(filenames):
+                    if not name.endswith(".lean"):
+                        continue
+                    path = current / name
+                    if path in seen or path.is_symlink():
+                        continue
+                    seen.add(path)
+                    add_file(path)
+        return "sha256:" + digest.hexdigest()
+
+    def _source_locations(self) -> tuple[tuple[Path, ...], tuple[Path, ...]]:
+        """Split owned sources into root module files and directories to walk.
+
+        A module prefix ``Foo.Bar`` owns ``Foo/Bar.lean`` and everything under
+        ``Foo/Bar/``. Without declared targets the whole project tree is walked.
+        """
+        roots = self.source_roots()
+        if roots is None:
+            return ((), (self.root,))
+        files: list[Path] = []
+        directories: list[Path] = []
+        for source_root, root_parts in roots:
+            module = source_root.joinpath(*root_parts)
+            module_file = module.with_suffix(".lean")
+            if module_file not in files:
+                files.append(module_file)
+            if module not in directories:
+                directories.append(module)
+        return tuple(files), tuple(directories)
 
     def current_manifest(self) -> Path | None:
         path = self.root / "lake-manifest.json"
@@ -424,7 +520,7 @@ class ProjectContext:
             pass
         return ProjectProvenance(
             root=str(self.root),
-            workspace_digest=source_snapshot_digest(self.root),
+            workspace_digest=self.source_digest(),
             lakefile_digest=_file_digest(self.lakefile) or "",
             manifest_digest=_file_digest(manifest) if manifest is not None else None,
             git_revision=revision,

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

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

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

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

{lean_runtime-4.26.0 → lean_runtime-4.27.0}/tests/test_header_cache.py

@@ -313,6 +313,7 @@ def test_shared_builds_record_workspace_lock_timing(tmp_path: Path) -> None:
             ),
             build_lock=build_lock,
         ),
+        events=SimpleNamespace(emit=lambda *_args, **_kwargs: None),
         _raw_result=lambda *_args, **_kwargs: _execution(True),
     )
     executor = ProjectExecutor(runtime)  # type: ignore[arg-type]

{lean_runtime-4.26.0 → lean_runtime-4.27.0}/tests/test_projects.py

@@ -1811,3 +1811,117 @@ def test_project_async_cancellation_waits_for_process_cleanup(tmp_path: Path) ->
             await task
 
     asyncio.run(cancel_check())
+
+
+def test_project_source_digest_ignores_unrelated_files(tmp_path: Path) -> None:
+    from lean_runtime.projects import discover_project
+
+    source = _project(tmp_path / "project")
+    (tmp_path / "project" / "lakefile.toml").write_text(
+        'name = "sample"\n[[lean_lib]]\nname = "Sample"\n'
+    )
+    context = discover_project(source)
+    assert context.source_roots() == (((tmp_path / "project").resolve(), ("Sample",)),)
+    original = context.provenance().workspace_digest
+    assert original.startswith("sha256:")
+
+    # Data, tooling, and nested unrelated projects beside the lakefile are not sources.
+    (tmp_path / "project" / "README.md").write_text("notes\n")
+    (tmp_path / "project" / "data").mkdir()
+    (tmp_path / "project" / "data" / "blob.bin").write_bytes(b"\0" * 4096)
+    (tmp_path / "project" / "venv" / "lib").mkdir(parents=True)
+    (tmp_path / "project" / "venv" / "lib" / "site.py").write_text("x = 1\n")
+    (tmp_path / "project" / "Other").mkdir()
+    (tmp_path / "project" / "Other" / "Unowned.lean").write_text("example : True := trivial\n")
+    assert context.provenance().workspace_digest == original
+
+    # Owned modules, sibling modules, and configuration do change it.
+    (tmp_path / "project" / "Sample" / "Extra.lean").write_text("example : True := trivial\n")
+    with_module = context.provenance().workspace_digest
+    assert with_module != original
+    (tmp_path / "project" / "Sample.lean").write_text("import Sample.Main\n")
+    with_root_module = context.provenance().workspace_digest
+    assert with_root_module != with_module
+    source.write_text("example : 1 = 1 := rfl\n")
+    with_edit = context.provenance().workspace_digest
+    assert with_edit != with_root_module
+    (tmp_path / "project" / "lean-toolchain").write_text("leanprover/lean4:v4.33.0\n")
+    with_toolchain = context.provenance().workspace_digest
+    assert with_toolchain != with_edit
+    (tmp_path / "project" / "lakefile.toml").write_text('name = "sample"\nversion = "0.2.0"\n')
+    assert context.provenance().workspace_digest != with_toolchain
+
+
+def test_project_source_digest_walks_whole_tree_without_declared_targets(
+    tmp_path: Path,
+) -> None:
+    from lean_runtime.projects import discover_project
+
+    root = tmp_path / "project"
+    root.mkdir()
+    (root / "lean-toolchain").write_text("leanprover/lean4:v4.32.0\n")
+    (root / "lakefile.lean").write_text("import Lake\nopen Lake DSL\npackage sample\n")
+    (root / "Sample").mkdir()
+    (root / "Sample" / "Main.lean").write_text("example : True := trivial\n")
+    context = discover_project(root / "Sample" / "Main.lean")
+    assert context.source_roots() is None
+    original = context.provenance().workspace_digest
+
+    (root / "data").mkdir()
+    (root / "data" / "blob.bin").write_bytes(b"\0" * 4096)
+    (root / ".lake").mkdir()
+    (root / ".lake" / "Ignored.lean").write_text("example : True := trivial\n")
+    assert context.provenance().workspace_digest == original
+
+    (root / "Anywhere").mkdir()
+    (root / "Anywhere" / "Module.lean").write_text("example : True := trivial\n")
+    assert context.provenance().workspace_digest != original
+
+
+def test_project_source_roots_include_globs_and_exe_roots(tmp_path: Path) -> None:
+    from lean_runtime.projects import discover_project
+
+    root = tmp_path / "project"
+    root.mkdir()
+    (root / "lean-toolchain").write_text("leanprover/lean4:v4.32.0\n")
+    (root / "lakefile.toml").write_text(
+        'name = "sample"\n'
+        "[[lean_lib]]\n"
+        'name = "Sample"\n'
+        'srcDir = "src"\n'
+        'globs = ["Extra.*"]\n'
+        "[[lean_exe]]\n"
+        'name = "tool"\n'
+        'root = "Tool.Main"\n'
+    )
+    (root / "src" / "Sample").mkdir(parents=True)
+    (root / "src" / "Sample" / "Main.lean").write_text("example : True := trivial\n")
+    context = discover_project(root / "src" / "Sample" / "Main.lean")
+    roots = context.source_roots()
+    assert roots is not None
+    assert set(roots) == {
+        ((root / "src").resolve(), ("Sample",)),
+        ((root / "src").resolve(), ("Extra",)),
+        (root.resolve(), ("Tool", "Main")),
+    }
+    assert context.owns_file(root / "src" / "Extra" / "Thing.lean") is True
+    assert context.owns_file(root / "Tool" / "Main" / "Impl.lean") is True
+    assert context.owns_file(root / "src" / "Stray.lean") is False
+
+
+def test_project_check_announces_fingerprinting(tmp_path: Path) -> None:
+    source = _project(tmp_path / "project")
+    events: list[RuntimeEvent] = []
+    runtime = Runtime(
+        toolchains=ProjectToolchains(tmp_path / "runtime"),
+        libraries=[],  # type: ignore[arg-type]
+        on_event=events.append,
+    )
+    result = runtime.project(source).check_file(source)
+    assert result.ok
+    kinds = [event.kind for event in events]
+    started = kinds.index("project.fingerprint_started")
+    finished = kinds.index("project.fingerprint_finished")
+    assert started < finished
+    assert events[started].data["root"] == str(runtime.project(source).root)
+    assert isinstance(events[finished].data["elapsed_ms"], int)