Package: argparser-adapter
This package provides automatic adding of arguments to an argparser. ArgumentParser
based on a simple method naming convention.Basic UsageWrite your class with methods you wish called from a command line decorated with@CommandLine()orChoiceCommand(choice)Create anArgparserAdapter, passing your object as a constructor. Decorated methods
will be added to an argparser via theregistercall as positional or options. After parsing,call_specified_methodswill call methods specified on command. ArgparseAdapter will
attempt to convert command line strings to appropriate types if Pythontype hintsare
provided.Choice OptionsChoice options are added by first creating aChoiceinstance and then adding aChoiceCommanddecorator for
each class method that should be a choice. The method name becomes a choice option for the specified choice. The
method docstring becomes part of the the help.Choices may be positional or options, depending the value of the Choiceis_positionattribute. Default values
may be supplied.CommandLine OptionsArguments may be designed as required using@CommandLine(required=True).Default values may
be specified with@CommandLine(default=10).Note specifying both required and a default is possible
but not useful.LoggingLogging is to:logging.getLogger(‘argparser_adapter’)Exampleimport argparse
from ipaddress import IPv4Address

from argparser_adapter import CommandLine, ArgparserAdapter, Choice, ChoiceCommand

petchoice = Choice("pet",False,default='cat',help="Pick your pet")
funchoice = Choice("fun",True,help="Pick your fun time")


class Something:

    @CommandLine()
    def seven(self) -> int:
        # no help for this argument
        print(7)
        return 7

    @CommandLine()
    def double(self, x: int):
        """double a number"""
        print(2 * x)

    @CommandLine()
    def sum(self, x: int, y: int):
        """sum arguments"""
        print(x + y)

    @CommandLine(default=10)
    def triple(self, x: int):
        """triple a value"""
        print(3 * int(x))

    @CommandLine()
    def ipv4address(self, x: IPv4Address):
        """Print ip address"""
        print(type(x))
        print(x)

    @CommandLine()
    def hello(self):
        print("Hi!")

    @CommandLine()
    def binary(self, value: bool):
        """True or false"""
        print(value)

    @ChoiceCommand(funchoice)
    def morning(self,name:str='Truman'):
        """The sun has risen"""
        print(f"morning {name}!")

    @ChoiceCommand(funchoice)
    def night(self):
        """dark"""
        print("it's dark")

    @ChoiceCommand(petchoice)
    def dog(self):
        """canine"""
        print("woof")

    @ChoiceCommand(petchoice)
    def cat(self,name:str='Morris'):
        """feline"""
        print(f"meow {name}")

def main():
    something = Something()
    adapter = ArgparserAdapter(something)
    #parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
    parser = argparse.ArgumentParser(formatter_class=argparse.RawTextHelpFormatter)
    adapter.register(parser)
    args = parser.parse_args()
    adapter.call_specified_methods(args)


if __name__ == "__main__":
    main()Note thedoublewill receive a string and must convert it to an integer. The
type hint intripleensures the argument will be an integer.The resulting argument argparser help is:usage: combined.py [-h] [--binary value] [--double x] [--hello]
                   [--ipv4address x] [--seven] [--sum x y] [--triple x]
                   [--pet {cat,dog}]
                   {morning,night}

positional arguments:
  {morning,night}  Pick your fun time
                   morning (The sun has risen)
                   night (dark)

optional arguments:
  -h, --help       show this help message and exit
  --binary value   True or false
  --double x       double a number
  --hello
  --ipv4address x  Print ip address
  --seven
  --sum x y        sum arguments
  --triple x       triple a value
  --pet {cat,dog}  Pick your pet
                   cat (feline)
                   dog (canine)Docstrings, if present, become help arguments.Advanced usageWhen type conversion fails, the methoddef param_conversion_exception(self, e: Exception, method_name: str, parameter_name: str, parameter_type: type,
                               value: str) -> Any:is called. The default behavior is to raise aValueErrorexception including the method and parameter names, the value
passed and the original exception message. This method is provided for subclasses to override,
if desired. An implementation should raise an Exception or return a suitable parameter for
callingmethod_name.Alternative packagesMore complete packages are available for this purpose, such asClick. This implementation is
intended to be simple, lightweight and easy to use.