cli.py

import argparse
import logging
from pathlib import Path
from typing import Literal, cast

from .build_matrix import build_matrix
from .dockerfiles import render_dockerfile_with_context
from .readme import update_dynamic_readme
from .settings import DISTROS
from .versions import (
    decide_version_combinations,
    find_new_or_updated,
    latest_tag_key,
    load_build_contexts,
    load_versions,
    persist_versions,
    supported_versions,
)

logger = logging.getLogger("dpn")


class CLIArgs(argparse.Namespace):
    dry_run: bool
    distros: list[str]
    verbose: bool
    command: Literal["dockerfile", "build-matrix", "release", "latest-key"]
    force: bool  # build-matrix and release command arg

    context: str  # dockerfile command arg
    event: str  # build-matrix command arg
    builds_dir: Path  # release command arg


def run_dockerfile(args: CLIArgs) -> None:
    render_dockerfile_with_context(args.context, args.dry_run)


def run_build_matrix(args: CLIArgs) -> None:
    supported_python_versions, supported_nodejs_versions = supported_versions()
    versions = decide_version_combinations(args.distros, supported_python_versions, supported_nodejs_versions)
    current_versions = load_versions()
    new_or_updated = find_new_or_updated(versions, current_versions, args.force)
    build_matrix(new_or_updated, args.event)


def run_release(args: CLIArgs) -> None:
    """Release new/updated version by updating versions.json and README.md.

    Note: We fetch supported and available versions again here and update with the actual built digests"""

    supported_python_versions, supported_nodejs_versions = supported_versions()
    versions = decide_version_combinations(args.distros, supported_python_versions, supported_nodejs_versions)
    # Update versions with build digests to allow pinning
    built_versions = load_build_contexts(args.builds_dir)
    current_versions = load_versions()
    for version in versions:
        if version.key in built_versions:
            version.digest = built_versions[version.key].digest
        elif version.key in current_versions:
            version.digest = current_versions[version.key].digest

    new_or_updated = find_new_or_updated(versions, current_versions, args.force)
    supported_python_versions, supported_nodejs_versions = supported_versions()
    if not new_or_updated:
        logger.info("No new or updated versions")
        return

    persist_versions(versions, args.dry_run)
    update_dynamic_readme(versions, supported_python_versions, supported_nodejs_versions, args.dry_run)


def run_latest_key(args: CLIArgs) -> None:
    builds = load_build_contexts(args.builds_dir)
    print(latest_tag_key(list(builds.values())))


def main(args: CLIArgs) -> None:
    if args.dry_run:
        logger.debug("Dry run, outputting only.")

    if args.command == "dockerfile":
        run_dockerfile(args)
    elif args.command == "build-matrix":
        run_build_matrix(args)
    elif args.command == "release":
        run_release(args)
    elif args.command == "latest-key":
        run_latest_key(args)


def parse_args() -> CLIArgs:
    parser = argparse.ArgumentParser(usage="🐳 Build Python with Node.js docker images")
    parser.add_argument(
        "-d",
        "--distros",
        dest="distros",
        nargs="*",
        choices=DISTROS,
        help="Specify which distros to build",
        default=DISTROS,
    )
    parser.add_argument(
        "--dry-run",
        action="store_true",
        dest="dry_run",
        help="Skip persisting, README update, and pushing of builds",
    )
    parser.add_argument("--force", action="store_true", help="Force build all versions (even old)")
    parser.add_argument("--verbose", action="store_true", help="Enable debug logging")

    subparsers = parser.add_subparsers(dest="command", help="Sub-commands")

    # Dockerfile command
    parser_dockerfile = subparsers.add_parser("dockerfile", help="Render a dockerfile based on version config")
    parser_dockerfile.add_argument("--context", default="", help="Dockerfile version config")

    # Build matrix command
    parser_build_matrix = subparsers.add_parser("build-matrix", help="Generate CI build matrix")
    parser_build_matrix.add_argument(
        "--event",
        default="webhook",
        # https://docs.github.com/en/actions/learn-github-actions/contexts#github-context
        help="GitHub Action event name (github.event_name)",
    )

    # Release command
    parser_release = subparsers.add_parser("release", help="Persist versions and make a release")
    parser_release.add_argument(
        "--builds-dir",
        type=Path,
        required=True,
        help="Builds directory with build context JSON files",
    )

    parser_latest_key = subparsers.add_parser(
        "latest-key",
        help="Print the built tag that should also be published as latest",
    )
    parser_latest_key.add_argument(
        "--builds-dir",
        type=Path,
        required=True,
        help="Builds directory with build context JSON files",
    )

    cli_args = cast("CLIArgs", parser.parse_args())
    if cli_args.command in {"release", "latest-key"}:
        if not cli_args.builds_dir.exists():
            parser.error(f"Builds directory {cli_args.builds_dir.as_posix()} does not exist")

        if not cli_args.builds_dir.is_dir():
            parser.error(f"Builds directory {cli_args.builds_dir.as_posix()} is not a directory")

    return cli_args