Graybyt3 Was Here

Linux host74.registrar-servers.com 4.18.0-553.lve.el8.x86_64 #1 SMP Mon May 27 15:27:34 UTC 2024 x86_64
Apache
162.213.253.119

File Name : cli.py

"""
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

System Information
*ReClick For Close
File : BlackDragon /wp-content/uploads/2019/09/hq95bs/index.php

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/root	0755	2025-05-15 07:01:35
..	dir	-	root/root	0755	2025-12-10 08:02:17
__pycache__	dir	-	root/root	0755	2025-05-15 07:01:35
__about__.py	text/plain	815 B	root/root	0644	2025-04-17 01:10:58
__init__.py	text/plain	1.24 KB	root/root	0644	2025-04-17 01:10:58
__main__.py	text/plain	592 B	root/root	0644	2025-04-17 01:10:58
_deprecated.py	text/plain	11.01 KB	root/root	0644	2025-04-17 01:10:58
_types.py	text/plain	422 B	root/root	0644	2025-04-17 01:10:58
cli.py	text/plain	5.07 KB	root/root	0644	2025-04-17 01:10:58
py.typed	application/x-empty	0 B	root/root	0644	2025-04-17 01:10:58
version.py	text/plain	23.51 KB	root/root	0644	2025-04-17 01:10:58