Oven logo

Oven

Published

A library to create a command-line program from a function

pip install autocommand

Package Downloads

Weekly DownloadsMonthly Downloads

Authors

Requires Python

>=3.7

Dependencies

    PyPI version

    autocommand

    A library to automatically generate and run simple argparse parsers from function signatures.

    Installation

    Autocommand is installed via pip:

    $ pip install autocommand
    

    Usage

    Autocommand turns a function into a command-line program. It converts the function's parameter signature into command-line arguments, and automatically runs the function if the module was called as __main__. In effect, it lets your create a smart main function.

    from autocommand import autocommand
    
    # This program takes exactly one argument and echos it.
    @autocommand(__name__)
    def echo(thing):
        print(thing)
    
    $ python echo.py hello
    hello
    $ python echo.py -h
    usage: echo [-h] thing
    
    positional arguments:
      thing
    
    optional arguments:
      -h, --help  show this help message and exit
    $ python echo.py hello world  # too many arguments
    usage: echo.py [-h] thing
    echo.py: error: unrecognized arguments: world
    

    As you can see, autocommand converts the signature of the function into an argument spec. When you run the file as a program, autocommand collects the command-line arguments and turns them into function arguments. The function is executed with these arguments, and then the program exits with the return value of the function, via sys.exit. Autocommand also automatically creates a usage message, which can be invoked with -h or --help, and automatically prints an error message when provided with invalid arguments.

    Types

    You can use a type annotation to give an argument a type. Any type (or in fact any callable) that returns an object when given a string argument can be used, though there are a few special cases that are described later.

    @autocommand(__name__)
    def net_client(host, port: int):
        ...
    

    Autocommand will catch TypeErrors raised by the type during argument parsing, so you can supply a callable and do some basic argument validation as well.

    Trailing Arguments

    You can add a *args parameter to your function to give it trailing arguments. The command will collect 0 or more trailing arguments and supply them to args as a tuple. If a type annotation is supplied, the type is applied to each argument.

    # Write the contents of each file, one by one
    @autocommand(__name__)
    def cat(*files):
        for filename in files:
            with open(filename) as file:
                for line in file:
                    print(line.rstrip())
    
    $ python cat.py -h
    usage: ipython [-h] [file [file ...]]
    
    positional arguments:
      file
    
    optional arguments:
      -h, --help  show this help message and exit
    

    Options

    To create --option switches, just assign a default. Autocommand will automatically create --long and -short switches.

    @autocommand(__name__)
    def do_with_config(argument, config='~/foo.conf'):
        pass
    
    $ python example.py -h
    usage: example.py [-h] [-c CONFIG] argument
    
    positional arguments:
      argument
    
    optional arguments:
      -h, --help            show this help message and exit
      -c CONFIG, --config CONFIG
    

    The option's type is automatically deduced from the default, unless one is explicitly given in an annotation:

    @autocommand(__name__)
    def http_connect(host, port=80):
        print('{}:{}'.format(host, port))
    
    $ python http.py -h
    usage: http.py [-h] [-p PORT] host
    
    positional arguments:
      host
    
    optional arguments:
      -h, --help            show this help message and exit
      -p PORT, --port PORT
    $ python http.py localhost
    localhost:80
    $ python http.py localhost -p 8080
    localhost:8080
    $ python http.py localhost -p blah
    usage: http.py [-h] [-p PORT] host
    http.py: error: argument -p/--port: invalid int value: 'blah'
    

    None

    If an option is given a default value of None, it reads in a value as normal, but supplies None if the option isn't provided.

    Switches

    If an argument is given a default value of True or False, or given an explicit bool type, it becomes an option switch.

        @autocommand(__name__)
        def example(verbose=False, quiet=False):
            pass
    
    $ python example.py -h
    usage: example.py [-h] [-v] [-q]
    
    optional arguments:
      -h, --help     show this help message and exit
      -v, --verbose
      -q, --quiet
    

    Autocommand attempts to do the "correct thing" in these cases- if the default is True, then supplying the switch makes the argument False; if the type is bool and the default is some other True value, then supplying the switch makes the argument False, while not supplying the switch makes the argument the default value.

    Autocommand also supports the creation of switch inverters. Pass add_nos=True to autocommand to enable this.

        @autocommand(__name__, add_nos=True)
        def example(verbose=False):
            pass
    
    $ python example.py -h
    usage: ipython [-h] [-v] [--no-verbose]
    
    optional arguments:
      -h, --help     show this help message and exit
      -v, --verbose
      --no-verbose
    

    Using the --no- version of a switch will pass the opposite value in as a function argument. If multiple switches are present, the last one takes precedence.

    Files

    If the default value is a file object, such as sys.stdout, then autocommand just looks for a string, for a file path. It doesn't do any special checking on the string, though (such as checking if the file exists); it's better to let the client decide how to handle errors in this case. Instead, it provides a special context manager called smart_open, which behaves exactly like open if a filename or other openable type is provided, but also lets you use already open files:

    from autocommand import autocommand, smart_open
    import sys
    
    # Write the contents of stdin, or a file, to stdout
    @autocommand(__name__)
    def write_out(infile=sys.stdin):
        with smart_open(infile) as f:
            for line in f:
                print(line.rstrip())
        # If a file was opened, it is closed here. If it was just stdin, it is untouched.
    
    $ echo "Hello World!" | python write_out.py | tee hello.txt
    Hello World!
    $ python write_out.py --infile hello.txt
    Hello World!
    

    Descriptions and docstrings

    The autocommand decorator accepts description and epilog kwargs, corresponding to the description <https://docs.python.org/3/library/argparse.html#description>_ and epilog <https://docs.python.org/3/library/argparse.html#epilog>_ of the ArgumentParser. If no description is given, but the decorated function has a docstring, then it is taken as the description for the ArgumentParser. You can also provide both the description and epilog in the docstring by splitting it into two sections with 4 or more - characters.

    @autocommand(__name__)
    def copy(infile=sys.stdin, outfile=sys.stdout):
        '''
        Copy an the contents of a file (or stdin) to another file (or stdout)
        ----------
        Some extra documentation in the epilog
        '''
        with smart_open(infile) as istr:
            with smart_open(outfile, 'w') as ostr:
                for line in istr:
                    ostr.write(line)
    
    $ python copy.py -h
    usage: copy.py [-h] [-i INFILE] [-o OUTFILE]
    
    Copy an the contents of a file (or stdin) to another file (or stdout)
    
    optional arguments:
      -h, --help            show this help message and exit
      -i INFILE, --infile INFILE
      -o OUTFILE, --outfile OUTFILE
    
    Some extra documentation in the epilog
    $ echo "Hello World" | python copy.py --outfile hello.txt
    $ python copy.py --infile hello.txt --outfile hello2.txt
    $ python copy.py --infile hello2.txt
    Hello World
    

    Parameter descriptions

    You can also attach description text to individual parameters in the annotation. To attach both a type and a description, supply them both in any order in a tuple

    @autocommand(__name__)
    def copy_net(
        infile: 'The name of the file to send',
        host: 'The host to send the file to',
        port: (int, 'The port to connect to')):
    
        '''
        Copy a file over raw TCP to a remote destination.
        '''
        # Left as an exercise to the reader
    

    Decorators and wrappers

    Autocommand automatically follows wrapper chains created by @functools.wraps. This means that you can apply other wrapping decorators to your main function, and autocommand will still correctly detect the signature.

    from functools import wraps
    from autocommand import autocommand
    
    def print_yielded(func):
        '''
        Convert a generator into a function that prints all yielded elements
        '''
        @wraps(func)
        def wrapper(*args, **kwargs):
            for thing in func(*args, **kwargs):
                print(thing)
        return wrapper
    
    @autocommand(__name__,
        description= 'Print all the values from START to STOP, inclusive, in steps of STEP',
        epilog=      'STOP and STEP default to 1')
    @print_yielded
    def seq(stop, start=1, step=1):
        for i in range(start, stop + 1, step):
            yield i
    
    $ seq.py -h
    usage: seq.py [-h] [-s START] [-S STEP] stop
    
    Print all the values from START to STOP, inclusive, in steps of STEP
    
    positional arguments:
      stop
    
    optional arguments:
      -h, --help            show this help message and exit
      -s START, --start START
      -S STEP, --step STEP
    
    STOP and STEP default to 1
    

    Even though autocommand is being applied to the wrapper returned by print_yielded, it still retreives the signature of the underlying seq function to create the argument parsing.

    Custom Parser

    While autocommand's automatic parser generator is a powerful convenience, it doesn't cover all of the different features that argparse provides. If you need these features, you can provide your own parser as a kwarg to autocommand:

    from argparse import ArgumentParser
    from autocommand import autocommand
    
    parser = ArgumentParser()
    # autocommand can't do optional positonal parameters
    parser.add_argument('arg', nargs='?')
    # or mutually exclusive options
    group = parser.add_mutually_exclusive_group()
    group.add_argument('-v', '--verbose', action='store_true')
    group.add_argument('-q', '--quiet', action='store_true')
    
    @autocommand(__name__, parser=parser)
    def main(arg, verbose, quiet):
        print(arg, verbose, quiet)
    
    $ python parser.py -h
    usage: write_file.py [-h] [-v | -q] [arg]
    
    positional arguments:
      arg
    
    optional arguments:
      -h, --help     show this help message and exit
      -v, --verbose
      -q, --quiet
    $ python parser.py
    None False False
    $ python parser.py hello
    hello False False
    $ python parser.py -v
    None True False
    $ python parser.py -q
    None False True
    $ python parser.py -vq
    usage: parser.py [-h] [-v | -q] [arg]
    parser.py: error: argument -q/--quiet: not allowed with argument -v/--verbose
    

    Any parser should work fine, so long as each of the parser's arguments has a corresponding parameter in the decorated main function. The order of parameters doesn't matter, as long as they are all present. Note that when using a custom parser, autocommand doesn't modify the parser or the retrieved arguments. This means that no description/epilog will be added, and the function's type annotations and defaults (if present) will be ignored.

    Testing and Library use

    The decorated function is only called and exited from if the first argument to autocommand is '__main__' or True. If it is neither of these values, or no argument is given, then a new main function is created by the decorator. This function has the signature main(argv=None), and is intended to be called with arguments as if via main(sys.argv[1:]). The function has the attributes parser and main, which are the generated ArgumentParser and the original main function that was decorated. This is to facilitate testing and library use of your main. Calling the function triggers a parse_args() with the supplied arguments, and returns the result of the main function. Note that, while it returns instead of calling sys.exit, the parse_args() function will raise a SystemExit in the event of a parsing error or -h/--help argument.

        @autocommand()
        def test_prog(arg1, arg2: int, quiet=False, verbose=False):
            if not quiet:
                print(arg1, arg2)
                if verbose:
                    print("LOUD NOISES")
    
            return 0
    
        print(test_prog(['-v', 'hello', '80']))
    
    $ python test_prog.py
    hello 80
    LOUD NOISES
    0
    

    If the function is called with no arguments, sys.argv[1:] is used. This is to allow the autocommand function to be used as a setuptools entry point.

    Exceptions and limitations

    • There are a few possible exceptions that autocommand can raise. All of them derive from autocommand.AutocommandError.

      • If an invalid annotation is given (that is, it isn't a type, str, (type, str), or (str, type), an AnnotationError is raised. The type may be any callable, as described in the Types_ section.
      • If the function has a **kwargs parameter, a KWargError is raised.
      • If, somehow, the function has a positional-only parameter, a PositionalArgError is raised. This means that the argument doesn't have a name, which is currently not possible with a plain def or lambda, though many built-in functions have this kind of parameter.
    • There are a few argparse features that are not supported by autocommand.

      • It isn't possible to have an optional positional argument (as opposed to a --option). POSIX thinks this is bad form anyway.
      • It isn't possible to have mutually exclusive arguments or options
      • It isn't possible to have subcommands or subparsers, though I'm working on a few solutions involving classes or nested function definitions to allow this.

    Development

    Autocommand cannot be important from the project root; this is to enforce separation of concerns and prevent accidental importing of setup.py or tests. To develop, install the project in editable mode:

    $ python setup.py develop
    

    This will create a link to the source files in the deployment directory, so that any source changes are reflected when it is imported.