lean-runtime 4.30.0__tar.gz → 4.33.0__tar.gz

{lean_runtime-4.30.0 → lean_runtime-4.33.0}/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 ## Unreleased
 
+## 4.33.0 - 2026-08-27
+
+- Cover the remaining silent phases with progress. Elan bootstrap and
+  `elan toolchain install`, and the `lake init`/`lake update` behind `new`, now
+  stream their output as `process.progress`/`process.output` like every other
+  subprocess. Long pure-Python loops report counted progress that renders as a
+  bar: `verification.inventory` (hashing build artifacts in `verify`),
+  `bundle.tree_inventory` (`env export`/`import`), `source.snapshot_digest`
+  (source fingerprints, including path dependencies during `adopt`), and
+  `capsule.import_parse`. The publish preflight fetch
+  (`publish.remote_probe_started`) and the Lake configuration read behind
+  project-wide `check` (`project.config_translate_started`) announce
+  themselves. Any event carrying `current`/`total` and a `label` now renders as
+  a counted bar without a dedicated console handler, and deep helpers reach
+  the active runtime's emitter through `lean_runtime.events.current()`.
+- Re-running `adopt` over a tree no longer re-probes every already attached
+  project (a Lake graph load each, up to two minutes for Mathlib); the plan
+  already reports them as attached and `verify` re-checks links. Attachment
+  now announces `adopt.attach_started` per project, rendered as
+  `Attaching projects [bar] i/n`, and the pre-swap Lake graph probe streams its
+  output like every other Lake invocation instead of running silently.
+
 ## 4.30.0 - 2026-08-26
 
 - Attach shared dependencies on Windows without administrator rights. Creating
@@ -29,8 +51,9 @@
   `project.detach.package_started` for each package `unshare` materializes; all
   carry `current`/`total` and render as the same counted bar.
 - Keep the terminal alive during any silent stretch: when no event has arrived
-  for two seconds the console shows `⋯ <last activity> (Ns)` in place; plain
-  logs print `Still working: …` after ten seconds and then every thirty.
+  for two seconds the console shows `⋯ no new events for Ns · last: <activity>`
+  in place; plain logs print `Still working (…)` after ten seconds and then
+  every thirty.
 - Name new shared package directories `pkg_<32 hex>` instead of
   `project_package_<64 hex>`. The 80-character name pushed Mathlib's deepest
   build outputs past Windows' 260-character path limit, so an adopted Mathlib

{lean_runtime-4.30.0/lean_runtime.egg-info → lean_runtime-4.33.0}/PKG-INFO

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

{lean_runtime-4.30.0 → lean_runtime-4.33.0}/lean_runtime/bundles.py

@@ -13,10 +13,11 @@ import tarfile
 import tempfile
 import uuid
 from collections.abc import Iterable, Mapping, Sequence
+from contextlib import nullcontext
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path, PurePosixPath
-from typing import Any
+from typing import Any, Protocol
 
 import zstandard
 
@@ -33,7 +34,7 @@ from .capsules import (
     setup_artifact_groups,
 )
 from .errors import EnvironmentError
-from .events import EventEmitter
+from .events import EventEmitter, current
 from .lake import ROOT_MODULE
 from .lockfiles import EnvironmentLock, LockedPackage
 from .locking import FileLock
@@ -61,6 +62,7 @@ from .packs import (
     unpack_frame,
 )
 from .policies import ExecutionPolicy
+from .progress import CountedProgress
 from .serialization import canonical_json_bytes, write_json_atomic
 from .store import (
     EnvironmentStore,
@@ -81,6 +83,53 @@ SOURCE_TREE_INVENTORY = ".lean-runtime-source-tree.json"
 MAX_CAPSULE_CONFIG_BYTES = 64 * 1024**2
 
 
+class _BinaryReader(Protocol):
+    def read(self, size: int = -1) -> bytes: ...
+
+    def readinto(self, buffer: Any) -> int | None: ...
+
+    def seek(self, offset: int, whence: int = 0) -> int: ...
+
+    def tell(self) -> int: ...
+
+
+class _ProgressReader:
+    """Report bytes after a consumer has actually read them."""
+
+    def __init__(
+        self, handle: _BinaryReader, progress: CountedProgress, *, offset: int = 0
+    ) -> None:
+        self._handle = handle
+        self._progress = progress
+        self._offset = offset
+        self._furthest = offset
+
+    def _report(self) -> None:
+        position = self._offset + self._handle.tell()
+        if position > self._furthest:
+            self._furthest = position
+            self._progress.advance(to=position)
+
+    def read(self, size: int = -1) -> bytes:
+        data = self._handle.read(size)
+        self._report()
+        return data
+
+    def readinto(self, buffer: Any) -> int:
+        count = self._handle.readinto(buffer)
+        self._report()
+        return count if count is not None else 0
+
+    def seek(self, offset: int, whence: int = 0) -> int:
+        return self._handle.seek(offset, whence)
+
+    def tell(self) -> int:
+        return self._handle.tell()
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._handle, name)
+
+
 @dataclass(frozen=True, slots=True)
 class PortableCopyInfo:
     environment_id: str
@@ -130,8 +179,27 @@ def _tree_entries(
     excluded_names: frozenset[str] = frozenset(),
     omit_volatile_build_metadata: bool = False,
 ) -> Iterable[tuple[Path, str]]:
-    for path in sorted(root.rglob("*"), key=lambda value: value.relative_to(root).as_posix()):
+    scan = CountedProgress(
+        current().emit,
+        "bundle.tree_scan",
+        f"Scanning {root.name}",
+        1,
+        phase="bundle",
+    )
+    scan.start()
+    paths = sorted(root.rglob("*"), key=lambda value: value.relative_to(root).as_posix())
+    scan.advance(f"{len(paths)} entries")
+    progress = CountedProgress(
+        current().emit,
+        "bundle.tree_inventory",
+        f"Inventorying {root.name}",
+        len(paths),
+        phase="bundle",
+    )
+    progress.start()
+    for path in paths:
         if excluded is not None and (path == excluded or excluded in path.parents):
+            progress.advance(path.relative_to(root).as_posix())
             continue
         relative = path.relative_to(root)
         if relative.parts and relative.parts[0] in excluded_names:
@@ -145,8 +213,10 @@ def _tree_entries(
                 or relative.name.endswith(".rsp")
             )
         ):
+            progress.advance(relative.as_posix())
             continue
         yield path, relative.as_posix()
+        progress.advance(relative.as_posix())
 
 
 def _write_tar_gzip(
@@ -219,6 +289,18 @@ def _oci_archive(entries: dict[str, bytes]) -> bytes:
 
 
 def _write_oci_archive(entries: dict[str, Path], output: Path) -> None:
+    ordered = sorted(entries.items())
+    total = sum(path.stat().st_size for _name, path in ordered)
+    progress = CountedProgress(
+        current().emit,
+        "bundle.archive_write",
+        "Writing portable archive",
+        total,
+        phase="bundle",
+        unit="bytes",
+    )
+    progress.start()
+    written = 0
     with (
         output.open("wb") as raw_output,
         gzip.GzipFile(
@@ -226,11 +308,13 @@ def _write_oci_archive(entries: dict[str, Path], output: Path) -> None:
         ) as compressed,
         tarfile.open(fileobj=compressed, mode="w|", format=tarfile.PAX_FORMAT) as archive,
     ):
-        for name, path in sorted(entries.items()):
+        for name, path in ordered:
             info = _normalized_info(name, mode=0o644)
             info.size = path.stat().st_size
             with path.open("rb") as handle:
-                archive.addfile(info, handle)
+                archive.addfile(info, _ProgressReader(handle, progress, offset=written))
+            written += info.size
+            progress.advance(name, to=written)
 
 
 def _safe_name(name: str) -> PurePosixPath:
@@ -315,16 +399,32 @@ def _extract_layer(data: bytes | Path, destination: Path) -> None:
     if destination.is_symlink():
         raise EnvironmentError("bundle extraction destination must not be a symlink")
     destination.mkdir(parents=True, exist_ok=True)
+    progress: CountedProgress | None = None
+    raw_handle: Any = None
     try:
         if isinstance(data, Path):
-            archive = tarfile.open(data, mode="r:gz")  # noqa: SIM115
+            raw_handle = data.open("rb")
+            progress = CountedProgress(
+                current().emit,
+                "bundle.layer_extract",
+                f"Extracting {destination.name}",
+                data.stat().st_size,
+                phase="bundle",
+                unit="bytes",
+            )
+            progress.start()
+            archive = tarfile.open(  # noqa: SIM115
+                fileobj=_ProgressReader(raw_handle, progress), mode="r:gz"
+            )
         else:
             archive = tarfile.open(  # noqa: SIM115
                 fileobj=io.BytesIO(data), mode="r:gz"
             )
     except (tarfile.TarError, OSError) as exc:
+        if raw_handle is not None:
+            raw_handle.close()
         raise EnvironmentError("bundle layer is not a valid gzip tar archive") from exc
-    with archive:
+    with archive, raw_handle if raw_handle is not None else nullcontext():
         for member in archive:
             count += 1
             total += member.size
@@ -353,6 +453,8 @@ def _extract_layer(data: bytes | Path, destination: Path) -> None:
                 target.symlink_to(member.linkname)
             else:
                 raise EnvironmentError(f"unsupported bundle member: {member.name!r}")
+    if progress is not None:
+        progress.advance(to=progress.total)
 
 
 def _git_object_id(kind: str, data: bytes) -> str:
@@ -1112,11 +1214,26 @@ class EnvironmentBundles:
         entries: dict[str, Path] = {}
         total = 0
         count = 0
+        byte_progress = CountedProgress(
+            current().emit,
+            "bundle.archive_extract",
+            f"Reading {bundle.name}",
+            bundle.stat().st_size,
+            phase="bundle",
+            unit="bytes",
+        )
+        byte_progress.start()
+        raw_handle: Any = None
         try:
-            archive = tarfile.open(bundle, mode="r:gz")  # noqa: SIM115
+            raw_handle = bundle.open("rb")
+            archive = tarfile.open(  # noqa: SIM115
+                fileobj=_ProgressReader(raw_handle, byte_progress), mode="r:gz"
+            )
         except (tarfile.TarError, OSError) as exc:
+            if raw_handle is not None:
+                raw_handle.close()
             raise EnvironmentError(f"could not read OCI bundle: {bundle}") from exc
-        with archive:
+        with archive, raw_handle:
             for member in archive:
                 count += 1
                 if count > MAX_FILES:
@@ -1136,6 +1253,7 @@ class EnvironmentBundles:
                 with path.open("wb") as output:
                     shutil.copyfileobj(source, output)
                 entries[member.name] = path
+        byte_progress.advance(to=byte_progress.total)
         return entries
 
     def _import_capsule_layout(

{lean_runtime-4.30.0 → lean_runtime-4.33.0}/lean_runtime/capsules.py

@@ -21,8 +21,10 @@ from pathlib import Path, PurePosixPath
 from typing import Any, Literal
 
 from .errors import EnvironmentError
+from .events import current
 from .import_syntax import IMPORT_STATEMENT
 from .lockfiles import EnvironmentLock
+from .progress import CountedProgress
 from .serialization import canonical_json_bytes, write_json_atomic
 
 CAPSULE_SCHEMA = "lean-runtime-check-capsule/1"
@@ -253,6 +255,14 @@ def parse_import_headers(
     with tempfile.TemporaryDirectory(prefix="lean-runtime-imports-") as raw:
         helper = Path(raw) / "ParseImports.lean"
         helper.write_text(IMPORT_PARSER_SOURCE, encoding="utf-8")
+        progress = CountedProgress(
+            current().emit,
+            "capsule.import_parse",
+            "Parsing imports",
+            len(source_paths),
+            phase="capsule",
+        )
+        progress.start()
         for offset in range(0, len(source_paths), batch_size):
             batch = list(source_paths[offset : offset + batch_size])
             process = subprocess.run(
@@ -286,6 +296,7 @@ def parse_import_headers(
                     if isinstance(item, dict) and isinstance(item.get("module"), str)
                 }
                 result[path] = tuple(sorted(names))
+            progress.advance(to=min(offset + len(batch), len(source_paths)))
     return result
 
 
@@ -369,16 +380,34 @@ def build_manifest(
     complete_modules: frozenset[str] | None = None,
 ) -> CapsuleManifest:
     """Inventory retained module artifacts beneath package build roots."""
+    scan = CountedProgress(
+        current().emit,
+        "capsule.artifact_scan",
+        "Scanning capsule artifacts",
+        1,
+        phase="capsule",
+    )
+    scan.start()
+    paths = [
+        (package, root, path)
+        for package, root in sorted(build_roots.items())
+        if root.is_dir()
+        for path in sorted(root.rglob("*"))
+        if path.is_file()
+    ]
+    scan.advance(f"{len(paths)} files")
+    progress = CountedProgress(
+        current().emit,
+        "capsule.artifact_inventory",
+        "Hashing capsule artifacts",
+        len(paths),
+        phase="capsule",
+    )
+    progress.start()
     modules: dict[str, tuple[str, list[CapsuleArtifact]]] = {}
-    for package, root in sorted(build_roots.items()):
-        if not root.is_dir():
-            continue
-        for path in sorted(root.rglob("*")):
-            if not path.is_file():
-                continue
-            module = module_from_artifact(path.relative_to(root))
-            if module is None:
-                continue
+    for package, root, path in paths:
+        module = module_from_artifact(path.relative_to(root))
+        if module is not None:
             relative = path.relative_to(workspace).as_posix()
             capability = artifact_capability(path)
             artifact = CapsuleArtifact(
@@ -390,6 +419,7 @@ def build_manifest(
                     f"capsule module {module} is provided by both {existing[0]} and {package}"
                 )
             modules.setdefault(module, (package, []))[1].append(artifact)
+        progress.advance(path.relative_to(workspace).as_posix())
     known_complete = frozenset(imports) if complete_modules is None else complete_modules
     records = tuple(
         CapsuleModule(
@@ -436,6 +466,14 @@ def inventory_workspace(
 ) -> CapsuleManifest:
     """Build an exact capsule inventory from a verified full workspace."""
     source_roots, build_roots = _package_directories(workspace, lock)
+    discovery = CountedProgress(
+        current().emit,
+        "capsule.module_discovery",
+        "Discovering capsule modules",
+        len(build_roots) + len(source_roots),
+        phase="capsule",
+    )
+    discovery.start()
     modules_by_package: dict[str, set[str]] = {}
     for package, root in build_roots.items():
         modules_by_package[package] = {
@@ -443,11 +481,13 @@ def inventory_workspace(
             for path in root.rglob("*.olean")
             if (module := module_from_artifact(path.relative_to(root))) is not None
         }
+        discovery.advance(package)
 
     source_modules: dict[Path, str] = {}
     claimed: dict[str, tuple[int, Path]] = {}
     for package, root in source_roots.items():
         if not root.is_dir():
+            discovery.advance(package)
             continue
         available = modules_by_package[package]
         for path in sorted(root.rglob("*.lean")):
@@ -473,6 +513,7 @@ def inventory_workspace(
                 source_modules.pop(previous[1], None)
             claimed[module] = (stripped, path)
             source_modules[path] = module
+        discovery.advance(package)
 
     parsed = parse_import_headers(lean_command, tuple(source_modules))
     imports = {source_modules[path]: names for path, names in parsed.items()}

{lean_runtime-4.30.0 → lean_runtime-4.33.0}/lean_runtime/cli.py

@@ -1970,9 +1970,9 @@ def main(argv: list[str] | None = None) -> int:
             )
             if declined is not None:
                 return declined
-            di_publication = OCIDeclarationIndexPublisher(di_repository).publish(
-                tuple(di_item.source for di_item in built.shards), lock_id=lock.lock_id
-            )
+            di_publication = OCIDeclarationIndexPublisher(
+                di_repository, events=runtime.events
+            ).publish(tuple(di_item.source for di_item in built.shards), lock_id=lock.lock_id)
             if args.sign:
                 CosignVerifier(executable=runtime.verification_executable).sign(
                     di_repository, di_publication.manifest_digest

{lean_runtime-4.30.0 → lean_runtime-4.33.0}/lean_runtime/console.py

@@ -141,6 +141,19 @@ class ConsoleRenderer:
             handler = getattr(self, "_render_" + event.kind.replace(".", "_"), None)
             if handler is not None:
                 handler(event)
+            elif (
+                isinstance(event.data.get("current"), int)
+                and isinstance(event.data.get("total"), int)
+                and event.data.get("label")
+            ):
+                # Any counted event renders as a bar without a dedicated handler.
+                self._render_count_progress(
+                    str(event.data["label"]),
+                    event.data["current"],
+                    event.data["total"],
+                    str(event.data.get("detail") or ""),
+                    bytes_unit=event.data.get("unit") == "bytes",
+                )
 
     def note(self, message: str) -> None:
         """Print one renderer-owned status line."""
@@ -183,11 +196,12 @@ class ConsoleRenderer:
                 idle = self._clock() - self._last_event_at
                 if idle < self._heartbeat_seconds:
                     continue
+                last = _truncate(self._last_message, _OUTPUT_WIDTH)
                 if self.mode == "tty":
-                    text = f"⋯ {_truncate(self._last_message, _OUTPUT_WIDTH)} ({int(idle)}s)"
+                    text = f"⋯ no new events for {int(idle)}s · last: {last}"
                     self._draw_line(text, self.style.dim(text))
                 elif idle >= self._next_plain_heartbeat:
-                    self._print(f"Still working: {self._last_message} ({int(idle)}s)")
+                    self._print(f"Still working ({int(idle)}s without events; last: {last})")
                     self._next_plain_heartbeat = idle + _PLAIN_HEARTBEAT_REPEAT_SECONDS
 
     # -- individual event renderings ------------------------------------
@@ -366,6 +380,9 @@ class ConsoleRenderer:
     def _render_adopt_identity_started(self, event: RuntimeEvent) -> None:
         self._count_from(event, "Resolving dependency identities", "name")
 
+    def _render_adopt_attach_started(self, event: RuntimeEvent) -> None:
+        self._count_from(event, "Attaching projects", "name")
+
     def _render_project_detach_package_started(self, event: RuntimeEvent) -> None:
         self._count_from(event, "Materializing packages", "package")
 
@@ -376,7 +393,11 @@ class ConsoleRenderer:
             return
         self._render_count_progress(label, current, total, str(event.data.get(detail_key) or ""))
 
-    def _render_count_progress(self, label: str, current: int, total: int, detail: str) -> None:
+    def _render_count_progress(
+        self, label: str, current: int, total: int, detail: str, *, bytes_unit: bool = False
+    ) -> None:
+        if total <= 0:
+            return
         current = min(current, total)
         if self.mode == "tty":
             now = self._clock()
@@ -390,10 +411,15 @@ class ConsoleRenderer:
             filled = _BAR_WIDTH * current // total
             bar = "█" * filled + "░" * (_BAR_WIDTH - filled)
             suffix = f" · {_truncate(detail, _DETAIL_WIDTH)}" if detail else ""
-            plain = f"{label} [{bar}] {current}/{total}{suffix}"
+            amount = (
+                f"{format_byte_size(current)}/{format_byte_size(total)}"
+                if bytes_unit
+                else f"{current}/{total}"
+            )
+            plain = f"{label} [{bar}] {amount}{suffix}"
             styled = (
                 f"{label} [{self.style.cyan(bar)}] "
-                f"{self.style.bold(f'{current}/{total}')}{self.style.dim(suffix)}"
+                f"{self.style.bold(amount)}{self.style.dim(suffix)}"
             )
             self._draw_line(plain, styled)
             if current >= total:
@@ -405,7 +431,12 @@ class ConsoleRenderer:
             self._count_checkpoint = _PLAIN_CHECKPOINT_PERCENT
         percent = current * 100 // total
         while self._count_checkpoint <= percent:
-            self._print(f"{label}: {self._count_checkpoint}% ({current}/{total})")
+            amount = (
+                f"{format_byte_size(current)}/{format_byte_size(total)}"
+                if bytes_unit
+                else f"{current}/{total}"
+            )
+            self._print(f"{label}: {self._count_checkpoint}% ({amount})")
             self._count_checkpoint += _PLAIN_CHECKPOINT_PERCENT
 
     # -- low-level output -----------------------------------------------

{lean_runtime-4.30.0 → lean_runtime-4.33.0}/lean_runtime/declaration_index_build.py

@@ -19,7 +19,9 @@ from .declaration_index import (
 )
 from .declaration_index_oci import DeclarationShardSource
 from .errors import EnvironmentError
+from .events import current
 from .lockfiles import EnvironmentLock, LockedPackage
+from .progress import CountedProgress
 from .runtime import Runtime
 from .serialization import canonical_json_bytes
 
@@ -101,9 +103,26 @@ def _declarations(root: Path) -> tuple[dict[str, str], tuple[str, ...], tuple[st
     declarations: dict[str, str] = {}
     ambiguous: set[str] = set()
     modules: set[str] = set()
+    scan = CountedProgress(
+        current().emit,
+        "declaration_index.scan",
+        f"Scanning declarations in {root.name}",
+        1,
+        phase="declaration-index",
+    )
+    scan.start()
     ileans = tuple(sorted(root.rglob("*.ilean"), key=lambda item: item.as_posix()))
+    scan.advance(f"{len(ileans)} files")
     if not ileans:
         raise EnvironmentError(f"compiled declaration root contains no .ilean files: {root}")
+    progress = CountedProgress(
+        current().emit,
+        "declaration_index.parse",
+        f"Reading declarations in {root.name}",
+        len(ileans),
+        phase="declaration-index",
+    )
+    progress.start()
     for path in ileans:
         if path.stat().st_size > MAX_ILEAN_BYTES:
             raise EnvironmentError(f"Lean index exceeds its supported size: {path}")
@@ -129,6 +148,7 @@ def _declarations(root: Path) -> tuple[dict[str, str], tuple[str, ...], tuple[st
                 ambiguous.add(name)
                 continue
             declarations[name] = module
+        progress.advance(path.name)
     if not declarations:
         raise EnvironmentError(f"compiled declaration root produced no public names: {root}")
     namespace_roots = {name.split(".", 1)[0] for name in declarations}
@@ -147,6 +167,14 @@ def _write_shard(
 ) -> None:
     if output.exists():
         raise EnvironmentError(f"refusing to overwrite declaration shard: {output}")
+    progress = CountedProgress(
+        current().emit,
+        "declaration_index.sqlite",
+        f"Writing declaration shard {output.stem[:20]}",
+        4,
+        phase="declaration-index",
+    )
+    progress.start()
     with sqlite3.connect(output) as connection:
         connection.executescript(
             f"""
@@ -171,6 +199,7 @@ def _write_shard(
             ) WITHOUT ROWID;
             """
         )
+        progress.advance("schema")
         metadata = {
             "schema": DECLARATION_SHARD_SCHEMA,
             "shard_id": shard_id,
@@ -184,12 +213,15 @@ def _write_shard(
             for name in sorted(declarations)
         ]
         connection.executemany("INSERT INTO decl VALUES (?, ?, ?, ?)", rows)
+        progress.advance("declarations")
         connection.executemany(
             "INSERT INTO suffix VALUES (?, ?)",
             sorted((name.rsplit(".", 1)[-1], name) for name in declarations),
         )
         connection.commit()
+        progress.advance("suffix index")
         connection.execute("VACUUM")
+        progress.advance("vacuum")
     DeclarationIndex(output, expected_shard_id=shard_id)