#!/usr/bin/env python3 """lbc: Lean build cache tool (pack, unpack, fetch, build keys) for the MoteMath Lean build cache. Design: ../ARCHITECTURE.md. Standard library plus the `zstd` command-line tool; `fetch` also needs huggingface_hub. lbc.py key [--package NAME] lbc.py pack --package NAME --commit SHA --source-repo URL --license SPDX --project-dir DIR [--toolchain TC] [--shard-bytes N] [--level N] [--exclude-setup-json] lbc.py unpack [--shards part-00001.tar.zst,...] lbc.py check lbc.py fetch [--module M ...] [--package P ...] [--namespace MoteMath] [--dry-run] [--check] `package_dir` is the directory that contains the package's `.lake/build` (the project root for the root package, `.lake/packages/` for a dependency). `fetch` downloads only what is needed. With `--module`, it takes the import closure of those modules across every package, using each build's `shards/modules.jsonl` import index, and downloads only the shards holding those modules (plus the shard with package-level files). Without `--module` it fetches every shard of every package found. Mathlib and its standard dependencies come from Mathlib's own cache (`lake exe cache get`). """ import argparse, hashlib, io, json, os, platform as _pf, re, subprocess, sys, tarfile, time SCHEMA = "lean-build-manifest/1" KEY_TAG = "lean-build-key-v1" STD = {"mathlib", "batteries", "Qq", "aesop", "proofwidgets", "plausible", "LeanSearchClient", "importGraph", "Cli"} def sha256_file(p, bufsize=1 << 20): h = hashlib.sha256() with open(p, "rb") as f: for b in iter(lambda: f.read(bufsize), b""): h.update(b) return h.hexdigest() def compress_frame(raw, level): """One zstd frame (content size recorded). Uses the zstandard module when present, else Python 3.14's own compression.zstd, else the zstd CLI.""" try: import zstandard return zstandard.ZstdCompressor(level=level, write_content_size=True).compress(raw) except ImportError: pass try: from compression import zstd as _z # Python 3.14+; one-shot compress records the content size return _z.compress(raw, level=level) except ImportError: # --stream-size records the content size in the frame header, as the library paths do (2026-11-13) return subprocess.run(["zstd", f"-{level}", "-q", "-c", f"--stream-size={len(raw)}"], input=raw, capture_output=True, check=True).stdout def decompress_frame(comp): try: import zstandard # decompressobj, not decompress(): frames written by the zstd CLI from a pipe (every build packed before # 2026-11-13) do not record their content size, and ZstdDecompressor.decompress() refuses those # ("could not determine content size in frame header"), found by the independent restore test on 2026-11-13 return zstandard.ZstdDecompressor().decompressobj().decompress(comp) except ImportError: pass try: from compression import zstd as _z # Python 3.14+ (no zstd install needed, e.g. on Windows) return _z.decompress(comp) except ImportError: return subprocess.run(["zstd", "-d", "-q", "-c"], input=comp, capture_output=True, check=True).stdout def platform_triple(): """Lean's own target triple for this machine (what `lean --version` prints), e.g. x86_64-unknown-linux-gnu, aarch64-apple-darwin, x86_64-w64-windows-gnu. Windows was 'pc-windows-msvc' before 2026-11-10; no Windows build was ever keyed with it.""" m = _pf.machine().lower() arch = {"amd64": "x86_64", "x86_64": "x86_64", "aarch64": "aarch64", "arm64": "aarch64"}.get(m, m) osn = {"linux": "unknown-linux-gnu", "darwin": "apple-darwin", "win32": "w64-windows-gnu"}.get(sys.platform, sys.platform) return f"{arch}-{osn}" # ---------------------------------------------------------------- licence detection (gate G5) LICENSE_NAME = re.compile(r"(?i)^(licen[cs]e|copying)([.\-_].*)?$") def classify_license(text): """SPDX id for the two licences the cache redistributes, else UNKNOWN (a licence file that is neither).""" t = " ".join(text.split()).lower() if "apache license" in t and "version 2.0" in t: return "Apache-2.0" if "mit license" in t or "permission is hereby granted, free of charge" in t: return "MIT" return "UNKNOWN" def detect_license(pkg_dir): """Licence of the package in `pkg_dir`: {"spdx", "file", "from"}. Looks for LICENSE / LICENCE / COPYING (any case, any extension) in the package directory, then in each parent up to the top of the git repository that contains it. A Lake project kept in a subdirectory (openai/math `lean/`, RogersRamanujan-artifacts/) is covered by its repository's licence file; before 2026-11-09 only the package directory was searched and such packages were skipped as NONE. The search never leaves the repository: a dependency checkout under .lake/packages is its own repository, so it never inherits the consumer's licence. """ d = os.path.abspath(pkg_dir) r = subprocess.run(["git", "-C", d, "rev-parse", "--show-toplevel"], capture_output=True, text=True) top = os.path.abspath(r.stdout.strip()) if r.returncode == 0 and r.stdout.strip() else d try: inside = os.path.commonpath([os.path.normcase(top), os.path.normcase(d)]) == os.path.normcase(top) except ValueError: inside = False if not inside: top = d cur = d while True: try: names = sorted(n for n in os.listdir(cur) if LICENSE_NAME.match(n) and os.path.isfile(os.path.join(cur, n))) except OSError: names = [] if names: f = os.path.join(cur, names[0]) with open(f, encoding="utf-8", errors="replace") as fh: spdx = classify_license(fh.read()) return {"spdx": spdx, "file": f, "from": "package" if cur == d else "repository"} if os.path.normcase(cur) == os.path.normcase(top) or os.path.dirname(cur) == cur: return {"spdx": "NONE", "file": None, "from": None} cur = os.path.dirname(cur) def cmd_license(a): print(json.dumps(detect_license(a.package_dir))) # ---------------------------------------------------------------- build keys def read_manifest(d): p = os.path.join(d, "lake-manifest.json") if not os.path.exists(p): return None with open(p, encoding="utf-8") as f: return json.load(f) def packages_dir(project_dir): root = read_manifest(project_dir) or {} return os.path.join(project_dir, root.get("packagesDir", ".lake/packages")) def package_dir(project_dir, name): """Directory of a package: the project itself, a local path dependency (manifest "dir"), or .lake/packages/.""" root = read_manifest(project_dir) or {} if name == root.get("name"): return project_dir for p in root.get("packages", []): if p.get("name") == name and p.get("type") == "path" and p.get("dir"): return os.path.normpath(os.path.join(project_dir, p["dir"])) d = os.path.join(packages_dir(project_dir), name) # Lake drops the «» quotes of a package name in its directory name (.lake/packages/doc-gen4 for «doc-gen4») plain = os.path.join(packages_dir(project_dir), name.strip("«»")) return d if os.path.isdir(d) or not os.path.isdir(plain) else plain def closure(project_dir, package=None): """(name, rev) closure of `package` (default: root) using the root manifest's revisions.""" root = read_manifest(project_dir) if root is None: raise SystemExit(f"no lake-manifest.json in {project_dir}") revs = {p["name"]: p.get("rev", "") for p in root.get("packages", [])} root_name = root.get("name") root_rev = subprocess.run(["git", "-C", project_dir, "rev-parse", "HEAD"], capture_output=True, text=True).stdout.strip() if package in (None, root_name): names = set(revs) own = (root_name, root_rev) else: if package not in revs: raise SystemExit(f"{package} not in the root manifest") pm = read_manifest(package_dir(project_dir, package)) names = {p["name"] for p in (pm or {}).get("packages", [])} missing = sorted(n for n in names if n not in revs) if missing: raise SystemExit(f"{package} requires packages absent from the root manifest: {missing}") own = (package, revs[package]) return sorted({(n, revs[n]) for n in names} | {own}) def build_key(toolchain, plat, cl, changes=None): s = f"{KEY_TAG}\n{toolchain}\n{plat}\n" + json.dumps(cl, separators=(",", ":")) if changes: # sources that differ from their pinned commit (e.g. a project's dependency patches): a different build s += "\nsource-changes:" + json.dumps(sorted(changes.items()), separators=(",", ":")) return hashlib.sha256(s.encode()).hexdigest()[:16] def source_changes(project_dir, cl): """{package: sha256[:16]} for every non-root package in the closure whose checkout differs from its pinned commit (git diff against HEAD plus untracked files, outside .lake). Empty for unmodified checkouts, so their keys are unchanged. A dependency patched by the project (openai/math lean/patches) gets a key of its own, and so does every package built on top of it.""" root = (read_manifest(project_dir) or {}).get("name") out = {} for name, _rev in cl: if name == root: continue d = package_dir(project_dir, name) if not os.path.exists(os.path.join(d, ".git")): continue spec = ["--", ".", ":(exclude).lake"] diff = subprocess.run(["git", "-C", d, "diff", "--binary", "HEAD"] + spec, capture_output=True).stdout unt = subprocess.run(["git", "-C", d, "ls-files", "--others", "--exclude-standard", "-z"] + spec, capture_output=True).stdout.split(b"\0") unt = sorted(u for u in unt if u) if not diff and not unt: continue h = hashlib.sha256(diff) for u in unt: h.update(b"\0" + u + b"\0") with open(os.path.join(d, u.decode()), "rb") as f: h.update(f.read()) out[name] = h.hexdigest()[:16] return out def key_for(project_dir, package=None): """(build key, closure, source changes) of a package in a project checkout.""" tc, plat = toolchain_of(project_dir), platform_triple() cl = closure(project_dir, package) ch = source_changes(project_dir, cl) return build_key(tc, plat, cl, ch), cl, ch def toolchain_of(project_dir): with open(os.path.join(project_dir, "lean-toolchain"), encoding="utf-8") as f: return f.read().strip() # ---------------------------------------------------------------- imports MODIFIERS = {"public", "private", "meta"} def parse_imports(path): """Module names imported by a Lean source file's header, or None if the file is missing. The header is read as a token stream, as Lean's grammar does: `module`? `prelude`? then any number of `[public|private|meta]* import [all|runtime]? `, where the identifier may sit on a later line. The header ends at the first token that does not fit. """ try: text = open(path, encoding="utf-8", errors="replace").read() except FileNotFoundError: return None text = re.sub(r"/-.*?-/", " ", text, flags=re.S) text = "\n".join(line.split("--", 1)[0] for line in text.splitlines()) toks = text.split() out, i = [], 0 while i < len(toks) and toks[i] in ("module", "prelude"): i += 1 while i < len(toks): j = i while j < len(toks) and toks[j] in MODIFIERS: j += 1 if j >= len(toks) or toks[j] != "import": break j += 1 while j < len(toks) and toks[j] in ("all", "runtime"): j += 1 if j >= len(toks): break out.append(toks[j]) i = j + 1 return out def cmd_reindex(a): """Rewrite shards/modules.jsonl of a staged build from its index and the package sources, then SHA256SUMS.""" out, pkg_dir = os.path.abspath(a.staging_dir), os.path.abspath(a.package_dir) man, idx = load(out) mod_shard = {} for e in idx.values(): if e["module"]: mod_shard.setdefault(e["module"], set()).add(e["shard"]) mods = sorted({e["module"] for e in idx.values() if e["module"] and e["path"].endswith(".olean")}) unparsed = 0 with open(os.path.join(out, "shards", "modules.jsonl"), "w", encoding="utf-8", newline="\n") as f: for m in mods: imps = parse_imports(os.path.join(pkg_dir, *m.split(".")) + ".lean") unparsed += imps is None f.write(json.dumps({"module": m, "shards": sorted(mod_shard.get(m, [])), "imports": imps}, separators=(",", ":")) + "\n") if "modules_index" not in man.get("features", []) or man.get("modules_without_source") != unparsed: man.setdefault("features", []).append("modules_index") if "modules_index" not in man.get("features", []) else None man["modules_without_source"] = unparsed with open(os.path.join(out, "manifest.json"), "w", encoding="utf-8", newline="\n") as f: json.dump(man, f, indent=1) write_sums(out) print(json.dumps({"package": man["package"], "modules": len(mods), "modules_without_source": unparsed})) # ---------------------------------------------------------------- pack def module_of(rel): """Module name for a build file, or None for package-level files.""" for pre in (".lake/build/lib/lean/", ".lake/build/ir/"): if rel.startswith(pre): parts = rel[len(pre):].split("/") return ".".join(parts[:-1] + [parts[-1].split(".")[0]]) return None def list_build_files(package_dir, exclude_setup_json): root = os.path.join(package_dir, ".lake", "build") if not os.path.isdir(root): raise SystemExit(f"no .lake/build under {package_dir}") out, skipped = [], [] for dp, dns, fns in os.walk(root, followlinks=False): dns.sort() for fn in fns: full = os.path.join(dp, fn) rel = os.path.relpath(full, package_dir).replace(os.sep, "/") if os.path.islink(full) or not os.path.isfile(full): skipped.append((rel, "not a regular file")); continue if exclude_setup_json and rel.endswith(".setup.json"): skipped.append((rel, "setup.json excluded")); continue out.append(rel) return out, skipped def deterministic_info(rel, size, executable): ti = tarfile.TarInfo(rel) ti.size, ti.mtime, ti.uid, ti.gid, ti.uname, ti.gname = size, 0, 0, 0, "", "" ti.mode = 0o755 if executable else 0o644 ti.type = tarfile.REGTYPE return ti def cmd_pack(a): pkg_dir = os.path.abspath(a.package_dir) out = os.path.abspath(a.out_dir) files, skipped = list_build_files(pkg_dir, a.exclude_setup_json) if not files: # e.g. a project with no default targets: `lake build` exits 0 and builds nothing. Fail before creating the # output folder, so the caller sees a non-zero exit and no half-made build folder (2026-11-10). raise SystemExit(f"no build outputs under {pkg_dir}/.lake/build: nothing to pack") os.makedirs(os.path.join(out, "shards"), exist_ok=False) keyed = sorted(files, key=lambda r: ((module_of(r) or ""), r.encode())) toolchain = a.toolchain or toolchain_of(a.project_dir) plat = platform_triple() rootname = read_manifest(a.project_dir).get("name") cl = closure(a.project_dir, None if a.package == rootname else a.package) changes = source_changes(a.project_dir, cl) key = build_key(toolchain, plat, cl, changes) shards, index, mod_shard, frames = [], [], {}, [] # one frame per module (package-level files first, as module None): a deterministic tar, compressed as its own # zstd frame. Frames are appended to the current shard; a shard is a valid multi-frame zstd file. groups = [] for rel in keyed: mod = module_of(rel) if not groups or groups[-1][0] != mod: groups.append((mod, [])) groups[-1][1].append(rel) def build_tar(group): mod, rels = group buf = io.BytesIO(); ents = [] with tarfile.open(fileobj=buf, mode="w", format=tarfile.GNU_FORMAT) as tf: for rel in rels: full = os.path.join(pkg_dir, rel) with open(full, "rb") as f: data = f.read() tf.addfile(deterministic_info(rel, len(data), os.access(full, os.X_OK)), io.BytesIO(data)) ents.append((rel, hashlib.sha256(data).hexdigest(), len(data))) raw = buf.getvalue() return mod, ents, len(raw), compress_frame(raw, a.level) from concurrent.futures import ThreadPoolExecutor workers = max(1, os.cpu_count() or 1) st = {"f": None, "name": None, "off": 0, "raw": 0, "files": 0, "first": None, "last": None, "h": None} def close_shard(): st["f"].close() p = os.path.join(out, st["name"]) shards.append({"name": st["name"], "sha256": st["h"].hexdigest(), "bytes": os.path.getsize(p), "bytes_uncompressed": st["raw"], "files": st["files"], "first_module": st["first"], "last_module": st["last"]}) total = 0 with ThreadPoolExecutor(workers) as ex: for i in range(0, len(groups), 4 * workers): for mod, ents, rawlen, comp in ex.map(build_tar, groups[i:i + 4 * workers]): if st["f"] is None or st["raw"] >= a.shard_bytes: if st["f"] is not None: close_shard() st["name"] = f"shards/part-{len(shards):05d}.tar.zst" st["f"] = open(os.path.join(out, st["name"]), "wb") st.update(off=0, raw=0, files=0, first=mod, h=hashlib.sha256()) st["f"].write(comp); st["h"].update(comp) frames.append({"shard": st["name"], "offset": st["off"], "length": len(comp), "raw_length": rawlen, "module": mod, "files": len(ents), "sha256": hashlib.sha256(comp).hexdigest()}) for rel, h, size in ents: index.append({"path": rel, "sha256": h, "bytes": size, "shard": st["name"], "module": mod}) total += size if mod: mod_shard.setdefault(mod, set()).add(st["name"]) st["off"] += len(comp); st["raw"] += rawlen; st["files"] += len(ents); st["last"] = mod if st["f"] is not None: close_shard() with open(os.path.join(out, "shards", "frames.jsonl"), "w", encoding="utf-8", newline="\n") as f: for e in frames: f.write(json.dumps(e, separators=(",", ":")) + "\n") with open(os.path.join(out, "shards", "index.jsonl"), "w", encoding="utf-8", newline="\n") as f: for e in index: f.write(json.dumps(e, separators=(",", ":")) + "\n") mods = sorted({e["module"] for e in index if e["module"] and e["path"].endswith(".olean")}) unparsed = 0 with open(os.path.join(out, "shards", "modules.jsonl"), "w", encoding="utf-8", newline="\n") as f: for m in mods: imps = parse_imports(os.path.join(pkg_dir, *m.split(".")) + ".lean") unparsed += imps is None f.write(json.dumps({"module": m, "shards": sorted(mod_shard.get(m, [])), "imports": imps}, separators=(",", ":")) + "\n") man = { "schema": SCHEMA, "features": ["modules_index", "module_frames"], "frames": len(frames), "package": a.package, "source_repo": a.source_repo, "commit": a.commit, "license": a.license, "toolchain": toolchain, "platform": plat, "build_key": key, "closure": [list(x) for x in cl], "modules_built": len(mods), "modules_without_source": unparsed, "files": len(index), "bytes_uncompressed": total, "bytes_compressed": sum(s["bytes"] for s in shards), "shard_target_bytes_uncompressed": a.shard_bytes, "shards": shards, "zstd_level": a.level, "excluded": {"setup_json": bool(a.exclude_setup_json), "skipped": skipped[:50], "skipped_count": len(skipped)}, "packed_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), "unofficial": True, } if changes: man["source_changes"] = changes # packages built from sources that differ from their pinned commit with open(os.path.join(a.project_dir, "lake-manifest.json"), "rb") as s, open(os.path.join(out, "lake-manifest.json"), "wb") as d: d.write(s.read()) # manifest.json is the LAST file written, and it appears in one step: a build folder with a manifest is complete, # one without is an interrupted pack (build-group.sh repacks it). SHA256SUMS.txt already lists the manifest's hash. man_bytes = json.dumps(man, indent=1).encode("utf-8") write_sums(out, extra={"manifest.json": hashlib.sha256(man_bytes).hexdigest()}) tmp = os.path.join(out, "manifest.json.lbc-tmp") with open(tmp, "wb") as f: f.write(man_bytes) os.replace(tmp, os.path.join(out, "manifest.json")) print(json.dumps({k: man[k] for k in ("package", "build_key", "modules_built", "modules_without_source", "files", "bytes_uncompressed", "bytes_compressed")} | {"shards": len(shards)})) def write_sums(out, extra=None): """SHA256SUMS.txt over every file in the build folder; `extra` adds rows for files written afterwards.""" rows = dict(extra or {}) for dp, _, fns in os.walk(out): for fn in sorted(fns): if fn != "SHA256SUMS.txt" and not fn.endswith(".lbc-tmp"): p = os.path.join(dp, fn) rows.setdefault(os.path.relpath(p, out).replace(os.sep, "/"), sha256_file(p)) with open(os.path.join(out, "SHA256SUMS.txt"), "w", encoding="utf-8", newline="\n") as f: for r, h in sorted(rows.items()): f.write(f"{h} {r}\n") # ---------------------------------------------------------------- check, unpack def load(staging): with open(os.path.join(staging, "manifest.json"), encoding="utf-8") as f: man = json.load(f) idx = {} with open(os.path.join(staging, "shards", "index.jsonl"), encoding="utf-8") as f: for line in f: if line.strip(): e = json.loads(line); idx[e["path"]] = e return man, idx def cmd_check(a): man, idx = load(a.staging_dir) bad = [s["name"] for s in man["shards"] if sha256_file(os.path.join(a.staging_dir, s["name"])) != s["sha256"]] for b in bad: print(f"MISMATCH {b}") print(f"shards={len(man['shards'])} bad={len(bad)} files_in_index={len(idx)}") sys.exit(1 if bad else 0) def safe_rel(name): parts = name.split("/") return (name.startswith(".lake/build/") and not name.startswith("/") and "\\" not in name and all(p not in ("", ".", "..") for p in parts)) def write_member(dest, name, data, mode, now): out = os.path.join(dest, *name.split("/")) os.makedirs(os.path.dirname(out), exist_ok=True) tmp = out + ".lbc-tmp" with open(tmp, "wb") as f: f.write(data) os.chmod(tmp, mode & 0o777) os.replace(tmp, out) os.utime(out, (now, now)) def check_member(m, idx, shard_name, data): if not m.isreg() or not safe_rel(m.name): raise SystemExit(f"refusing unsafe member {m.name!r} in {shard_name}") e = idx.get(m.name) if e is None or e["shard"] != shard_name: raise SystemExit(f"member not in index for this shard: {m.name}") if hashlib.sha256(data).hexdigest() != e["sha256"] or len(data) != e["bytes"]: raise SystemExit(f"file hash mismatch: {m.name}") def extract_shard(shard_path, shard_name, idx, dest, now): """Legacy builds (one zstd stream per shard): stream the whole shard.""" n = 0 # resolve symlinks first: the Hugging Face cache hands back a symlink, and zstd silently skips symlinks z = subprocess.Popen(["zstd", "-d", "-q", "-c", os.path.realpath(shard_path)], stdout=subprocess.PIPE) with tarfile.open(fileobj=z.stdout, mode="r|") as tf: for m in tf: data = tf.extractfile(m).read() if m.isreg() else b"" check_member(m, idx, shard_name, data) write_member(dest, m.name, data, m.mode, now) n += 1 if z.wait() != 0: raise SystemExit(f"zstd failed on {shard_name}") return n def extract_frame(comp, fr, idx, dest, now): """Verify one module frame (compressed hash, raw length), then extract its tar with per-file hash checks.""" if len(comp) != fr["length"] or hashlib.sha256(comp).hexdigest() != fr["sha256"]: raise SystemExit(f"frame hash mismatch: {fr['shard']} offset {fr['offset']} ({fr['module']})") raw = decompress_frame(comp) if len(raw) != fr["raw_length"]: raise SystemExit(f"frame length mismatch: {fr['module']}") n = 0 with tarfile.open(fileobj=io.BytesIO(raw), mode="r:") as tf: for m in tf.getmembers(): data = tf.extractfile(m).read() if m.isreg() else b"" check_member(m, idx, fr["shard"], data) if idx[m.name]["module"] != fr["module"]: raise SystemExit(f"member {m.name} is not in module {fr['module']}") write_member(dest, m.name, data, m.mode, now) n += 1 if n != fr["files"]: raise SystemExit(f"frame {fr['module']}: extracted {n} files, index says {fr['files']}") return n def load_frames(path): out = [] for line in open(path, encoding="utf-8"): if line.strip(): out.append(json.loads(line)) return out def extract_frames_from_file(path, frames, idx, dest, now): n = 0 with open(os.path.realpath(path), "rb") as f: for fr in frames: f.seek(fr["offset"]) n += extract_frame(f.read(fr["length"]), fr, idx, dest, now) return n def cmd_unpack(a): man, idx = load(a.staging_dir) framed = "module_frames" in man.get("features", []) frames = load_frames(os.path.join(a.staging_dir, "shards", "frames.jsonl")) if framed else [] want = set(a.shards.split(",")) if a.shards else None dest, now, seen, used = os.path.abspath(a.package_dir), time.time(), 0, 0 for s in man["shards"]: if want is not None and s["name"] not in want and os.path.basename(s["name"]) not in want: continue sp = os.path.join(a.staging_dir, s["name"]) if sha256_file(sp) != s["sha256"]: raise SystemExit(f"shard hash mismatch: {s['name']}") if framed: got = extract_frames_from_file(sp, [fr for fr in frames if fr["shard"] == s["name"]], idx, dest, now) else: got = extract_shard(sp, s["name"], idx, dest, now) if got != s["files"]: raise SystemExit(f"{s['name']}: extracted {got} files, manifest says {s['files']}") seen += got used += 1 if want is None and seen != len(idx): raise SystemExit(f"extracted {seen} files, index has {len(idx)}") print(f"unpacked {seen} files from {used} of {len(man['shards'])} shards into {dest} (all sha256 verified)") # ---------------------------------------------------------------- strip (2026-11-12) STRIP_DEFAULT = r"^\.lake/build/bin/" def cmd_strip(a): """Remove files matching --pattern (default: everything under .lake/build/bin/, i.e. the executables and their response, trace and hash files) from a staged build folder, in place, without rebuilding. Only the frames that hold such files are rewritten; every other frame keeps its bytes, so the other shards keep their hashes. frames.jsonl offsets, index.jsonl, the manifest (shard hashes, sizes, file counts) and SHA256SUMS.txt are updated, and the manifest records what was removed under "stripped". The build key does not change: it is computed from the toolchain, platform and dependency closure, not from the contents. User decision 2026-11-12: strip native executables from the public builds; libraries (.so, .a, .o) stay because Lake needs them for the packages' own library targets.""" d = os.path.abspath(a.staging_dir) pat = re.compile(a.pattern or STRIP_DEFAULT) man, idx = load(d) gone = sorted(p for p in idx if pat.search(p)) if not gone: print(json.dumps({"stripped": 0})); return gone_set = set(gone) if "module_frames" not in man.get("features", []): # legacy build (one zstd stream per shard, packed before 2026-11-09): rewrite each affected shard whole removed_bytes = 0 for s in man["shards"]: if not any(idx[p]["shard"] == s["name"] for p in gone): continue sp = os.path.join(d, s["name"]) if sha256_file(sp) != s["sha256"]: raise SystemExit(f"shard hash mismatch before strip: {s['name']}") raw = subprocess.run(["zstd", "-d", "-q", "-c", sp], capture_output=True, check=True).stdout buf, n = io.BytesIO(), 0 with tarfile.open(fileobj=io.BytesIO(raw), mode="r:") as tf, \ tarfile.open(fileobj=buf, mode="w", format=tarfile.GNU_FORMAT) as tw: for m in tf.getmembers(): if m.name in gone_set: removed_bytes += m.size; continue data = tf.extractfile(m).read() if m.isreg() else b"" tw.addfile(deterministic_info(m.name, len(data), bool(m.mode & 0o111)), io.BytesIO(data)) n += 1 comp = compress_frame(buf.getvalue(), man.get("zstd_level", 19)) with open(sp + ".lbc-tmp", "wb") as f: f.write(comp) os.replace(sp + ".lbc-tmp", sp) s.update(sha256=hashlib.sha256(comp).hexdigest(), bytes=len(comp), files=n) if "bytes_uncompressed" in s: s["bytes_uncompressed"] = len(buf.getvalue()) new_frames = None else: new_frames, removed_bytes = _strip_frames(d, man, idx, gone, gone_set) _strip_finish(d, man, idx, gone, gone_set, new_frames, removed_bytes, pat) def _strip_frames(d, man, idx, gone, gone_set): frames = load_frames(os.path.join(d, "shards", "frames.jsonl")) by_shard = {} for fr in frames: by_shard.setdefault(fr["shard"], []).append(fr) new_frames, removed_bytes = [], 0 for s in man["shards"]: frs = sorted(by_shard.get(s["name"], []), key=lambda f: f["offset"]) if not any(idx[p]["shard"] == s["name"] for p in gone): new_frames += frs; continue sp = os.path.join(d, s["name"]) if sha256_file(sp) != s["sha256"]: raise SystemExit(f"shard hash mismatch before strip: {s['name']}") blob = open(sp, "rb").read() out, off, h, raw_total, nfiles = io.BytesIO(), 0, hashlib.sha256(), 0, 0 for fr in frs: comp = blob[fr["offset"]:fr["offset"] + fr["length"]] if hashlib.sha256(comp).hexdigest() != fr["sha256"]: raise SystemExit(f"frame hash mismatch: {fr['shard']} {fr['offset']}") raw = decompress_frame(comp) keep_n = fr["files"] with tarfile.open(fileobj=io.BytesIO(raw), mode="r:") as tf: members = tf.getmembers() if any(m.name in gone_set for m in members): buf = io.BytesIO() with tarfile.open(fileobj=buf, mode="w", format=tarfile.GNU_FORMAT) as tw: keep_n = 0 for m in members: if m.name in gone_set: removed_bytes += m.size; continue data = tf.extractfile(m).read() if m.isreg() else b"" tw.addfile(deterministic_info(m.name, len(data), bool(m.mode & 0o111)), io.BytesIO(data)) keep_n += 1 raw = buf.getvalue() comp = compress_frame(raw, man.get("zstd_level", 19)) if keep_n else b"" if not comp: continue # a frame that held only stripped files disappears out.write(comp); h.update(comp) new_frames.append(dict(fr, offset=off, length=len(comp), raw_length=len(raw), files=keep_n, sha256=hashlib.sha256(comp).hexdigest())) off += len(comp); raw_total += len(raw); nfiles += keep_n tmp = sp + ".lbc-tmp" with open(tmp, "wb") as f: f.write(out.getvalue()) os.replace(tmp, sp) s.update(sha256=h.hexdigest(), bytes=off, bytes_uncompressed=raw_total, files=nfiles) return new_frames, removed_bytes def _strip_finish(d, man, idx, gone, gone_set, new_frames, removed_bytes, pat): index = [e for p, e in idx.items() if p not in gone_set] if new_frames is not None: with open(os.path.join(d, "shards", "frames.jsonl"), "w", encoding="utf-8", newline="\n") as f: for e in new_frames: f.write(json.dumps(e, separators=(",", ":")) + "\n") man["frames"] = len(new_frames) with open(os.path.join(d, "shards", "index.jsonl"), "w", encoding="utf-8", newline="\n") as f: for e in index: f.write(json.dumps(e, separators=(",", ":")) + "\n") man["files"] = len(index) man["bytes_uncompressed"] = sum(e["bytes"] for e in index) man["bytes_compressed"] = sum(s["bytes"] for s in man["shards"]) man.setdefault("stripped", []).append({"at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), "pattern": pat.pattern, "files": gone, "bytes": removed_bytes, "reason": "native executables are not redistributed (decision 2026-11-12)"}) man_bytes = json.dumps(man, indent=1).encode("utf-8") write_sums(d, extra={"manifest.json": hashlib.sha256(man_bytes).hexdigest()}) tmp = os.path.join(d, "manifest.json.lbc-tmp") with open(tmp, "wb") as f: f.write(man_bytes) os.replace(tmp, os.path.join(d, "manifest.json")) print(json.dumps({"stripped": len(gone), "bytes": removed_bytes, "files_left": len(index), "bytes_compressed": man["bytes_compressed"]})) # ---------------------------------------------------------------- fetch from Hugging Face def _resolve(url, token): """Follow the Hub's redirect once by hand, so the CDN gets no Authorization header; return (url, needs_auth).""" import urllib.request import urllib.error class NoRedirect(urllib.request.HTTPRedirectHandler): def redirect_request(self, *args, **kw): return None req = urllib.request.Request(url, method="HEAD", headers={"Authorization": f"Bearer {token}"} if token else {}) try: urllib.request.build_opener(NoRedirect).open(req, timeout=60) return url, True except urllib.error.HTTPError as e: if e.code in (301, 302, 303, 307, 308) and e.headers.get("Location"): from urllib.parse import urljoin return urljoin(url, e.headers["Location"]), False raise def _range_get(url, start, end, token, with_auth): import urllib.request h = {"Range": f"bytes={start}-{end}"} if with_auth and token: h["Authorization"] = f"Bearer {token}" for attempt in range(4): try: with urllib.request.urlopen(urllib.request.Request(url, headers=h), timeout=300) as r: body = r.read() if r.status == 200: # the server ignored the range: slice the whole body body = body[start:end + 1] if len(body) != end - start + 1: raise IOError(f"short range read {len(body)} of {end - start + 1}") return body except Exception: if attempt == 3: raise time.sleep(2 * (attempt + 1)) def cmd_fetch(a): from huggingface_hub import hf_hub_download, hf_hub_url, get_token from concurrent.futures import ThreadPoolExecutor proj = os.path.abspath(a.project_dir) root = read_manifest(proj) if root is None: raise SystemExit("no lake-manifest.json: run `lake exe cache get` (or `lake update`) in the project first") tc, plat = toolchain_of(proj), platform_triple() pkgs = [root["name"]] + [p["name"] for p in root.get("packages", []) if p["name"] not in STD] # Mathlib and the other standard packages normally come from Mathlib's own cache. When that cache has nothing for # this project (its Lean version differs from Mathlib's, as for fermats-last-theorem), they are fetched from here # too: any standard package that is checked out and has a published build for its exact key, unless it already has # at least as many compiled modules as that build (then Mathlib's cache provided it). `lake exe cache get` compiles # a few Mathlib and Batteries modules for its own tool, so "has some .olean files" is not the test. def n_oleans(d): lib = os.path.join(d, ".lake", "build", "lib") return sum(f.endswith(".olean") for _, _, fs in os.walk(lib) for f in fs) if os.path.isdir(lib) else 0 std_missing = [p["name"] for p in root.get("packages", []) if p["name"] in STD and os.path.isdir(package_dir(proj, p["name"]))] if a.package: pkgs = [p for p in pkgs if p in set(a.package)] std_missing = [p for p in std_missing if p in set(a.package)] # Lake checks out only the dependencies the project's targets need (teorth/analysis lists doc-gen4 and its # dependencies, which `lake exe cache get` leaves out). Such a package is skipped with a note, not an error # (found by the independent restore test on 2026-11-13; before, fetch stopped here). missing_deps = [p for p in pkgs if p != root["name"] and not os.path.isdir(package_dir(proj, p))] for p in missing_deps: print(f"{p}: not checked out by Lake (not needed by this project's targets); skipped") pkgs = [p for p in pkgs if p not in missing_deps] if not os.path.isdir(packages_dir(proj)) and len(root.get("packages", [])) > 0 and missing_deps: print("note: no dependency is checked out; run `lake exe cache get` (or `lake env true`) first if the build fails") cache = os.path.join(proj, ".lake", "lbc-cache") token = get_token() cat_path = hf_hub_download(f"{a.namespace}/lean-builds-index", "catalog/builds.jsonl", repo_type="dataset", cache_dir=cache) catalog = {} for line in open(cat_path, encoding="utf-8"): if line.strip(): r = json.loads(line) catalog[r["build_key"]] = r builds = {} for p in pkgs + std_missing: pdir = package_dir(proj, p) key = key_for(proj, None if p == root["name"] else p)[0] row = catalog.get(key) if p in std_missing: if row is None: continue # the usual case: Mathlib's own cache serves it if n_oleans(pdir) >= int(row.get("modules") or 0): print(f"{p}: already compiled ({n_oleans(pdir)} modules); not fetched") continue if row is None: print(f"{p}: no published build for key {key} (toolchain {tc}, platform {plat}); build it locally") continue get = lambda f, r=row: hf_hub_download(r["hf_repo"], f"{r['hf_path']}/{f}", repo_type="dataset", cache_dir=cache) mp = get("manifest.json") if sha256_file(mp) != row["manifest_sha256"]: raise SystemExit(f"{p}: manifest hash differs from the catalog") man = json.load(open(mp, encoding="utf-8")) idx = {} for line in open(get("shards/index.jsonl"), encoding="utf-8"): if line.strip(): e = json.loads(line) idx[e["path"]] = e feats = man.get("features", []) mods = {} if "modules_index" in feats: for line in open(get("shards/modules.jsonl"), encoding="utf-8"): if line.strip(): e = json.loads(line) mods[e["module"]] = e frames = load_frames(get("shards/frames.jsonl")) if "module_frames" in feats else None builds[p] = {"row": row, "man": man, "idx": idx, "mods": mods, "frames": frames, "dir": pdir, "get": get} owner = {m: p for p, b in builds.items() for m in b["mods"]} whole, need = set(), set() if a.module: todo = list(a.module) while todo: m = todo.pop() if m in need or m not in owner: continue need.add(m) imps = builds[owner[m]]["mods"][m]["imports"] if imps is None: whole.add(owner[m]) else: todo += imps for m in a.module: if m not in owner: print(f"note: {m} is not in any fetched build index (Mathlib, core, or not published)") now = time.time() tot_b = tot_all = 0 for p, b in builds.items(): man, frames = b["man"], b["frames"] allb = sum(s["bytes"] for s in man["shards"]) tot_all += allb partial = bool(a.module) and p not in whole and bool(b["mods"]) pneed = {m for m in need if owner.get(m) == p} if partial else None if partial and not pneed: print(f"{p}: nothing needed") continue if frames is not None: sel = [fr for fr in frames if not partial or fr["module"] is None or fr["module"] in pneed] size = sum(fr["length"] for fr in sel) nsh = len({fr["shard"] for fr in sel}) else: if partial: shards = {s for m in pneed for s in b["mods"][m]["shards"]} shards |= {e["shard"] for e in b["idx"].values() if e["module"] is None} else: shards = {s["name"] for s in man["shards"]} sel = [s for s in man["shards"] if s["name"] in shards] size = sum(s["bytes"] for s in sel) nsh = len(sel) tot_b += size print(f"{p}: {size/1e6:.1f} of {allb/1e6:.1f} MB from {nsh} of {len(man['shards'])} shards" + (f", {len(pneed)} of {len(b['mods'])} modules" if partial else "")) if a.dry_run: continue if frames is None: for s in sel: sp = b["get"](s["name"]) if sha256_file(sp) != s["sha256"]: raise SystemExit(f"{p}: shard hash mismatch {s['name']}") if extract_shard(sp, s["name"], b["idx"], b["dir"], now) != s["files"]: raise SystemExit(f"{p}: {s['name']} file count mismatch") continue by_shard = {} for fr in sel: by_shard.setdefault(fr["shard"], []).append(fr) shard_bytes = {s["name"]: s["bytes"] for s in man["shards"]} for sh, frs in sorted(by_shard.items()): frs.sort(key=lambda fr: fr["offset"]) need_b = sum(fr["length"] for fr in frs) if not partial or need_b > 0.6 * shard_bytes[sh]: sp = b["get"](sh) # most of the shard is needed: one whole download, cached by the Hub client extract_frames_from_file(sp, frs, b["idx"], b["dir"], now) continue url, direct = _resolve(hf_hub_url(b["row"]["hf_repo"], f"{b['row']['hf_path']}/{sh}", repo_type="dataset"), token) runs, cur = [], None for fr in frs: # frames closer than 256 KiB share one range request if cur and fr["offset"] - cur[1] <= 262144: cur[1] = fr["offset"] + fr["length"] cur[2].append(fr) else: cur = [fr["offset"], fr["offset"] + fr["length"], [fr]] runs.append(cur) def do_run(run, url=url, direct=direct, b=b): body = _range_get(url, run[0], run[1] - 1, token, direct) return sum(extract_frame(body[fr["offset"] - run[0]: fr["offset"] - run[0] + fr["length"]], fr, b["idx"], b["dir"], now) for fr in run[2]) with ThreadPoolExecutor(8) as ex: list(ex.map(do_run, runs)) print(f"TOTAL {tot_b/1e6:.1f} of {tot_all/1e6:.1f} MB" + (" (dry run, nothing written)" if a.dry_run else " fetched and verified")) if a.check and not a.dry_run: targets = ["+" + m for m in a.module] if a.module else [] r = subprocess.run(["lake", "build", "--no-build"] + targets, cwd=proj) sys.exit(r.returncode) def cmd_key(a): tc, plat = toolchain_of(a.project_dir), platform_triple() key, cl, ch = key_for(a.project_dir, a.package) print(json.dumps({"toolchain": tc, "platform": plat, "build_key": key, "closure": cl, "source_changes": ch}, indent=1)) def main(): ap = argparse.ArgumentParser(prog="lbc") sp = ap.add_subparsers(dest="cmd", required=True) k = sp.add_parser("key"); k.add_argument("project_dir"); k.add_argument("--package") p = sp.add_parser("pack"); p.add_argument("package_dir"); p.add_argument("out_dir") for opt in ("--package", "--commit", "--source-repo", "--license", "--project-dir"): p.add_argument(opt, required=True) p.add_argument("--toolchain"); p.add_argument("--shard-bytes", type=int, default=1_000_000_000) p.add_argument("--level", type=int, default=19); p.add_argument("--exclude-setup-json", action="store_true") u = sp.add_parser("unpack"); u.add_argument("staging_dir"); u.add_argument("package_dir"); u.add_argument("--shards") c = sp.add_parser("check"); c.add_argument("staging_dir") st = sp.add_parser("strip"); st.add_argument("staging_dir"); st.add_argument("--pattern") r = sp.add_parser("reindex"); r.add_argument("staging_dir"); r.add_argument("package_dir") d = sp.add_parser("pkgdir"); d.add_argument("project_dir"); d.add_argument("name") li = sp.add_parser("license"); li.add_argument("package_dir") f = sp.add_parser("fetch"); f.add_argument("project_dir"); f.add_argument("--module", action="append") f.add_argument("--package", action="append"); f.add_argument("--namespace", default="MoteMath") f.add_argument("--dry-run", action="store_true"); f.add_argument("--check", action="store_true") a = ap.parse_args() {"key": cmd_key, "pack": cmd_pack, "unpack": cmd_unpack, "check": cmd_check, "strip": cmd_strip, "fetch": cmd_fetch, "reindex": cmd_reindex, "license": cmd_license, "pkgdir": lambda a: print(package_dir(os.path.abspath(a.project_dir), a.name))}[a.cmd](a) if __name__ == "__main__": main()