Terminology¶

argument

a string entered on the command-line, and passed by the shell toexecl()orexecv(). In Python, arguments are elements ofsys.argv[1:](sys.argv[0] is the name of the program being executed). Unix shellsalso use the term “word”.

It is occasionally desirable to substitute an argument list other thansys.argv[1:], so you should read “argument” as “an element ofsys.argv[1:], or of some other list provided as a substitute forsys.argv[1:]”.

option

an argument used to supply extra information to guide or customize theexecution of a program. There are many different syntaxes for options; thetraditional Unix syntax is a hyphen (“-”) followed by a single letter,e.g.-x or-F. Also, traditional Unix syntax allows multipleoptions to be merged into a single argument, e.g.-x-F is equivalentto-xF. The GNU project introduced-- followed by a series ofhyphen-separated words, e.g.--file or--dry-run. These are theonly two option syntaxes provided byoptparse.

Some other option syntaxes that the world has seen include:

• a hyphen followed by a few letters, e.g.-pf (this isnot the sameas multiple options merged into a single argument)

• a hyphen followed by a whole word, e.g.-file (this is technicallyequivalent to the previous syntax, but they aren’t usually seen in the sameprogram)

• a plus sign followed by a single letter, or a few letters, or a word, e.g.+f,+rgb

• a slash followed by a letter, or a few letters, or a word, e.g./f,/file

These option syntaxes are not supported byoptparse, and they neverwill be. This is deliberate: the first three are non-standard on anyenvironment, and the last only makes sense if you’re exclusively targetingWindows or certain legacy platforms (e.g. VMS, MS-DOS).

option argument

an argument that follows an option, is closely associated with that option,and is consumed from the argument list when that option is. Withoptparse, option arguments may either be in a separate argument fromtheir option:

-f foo--file foo

or included in the same argument:

-ffoo--file=foo

Typically, a given option either takes an argument or it doesn’t. Lots ofpeople want an “optional option arguments” feature, meaning that some optionswill take an argument if they see it, and won’t if they don’t. This issomewhat controversial, because it makes parsing ambiguous: if-a takesan optional argument and-b is another option entirely, how do weinterpret-ab? Because of this ambiguity,optparse does notsupport this feature.

positional argument

something leftover in the argument list after options have been parsed, i.e.after options and their arguments have been parsed and removed from theargument list.

required option

an option that must be supplied on the command-line; note that the phrase“required option” is self-contradictory in English.optparse doesn’tprevent you from implementing required options, but doesn’t give you muchhelp at it either.

For example, consider this hypothetical command-line:

prog-v--reportreport.txtfoobar

-v and--report are both options. Assuming that--reporttakes one argument,report.txt is an option argument.foo andbar are positional arguments.

What are options for?¶

Options are used to provide extra information to tune or customize the executionof a program. In case it wasn’t clear, options are usuallyoptional. Aprogram should be able to run just fine with no options whatsoever. (Pick arandom program from the Unix or GNU toolsets. Can it run without any options atall and still make sense? The main exceptions arefind,tar, anddd—all of which are mutant oddballs that have been rightly criticizedfor their non-standard syntax and confusing interfaces.)

Lots of people want their programs to have “required options”. Think about it.If it’s required, then it’snot optional! If there is a piece of informationthat your program absolutely requires in order to run successfully, that’s whatpositional arguments are for.

As an example of good command-line interface design, consider the humblecputility, for copying files. It doesn’t make much sense to try to copy fileswithout supplying a destination and at least one source. Hence,cp fails ifyou run it with no arguments. However, it has a flexible, useful syntax thatdoes not require any options at all:

cpSOURCEDESTcpSOURCE...DEST-DIR

You can get pretty far with just that. Mostcp implementations provide abunch of options to tweak exactly how the files are copied: you can preservemode and modification time, avoid following symlinks, ask before clobberingexisting files, etc. But none of this distracts from the core mission ofcp, which is to copy either one file to another, or several files to anotherdirectory.

What are positional arguments for?¶

Positional arguments are for those pieces of information that your programabsolutely, positively requires to run.

A good user interface should have as few absolute requirements as possible. Ifyour program requires 17 distinct pieces of information in order to runsuccessfully, it doesn’t much matterhow you get that information from theuser—most people will give up and walk away before they successfully run theprogram. This applies whether the user interface is a command-line, aconfiguration file, or a GUI: if you make that many demands on your users, mostof them will simply give up.

In short, try to minimize the amount of information that users are absolutelyrequired to supply—use sensible defaults whenever possible. Of course, youalso want to make your programs reasonably flexible. That’s what options arefor. Again, it doesn’t matter if they are entries in a config file, widgets inthe “Preferences” dialog of a GUI, or command-line options—the more optionsyou implement, the more flexible your program is, and the more complicated itsimplementation becomes. Too much flexibility has drawbacks as well, of course;too many options can overwhelm users and make your code much harder to maintain.

Understanding option actions¶

Actions telloptparse what to do when it encounters an option on thecommand line. There is a fixed set of actions hard-coded intooptparse;adding new actions is an advanced topic covered in sectionExtending optparse. Most actions telloptparse to storea value in some variable—for example, take a string from the command line andstore it in an attribute ofoptions.

If you don’t specify an option action,optparse defaults tostore.

The store action¶

The most common option action isstore, which tellsoptparse to takethe next argument (or the remainder of the current argument), ensure that it isof the correct type, and store it to your chosen destination.

For example:

parser.add_option("-f","--file",action="store",type="string",dest="filename")

Now let’s make up a fake command line and askoptparse to parse it:

args=["-f","foo.txt"](options,args)=parser.parse_args(args)

Whenoptparse sees the option string-f, it consumes the nextargument,foo.txt, and stores it inoptions.filename. So, after thiscall toparse_args(),options.filename is"foo.txt".

Some other option types supported byoptparse areint andfloat.Here’s an option that expects an integer argument:

parser.add_option("-n",type="int",dest="num")

Note that this option has no long option string, which is perfectly acceptable.Also, there’s no explicit action, since the default isstore.

Let’s parse another fake command-line. This time, we’ll jam the option argumentright up against the option: since-n42 (one argument) is equivalent to-n42 (two arguments), the code

(options,args)=parser.parse_args(["-n42"])print(options.num)

will print42.

If you don’t specify a type,optparse assumesstring. Combined withthe fact that the default action isstore, that means our first example canbe a lot shorter:

parser.add_option("-f","--file",dest="filename")

If you don’t supply a destination,optparse figures out a sensibledefault from the option strings: if the first long option string is--foo-bar, then the default destination isfoo_bar. If there are nolong option strings,optparse looks at the first short option string: thedefault destination for-f isf.

optparse also includes the built-incomplex type. Addingtypes is covered in sectionExtending optparse.

Handling boolean (flag) options¶

Flag options—set a variable to true or false when a particular option isseen—are quite common.optparse supports them with two separate actions,store_true andstore_false. For example, you might have averboseflag that is turned on with-v and off with-q:

parser.add_option("-v",action="store_true",dest="verbose")parser.add_option("-q",action="store_false",dest="verbose")

Here we have two different options with the same destination, which is perfectlyOK. (It just means you have to be a bit careful when setting defaultvalues—see below.)

Whenoptparse encounters-v on the command line, it setsoptions.verbose toTrue; when it encounters-q,options.verbose is set toFalse.

Other actions¶

Some other actions supported byoptparse are:

"store_const"

store a constant value, pre-set viaOption.const

"append"

append this option’s argument to a list

"count"

increment a counter by one

"callback"

call a specified function

These are covered in sectionReference Guide,and sectionOption Callbacks.

Default values¶

All of the above examples involve setting some variable (the “destination”) whencertain command-line options are seen. What happens if those options are neverseen? Since we didn’t supply any defaults, they are all set toNone. Thisis usually fine, but sometimes you want more control.optparse lets yousupply a default value for each destination, which is assigned before thecommand line is parsed.

First, consider the verbose/quiet example. If we wantoptparse to setverbose toTrue unless-q is seen, then we can do this:

parser.add_option("-v",action="store_true",dest="verbose",default=True)parser.add_option("-q",action="store_false",dest="verbose")

Since default values apply to thedestination rather than to any particularoption, and these two options happen to have the same destination, this isexactly equivalent:

parser.add_option("-v",action="store_true",dest="verbose")parser.add_option("-q",action="store_false",dest="verbose",default=True)

Consider this:

parser.add_option("-v",action="store_true",dest="verbose",default=False)parser.add_option("-q",action="store_false",dest="verbose",default=True)

Again, the default value forverbose will beTrue: the last defaultvalue supplied for any particular destination is the one that counts.

A clearer way to specify default values is theset_defaults() method ofOptionParser, which you can call at any time before callingparse_args():

parser.set_defaults(verbose=True)parser.add_option(...)(options,args)=parser.parse_args()

As before, the last value specified for a given option destination is the onethat counts. For clarity, try to use one method or the other of setting defaultvalues, not both.

Generating help¶

optparse’s ability to generate help and usage text automatically isuseful for creating user-friendly command-line interfaces. All you have to dois supply ahelp value for each option, and optionally a shortusage message for your whole program. Here’s an OptionParser populated withuser-friendly (documented) options:

usage="usage: %prog [options] arg1 arg2"parser=OptionParser(usage=usage)parser.add_option("-v","--verbose",action="store_true",dest="verbose",default=True,help="make lots of noise [default]")parser.add_option("-q","--quiet",action="store_false",dest="verbose",help="be vewwy quiet (I'm hunting wabbits)")parser.add_option("-f","--filename",metavar="FILE",help="write output to FILE")parser.add_option("-m","--mode",default="intermediate",help="interaction mode: novice, intermediate, ""or expert [default:%default]")

Ifoptparse encounters either-h or--help on thecommand-line, or if you just callparser.print_help(), it prints thefollowing to standard output:

Usage: <yourscript> [options] arg1 arg2Options:  -h, --help            show this help message and exit  -v, --verbose         make lots of noise [default]  -q, --quiet           be vewwy quiet (I'm hunting wabbits)  -f FILE, --filename=FILE                        write output to FILE  -m MODE, --mode=MODE  interaction mode: novice, intermediate, or                        expert [default: intermediate]

(If the help output is triggered by a help option,optparse exits afterprinting the help text.)

There’s a lot going on here to helpoptparse generate the best possiblehelp message:

• the script defines its own usage message:

  usage="usage: %prog [options] arg1 arg2"

  optparse expands%prog in the usage string to the name of thecurrent program, i.e.os.path.basename(sys.argv[0]). The expanded stringis then printed before the detailed option help.

  If you don’t supply a usage string,optparse uses a bland but sensibledefault:"Usage:%prog[options]", which is fine if your script doesn’ttake any positional arguments.

• every option defines a help string, and doesn’t worry aboutline-wrapping—optparse takes care of wrapping lines and makingthe help output look good.

• options that take a value indicate this fact in their automatically generatedhelp message, e.g. for the “mode” option:

  -mMODE,--mode=MODE

  Here, “MODE” is called the meta-variable: it stands for the argument that theuser is expected to supply to-m/--mode. By default,optparse converts the destination variable name to uppercase and usesthat for the meta-variable. Sometimes, that’s not what you want—forexample, the--filename option explicitly setsmetavar="FILE",resulting in this automatically generated option description:

  -fFILE,--filename=FILE

  This is important for more than just saving space, though: the manuallywritten help text uses the meta-variableFILE to clue the user in thatthere’s a connection between the semi-formal syntax-fFILE and the informalsemantic description “write output to FILE”. This is a simple but effectiveway to make your help text a lot clearer and more useful for end users.

• options that have a default value can include%default in the helpstring—optparse will replace it withstr() of the option’sdefault value. If an option has no default value (or the default value isNone),%default expands tonone.

group=OptionGroup(parser,"Dangerous Options","Caution: use these options at your own risk.  ""It is believed that some of them bite.")group.add_option("-g",action="store_true",help="Group option.")parser.add_option_group(group)

Usage: <yourscript> [options] arg1 arg2Options:  -h, --help            show this help message and exit  -v, --verbose         make lots of noise [default]  -q, --quiet           be vewwy quiet (I'm hunting wabbits)  -f FILE, --filename=FILE                        write output to FILE  -m MODE, --mode=MODE  interaction mode: novice, intermediate, or                        expert [default: intermediate]  Dangerous Options:    Caution: use these options at your own risk.  It is believed that some    of them bite.    -g                  Group option.

group=OptionGroup(parser,"Dangerous Options","Caution: use these options at your own risk.  ""It is believed that some of them bite.")group.add_option("-g",action="store_true",help="Group option.")parser.add_option_group(group)group=OptionGroup(parser,"Debug Options")group.add_option("-d","--debug",action="store_true",help="Print debug information")group.add_option("-s","--sql",action="store_true",help="Print all SQL statements executed")group.add_option("-e",action="store_true",help="Print every action done")parser.add_option_group(group)

Usage: <yourscript> [options] arg1 arg2Options:  -h, --help            show this help message and exit  -v, --verbose         make lots of noise [default]  -q, --quiet           be vewwy quiet (I'm hunting wabbits)  -f FILE, --filename=FILE                        write output to FILE  -m MODE, --mode=MODE  interaction mode: novice, intermediate, or expert                        [default: intermediate]  Dangerous Options:    Caution: use these options at your own risk.  It is believed that some    of them bite.    -g                  Group option.  Debug Options:    -d, --debug         Print debug information    -s, --sql           Print all SQL statements executed    -e                  Print every action done

Printing a version string¶

Similar to the brief usage string,optparse can also print a versionstring for your program. You have to supply the string as theversionargument to OptionParser:

parser=OptionParser(usage="%prog [-f] [-q]",version="%prog 1.0")

%prog is expanded just like it is inusage. Apart from that,version can contain anything you like. When you supply it,optparseautomatically adds a--version option to your parser. If it encountersthis option on the command line, it expands yourversion string (byreplacing%prog), prints it to stdout, and exits.

For example, if your script is called/usr/bin/foo:

$/usr/bin/foo--versionfoo 1.0

The following two methods can be used to print and get theversion string:

OptionParser.print_version(file=None)¶

Print the version message for the current program (self.version) tofile (default stdout). As withprint_usage(), any occurrenceof%prog inself.version is replaced with the name of the currentprogram. Does nothing ifself.version is empty or undefined.

OptionParser.get_version()¶

Same asprint_version() but returns the version string instead ofprinting it.

Howoptparse handles errors¶

There are two broad classes of errors thatoptparse has to worry about:programmer errors and user errors. Programmer errors are usually erroneouscalls toOptionParser.add_option(), e.g. invalid option strings, unknownoption attributes, missing option attributes, etc. These are dealt with in theusual way: raise an exception (eitheroptparse.OptionError orTypeError) and let the program crash.

Handling user errors is much more important, since they are guaranteed to happenno matter how stable your code is.optparse can automatically detectsome user errors, such as bad option arguments (passing-n4x where-n takes an integer argument), missing arguments (-n at the endof the command line, where-n takes an argument of any type). Also,you can callOptionParser.error() to signal an application-defined errorcondition:

(options,args)=parser.parse_args()...ifoptions.aandoptions.b:parser.error("options -a and -b are mutually exclusive")

In either case,optparse handles the error the same way: it prints theprogram’s usage message and an error message to standard error and exits witherror status 2.

Consider the first example above, where the user passes4x to an optionthat takes an integer:

$/usr/bin/foo-n4xUsage: foo [options]foo: error: option -n: invalid integer value: '4x'

Or, where the user fails to pass a value at all:

$/usr/bin/foo-nUsage: foo [options]foo: error: -n option requires an argument

optparse-generated error messages take care always to mention theoption involved in the error; be sure to do the same when callingOptionParser.error() from your application code.

Ifoptparse’s default error-handling behaviour does not suit your needs,you’ll need to subclass OptionParser and override itsexit()and/orerror() methods.

Putting it all together¶

Here’s whatoptparse-based scripts usually look like:

fromoptparseimportOptionParser...defmain():usage="usage: %prog [options] arg"parser=OptionParser(usage)parser.add_option("-f","--file",dest="filename",help="read data from FILENAME")parser.add_option("-v","--verbose",action="store_true",dest="verbose")parser.add_option("-q","--quiet",action="store_false",dest="verbose")...(options,args)=parser.parse_args()iflen(args)!=1:parser.error("incorrect number of arguments")ifoptions.verbose:print("reading%s..."%options.filename)...if__name__=="__main__":main()

Creating the parser¶

The first step in usingoptparse is to create an OptionParser instance.

classoptparse.OptionParser(...)¶

The OptionParser constructor has no required arguments, but a number ofoptional keyword arguments. You should always pass them as keywordarguments, i.e. do not rely on the order in which the arguments are declared.

usage (default:"%prog[options]")

The usage summary to print when your program is run incorrectly or with ahelp option. Whenoptparse prints the usage string, it expands%prog toos.path.basename(sys.argv[0]) (or toprog if youpassed that keyword argument). To suppress a usage message, pass thespecial valueoptparse.SUPPRESS_USAGE.

option_list (default:[])

A list of Option objects to populate the parser with. The options inoption_list are added after any options instandard_option_list (aclass attribute that may be set by OptionParser subclasses), but beforeany version or help options. Deprecated; useadd_option() aftercreating the parser instead.

option_class (default: optparse.Option)

Class to use when adding options to the parser inadd_option().

version (default:None)

A version string to print when the user supplies a version option. If yousupply a true value forversion,optparse automatically adds aversion option with the single option string--version. Thesubstring%prog is expanded the same as forusage.

conflict_handler (default:"error")

Specifies what to do when options with conflicting option strings areadded to the parser; see sectionConflicts between options.

description (default:None)

A paragraph of text giving a brief overview of your program.optparse reformats this paragraph to fit the current terminal widthand prints it when the user requests help (afterusage, but before thelist of options).

formatter (default: a newIndentedHelpFormatter)

An instance of optparse.HelpFormatter that will be used for printing helptext.optparse provides two concrete classes for this purpose:IndentedHelpFormatter and TitledHelpFormatter.

add_help_option (default:True)

If true,optparse will add a help option (with option strings-hand--help) to the parser.

prog

The string to use when expanding%prog inusage andversioninstead ofos.path.basename(sys.argv[0]).

epilog (default:None)

A paragraph of help text to print after the option help.

Populating the parser¶

There are several ways to populate the parser with options. The preferred wayis by usingOptionParser.add_option(), as shown in sectionTutorial.add_option() can be called in one of two ways:

• pass it an Option instance (as returned bymake_option())

• pass it any combination of positional and keyword arguments that areacceptable tomake_option() (i.e., to the Option constructor), and itwill create the Option instance for you

The other alternative is to pass a list of pre-constructed Option instances tothe OptionParser constructor, as in:

option_list=[make_option("-f","--filename",action="store",type="string",dest="filename"),make_option("-q","--quiet",action="store_false",dest="verbose"),]parser=OptionParser(option_list=option_list)

(make_option() is a factory function for creating Option instances;currently it is an alias for the Option constructor. A future version ofoptparse may split Option into several classes, andmake_option()will pick the right class to instantiate. Do not instantiate Option directly.)

Defining options¶

Each Option instance represents a set of synonymous command-line option strings,e.g.-f and--file. You can specify any number of short orlong option strings, but you must specify at least one overall option string.

The canonical way to create anOption instance is with theadd_option() method ofOptionParser.

OptionParser.add_option(option)¶

OptionParser.add_option(*opt_str,attr=value,...)

To define an option with only a short option string:

parser.add_option("-f",attr=value,...)

And to define an option with only a long option string:

parser.add_option("--foo",attr=value,...)

The keyword arguments define attributes of the new Option object. The mostimportant option attribute isaction, and it largelydetermines which other attributes are relevant or required. If you passirrelevant option attributes, or fail to pass required ones,optparseraises anOptionError exception explaining your mistake.

An option’saction determines whatoptparse does when it encountersthis option on the command-line. The standard option actions hard-coded intooptparse are:

"store"

store this option’s argument (default)

"store_const"

store a constant value, pre-set viaOption.const

"store_true"

storeTrue

"store_false"

storeFalse

"append"

append this option’s argument to a list

"append_const"

append a constant value to a list, pre-set viaOption.const

"count"

increment a counter by one

"callback"

call a specified function

"help"

print a usage message including all options and the documentation for them

(If you don’t supply an action, the default is"store". For this action,you may also supplytype anddest optionattributes; seeStandard option actions.)

As you can see, most actions involve storing or updating a value somewhere.optparse always creates a special object for this, conventionally calledoptions, which is an instance ofoptparse.Values.

classoptparse.Values¶

An object holding parsed argument names and values as attributes.Normally created by calling when callingOptionParser.parse_args(),and can be overridden by a custom subclass passed to thevalues argument ofOptionParser.parse_args() (as described inParsing arguments).

Optionarguments (and various other values) are stored as attributes of this object,according to thedest (destination) option attribute.

For example, when you call

parser.parse_args()

one of the first thingsoptparse does is create theoptions object:

options=Values()

If one of the options in this parser is defined with

parser.add_option("-f","--file",action="store",type="string",dest="filename")

and the command-line being parsed includes any of the following:

-ffoo-ffoo--file=foo--filefoo

thenoptparse, on seeing this option, will do the equivalent of

options.filename="foo"

Thetype anddest option attributes are almostas important asaction, butaction is the onlyone that makes sense forall options.

Option attributes¶

classoptparse.Option¶

A single command line argument,with various attributes passed by keyword to the constructor.Normally created withOptionParser.add_option() rather than directly,and can be overridden by a custom class via theoption_class argumenttoOptionParser.

The following option attributes may be passed as keyword arguments toOptionParser.add_option(). If you pass an option attribute that is notrelevant to a particular option, or fail to pass a required option attribute,optparse raisesOptionError.

Option.action¶

(default:"store")

Determinesoptparse’s behaviour when this option is seen on thecommand line; the available options are documentedhere.

Option.type¶

(default:"string")

The argument type expected by this option (e.g.,"string" or"int");the available option types are documentedhere.

Option.dest¶

(default: derived from option strings)

If the option’s action implies writing or modifying a value somewhere, thistellsoptparse where to write it:dest names anattribute of theoptions object thatoptparse builds as it parsesthe command line.

Option.default¶

The value to use for this option’s destination if the option is not seen onthe command line. See alsoOptionParser.set_defaults().

Option.nargs¶

(default: 1)

How many arguments of typetype should be consumed when thisoption is seen. If > 1,optparse will store a tuple of values todest.

Option.const¶

For actions that store a constant value, the constant value to store.

Option.choices¶

For options of type"choice", the list of strings the user may choosefrom.

Option.callback¶

For options with action"callback", the callable to call when this optionis seen. See sectionOption Callbacks for detail on thearguments passed to the callable.

Option.callback_args¶

Option.callback_kwargs¶

Additional positional and keyword arguments to pass tocallback after thefour standard callback arguments.

Option.help¶

Help text to print for this option when listing all available options afterthe user supplies ahelp option (such as--help). Ifno help text is supplied, the option will be listed without help text. Tohide this option, use the special valueoptparse.SUPPRESS_HELP.

Option.metavar¶

(default: derived from option strings)

Stand-in for the option argument(s) to use when printing help text. SeesectionTutorial for an example.

Standard option actions¶

The various option actions all have slightly different requirements and effects.Most actions have several relevant option attributes which you may specify toguideoptparse’s behaviour; a few have required attributes, which youmust specify for any option using that action.

• "store" [relevant:type,dest,nargs,choices]

  The option must be followed by an argument, which is converted to a valueaccording totype and stored indest. Ifnargs > 1, multiple arguments will be consumed from thecommand line; all will be converted according totype andstored todest as a tuple. See theStandard option types section.

  Ifchoices is supplied (a list or tuple of strings), the typedefaults to"choice".

  Iftype is not supplied, it defaults to"string".

  Ifdest is not supplied,optparse derives a destinationfrom the first long option string (e.g.,--foo-bar impliesfoo_bar). If there are no long option strings,optparse derives adestination from the first short option string (e.g.,-f impliesf).

  Example:

  parser.add_option("-f")parser.add_option("-p",type="float",nargs=3,dest="point")

  As it parses the command line

  -ffoo.txt-p1-3.54-fbar.txt

  optparse will set

  options.f="foo.txt"options.point=(1.0,-3.5,4.0)options.f="bar.txt"

• "store_const" [required:const; relevant:dest]

  The valueconst is stored indest.

  Example:

  parser.add_option("-q","--quiet",action="store_const",const=0,dest="verbose")parser.add_option("-v","--verbose",action="store_const",const=1,dest="verbose")parser.add_option("--noisy",action="store_const",const=2,dest="verbose")

  If--noisy is seen,optparse will set

  options.verbose=2

• "store_true" [relevant:dest]

  A special case of"store_const" that storesTrue todest.

• "store_false" [relevant:dest]

  Like"store_true", but storesFalse.

  Example:

  parser.add_option("--clobber",action="store_true",dest="clobber")parser.add_option("--no-clobber",action="store_false",dest="clobber")

• "append" [relevant:type,dest,nargs,choices]

  The option must be followed by an argument, which is appended to the list indest. If no default value fordest issupplied, an empty list is automatically created whenoptparse firstencounters this option on the command-line. Ifnargs > 1,multiple arguments are consumed, and a tuple of lengthnargsis appended todest.

  The defaults fortype anddest are the same asfor the"store" action.

  Example:

  parser.add_option("-t","--tracks",action="append",type="int")

  If-t3 is seen on the command-line,optparse does the equivalentof:

  options.tracks=[]options.tracks.append(int("3"))

  If, a little later on,--tracks=4 is seen, it does:

  options.tracks.append(int("4"))

  Theappend action calls theappend method on the current value of theoption. This means that any default value specified must have anappendmethod. It also means that if the default value is non-empty, the defaultelements will be present in the parsed value for the option, with any valuesfrom the command line appended after those default values:

  >>>parser.add_option("--files",action="append",default=['~/.mypkg/defaults'])>>>opts,args=parser.parse_args(['--files','overrides.mypkg'])>>>opts.files['~/.mypkg/defaults', 'overrides.mypkg']

• "append_const" [required:const; relevant:dest]

  Like"store_const", but the valueconst is appended todest; as with"append",dest defaults toNone, and an empty list is automatically created the first time the optionis encountered.

• "count" [relevant:dest]

  Increment the integer stored atdest. If no default value issupplied,dest is set to zero before being incremented thefirst time.

  Example:

  parser.add_option("-v",action="count",dest="verbosity")

  The first time-v is seen on the command line,optparse does theequivalent of:

  options.verbosity=0options.verbosity+=1

  Every subsequent occurrence of-v results in

  options.verbosity+=1

• "callback" [required:callback; relevant:type,nargs,callback_args,callback_kwargs]

  Call the function specified bycallback, which is called as

  func(option,opt_str,value,parser,*args,**kwargs)

  See sectionOption Callbacks for more detail.

• "help"

  Prints a complete help message for all the options in the current optionparser. The help message is constructed from theusage string passed toOptionParser’s constructor and thehelp string passed to everyoption.

  If nohelp string is supplied for an option, it will still belisted in the help message. To omit an option entirely, use the special valueoptparse.SUPPRESS_HELP.

  optparse automatically adds ahelp option to allOptionParsers, so you do not normally need to create one.

  Example:

  fromoptparseimportOptionParser,SUPPRESS_HELP# usually, a help option is added automatically, but that can# be suppressed using the add_help_option argumentparser=OptionParser(add_help_option=False)parser.add_option("-h","--help",action="help")parser.add_option("-v",action="store_true",dest="verbose",help="Be moderately verbose")parser.add_option("--file",dest="filename",help="Input file to read data from")parser.add_option("--secret",help=SUPPRESS_HELP)

  Ifoptparse sees either-h or--help on the command line,it will print something like the following help message to stdout (assumingsys.argv[0] is"foo.py"):

  Usage: foo.py [options]Options:  -h, --help        Show this help message and exit  -v                Be moderately verbose  --file=FILENAME   Input file to read data from

  After printing the help message,optparse terminates your process withsys.exit(0).

• "version"

  Prints the version number supplied to the OptionParser to stdout and exits.The version number is actually formatted and printed by theprint_version() method of OptionParser. Generally only relevant if theversion argument is supplied to the OptionParser constructor. As withhelp options, you will rarely createversion options,sinceoptparse automatically adds them when needed.

Standard option types¶

optparse has five built-in option types:"string","int","choice","float" and"complex". If you need to add newoption types, see sectionExtending optparse.

Arguments to string options are not checked or converted in any way: the text onthe command line is stored in the destination (or passed to the callback) as-is.

Integer arguments (type"int") are parsed as follows:

• if the number starts with0x, it is parsed as a hexadecimal number

• if the number starts with0, it is parsed as an octal number

• if the number starts with0b, it is parsed as a binary number

• otherwise, the number is parsed as a decimal number

The conversion is done by callingint() with the appropriate base (2, 8,10, or 16). If this fails, so willoptparse, although with a more usefulerror message.

"float" and"complex" option arguments are converted directly withfloat() andcomplex(), with similar error-handling.

"choice" options are a subtype of"string" options. Thechoices option attribute (a sequence of strings) defines theset of allowed option arguments.optparse.check_choice() comparesuser-supplied option arguments against this master list and raisesOptionValueError if an invalid string is given.

Parsing arguments¶

The whole point of creating and populating an OptionParser is to call itsparse_args() method.

OptionParser.parse_args(args=None,values=None)¶

Parse the command-line options found inargs.

The input parameters are

args

the list of arguments to process (default:sys.argv[1:])

values

aValues object to store option arguments in (default: anew instance ofValues) – if you give an existing object, theoption defaults will not be initialized on it

and the return value is a pair(options,args) where

options

the same object that was passed in asvalues, or theoptparse.Valuesinstance created byoptparse

args

the leftover positional arguments after all options have been processed

The most common usage is to supply neither keyword argument. If you supplyvalues, it will be modified with repeatedsetattr() calls (roughly onefor every option argument stored to an option destination) and returned byparse_args().

Ifparse_args() encounters any errors in the argument list, it calls theOptionParser’serror() method with an appropriate end-user error message.This ultimately terminates your process with an exit status of 2 (thetraditional Unix exit status for command-line errors).

Querying and manipulating your option parser¶

The default behavior of the option parser can be customized slightly, and youcan also poke around your option parser and see what’s there. OptionParserprovides several methods to help you out:

OptionParser.disable_interspersed_args()¶

Set parsing to stop on the first non-option. For example, if-a and-b are both simple options that take no arguments,optparsenormally accepts this syntax:

prog-aarg1-barg2

and treats it as equivalent to

prog-a-barg1arg2

To disable this feature, calldisable_interspersed_args(). Thisrestores traditional Unix syntax, where option parsing stops with the firstnon-option argument.

Use this if you have a command processor which runs another command which hasoptions of its own and you want to make sure these options don’t getconfused. For example, each command might have a different set of options.

OptionParser.enable_interspersed_args()¶

Set parsing to not stop on the first non-option, allowing interspersingswitches with command arguments. This is the default behavior.

OptionParser.get_option(opt_str)¶

Returns the Option instance with the option stringopt_str, orNone ifno options have that option string.

OptionParser.has_option(opt_str)¶

ReturnTrue if the OptionParser has an option with option stringopt_str(e.g.,-q or--verbose).

OptionParser.remove_option(opt_str)¶

If theOptionParser has an option corresponding toopt_str, thatoption is removed. If that option provided any other option strings, all ofthose option strings become invalid. Ifopt_str does not occur in anyoption belonging to thisOptionParser, raisesValueError.

Conflicts between options¶

If you’re not careful, it’s easy to define options with conflicting optionstrings:

parser.add_option("-n","--dry-run",...)...parser.add_option("-n","--noisy",...)

(This is particularly true if you’ve defined your own OptionParser subclass withsome standard options.)

Every time you add an option,optparse checks for conflicts with existingoptions. If it finds any, it invokes the current conflict-handling mechanism.You can set the conflict-handling mechanism either in the constructor:

parser=OptionParser(...,conflict_handler=handler)

or with a separate call:

parser.set_conflict_handler(handler)

The available conflict handlers are:

"error" (default)

assume option conflicts are a programming error and raiseOptionConflictError

"resolve"

resolve option conflicts intelligently (see below)

As an example, let’s define anOptionParser that resolves conflictsintelligently and add conflicting options to it:

parser=OptionParser(conflict_handler="resolve")parser.add_option("-n","--dry-run",...,help="do no harm")parser.add_option("-n","--noisy",...,help="be noisy")

At this point,optparse detects that a previously added option is alreadyusing the-n option string. Sinceconflict_handler is"resolve",it resolves the situation by removing-n from the earlier option’s list ofoption strings. Now--dry-run is the only way for the user to activatethat option. If the user asks for help, the help message will reflect that:

Options:--dry-rundonoharm...-n,--noisybenoisy

It’s possible to whittle away the option strings for a previously added optionuntil there are none left, and the user has no way of invoking that option fromthe command-line. In that case,optparse removes that option completely,so it doesn’t show up in help text or anywhere else. Carrying on with ourexisting OptionParser:

parser.add_option("--dry-run",...,help="new dry-run option")

At this point, the original-n/--dry-run option is no longeraccessible, sooptparse removes it, leaving this help text:

Options:...-n,--noisybenoisy--dry-runnewdry-runoption

Cleanup¶

OptionParser instances have several cyclic references. This should not be aproblem for Python’s garbage collector, but you may wish to break the cyclicreferences explicitly by callingdestroy() on yourOptionParser once you are done with it. This is particularly useful inlong-running applications where large object graphs are reachable from yourOptionParser.

Other methods¶

OptionParser supports several other public methods:

OptionParser.set_usage(usage)¶

Set the usage string according to the rules described above for theusageconstructor keyword argument. PassingNone sets the default usagestring; useoptparse.SUPPRESS_USAGE to suppress a usage message.

OptionParser.print_usage(file=None)¶

Print the usage message for the current program (self.usage) tofile(default stdout). Any occurrence of the string%prog inself.usageis replaced with the name of the current program. Does nothing ifself.usage is empty or not defined.

OptionParser.get_usage()¶

Same asprint_usage() but returns the usage string instead ofprinting it.

OptionParser.set_defaults(dest=value,...)¶

Set default values for several option destinations at once. Usingset_defaults() is the preferred way to set default values for options,since multiple options can share the same destination. For example, ifseveral “mode” options all set the same destination, any one of them can setthe default, and the last one wins:

parser.add_option("--advanced",action="store_const",dest="mode",const="advanced",default="novice")# overridden belowparser.add_option("--novice",action="store_const",dest="mode",const="novice",default="advanced")# overrides above setting

To avoid this confusion, useset_defaults():

parser.set_defaults(mode="advanced")parser.add_option("--advanced",action="store_const",dest="mode",const="advanced")parser.add_option("--novice",action="store_const",dest="mode",const="novice")

Defining a callback option¶

As always, the easiest way to define a callback option is by using theOptionParser.add_option() method. Apart fromaction, theonly option attribute you must specify iscallback, the function to call:

parser.add_option("-c",action="callback",callback=my_callback)

callback is a function (or other callable object), so you must have alreadydefinedmy_callback() when you create this callback option. In this simplecase,optparse doesn’t even know if-c takes any arguments,which usually means that the option takes no arguments—the mere presence of-c on the command-line is all it needs to know. In somecircumstances, though, you might want your callback to consume an arbitrarynumber of command-line arguments. This is where writing callbacks gets tricky;it’s covered later in this section.

optparse always passes four particular arguments to your callback, and itwill only pass additional arguments if you specify them viacallback_args andcallback_kwargs. Thus, theminimal callback function signature is:

defmy_callback(option,opt,value,parser):

The four arguments to a callback are described below.

There are several other option attributes that you can supply when you define acallback option:

type

has its usual meaning: as with the"store" or"append" actions, itinstructsoptparse to consume one argument and convert it totype. Rather than storing the converted value(s) anywhere,though,optparse passes it to your callback function.

nargs

also has its usual meaning: if it is supplied and > 1,optparse willconsumenargs arguments, each of which must be convertible totype. It then passes a tuple of converted values to yourcallback.

callback_args

a tuple of extra positional arguments to pass to the callback

callback_kwargs

a dictionary of extra keyword arguments to pass to the callback

How callbacks are called¶

All callbacks are called as follows:

func(option,opt_str,value,parser,*args,**kwargs)

where

option

is the Option instance that’s calling the callback

opt_str

is the option string seen on the command-line that’s triggering the callback.(If an abbreviated long option was used,opt_str will be the full,canonical option string—e.g. if the user puts--foo on thecommand-line as an abbreviation for--foobar, thenopt_str will be"--foobar".)

value

is the argument to this option seen on the command-line.optparse willonly expect an argument iftype is set; the type ofvalue will bethe type implied by the option’s type. Iftype for this option isNone (no argument expected), thenvalue will beNone. Ifnargs> 1,value will be a tuple of values of the appropriate type.

parser

is the OptionParser instance driving the whole thing, mainly useful becauseyou can access some other interesting data through its instance attributes:

parser.largs

the current list of leftover arguments, ie. arguments that have beenconsumed but are neither options nor option arguments. Feel free to modifyparser.largs, e.g. by adding more arguments to it. (This list willbecomeargs, the second return value ofparse_args().)

parser.rargs

the current list of remaining arguments, ie. withopt_str andvalue (if applicable) removed, and only the arguments following themstill there. Feel free to modifyparser.rargs, e.g. by consuming morearguments.

parser.values

the object where option values are by default stored (an instance ofoptparse.OptionValues). This lets callbacks use the same mechanism as therest ofoptparse for storing option values; you don’t need to messaround with globals or closures. You can also access or modify thevalue(s) of any options already encountered on the command-line.

args

is a tuple of arbitrary positional arguments supplied via thecallback_args option attribute.

kwargs

is a dictionary of arbitrary keyword arguments supplied viacallback_kwargs.

Raising errors in a callback¶

The callback function should raiseOptionValueError if there are anyproblems with the option or its argument(s).optparse catches this andterminates the program, printing the error message you supply to stderr. Yourmessage should be clear, concise, accurate, and mention the option at fault.Otherwise, the user will have a hard time figuring out what they did wrong.

Callback example 1: trivial callback¶

Here’s an example of a callback option that takes no arguments, and simplyrecords that the option was seen:

defrecord_foo_seen(option,opt_str,value,parser):parser.values.saw_foo=Trueparser.add_option("--foo",action="callback",callback=record_foo_seen)

Of course, you could do that with the"store_true" action.

Callback example 2: check option order¶

Here’s a slightly more interesting example: record the fact that-a isseen, but blow up if it comes after-b in the command-line.

defcheck_order(option,opt_str,value,parser):ifparser.values.b:raiseOptionValueError("can't use -a after -b")parser.values.a=1...parser.add_option("-a",action="callback",callback=check_order)parser.add_option("-b",action="store_true",dest="b")

Callback example 3: check option order (generalized)¶

If you want to reuse this callback for several similar options (set a flag, butblow up if-b has already been seen), it needs a bit of work: the errormessage and the flag that it sets must be generalized.

defcheck_order(option,opt_str,value,parser):ifparser.values.b:raiseOptionValueError("can't use%s after -b"%opt_str)setattr(parser.values,option.dest,1)...parser.add_option("-a",action="callback",callback=check_order,dest='a')parser.add_option("-b",action="store_true",dest="b")parser.add_option("-c",action="callback",callback=check_order,dest='c')

Callback example 4: check arbitrary condition¶

Of course, you could put any condition in there—you’re not limited to checkingthe values of already-defined options. For example, if you have options thatshould not be called when the moon is full, all you have to do is this:

defcheck_moon(option,opt_str,value,parser):ifis_moon_full():raiseOptionValueError("%s option invalid when moon is full"%opt_str)setattr(parser.values,option.dest,1)...parser.add_option("--foo",action="callback",callback=check_moon,dest="foo")

(The definition ofis_moon_full() is left as an exercise for the reader.)

Callback example 5: fixed arguments¶

Things get slightly more interesting when you define callback options that takea fixed number of arguments. Specifying that a callback option takes argumentsis similar to defining a"store" or"append" option: if you definetype, then the option takes one argument that must beconvertible to that type; if you further definenargs, then theoption takesnargs arguments.

Here’s an example that just emulates the standard"store" action:

defstore_value(option,opt_str,value,parser):setattr(parser.values,option.dest,value)...parser.add_option("--foo",action="callback",callback=store_value,type="int",nargs=3,dest="foo")

Note thatoptparse takes care of consuming 3 arguments and convertingthem to integers for you; all you have to do is store them. (Or whatever;obviously you don’t need a callback for this example.)

Callback example 6: variable arguments¶

Things get hairy when you want an option to take a variable number of arguments.For this case, you must write a callback, asoptparse doesn’t provide anybuilt-in capabilities for it. And you have to deal with certain intricacies ofconventional Unix command-line parsing thatoptparse normally handles foryou. In particular, callbacks should implement the conventional rules for bare-- and- arguments:

• either-- or- can be option arguments

• bare-- (if not the argument to some option): halt command-lineprocessing and discard the--

• bare- (if not the argument to some option): halt command-lineprocessing but keep the- (append it toparser.largs)

If you want an option that takes a variable number of arguments, there areseveral subtle, tricky issues to worry about. The exact implementation youchoose will be based on which trade-offs you’re willing to make for yourapplication (which is whyoptparse doesn’t support this sort of thingdirectly).

Nevertheless, here’s a stab at a callback for an option with variablearguments:

defvararg_callback(option,opt_str,value,parser):assertvalueisNonevalue=[]deffloatable(str):try:float(str)returnTrueexceptValueError:returnFalseforarginparser.rargs:# stop on --foo like optionsifarg[:2]=="--"andlen(arg)>2:break# stop on -a, but not on -3 or -3.0ifarg[:1]=="-"andlen(arg)>1andnotfloatable(arg):breakvalue.append(arg)delparser.rargs[:len(value)]setattr(parser.values,option.dest,value)...parser.add_option("-c","--callback",dest="vararg_attr",action="callback",callback=vararg_callback)

Adding new types¶

To add new types, you need to define your own subclass ofoptparse’sOption class. This class has a couple of attributes that defineoptparse’s types:TYPES andTYPE_CHECKER.

Option.TYPES¶

A tuple of type names; in your subclass, simply define a new tupleTYPES that builds on the standard one.

Option.TYPE_CHECKER¶

A dictionary mapping type names to type-checking functions. A type-checkingfunction has the following signature:

defcheck_mytype(option,opt,value)

whereoption is anOption instance,opt is an option string(e.g.,-f), andvalue is the string from the command line that mustbe checked and converted to your desired type.check_mytype() shouldreturn an object of the hypothetical typemytype. The value returned bya type-checking function will wind up in the OptionValues instance returnedbyOptionParser.parse_args(), or be passed to a callback as thevalue parameter.

Your type-checking function should raiseOptionValueError if itencounters any problems.OptionValueError takes a single stringargument, which is passed as-is toOptionParser’serror()method, which in turn prepends the program name and the string"error:"and prints everything to stderr before terminating the process.

Here’s a silly example that demonstrates adding a"complex" option type toparse Python-style complex numbers on the command line. (This is even sillierthan it used to be, becauseoptparse 1.3 added built-in support forcomplex numbers, but never mind.)

First, the necessary imports:

fromcopyimportcopyfromoptparseimportOption,OptionValueError

You need to define your type-checker first, since it’s referred to later (in theTYPE_CHECKER class attribute of your Option subclass):

defcheck_complex(option,opt,value):try:returncomplex(value)exceptValueError:raiseOptionValueError("option%s: invalid complex value:%r"%(opt,value))

Finally, the Option subclass:

classMyOption(Option):TYPES=Option.TYPES+("complex",)TYPE_CHECKER=copy(Option.TYPE_CHECKER)TYPE_CHECKER["complex"]=check_complex

(If we didn’t make acopy() ofOption.TYPE_CHECKER, we would endup modifying theTYPE_CHECKER attribute ofoptparse’sOption class. This being Python, nothing stops you from doing that except goodmanners and common sense.)

That’s it! Now you can write a script that uses the new option type just likeany otheroptparse-based script, except you have to instruct yourOptionParser to use MyOption instead of Option:

parser=OptionParser(option_class=MyOption)parser.add_option("-c",type="complex")

Alternately, you can build your own option list and pass it to OptionParser; ifyou don’t useadd_option() in the above way, you don’t need to tellOptionParser which option class to use:

option_list=[MyOption("-c",action="store",type="complex",dest="c")]parser=OptionParser(option_list=option_list)

Adding new actions¶

Adding new actions is a bit trickier, because you have to understand thatoptparse has a couple of classifications for actions:

“store” actions

actions that result inoptparse storing a value to an attribute of thecurrent OptionValues instance; these options require adestattribute to be supplied to the Option constructor.

“typed” actions

actions that take a value from the command line and expect it to be of acertain type; or rather, a string that can be converted to a certain type.These options require atype attribute to the Optionconstructor.

These are overlapping sets: some default “store” actions are"store","store_const","append", and"count", while the default “typed”actions are"store","append", and"callback".

When you add an action, you need to categorize it by listing it in at least oneof the following class attributes of Option (all are lists of strings):

Option.ACTIONS¶

All actions must be listed in ACTIONS.

Option.STORE_ACTIONS¶

“store” actions are additionally listed here.

Option.TYPED_ACTIONS¶

“typed” actions are additionally listed here.

Option.ALWAYS_TYPED_ACTIONS¶

Actions that always take a type (i.e. whose options always take a value) areadditionally listed here. The only effect of this is thatoptparseassigns the default type,"string", to options with no explicit typewhose action is listed inALWAYS_TYPED_ACTIONS.

In order to actually implement your new action, you must override Option’stake_action() method and add a case that recognizes your action.

For example, let’s add an"extend" action. This is similar to the standard"append" action, but instead of taking a single value from the command-lineand appending it to an existing list,"extend" will take multiple values ina single comma-delimited string, and extend an existing list with them. Thatis, if--names is an"extend" option of type"string", the commandline

--names=foo,bar--namesblah--namesding,dong

would result in a list

["foo","bar","blah","ding","dong"]

Again we define a subclass of Option:

classMyOption(Option):ACTIONS=Option.ACTIONS+("extend",)STORE_ACTIONS=Option.STORE_ACTIONS+("extend",)TYPED_ACTIONS=Option.TYPED_ACTIONS+("extend",)ALWAYS_TYPED_ACTIONS=Option.ALWAYS_TYPED_ACTIONS+("extend",)deftake_action(self,action,dest,opt,value,values,parser):ifaction=="extend":lvalue=value.split(",")values.ensure_value(dest,[]).extend(lvalue)else:Option.take_action(self,action,dest,opt,value,values,parser)

Features of note:

• "extend" both expects a value on the command-line and stores that valuesomewhere, so it goes in bothSTORE_ACTIONS andTYPED_ACTIONS.

• to ensure thatoptparse assigns the default type of"string" to"extend" actions, we put the"extend" action inALWAYS_TYPED_ACTIONS as well.

• MyOption.take_action() implements just this one new action, and passescontrol back toOption.take_action() for the standardoptparseactions.

• values is an instance of the optparse_parser.Values class, which providesthe very usefulensure_value() method.ensure_value() isessentiallygetattr() with a safety valve; it is called as

  values.ensure_value(attr,value)

  If theattr attribute ofvalues doesn’t exist or isNone, thenensure_value() first sets it tovalue, and then returnsvalue. This isvery handy for actions like"extend","append", and"count", allof which accumulate data in a variable and expect that variable to be of acertain type (a list for the first two, an integer for the latter). Usingensure_value() means that scripts using your action don’t have to worryabout setting a default value for the option destinations in question; theycan just leave the default asNone andensure_value() will take care ofgetting it right when it’s needed.