We Keep Coding

unittest for command line arguments

How do I unit test my script for incorrect command line arguments?
For example,
my_script.py -t
should give an error since -t flag is not present, as shown in the code below:
parser = OptionParser()
parser.add_option("-d",
action="callback",
callback=get_bios_difference,
help="Check difference between two files"
)
(options, args) = parser.parse_args()
if len(sys.argv) == 1: # if only 1 argument, it's the script name
parser.print_help()
exit()

First, you need a unit to test:
def parse_options(args=None):
# Duplicating the default behavior of OptionParser.parse_args
if args is None:
args = sys.argv[1:]
parser = OptionParser()
parser.add_option("-d",
action="callback",
callback=get_bios_difference,
help="Check difference between two files"
)
(options, args) = parser.parse_args(args)
if not args:
parser.print_help()
exit()
Note that we explicitly pass args to parse_args, rather than let it assume sys.argv is to be parsed.
In production, you can call parse_options() and it will work as before. For testing, you can call parse_options([]) or parse_options(["-t"]) or whatever other combination of arguments you want to test.
All that said, you should be using argparse instead of optparse (which has been deprecated for years) in new code.

OptionParser
Deprecated since version 2.7: The optparse module is deprecated and will not be developed further; development will continue with the argparse module.
your questions has nothing to do with unittest? there is no need to assert, the nargs=2 defined 2 items needed for --d.
argparse will check the number of args for you, here is parameter.py
import argparse
from pprint import pprint
def get_parser():
parser = argparse.ArgumentParser(description='example of argparse')
parser.add_argument('--d', type=str, nargs=2, help='2 files')
return parser
if __name__ == '__main__':
parser = get_parser()
args = parser.parse_args(sys.argv[1:])
pprint(args)
run with 2 files:
parameter.py --d a b
Namespace(d=['a', 'b'])
When run with 1 parameter
parameter.py --d a
parameter.py: error: argument --d: expected 2 argument(s)

Argument parsing in Python (required vs. optional)

I'm currently working on a script that will be able to take multiple flags. I want it so that no matter what the last argument should be 'start|stop|status'.
#!/usr/bin/env python
from argparse import ArgumentParser
def argument_analysis():
"""
This will analyze arguments, and return the region as a string, the filter as a dictionary, and the command as a string.
:return: region,filters,command
"""
parser_options = ArgumentParser()
parser_options.add_argument("-r", "--region", dest='region',
help="Filter by region.")
parser_options.add_argument("-n", "--name", dest='name',
help="Filter by hostname.")
parser_options.add_argument("-P", "--project", dest='project',
help="Filter by Project tag.")
parser_options.add_argument("-U", "--usage", dest='usage',
help="Filter by Usage tag.")
parser_options.add_argument("-i", "--instance_id", dest='instance_id',
help="Filter by instance_id.")
parser_options.add_argument("-t", "--type", dest='type',
help="Filter by instance_size.")
parser_options.add_argument("-p", "--ip", dest='internal_ip',
help="Filter by internal_ip")
parser_options.add_argument("-c", "--command", dest='command',
help="stop/start, or check the status of instances.")
parser_options.add_argument("-a", "--all", dest='all', default=False, action='store_true',
help="No filter, display status of all servers.")
arguments = vars(parser_options.parse_args())
return arguments
if __name__ == '__main__':
print argument_analysis()
I want it so that ./argument_analysis_script.py will require a 'stop|start|status' at the end. I haven't had much luck getting help with the ARgumentParser(). If anybody has any suggestions it would be very helpful.
Thanks in advance for your time.
NOTE: I would like for the script to stop if [stop|start|restart|status] is not entered, and explain that [stop|start|restart|status] is required.
**UPDATE** **UPDATE** **UPDATE**
After doing some more digging, to be able to analyze/use command line options, and arguments, I stumbled upon OptionParser, which I avoided as docs.python.org states it's deprecated. Anyway, since that is the only thing that I could find to give me exactly what I wanted, here is an update of what I've got:
#!/usr/bin/env python
from optparse import OptionParser
def argument_analysis():
"""
This will analyze arguments, and return the region as a string, the filter as a dictionary, and the command as a string.
:return: region,filters,command
"""
parser = OptionParser()
parser.add_option("-r", "--region", dest='region',
help="Filter by region.")
parser.add_option("-n", "--name", dest='name',
help="Filter by hostname.")
parser.add_option("-P", "--project", dest='project',
help="Filter by Project tag.")
parser.add_option("-U", "--usage", dest='usage',
help="Filter by Usage tag.")
parser.add_option("-i", "--instance_id", dest='instance_id',
help="Filter by instance_id.")
parser.add_option("-t", "--type", dest='type',
help="Filter by instance_size.")
parser.add_option("-p", "--ip", dest='internal_ip',
help="Filter by internal_ip")
parser.add_option("-c", "--command", dest='command',
help="stop/start, or check the status of instances.")
parser.add_option("-a", "--all", dest='all', default=False, action='store_true',
help="No filter, display status of all servers.")
(options, args) = parser.parse_args() # Grab Options specifed from above, as well as actual Arguments.
options = vars(options) # Convert 'options' into dictionary: key=dest_name, value=dest_value
# Getting variables for dictionary below.
region_filter = options['region']
name_filter = options['name']
project_filter = options['project']
usage_filter = options['usage']
instance_filter = options['instance_id']
type_filter = options['type']
ip_filter = options['internal_ip']
all_filter = options['all']
region = region_filter if region_filter else 'us-east-1' # Return 'us-east-1' region is not specified.
filters = {'tag:Name': name_filter, 'tag:Project': project_filter, 'tag:Usage': usage_filter,
'instance-id': instance_filter, 'instance_type': type_filter, 'private-ip-address': ip_filter,
'all': all_filter}
command = 'No commands.' if not args else args #Return "No commands" if no command is specified.
return region, filters, command
if __name__ == '__main__':
opts_and_args = argument_analysis()
print "Region: " + str(opts_and_args[0])
print "Filters: " + str(opts_and_args[1])
print "Command: " + str(opts_and_args[2])
As you can see, you can apply whatever logic you want to based on the returned object, or within the definition. Thanks everybody for your assistance on this one.

Maybe you can do this with argparse, but another option is to use the sys module
import sys
print sys.argv # prints command line arguments
sys.argv has the command line arguments in a list, so you can check the last one for whatever:
if sys.argv[-1] != 'start':
print "Error, expected <something>"
// quit

Partially the same as Ben's answer, but extended with regex to avoid declaring an if statement for each case, e.g. start, stop.
import sys
import re
a = sys.argv[-1]
if not re.search(r"^(start|stop|restart|status)$", a):
raise Exception("start, stop, restart or status should be passed to this script instead of: \""+a+"\"")

I recommend taking a look at docopt. It's not in the standard library, but it's definitely more powerful and intuitive. For example, in your case you could just do this:
docstring='''My Program.
Usage: my_prog [options] (flag1|flag2|flag3) (start|stop|restart|status)
Options:
-a stuff about this
-b more stuff
-c yet more stuff
-d finally stuff'''
from docopt import docopt
parsed = docopt(docstring)

Argument parsing python using ArgParse

I am creating a python script and for parsing the arguments I would need this:
the script will accept three parameters, only one always mandatory, the second one will only be mandatory depending on certain values of the first one and the third one may or may not appear.
This is my try:
class pathAction(argparse.Action):
folder = {'remote':'/path1', 'projects':'/path2'}
def __call__(self, parser, args, values, option = None):
args.path = values
print "ferw %s " % args.component
if args.component=='hos' or args.component=='hcr':
print "rte %s" % args.path
if args.path and pathAction.folder.get(args.path):
args.path = pathAction.folder[args.path]
else:
parser.error("You must enter the folder you want to clean: available choices[remote, projects]")
def main():
try:
# Arguments parsing
parser = argparse.ArgumentParser(description="""This script will clean the old component files.""")
parser.add_argument("-c", "--component", help="component to clean", type=lowerit, choices=["hos", "hcr", "mdw", "gui"], required=True)
parser.add_argument("-p", "--path", help="path to clean", action = pathAction, choices = ["remote", "projects"])
parser.add_argument("-d", "--delete", help="parameter for deleting the files from the filesystem", nargs='*', default=True)
args = parser.parse_args()
if works well except one case: if i have -c it should complain because there is no -p however it does not
Can you help me please?
Thanks

You can add some custom validation like this:
if args.component and not args.path:
parser.error('Your error message!')

Your special action will be used only if there is a -p argument. If you just give it a -c the cross check is never used.
Generally checking for interactions after parse_args (as Gohn67 suggested) is more reliable, and simpler than with custom actions.
What happens if your commandline was '-p remote -c ...'? pathAction would be called before the -c value is parsed and set. Is that what you want? Your special action only works if -p is given, and is the last argument.
Another option is to make 'component' a subparser positional. By default positionals are required. path and delete can be added to those subparsers that need them.
import argparse
parser = argparse.ArgumentParser(description="""This script will clean the old component files.""")
p1 = argparse.ArgumentParser(add_help=False)
p1.add_argument("path", help="path to clean", choices = ["remote", "projects"])
p2 = argparse.ArgumentParser(add_help=False)
p2.add_argument("-d", "--delete", help="parameter for deleting the files from the filesystem", nargs='*', default=True)
sp = parser.add_subparsers(dest='component',description="component to clean")
sp.add_parser('hos', parents=[p1,p2])
sp.add_parser('hcr', parents=[p1,p2])
sp.add_parser('mdw', parents=[p2])
sp.add_parser('gui', parents=[p2])
print parser.parse_args()
sample use:
1848:~/mypy$ python2.7 stack21625446.py hos remote -d 1 2 3
Namespace(component='hos', delete=['1', '2', '3'], path='remote')
I used parents to simplify adding arguments to multiple subparsers. I made path a positional, since it is required (for 2 of the subparsers). In those cases --path just makes the user type more. With nargs='*', --delete has to belong to the subparsers so it can occur last. If it's nargs was fixed (None or number) it could be an argument of parser.

optparse csv.reader

Can somebody help me, I'm trying to link an optparse with a csv reader, but I have been unable to do so. Below is my code:
import csv
from optparse import OptionParser
parser = OptionParser()
parser.add_option('--i1', action='store', type='string', dest='input1file', help='[REQUIRED] The input .csv file path.')
(options, args) = parser.parse_args()
input1file = options.input1file
data = csv.reader(open('input1file','r'))
temp = open('C:\Practice\output_edited.csv','a')
for column in data:
temp.write(column[0]+','+column[len(column)-1]+'\n')
print column[0]+','+column[len(column)-1]+'\n'
temp.close()
I don't know how to connect the add_option part so that the user can type in the filename path.
Thanks!
I updated my code. Still can't get it working though.
Update1:
import sys
import csv
from optparse import OptionParser
parser = OptionParser()
parser.add_option('--i1', action='store', type='string', dest='input1file', help='[REQUIRED] The input .csv file path.')
(options, args) = parser.parse_args()
input1file = options.input1file
try:
input1file = args[1]
except IndexError:
sys.exit("Input file required, none given")
data = csv.reader(open(sys.args[1],'r'))
temp = open('C:\Practice\output_edited.csv','a')
for column in data:
temp.write(column[0]+','+column[len(column)-1]+'\n')
print column[0]+','+column[len(column)-1]+'\n'
temp.close()

If you don't specify --i1 on the command line, options.input1file is None, since you don't provide a default value.
myscript.py --i1 input.txt
Since --i1 is required, it really shouldn't be an option (since it is not optional). Take the input file from args, instead:
parser = OptionParser()
(options, args) = parser.parse_args()
try:
input1file = args[0]
except IndexError:
sys.exit("Input file required, none given")
Or, as mgilson suggested, use argparse instead. It supports named positional parameters.

data = csv.reader(open('input1file','r'))
should be
data = csv.reader(open(input1file,'r'))
Based on your comment, it looks like you're forgetting to use the --i1 argument. If it is actually required, you should enforce that:
e.g.:
if not input1file:
print "What? you were supposed to give '--i1 filename', but you didn't. Shame on you!"
sys.exit(1)
note that this is easier to do in argparse. You just pass required=True to the add_argument method

Display help message with Python argparse when script is called without any arguments

Assume I have a program that uses argparse to process command line arguments/options. The following will print the 'help' message:
./myprogram -h
or:
./myprogram --help
But, if I run the script without any arguments whatsoever, it doesn't do anything. What I want it to do is to display the usage message when it is called with no arguments. How is that done?

This answer comes from Steven Bethard on Google groups. I'm reposting it here to make it easier for people without a Google account to access.
You can override the default behavior of the error method:
import argparse
import sys
class MyParser(argparse.ArgumentParser):
def error(self, message):
sys.stderr.write('error: %s\n' % message)
self.print_help()
sys.exit(2)
parser = MyParser()
parser.add_argument('foo', nargs='+')
args = parser.parse_args()
Note that the above solution will print the help message whenever the error
method is triggered. For example, test.py --blah will print the help message
too if --blah isn't a valid option.
If you want to print the help message only if no arguments are supplied on the
command line, then perhaps this is still the easiest way:
import argparse
import sys
parser=argparse.ArgumentParser()
parser.add_argument('foo', nargs='+')
if len(sys.argv)==1:
parser.print_help(sys.stderr)
sys.exit(1)
args=parser.parse_args()
Note that parser.print_help() prints to stdout by default. As init_js suggests, use parser.print_help(sys.stderr) to print to stderr.

Instead of writing a class, a try/except can be used instead
try:
options = parser.parse_args()
except:
parser.print_help()
sys.exit(0)
The upside is that the workflow is clearer and you don't need a stub class. The downside is that the first 'usage' line is printed twice.
This will need at least one mandatory argument. With no mandatory arguments, providing zero args on the commandline is valid.

With argparse you could use ArgumentParser.print_usage():
parser.argparse.ArgumentParser()
# parser.add_args here
# sys.argv includes a list of elements starting with the program
if len(sys.argv) < 2:
parser.print_usage()
sys.exit(1)
Printing help
ArgumentParser.print_usage(file=None)
  Print a brief description of how the ArgumentParser should be invoked on the command line. If file is None, sys.stdout is assumed.

The cleanest solution will be to manually pass default argument if none were given on the command line:
parser.parse_args(args=None if sys.argv[1:] else ['--help'])
Complete example:
import argparse, sys
parser = argparse.ArgumentParser()
parser.add_argument('--host', default='localhost', help='Host to connect to')
# parse arguments
args = parser.parse_args(args=None if sys.argv[1:] else ['--help'])
# use your args
print("connecting to {}".format(args.host))
This will print complete help (not short usage) if called w/o arguments.

If you associate default functions for (sub)parsers, as is mentioned under add_subparsers, you can simply add it as the default action:
parser = argparse.ArgumentParser()
parser.set_defaults(func=lambda x: parser.print_usage())
args = parser.parse_args()
args.func(args)
Add the try-except if you raise exceptions due to missing positional arguments.

If you have arguments that must be specified for the script to run - use the required parameter for ArgumentParser as shown below:-
parser.add_argument('--foo', required=True)
parse_args() will report an error if the script is run without any arguments.

Throwing my version into the pile here:
import argparse
parser = argparse.ArgumentParser()
args = parser.parse_args()
if not vars(args):
parser.print_help()
parser.exit(1)
You may notice the parser.exit - I mainly do it like that because it saves an import line if that was the only reason for sys in the file...

There are a pair of one-liners with sys.argv[1:] (a very common Python's idiom to refer the command line arguments, being sys.argv[0] the script's name) that can do the job.
The first one is self-explanatory, clean and pythonic:
args = parser.parse_args(None if sys.argv[1:] else ['-h'])
The second one is a little hackier. Combining the previously evaluated fact that an empty list is False with the True == 1 and False == 0 equivalences you get this:
args = parser.parse_args([None, ['-h']][not sys.argv[1:]])
Maybe too many brackets, but pretty clear if a previous argument selection was made.
_, *av = sys.argv
args = parser.parse_args([None, ['-h']][not av])

parser.print_help()
parser.exit()
The parser.exit method also accept a status (returncode), and a message value (include a trailing newline yourself!).
an opinionated example,
:)
#!/usr/bin/env python3
""" Example argparser based python file
"""
import argparse
ARGP = argparse.ArgumentParser(
description=__doc__,
formatter_class=argparse.RawTextHelpFormatter,
)
ARGP.add_argument('--example', action='store_true', help='Example Argument')
def main(argp=None):
if argp is None:
argp = ARGP.parse_args() # pragma: no cover
if 'soemthing_went_wrong' and not argp.example:
ARGP.print_help()
ARGP.exit(status=64, message="\nSomething went wrong, --example condition was not set\n")
if __name__ == '__main__':
main() # pragma: no cover
Example calls:
$ python3 ~/helloworld.py; echo $?
usage: helloworld.py [-h] [--example]
Example argparser based python file
optional arguments:
-h, --help show this help message and exit
--example Example Argument
Something went wrong, --example condition was not set
64
$ python3 ~/helloworld.py --example; echo $?
0

Most of the answers here required another module, such as sys, to be imported or were using optional arguments. I wanted to discover an answer that used only argparse, worked with required arguments, and if possible worked without catching exceptions. I ended up with the following:
import argparse
if __name__ == '__main__':
arg_parser = argparse.ArgumentParser(add_help=False)
arg_parser.add_argument('input_file', type=str, help='The path to the input file.')
arg_parser.add_argument('output_file', type=str, help='The path to the output file.')
arg_parser.add_argument('-h','--help', action='store_true', help='show this help message and exit')
arg_parser.usage = arg_parser.format_help()
args = arg_parser.parse_args()
The main idea was to use the format_help function in order to provide the help string to the usage statement. Setting add_help to False in the call to ArgumentParser() prevents the help statement from printing twice in certain circumstances. However, I had to create an argument for the optional help argument that mimicked the typical help message once it was set to False in order to display the optional help argument in the help message. The action is set to store_true in the help argument to prevent the help message from filling in a value like HELP for the parameter when it prints the help message.

So for a really simple answer. Most of the time with argparse you are checking to see if parameters are set anyway, to call a function that does something.
If no parameters, just else out at the end and print the help. Simple and works.
import argparse
import sys
parser = argparse.ArgumentParser()
group = parser.add_mutually_exclusive_group()
group.add_argument("--holidays", action='store_true')
group.add_argument("--people", action='store_true')
args=parser.parse_args()
if args.holidays:
get_holidays()
elif args.people:
get_people()
else:
parser.print_help(sys.stderr)

Here is another way to do it, if you need something flexible where you want to display help if specific params are passed, none at all or more than 1 conflicting arg:
import argparse
import sys
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-d', '--days', required=False, help="Check mapped inventory that is x days old", default=None)
parser.add_argument('-e', '--event', required=False, action="store", dest="event_id",
help="Check mapped inventory for a specific event", default=None)
parser.add_argument('-b', '--broker', required=False, action="store", dest="broker_id",
help="Check mapped inventory for a broker", default=None)
parser.add_argument('-k', '--keyword', required=False, action="store", dest="event_keyword",
help="Check mapped inventory for a specific event keyword", default=None)
parser.add_argument('-p', '--product', required=False, action="store", dest="product_id",
help="Check mapped inventory for a specific product", default=None)
parser.add_argument('-m', '--metadata', required=False, action="store", dest="metadata",
help="Check mapped inventory for specific metadata, good for debugging past tix", default=None)
parser.add_argument('-u', '--update', required=False, action="store_true", dest="make_updates",
help="Update the event for a product if there is a difference, default No", default=False)
args = parser.parse_args()
days = args.days
event_id = args.event_id
broker_id = args.broker_id
event_keyword = args.event_keyword
product_id = args.product_id
metadata = args.metadata
make_updates = args.make_updates
no_change_counter = 0
change_counter = 0
req_arg = bool(days) + bool(event_id) + bool(broker_id) + bool(product_id) + bool(event_keyword) + bool(metadata)
if not req_arg:
print("Need to specify days, broker id, event id, event keyword or past tickets full metadata")
parser.print_help()
sys.exit()
elif req_arg != 1:
print("More than one option specified. Need to specify only one required option")
parser.print_help()
sys.exit()
# Processing logic here ...
Cheers!

I like to keep things as simple as possible, this works great:
#!/usr/bin/env python3
Description = """Tool description"""
Epilog = """toolname.py -a aflag -b bflag with these combined it does blah"""
arg_parser = argparse.ArgumentParser(
formatter_class=argparse.RawDescriptionHelpFormatter,
description=Description,
epilog=Epilog,
)
try:
if len(sys.argv) == 1:
arg_parser.print_help()
except Exception as e:
print(e)
This is how I start all my tools as its always good to include some examples

When call add_subparsers method save the first positional argument to dest= and check value after argparse has been initialized, like this:
subparsers = parser.add_subparsers(dest='command')
And just check this this variable:
if not args.command:
parser.print_help()
parser.exit(1) # If exit() - exit code will be zero (no error)
Full example:
#!/usr/bin/env python
""" doc """
import argparse
import sys
parser = argparse.ArgumentParser(description=__doc__)
subparsers = parser.add_subparsers(dest='command',
help='List of commands')
list_parser = subparsers.add_parser('list',
help='List contents')
list_parser.add_argument('dir', action='store',
help='Directory to list')
create_parser = subparsers.add_parser('create',
help='Create a directory')
create_parser.add_argument('dirname', action='store',
help='New directory to create')
create_parser.add_argument('--read-only', default=False, action='store_true',
help='Set permissions to prevent writing to the directory')
args = parser.parse_args()
if not args.command:
parser.print_help()
parser.exit(1)
print(vars(args)) # For debug

This approach is a lot more elegant than most others. Instead of overriding error(), you can control the behaviour a lot more precisely by wrapping the parse_args() method:
import sys
import argparse
HelpFlags = ('help', '--help', '-h', '/h', '?', '/?', )
class ArgParser (argparse.ArgumentParser):
def __init__(self, *args, **kws):
super().__init__(*args, **kws)
def parse_args(self, args=None, namespace=None):
if args is None:
args = sys.argv[1:]
if len(args) < 1 or (args[0].lower() in HelpFlags):
self.print_help(sys.stderr)
sys.exit()
return super().parse_args(args, namespace)

Set your positional arguments with nargs, and check if positional args are empty.
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('file', nargs='?')
args = parser.parse_args()
if not args.file:
parser.print_help()
Reference Python nargs

If your command is something where a user needs to choose some action, then use a mutually exclusive group with required=True.
This is kind of an extension to the answer given by pd321.
import argparse
parser = argparse.ArgumentParser()
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument("--batch", action='store', type=int, metavar='pay_id')
group.add_argument("--list", action='store_true')
group.add_argument("--all", action='store_true', help='check all payments')
args=parser.parse_args()
if args.batch:
print('batch {}'.format(args.batch))
if args.list:
print('list')
if args.all:
print('all')
Output:
$ python3 a_test.py
usage: a_test.py [-h] (--batch pay_id | --list | --all)
a_test.py: error: one of the arguments --batch --list --all is required
This only give the basic help. And some of the other answers will give you the full help. But at least your users know they can do -h

This isn't good (also, because intercepts all errors), but:
def _error(parser):
def wrapper(interceptor):
parser.print_help()
sys.exit(-1)
return wrapper
def _args_get(args=sys.argv[1:]):
parser = argparser.ArgumentParser()
parser.error = _error(parser)
parser.add_argument(...)
...
Here is definition of the error function of the ArgumentParser class.
As you see, the following signature takes two arguments. However, functions outside the class know nothing about first argument self, because, roughly speaking, this argument is for the class.
def _error(self, message):
self.print_help()
sys.exit(-1)
def _args_get(args=sys.argv[1:]):
parser = argparser.ArgumentParser()
parser.error = _error
...
will output:
"AttributeError: 'str' object has no attribute 'print_help'"
You can pass parser (self) in _error function, by calling it:
def _error(self, message):
self.print_help()
sys.exit(-1)
def _args_get(args=sys.argv[1:]):
parser = argparser.ArgumentParser()
parser.error = _error(parser)
...
But if you don't want exit the program right now, return it:
def _error(parser):
def wrapper():
parser.print_help()
sys.exit(-1)
return wrapper
Nonetheless, parser doesn't know that it has been modified. Thus, when an error occurs, it will print the cause of it (by the way, it's a localized translation). So intercept it:
def _error(parser):
def wrapper(interceptor):
parser.print_help()
sys.exit(-1)
return wrapper
Now, when an error occurs, parser will print the cause of it, and you'll intercept it, look at it, and... throw out.