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(