cibuildmp 0.3.0__py3-none-any.whl

cibuildmp/__init__.py

@@ -0,0 +1,19 @@
+"""cibuildmp -- build MicroPython native C extensions on CI, and locally."""
+
+from __future__ import annotations
+
+import sys
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("cibuildmp")
+except PackageNotFoundError:  # running from a source tree, not installed
+    __version__ = "0.0.0.dev0"
+
+from .cli import main as _main
+
+__all__ = ["__version__", "main"]
+
+
+def main() -> None:
+    sys.exit(_main())

cibuildmp/__main__.py

@@ -0,0 +1,4 @@
+from cibuildmp import main
+
+if __name__ == "__main__":
+    main()

cibuildmp/build.py

@@ -0,0 +1,300 @@
+"""Running the build itself: pre-build command, make, collect, verify,
+package.
+
+Fails fast, one target at a time -- matching cibuildwheel's own
+build-in-container loop (platforms/linux.py), which lets a
+`subprocess.CalledProcessError` from one identifier abort the whole
+invocation rather than collecting per-target failures into a report.
+`cli.build()` already handles that: this module raises, cli.main() catches
+alongside SourceError/ToolchainError.
+
+Also cibuildwheel-shaped: `collect_output()`/`verify_output()` mirror its
+"exactly one artifact, or a named error" check (BuildProducedNoWheelError/
+RepairStepProducedMultipleWheelsError), and the BuildResult accumulated per
+target mirrors its BuildInfo summary line.
+
+No separate `cibuildmp publish` step (see docs/BACKLOG.md D14): each
+target's own directory under `output-dir` already holds everything mip
+needs -- the `.mpy`, any `extra-files` companions, and a `package.json` --
+the moment the build finishes. Assembling a ready-to-upload tree is as far
+as this goes; creating a release or uploading it stays the caller's own CI
+step, the same way cibuildwheel never runs `twine upload` itself.
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+import time
+from collections.abc import Sequence
+from dataclasses import dataclass
+from pathlib import Path
+
+from .options import BuildOptions
+from .targets import NATIVE_ARCH_CODE
+from .toolchains import ResolvedToolchain
+
+MPY_HEADER_MAGIC = ord("M")
+MPY_ARCH_FLAGS_BIT = 0x40
+
+
+class BuildError(Exception):
+    pass
+
+
+@dataclass(frozen=True)
+class BuildResult:
+    identifier: str
+    output: Path
+    duration: float
+
+    @property
+    def size(self) -> int:
+        return self.output.stat().st_size
+
+
+def make_command(
+    build_options: BuildOptions, mpy_dir: Path, module_root: Path
+) -> list[str]:
+    """The make invocation for one target.
+
+    PYTHON=<sys.executable> is what makes pyelftools/ar cibuildmp's own
+    dependencies rather than something installed at build time (D12):
+    py/dynruntime.mk assigns PYTHON with a plain `=`, never `override`, so
+    this wins over the `python3` it would otherwise default to -- the same
+    mechanism already used for CROSS= in toolchains.ResolvedToolchain.
+    """
+    return [
+        "make",
+        "-C",
+        str(module_root),
+        f"ARCH={build_options.target.arch}",
+        f"MPY_DIR={mpy_dir}",
+        f"PYTHON={sys.executable}",
+        *build_options.extra_make_args,
+        build_options.make_target,
+    ]
+
+
+def run_pre_build_command(module_root: Path, command: str, env: dict[str, str]) -> None:
+    if not command:
+        return
+    try:
+        subprocess.run(command, shell=True, cwd=module_root, env=env, check=True)
+    except subprocess.CalledProcessError as exc:
+        raise BuildError(f"pre-build-command failed: {command!r} ({exc})") from exc
+
+
+def run_make(
+    build_options: BuildOptions, mpy_dir: Path, module_root: Path, env: dict[str, str]
+) -> None:
+    # No cwd= here: `-C module_root` in the command itself already makes
+    # make chdir there, and module_root can be relative (it usually is --
+    # options.package_dir is often "."), so also passing it as cwd would
+    # chdir twice and have make look for module_root nested inside itself.
+    command = make_command(build_options, mpy_dir, module_root)
+    try:
+        subprocess.run(command, env=env, check=True)
+    except subprocess.CalledProcessError as exc:
+        raise BuildError(
+            f"{build_options.identifier}: `{' '.join(command)}` failed with exit "
+            f"code {exc.returncode}"
+        ) from exc
+
+
+def collect_output(build_options: BuildOptions, module_root: Path) -> Path:
+    """Find the one .mpy the `dist` target produced.
+
+    Every natmod Makefile in the wild drops it under build/<arch>*/ -- the
+    same layout build-natmod's own artifact-upload step already assumes
+    (`path: natmod/build/${{ matrix.arch }}*/`), not something cibuildmp
+    invents here.
+    """
+    arch = build_options.target.arch
+    candidates = sorted(module_root.glob(f"build/{arch}*/*.mpy"))
+    if not candidates:
+        raise BuildError(
+            f"{build_options.identifier}: `{build_options.make_target}` produced no "
+            f".mpy under {module_root}/build/{arch}*/"
+        )
+    if len(candidates) > 1:
+        names = ", ".join(p.name for p in candidates)
+        raise BuildError(
+            f"{build_options.identifier}: ambiguous output -- found "
+            f"{len(candidates)} .mpy files under {module_root}/build/{arch}*/: {names}"
+        )
+    return candidates[0]
+
+
+def _read_varint(data: bytes, offset: int) -> tuple[int, int]:
+    """MicroPython's own uint encoding: big-endian 7-bit groups, MSB=more.
+
+    Same format tools/mpy_ld.py's MPYOutput.write_uint() writes and
+    py/persistentcode.c's read_uint() reads. Returns (value, bytes consumed).
+    """
+    value = 0
+    consumed = 0
+    while True:
+        if offset + consumed >= len(data):
+            raise BuildError("truncated .mpy header (arch-flags field cut off)")
+        byte = data[offset + consumed]
+        value = (value << 7) | (byte & 0x7F)
+        consumed += 1
+        if not byte & 0x80:
+            return value, consumed
+
+
+def read_mpy_header(mpy_path: Path) -> tuple[int, int, int]:
+    """(MPY_VERSION, native-arch code, arch_flags) from a compiled .mpy.
+
+    Layout from tools/mpy_ld.py's build_mpy() / py/persistentcode.h: byte 0
+    is 'M', byte 1 is MPY_VERSION, byte 2 packs MPY_SUB_VERSION in bits 0-1,
+    the native-arch code in bits 2-6 (`MPY_FEATURE_DECODE_ARCH`, mask 0x2F
+    *after* the shift -- bit 6 is the arch-flags marker, not part of the
+    arch code, and must be excluded or a flagged file decodes as a bogus
+    arch), byte 3 is MP_SMALL_INT_BITS. A variable-length uint (arch_flags)
+    follows when that marker bit is set.
+    """
+    data = mpy_path.read_bytes()
+    if len(data) < 4 or data[0] != MPY_HEADER_MAGIC:
+        raise BuildError(f"{mpy_path}: does not look like a compiled .mpy (bad header)")
+    feat = data[2]
+    arch_code = (feat >> 2) & 0x2F
+    arch_flags = 0
+    if feat & MPY_ARCH_FLAGS_BIT:
+        arch_flags, _consumed = _read_varint(data, 4)
+    return data[1], arch_code, arch_flags
+
+
+def read_native_arch(mpy_path: Path) -> int:
+    """The MP_NATIVE_ARCH_* code baked into a native .mpy's own header."""
+    return read_mpy_header(mpy_path)[1]
+
+
+def verify_output(build_options: BuildOptions, mpy_path: Path) -> None:
+    """cibuildmp's equivalent of auditwheel: the header the linker actually
+    wrote must name the arch (and, for rv32imc, the arch-flags) this target
+    was building for, not just live in the right build/<arch>*/ directory --
+    catches "built the wrong thing into the right directory" the way a wheel
+    tag/platform mismatch would.
+
+    Exact match on arch_flags, not the "required subset of available" rule
+    mip applies when installing (micropython/micropython#19479) -- that
+    rule is about whether a *device* can run this file; this check is about
+    whether the *linker* encoded what the config actually asked for.
+    """
+    target = build_options.target
+    _version, actual_arch, actual_flags = read_mpy_header(mpy_path)
+    expected_arch = NATIVE_ARCH_CODE[target.arch]
+    if actual_arch != expected_arch:
+        raise BuildError(
+            f"{build_options.identifier}: {mpy_path.name}'s header encodes native "
+            f"arch code {actual_arch}, expected {expected_arch} ({target.arch})"
+        )
+    if actual_flags != target.arch_flags:
+        raise BuildError(
+            f"{build_options.identifier}: {mpy_path.name}'s header encodes "
+            f"arch_flags {actual_flags:#x}, expected {target.arch_flags:#x}"
+        )
+
+
+def output_name(build_options: BuildOptions, mpy_path: Path) -> str:
+    # Identifier-qualified even though the file already lives in its own
+    # identifier/ directory: package.json's own urls stay unambiguous even
+    # if a caller later flattens several identifiers' directories into one
+    # namespace (e.g. a GitHub Release's own asset list, which cannot nest
+    # directories -- see D14's "still open" deployment note).
+    return f"{mpy_path.stem}-{build_options.identifier}{mpy_path.suffix}"
+
+
+def _write_package_json(path: Path, urls: list[tuple[str, str]], version: str) -> None:
+    manifest = {
+        "urls": [[target_path, url] for target_path, url in urls],
+        "version": version,
+    }
+    path.write_text(json.dumps(manifest, indent=2) + "\n")
+
+
+def package_target(
+    build_options: BuildOptions,
+    identifier_dir: Path,
+    install_name: str,
+    mpy_dest: Path,
+    extra_files: list[Path],
+    version: str,
+) -> None:
+    """Copy `extra-files` alongside the built `.mpy` and write this
+    identifier's own `package.json` (**D14**): today's plain, always-
+    supported two-element `urls` schema, not a unified multi-arch manifest
+    -- see build.__doc__ and docs/BACKLOG.md D14 for why.
+
+    `urls` entries are `[target_path, url]`, deliberately not the same
+    string twice: `target_path` is what `import <module>` needs on-device
+    -- the project's own original basename (e.g. `template.mpy`), not the
+    identifier-qualified one `mpy_dest` was stored under -- while `url` is
+    that qualified, collision-safe filename actually sitting next to this
+    `package.json`. Conflating the two would make mip install the file
+    under its long, arch-qualified name, and `import template` would not
+    find it.
+
+    A no-op when `version` is unset: an identifier directory with a `.mpy`
+    and no `package.json` is still useful (the file itself is what a
+    Makefile-driven consumer wants), it just is not mip-installable yet.
+    """
+    if not version:
+        return
+    urls = [(install_name, mpy_dest.name)]
+    for extra in extra_files:
+        if not extra.is_file():
+            raise BuildError(
+                f"{build_options.identifier}: extra-files entry not found: {extra}"
+            )
+        dest = identifier_dir / extra.name
+        dest.write_bytes(extra.read_bytes())
+        urls.append((extra.name, extra.name))
+    _write_package_json(identifier_dir / "package.json", urls, version)
+
+
+def build_target(
+    build_options: BuildOptions,
+    chain: ResolvedToolchain,
+    mpy_dir: Path,
+    module_root: Path,
+    output_dir: Path,
+    *,
+    extra_files: Sequence[Path] = (),
+    version: str = "",
+) -> BuildResult:
+    """Run one target's build end to end: pre-build-command, make, collect,
+    verify, package.
+
+    Writes into `output_dir/<identifier>/`, not a flat `output_dir/` --
+    every identifier gets its own directory from the start (D14), so there
+    is no separate reorganising step between building and having something
+    mip can install. Two targets can never collide here: `Target` is keyed
+    on (abi, mode, arch, tag, arch_flags), and natmod_targets()/tag_groups()
+    both dedupe by construction, so distinct targets always get distinct
+    identifiers and therefore distinct directories.
+    """
+    start = time.time()
+    env = chain.env()
+
+    run_pre_build_command(module_root, build_options.pre_build_command, env)
+    run_make(build_options, mpy_dir, module_root, env)
+
+    produced = collect_output(build_options, module_root)
+    verify_output(build_options, produced)
+
+    identifier_dir = output_dir / build_options.identifier
+    identifier_dir.mkdir(parents=True, exist_ok=True)
+    dest = identifier_dir / output_name(build_options, produced)
+    dest.write_bytes(produced.read_bytes())
+
+    package_target(
+        build_options, identifier_dir, produced.name, dest, list(extra_files), version
+    )
+
+    return BuildResult(
+        identifier=build_options.identifier, output=dest, duration=time.time() - start
+    )

cibuildmp/cli.py

@@ -0,0 +1,367 @@
+"""Command line interface."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import sys
+from pathlib import Path
+
+from . import __version__
+from .build import BuildError, BuildResult, build_target
+from .options import BuildOptions, ConfigError, Options
+from .sources import (
+    SourceError,
+    build_mpy_cross,
+    cache_root,
+    fetch_micropython,
+    read_mpy_abi,
+)
+from .targets import (
+    LATEST_KNOWN_ABI,
+    NATMOD_ARCHS,
+    Target,
+    UnknownArchError,
+    is_abi_known,
+)
+from .toolchains import ResolvedToolchain, ToolchainError, resolve
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="cibuildmp",
+        description="Build MicroPython native C extensions across every target "
+        "a module supports, from one declarative config.",
+        epilog="Most options are supplied via cibuildmp.toml or CIBMP_* environment "
+        "variables. See docs/BACKLOG.md for the design and what is implemented.",
+    )
+    parser.add_argument(
+        "package_dir",
+        nargs="?",
+        default=".",
+        type=Path,
+        help='Directory containing the module and its config (default: ".")',
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"cibuildmp {__version__}",
+    )
+    parser.add_argument(
+        "--config-file",
+        type=Path,
+        default=None,
+        help="Config file to use instead of <package_dir>/cibuildmp.toml",
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        default=None,
+        help="Where to collect built .mpy files (overrides the config)",
+    )
+    parser.add_argument(
+        "--only",
+        default=None,
+        metavar="IDENTIFIER",
+        help="Build exactly this one identifier, overriding the config's own "
+        "build/skip selectors. Opt into a job-per-target CI layout with this; "
+        "the default is one invocation building every selected target.",
+    )
+    parser.add_argument(
+        "--archs",
+        default=None,
+        help="Comma-separated list of architectures to build, or 'all'. Overrides "
+        "the config's own archs. There is no 'auto': every natmod arch is a "
+        "cross-compile, so none of them depends on what this machine is.",
+    )
+    parser.add_argument(
+        "--toolchain",
+        default="auto",
+        choices=["auto", "host", "download"],
+        help="How to obtain each target's cross toolchain. auto (default) uses "
+        "one already on PATH and downloads a pinned tarball otherwise; host "
+        "refuses to download; download ignores what is on PATH.",
+    )
+    parser.add_argument(
+        "--clean-cache",
+        action="store_true",
+        help="Delete cibuildmp's cache (MicroPython checkouts, mpy-cross builds "
+        "and downloaded toolchains) and exit",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Print the resolved build plan and exit without building",
+    )
+    parser.add_argument(
+        "--print-build-identifiers",
+        action="store_true",
+        help="Print the identifiers this config selects, one per line, then exit",
+    )
+    parser.add_argument(
+        "--print-build-matrix",
+        action="store_true",
+        help="Print a JSON array of {only, os} objects, then exit. Feed it to a "
+        "GitHub Actions `strategy.matrix.include` via fromJSON() to get one job "
+        "per target. Only worth it when targets need different runners.",
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="With --print-build-identifiers, emit a JSON array instead of lines",
+    )
+    parser.add_argument(
+        "--allow-empty",
+        action="store_true",
+        help="Do not report an error code if no target is selected",
+    )
+    parser.add_argument(
+        "--debug-traceback",
+        action="store_true",
+        default=os.environ.get("CIBMP_DEBUG_TRACEBACK", "") not in {"", "0"},
+        help="Print a full traceback for all errors",
+    )
+    parser.add_argument(
+        "--platform",
+        default="natmod",
+        choices=["natmod"],
+        help="Build mode. Only natmod is implemented; usermod is planned "
+        "(see docs/BACKLOG.md).",
+    )
+    return parser
+
+
+def _plan_line(
+    index: int,
+    total: int,
+    options: BuildOptions,
+    chain: ResolvedToolchain | None = None,
+) -> str:
+    make = ["make", "-C", options.module_dir, f"ARCH={options.target.arch}"]
+    make += options.extra_make_args
+    make.append(options.make_target)
+    # The prefix actually in play, which is not always the one dynruntime.mk
+    # hardcodes -- showing target.cross here would contradict the CROSS=
+    # override sitting in the same line's make command.
+    prefix = chain.prefix if chain is not None else options.target.cross
+    # Right-align the counter so the columns after it stay put once the
+    # index gains a digit ([10/10] is wider than [9/10]).
+    counter = f"[{index:>{len(str(total))}}/{total}]"
+    return (
+        f"{counter} {options.target.identifier:<28} "
+        f"CROSS={prefix or '(host)':<22} {' '.join(make)}"
+    )
+
+
+def build(options: Options, targets: list[Target], *, toolchain: str = "auto") -> int:
+    """Build every selected target in one invocation.
+
+    Sequential and in-process on purpose (D9), the same shape cibuildwheel
+    uses for the Python versions inside one runner. Fetching MicroPython and
+    building mpy-cross are identical for every natmod arch *sharing an ABI*,
+    so doing them once per ABI group here is strictly cheaper than paying
+    for them in each of ten matrix legs -- and unlike cibuildwheel, no
+    natmod target needs a runner any other target cannot use, so nothing
+    forces a fan-out. Callers who want one anyway (failure isolation,
+    wall-clock) opt in with --only.
+
+    Grouped by MicroPython tag (**D13**): almost always one group, since
+    that is the common case, but `tag_groups()` can hand back more than one
+    when `micropython` spans an ABI boundary, and each needs its own
+    checkout and its own mpy-cross.
+    """
+    resolved = [options.build_options(t) for t in targets]
+    total = len(resolved)
+
+    # Toolchains are resolved before the plan is printed, not after: where a
+    # toolchain's prefix is not the one dynruntime.mk hardcodes, resolution
+    # adds a CROSS= override, and a plan printed first would show a make
+    # command that is not the one about to run.
+    print(f"cibuildmp: resolving toolchains for {total} target(s)")
+    chains = []
+    for build_options in resolved:
+        chain = resolve(build_options.target.arch, strategy=toolchain)
+        chains.append(chain)
+        build_options.extra_make_args = [
+            *chain.make_overrides,
+            *build_options.extra_make_args,
+        ]
+
+    tags = ", ".join(tag for tag, _abi in options.tag_groups())
+    print(f"\ncibuildmp: {total} target(s) against MicroPython {tags}")
+    for index, (build_options, chain) in enumerate(
+        zip(resolved, chains, strict=True), 1
+    ):
+        print("  " + _plan_line(index, total, build_options, chain))
+        print(f"        {chain.describe()}")
+
+    # Resolved once, not per target: the same files and version apply to
+    # every identifier's own package.json (D14). Checked up front so a
+    # missing extra-files entry fails before any target builds, not after
+    # the first one succeeds.
+    extra_files = [options.package_dir / f for f in options.extra_files()]
+    for extra in extra_files:
+        if not extra.is_file():
+            raise BuildError(f"extra-files entry not found: {extra}")
+
+    results: list[BuildResult] = []
+    index = 0
+    # Preserves first-appearance order (options.targets() emits one ABI
+    # group at a time), not sorted -- a later tag never jumps ahead of an
+    # earlier one just because it sorts first.
+    build_tags = list(dict.fromkeys(bo.target.tag for bo in resolved))
+    for tag in build_tags:
+        group = [
+            (bo, chain)
+            for bo, chain in zip(resolved, chains, strict=True)
+            if bo.target.tag == tag
+        ]
+        abi = group[0][0].target.abi  # one ABI per tag group, by construction
+
+        # Shared setup, paid once per ABI group rather than once per target
+        # in it -- see build()'s own docstring and D9.
+        print(f"\ncibuildmp: preparing MicroPython {tag}")
+        mpy_dir = fetch_micropython(tag, submodules=options.micropython_submodules)
+        build_mpy_cross(mpy_dir)
+
+        # The checkout is authoritative about the ABI; targets.MPY_ABI's
+        # table is only a way to answer the question without one. A
+        # disagreement means the identifiers already printed are wrong, so
+        # it stops here rather than producing files labelled with an ABI
+        # they do not have.
+        actual_abi = read_mpy_abi(mpy_dir)
+        if actual_abi != abi:
+            raise SourceError(
+                f"MicroPython {tag} has .mpy ABI {actual_abi}, but the "
+                f"identifiers were built assuming {abi}. Set `mpy-abi = "
+                f'"{actual_abi}"` in the config, or report the stale entry in '
+                f"cibuildmp.targets.MPY_ABI."
+            )
+
+        print(f"\ncibuildmp: building {len(group)} target(s) for MicroPython {tag}")
+        for build_options, chain in group:
+            index += 1
+            print("\n  " + _plan_line(index, total, build_options, chain))
+            module_root = options.package_dir / build_options.module_dir
+            output_dir = options.package_dir / build_options.output_dir
+            result = build_target(
+                build_options,
+                chain,
+                mpy_dir,
+                module_root,
+                output_dir,
+                extra_files=extra_files,
+                version=options.version,
+            )
+            results.append(result)
+            print(f"        done in {result.duration:.1f}s -> {result.output}")
+
+    total_duration = sum(r.duration for r in results)
+    print(f"\ncibuildmp: {total} target(s) built in {total_duration:.1f}s")
+    for result in results:
+        print(f"  {result.identifier}: {result.output.name} ({result.size} bytes)")
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    if args.clean_cache:
+        root = cache_root()
+        if not root.exists():
+            print(f"cibuildmp: nothing to clean ({root} does not exist)")
+            return 0
+        shutil.rmtree(root)
+        print(f"cibuildmp: removed {root}")
+        return 0
+
+    try:
+        options = Options.load(args.package_dir, args.config_file)
+        if args.output_dir is not None:
+            options.output_dir = args.output_dir
+        if args.archs is not None:
+            options.archs = (
+                list(NATMOD_ARCHS)
+                if args.archs.strip() == "all"
+                else [a.strip() for a in args.archs.split(",") if a.strip()]
+            )
+        targets = options.targets()
+    except (ConfigError, UnknownArchError, SourceError) as exc:
+        if args.debug_traceback:
+            raise
+        print(f"cibuildmp: error: {exc}", file=sys.stderr)
+        return 2
+
+    if args.only is not None:
+        # --only overrides build/skip, matching cibuildwheel's own semantics
+        # for the flag: the caller has already decided what this invocation
+        # is for, and a matrix leg that reached here was selected when the
+        # matrix was generated.
+        targets = [t for t in targets if t.identifier == args.only]
+        if not targets:
+            print(
+                f"cibuildmp: error: --only {args.only!r} matches no target this "
+                f"config can produce",
+                file=sys.stderr,
+            )
+            return 2
+
+    if args.print_build_matrix:
+        print(
+            json.dumps(
+                [
+                    {"only": bo.target.identifier, "os": bo.runs_on}
+                    for bo in (options.build_options(t) for t in targets)
+                ]
+            )
+        )
+        return 0
+
+    if args.print_build_identifiers:
+        identifiers = [t.identifier for t in targets]
+        if args.json:
+            print(json.dumps(identifiers))
+        else:
+            for identifier in identifiers:
+                print(identifier)
+        return 0
+
+    if not targets:
+        if args.allow_empty:
+            print("cibuildmp: no targets selected")
+            return 0
+        print(
+            "cibuildmp: error: no targets selected. Pass --allow-empty if that "
+            "is expected.",
+            file=sys.stderr,
+        )
+        return 2
+
+    unknown_tags = [tag for tag in options.micropython if not is_abi_known(tag)]
+    if unknown_tags:
+        print(
+            f"cibuildmp: warning: no recorded .mpy ABI for MicroPython "
+            f"{', '.join(unknown_tags)}; assuming {LATEST_KNOWN_ABI}. The ABI "
+            f"actually encoded in each built .mpy is verified against its "
+            f"identifier, so a wrong guess fails the build rather than shipping.",
+            file=sys.stderr,
+        )
+
+    if args.dry_run:
+        total = len(targets)
+        tags = ", ".join(tag for tag, _abi in options.tag_groups())
+        print(f"cibuildmp: {total} target(s) against MicroPython {tags}")
+        for index, target in enumerate(targets, 1):
+            print("  " + _plan_line(index, total, options.build_options(target)))
+        return 0
+
+    try:
+        return build(options, targets, toolchain=args.toolchain)
+    except (SourceError, ToolchainError, BuildError) as exc:
+        if args.debug_traceback:
+            raise
+        print(f"cibuildmp: error: {exc}", file=sys.stderr)
+        return 2