argparser-adapter 2.2.4

CommandLine Options

Arguments 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.

Logging

Logging is to: logging.getLogger(‘argparser_adapter’)

Example

import 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 the double will receive a string and must convert it to an integer. The type hint in triple ensures 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.

def param_conversion_exception(self, e: Exception, method_name: str, parameter_name: str, parameter_type: type,
                               value: str) -> Any: