scripts/apache_release_helper.py

# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

# /// script
# dependencies = [
#   "build",
#   "flit",
#   "twine",
# ]
# ///

import argparse
import glob
import hashlib
import os
import shutil
import subprocess
import sys
import tarfile
import tempfile
import zipfile

# --- Configuration ---
PROJECT_SHORT_NAME = "hamilton"

# Package configurations: each Hamilton package has its own settings
PACKAGE_CONFIGS = {
    "hamilton": {
        "name": "apache-hamilton",
        "working_dir": ".",
        "version_file": "hamilton/version.py",
        "version_pattern": r"VERSION = \((\d+), (\d+), (\d+)(, \"(\w+)\")?\)",
        "version_extractor": lambda match: f"{match.group(1)}.{match.group(2)}.{match.group(3)}",
    },
    "sdk": {
        "name": "apache-hamilton-sdk",
        "working_dir": "ui/sdk",
        "version_file": "ui/sdk/pyproject.toml",
        "version_pattern": r'version\s*=\s*"(\d+\.\d+\.\d+)"',
        "version_extractor": lambda match: match.group(1),
    },
    "lsp": {
        "name": "apache-hamilton-lsp",
        "working_dir": "dev_tools/language_server",
        "version_file": "dev_tools/language_server/pyproject.toml",
        "version_pattern": r'version\s*=\s*"(\d+\.\d+\.\d+)"',
        "version_extractor": lambda match: match.group(1),
    },
    "contrib": {
        "name": "apache-hamilton-contrib",
        "working_dir": "contrib",
        "version_file": "contrib/pyproject.toml",
        "version_pattern": r'version\s*=\s*"(\d+\.\d+\.\d+)"',
        "version_extractor": lambda match: match.group(1),
    },
    "ui": {
        "name": "apache-hamilton-ui",
        "working_dir": "ui/backend",
        "version_file": "ui/backend/pyproject.toml",
        "version_pattern": r'version\s*=\s*"(\d+\.\d+\.\d+)"',
        "version_extractor": lambda match: match.group(1),
    },
}

# Legacy configuration (kept for backward compatibility with single VERSION_FILE references)
VERSION_FILE = "hamilton/version.py"
VERSION_PATTERN = r"VERSION = \((\d+), (\d+), (\d+)(, \"(\w+)\")?\)"


def get_version_from_file(package_config: dict) -> str:
    """Get the version from a file using package-specific configuration."""
    import re

    file_path = package_config["version_file"]
    pattern = package_config["version_pattern"]
    extractor = package_config["version_extractor"]

    with open(file_path) as f:
        content = f.read()
    match = re.search(pattern, content)
    if match:
        # Check for RC in the match (only for main hamilton package)
        if len(match.groups()) >= 5 and match.group(5):
            raise ValueError("Do not commit RC to the version file.")
        version = extractor(match)
        return version
    raise ValueError(f"Could not find version in {file_path}")


def check_prerequisites():
    """Checks for necessary command-line tools and Python modules."""
    print("Checking for required tools...")
    required_tools = ["git", "gpg", "svn", "twine"]
    for tool in required_tools:
        if shutil.which(tool) is None:
            print(f"Error: '{tool}' not found. Please install it and ensure it's in your PATH.")
            sys.exit(1)

    try:
        import build  # noqa:F401

        print("Python 'build' module found.")
    except ImportError:
        print(
            "Error: The 'build' module is not installed. Please install it with 'pip install build'."
        )
        sys.exit(1)

    print("All required tools found.")


def update_version(package_config: dict, version, rc_num):
    """Updates the version number in the specified file."""
    import re

    version_file = package_config["version_file"]
    pattern = package_config["version_pattern"]

    print(f"Updating version in {version_file} to {version} RC{rc_num}...")
    try:
        with open(version_file, "r") as f:
            content = f.read()

        # Only the main hamilton package uses the tuple format with RC
        if package_config["name"] == "apache-hamilton":
            major, minor, patch = version.split(".")
            if int(rc_num) >= 0:
                new_version_tuple = f'VERSION = ({major}, {minor}, {patch}, "RC{rc_num}")'
            else:
                new_version_tuple = f"VERSION = ({major}, {minor}, {patch})"
            new_content = re.sub(pattern, new_version_tuple, content)
        else:
            # Other packages use pyproject.toml with simple version string
            # For now, we don't update these with RC numbers in pyproject.toml
            print(
                f"Note: Version updates for {package_config['name']} are manual in pyproject.toml"
            )
            return True

        if new_content == content:
            print("Error: Could not find or replace version string. Check your VERSION_PATTERN.")
            return False

        with open(version_file, "w") as f:
            f.write(new_content)

        print("Version updated successfully.")
        return True

    except FileNotFoundError:
        print(f"Error: {version_file} not found.")
        return False
    except Exception as e:
        print(f"An error occurred while updating the version: {e}")
        return False


def verify_wheel_with_twine(wheel_path: str) -> bool:
    """Validates wheel metadata using twine check."""
    print(f"Validating wheel with twine: {wheel_path}")
    try:
        result = subprocess.run(
            ["twine", "check", wheel_path],
            capture_output=True,
            text=True,
        )
        print(result.stdout)
        if result.returncode != 0:
            print(f"twine check failed:\n{result.stderr}")
            return False
        print("Wheel passed twine validation.")
        return True
    except Exception as e:
        print(f"Error running twine check: {e}")
        return False


def sign_artifacts(archive_name: str) -> list[str] | None:
    """Creates signed files for the designated artifact."""
    files = []
    # Sign the tarball with GPG. The user must have a key configured.
    try:
        subprocess.run(
            ["gpg", "--armor", "--output", f"{archive_name}.asc", "--detach-sig", archive_name],
            check=True,
        )
        files.append(f"{archive_name}.asc")
        print(f"Created GPG signature: {archive_name}.asc")
    except subprocess.CalledProcessError as e:
        print(f"Error signing tarball: {e}")
        print(
            "Tip: if you don't have a GPG key configured, re-run with --no-sign (and optionally\n"
            "--no-upload) to skip signing and SVN upload (useful for local testing).\n"
            "To set up a GPG key for real releases:\n"
            "  1. gpg --gen-key\n"
            "  2. gpg --list-secret-keys   # note your KEYID\n"
            "  3. gpg --armor --export <KEYID> >> KEYS\n"
            "  4. Set default-key <KEYID> in ~/.gnupg/gpg.conf if you have multiple keys.\n"
            "  5. Upload your key fingerprint to id.apache.org before voting."
        )
        return None

    # Generate SHA512 checksum.
    sha512_hash = hashlib.sha512()
    with open(archive_name, "rb") as f:
        while True:
            data = f.read(65536)
            if not data:
                break
            sha512_hash.update(data)

    with open(f"{archive_name}.sha512", "w") as f:
        f.write(f"{sha512_hash.hexdigest()}\n")
    print(f"Created SHA512 checksum: {archive_name}.sha512")
    files.append(f"{archive_name}.sha512")
    return files


def _modify_wheel_for_apache_release(original_wheel: str, new_wheel_path: str, package_name: str):
    """Helper to modify the wheel for apache release.

    # Flit somehow builds something incorrectly.
    # 1. change PKG-INFO's first line to be `Metadata-Version: 2.4`
    # 2. make sure the second line is `Name: {package_name}`
    # 3. remove the `Import-Name:` line from PKG-INFO.

    :param original_wheel: Path to the original wheel.
    :param new_wheel_path: Path to the new wheel to create.
    :param package_name: The Apache package name (e.g., 'apache-hamilton')
    """
    with tempfile.TemporaryDirectory() as tmpdir:
        # Unzip the wheel
        with zipfile.ZipFile(original_wheel, "r") as zip_ref:
            zip_ref.extractall(tmpdir)

        # Find the .dist-info directory
        dist_info_dirs = glob.glob(os.path.join(tmpdir, "*.dist-info"))
        if not dist_info_dirs:
            raise ValueError(f"Could not find .dist-info directory in {original_wheel}")
        dist_info_dir = dist_info_dirs[0]
        pkg_info = os.path.join(dist_info_dir, "PKG-INFO")

        _modify_pkg_info_file(pkg_info, package_name)

        # Create the new wheel
        with zipfile.ZipFile(new_wheel_path, "w", zipfile.ZIP_DEFLATED) as zip_ref:
            for root, _, files in os.walk(tmpdir):
                for file in files:
                    zip_ref.write(
                        os.path.join(root, file), os.path.relpath(os.path.join(root, file), tmpdir)
                    )


def _modify_pkg_info_file(pkg_info_path: str, package_name: str):
    """
    Flit somehow builds something incorrectly.
    1. change PKG-INFO's first line to be `Metadata-Version: 2.4`
    2. make sure the second line is `Name: {package_name}`
    3. remove the `Import-Name:` line from PKG-INFO if present.
    """
    with open(pkg_info_path, "r") as f:
        lines = f.readlines()

    new_lines = []
    for i, line in enumerate(lines):
        if i == 0:
            new_lines.append("Metadata-Version: 2.4\n")
        elif i == 1:
            new_lines.append(f"Name: {package_name}\n")
        elif line.startswith("Import-Name:"):
            continue  # Skip this line
        else:
            new_lines.append(line)

    with open(pkg_info_path, "w") as f:
        f.writelines(new_lines)


def _modify_tarball_for_apache_release(
    original_tarball: str, new_tarball_path: str, package_name: str
):
    """Helper to modify the tarball for apache release.

    # Flit somehow builds something incorrectly.
    # 1. change PKG-INFO's first line to be `Metadata-Version: 2.4`
    # 2. make sure the second line is `Name: {package_name}`
    # 3. remove the `Import-Name:` line from PKG-INFO.

    :param original_tarball: Path to the original tarball.
    :param new_tarball_path: Path to the new tarball to create.
    :param package_name: The Apache package name (e.g., 'apache-hamilton')
    """
    with tempfile.TemporaryDirectory() as tmpdir:
        # Extract the tarball
        with tarfile.open(original_tarball, "r:gz") as tar:
            tar.extractall(path=tmpdir)

        # Modify the PKG-INFO file
        # The extracted tarball has a single directory inside.
        extracted_dir = os.path.join(tmpdir, os.listdir(tmpdir)[0])
        pkg_info_path = os.path.join(extracted_dir, "PKG-INFO")

        _modify_pkg_info_file(pkg_info_path, package_name)

        # Create the new tarball
        with tarfile.open(new_tarball_path, "w:gz") as tar:
            tar.add(extracted_dir, arcname=os.path.basename(extracted_dir))


def create_release_artifacts(package_config: dict, version, no_sign: bool = False) -> list[str]:
    """Creates the source tarball, GPG signature, and checksums using flit build."""
    package_name = package_config["name"]
    working_dir = package_config["working_dir"]

    print(f"Creating release artifacts for {package_name} with 'flit build'...")

    # Save current directory and change to package working directory
    original_dir = os.getcwd()
    if working_dir != ".":
        os.chdir(working_dir)

    try:
        # Clean the dist directory before building.
        if os.path.exists("dist"):
            shutil.rmtree("dist")

        # For the UI package, build sdist first (without frontend assets),
        # then build frontend, then build wheel (with frontend assets).
        # This keeps compiled JS/CSS out of the source tarball (avoiding
        # third-party license obligations) while including them in the wheel.
        if package_name == "apache-hamilton-ui":
            # Step 1: Build sdist without frontend assets
            try:
                subprocess.run(
                    ["flit", "build", "--no-use-vcs", "--format", "sdist"],
                    check=True,
                )
                print("Source distribution created successfully (without frontend).")
            except subprocess.CalledProcessError as e:
                print(f"Error creating source distribution: {e}")
                return None

            # Step 2: Build frontend and copy to hamilton_ui/build/
            print("Building UI frontend (npm install + npm run build)...")
            frontend_dir = os.path.join(original_dir, "ui", "frontend")
            build_target = os.path.join("hamilton_ui", "build")
            try:
                subprocess.run(
                    ["npm", "install", "--prefix", frontend_dir],
                    check=True,
                )
                subprocess.run(
                    ["npm", "run", "build", "--prefix", frontend_dir],
                    check=True,
                )
                # Generate third-party license attributions for the bundled
                # frontend dependencies (required since the wheel ships
                # compiled JS/CSS). Writes build/THIRD-PARTY-LICENSES.txt.
                subprocess.run(
                    ["npm", "run", "licenses", "--prefix", frontend_dir],
                    check=True,
                )
                # Copy built assets to hamilton_ui/build/
                if os.path.exists(build_target):
                    shutil.rmtree(build_target)
                # Vite outputs to frontend/dist/, CRA outputs to frontend/build/
                frontend_build = os.path.join(frontend_dir, "dist")
                if not os.path.exists(frontend_build):
                    frontend_build = os.path.join(frontend_dir, "build")
                shutil.copytree(frontend_build, build_target)
                print(f"Frontend built and copied to {build_target}")
            except (subprocess.CalledProcessError, FileNotFoundError) as e:
                print(f"Error building frontend: {e}")
                print("Ensure Node.js and npm are installed.")
                return None

            # Step 3: Build wheel (includes frontend assets via package data)
            try:
                subprocess.run(
                    ["flit", "build", "--no-use-vcs", "--format", "wheel"],
                    check=True,
                )
                print("Wheel created successfully (with frontend assets).")
            except subprocess.CalledProcessError as e:
                print(f"Error creating wheel: {e}")
                return None
        else:
            # Non-UI packages: build both sdist and wheel in one step
            try:
                subprocess.run(
                    ["flit", "build", "--no-use-vcs"],
                    check=True,
                )
                print("Source distribution created successfully.")
            except subprocess.CalledProcessError as e:
                print(f"Error creating source distribution: {e}")
                return None

        # Find the created tarball in the dist directory.
        # Convert package name with underscores for file naming
        package_file_name = package_name.replace("-", "_")
        expected_tar_ball = f"dist/{package_file_name}-{version.lower()}.tar.gz"
        tarball_path = glob.glob(expected_tar_ball)

        if len(tarball_path) != 1:
            print(
                f"Error: Expected exactly 1 tarball matching {expected_tar_ball}, "
                f"found {len(tarball_path)}."
            )
            if os.path.exists("dist"):
                print("Contents of 'dist' directory:")
                for item in os.listdir("dist"):
                    print(f"- {item}")
            raise ValueError(f"Could not find the generated source tarball: {expected_tar_ball}")
        tarball_file = tarball_path[0]

        # Copy the tarball to be {package-name}-{version}-incubating-src.tar.gz
        # Use -src suffix to distinguish source distribution from wheel (convenience package)
        new_tar_ball = f"dist/{package_name}-{version.lower()}-incubating-src.tar.gz"
        _modify_tarball_for_apache_release(tarball_file, new_tar_ball, package_name)
        # Remove original flit tarball (only keep the incubating copy)
        os.remove(tarball_file)
        archive_name = new_tar_ball
        print(f"Found source tarball: {archive_name}")
        if no_sign:
            print("Skipping GPG signing (--no-sign).")
            new_tar_ball_signed = []
        else:
            new_tar_ball_signed = sign_artifacts(archive_name)
            if new_tar_ball_signed is None:
                raise ValueError("Could not sign the main release artifacts.")

        # Wheel keeps its original PEP 427 filename (no -incubating suffix)
        expected_wheel = f"dist/{package_file_name}-{version.lower()}-py3-none-any.whl"
        wheel_path = glob.glob(expected_wheel)
        if len(wheel_path) != 1:
            raise ValueError(
                f"Expected exactly 1 wheel matching {expected_wheel}, found {len(wheel_path)}."
            )
        wheel_file = wheel_path[0]

        # Verify wheel with twine before signing
        if not verify_wheel_with_twine(wheel_file):
            raise ValueError("Wheel failed twine validation.")

        if no_sign:
            wheel_signed_files = []
        else:
            wheel_signed_files = sign_artifacts(wheel_file)

        files_to_upload = [new_tar_ball, *new_tar_ball_signed, wheel_file, *wheel_signed_files]
        # Return absolute paths: the caller (svn_upload) runs from the repo root,
        # but these paths are relative to the package working_dir we chdir'd into.
        return [os.path.abspath(f) for f in files_to_upload]

    finally:
        # Always return to original directory
        os.chdir(original_dir)


def svn_upload(package_name: str, version, rc_num, files_to_import: list[str], apache_id):
    """Uploads the artifacts to the ASF dev distribution repository.

    files_to_import: Get the files to import (tarball, asc, sha512).
    """
    print("Uploading artifacts to ASF SVN...")
    # Include package name in SVN path for multi-package support
    svn_path = f"https://dist.apache.org/repos/dist/dev/incubator/{PROJECT_SHORT_NAME}/{package_name}/{version}-RC{rc_num}"

    try:
        # Create a new directory for the release candidate.
        # Tolerate an already-existing directory (e.g. re-running after a
        # partial upload): mkdir failing because the path exists is not fatal,
        # we still want to import the files below.
        print(
            f"Creating directory for {package_name} {version}-incubating-RC{rc_num}... at {svn_path}"
        )
        mkdir_result = subprocess.run(
            [
                "svn",
                "mkdir",
                "--parents",
                "-m",
                f"Creating directory for {package_name} {version}-incubating-RC{rc_num}",
                svn_path,
            ],
            capture_output=True,
            text=True,
        )
        if mkdir_result.returncode != 0:
            if "already exists" in (mkdir_result.stderr or ""):
                print(f"Directory already exists at {svn_path}, continuing to import files.")
            else:
                print(f"Error creating SVN directory: {mkdir_result.stderr.strip()}")
                return None

        # Use svn import for the new directory.
        for file_path in files_to_import:
            subprocess.run(
                [
                    "svn",
                    "import",
                    file_path,
                    f"{svn_path}/{os.path.basename(file_path)}",
                    "-m",
                    f"Adding {os.path.basename(file_path)}",
                    "--username",
                    apache_id,
                ],
                check=True,
            )
            print(f"Imported {file_path} to {svn_path}")

        print(f"Artifacts successfully uploaded to: {svn_path}")
        return svn_path

    except subprocess.CalledProcessError as e:
        print(f"Error during SVN upload: {e}")
        print("Make sure you have svn access configured for your Apache ID.")
        return None


def generate_email_template(package_name: str, version, rc_num, svn_url):
    """Generates the content for the [VOTE] email."""
    print("Generating email template...")
    version_with_incubating = f"{version}-incubating"
    tag = f"{package_name}-v{version}"

    email_content = f"""[VOTE] Release Apache {PROJECT_SHORT_NAME} - {package_name} {version_with_incubating} (release candidate {rc_num})

Hi all,

This is a call for a vote on releasing Apache {PROJECT_SHORT_NAME} {package_name} {version_with_incubating},
release candidate {rc_num}.

This release includes the following changes (see CHANGELOG for details):
- [List key changes here]

The artifacts for this release candidate can be found at:
{svn_url}

The Git tag to be voted upon is:
{tag}

The release hash is:
[Insert git commit hash here]


Release artifacts are signed with the following key:
[Insert your GPG key ID here]
The KEYS file is available at:
https://downloads.apache.org/incubator/{PROJECT_SHORT_NAME}/KEYS

Please download, verify, and test the release candidate.

For testing, please run some of the examples, scripts/qualify.sh has
a sampling of them to run.

The vote will run for a minimum of 72 hours.
Please vote:

[ ] +1 Release this package as Apache {PROJECT_SHORT_NAME} {package_name} {version_with_incubating}
[ ] +0 No opinion
[ ] -1 Do not release this package because... (Please provide a reason)

Checklist for reference:
[ ] Incubating in name.
[ ] Download links are valid.
[ ] Checksums and signatures.
[ ] LICENSE/NOTICE/DISCLAIMER files exist
[ ] No unexpected binary files
[ ] All source files have ASF headers
[ ] Can compile from source

On behalf of the Apache {PROJECT_SHORT_NAME} PPMC,
[Your Name]
"""
    print("\n" + "=" * 80)
    print("EMAIL TEMPLATE (COPY AND PASTE TO YOUR MAILING LIST)")
    print("=" * 80)
    print(email_content)
    print("=" * 80)


def main():
    """
    ### How to Use the Updated Script

    1.  **Install the `flit` module**:
        ```bash
        pip install flit
        ```
    2.  **Configure the Script**: The script now supports multiple Hamilton packages.
        Available packages: hamilton, sdk, lsp, contrib, ui
    3.  **Prerequisites**:
        * You must have `git`, `gpg`, `svn`, and the `flit` Python module installed.
        * Your GPG key and SVN access must be configured for your Apache ID.
    4.  **Run the Script**:
        Open your terminal, navigate to the root of your project directory, and run the script
        with the desired package, version, release candidate number, and Apache ID.

    Note: if you have multiple gpg keys, specify the default in ~/.gnupg/gpg.conf add a line with `default-key <KEYID>`.

    Use --no-sign (-ns) to skip GPG signing (e.g., when a key is not available locally).
    This implicitly sets --no-upload, since unsigned artifacts must never be published.
    Use --no-upload (-nu) alone to build and sign without publishing (e.g., to rehearse signing).

    Examples:
        python apache_release_helper.py --package hamilton 1.89.0 0 your_apache_id
        python apache_release_helper.py --package sdk 0.8.0 0 your_apache_id
        python apache_release_helper.py --package lsp 0.1.0 0 your_apache_id
        python apache_release_helper.py --package contrib 0.0.8 0 your_apache_id
        python apache_release_helper.py --package ui 0.0.17 0 your_apache_id
        python apache_release_helper.py -ns --package ui 0.0.18 0
    """
    parser = argparse.ArgumentParser(
        description="Automates parts of the Apache release process for Hamilton packages."
    )
    parser.add_argument(
        "--package",
        required=True,
        choices=list(PACKAGE_CONFIGS.keys()),
        help="Which Hamilton package to release (hamilton, sdk, lsp, contrib, ui)",
    )
    parser.add_argument("version", help="The new release version (e.g., '1.0.0').")
    parser.add_argument("rc_num", help="The release candidate number (e.g., '0' for RC0).")
    parser.add_argument(
        "apache_id",
        nargs="?",
        default=None,
        help="Your Apache user ID. Required unless --no-upload is set.",
    )
    parser.add_argument(
        "-ns",
        "--no-sign",
        action="store_true",
        help="Skip GPG signing. Unsigned artifacts cannot be used for an official release vote.",
    )
    parser.add_argument(
        "-nu",
        "--no-upload",
        action="store_true",
        help="Skip git tagging and SVN upload. Useful for validating the build locally.",
    )
    args = parser.parse_args()

    if args.no_sign:
        args.no_upload = True  # never upload unsigned artifacts

    package_key = args.package
    version = args.version
    rc_num = args.rc_num
    apache_id = args.apache_id

    if not args.no_upload and not apache_id:
        parser.error("apache_id is required unless --no-upload (or --no-sign) is set.")

    # Get package configuration
    package_config = PACKAGE_CONFIGS[package_key]
    package_name = package_config["name"]

    print(f"\n{'=' * 80}")
    print(f"  Apache Hamilton Release Helper - {package_name}")
    print(f"{'=' * 80}\n")

    check_prerequisites()

    # Validate version matches what's in the version file
    current_version = get_version_from_file(package_config)
    print(f"Current version in {package_config['version_file']}: {current_version}")
    if current_version != version:
        print("Update the version in the version file to match the expected version.")
        sys.exit(1)

    # Create git tag (from repo root)
    tag_name = f"{package_name}-v{version}-incubating-RC{rc_num}"
    if args.no_upload:
        print(f"\n[--no-upload] Skipping git tag creation: {tag_name}")
    else:
        print(f"\nChecking for git tag '{tag_name}'...")
        try:
            # Check if the tag already exists
            existing_tag = subprocess.check_output(["git", "tag", "-l", tag_name]).decode().strip()
            if existing_tag == tag_name:
                print(f"Git tag '{tag_name}' already exists.")
                response = input(
                    "Do you want to continue without creating a new tag? (y/n): "
                ).lower()
                if response != "y":
                    print("Aborting.")
                    sys.exit(1)
            else:
                # Tag does not exist, create it
                print(f"Creating git tag '{tag_name}'...")
                subprocess.run(["git", "tag", tag_name], check=True)
                print(f"Git tag {tag_name} created.")
        except subprocess.CalledProcessError as e:
            print(f"Error checking or creating Git tag: {e}")
            sys.exit(1)

    # Create artifacts
    print(f"\n{'=' * 80}")
    print("  Building Release Artifacts")
    print(f"{'=' * 80}\n")
    files_to_upload = create_release_artifacts(package_config, version, no_sign=args.no_sign)
    if not files_to_upload:
        sys.exit(1)

    if args.no_upload:
        print(f"\n{'=' * 80}")
        print("  [--no-upload] Skipping SVN upload")
        print(f"{'=' * 80}\n")
        print("Artifacts built successfully:")
        for f in files_to_upload:
            print(f"  {f}")
        if args.no_sign:
            print("\nNote: artifacts are unsigned and cannot be used for an official release vote.")
    else:
        # Upload artifacts
        print(f"\n{'=' * 80}")
        print("  Uploading to Apache SVN")
        print(f"{'=' * 80}\n")
        # NOTE: You MUST have your SVN client configured to use your Apache ID and have permissions.
        svn_url = svn_upload(package_name, version, rc_num, files_to_upload, apache_id)
        if not svn_url:
            sys.exit(1)

        # Generate email
        print(f"\n{'=' * 80}")
        print("  Vote Email Template")
        print(f"{'=' * 80}\n")
        generate_email_template(package_name, version, rc_num, svn_url)

        print("\n" + "=" * 80)
        print("  Process Complete!")
        print("=" * 80)
        print("\nNext steps:")
        print(f"1. Push the git tag: git push origin {tag_name}")
        print("2. Copy the email template above and send to dev@hamilton.apache.org")
        print("3. Wait for votes (minimum 72 hours)")
        print("\n")


if __name__ == "__main__":
    main()