component_versions.py

#!/usr/bin/env python3

# Dictionary to track version numbers for each METplus component
# The key of each entry is the coordinated release version, e.g. 6.0
# The value is another dictionary where the key is the METplus component name
#   (in lower-case) and the value is a string that contains the latest
#   X.Y.Z version of that component or None if no version is available.
# Add entries for a new coordinated release at the top of the dictionary.
# The versions should be updated when a bugfix release is created.
# METexpress does not include a release for the beta versions, so the value for
#   METexpress should be set to None until the official coordinated release
#   has been created.

import sys

VERSION_LOOKUP = {
    '6.1': {
        'metplus': '6.1.0',
        'met': '12.1.0',
        'metplotpy': '3.1.0',
        'metcalcpy': '3.1.0',
        'metdataio': '3.1.0',
        'metviewer': '6.1.0',
        'metexpress': None,
    },
    '6.0': {
        'metplus': '6.0.0',
        'met': '12.0.0',
        'metplotpy': '3.0.0',
        'metcalcpy': '3.0.0',
        'metdataio': '3.0.0',
        'metviewer': '6.0.0',
        'metexpress': '6.0.0',
    },
    '5.1': {
        'metplus': '5.1.0',
        'met': '11.1.1',
        'metplotpy': '2.1.0',
        'metcalcpy': '2.1.0',
        'metdataio': '2.1.0',
        'metviewer': '5.1.0',
        'metexpress': '5.3.5',
    },
}

# assumes the 2nd highest version in the table is the latest
# the highest version in the table is in development
LATEST_OFFICIAL_RELEASE = sorted(VERSION_LOOKUP.keys(), reverse=True)[1]

DEFAULT_OUTPUT_FORMAT = "v{X}.{Y}.{Z}{N}"

def get_component_version(input_component, input_version, output_component,
                          output_format=DEFAULT_OUTPUT_FORMAT, get_dev=True,
                          rc_is_dev=False):
    """!Get the version of a requested METplus component given another METplus
    component and its version. Parses out X.Y version numbers of input version
    to find desired version. Optionally specific format of output content.
    If input version ends with "-dev", then return "develop".

    @param input_component name of METplus component to use to find version,
    e.g. MET, METplus, or METplotpy (case-insensitive).
    @param input_version version of input_component to search.
    @param output_component name of METplus component to obtain version number
    @param output_format (optional) format to use to output version number.
     {X}, {Y}, and {Z} will be replaced with x, y, and z version numbers from
     X.Y.Z. {N} will be replaced with development version if found in the
     input version, e.g. "-beta3" or "-rc1"
     @param get_dev (optional) if True, get corresponding -beta version.
     If False, return "develop" if input is beta. Also include -rc version if
     rc_is_dev is True.
     @returns string of requested version number, or "develop" if input version
     ends with "-dev", or None if version number could not be determined.
     @param rc_is_dev (optional) if True, an -rcN version will be considered a
     development version, otherwise it will not. Defaults to False because we
     create a main_vX.Y branch for the rc1 release, so we do not want to use
     the develop branch for rc versions.
    """
    if _is_development(input_version, get_dev, rc_is_dev):
        return 'develop'

    coord_version = get_coordinated_version(input_component, input_version)
    versions = VERSION_LOOKUP.get(coord_version)
    if versions is None:
        return None
    output_version = versions.get(output_component.lower())
    if output_version is None:
        return None
    x, y, z = output_version.split('.')
    dev_version = input_version.split('-')[1:]
    dev_version = '' if not dev_version else f"-{dev_version[0]}"
    return output_format.format(X=x, Y=y, Z=z, N=dev_version)

def _is_development(input_version, get_dev, rc_is_dev):
    if '-dev' in input_version or input_version == "develop":
        return True

    check_exts = ['-beta']
    if rc_is_dev:
        check_exts.append('-rc')

    if not get_dev and any(ext in input_version for ext in check_exts):
        return True
    return False

def get_coordinated_version(component, version):
    """!Get coordinated release version number based on the X.Y version number
    of a given METplus component.

    @param component name of METplus component to search (case-insensitive)
    @param version number of version to search for. Can be formatted with main_v
    prefix and development release info, e.g. main_vX.Y or X.Y.Z-beta3.
    @returns string of coordinated release version number X.Y or None.
    """
    # remove main_v or v prefix, remove content after dash
    search_version = version.removeprefix('main_').lstrip('v').split('-')[0]
    # get X.Y only
    search_version = '.'.join(search_version.split('.')[:2])
    # look for component version that begins with search version
    for coord_version, versions in VERSION_LOOKUP.items():
        try:
            if versions.get(component.lower()).startswith(search_version):
                return coord_version
        except AttributeError:
            pass
    return None

def main():
    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument('-i', '--input_component',
                        default='metplus',
                        help='Name of METplus component to use to find version.'
                        ' Default is METplus.')
    parser.add_argument('-v', '--input_version',
                        default=LATEST_OFFICIAL_RELEASE,
                        help='version of input_component to search.'
                             ' Default is latest official release')
    parser.add_argument('-o', '--output_component', required=True,
                        help='name of METplus component to obtain version')
    parser.add_argument('-f', '--output_format',
                        default=DEFAULT_OUTPUT_FORMAT,
                        help='format to use to output version number.'
                             '{X}, {Y}, and {Z} will be replaced with x, y, and'
                             ' z version numbers from X.Y.Z. {N} will be '
                             'replaced with development version if found in the'
                             ' input version, e.g. "-beta3" or "-rc1".'
                             ' Default is v{X}.{Y}.{Z}{N}')
    parser.add_argument('--get_dev_version', action=argparse.BooleanOptionalAction,
                        default=True,
                        help='If True, get corresponding -beta or -rc version. '
                             'If False, return develop if development version.')
    parser.add_argument('--rc_is_dev', action=argparse.BooleanOptionalAction,
                        default=False,
                        help='If True, an -rcN version will be considered a '
                             'development version, otherwise it will not. '
                             'Defaults to False because we create a main_vX.Y '
                             'branch for the rc1 release, so we do not want to '
                             'use the develop branch for rc versions')
    args = parser.parse_args()
    return get_component_version(args.input_component, args.input_version,
                                 args.output_component, args.output_format,
                                 args.get_dev_version, args.rc_is_dev)

def init():
    if __name__ == "__main__":
        out_version = main()
        if not out_version:
            sys.exit(1)

        print(out_version)

init()