livery.workshop._release_driver¶
livery.workshop._release_driver ¶
workflow.release: the release train's driver on the engine.
One release shape for a set of N >= 1 packages: derive each member's
version from its commits and its entry through the release notes'
provider, bump floors within the set only, stamp, commit per member in
dependency order, and hand the branch to the shared engine. The branch
decides the act: main-family (main and the engine's workflow/
namespace) runs the real train, any other branch is the dev act, a wheel
straight from the branch. --local is everything that stays on this
machine: derive, build, validate, report, then roll the stamps back like
a failed prepare, leaving dist/ and the report.
Classes:
| Name | Description |
|---|---|
MemberPlan |
One member's derived release: the package and its next version. |
ReleaseDriver |
The release kind's driver for the shared engine. |
Functions:
| Name | Description |
|---|---|
release_name |
The workflow name a set earns: its directories, sorted and |
resolve_set |
The named packages, in dependency order; every name must exist. |
derive_plans |
Each member's next version, every member refused when unchanged. |
member_pairs_at |
(distribution, version) for each member in the member list at ref. |
bump_set_floors |
Raise floors between co-released members through the stamp phase; the files. |
rollback_prepare |
Restore exactly the files prepare writes; never raises. |
verify_set |
Run the publish job's own checks over the stamped set, before any leg. |
proved_resolutions |
The resolutions package's release tests at, and the file that listed them. |
validate_member |
Run the member's test phase isolated once per resolution it proves; report each. |
require_verified_base |
Wait for the base's own push CI to be green; stop on red or skip. |
release_title |
The release pull request's title: each member with its version, or a count. |
runs_the_train |
Whether |
fresh_receipts |
Fetch origin's tags, so a derivation reads every receipt a wave cut. |
local_release |
Everything that stays on this machine, then the stamps roll back. |
await_wave |
The id of the newest wave run not in before, or |
dispatch_flow |
Dispatch the wave for a merged, unpublished release, or say why not. |
newest_release_squash |
The newest release squash on the base, as (sha, subject); ("", "") when none. |
pending_release_waves |
Every recent release squash whose receipts are not all cut, oldest first. |
pending_release_wave |
The oldest release squash with an uncut receipt, or None. |
pending_release_wave_for |
The oldest uncut squash whose receipts touch members, or None. |
uncut_in_set |
The uncut receipts, |
workflow_release |
Release a set of packages: the branch decides the act. |
run_release |
Drive a release through the engine; an armed one re-derives a stale set. |
set_moved |
Whether release name's open pull request is stale in its set's paths. |
workflow_release_dispatch |
Dispatch the release wave for a merged, unpublished release; green otherwise. |
workflow_release_check_title |
Verify a release PR's title against the release's member list. |
workflow_release_check_fresh |
Refuse a release pull request whose base moved in its set's paths. |
workflow_release_publish |
Publish the squash at --ref: the wave, receipts cut per member. |
collected_wheels |
Whether the run collected what a job built for this wave, judged inside CI alone. |
Attributes:
| Name | Type | Description |
|---|---|---|
BASE_TIMEOUT |
|
|
BASE_POLL |
|
|
SILENT_NUDGE_AFTER |
|
|
NAME_LIMIT |
|
|
PROVE |
|
|
RESOLUTIONS |
|
|
DEFAULT_RESOLUTIONS |
|
|
TITLE_LIMIT |
|
|
RELEASE_WORKFLOW |
|
|
release_group |
|
|
REDERIVE_LIMIT |
|
release_group
module-attribute
¶
release_group = workflow.group('release', help='The release train')
MemberPlan
dataclass
¶
ReleaseDriver ¶
ReleaseDriver(root: Path, repo: Repository, members: tuple[Package, ...], *, armed: bool, force_unverified_base: bool = False, wave_timeout: float = 1800.0)
The release kind's driver for the shared engine.
Methods:
| Name | Description |
|---|---|
discard |
Give up the prepared branch: the base moved in the set's paths. |
legs_kept |
The members whose legs from the discarded prepare still hold. |
prepare |
Derive, stamp, and commit the set; recover an existing branch. |
on_merged |
The merge point dispatches the wave; follow it to its verdict. |
Attributes:
| Name | Type | Description |
|---|---|---|
kind |
|
|
members |
|
|
name |
|
|
armed |
|
|
watch |
|
|
branch |
str
|
|
base |
str
|
|
Source code in packages/workshop/src/livery/workshop/_release_driver.py
discard ¶
Give up the prepared branch: the base moved in the set's paths.
The next prepare derives the set again from the base and
force-pushes the branch, so the open pull request carries the
new stamps, entries and Mined-At. The given-up branch's
manifest is kept: a member whose directory the base did not
move since that prepare, at the same versions for the whole
set, keeps its legs' verdict instead of running them again.
Source code in packages/workshop/src/livery/workshop/_release_driver.py
legs_kept ¶
legs_kept(plans: tuple[MemberPlan, ...], mined_at: str) -> set[str]
The members whose legs from the discarded prepare still hold.
Only when the whole set keeps its versions (a co-member's new version moves the floors every other member is tested at), and then each member the base did not touch between the two mining points.
Source code in packages/workshop/src/livery/workshop/_release_driver.py
prepare ¶
prepare() -> Submission | None
Derive, stamp, and commit the set; recover an existing branch.
A branch already alive locally or on the remote is recovery: nothing is rebuilt, the engine re-submits what the branch holds, and titles come from the ref, never the working tree.
Source code in packages/workshop/src/livery/workshop/_release_driver.py
719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 | |
on_merged ¶
The merge point dispatches the wave; follow it to its verdict.
The wave's run is awaited by its id, then followed the way
ci.status --point=release --wait follows it, so the act
ends with the wave's own verdict and exit; the receipt tags
say when each member is done. A wave timeout of zero reports
the merge and names the dispatch verb as the confirmation
instead of waiting: the engine's own tests run against a
forge with no merge point.
Source code in packages/workshop/src/livery/workshop/_release_driver.py
release_name ¶
The workflow name a set earns: its directories, sorted and +-joined.
A set whose joined directories run past NAME_LIMIT is named by
its size and a digest of them instead, so the branch stays short
and the same set always earns the same name.
Source code in packages/workshop/src/livery/workshop/_release_driver.py
resolve_set ¶
The named packages, in dependency order; every name must exist.
Source code in packages/workshop/src/livery/workshop/_release_driver.py
derive_plans ¶
derive_plans(root: Path, members: tuple[Package, ...]) -> tuple[MemberPlan, ...]
Each member's next version, every member refused when unchanged.
Runs before the branch is cut, from read-only state: a refusal here has nothing to undo. A member whose bump equals its newest released tag has nothing unreleased, and minting a number the index already has is refused with the options. The tag is the judge, never the stamped version: a stamp can land without its release cutting, and judging by it would strand that release (the same rule livery.workshop._release.prepare_release keeps).
Source code in packages/workshop/src/livery/workshop/_release_driver.py
member_pairs_at ¶
(distribution, version) for each member in the member list at ref.
Each name is read from the member's contract as committed at ref, so the answer describes that commit alone. None when ref carries no readable list.
Source code in packages/workshop/src/livery/workshop/_release_driver.py
bump_set_floors ¶
bump_set_floors(root: Path, plans: tuple[MemberPlan, ...]) -> list[str]
Raise floors between co-released members through the stamp phase; the files.
Within the set only (contract: a solo release never moves a
floor): each member's stamp phase runs at the version it declares
now, with every other member's version as its floors, so the
version stays for prepare_release to stamp. Each step raises the
floors in its own manifests, and the base those of the member's
[[depends]] edges, as livery.workshop._lifecycle.stamp says.
The files are the ones the phase reported, relative to root.
Source code in packages/workshop/src/livery/workshop/_release_driver.py
rollback_prepare ¶
Restore exactly the files prepare writes; never raises.
The error being unwound is the one worth seeing, so this raises nothing of its own: each member's changelog, contract and version files return to HEAD, and so do the files the stamp phase reported raising floors in (relative to root), the set's manifest and the workspace lock the stamp refreshed. One of these files on disk that HEAD lacks is one prepare created, as a first release's changelog and manifest are, and it is removed, so the switch back to the base does not carry it along. Each restore reads HEAD, never the index: a commit that failed (a signing agent that refused) has already staged every change, and a restore from the index would keep them. Each path the rollback could not put back is printed with the reason, and the other paths are put back all the same.
Source code in packages/workshop/src/livery/workshop/_release_driver.py
verify_set ¶
verify_set(root: Path, plans: tuple[MemberPlan, ...]) -> None
Run the publish job's own checks over the stamped set, before any leg.
The wave refuses a member whose version homes disagree with its tag, whose release notes are unsound, or whose floor names an unreleased version, and it refuses only after the release has merged. The same checks on the stamped tree refuse before a release pull request exists. The set's own tags count as released, as the wave counts them.
Raises:
| Type | Description |
|---|---|
Failed
|
as the publish job's check refuses, naming the member and each problem. |
Source code in packages/workshop/src/livery/workshop/_release_driver.py
proved_resolutions ¶
The resolutions package's release tests at, and the file that listed them.
The package's own [release] prove wins; the workspace's is the
default; without either the release tests at
livery.workshop._release_driver.DEFAULT_RESOLUTIONS, and the
file is empty. The contract's judge refuses a word other than the
three and a word listed twice, so the list holds each at most
once, in the order the legs run.
Source code in packages/workshop/src/livery/workshop/_release_driver.py
validate_member ¶
validate_member(root: Path, plan: MemberPlan, release_dirs: tuple[Path, ...]) -> None
Run the member's test phase isolated once per resolution it proves; report each.
One leg per resolution
(livery.workshop._release_driver.proved_resolutions), in the
order of livery.workshop._release_driver.RESOLUTIONS, so the
floor leg runs before the latest leg; a list from a contract is
named with its file. The report names what each leg resolved per
co-member and sibling: every workspace member but the one under
test. The caller builds every set member's wheel first: the legs'
find-links name each sibling's dist/, so a later member's
wheel must exist before an earlier member's floor leg resolves.
A member whose extensions add no isolated test, as a conan package's do, has no venv to isolate: its own gate already built and ran ctest, so the legs skip saying why.
Source code in packages/workshop/src/livery/workshop/_release_driver.py
require_verified_base ¶
require_verified_base(repo: Repository, root: Path, base: str, *, force: bool = False, timeout: float = BASE_TIMEOUT, poll: float = BASE_POLL) -> None
Wait for the base's own push CI to be green; stop on red or skip.
Branch protection only ever judged PR heads, and a release publishes the base's tree, so the base's push run is the only vouching there is. Green, not merely not-red; red is a verdict waiting cannot improve; a skip-ci tip will never get a run; an unreachable forge fails open, the engine's UNKNOWN story says it better.
Zero reported contexts after minutes means run creation itself failed, and every forge can do it: Gitea's actions queue could wedge before 1.27.3, GitHub silently drops a push's workflow-run creation under load, and GitLab can never mint the pipeline (a job-queue backlog, or workflow rules evaluating to nothing). The combined-status read reports all three identically, so detection is uniform; the safe remedy is not (whether a tool may push to the base varies per forge and protection), so the silent tip gets a printed teaching naming the fresh-push-event remedy, never an automatic push. The timeout tells the two conditions apart: a run that reported and hung sends the reader to the runners, a tip that never got a run names run creation.
Source code in packages/workshop/src/livery/workshop/_release_driver.py
500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 | |
release_title ¶
The release pull request's title: each member with its version, or a count.
The title is the squash commit's headline, and arming hands it to
GitHub's auto-merge, which refuses a long one. A set whose title
would pass TITLE_LIMIT characters is counted instead; the pull
request's body and the commit's body list every member.
Source code in packages/workshop/src/livery/workshop/_release_driver.py
runs_the_train ¶
Whether workflow.release on branch is the release train, not the dev act.
main and the engine's reserved workflow/ branches release;
any other branch builds a dev wheel straight from its commit.
Source code in packages/workshop/src/livery/workshop/_release_driver.py
fresh_receipts ¶
fresh_receipts(root: Path) -> None
Fetch origin's tags, so a derivation reads every receipt a wave cut.
A release wave tags its receipts on the remote, and this checkout holds them only after a fetch: a derivation from stale tags names versions the index already has. A checkout with no origin has only its own tags to read; one that cannot reach origin derives from its own and says so.
Source code in packages/workshop/src/livery/workshop/_release_driver.py
local_release ¶
Everything that stays on this machine, then the stamps roll back.
Derive, stamp (so the built wheels carry the would-be versions),
build, run the isolated legs, print the would-be release, restore
the tree; dist/ and the report remain. Publishing consent is
never asked because nothing leaves the machine. The derivation
reads origin's receipts, fetched first, so it names the versions
the armed act would (livery.workshop._release_driver.fresh_receipts).
Before any of it, the act refuses while a file it would write has
changes of its own, since the restore would discard them; a change
anywhere else in the tree is left alone.
Source code in packages/workshop/src/livery/workshop/_release_driver.py
await_wave ¶
await_wave(repo: Repository, *, before: set[int], timeout: float = 1800.0, interval: float = _WAVE_POLL, transient: Transient | None = None) -> int | None
The id of the newest wave run not in before, or None when none appears.
Any state counts: a wave that already finished by the time the poll saw it is still the wave that ran, and a confirmation that demanded a live run would miss a fast forge. An unreadable poll is retried within transient's budget.
Source code in packages/workshop/src/livery/workshop/_release_driver.py
dispatch_flow ¶
dispatch_flow(root: Path, repo: Repository, *, base: str = 'main', at: str = '', workshop: str = '', again: bool = False, timeout: float = 60.0, interval: float = 2.0) -> list[str]
Dispatch the wave for a merged, unpublished release, or say why not.
Reads the manifest on origin/<base> after a fetch, whatever
commit this checkout stands on, or at at, an older release squash
a later release has moved past. A checkout behind the base would
otherwise send the wave to the squash a later release took over.
workshop names a released driver for the wave instead of the
squash's own, the recovery for a wave whose workshop was the fault;
empty runs the squash's. Green when there is none, or when
every member's receipt tag is already on the remote: the
manifest is permanent residue of the last release, so presence
is not the signal, missing receipts are. A wave already in
flight is reported green with its run id. A wave that already ran
at the squash with the squash's own driver and ended failure is
reported green too, with its run and the recoveries, and nothing
is dispatched: the same wave fails the same way, and every merge
would otherwise start one more copy of it. again dispatches it
anyway, the gesture by hand once the cause is gone, and a named
workshop is another wave. Otherwise the wave is dispatched on
base with the commit that stamped the manifest as its ref
input, never this run's own sha, so an unrelated merge landing
first cannot move the wave onto another tree; the dispatch is
confirmed by the run id that appears, or refused with the reason.
Remote state only, receipts by ls-remote and runs by the
forge, so any checkout answers the same as CI.
Source code in packages/workshop/src/livery/workshop/_release_driver.py
1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 | |
newest_release_squash ¶
The newest release squash on the base, as (sha, subject); ("", "") when none.
Source code in packages/workshop/src/livery/workshop/_release_driver.py
pending_release_waves ¶
Every recent release squash whose receipts are not all cut, oldest first.
A merged release whose wave died leaves the squash on the base
with the stamps and changelogs landed and receipt tags missing.
Re-preparing from that state derives an empty release (measured:
an empty pull request the forge never agrees to merge), so the
recovery is the wave at the squash, never a new pull request.
Every release squash in the base's recent history is consulted, so
a later release never strands an earlier died wave, and a checkout
standing on a release branch still finds the squash it was merged
as. A later release squash naming a package takes over that
package's uncut receipt, so a squash abandoned for a new release
(fm workflow.release --abandon) is never offered again. Each
entry is the squash sha and its missing receipt tags.
Source code in packages/workshop/src/livery/workshop/_release_driver.py
pending_release_wave ¶
The oldest release squash with an uncut receipt, or None.
The set-blind selection, for a dispatch with no set named: recoveries run in order, oldest first.
Source code in packages/workshop/src/livery/workshop/_release_driver.py
pending_release_wave_for ¶
pending_release_wave_for(root: Path, members: tuple[Package, ...]) -> tuple[str, tuple[str, ...]] | None
The oldest uncut squash whose receipts touch members, or None.
A release of one set must find its own died wave even when an older squash of another set is uncut too: that squash is the other set's recovery, named by the caller, never a reason to prepare this set again from a tree already stamped.
Source code in packages/workshop/src/livery/workshop/_release_driver.py
uncut_in_set ¶
The uncut receipts, packages/<member>/v<x>, that belong to members.
Source code in packages/workshop/src/livery/workshop/_release_driver.py
workflow_release ¶
workflow_release(*paths: str, armed: Annotated[bool, doc('arm the release PR to merge on green')] = False, local: Annotated[bool, doc('derive, build, validate, report; nothing leaves the machine')] = False, force_unverified_base: Annotated[bool, doc("release without waiting for the base's own CI")] = False, workshop: Annotated[str, doc('a released livery-workshop version to drive a re-dispatched wave')] = '', abandon: Annotated[bool, doc('prepare a new release over a died wave of this set instead of re-dispatching it')] = False) -> None
Release a set of packages: the branch decides the act.
Names the set positionally (packages/forge or just forge).
On a main-family branch this is the release train: one PR,
receipts per member, re-running the recovery at every step;
--armed follows the pull request to its squash and the wave
to its verdict, from main, the way submit --armed follows a
feature pull request, and an unarmed run returns at once. On
any other branch it is the dev act: a wheel straight from the
branch at a dev version, published only to the configured custom
index after a confirmation, no reserved branch, no PR, no tags.
--local is everything that stays on this machine, on either
branch mode. --workshop applies only to the recovery of a
died wave: the named release drives the wave in place of the
squash's own workshop. --abandon gives up that recovery: when
no released workshop can drive the died wave, a new release of
the set takes its uncut receipts over.
Source code in packages/workshop/src/livery/workshop/_release_driver.py
1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 | |
run_release ¶
run_release(make_driver: Callable[[], ReleaseDriver], repo: Repository, root: Path, *, armed: bool) -> None
Drive a release through the engine; an armed one re-derives a stale set.
An armed release whose follow ends red because the base moved under its set prepares again on the moved base and follows again, up to [livery.workshop._release_driver.REDERIVE_LIMIT] prepares in all; any other red is the release's verdict and exits with it.
Source code in packages/workshop/src/livery/workshop/_release_driver.py
set_moved ¶
set_moved(repo: Repository, root: Path, name: str) -> bool
Whether release name's open pull request is stale in its set's paths.
Source code in packages/workshop/src/livery/workshop/_release_driver.py
workflow_release_dispatch ¶
workflow_release_dispatch(at: Annotated[str, doc("an older release squash to dispatch instead of HEAD's")] = '', workshop: Annotated[str, doc('a released livery-workshop version to drive the wave')] = '', again: Annotated[bool, doc('dispatch although a wave already failed at the squash')] = False) -> None
Dispatch the release wave for a merged, unpublished release; green otherwise.
The merge point's last task, and the recovery gesture by hand:
it reads the manifest at HEAD and the receipts on the remote, so
on a normal day it prints green, after a died merge run it
dispatches, a wave in flight is reported with its run id, and a
wave that already failed at the squash is reported with its run
and dispatched again only on --again. --at names an older
release squash a later release has moved past; --workshop
names a released driver for a wave whose own workshop was the
fault.
Source code in packages/workshop/src/livery/workshop/_release_driver.py
workflow_release_check_title ¶
Verify a release PR's title against the release's member list.
The publish wave discovers a release from the squash's member
list; the title is presentation. This job keeps the two
consistent: the gate job runs this first, so a title that no
longer names what the list prepared is refused before the
union and the verdict, and the merge waits for a person to fix
the title. Without --title the title
comes from the runner's event payload; a run that is not a pull
request, or a pull request off a release branch, is green here
and says so.
Source code in packages/workshop/src/livery/workshop/_release_driver.py
workflow_release_check_fresh ¶
workflow_release_check_fresh(head: Annotated[str, doc("the pull request's head branch")] = '', base: Annotated[str, doc('the branch it merges into')] = '') -> None
Refuse a release pull request whose base moved in its set's paths.
The gate job runs this last, so the time between the check and
the merge it allows is as short as the forge makes it. The
release's manifest names its members and the commit the prepare
mined at; a commit the base gained since then under a member's
directory is code the stamped changelog does not cover, and the
squash's publish would refuse it after the merge, where nothing
can fix the squash. Refused here, the pull request waits while
workflow.release re-derives it in place. Without --head the
branches come from the runner's event payload; a run that is not
a pull request, or one off a release branch, is green and says so.
Source code in packages/workshop/src/livery/workshop/_release_driver.py
1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 | |
workflow_release_publish ¶
workflow_release_publish(ref: Annotated[str, doc('the release squash; empty means HEAD')] = '', prebuilt: Annotated[bool, doc('trust the dist/ the run collected for each member a job builds')] = False) -> None
Publish the squash at --ref: the wave, receipts cut per member.
The CI entry point after a release PR merges, and the recovery
entry when a publish died mid-wave: everything already tagged is
walked past. --ref exists because HEAD usually moves past the
squash before a recovery runs. Each member publishes to the
registry of the ecosystem its extensions release it to, and the
wave reads what that registry serves through the probe they answer:
the resolved index for a python package, the resolved conan target
for a conan recipe that names a reference.
--prebuilt says the jobs of the run already built the members
they build before the wave, the workspace's job-built-members
answer: a platform-wheel member's dist/ holds the wheels collected
from every platform, a conan member's the caches saved on every
host, and the wave publishes them instead of building on this
runner alone. Inside CI the wave decides that for itself: such a
member whose dist/ already holds a file was fed by the run, since
a runner's checkout starts with none.
Source code in packages/workshop/src/livery/workshop/_release_driver.py
1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 | |
collected_wheels ¶
Whether the run collected what a job built for this wave, judged inside CI alone.
The members a job builds before the wave are the workspace's
job-built-members answer. A runner's checkout starts with no
dist/, so a file in such a member's dist/ was collected from that
job's artifact, and the wave trusts the collection; each member it
trusts is printed with its job. Outside CI a dist/ may hold a stale
local build, and the wave builds as asked.