From 2ca4120e83bb206423a04c48c223602c0894613d Mon Sep 17 00:00:00 2001 From: Nikhil Pareek <8347993+nik13@users.noreply.github.com> Date: Sat, 31 Oct 2026 19:09:00 -0700 Subject: [PATCH 1/4] ci(release): scope release completion to the release PR and stop republishing Java reactors complete_release.py kept a merged release PR at "autorelease: pending" until every manifest version had a GitHub release, so first-time PyPI projects waiting on the new-project rate limit blocked every later release PR. It now requires only the versions the release PR changed (manifest at the merge commit vs its first parent), falling back to every package when that cannot be read, and creates the "autorelease: tagged" label if it is missing. The Java plan treated a reactor version as unpublished when any module was missing from Central, so adding a module after 1.0.0 re-deployed 1.0.0 and Central refused it. The reactor is one all-or-nothing deployment: the parent decides, and a module added later ships with the next version. Co-Authored-By: Claude Opus 5.5 --- .github/release/complete_release.py | 33 ++++++++++- .github/release/release_plan.py | 16 ++++-- .github/release/test_release_extensions.py | 65 +++++++++++++++++++++- 3 files changed, 108 insertions(+), 6 deletions(-) diff --git a/.github/release/complete_release.py b/.github/release/complete_release.py index 306d64963..4f1f164db 100644 --- a/.github/release/complete_release.py +++ b/.github/release/complete_release.py @@ -4,6 +4,7 @@ release-please release-pr refuses new PRs while a merged release PR is pending. Publishers own the tags, so they must also acknowledge completed release PRs. """ +import base64 import json import os import subprocess @@ -16,10 +17,26 @@ def gh_json(*args): return json.loads(subprocess.check_output(["gh", *args], text=True)) +def changed_release_paths(repo, pr): + """Manifest paths whose version this merged release PR changed, or None when that cannot be read.""" + try: + merge = pr["mergeCommit"]["oid"] + parent = gh_json("api", f"repos/{repo}/commits/{merge}")["parents"][0]["sha"] + + def manifest(ref): + d = gh_json("api", f"repos/{repo}/contents/.release-please-manifest.json?ref={ref}") + return json.loads(base64.b64decode(d["content"])) + + before, after = manifest(parent), manifest(merge) + return {path for path, version in after.items() if before.get(path) != version} + except Exception: + return None + + def main(): repo = os.environ["GITHUB_REPOSITORY"] pending = gh_json("pr", "list", "--repo", repo, "--base", "main", "--state", "merged", "--label", "autorelease: pending", - "--limit", "100", "--json", "number,headRefName") + "--limit", "100", "--json", "number,headRefName,mergeCommit") pending = [p for p in pending if p["headRefName"].startswith("release-please--branches--main")] if not pending: return @@ -27,6 +44,18 @@ def main(): tags = {r["tag_name"] for page in releases for r in page} skip = load_config().get("skip", {}) packages = python_packages(REPO_ROOT) + typescript_packages(REPO_ROOT) + other_packages(REPO_ROOT) + # Only the versions these release PRs changed must be released. A first-time package that is + # still waiting on its registry must not hold back every later release. If a PR's changes cannot + # be read, fall back to requiring every package. + scope = set() + for pr in pending: + paths = changed_release_paths(repo, pr) + if paths is None: + scope = None + break + scope |= paths + if scope is not None: + packages = [p for p in packages if p.get("release_path", p["dir"]) in scope] missing = [p["tag"] for p in packages if p["name"] not in skip and p["tag"] not in tags] if missing: print(f"Still pending: {len(missing)} package releases; finish credentials/publishing and rerun Release.") @@ -38,6 +67,8 @@ def main(): if versions is None or package["version"] not in versions: print(f"Still pending: {package['name']} {package['version']} is not served by its registry") return + subprocess.run(["gh", "label", "create", "autorelease: tagged", "--repo", repo, "--force", "--color", "0e8a16", + "--description", "release-please: release PR whose versions are all tagged and released"], check=False) for pr in pending: subprocess.run(["gh", "pr", "edit", str(pr["number"]), "--repo", repo, "--remove-label", "autorelease: pending", "--add-label", "autorelease: tagged"], check=True) diff --git a/.github/release/release_plan.py b/.github/release/release_plan.py index f54b2256a..ccac4d69e 100644 --- a/.github/release/release_plan.py +++ b/.github/release/release_plan.py @@ -219,16 +219,24 @@ def published_versions(p: dict) -> set[str] | None: return {p["version"]} if d else None if eco == "java": # Query canonical repository files rather than the eventually consistent search index. - # One reactor publishes together; do not skip if any module is missing. - for artifact in p["artifacts"]: + # One reactor publishes together in a single Central deployment, so the parent decides whether + # this version is published. Central never accepts a second upload of a published version: a + # module added after that ships with the next reactor version. + def on_central(artifact): url = f"https://repo.maven.apache.org/maven2/{p['group'].replace('.', '/')}/{artifact}/{p['version']}/{artifact}-{p['version']}.pom" try: with urllib.request.urlopen(url, timeout=30): - pass + return True except urllib.error.HTTPError as e: if e.code == 404: - return None + return False raise + parent, *modules = p["artifacts"] # other_packages lists the reactor parent first + if not on_central(parent): + return None + later = [a for a in modules if not on_central(a)] + if later: + print(f"{p['group']}:{parent} {p['version']} is published; {', '.join(later)} ship with the next reactor version", file=sys.stderr) return {p["version"]} raise ValueError(f"Unknown ecosystem: {eco}") diff --git a/.github/release/test_release_extensions.py b/.github/release/test_release_extensions.py index a66b960c6..14eb053d8 100644 --- a/.github/release/test_release_extensions.py +++ b/.github/release/test_release_extensions.py @@ -67,11 +67,16 @@ def test_java_cannot_publish_legacy_or_snapshot_coordinates(self): p.update(group='com.futureagi', version='1.1.0-SNAPSHOT') self.assertEqual(release_plan.plan([p], {}, offline=True)['java'], []) - def test_java_skip_requires_every_reactor_artifact_on_central(self): + def test_java_reactor_version_is_published_when_its_parent_is_on_central(self): + # Central deploys the reactor as one bundle, so the parent decides. A module missing at a + # published version was added later and ships with the next version (Central refuses re-uploads). p = {'ecosystem': 'java', 'group': 'com.futureagi', 'version': '1.0.0', 'artifacts': ['parent', 'core']} context = Mock(); context.__enter__ = Mock(); context.__exit__ = Mock(return_value=False) with patch('urllib.request.urlopen', side_effect=[context, urllib.error.HTTPError('url', 404, 'missing', {}, None)]): + self.assertEqual(release_plan.published_versions(p), {'1.0.0'}) + with patch('urllib.request.urlopen', side_effect=[urllib.error.HTTPError('url', 404, 'missing', {}, None)]) as get: self.assertIsNone(release_plan.published_versions(p)) + self.assertEqual(get.call_count, 1) with patch('urllib.request.urlopen', return_value=context) as get: self.assertEqual(release_plan.published_versions(p), {'1.0.0'}) self.assertEqual(get.call_count, 2) @@ -122,6 +127,64 @@ def test_completion_does_not_acknowledge_go_tag_until_proxy_serves_version(self) complete_release.main() run.assert_not_called() + def test_completion_requires_only_the_versions_the_release_pr_changed(self): + # A first-time package still waiting on its registry must not block an unrelated release PR. + released = {'ecosystem': 'python', 'name': 'a', 'version': '0.1.1', 'tag': 'a-v0.1.1', 'dir': 'python/frameworks/a'} + waiting = {'ecosystem': 'python', 'name': 'b', 'version': '0.1.0', 'tag': 'b-v0.1.0', 'dir': 'python/frameworks/b'} + pending = [{'number': 7, 'headRefName': 'release-please--branches--main', 'mergeCommit': {'oid': 'm'}}] + with patch.dict(os.environ, {'GITHUB_REPOSITORY': 'owner/repo'}), \ + patch.object(complete_release, 'gh_json', side_effect=[pending, [[{'tag_name': 'a-v0.1.1'}]]]), \ + patch.object(complete_release, 'changed_release_paths', return_value={'python/frameworks/a'}), \ + patch.object(complete_release, 'python_packages', return_value=[released, waiting]), \ + patch.object(complete_release, 'typescript_packages', return_value=[]), \ + patch.object(complete_release, 'other_packages', return_value=[]), \ + patch.object(complete_release, 'load_config', return_value={'skip': {}}), \ + patch.object(complete_release, 'published_versions', return_value={'0.1.1'}), \ + patch('subprocess.run') as run: + complete_release.main() + commands = [c.args[0] for c in run.call_args_list] + self.assertIn(['gh', 'pr', 'edit', '7', '--repo', 'owner/repo', '--remove-label', 'autorelease: pending', '--add-label', 'autorelease: tagged'], commands) + self.assertTrue(any(c[:3] == ['gh', 'label', 'create'] for c in commands), 'the tagged label is created when missing') + + def test_completion_still_waits_for_a_version_the_release_pr_changed(self): + changed = {'ecosystem': 'python', 'name': 'a', 'version': '0.1.1', 'tag': 'a-v0.1.1', 'dir': 'python/frameworks/a'} + pending = [{'number': 7, 'headRefName': 'release-please--branches--main', 'mergeCommit': {'oid': 'm'}}] + with patch.dict(os.environ, {'GITHUB_REPOSITORY': 'owner/repo'}), \ + patch.object(complete_release, 'gh_json', side_effect=[pending, [[]]]), \ + patch.object(complete_release, 'changed_release_paths', return_value={'python/frameworks/a'}), \ + patch.object(complete_release, 'python_packages', return_value=[changed]), \ + patch.object(complete_release, 'typescript_packages', return_value=[]), \ + patch.object(complete_release, 'other_packages', return_value=[]), \ + patch.object(complete_release, 'load_config', return_value={'skip': {}}), \ + patch('subprocess.run') as run: + complete_release.main() + run.assert_not_called() + + def test_changed_release_paths_compares_the_manifest_across_the_merge(self): + import base64 as b64 + enc = lambda d: {'content': b64.b64encode(json.dumps(d).encode()).decode()} + replies = {'repos/o/r/commits/m': {'parents': [{'sha': 'p'}]}, + 'repos/o/r/contents/.release-please-manifest.json?ref=p': enc({'x': '1.0.0', 'y': '0.1.0'}), + 'repos/o/r/contents/.release-please-manifest.json?ref=m': enc({'x': '1.0.1', 'y': '0.1.0', 'z': '0.1.0'})} + with patch.object(complete_release, 'gh_json', side_effect=lambda *a: replies[a[1]]): + self.assertEqual(complete_release.changed_release_paths('o/r', {'mergeCommit': {'oid': 'm'}}), {'x', 'z'}) + self.assertIsNone(complete_release.changed_release_paths('o/r', {'number': 1})) + + def test_java_new_module_does_not_republish_a_published_reactor(self): + import urllib.error as ue + p = {'ecosystem': 'java', 'name': 'com.futureagi:traceai-java-parent', 'group': 'com.futureagi', 'version': '1.0.0', + 'artifacts': ['traceai-java-parent', 'traceai-java-core', 'traceai-java-new']} # parent first, as other_packages builds it + def urlopen(url, timeout=30): + if 'traceai-java-new' in url: + raise ue.HTTPError(url, 404, 'not found', {}, None) + return Mock(__enter__=lambda s: s, __exit__=lambda *a: False) + with patch.object(release_plan.urllib.request, 'urlopen', side_effect=urlopen): + self.assertEqual(release_plan.published_versions(p), {'1.0.0'}) + def missing_parent(url, timeout=30): + raise ue.HTTPError(url, 404, 'not found', {}, None) + with patch.object(release_plan.urllib.request, 'urlopen', side_effect=missing_parent): + self.assertIsNone(release_plan.published_versions(p)) + def test_workflow_plan_orders_every_npm_dependency_edge(self): with tempfile.TemporaryDirectory() as d: root = Path(d) From 421f0b8d9b31dec568a5bbc6ef2846872b82176a Mon Sep 17 00:00:00 2001 From: Nikhil Pareek <8347993+nik13@users.noreply.github.com> Date: Sat, 31 Oct 2026 19:26:43 -0700 Subject: [PATCH 2/4] ci(release): keep release verification strict and check the released versions Review of the previous commit found two problems. published_versions also feeds the post-deploy Central poll in release-java.yml and the final registry gate in complete_release.py, which must still see every reactor artifact; only the plan's skip decision now passes strict=False. And completion checked the versions in the current checkout, which a later bump on main may have moved past; it now checks the versions (and tags) from the release PR's merge-commit manifest. Co-Authored-By: Claude Opus 5.5 --- .github/release/complete_release.py | 23 ++++++++---- .github/release/release_plan.py | 13 ++++--- .github/release/test_release_extensions.py | 41 ++++++++++++++++++---- .github/release/test_release_plan.py | 4 +-- 4 files changed, 61 insertions(+), 20 deletions(-) diff --git a/.github/release/complete_release.py b/.github/release/complete_release.py index 4f1f164db..7b4680f7a 100644 --- a/.github/release/complete_release.py +++ b/.github/release/complete_release.py @@ -18,7 +18,7 @@ def gh_json(*args): def changed_release_paths(repo, pr): - """Manifest paths whose version this merged release PR changed, or None when that cannot be read.""" + """{manifest path: version} for every version this merged release PR changed, or None when that cannot be read.""" try: merge = pr["mergeCommit"]["oid"] parent = gh_json("api", f"repos/{repo}/commits/{merge}")["parents"][0]["sha"] @@ -28,11 +28,19 @@ def manifest(ref): return json.loads(base64.b64decode(d["content"])) before, after = manifest(parent), manifest(merge) - return {path for path, version in after.items() if before.get(path) != version} + return {path: version for path, version in after.items() if before.get(path) != version} except Exception: return None +def with_version(package, version): + """The package as released at version: tags end in the version (name-vX, npm-...-vX, java-vX, go/x/vX).""" + tag = package["tag"] + if tag.endswith(package["version"]): + tag = tag[: -len(package["version"])] + version + return {**package, "version": version, "tag": tag} + + def main(): repo = os.environ["GITHUB_REPOSITORY"] pending = gh_json("pr", "list", "--repo", repo, "--base", "main", "--state", "merged", "--label", "autorelease: pending", @@ -47,15 +55,16 @@ def main(): # Only the versions these release PRs changed must be released. A first-time package that is # still waiting on its registry must not hold back every later release. If a PR's changes cannot # be read, fall back to requiring every package. - scope = set() + scope = {} for pr in pending: - paths = changed_release_paths(repo, pr) - if paths is None: + changed = changed_release_paths(repo, pr) + if changed is None: scope = None break - scope |= paths + scope.update(changed) if scope is not None: - packages = [p for p in packages if p.get("release_path", p["dir"]) in scope] + # Check the versions the release PRs released, which a later bump on main may have moved past. + packages = [with_version(p, scope[path]) for p in packages if (path := p.get("release_path", p["dir"])) in scope] missing = [p["tag"] for p in packages if p["name"] not in skip and p["tag"] not in tags] if missing: print(f"Still pending: {len(missing)} package releases; finish credentials/publishing and rerun Release.") diff --git a/.github/release/release_plan.py b/.github/release/release_plan.py index ccac4d69e..d02832306 100644 --- a/.github/release/release_plan.py +++ b/.github/release/release_plan.py @@ -201,7 +201,7 @@ def _get_json(url: str) -> dict | None: raise # Authentication failures, rate limits and server errors must never mean 'not published'. -def published_versions(p: dict) -> set[str] | None: +def published_versions(p: dict, *, strict: bool = True) -> set[str] | None: eco = p["ecosystem"] if eco == "python": d = _get_json(f"https://pypi.org/pypi/{p['name']}/json") @@ -219,9 +219,10 @@ def published_versions(p: dict) -> set[str] | None: return {p["version"]} if d else None if eco == "java": # Query canonical repository files rather than the eventually consistent search index. - # One reactor publishes together in a single Central deployment, so the parent decides whether - # this version is published. Central never accepts a second upload of a published version: a - # module added after that ships with the next reactor version. + # Verification (strict) needs every reactor artifact served. The plan's skip decision + # (strict=False) needs only the parent: the reactor is one Central deployment, Central never + # accepts a second upload of a published version, and a module added later ships with the + # next reactor version. def on_central(artifact): url = f"https://repo.maven.apache.org/maven2/{p['group'].replace('.', '/')}/{artifact}/{p['version']}/{artifact}-{p['version']}.pom" try: @@ -235,6 +236,8 @@ def on_central(artifact): if not on_central(parent): return None later = [a for a in modules if not on_central(a)] + if later and strict: + return None if later: print(f"{p['group']}:{parent} {p['version']} is published; {', '.join(later)} ship with the next reactor version", file=sys.stderr) return {p["version"]} @@ -255,7 +258,7 @@ def plan(packages: list[dict], config: dict, *, offline: bool = False, only: set out["skipped"].append({"name": p["name"], "reason": "Central requires com.futureagi release coordinates; merge the Java release-profile PR first"}) continue if not offline: - have = published_versions(p) + have = published_versions(p, strict=False) published = have is not None and p["version"] in have if published and not include_published: out["skipped"].append({"name": p["name"], "reason": f"{p['version']} is already published"}) diff --git a/.github/release/test_release_extensions.py b/.github/release/test_release_extensions.py index 14eb053d8..4fede9ece 100644 --- a/.github/release/test_release_extensions.py +++ b/.github/release/test_release_extensions.py @@ -67,13 +67,15 @@ def test_java_cannot_publish_legacy_or_snapshot_coordinates(self): p.update(group='com.futureagi', version='1.1.0-SNAPSHOT') self.assertEqual(release_plan.plan([p], {}, offline=True)['java'], []) - def test_java_reactor_version_is_published_when_its_parent_is_on_central(self): + def test_java_verification_needs_every_artifact_and_the_plan_only_the_parent(self): # Central deploys the reactor as one bundle, so the parent decides. A module missing at a # published version was added later and ships with the next version (Central refuses re-uploads). p = {'ecosystem': 'java', 'group': 'com.futureagi', 'version': '1.0.0', 'artifacts': ['parent', 'core']} context = Mock(); context.__enter__ = Mock(); context.__exit__ = Mock(return_value=False) with patch('urllib.request.urlopen', side_effect=[context, urllib.error.HTTPError('url', 404, 'missing', {}, None)]): - self.assertEqual(release_plan.published_versions(p), {'1.0.0'}) + self.assertIsNone(release_plan.published_versions(p)) + with patch('urllib.request.urlopen', side_effect=[context, urllib.error.HTTPError('url', 404, 'missing', {}, None)]): + self.assertEqual(release_plan.published_versions(p, strict=False), {'1.0.0'}) with patch('urllib.request.urlopen', side_effect=[urllib.error.HTTPError('url', 404, 'missing', {}, None)]) as get: self.assertIsNone(release_plan.published_versions(p)) self.assertEqual(get.call_count, 1) @@ -134,7 +136,7 @@ def test_completion_requires_only_the_versions_the_release_pr_changed(self): pending = [{'number': 7, 'headRefName': 'release-please--branches--main', 'mergeCommit': {'oid': 'm'}}] with patch.dict(os.environ, {'GITHUB_REPOSITORY': 'owner/repo'}), \ patch.object(complete_release, 'gh_json', side_effect=[pending, [[{'tag_name': 'a-v0.1.1'}]]]), \ - patch.object(complete_release, 'changed_release_paths', return_value={'python/frameworks/a'}), \ + patch.object(complete_release, 'changed_release_paths', return_value={'python/frameworks/a': '0.1.1'}), \ patch.object(complete_release, 'python_packages', return_value=[released, waiting]), \ patch.object(complete_release, 'typescript_packages', return_value=[]), \ patch.object(complete_release, 'other_packages', return_value=[]), \ @@ -151,7 +153,7 @@ def test_completion_still_waits_for_a_version_the_release_pr_changed(self): pending = [{'number': 7, 'headRefName': 'release-please--branches--main', 'mergeCommit': {'oid': 'm'}}] with patch.dict(os.environ, {'GITHUB_REPOSITORY': 'owner/repo'}), \ patch.object(complete_release, 'gh_json', side_effect=[pending, [[]]]), \ - patch.object(complete_release, 'changed_release_paths', return_value={'python/frameworks/a'}), \ + patch.object(complete_release, 'changed_release_paths', return_value={'python/frameworks/a': '0.1.1'}), \ patch.object(complete_release, 'python_packages', return_value=[changed]), \ patch.object(complete_release, 'typescript_packages', return_value=[]), \ patch.object(complete_release, 'other_packages', return_value=[]), \ @@ -160,6 +162,29 @@ def test_completion_still_waits_for_a_version_the_release_pr_changed(self): complete_release.main() run.assert_not_called() + def test_completion_checks_the_released_version_not_the_current_checkout(self): + # main has moved on to 0.1.2; the pending release PR released 0.1.1. + package = {'ecosystem': 'python', 'name': 'a', 'version': '0.1.2', 'tag': 'a-v0.1.2', 'dir': 'python/frameworks/a'} + pending = [{'number': 7, 'headRefName': 'release-please--branches--main', 'mergeCommit': {'oid': 'm'}}] + seen = [] + with patch.dict(os.environ, {'GITHUB_REPOSITORY': 'owner/repo'}), \ + patch.object(complete_release, 'gh_json', side_effect=[pending, [[{'tag_name': 'a-v0.1.1'}]]]), \ + patch.object(complete_release, 'changed_release_paths', return_value={'python/frameworks/a': '0.1.1'}), \ + patch.object(complete_release, 'python_packages', return_value=[package]), \ + patch.object(complete_release, 'typescript_packages', return_value=[]), \ + patch.object(complete_release, 'other_packages', return_value=[]), \ + patch.object(complete_release, 'load_config', return_value={'skip': {}}), \ + patch.object(complete_release, 'published_versions', side_effect=lambda p: seen.append(p['version']) or {'0.1.1'}), \ + patch('subprocess.run') as run: + complete_release.main() + self.assertEqual(seen, ['0.1.1']) + self.assertTrue(any(c.args[0][:3] == ['gh', 'pr', 'edit'] for c in run.call_args_list)) + + def test_with_version_rewrites_every_tag_style(self): + for tag, version, want in (('traceai-a-v0.1.2', '0.1.1', 'traceai-a-v0.1.1'), ('npm-traceai-x-v1.2.0', '1.1.9', 'npm-traceai-x-v1.1.9'), + ('java-v1.0.2', '1.0.1', 'java-v1.0.1'), ('go/openai/v0.1.2', '0.1.1', 'go/openai/v0.1.1')): + self.assertEqual(complete_release.with_version({'tag': tag, 'version': tag.rsplit('v', 1)[1]}, version)['tag'], want) + def test_changed_release_paths_compares_the_manifest_across_the_merge(self): import base64 as b64 enc = lambda d: {'content': b64.b64encode(json.dumps(d).encode()).decode()} @@ -167,7 +192,7 @@ def test_changed_release_paths_compares_the_manifest_across_the_merge(self): 'repos/o/r/contents/.release-please-manifest.json?ref=p': enc({'x': '1.0.0', 'y': '0.1.0'}), 'repos/o/r/contents/.release-please-manifest.json?ref=m': enc({'x': '1.0.1', 'y': '0.1.0', 'z': '0.1.0'})} with patch.object(complete_release, 'gh_json', side_effect=lambda *a: replies[a[1]]): - self.assertEqual(complete_release.changed_release_paths('o/r', {'mergeCommit': {'oid': 'm'}}), {'x', 'z'}) + self.assertEqual(complete_release.changed_release_paths('o/r', {'mergeCommit': {'oid': 'm'}}), {'x': '1.0.1', 'z': '0.1.0'}) self.assertIsNone(complete_release.changed_release_paths('o/r', {'number': 1})) def test_java_new_module_does_not_republish_a_published_reactor(self): @@ -179,7 +204,11 @@ def urlopen(url, timeout=30): raise ue.HTTPError(url, 404, 'not found', {}, None) return Mock(__enter__=lambda s: s, __exit__=lambda *a: False) with patch.object(release_plan.urllib.request, 'urlopen', side_effect=urlopen): - self.assertEqual(release_plan.published_versions(p), {'1.0.0'}) + self.assertEqual(release_plan.published_versions(p, strict=False), {'1.0.0'}, 'the plan does not re-deploy 1.0.0') + self.assertIsNone(release_plan.published_versions(p), 'verification still needs every artifact') + planned = release_plan.plan([{**p, 'core': False}], {}) + self.assertEqual(planned['java'], []) + self.assertIn('1.0.0 is already published', planned['skipped'][0]['reason']) def missing_parent(url, timeout=30): raise ue.HTTPError(url, 404, 'not found', {}, None) with patch.object(release_plan.urllib.request, 'urlopen', side_effect=missing_parent): diff --git a/.github/release/test_release_plan.py b/.github/release/test_release_plan.py index 4a2c3d935..3055d43f5 100644 --- a/.github/release/test_release_plan.py +++ b/.github/release/test_release_plan.py @@ -108,7 +108,7 @@ def test_offline_plan_lists_everything_core_first_and_honours_skips(self): def test_plan_skips_published_versions(self): have = {"traceAI-openai": {"0.1.9", "0.1.10"}, "fi-instrumentation-otel": {"1.0.0"}, "@traceai/openai": None} - with patch.object(release_plan, 'published_versions', side_effect=lambda p: have.get(p["name"], set())): + with patch.object(release_plan, 'published_versions', side_effect=lambda p, **kw: have.get(p["name"], set())): p = release_plan.plan(self.packages, {"skip": {}}, only={"traceAI-openai", "fi-instrumentation-otel", "@traceai/openai"}) self.assertEqual([e["name"] for e in p["python"]], ["fi-instrumentation-otel"]) self.assertEqual([(e["name"], e["first_release"]) for e in p["typescript"]], [("@traceai/openai", True)]) @@ -117,7 +117,7 @@ def test_plan_skips_published_versions(self): def test_bootstrap_token_only_for_listed_projects_never_published(self): have = {"traceai-agno": None, "traceAI-openai": None, "fi-instrumentation-otel": {"1.0.0"}} cfg = {"skip": {}, "pypi_bootstrap_token": ["traceai-agno", "fi-instrumentation-otel"]} - with patch.object(release_plan, 'published_versions', side_effect=lambda p: have.get(p["name"], set())): + with patch.object(release_plan, 'published_versions', side_effect=lambda p, **kw: have.get(p["name"], set())): p = release_plan.plan(self.packages, cfg, only={"traceai-agno", "traceAI-openai", "fi-instrumentation-otel"}) self.assertEqual({e["name"]: e["pypi_bootstrap"] for e in p["python"]}, {"fi-instrumentation-otel": False, "traceai-agno": True, "traceAI-openai": False}) From 9e005cef867b744cbdc90d610f42d8709be08b5b Mon Sep 17 00:00:00 2001 From: Nikhil Pareek <8347993+nik13@users.noreply.github.com> Date: Sat, 31 Oct 2026 19:41:45 -0700 Subject: [PATCH 3/4] ci(release): complete each pending release PR on its own versions Merging every pending PR's changed versions into one map let a newer release PR's version be overwritten by an older one for the same package, and then both PRs were marked tagged. Each pending PR is now checked against its own versions and only the complete ones are marked. Co-Authored-By: Claude Opus 5.5 --- .github/release/complete_release.py | 51 ++++++++++++---------- .github/release/test_release_extensions.py | 19 ++++++++ 2 files changed, 48 insertions(+), 22 deletions(-) diff --git a/.github/release/complete_release.py b/.github/release/complete_release.py index 7b4680f7a..c52f13203 100644 --- a/.github/release/complete_release.py +++ b/.github/release/complete_release.py @@ -41,6 +41,20 @@ def with_version(package, version): return {**package, "version": version, "tag": tag} +def unreleased(packages, tags, skip): + """The first reason these package versions are not fully released, or None.""" + missing = [p["tag"] for p in packages if p["name"] not in skip and p["tag"] not in tags] + if missing: + return f"{len(missing)} package releases ({', '.join(missing[:5])}); finish credentials/publishing and rerun Release" + for package in packages: + if package["name"] in skip: + continue + versions = published_versions(package) + if versions is None or package["version"] not in versions: + return f"{package['name']} {package['version']} is not served by its registry" + return None + + def main(): repo = os.environ["GITHUB_REPOSITORY"] pending = gh_json("pr", "list", "--repo", repo, "--base", "main", "--state", "merged", "--label", "autorelease: pending", @@ -52,36 +66,29 @@ def main(): tags = {r["tag_name"] for page in releases for r in page} skip = load_config().get("skip", {}) packages = python_packages(REPO_ROOT) + typescript_packages(REPO_ROOT) + other_packages(REPO_ROOT) - # Only the versions these release PRs changed must be released. A first-time package that is - # still waiting on its registry must not hold back every later release. If a PR's changes cannot - # be read, fall back to requiring every package. - scope = {} + complete = [] for pr in pending: + # Each release PR is complete once the versions it changed are released, checked at the + # version it released (a later bump on main may have moved past it). A first-time package + # still waiting on its registry does not hold back unrelated release PRs. If a PR's changes + # cannot be read, require every package at its current version. changed = changed_release_paths(repo, pr) if changed is None: - scope = None - break - scope.update(changed) - if scope is not None: - # Check the versions the release PRs released, which a later bump on main may have moved past. - packages = [with_version(p, scope[path]) for p in packages if (path := p.get("release_path", p["dir"])) in scope] - missing = [p["tag"] for p in packages if p["name"] not in skip and p["tag"] not in tags] - if missing: - print(f"Still pending: {len(missing)} package releases; finish credentials/publishing and rerun Release.") + required = packages + else: + required = [with_version(p, changed[path]) for p in packages if (path := p.get("release_path", p["dir"])) in changed] + reason = unreleased(required, tags, skip) + if reason: + print(f"Still pending: release PR #{pr['number']}: {reason}") + else: + complete.append(pr) + if not complete: return - for package in packages: - if package["name"] in skip: - continue - versions = published_versions(package) - if versions is None or package["version"] not in versions: - print(f"Still pending: {package['name']} {package['version']} is not served by its registry") - return subprocess.run(["gh", "label", "create", "autorelease: tagged", "--repo", repo, "--force", "--color", "0e8a16", "--description", "release-please: release PR whose versions are all tagged and released"], check=False) - for pr in pending: + for pr in complete: subprocess.run(["gh", "pr", "edit", str(pr["number"]), "--repo", repo, "--remove-label", "autorelease: pending", "--add-label", "autorelease: tagged"], check=True) - if __name__ == "__main__": main() diff --git a/.github/release/test_release_extensions.py b/.github/release/test_release_extensions.py index 4fede9ece..ba2638a7e 100644 --- a/.github/release/test_release_extensions.py +++ b/.github/release/test_release_extensions.py @@ -180,6 +180,25 @@ def test_completion_checks_the_released_version_not_the_current_checkout(self): self.assertEqual(seen, ['0.1.1']) self.assertTrue(any(c.args[0][:3] == ['gh', 'pr', 'edit'] for c in run.call_args_list)) + def test_each_pending_release_pr_is_completed_on_its_own_versions(self): + # Two pending release PRs for the same package: only the one whose version is released completes. + package = {'ecosystem': 'python', 'name': 'a', 'version': '0.1.2', 'tag': 'a-v0.1.2', 'dir': 'python/frameworks/a'} + pending = [{'number': 9, 'headRefName': 'release-please--branches--main', 'mergeCommit': {'oid': 'n'}}, + {'number': 8, 'headRefName': 'release-please--branches--main', 'mergeCommit': {'oid': 'o'}}] + changed = {9: {'python/frameworks/a': '0.1.2'}, 8: {'python/frameworks/a': '0.1.1'}} + with patch.dict(os.environ, {'GITHUB_REPOSITORY': 'owner/repo'}), \ + patch.object(complete_release, 'gh_json', side_effect=[pending, [[{'tag_name': 'a-v0.1.1'}]]]), \ + patch.object(complete_release, 'changed_release_paths', side_effect=lambda repo, pr: changed[pr['number']]), \ + patch.object(complete_release, 'python_packages', return_value=[package]), \ + patch.object(complete_release, 'typescript_packages', return_value=[]), \ + patch.object(complete_release, 'other_packages', return_value=[]), \ + patch.object(complete_release, 'load_config', return_value={'skip': {}}), \ + patch.object(complete_release, 'published_versions', return_value={'0.1.1'}), \ + patch('subprocess.run') as run: + complete_release.main() + edits = [c.args[0][3] for c in run.call_args_list if c.args[0][:3] == ['gh', 'pr', 'edit']] + self.assertEqual(edits, ['8']) + def test_with_version_rewrites_every_tag_style(self): for tag, version, want in (('traceai-a-v0.1.2', '0.1.1', 'traceai-a-v0.1.1'), ('npm-traceai-x-v1.2.0', '1.1.9', 'npm-traceai-x-v1.1.9'), ('java-v1.0.2', '1.0.1', 'java-v1.0.1'), ('go/openai/v0.1.2', '0.1.1', 'go/openai/v0.1.1')): From 0bc3ffbe1f5b916ff799e0eb9aa15cf902baca9b Mon Sep 17 00:00:00 2001 From: Nikhil Pareek <8347993+nik13@users.noreply.github.com> Date: Sat, 31 Oct 2026 19:58:45 -0700 Subject: [PATCH 4/4] ci(release): keep a release PR pending when its released versions cannot be read Falling back to the current checkout could mark an older release PR tagged when its own version never shipped but a later one did. Co-Authored-By: Claude Opus 5.5 --- .github/release/complete_release.py | 8 +++---- .github/release/test_release_extensions.py | 25 +++++++++++++++++++--- 2 files changed, 26 insertions(+), 7 deletions(-) diff --git a/.github/release/complete_release.py b/.github/release/complete_release.py index c52f13203..eeaa90d4d 100644 --- a/.github/release/complete_release.py +++ b/.github/release/complete_release.py @@ -71,12 +71,12 @@ def main(): # Each release PR is complete once the versions it changed are released, checked at the # version it released (a later bump on main may have moved past it). A first-time package # still waiting on its registry does not hold back unrelated release PRs. If a PR's changes - # cannot be read, require every package at its current version. + # cannot be read, it stays pending: the current checkout says nothing about what it released. changed = changed_release_paths(repo, pr) if changed is None: - required = packages - else: - required = [with_version(p, changed[path]) for p in packages if (path := p.get("release_path", p["dir"])) in changed] + print(f"Still pending: release PR #{pr['number']}: could not read the versions it released") + continue + required = [with_version(p, changed[path]) for p in packages if (path := p.get("release_path", p["dir"])) in changed] reason = unreleased(required, tags, skip) if reason: print(f"Still pending: release PR #{pr['number']}: {reason}") diff --git a/.github/release/test_release_extensions.py b/.github/release/test_release_extensions.py index ba2638a7e..89215a3d2 100644 --- a/.github/release/test_release_extensions.py +++ b/.github/release/test_release_extensions.py @@ -123,9 +123,9 @@ def test_completion_only_considers_merged_release_please_branches(self): self.assertEqual(gh.call_count, 1) def test_completion_does_not_acknowledge_go_tag_until_proxy_serves_version(self): - package = {'ecosystem': 'go', 'name': 'example/module', 'version': '0.1.0', 'tag': 'go/module/v0.1.0'} - pending = [{'number': 1, 'headRefName': 'release-please--branches--main'}] - with patch.dict(os.environ, {'GITHUB_REPOSITORY': 'owner/repo'}), patch.object(complete_release, 'gh_json', side_effect=[pending, [[{'tag_name': package['tag']}]]]), patch.object(complete_release, 'python_packages', return_value=[]), patch.object(complete_release, 'typescript_packages', return_value=[]), patch.object(complete_release, 'other_packages', return_value=[package]), patch.object(complete_release, 'load_config', return_value={'skip': {}}), patch.object(complete_release, 'published_versions', return_value=None), patch('subprocess.run') as run: + package = {'ecosystem': 'go', 'name': 'example/module', 'version': '0.1.0', 'tag': 'go/module/v0.1.0', 'dir': 'go/module'} + pending = [{'number': 1, 'headRefName': 'release-please--branches--main', 'mergeCommit': {'oid': 'm'}}] + with patch.dict(os.environ, {'GITHUB_REPOSITORY': 'owner/repo'}), patch.object(complete_release, 'gh_json', side_effect=[pending, [[{'tag_name': package['tag']}]]]), patch.object(complete_release, 'changed_release_paths', return_value={'go/module': '0.1.0'}), patch.object(complete_release, 'python_packages', return_value=[]), patch.object(complete_release, 'typescript_packages', return_value=[]), patch.object(complete_release, 'other_packages', return_value=[package]), patch.object(complete_release, 'load_config', return_value={'skip': {}}), patch.object(complete_release, 'published_versions', return_value=None), patch('subprocess.run') as run: complete_release.main() run.assert_not_called() @@ -199,6 +199,25 @@ def test_each_pending_release_pr_is_completed_on_its_own_versions(self): edits = [c.args[0][3] for c in run.call_args_list if c.args[0][:3] == ['gh', 'pr', 'edit']] self.assertEqual(edits, ['8']) + def test_completion_keeps_a_release_pr_pending_when_its_versions_cannot_be_read(self): + # #8 released 0.1.1, which never shipped; its lookup fails while #9's 0.1.2 is released. + package = {'ecosystem': 'python', 'name': 'a', 'version': '0.1.2', 'tag': 'a-v0.1.2', 'dir': 'python/frameworks/a'} + pending = [{'number': 9, 'headRefName': 'release-please--branches--main', 'mergeCommit': {'oid': 'n'}}, + {'number': 8, 'headRefName': 'release-please--branches--main', 'mergeCommit': {'oid': 'o'}}] + changed = {9: {'python/frameworks/a': '0.1.2'}, 8: None} + with patch.dict(os.environ, {'GITHUB_REPOSITORY': 'owner/repo'}), \ + patch.object(complete_release, 'gh_json', side_effect=[pending, [[{'tag_name': 'a-v0.1.2'}]]]), \ + patch.object(complete_release, 'changed_release_paths', side_effect=lambda repo, pr: changed[pr['number']]), \ + patch.object(complete_release, 'python_packages', return_value=[package]), \ + patch.object(complete_release, 'typescript_packages', return_value=[]), \ + patch.object(complete_release, 'other_packages', return_value=[]), \ + patch.object(complete_release, 'load_config', return_value={'skip': {}}), \ + patch.object(complete_release, 'published_versions', return_value={'0.1.2'}), \ + patch('subprocess.run') as run: + complete_release.main() + edits = [c.args[0][3] for c in run.call_args_list if c.args[0][:3] == ['gh', 'pr', 'edit']] + self.assertEqual(edits, ['9']) + def test_with_version_rewrites_every_tag_style(self): for tag, version, want in (('traceai-a-v0.1.2', '0.1.1', 'traceai-a-v0.1.1'), ('npm-traceai-x-v1.2.0', '1.1.9', 'npm-traceai-x-v1.1.9'), ('java-v1.0.2', '1.0.1', 'java-v1.0.1'), ('go/openai/v0.1.2', '0.1.1', 'go/openai/v0.1.1')):