????
Your IP : 13.58.53.112
"""
CLI parsing for :command:`pysemver` command.
Each command in :command:`pysemver` is mapped to a ``cmd_`` function.
The :func:`main <semver.cli.main>` function calls
:func:`createparser <semver.cli.createparser>` and
:func:`process <semver.cli.process>` to parse and process
all the commandline options.
The result of each command is printed on stdout.
"""
import argparse
import sys
from typing import cast, List, Optional
from .version import Version
from .__about__ import __version__
def cmd_bump(args: argparse.Namespace) -> str:
"""
Subcommand: Bumps a version.
Synopsis: bump <PART> <VERSION>
<PART> can be major, minor, patch, prerelease, or build
:param args: The parsed arguments
:return: the new, bumped version
"""
maptable = {
"major": "bump_major",
"minor": "bump_minor",
"patch": "bump_patch",
"prerelease": "bump_prerelease",
"build": "bump_build",
}
if args.bump is None:
# When bump is called without arguments,
# print the help and exit
args.parser.parse_args(["bump", "-h"])
ver = Version.parse(args.version)
# get the respective method and call it
func = getattr(ver, maptable[cast(str, args.bump)])
return str(func())
def cmd_check(args: argparse.Namespace) -> None:
"""
Subcommand: Checks if a string is a valid semver version.
Synopsis: check <VERSION>
:param args: The parsed arguments
"""
if Version.is_valid(args.version):
return None
raise ValueError("Invalid version %r" % args.version)
def cmd_compare(args: argparse.Namespace) -> str:
"""
Subcommand: Compare two versions.
Synopsis: compare <VERSION1> <VERSION2>
:param args: The parsed arguments
"""
ver1 = Version.parse(args.version1)
return str(ver1.compare(args.version2))
def cmd_nextver(args: argparse.Namespace) -> str:
"""
Subcommand: Determines the next version, taking prereleases into account.
Synopsis: nextver <VERSION> <PART>
:param args: The parsed arguments
"""
version = Version.parse(args.version)
return str(version.next_version(args.part))
def createparser() -> argparse.ArgumentParser:
"""
Create an :class:`argparse.ArgumentParser` instance.
:return: parser instance
"""
parser = argparse.ArgumentParser(prog=__package__, description=__doc__)
parser.add_argument(
"--version", action="version", version="%(prog)s " + __version__
)
s = parser.add_subparsers()
# create compare subcommand
parser_compare = s.add_parser("compare", help="Compare two versions")
parser_compare.set_defaults(func=cmd_compare)
parser_compare.add_argument("version1", help="First version")
parser_compare.add_argument("version2", help="Second version")
# create bump subcommand
parser_bump = s.add_parser("bump", help="Bumps a version")
parser_bump.set_defaults(func=cmd_bump)
sb = parser_bump.add_subparsers(title="Bump commands", dest="bump")
# Create subparsers for the bump subparser:
for p in (
sb.add_parser("major", help="Bump the major part of the version"),
sb.add_parser("minor", help="Bump the minor part of the version"),
sb.add_parser("patch", help="Bump the patch part of the version"),
sb.add_parser("prerelease", help="Bump the prerelease part of the version"),
sb.add_parser("build", help="Bump the build part of the version"),
):
p.add_argument("version", help="Version to raise")
# Create the check subcommand
parser_check = s.add_parser(
"check", help="Checks if a string is a valid semver version"
)
parser_check.set_defaults(func=cmd_check)
parser_check.add_argument("version", help="Version to check")
# Create the nextver subcommand
parser_nextver = s.add_parser(
"nextver", help="Determines the next version, taking prereleases into account."
)
parser_nextver.set_defaults(func=cmd_nextver)
parser_nextver.add_argument("version", help="Version to raise")
parser_nextver.add_argument(
"part", help="One of 'major', 'minor', 'patch', or 'prerelease'"
)
return parser
def process(args: argparse.Namespace) -> str:
"""
Process the input from the CLI.
:param args: The parsed arguments
:param parser: the parser instance
:return: result of the selected action
"""
if not hasattr(args, "func"):
args.parser.print_help()
raise SystemExit()
# Call the respective function object:
return args.func(args)
def main(cliargs: Optional[List[str]] = None) -> int:
"""
Entry point for the application script.
:param list cliargs: Arguments to parse or None (=use :class:`sys.argv`)
:return: error code
"""
try:
parser = createparser()
args = parser.parse_args(args=cliargs)
# Save parser instance:
args.parser = parser
result = process(args)
if result is not None:
print(result)
return 0
except (ValueError, TypeError) as err:
print("ERROR", err, file=sys.stderr)
return 2