Navigation

Deprecated since version 3.2: The optparse module is deprecated and will not be developed further;
development will continue with the argparse module.

optparse is a more convenient, flexible, and powerful library for parsing
command-line options than the old getopt module. optparse uses a
more declarative style of command-line parsing: you create an instance of
OptionParser, populate it with options, and parse the command
line. optparse allows users to specify options in the conventional
GNU/POSIX syntax, and additionally generates usage and help messages for you.

With these few lines of code, users of your script can now do the “usual thing”
on the command-line, for example:

<yourscript>--file=outfile-q

As it parses the command line, optparse sets attributes of the
options object returned by parse_args() based on user-supplied
command-line values. When parse_args() returns from parsing this command
line, options.filename will be "outfile" and options.verbose will be
False. optparse supports both long and short options, allows short
options to be merged together, and allows options to be associated with their
arguments in a variety of ways. Thus, the following command lines are all
equivalent to the above example:

optparse was explicitly designed to encourage the creation of programs
with straightforward, conventional command-line interfaces. To that end, it
supports only the most common command-line syntax and semantics conventionally
used under Unix. If you are unfamiliar with these conventions, read this
section to acquaint yourself with them.

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

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

option

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

Some other option syntaxes that the world has seen include:

a hyphen followed by a few letters, e.g. -pf (this is not the same
as multiple options merged into a single argument)

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

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 by optparse, and they never
will be. This is deliberate: the first three are non-standard on any
environment, and the last only makes sense if you’re exclusively targeting
VMS, MS-DOS, and/or Windows.

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. With
optparse, option arguments may either be in a separate argument from
their 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 of
people want an “optional option arguments” feature, meaning that some options
will take an argument if they see it, and won’t if they don’t. This is
somewhat controversial, because it makes parsing ambiguous: if -a takes
an optional argument and -b is another option entirely, how do we
interpret -ab? Because of this ambiguity, optparse does not
support 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 the
argument 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’t
prevent you from implementing required options, but doesn’t give you much
help at it either.

For example, consider this hypothetical command-line:

prog-v--reportreport.txtfoobar

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

Options are used to provide extra information to tune or customize the execution
of a program. In case it wasn’t clear, options are usually optional. A
program should be able to run just fine with no options whatsoever. (Pick a
random program from the Unix or GNU toolsets. Can it run without any options at
all and still make sense? The main exceptions are find, tar, and
dd—all of which are mutant oddballs that have been rightly criticized
for 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’s not optional! If there is a piece of information
that your program absolutely requires in order to run successfully, that’s what
positional arguments are for.

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

cpSOURCEDESTcpSOURCE...DEST-DIR

You can get pretty far with just that. Most cp implementations provide a
bunch of options to tweak exactly how the files are copied: you can preserve
mode and modification time, avoid following symlinks, ask before clobbering
existing files, etc. But none of this distracts from the core mission of
cp, which is to copy either one file to another, or several files to another
directory.

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

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

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

While optparse is quite flexible and powerful, it’s also straightforward
to use in most cases. This section covers the code patterns that are common to
any optparse-based program.

First, you need to import the OptionParser class; then, early in the main
program, create an OptionParser instance:

fromoptparseimportOptionParser...parser=OptionParser()

Then you can start defining options. The basic syntax is:

parser.add_option(opt_str,...,attr=value,...)

Each option has one or more option strings, such as -f or --file,
and several option attributes that tell optparse what to expect and what
to do when it encounters that option on the command line.

Typically, each option will have one short option string and one long option
string, e.g.:

parser.add_option("-f","--file",...)

You’re free to define as many short option strings and as many long option
strings as you like (including zero), as long as there is at least one option
string overall.

The option strings passed to OptionParser.add_option() are effectively
labels for the
option defined by that call. For brevity, we will frequently refer to
encountering an option on the command line; in reality, optparse
encounters option strings and looks up options from them.

Once all of your options are defined, instruct optparse to parse your
program’s command line:

(options,args)=parser.parse_args()

(If you like, you can pass a custom argument list to parse_args(), but
that’s rarely necessary: by default it uses sys.argv[1:].)

parse_args() returns two values:

options, an object containing values for all of your options—e.g. if
--file takes a single string argument, then options.file will be the
filename supplied by the user, or None if the user did not supply that
option

args, the list of positional arguments leftover after parsing options

This tutorial section only covers the four most important option attributes:
action, type, dest
(destination), and help. Of these, action is the
most fundamental.

Actions tell optparse what to do when it encounters an option on the
command line. There is a fixed set of actions hard-coded into optparse;
adding new actions is an advanced topic covered in section
Extending optparse. Most actions tell optparse to store
a value in some variable—for example, take a string from the command line and
store it in an attribute of options.

The most common option action is store, which tells optparse to take
the next argument (or the remainder of the current argument), ensure that it is
of the correct type, and store it to your chosen destination.

When optparse sees the option string -f, it consumes the next
argument, foo.txt, and stores it in options.filename. So, after this
call to parse_args(), options.filename is "foo.txt".

Some other option types supported by optparse are int and float.
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 is store.

Let’s parse another fake command-line. This time, we’ll jam the option argument
right 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 print 42.

If you don’t specify a type, optparse assumes string. Combined with
the fact that the default action is store, that means our first example can
be a lot shorter:

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

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

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

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

First, consider the verbose/quiet example. If we want optparse to set
verbose to True unless -q is seen, then we can do this:

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

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

There’s a lot going on here to help optparse generate the best possible
help 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 the
current program, i.e. os.path.basename(sys.argv[0]). The expanded string
is then printed before the detailed option help.

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

every option defines a help string, and doesn’t worry about
line-wrapping—optparse takes care of wrapping lines and making
the help output look good.

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

-mMODE,--mode=MODE

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

-fFILE,--filename=FILE

This is important for more than just saving space, though: the manually
written help text uses the meta-variable FILE to clue the user in that
there’s a connection between the semi-formal syntax -fFILE and the informal
semantic description “write output to FILE”. This is a simple but effective
way 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 help
string—optparse will replace it with str() of the option’s
default value. If an option has no default value (or the default value is
None), %default expands to none.

OptionGroup inherits from OptionContainer (like
OptionParser) and so the add_option() method can be used to add
an option to the group.

Once all the options are declared, using the OptionParser method
add_option_group() the group is added to the previously defined parser.

Continuing with the parser defined in the previous section, adding an
OptionGroup to a parser is easy:

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)

A bit more complete example might involve using more than one group: still
extending the previous example:

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)

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

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

%prog is expanded just like it is in usage. Apart from that,
version can contain anything you like. When you supply it, optparse
automatically adds a --version option to your parser. If it encounters
this option on the command line, it expands your version string (by
replacing %prog), prints it to stdout, and exits.

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

$ /usr/bin/foo --version
foo 1.0

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

Print the version message for the current program (self.version) to
file (default stdout). As with print_usage(), any occurrence
of %prog in self.version is replaced with the name of the current
program. Does nothing if self.version is empty or undefined.

There are two broad classes of errors that optparse has to worry about:
programmer errors and user errors. Programmer errors are usually erroneous
calls to OptionParser.add_option(), e.g. invalid option strings, unknown
option attributes, missing option attributes, etc. These are dealt with in the
usual way: raise an exception (either optparse.OptionError or
TypeError) and let the program crash.

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

The OptionParser constructor has no required arguments, but a number of
optional keyword arguments. You should always pass them as keyword
arguments, 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 a
help option. When optparse prints the usage string, it expands
%prog to os.path.basename(sys.argv[0]) (or to prog if you
passed that keyword argument). To suppress a usage message, pass the
special value optparse.SUPPRESS_USAGE.

option_list (default: [])

A list of Option objects to populate the parser with. The options in
option_list are added after any options in standard_option_list (a
class attribute that may be set by OptionParser subclasses), but before
any version or help options. Deprecated; use add_option() after
creating the parser instead.

A version string to print when the user supplies a version option. If you
supply a true value for version, optparse automatically adds a
version option with the single option string --version. The
substring %prog is expanded the same as for usage.

conflict_handler (default: "error")

Specifies what to do when options with conflicting option strings are
added to the parser; see section
Conflicts 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 width
and prints it when the user requests help (after usage, but before the
list of options).

formatter (default: a new IndentedHelpFormatter)

An instance of optparse.HelpFormatter that will be used for printing help
text. 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 -h
and --help) to the parser.

prog

The string to use when expanding %prog in usage and version
instead of os.path.basename(sys.argv[0]).

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

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

The canonical way to create an Option instance is with the
add_option() method of OptionParser.

The keyword arguments define attributes of the new Option object. The most
important option attribute is action, and it largely
determines which other attributes are relevant or required. If you pass
irrelevant option attributes, or fail to pass required ones, optparse
raises an OptionError exception explaining your mistake.

An option’s action determines what optparse does when it encounters
this option on the command-line. The standard option actions hard-coded into
optparse are:

"store"

store this option’s argument (default)

"store_const"

store a constant value

"store_true"

store a true value

"store_false"

store a false value

"append"

append this option’s argument to a list

"append_const"

append a constant value to a list

"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 supply type and dest option
attributes; see Standard option actions.)

As you can see, most actions involve storing or updating a value somewhere.
optparse always creates a special object for this, conventionally called
options (it happens to be an instance of optparse.Values). Option
arguments (and various other values) are stored as attributes of this object,
according to the dest (destination) option attribute.

The following option attributes may be passed as keyword arguments to
OptionParser.add_option(). If you pass an option attribute that is not
relevant to a particular option, or fail to pass a required option attribute,
optparse raises OptionError.

If the option’s action implies writing or modifying a value somewhere, this
tells optparse where to write it: dest names an
attribute of the options object that optparse builds as it parses
the command line.

Help text to print for this option when listing all available options after
the user supplies a help option (such as --help). If
no help text is supplied, the option will be listed without help text. To
hide this option, use the special value optparse.SUPPRESS_HELP.

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

The option must be followed by an argument, which is converted to a value
according to type and stored in dest. If
nargs > 1, multiple arguments will be consumed from the
command line; all will be converted according to type and
stored to dest as a tuple. See the
Standard option types section.

If choices is supplied (a list or tuple of strings), the type
defaults to "choice".

If dest is not supplied, optparse derives a destination
from the first long option string (e.g., --foo-bar implies
foo_bar). If there are no long option strings, optparse derives a
destination from the first short option string (e.g., -f implies f).

The option must be followed by an argument, which is appended to the list in
dest. If no default value for dest is
supplied, an empty list is automatically created when optparse first
encounters this option on the command-line. If nargs > 1,
multiple arguments are consumed, and a tuple of length nargs
is appended to dest.

The defaults for type and dest are the same as
for the "store" action.

The append action calls the append method on the current value of the
option. This means that any default value specified must have an append
method. It also means that if the default value is non-empty, the default
elements will be present in the parsed value for the option, with any values
from the command line appended after those default values:

Prints a complete help message for all the options in the current option
parser. The help message is constructed from the usage string passed to
OptionParser’s constructor and the help string passed to every
option.

If no help string is supplied for an option, it will still be
listed in the help message. To omit an option entirely, use the special value
optparse.SUPPRESS_HELP.

optparse automatically adds a help option to all
OptionParsers, 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)

If optparse sees either -h or --help on the command line,
it will print something like the following help message to stdout (assuming
sys.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 with
sys.exit(0).

"version"

Prints the version number supplied to the OptionParser to stdout and exits.
The version number is actually formatted and printed by the
print_version() method of OptionParser. Generally only relevant if the
version argument is supplied to the OptionParser constructor. As with
help options, you will rarely create version options,
since optparse automatically adds them when needed.

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

Arguments to string options are not checked or converted in any way: the text on
the 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 with 0x, it is parsed as a hexadecimal number

if the number starts with 0, it is parsed as an octal number

if the number starts with 0b, it is parsed as a binary number

otherwise, the number is parsed as a decimal number

The conversion is done by calling int() with the appropriate base (2, 8,
10, or 16). If this fails, so will optparse, although with a more useful
error message.

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

"choice" options are a subtype of "string" options. The
choices option attribute (a sequence of strings) defines the
set of allowed option arguments. optparse.check_choice() compares
user-supplied option arguments against this master list and raises
OptionValueError if an invalid string is given.

The whole point of creating and populating an OptionParser is to call its
parse_args() method:

(options,args)=parser.parse_args(args=None,values=None)

where the input parameters are

args

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

values

an optparse.Values object to store option arguments in (default: a
new instance of Values) – if you give an existing object, the
option defaults will not be initialized on it

and the return values are

options

the same object that was passed in as values, or the optparse.Values
instance created by optparse

args

the leftover positional arguments after all options have been processed

The most common usage is to supply neither keyword argument. If you supply
values, it will be modified with repeated setattr() calls (roughly one
for every option argument stored to an option destination) and returned by
parse_args().

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

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

prog-aarg1-barg2

and treats it as equivalent to

prog-a-barg1arg2

To disable this feature, call disable_interspersed_args(). This
restores traditional Unix syntax, where option parsing stops with the first
non-option argument.

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

If the OptionParser has an option corresponding to opt_str, that
option is removed. If that option provided any other option strings, all of
those option strings become invalid. If opt_str does not occur in any
option belonging to this OptionParser, raises ValueError.

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

Every time you add an option, optparse checks for conflicts with existing
options. 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 raise
OptionConflictError

"resolve"

resolve option conflicts intelligently (see below)

As an example, let’s define an OptionParser that resolves conflicts
intelligently and add conflicting options to it:

At this point, optparse detects that a previously-added option is already
using the -n option string. Since conflict_handler is "resolve",
it resolves the situation by removing -n from the earlier option’s list of
option strings. Now --dry-run is the only way for the user to activate
that 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 option
until there are none left, and the user has no way of invoking that option from
the 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 our
existing OptionParser:

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

At this point, the original -n/--dry-run option is no longer
accessible, so optparse removes it, leaving this help text:

OptionParser instances have several cyclic references. This should not be a
problem for Python’s garbage collector, but you may wish to break the cyclic
references explicitly by calling destroy() on your
OptionParser once you are done with it. This is particularly useful in
long-running applications where large object graphs are reachable from your
OptionParser.

Set the usage string according to the rules described above for the usage
constructor keyword argument. Passing None sets the default usage
string; use optparse.SUPPRESS_USAGE to suppress a usage message.

Print the usage message for the current program (self.usage) to file
(default stdout). Any occurrence of the string %prog in self.usage
is replaced with the name of the current program. Does nothing if
self.usage is empty or not defined.

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

When optparse’s built-in actions and types aren’t quite enough for your
needs, you have two choices: extend optparse or define a callback option.
Extending optparse is more general, but overkill for a lot of simple
cases. Quite often a simple callback is all you need.

There are two steps to defining a callback option:

define the option itself using the "callback" action

write the callback; this is a function (or method) that takes at least four
arguments, as described below

As always, the easiest way to define a callback option is by using the
OptionParser.add_option() method. Apart from action, the
only option attribute you must specify is callback, 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 already
defined my_callback() when you create this callback option. In this simple
case, 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 some
circumstances, though, you might want your callback to consume an arbitrary
number 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 it
will only pass additional arguments if you specify them via
callback_args and callback_kwargs. Thus, the
minimal 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 a
callback option:

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

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 the
command-line as an abbreviation for --foobar, then opt_str will be
"--foobar".)

value

is the argument to this option seen on the command-line. optparse will
only expect an argument if type is set; the type of value will be
the type implied by the option’s type. If type for this option is
None (no argument expected), then value will be None. If nargs
> 1, value will be a tuple of values of the appropriate type.

parser

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

parser.largs

the current list of leftover arguments, ie. arguments that have been
consumed but are neither options nor option arguments. Feel free to modify
parser.largs, e.g. by adding more arguments to it. (This list will
become args, the second return value of parse_args().)

parser.rargs

the current list of remaining arguments, ie. with opt_str and
value (if applicable) removed, and only the arguments following them
still there. Feel free to modify parser.rargs, e.g. by consuming more
arguments.

parser.values

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

args

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

kwargs

is a dictionary of arbitrary keyword arguments supplied via
callback_kwargs.

The callback function should raise OptionValueError if there are any
problems with the option or its argument(s). optparse catches this and
terminates the program, printing the error message you supply to stderr. Your
message 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.

Here’s a slightly more interesting example: record the fact that -a is
seen, 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")

If you want to re-use this callback for several similar options (set a flag, but
blow up if -b has already been seen), it needs a bit of work: the error
message 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')

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

Things get slightly more interesting when you define callback options that take
a fixed number of arguments. Specifying that a callback option takes arguments
is similar to defining a "store" or "append" option: if you define
type, then the option takes one argument that must be
convertible to that type; if you further define nargs, then the
option takes nargs arguments.

Things get hairy when you want an option to take a variable number of arguments.
For this case, you must write a callback, as optparse doesn’t provide any
built-in capabilities for it. And you have to deal with certain intricacies of
conventional Unix command-line parsing that optparse normally handles for
you. 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-line
processing and discard the --

bare - (if not the argument to some option): halt command-line
processing but keep the - (append it to parser.largs)

If you want an option that takes a variable number of arguments, there are
several subtle, tricky issues to worry about. The exact implementation you
choose will be based on which trade-offs you’re willing to make for your
application (which is why optparse doesn’t support this sort of thing
directly).

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

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)

Since the two major controlling factors in how optparse interprets
command-line options are the action and type of each option, the most likely
direction of extension is to add new actions and new types.

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

defcheck_mytype(option,opt,value)

where option is an Option instance, opt is an option string
(e.g., -f), and value is the string from the command line that must
be checked and converted to your desired type. check_mytype() should
return an object of the hypothetical type mytype. The value returned by
a type-checking function will wind up in the OptionValues instance returned
by OptionParser.parse_args(), or be passed to a callback as the
value parameter.

Your type-checking function should raise OptionValueError if it
encounters any problems. OptionValueError takes a single string
argument, which is passed as-is to OptionParser’s error()
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 to
parse Python-style complex numbers on the command line. (This is even sillier
than it used to be, because optparse 1.3 added built-in support for
complex 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 the
TYPE_CHECKER class attribute of your Option subclass):

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

“store” actions

actions that result in optparse storing a value to an attribute of the
current OptionValues instance; these options require a dest
attribute to be supplied to the Option constructor.

“typed” actions

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

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 one
of the following class attributes of Option (all are lists of strings):

Actions that always take a type (i.e. whose options always take a value) are
additionally listed here. The only effect of this is that optparse
assigns the default type, "string", to options with no explicit type
whose action is listed in ALWAYS_TYPED_ACTIONS.

In order to actually implement your new action, you must override Option’s
take_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-line
and appending it to an existing list, "extend" will take multiple values in
a single comma-delimited string, and extend an existing list with them. That
is, if --names is an "extend" option of type "string", the command
line

"extend" both expects a value on the command-line and stores that value
somewhere, so it goes in both STORE_ACTIONS and
TYPED_ACTIONS.

to ensure that optparse assigns the default type of "string" to
"extend" actions, we put the "extend" action in
ALWAYS_TYPED_ACTIONS as well.

MyOption.take_action() implements just this one new action, and passes
control back to Option.take_action() for the standard optparse
actions.

values is an instance of the optparse_parser.Values class, which provides
the very useful ensure_value() method. ensure_value() is
essentially getattr() with a safety valve; it is called as

values.ensure_value(attr,value)

If the attr attribute of values doesn’t exist or is None, then
ensure_value() first sets it to value, and then returns ‘value. This is
very handy for actions like "extend", "append", and "count", all
of which accumulate data in a variable and expect that variable to be of a
certain type (a list for the first two, an integer for the latter). Using
ensure_value() means that scripts using your action don’t have to worry
about setting a default value for the option destinations in question; they
can just leave the default as None and ensure_value() will take care of
getting it right when it’s needed.