Refactor release tool commands into classes.

Factored out cmd_* functions from release.py into separate classes with explicit dependency injection of Git and GitHub helpers. This improves testability and code organization. Simplified mocks in tests to use injection instead of module-level patching.

Author: rickeylev

tests/tools/private/release/release_test.py

@@ -10,12 +10,17 @@ py_library(
 py_binary(
     name = "release",
     srcs = [
+        "__init__.py",
+        "complete_prepare.py",
         "create_rc.py",
         "create_release_branch.py",
+        "create_release_issue.py",
+        "determine_next_version.py",
         "gh.py",
         "git.py",
         "prepare.py",
         "process_backports.py",
+        "promote_rc.py",
         "release.py",
         "release_issue.py",
         "shell.py",

tools/private/release/BUILD.bazel

@@ -0,0 +1 @@
+"""Release tools package."""

tools/private/release/__init__.py

@@ -0,0 +1,81 @@
+"""Subcommand to mark preparation task as complete."""
+
+import re
+
+from tools.private.release.gh import GitHub
+from tools.private.release.release_issue import update_task_in_body
+
+
+class CompletePrepare:
+    """Class to mark preparation task as complete."""
+
+    def __init__(self, args, gh: GitHub):
+        self.args = args
+        self.gh = gh
+
+    def run(self) -> int:
+        """Executes the complete-prepare subcommand (Phase 2 PR merged)."""
+        args = self.args
+        print(f"Completing preparation for PR #{args.pr}...")
+
+        pr_info = self.gh.get_pr_info(args.pr)
+        if not pr_info or pr_info.get("state") != "MERGED":
+            state = pr_info.get("state", "UNKNOWN")
+            print(f"Error: PR #{args.pr} is not merged yet (state: {state}).")
+            return 1
+
+        # Resolve issue number from PR body
+        pr_body = pr_info.get("body", "")
+        match = re.search(r"Work towards #(\d+)", pr_body)
+        if not match:
+            match = re.search(r"#(\d+)", pr_body)
+        if not match:
+            print(
+                f"Error: Could not determine tracking issue number from PR"
+                f" #{args.pr} body: {pr_body}"
+            )
+            return 1
+
+        issue_num = int(match.group(1))
+        print(f"Resolved tracking issue #{issue_num} from PR #{args.pr} body.")
+
+        commit_sha = pr_info["mergeCommit"]["oid"]
+        short_commit = commit_sha[:8]
+        print(
+            f"PR #{args.pr} merged at commit {commit_sha}. Updating tracking issue..."
+        )
+
+        # Update checklist: mark Prepare Release as done (checked) and set SUCCESS
+        body = self.gh.get_issue_body(issue_num)
+        metadata = {
+            "status": "done",
+            "pr": f"#{args.pr}",
+            "commit": short_commit,
+        }
+        updated_body = update_task_in_body(
+            body, "Prepare Release", checked=True, metadata=metadata
+        )
+        self.gh.update_issue_body(issue_num, updated_body)
+        print("Prepare Release task marked complete successfully!")
+        return 0
+
+    @classmethod
+    def add_parser(cls, subparsers):
+        """Adds parser for complete-prepare subcommand."""
+        parser = subparsers.add_parser(
+            "complete-prepare",
+            help="Mark the Prepare Release task as complete in the tracking issue.",
+        )
+        parser.add_argument(
+            "--pr",
+            type=int,
+            required=True,
+            help="The merged preparation PR number.",
+        )
+        parser.set_defaults(command=cls.run_from_args)
+
+    @classmethod
+    def run_from_args(cls, args):
+        """Instantiates and runs the command from parsed args."""
+        gh = GitHub()
+        return cls(args, gh).run()

tools/private/release/complete_prepare.py

@@ -1,6 +1,7 @@
 """Subcommand to tag and push the next release candidate."""
 
-from tools.private.release import gh, git
+from tools.private.release.gh import GitHub
+from tools.private.release.git import Git
 from tools.private.release.release_issue import (
     RELEASE_TITLE_RE,
     parse_backports,
@@ -13,98 +14,139 @@
 )
 
 
-def cmd_create_rc(args):
-    """Executes the create-rc subcommand."""
-    body = gh.get_issue_body(args.issue)
-    state = parse_checklist_state(body)
-
-    if (
-        state["prepare_release"]["status"] != "done"
-        or state["create_branch"]["status"] != "done"
-    ):
-        print(
-            "Error: Preconditions not met (release must be prepared and branch created)."
-        )
-        return 1
-
-    # Gating: RC tagging is blocked if any backport is unchecked OR does not have status=done
-    backports = parse_backports(body)
-    conflicting_or_pending = [
-        b for b in backports if not b.checked or b.status != "done"
-    ]
-    if conflicting_or_pending:
-        print(
-            f"Gating RC tagging: {len(conflicting_or_pending)} backports are still"
-            " unfinished, failed, or in conflict."
-        )
-        return 1
-
-    # Resolve version and branch
-    issue_title = gh.get_issue_title(args.issue)
-    version_match = RELEASE_TITLE_RE.search(issue_title)
-    if not version_match:
-        print(f"Error: Could not parse version from issue title: {issue_title}")
-        return 1
-
-    version = version_match.group(1)
-    branch_version = ".".join(version.split(".")[:2])
-    branch_name = f"release/{branch_version}"
-
-    # Determine next RC tag
-    git.fetch(args.remote)
-    git.fetch(args.remote, tags=True, force=True)
-    latest_rc = get_latest_rc_tag(version, remote=args.remote)
-
-    if not latest_rc:
-        next_rc_num = 0
-        next_rc = f"{version}-rc0"
-    else:
-        rc_num = int(latest_rc.split("-rc")[-1])
-        next_rc_num = rc_num + 1
-        next_rc = f"{version}-rc{next_rc_num}"
-
-    # Precheck: next RC number must exist and be unchecked in the checklist
-    rc_tags = state.get("rc_tags", {})
-    if next_rc_num not in rc_tags:
-        print(
-            f"Error: Checklist is missing required task 'Tag RC{next_rc_num}'"
-            f" to cut {version}-rc{next_rc_num}."
+class CreateRc:
+    """Class to tag and push the next release candidate."""
+
+    def __init__(self, args, git: Git, gh: GitHub):
+        self.args = args
+        self.git = git
+        self.gh = gh
+
+    def run(self) -> int:
+        """Executes the create-rc subcommand."""
+        args = self.args
+        body = self.gh.get_issue_body(args.issue)
+        state = parse_checklist_state(body)
+
+        if (
+            state["prepare_release"].status != "done"
+            or state["create_branch"].status != "done"
+        ):
+            print(
+                "Error: Preconditions not met (release must be prepared and"
+                " branch created)."
+            )
+            return 1
+
+        # Gating: RC tagging is blocked if any backport is unchecked OR does not have status=done
+        backports = parse_backports(body)
+        conflicting_or_pending = [
+            b for b in backports if not b.checked or b.status != "done"
+        ]
+        if conflicting_or_pending:
+            print(
+                f"Gating RC tagging: {len(conflicting_or_pending)} backports"
+                " are still unfinished, failed, or in conflict."
+            )
+            return 1
+
+        # Resolve version and branch
+        issue_title = self.gh.get_issue_title(args.issue)
+        version_match = RELEASE_TITLE_RE.search(issue_title)
+        if not version_match:
+            print(f"Error: Could not parse version from issue title: {issue_title}")
+            return 1
+
+        version = version_match.group(1)
+        branch_version = ".".join(version.split(".")[:2])
+        branch_name = f"release/{branch_version}"
+
+        # Determine next RC tag
+        self.git.fetch(args.remote)
+        self.git.fetch(args.remote, tags=True, force=True)
+        latest_rc = get_latest_rc_tag(version, remote=args.remote)
+
+        if not latest_rc:
+            next_rc_num = 0
+            next_rc = f"{version}-rc0"
+        else:
+            rc_num = int(latest_rc.split("-rc")[-1])
+            next_rc_num = rc_num + 1
+            next_rc = f"{version}-rc{next_rc_num}"
+
+        # Precheck: next RC number must exist and be unchecked in the checklist
+        rc_tags = state.get("rc_tags", {})
+        if next_rc_num not in rc_tags:
+            print(
+                f"Error: Checklist is missing required task 'Tag RC{next_rc_num}'"
+                f" to cut {version}-rc{next_rc_num}."
+            )
+            return 1
+
+        target_rc_task = rc_tags[next_rc_num]
+        if target_rc_task.checked or target_rc_task.status == "done":
+            print(
+                f"Error: Task 'Tag RC{next_rc_num}' is already marked done in"
+                " the checklist."
+            )
+            return 1
+
+        target_ref = f"{args.remote}/{branch_name}"
+        commit_sha = self.git.get_commit_sha(target_ref)
+
+        print(f"Tagging and pushing next RC: {next_rc}...")
+        self.git.tag(next_rc, target_ref)
+        self.git.push(args.remote, next_rc)
+
+        # Check off the appropriate "Tag RC{N}" task in the checklist
+        print(f"Checking off Tag RC{next_rc_num} task...")
+        metadata = {"status": "done", "tag": next_rc, "commit": commit_sha[:8]}
+        task_name = f"Tag RC{next_rc_num}"
+        updated_body = update_task_in_body(
+            body, task_name, checked=True, metadata=metadata
         )
-        return 1
-
-    target_rc_task = rc_tags[next_rc_num]
-    if target_rc_task["checked"] or target_rc_task["status"] == "done":
-        print(
-            f"Error: Task 'Tag RC{next_rc_num}' is already marked done in the checklist."
-        )
-        return 1
-
-    target_ref = f"{args.remote}/{branch_name}"
-    commit_sha = git.get_commit_sha(target_ref)
+        self.gh.update_issue_body(args.issue, updated_body)
 
-    print(f"Tagging and pushing next RC: {next_rc}...")
-    git.tag(next_rc, target_ref)
-    git.push(args.remote, next_rc)
-
-    # Check off the appropriate "Tag RC{N}" task in the checklist
-    print(f"Checking off Tag RC{next_rc_num} task...")
-    metadata = {"status": "done", "tag": next_rc, "commit": commit_sha[:8]}
-    task_name = f"Tag RC{next_rc_num}"
-    updated_body = update_task_in_body(body, task_name, checked=True, metadata=metadata)
-    gh.update_issue_body(args.issue, updated_body)
-
-    tag_url = f"{REPO_URL}/releases/tag/{next_rc}"
-    bcr_entry_url = f"https://registry.bazel.build/modules/rules_python/{version}"
-    bcr_search_url = f"https://github.com/bazelbuild/bazel-central-registry/pulls?q=is%3Apr+rules_python+{version}"
-    release_workflow_url = f"{REPO_URL}/actions/workflows/release.yml"
-    comment_body = f"""**New Release Candidate Tagged!** 🐍🌿
+        tag_url = f"{REPO_URL}/releases/tag/{next_rc}"
+        bcr_entry_url = f"https://registry.bazel.build/modules/rules_python/{version}"
+        bcr_search_url = f"https://github.com/bazelbuild/bazel-central-registry/pulls?q=is%3Apr+rules_python+{version}"
+        release_workflow_url = f"{REPO_URL}/actions/workflows/release.yml"
+        comment_body = f"""**New Release Candidate Tagged!** 🐍🌿
 
 Release Candidate **{next_rc}** has been successfully generated and tagged on branch `{branch_name}`.
 
 - [Github Release {next_rc}]({tag_url})
 - BCR Entry: [rules_python@{version}]({bcr_entry_url})
 - [BCR PRs]({bcr_search_url})
 - [Release workflow status]({release_workflow_url})"""
-    gh.post_issue_comment(args.issue, comment_body)
-    print("RC creation completed successfully!")
-    return 0
+        self.gh.post_issue_comment(args.issue, comment_body)
+        print("RC creation completed successfully!")
+        return 0
+
+    @classmethod
+    def add_parser(cls, subparsers):
+        """Adds parser for create-rc subcommand."""
+        parser = subparsers.add_parser(
+            "create-rc",
+            help="Tags the next RC on the release branch if no backports remain.",
+        )
+        parser.add_argument(
+            "--issue",
+            type=int,
+            required=True,
+            help="The tracking issue number (required).",
+        )
+        parser.add_argument(
+            "--remote",
+            type=str,
+            required=True,
+            help="The git remote to push the RC tag to (required).",
+        )
+        parser.set_defaults(command=cls.run_from_args)
+
+    @classmethod
+    def run_from_args(cls, args):
+        """Instantiates and runs the command from parsed args."""
+        git = Git(".")
+        gh = GitHub()
+        return cls(args, git, gh).run()