livery.extensions.nanobind._ci¶
livery.extensions.nanobind._ci ¶
The wheels job's runners, the members it builds, and what each of its legs builds.
A package that holds nanobind names the runner labels that build its
platform wheels under [nanobind] wheel-platforms in its own
workshop.toml. The wheels job nanobind's declaration adds to the
release point names wheel_runners as its labels: one leg per
label in the union over those packages. A workspace whose packages
hold no nanobind names no label, and its release renders no wheels
job.
Each leg builds the members job_built_members names: every package
that holds nanobind, and every package that releases a conan package.
It is nanobind's answer to the workspace's job-built-members
query, which the release train reads to publish what the run
collected for those members, and the entry reads to install the ones
uv installs after the tools. host_build is what each leg builds; the
verb that runs it is in this extension's _tasks module.
Functions:
| Name | Description |
|---|---|
holds_nanobind |
Whether package's set holds nanobind: its list, or what the list requires. |
releases_a_conan_package |
Whether package releases a conan package, which each leg creates for its host. |
job_built_members |
The members the wheels job builds before the wave, each path to the job. |
declared_wheel_platforms |
The runner labels package declares under |
wheel_runners |
The wheels job's legs: every label the packages declare, once, in order. |
host_build |
Build this host's native artifacts for the release at root's HEAD. |
floor_legs |
Prove every floor package declares on a conan package, one leg each. |
Attributes:
| Name | Type | Description |
|---|---|---|
EXTENSION |
|
|
WHEEL_PLATFORMS_KEY |
|
|
JOB |
|
|
CONAN |
|
holds_nanobind ¶
Whether package's set holds nanobind: its list, or what the list requires.
releases_a_conan_package ¶
Whether package releases a conan package, which each leg creates for its host.
Its extensions answer the distributions query, which names a
conan package for a recipe that names a reference and nothing for
a consumer's recipe.
Source code in packages/extensions/nanobind/src/livery/extensions/nanobind/_ci.py
job_built_members ¶
The members the wheels job builds before the wave, each path to the job.
Every package that holds nanobind, whose platform wheels each leg builds, and every package that releases a conan package, which each leg creates for its host and saves beside the wheels, in discovery order. A workspace whose packages hold no nanobind has no wheels job, and names no member.
Source code in packages/extensions/nanobind/src/livery/extensions/nanobind/_ci.py
declared_wheel_platforms ¶
The runner labels package declares under [nanobind] wheel-platforms.
Empty for a package that holds no nanobind and names no label.
Raises:
| Type | Description |
|---|---|
Failed
|
naming the package and the key, when a package that holds nanobind declares no labels, an empty list or a blank label, since the forge cannot schedule a leg on any of those; and when a package that holds no nanobind declares the key, since no leg builds its wheel. The labels are the package's own fact, never guessed from the check runners. |
Source code in packages/extensions/nanobind/src/livery/extensions/nanobind/_ci.py
wheel_runners ¶
The wheels job's legs: every label the packages declare, once, in order.
The packages are read in discovery order, and each package's labels in its own order. Empty when no package holds nanobind, so the release renders no wheels job.
Source code in packages/extensions/nanobind/src/livery/extensions/nanobind/_ci.py
host_build ¶
host_build(root: Path) -> None
Build this host's native artifacts for the release at root's HEAD.
Each leg of the release's wheels job runs this before the wave,
over the members of the release that job_built_members names, in
three steps. Each of them that releases a conan package is created
into this leg's cache and saved beside its wheels, one file per
host, which is how a forge with no conan registry carries the
package. Then each package that holds nanobind builds through its
set's build phase, for the interpreters the caller's CIBW_BUILD
names, resolving each conan member from the cache the first step
filled. Then every declared floor on a conan member is proved with
its own build (floor_legs). The publish job collects each leg's
dist/, and the wave publishes the union. A release with no such
member prints so and builds nothing, so the leg stays green on a
pure release.
Source code in packages/extensions/nanobind/src/livery/extensions/nanobind/_ci.py
floor_legs ¶
Prove every floor package declares on a conan package, one leg each.
A floor is a claim: the extension module compiles and its tests
pass against that version of the library, so a consumer who
resolves the floor gets a working package. The claim is proved
here. Per dependency that releases a conan package: the floor's
saved cache is restored from its own release, one wheel is built
for this machine with the requirement replaced by the floor, and
the package's tests run against that wheel in a fresh venv. The pin
is a conan profile holding a [replace_requires] line, added to the
ones the dependency provider already passes, so the range the
recipe declares resolves to that version alone.
A floor equal to the version this wave releases is the package the main build already linked, so that leg says so and does nothing. released is the wave's manifest, member path to version.
Raises:
| Type | Description |
|---|---|
Failed
|
when the floor's cache is not on its release, when the pinned build fails, or when the tests fail against it. A floor whose header lacks a symbol the extension module calls fails at the compile. |