456 lines
16 KiB
Python
456 lines
16 KiB
Python
from argparse import ArgumentParser
|
|
|
|
from util import ReleaseRepo
|
|
|
|
ALL: list[ReleaseRepo] = []
|
|
BY_FULL_NAME: dict[str, ReleaseRepo] = {}
|
|
|
|
|
|
def _register(repo: ReleaseRepo) -> None:
|
|
ALL.append(repo)
|
|
BY_FULL_NAME[repo.gh_full_name] = repo
|
|
|
|
|
|
##################
|
|
## Repositories ##
|
|
##################
|
|
|
|
|
|
# Repositories managed by this release process should specify their dependencies
|
|
# through reservoir name/scope. The versions should be specified via tags, where
|
|
# available, or commit hashes otherwise.
|
|
|
|
|
|
# For release `v4.X.0-rc1`, a branch `releases/v4.X.0` is created off of
|
|
# `master`. This branch is reused for all subsequent release candidates and
|
|
# releases with the same major and minor version, e.g. `v4.X.0`, `v4.X.1`.
|
|
#
|
|
# `src/CMakeLists.txt` contains the variables LEAN_VERSION_MAJOR,
|
|
# LEAN_VERSION_MINOR, LEAN_VERSION_PATCH, and LEAN_VERSION_IS_RELEASE. On
|
|
# master, these should point to the next release once the release branch is cut,
|
|
# i.e. `v4.X+1.0`, and LEAN_VERSION_IS_RELEASE should be 0. On the release
|
|
# branch, these should point to the current release (and updated only when
|
|
# necessary for patch releases), and LEAN_VERSION_IS_RELEASE should be 1.
|
|
#
|
|
# Before creating a release, ensure that no blocking issues/PRs or open backport
|
|
# PRs exist. See also the labels `backport releases/v4.X.0` and
|
|
# `blocks-release-v4.X.0` on GitHub. There should also be a
|
|
# `blocks-release-v4.X+1.0` label corresponding to the CMakeLists version on
|
|
# `master`, which should be created after cutting a release branch.
|
|
#
|
|
# To create a release, push a tag `v4.X.Y` or `v4.X.Y-rcZ`. The tag triggers CI,
|
|
# which builds the release artifacts and creates a release on GitHub.
|
|
#
|
|
# After a release has been created, its description may need to be updated. For
|
|
# release candidates, it should read "This is the n-th release candidate for the
|
|
# v4.X.Y release of Lean." For releases, it should read "This is the v4.X.Y
|
|
# release of Lean. View the release notes for more information." where "release
|
|
# notes" is a link to the corresponding release notes section. If the release
|
|
# notes has not yet been updated, this second sentence can be omitted and added
|
|
# later.
|
|
#
|
|
# Finally, all the other repos listed below should be updated to use the newly
|
|
# released version of Lean.
|
|
LEAN4 = ReleaseRepo(github=("leanprover", "lean4"))
|
|
# Don't register this repo!
|
|
|
|
LEAN4_NIGHTLY = ReleaseRepo(github=("leanprover", "lean4-nightly"))
|
|
# Don't register this repo!
|
|
|
|
|
|
# To create a new release, open a PR into `main`. In it, bump the toolchain.
|
|
#
|
|
# For `v4.X.0-rc1` releases, use the existing `bump/v4.X.0` branch. To get the
|
|
# latest nightly fixes, you may need to merge the latest
|
|
# `bump/nightly-YYYY-MM-DD` PRs, or merge `nightly-testing` directly. After
|
|
# merging the PR, create a new `bump/v4.X+1.0` branch off of `main`.
|
|
#
|
|
# For other releases, create a new branch off of `main` and use it for the PR.
|
|
#
|
|
# Once the release PR is merged, tag the resulting commit with the lean version.
|
|
# Then, update the `stable` branch to point to the same commit.
|
|
BATTERIES = ReleaseRepo(
|
|
github=("leanprover-community", "batteries"),
|
|
bump_branch=True,
|
|
release_tag="lean",
|
|
stable_branch="stable",
|
|
)
|
|
_register(BATTERIES)
|
|
|
|
|
|
# To create a new release, open a PR into `master`. In it, bump the toolchain
|
|
# and all dependencies. For `v4.X.0-rc1` releases, you may need to merge
|
|
# `nightly-testing` into the PR.
|
|
#
|
|
# Once the release PR is merged, tag the resulting commit with the lean version.
|
|
# Then, update the `stable` branch to point to the same commit.
|
|
AESOP = ReleaseRepo(
|
|
github=("leanprover-community", "aesop"),
|
|
release_tag="lean",
|
|
stable_branch="stable",
|
|
strong_deps=[BATTERIES],
|
|
)
|
|
_register(AESOP)
|
|
|
|
|
|
# To create a new release, open a PR into `main`. In it, bump the toolchain and
|
|
# all dependencies. For `v4.X.0-rc1` releases, you may need to merge
|
|
# `nightly-testing` into the PR.
|
|
#
|
|
# Once the release PR is merged, tag the resulting commit with the lean version.
|
|
LEAN4_CLI = ReleaseRepo(
|
|
github=("leanprover", "lean4-cli"),
|
|
release_tag="lean",
|
|
)
|
|
_register(LEAN4_CLI)
|
|
|
|
|
|
# To create a new release, open a PR into `main`. In it, bump the toolchain and
|
|
# all dependencies. For `v4.X.0-rc1` releases, you may need to merge
|
|
# `nightly-testing` into the PR.
|
|
#
|
|
# Once the release PR is merged, tag the resulting commit with the lean version.
|
|
IMPORT_GRAPH = ReleaseRepo(
|
|
github=("leanprover-community", "import-graph"),
|
|
release_tag="lean",
|
|
strong_deps=[LEAN4_CLI],
|
|
)
|
|
_register(IMPORT_GRAPH)
|
|
|
|
|
|
# To create a new release, open a PR into `main`. In it, bump the toolchain. For
|
|
# `v4.X.0-rc1` releases, you may need to merge `nightly-testing` into the PR.
|
|
#
|
|
# Once the release PR is merged, tag the resulting commit with the lean version.
|
|
PLAUSIBLE = ReleaseRepo(
|
|
github=("leanprover-community", "plausible"),
|
|
release_tag="lean",
|
|
)
|
|
_register(PLAUSIBLE)
|
|
|
|
|
|
# To create a new release, open a PR into `main`. In it, bump the toolchain. For
|
|
# `v4.X.0-rc1` releases, you may need to merge `nightly-testing` into the PR.
|
|
#
|
|
# Obtain the next ProofWidgets version number by incrementing the patch version
|
|
# of the latest release (which will have the form `v0.0.X`). Once the release PR
|
|
# is merged, tag the resulting commit with the new version number.
|
|
PROOFWIDGETS4 = ReleaseRepo(
|
|
github=("leanprover-community", "ProofWidgets4"),
|
|
release_tag="proofwidgets",
|
|
)
|
|
_register(PROOFWIDGETS4)
|
|
|
|
# To create a new release, open a PR into `main`. In it, bump the toolchain. For
|
|
# `v4.X.0-rc1` releases, you may need to merge `nightly-testing` into the PR.
|
|
#
|
|
# Once the release PR is merged, tag the resulting commit with the lean version.
|
|
# Then, update the `stable` branch to point to the same commit.
|
|
QUOTE4 = ReleaseRepo(
|
|
github=("leanprover-community", "quote4"),
|
|
release_tag="lean",
|
|
stable_branch="stable",
|
|
)
|
|
_register(QUOTE4)
|
|
|
|
|
|
# To create a new release, open a PR into `master`. In it, bump the toolchain
|
|
# and all dependencies.
|
|
#
|
|
# For `v4.X.0-rc1` releases, use the existing `bump/v4.X.0` branch from the
|
|
# nightly repo. To get the latest nightly fixes, you may need to merge the
|
|
# latest `bump/nightly-YYYY-MM-DD` PRs, or merge `nightly-testing` directly.
|
|
# After merging the PR, create a new `bump/v4.X+1.0` branch off of `master`.
|
|
#
|
|
# For other releases, create a new branch off of `master` and use it for the PR.
|
|
#
|
|
# Once the release PR is merged, tag the resulting commit with the lean version.
|
|
# Then, update the `stable` branch to point to the same commit.
|
|
MATHLIB4 = ReleaseRepo(
|
|
github=("leanprover-community", "mathlib4"),
|
|
nightly=ReleaseRepo(github=("leanprover-community", "mathlib4-nightly-testing")),
|
|
bump_branch=True,
|
|
release_tag="lean",
|
|
stable_branch="stable",
|
|
strong_deps=[BATTERIES, QUOTE4, AESOP, PROOFWIDGETS4, IMPORT_GRAPH, PLAUSIBLE],
|
|
)
|
|
_register(MATHLIB4)
|
|
|
|
|
|
# To create a new release, open a PR into `main`. In it, bump the toolchain and
|
|
# all dependencies.
|
|
#
|
|
# For `v4.X.0-rc1` releases, use the existing `bump/v4.X.0` branch. To get the
|
|
# latest nightly fixes, you may need to merge the latest
|
|
# `bump/nightly-YYYY-MM-DD` PRs, or merge `nightly-testing` directly. After
|
|
# merging the PR, create a new `bump/v4.X+1.0` branch off of `main`.
|
|
#
|
|
# For other releases, create a new branch off of `main` and use it for the PR.
|
|
#
|
|
# Once the release PR is merged, tag the resulting commit with the lean version.
|
|
# Then, update the `stable` branch to point to the same commit.
|
|
CSLIB = ReleaseRepo(
|
|
github=("leanprover", "cslib"),
|
|
bump_branch=True,
|
|
release_tag="lean",
|
|
stable_branch="stable",
|
|
strong_deps=[MATHLIB4],
|
|
)
|
|
_register(CSLIB)
|
|
|
|
|
|
# To create a new release, open a PR into `main`. In it, bump the toolchain and
|
|
# all dependencies. Also bump the toolchain and deps in `test/Mathlib`. Maybe
|
|
# run the tests locally before creating the PR? For `v4.X.0-rc1` releases, you
|
|
# may need to merge `nightly-testing` into the PR.
|
|
#
|
|
# Once the release PR is merged, tag the resulting commit with the lean version.
|
|
# Then, update the `stable` branch to point to the same commit.
|
|
REPL = ReleaseRepo(
|
|
github=("leanprover-community", "repl"),
|
|
release_tag="lean",
|
|
stable_branch="stable",
|
|
strong_deps=[MATHLIB4], # For tests in CI
|
|
)
|
|
_register(REPL)
|
|
|
|
|
|
# To create a new release, open a PR into `main`. In it, bump the toolchain and
|
|
# all dependencies, then run `update-subverso.sh`. For `v4.X.0-rc1` releases,
|
|
# you may need to merge `nightly-testing` into the PR.
|
|
#
|
|
# Once the release PR is merged, tag the resulting commit with the lean version.
|
|
VERSO = ReleaseRepo(
|
|
github=("leanprover", "verso"),
|
|
release_tag="lean",
|
|
strong_deps=[PLAUSIBLE],
|
|
weak_deps=[MATHLIB4], # For benchmarks
|
|
)
|
|
_register(VERSO)
|
|
|
|
# To create a new release, open a PR into `main`. In it, bump the toolchain and
|
|
# all dependencies. For `v4.X.0-rc1` releases, you may need to merge
|
|
# `nightly-testing` into the PR.
|
|
#
|
|
# Once the release PR is merged, tag the resulting commit with the lean version.
|
|
VERSO_WEB_COMPONENTS = ReleaseRepo(
|
|
github=("leanprover", "verso-web-components"),
|
|
release_tag="lean",
|
|
strong_deps=[VERSO],
|
|
)
|
|
_register(VERSO_WEB_COMPONENTS)
|
|
|
|
|
|
# To bump the toolchain, open a PR into `main`. In it, bump the toolchain and
|
|
# all dependencies.
|
|
#
|
|
# For `v4.X.0-rc1` releases, generate a new set of release notes and ensure
|
|
# they're imported and linked. For other releases, regenerate the existing
|
|
# release notes. For `v4.X.0-rc1` releases, you may also need to merge
|
|
# `nightly-testing` into the PR.
|
|
#
|
|
# Once the toolchain bump PR is merged, tag the resulting commit with the lean
|
|
# version. If the tag already exists, it may need to be updated manually.
|
|
#
|
|
# Highlights should be added in a separate PR and merged only shortly before the
|
|
# final release. That way, they don't get in the way of the RC bumps and can be
|
|
# commented on by the other developers.
|
|
REFERENCE_MANUAL = ReleaseRepo(
|
|
github=("leanprover", "reference-manual"),
|
|
release_tag="lean",
|
|
strong_deps=[VERSO_WEB_COMPONENTS, VERSO],
|
|
)
|
|
_register(REFERENCE_MANUAL)
|
|
|
|
|
|
# To create a new release, open a PR into `main`. In it, bump the toolchain and
|
|
# all dependencies. Also bump the toolchain and dependencies in `examples/hero`.
|
|
# Finally, run `scripts/update.sh`. For `v4.X.0-rc1` releases, you may need to
|
|
# merge `nightly-testing` into the PR.
|
|
LEAN_FRO_ORG = ReleaseRepo(
|
|
github=("leanprover", "lean-fro.org"),
|
|
strong_deps=[VERSO, VERSO_WEB_COMPONENTS],
|
|
)
|
|
_register(LEAN_FRO_ORG)
|
|
|
|
|
|
# To create a new release, trigger the "Update Toolchain" CI workflow and wait
|
|
# for it to open a PR, then merge the PR if it looks good. For non-RC releases,
|
|
# wait for the maintainer to release a new version.
|
|
LEAN4_UNICODE_BASIC = ReleaseRepo(
|
|
github=("fgdorais", "lean4-unicode-basic"),
|
|
)
|
|
_register(LEAN4_UNICODE_BASIC)
|
|
|
|
|
|
# To create a new release, open a PR into `master`. In it, bump the toolchain
|
|
# and all dependencies. For `v4.X.0-rc1` releases, you may need to merge
|
|
# `nightly-testing` into the PR.
|
|
BIBTEX_QUERY = ReleaseRepo(
|
|
github=("dupuisf", "BibtexQuery"),
|
|
release_tag="lean",
|
|
strong_deps=[LEAN4_UNICODE_BASIC],
|
|
)
|
|
_register(BIBTEX_QUERY)
|
|
|
|
# To create a new release, open a PR into `master`. In it, bump the toolchain
|
|
# and all dependencies.
|
|
#
|
|
# Once the release PR is merged, tag the resulting commit with the lean version.
|
|
LEANSQLITE = ReleaseRepo(
|
|
github=("leanprover", "leansqlite"),
|
|
release_tag="lean",
|
|
strong_deps=[PLAUSIBLE],
|
|
)
|
|
_register(LEANSQLITE)
|
|
|
|
# To create a new release, open a PR into `main`. In it, bump the toolchain and
|
|
# all dependencies. For `v4.X.0-rc1` releases, you may need to merge
|
|
# `nightly-testing` into the PR.
|
|
#
|
|
# Once the release PR is merged, tag the resulting commit with the lean version.
|
|
DOC_GEN4 = ReleaseRepo(
|
|
github=("leanprover", "doc-gen4"),
|
|
release_tag="lean",
|
|
strong_deps=[BIBTEX_QUERY, LEAN4_UNICODE_BASIC, LEAN4_CLI, LEANSQLITE],
|
|
# Doc-gen4 shouldn't lag behind mathlib if possible because of downstream
|
|
# users, and doc-gen4 benchmarks failing for a short while is an acceptable
|
|
# price to pay for that.
|
|
# https://leanprover.zulipchat.com/#narrow/channel/287929-mathlib4/topic/Tagging.20commits.20in.20mathlib4/near/585725955
|
|
ignored_deps=[MATHLIB4], # For benchmarks
|
|
)
|
|
_register(DOC_GEN4)
|
|
BATTERIES.ignored_deps.append(DOC_GEN4)
|
|
|
|
|
|
# To create a new release, open a PR into `master`. In it, bump the toolchain
|
|
# and all dependencies.
|
|
#
|
|
# Once the release PR is merged, tag the resulting commit with the lean version.
|
|
COMPARATOR = ReleaseRepo(
|
|
github=("leanprover", "comparator"),
|
|
release_tag="lean",
|
|
)
|
|
_register(COMPARATOR)
|
|
|
|
|
|
# To create a new release, open a PR into `master`. In it, bump the toolchain
|
|
# and all dependencies.
|
|
#
|
|
# Once the release PR is merged, tag the resulting commit with the lean version.
|
|
LEAN4EXPORT = ReleaseRepo(
|
|
github=("leanprover", "lean4export"),
|
|
release_tag="lean",
|
|
)
|
|
_register(LEAN4EXPORT)
|
|
|
|
|
|
###################
|
|
## Visualization ##
|
|
###################
|
|
|
|
|
|
def transitive_strong_deps(repo: ReleaseRepo) -> set[str]:
|
|
result = set()
|
|
for dep in repo.strong_deps:
|
|
result.add(dep.gh_full_name)
|
|
result |= transitive_strong_deps(dep)
|
|
return result
|
|
|
|
|
|
def indirect_strong_deps(repo: ReleaseRepo) -> set[str]:
|
|
result = set()
|
|
for dep in repo.strong_deps:
|
|
result |= transitive_strong_deps(dep)
|
|
return result
|
|
|
|
|
|
def graphviz_attrs(**kwargs: str) -> str:
|
|
if not kwargs:
|
|
return ""
|
|
style_str = " ".join(f"{k}=<{v}>" for k, v in kwargs.items())
|
|
return f" [{style_str}]"
|
|
|
|
|
|
def print_graphviz_line(
|
|
repo: ReleaseRepo,
|
|
dep: ReleaseRepo,
|
|
comment: bool = False,
|
|
attrs: dict[str, str] | None = None,
|
|
) -> None:
|
|
comment_str = "// " if comment else ""
|
|
attrs_str = graphviz_attrs(**attrs or {})
|
|
print(f' {comment_str}"{dep.gh_full_name}" -> "{repo.gh_full_name}"{attrs_str};')
|
|
|
|
|
|
def print_graphviz_dot(
|
|
prune: bool = True, no_weak: bool = False, no_ignored: bool = False
|
|
) -> None:
|
|
print("digraph G {")
|
|
print(" rankdir=LR;")
|
|
|
|
for repo in sorted(ALL, key=lambda r: r.gh_full_name):
|
|
indirect = indirect_strong_deps(repo)
|
|
|
|
# label = f"<FONT POINT_SIZE=10>{repo.gh_owner}</FONT>{repo.gh_name}"
|
|
label = f'<FONT POINT-SIZE="8">{repo.gh_owner}</FONT><BR/>{repo.gh_name}'
|
|
attrs = {"label": label}
|
|
if repo.completed:
|
|
attrs["style"] = "filled"
|
|
attrs["color"] = "palegreen"
|
|
print(f' "{repo.gh_full_name}"{graphviz_attrs(**attrs)};')
|
|
|
|
for dep in repo.strong_deps:
|
|
comment = prune and dep.gh_full_name in indirect
|
|
print_graphviz_line(repo, dep, comment=comment)
|
|
for dep in repo.weak_deps:
|
|
comment = no_weak or (prune and dep.gh_full_name in indirect)
|
|
print_graphviz_line(repo, dep, comment=comment, attrs={"style": "dashed"})
|
|
for dep in repo.ignored_deps:
|
|
comment = no_ignored or (prune and dep.gh_full_name in indirect)
|
|
attrs = {"style": "dashed", "color": "red", "constraint": "false"}
|
|
print_graphviz_line(repo, dep, comment=comment, attrs=attrs)
|
|
|
|
print("}")
|
|
|
|
|
|
def print_all_urls() -> None:
|
|
for repo in ALL:
|
|
print(f"- {repo.gh_url}")
|
|
|
|
|
|
def clone_all_repos() -> None:
|
|
for repo in ALL:
|
|
print(f"Cloning {repo.gh_full_name}...")
|
|
repo.local.prepare()
|
|
|
|
|
|
class Args:
|
|
graph: bool
|
|
prune: bool
|
|
no_weak: bool
|
|
no_ignored: bool
|
|
urls: bool
|
|
clone: bool
|
|
|
|
|
|
if __name__ == "__main__":
|
|
parser = ArgumentParser()
|
|
parser.add_argument("-g", "--graph", action="store_true")
|
|
parser.add_argument("-p", "--prune", action="store_true")
|
|
parser.add_argument("-W", "--no-weak", action="store_true")
|
|
parser.add_argument("-I", "--no-ignored", action="store_true")
|
|
parser.add_argument("-u", "--urls", action="store_true")
|
|
parser.add_argument("-c", "--clone", action="store_true")
|
|
args = parser.parse_args(namespace=Args())
|
|
|
|
if args.graph:
|
|
print_graphviz_dot(
|
|
prune=args.prune, no_weak=args.no_weak, no_ignored=args.no_ignored
|
|
)
|
|
|
|
if args.urls:
|
|
print_all_urls()
|
|
|
|
if args.clone:
|
|
clone_all_repos()
|