set svn:eol-style

3 files changed, 8315 insertions, 8315 deletions

diff --git a/Doc/library/argparse.rst b/Doc/library/argparse.rst
index 78922b1..750e819 100644
--- a/Doc/library/argparse.rst
+++ b/Doc/library/argparse.rst
@@ -1,1758 +1,1758 @@
-:mod:`argparse` -- Parser for command line options, arguments and sub-commands

-==============================================================================

-

-.. module:: argparse

-   :synopsis: Command-line option and argument parsing library.

-.. moduleauthor:: Steven Bethard <steven.bethard@gmail.com>

-.. versionadded:: 2.7

-.. sectionauthor:: Steven Bethard <steven.bethard@gmail.com>

-

-

-The :mod:`argparse` module makes it easy to write user friendly command line

-interfaces. You define what arguments your program requires, and

-:mod:`argparse` will figure out how to parse those out of ``sys.argv``. The

-:mod:`argparse` module also automatically generates help and usage messages

-based on the arguments you have defined, and issues errors when users give your

-program invalid arguments.

-

-Example

--------

-

-As an example, the following code is a Python program that takes a list of

-integers and produces either the sum or the max::

-

-   import argparse

-

-   parser = argparse.ArgumentParser(description='Process some integers.')

-   parser.add_argument('integers', metavar='N', type=int, nargs='+',

-                      help='an integer for the accumulator')

-   parser.add_argument('--sum', dest='accumulate', action='store_const',

-                      const=sum, default=max,

-                      help='sum the integers (default: find the max)')

-

-   args = parser.parse_args()

-   print args.accumulate(args.integers)

-

-Assuming the Python code above is saved into a file called ``prog.py``, it can

-be run at the command line and provides useful help messages::

-

-   $ prog.py -h

-   usage: prog.py [-h] [--sum] N [N ...]

-

-   Process some integers.

-

-   positional arguments:

-    N           an integer for the accumulator

-

-   optional arguments:

-    -h, --help  show this help message and exit

-    --sum       sum the integers (default: find the max)

-

-When run with the appropriate arguments, it prints either the sum or the max of

-the command-line integers::

-

-   $ prog.py 1 2 3 4

-   4

-

-   $ prog.py 1 2 3 4 --sum

-   10

-

-If invalid arguments are passed in, it will issue an error::

-

-   $ prog.py a b c

-   usage: prog.py [-h] [--sum] N [N ...]

-   prog.py: error: argument N: invalid int value: 'a'

-

-The following sections walk you through this example.

-

-Creating a parser

-^^^^^^^^^^^^^^^^^

-

-Pretty much every script that uses the :mod:`argparse` module will start out by

-creating an :class:`ArgumentParser` object::

-

-   >>> parser = argparse.ArgumentParser(description='Process some integers.')

-

-The :class:`ArgumentParser` object will hold all the information necessary to

-parse the command line into a more manageable form for your program.

-

-

-Adding arguments

-^^^^^^^^^^^^^^^^

-

-Once you've created an :class:`ArgumentParser`, you'll want to fill it with

-information about your program arguments. You typically do this by making calls

-to the :meth:`add_argument` method.  Generally, these calls tell the

-:class:`ArgumentParser` how to take the strings on the command line and turn

-them into objects for you. This information is stored and used when

-:meth:`parse_args` is called. For example, if we add some arguments like this::

-

-   >>> parser.add_argument('integers', metavar='N', type=int, nargs='+',

-   ...                     help='an integer for the accumulator')

-   >>> parser.add_argument('--sum', dest='accumulate', action='store_const',

-   ...                     const=sum, default=max,

-   ...                     help='sum the integers (default: find the max)')

-

-when we later call :meth:`parse_args`, we can expect it to return an object

-with two attributes, ``integers`` and ``accumulate``.  The ``integers``

-attribute will be a list of one or more ints, and the ``accumulate`` attribute

-will be either the ``sum`` function, if ``--sum`` was specified at the command

-line, or the ``max`` function if it was not.

-

-Parsing arguments

-^^^^^^^^^^^^^^^^^

-

-Once an :class:`ArgumentParser` has been initialized with appropriate calls to

-:meth:`add_argument`, it can be instructed to parse the command-line args by

-calling the :meth:`parse_args` method.  This will inspect the command-line,

-convert each arg to the appropriate type and then invoke the appropriate

-action.  In most cases, this means a simple namespace object will be built up

-from attributes parsed out of the command-line::

-

-   >>> parser.parse_args(['--sum', '7', '-1', '42'])

-   Namespace(accumulate=<built-in function sum>, integers=[7, -1, 42])

-

-In a script, :meth:`parse_args` will typically be called with no arguments, and

-the :class:`ArgumentParser` will automatically determine the command-line args

-from ``sys.argv``. That's pretty much it. You're now ready to go write some

-command line interfaces!

-

-

-ArgumentParser objects

-----------------------

-

-.. class:: ArgumentParser([description], [epilog], [prog], [usage], [add_help], [argument_default], [parents], [prefix_chars], [conflict_handler], [formatter_class])

-

-   Create a new :class:`ArgumentParser` object. Each parameter has its own more

-   detailed description below, but in short they are:

-

-   * description_ - Text to display before the argument help.

-

-   * epilog_ - Text to display after the argument help.

-

-   * add_help_ - Add a -h/--help option to the parser. (default: True)

-

-   * argument_default_ - Set the global default value for arguments.

-     (default: None)

-

-   * parents_ - A list of :class:ArgumentParser objects whose arguments should

-     also be included.

-

-   * prefix_chars_ - The set of characters that prefix optional arguments.

-     (default: '-')

-

-   * fromfile_prefix_chars_ - The set of characters that prefix files from

-     which additional arguments should be read. (default: None)

-

-   * formatter_class_ - A class for customizing the help output.

-

-   * conflict_handler_ - Usually unnecessary, defines strategy for resolving

-     conflicting optionals.

-

-   * prog_ - Usually unnecessary, the name of the program

-     (default: ``sys.argv[0]``)

-

-   * usage_ - Usually unnecessary, the string describing the program usage

-     (default: generated)

-

-   The following sections describe how each of these are used.

-

-

-description

-^^^^^^^^^^^

-

-Most calls to the ArgumentParser constructor will use the ``description=``

-keyword argument. This argument gives a brief description of what the program

-does and how it works. In help messages, the description is displayed between

-the command-line usage string and the help messages for the various arguments::

-

-   >>> parser = argparse.ArgumentParser(description='A foo that bars')

-   >>> parser.print_help()

-   usage: argparse.py [-h]

-

-   A foo that bars

-

-   optional arguments:

-    -h, --help  show this help message and exit

-

-By default, the description will be line-wrapped so that it fits within the

-given space. To change this behavior, see the formatter_class_ argument.

-

-

-epilog

-^^^^^^

-

-Some programs like to display additional description of the program after the

-description of the arguments. Such text can be specified using the ``epilog=``

-argument to ArgumentParser::

-

-   >>> parser = argparse.ArgumentParser(

-   ...     description='A foo that bars',

-   ...     epilog="And that's how you'd foo a bar")

-   >>> parser.print_help()

-   usage: argparse.py [-h]

-

-   A foo that bars

-

-   optional arguments:

-    -h, --help  show this help message and exit

-

-   And that's how you'd foo a bar

-

-As with the description_ argument, the ``epilog=`` text is by default

-line-wrapped, but this behavior can be adjusted with the formatter_class_

-argument to ArgumentParser.

-

-

-add_help

-^^^^^^^^

-

-By default, ArgumentParser objects add a ``-h/--help`` option which simply

-displays the parser's help message. For example, consider a file named

-``myprogram.py`` containing the following code::

-

-   import argparse

-   parser = argparse.ArgumentParser()

-   parser.add_argument('--foo', help='foo help')

-   args = parser.parse_args()

-

-If ``-h`` or ``--help`` is supplied is at the command-line, the ArgumentParser

-help will be printed::

-

-   $ python myprogram.py --help

-   usage: myprogram.py [-h] [--foo FOO]

-

-   optional arguments:

-    -h, --help  show this help message and exit

-    --foo FOO   foo help

-

-Occasionally, it may be useful to disable the addition of this help option.

-This can be achieved by passing ``False`` as the ``add_help=`` argument to

-ArgumentParser::

-

-   >>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)

-   >>> parser.add_argument('--foo', help='foo help')

-   >>> parser.print_help()

-   usage: PROG [--foo FOO]

-

-   optional arguments:

-    --foo FOO  foo help

-

-

-prefix_chars

-^^^^^^^^^^^^

-

-Most command-line options will use ``'-'`` as the prefix, e.g. ``-f/--foo``.

-Parsers that need to support additional prefix characters, e.g. for options

-like ``+f`` or ``/foo``, may specify them using the ``prefix_chars=`` argument

-to the ArgumentParser constructor::

-

-   >>> parser = argparse.ArgumentParser(prog='PROG', prefix_chars='-+')

-   >>> parser.add_argument('+f')

-   >>> parser.add_argument('++bar')

-   >>> parser.parse_args('+f X ++bar Y'.split())

-   Namespace(bar='Y', f='X')

-

-The ``prefix_chars=`` argument defaults to ``'-'``. Supplying a set of

-characters that does not include ``'-'`` will cause ``-f/--foo`` options to be

-disallowed.

-

-

-fromfile_prefix_chars

-^^^^^^^^^^^^^^^^^^^^^

-

-Sometimes, e.g. for particularly long argument lists, it may make sense to

-keep the list of arguments in a file rather than typing it out at the command

-line. If the ``fromfile_prefix_chars=`` argument is given to the ArgumentParser

-constructor, then arguments that start with any of the specified characters

-will be treated as files, and will be replaced by the arguments they contain.

-For example::

-

-   >>> open('args.txt', 'w').write('-f\nbar')

-   >>> parser = argparse.ArgumentParser(fromfile_prefix_chars='@')

-   >>> parser.add_argument('-f')

-   >>> parser.parse_args(['-f', 'foo', '@args.txt'])

-   Namespace(f='bar')

-

-Arguments read from a file must by default be one per line (but see also

-:meth:`convert_arg_line_to_args`) and are treated as if they were in the same

-place as the original file referencing argument on the command line. So in the

-example above, the expression ``['-f', 'foo', '@args.txt']`` is considered

-equivalent to the expression ``['-f', 'foo', '-f', 'bar']``.

-

-The ``fromfile_prefix_chars=`` argument defaults to ``None``, meaning that

-arguments will never be treated as file references.

-

-argument_default

-^^^^^^^^^^^^^^^^

-

-Generally, argument defaults are specified either by passing a default to

-:meth:`add_argument` or by calling the :meth:`set_defaults` methods with a

-specific set of name-value pairs. Sometimes however, it may be useful to

-specify a single parser-wide default for arguments. This can be accomplished by

-passing the ``argument_default=`` keyword argument to ArgumentParser. For

-example, to globally suppress attribute creation on :meth:`parse_args` calls,

-we supply ``argument_default=SUPPRESS``::

-

-   >>> parser = argparse.ArgumentParser(argument_default=argparse.SUPPRESS)

-   >>> parser.add_argument('--foo')

-   >>> parser.add_argument('bar', nargs='?')

-   >>> parser.parse_args(['--foo', '1', 'BAR'])

-   Namespace(bar='BAR', foo='1')

-   >>> parser.parse_args([])

-   Namespace()

-

-

-parents

-^^^^^^^

-

-Sometimes, several parsers share a common set of arguments. Rather than

-repeating the definitions of these arguments, you can define a single parser

-with all the shared arguments and then use the ``parents=`` argument to

-ArgumentParser to have these "inherited". The ``parents=`` argument takes a

-list of ArgumentParser objects, collects all the positional and optional

-actions from them, and adds these actions to the ArgumentParser object being

-constructed::

-

-   >>> parent_parser = argparse.ArgumentParser(add_help=False)

-   >>> parent_parser.add_argument('--parent', type=int)

-

-   >>> foo_parser = argparse.ArgumentParser(parents=[parent_parser])

-   >>> foo_parser.add_argument('foo')

-   >>> foo_parser.parse_args(['--parent', '2', 'XXX'])

-   Namespace(foo='XXX', parent=2)

-

-   >>> bar_parser = argparse.ArgumentParser(parents=[parent_parser])

-   >>> bar_parser.add_argument('--bar')

-   >>> bar_parser.parse_args(['--bar', 'YYY'])

-   Namespace(bar='YYY', parent=None)

-

-Note that most parent parsers will specify ``add_help=False``. Otherwise, the

-ArgumentParser will see two ``-h/--help`` options (one in the parent and one in

-the child) and raise an error.

-

-

-formatter_class

-^^^^^^^^^^^^^^^

-

-ArgumentParser objects allow the help formatting to be customized by specifying

-an alternate formatting class. Currently, there are three such classes:

-``argparse.RawDescriptionHelpFormatter``, ``argparse.RawTextHelpFormatter`` and

-``argparse.ArgumentDefaultsHelpFormatter``. The first two allow more control

-over how textual descriptions are displayed, while the last automatically adds

-information about argument default values.

-

-By default, ArgumentParser objects line-wrap the description_ and epilog_ texts

-in command-line help messages::

-

-   >>> parser = argparse.ArgumentParser(

-   ...     prog='PROG',

-   ...     description='''this description

-   ...         was indented weird

-   ...             but that is okay''',

-   ...     epilog='''

-   ...             likewise for this epilog whose whitespace will

-   ...         be cleaned up and whose words will be wrapped

-   ...         across a couple lines''')

-   >>> parser.print_help()

-   usage: PROG [-h]

-

-   this description was indented weird but that is okay

-

-   optional arguments:

-    -h, --help  show this help message and exit

-

-   likewise for this epilog whose whitespace will be cleaned up and whose words

-   will be wrapped across a couple lines

-

-When you have description_ and epilog_ that is already correctly formatted and

-should not be line-wrapped, you can indicate this by passing

-``argparse.RawDescriptionHelpFormatter`` as the ``formatter_class=`` argument

-to ArgumentParser::

-

-   >>> parser = argparse.ArgumentParser(

-   ...     prog='PROG',

-   ...     formatter_class=argparse.RawDescriptionHelpFormatter,

-   ...     description=textwrap.dedent('''\

-   ...         Please do not mess up this text!

-   ...         --------------------------------

-   ...             I have indented it

-   ...             exactly the way

-   ...             I want it

-   ...         '''))

-   >>> parser.print_help()

-   usage: PROG [-h]

-

-   Please do not mess up this text!

-   --------------------------------

-      I have indented it

-      exactly the way

-      I want it

-

-   optional arguments:

-    -h, --help  show this help message and exit

-

-If you want to maintain whitespace for all sorts of help text (including

-argument descriptions), you can use ``argparse.RawTextHelpFormatter``.

-

-The other formatter class available,

-``argparse.ArgumentDefaultsHelpFormatter``, will add information about the

-default value of each of the arguments::

-

-   >>> parser = argparse.ArgumentParser(

-   ...     prog='PROG',

-   ...     formatter_class=argparse.ArgumentDefaultsHelpFormatter)

-   >>> parser.add_argument('--foo', type=int, default=42, help='FOO!')

-   >>> parser.add_argument('bar', nargs='*', default=[1, 2, 3], help='BAR!')

-   >>> parser.print_help()

-   usage: PROG [-h] [--foo FOO] [bar [bar ...]]

-

-   positional arguments:

-    bar         BAR! (default: [1, 2, 3])

-

-   optional arguments:

-    -h, --help  show this help message and exit

-    --foo FOO   FOO! (default: 42)

-

-

-conflict_handler

-^^^^^^^^^^^^^^^^

-

-ArgumentParser objects do not allow two actions with the same option string.

-By default, ArgumentParser objects will raise an exception if you try to create

-an argument with an option string that is already in use::

-

-   >>> parser = argparse.ArgumentParser(prog='PROG')

-   >>> parser.add_argument('-f', '--foo', help='old foo help')

-   >>> parser.add_argument('--foo', help='new foo help')

-   Traceback (most recent call last):

-    ..

-   ArgumentError: argument --foo: conflicting option string(s): --foo

-

-Sometimes (e.g. when using parents_) it may be useful to simply override any

-older arguments with the same option string. To get this behavior, the value

-``'resolve'`` can be supplied to the ``conflict_handler=`` argument of

-ArgumentParser::

-

-   >>> parser = argparse.ArgumentParser(prog='PROG', conflict_handler='resolve')

-   >>> parser.add_argument('-f', '--foo', help='old foo help')

-   >>> parser.add_argument('--foo', help='new foo help')

-   >>> parser.print_help()

-   usage: PROG [-h] [-f FOO] [--foo FOO]

-

-   optional arguments:

-    -h, --help  show this help message and exit

-    -f FOO      old foo help

-    --foo FOO   new foo help

-

-Note that ArgumentParser objects only remove an action if all of its option

-strings are overridden. So, in the example above, the old ``-f/--foo`` action

-is retained as the ``-f`` action, because only the ``--foo`` option string was

-overridden.

-

-

-prog

-^^^^

-

-By default, ArgumentParser objects use ``sys.argv[0]`` to determine how to

-display the name of the program in help messages. This default is almost always

-what you want because it will make the help messages match what your users have

-typed at the command line. For example, consider a file named ``myprogram.py``

-with the following code::

-

-   import argparse

-   parser = argparse.ArgumentParser()

-   parser.add_argument('--foo', help='foo help')

-   args = parser.parse_args()

-

-The help for this program will display ``myprogram.py`` as the program name

-(regardless of where the program was invoked from)::

-

-   $ python myprogram.py --help

-   usage: myprogram.py [-h] [--foo FOO]

-

-   optional arguments:

-    -h, --help  show this help message and exit

-    --foo FOO   foo help

-   $ cd ..

-   $ python subdir\myprogram.py --help

-   usage: myprogram.py [-h] [--foo FOO]

-

-   optional arguments:

-    -h, --help  show this help message and exit

-    --foo FOO   foo help

-

-To change this default behavior, another value can be supplied using the

-``prog=`` argument to ArgumentParser::

-

-   >>> parser = argparse.ArgumentParser(prog='myprogram')

-   >>> parser.print_help()

-   usage: myprogram [-h]

-

-   optional arguments:

-    -h, --help  show this help message and exit

-

-Note that the program name, whether determined from ``sys.argv[0]`` or from the

-``prog=`` argument, is available to help messages using the ``%(prog)s`` format

-specifier.

-

-::

-

-   >>> parser = argparse.ArgumentParser(prog='myprogram')

-   >>> parser.add_argument('--foo', help='foo of the %(prog)s program')

-   >>> parser.print_help()

-   usage: myprogram [-h] [--foo FOO]

-

-   optional arguments:

-    -h, --help  show this help message and exit

-    --foo FOO   foo of the myprogram program

-

-

-usage

-^^^^^

-

-By default, ArgumentParser objects calculate the usage message from the

-arguments it contains::

-

-   >>> parser = argparse.ArgumentParser(prog='PROG')

-   >>> parser.add_argument('--foo', nargs='?', help='foo help')

-   >>> parser.add_argument('bar', nargs='+', help='bar help')

-   >>> parser.print_help()

-   usage: PROG [-h] [--foo [FOO]] bar [bar ...]

-

-   positional arguments:

-    bar          bar help

-

-   optional arguments:

-    -h, --help   show this help message and exit

-    --foo [FOO]  foo help

-

-If the default usage message is not appropriate for your application, you can

-supply your own usage message using the ``usage=`` keyword argument to

-ArgumentParser::

-

-   >>> parser = argparse.ArgumentParser(prog='PROG', usage='%(prog)s [options]')

-   >>> parser.add_argument('--foo', nargs='?', help='foo help')

-   >>> parser.add_argument('bar', nargs='+', help='bar help')

-   >>> parser.print_help()

-   usage: PROG [options]

-

-   positional arguments:

-    bar          bar help

-

-   optional arguments:

-    -h, --help   show this help message and exit

-    --foo [FOO]  foo help

-

-Note you can use the ``%(prog)s`` format specifier to fill in the program name

-in your usage messages.

-

-

-The add_argument() method

--------------------------

-

-.. method:: add_argument(name or flags..., [action], [nargs], [const], [default], [type], [choices], [required], [help], [metavar], [dest])

-

-   Define how a single command line argument should be parsed. Each parameter

-   has its own more detailed description below, but in short they are:

-

-   * `name or flags`_ - Either a name or a list of option strings, e.g. ``foo``

-     or ``-f, --foo``

-

-   * action_ - The basic type of action to be taken when this argument is

-     encountered at the command-line.

-

-   * nargs_ - The number of command-line arguments that should be consumed.

-

-   * const_ - A constant value required by some action_ and nargs_ selections.

-

-   * default_ - The value produced if the argument is absent from the

-     command-line.

-

-   * type_ - The type to which the command-line arg should be converted.

-

-   * choices_ - A container of the allowable values for the argument.

-

-   * required_ - Whether or not the command-line option may be omitted

-     (optionals only).

-

-   * help_ - A brief description of what the argument does.

-

-   * metavar_ - A name for the argument in usage messages.

-

-   * dest_ - The name of the attribute to be added to the object returned by

-     :meth:`parse_args`.

-

-   The following sections describe how each of these are used.

-

-name or flags

-^^^^^^^^^^^^^

-

-The :meth:`add_argument` method needs to know whether you're expecting an

-optional argument, e.g. ``-f`` or ``--foo``, or a positional argument, e.g. a

-list of filenames. The first arguments passed to :meth:`add_argument` must

-therefore be either a series of flags, or a simple argument name. For example,

-an optional argument could be created like::

-

-   >>> parser.add_argument('-f', '--foo')

-

-while a positional argument could be created like::

-

-   >>> parser.add_argument('bar')

-

-When :meth:`parse_args` is called, optional arguments will be identified by the

-``-`` prefix, and the remaining arguments will be assumed to be positional::

-

-   >>> parser = argparse.ArgumentParser(prog='PROG')

-   >>> parser.add_argument('-f', '--foo')

-   >>> parser.add_argument('bar')

-   >>> parser.parse_args(['BAR'])

-   Namespace(bar='BAR', foo=None)

-   >>> parser.parse_args(['BAR', '--foo', 'FOO'])

-   Namespace(bar='BAR', foo='FOO')

-   >>> parser.parse_args(['--foo', 'FOO'])

-   usage: PROG [-h] [-f FOO] bar

-   PROG: error: too few arguments

-

-action

-^^^^^^

-

-:class:`ArgumentParser` objects associate command-line args with actions. These

-actions can do just about anything with the command-line args associated with

-them, though most actions simply add an attribute to the object returned by

-:meth:`parse_args`.  When you specify a new argument using the

-:meth:`add_argument` method, you can indicate how the command-line args should

-be handled by specifying the ``action`` keyword argument. The supported actions

-are:

-

-* ``'store'`` - This just stores the argument's value. This is the default

-   action. For example::

-

-    >>> parser = argparse.ArgumentParser()

-    >>> parser.add_argument('--foo')

-    >>> parser.parse_args('--foo 1'.split())

-    Namespace(foo='1')

-

-* ``'store_const'`` - This stores the value specified by the const_ keyword

-   argument. Note that the const_ keyword argument defaults to ``None``, so

-   you'll almost always need to provide a value for it. The ``'store_const'``

-   action is most commonly used with optional arguments that specify some sort

-   of flag.  For example::

-

-    >>> parser = argparse.ArgumentParser()

-    >>> parser.add_argument('--foo', action='store_const', const=42)

-    >>> parser.parse_args('--foo'.split())

-    Namespace(foo=42)

-

-* ``'store_true'`` and ``'store_false'`` - These store the values ``True`` and

-  ``False`` respectively.  These are basically special cases of

-  ``'store_const'``.  For example::

-

-    >>> parser = argparse.ArgumentParser()

-    >>> parser.add_argument('--foo', action='store_true')

-    >>> parser.add_argument('--bar', action='store_false')

-    >>> parser.parse_args('--foo --bar'.split())

-    Namespace(bar=False, foo=True)

-

-* ``'append'`` - This stores a list, and appends each argument value to the

-  list.  This is useful when you want to allow an option to be specified

-  multiple times.  Example usage::

-

-    >>> parser = argparse.ArgumentParser()

-    >>> parser.add_argument('--foo', action='append')

-    >>> parser.parse_args('--foo 1 --foo 2'.split())

-    Namespace(foo=['1', '2'])

-

-* ``'append_const'`` - This stores a list, and appends the value specified by

-  the const_ keyword argument to the list.  Note that the const_ keyword

-  argument defaults to ``None``, so you'll almost always need to provide a

-  value for it.  The ``'append_const'`` action is typically useful when you

-  want multiple arguments to store constants to the same list, for example::

-

-    >>> parser = argparse.ArgumentParser()

-    >>> parser.add_argument('--str', dest='types', action='append_const', const=str)

-    >>> parser.add_argument('--int', dest='types', action='append_const', const=int)

-    >>> parser.parse_args('--str --int'.split())

-    Namespace(types=[<type 'str'>, <type 'int'>])

-

-* ``'version'`` - This expects a ``version=`` keyword argument in the

-  :meth:`add_argument` call, and prints version information and exits when

-  invoked.

-

-    >>> import argparse

-    >>> parser = argparse.ArgumentParser(prog='PROG')

-    >>> parser.add_argument('-v', '--version', action='version', version='%(prog)s 2.0')

-    >>> parser.parse_args(['-v'])

-    PROG 2.0

-

-You can also specify an arbitrary action by passing an object that implements

-the Action API.  The easiest way to do this is to extend ``argparse.Action``,

-supplying an appropriate ``__call__`` method.  The ``__call__`` method accepts

-four parameters:

-

-* ``parser`` - The ArgumentParser object which contains this action.

-

-* ``namespace`` - The namespace object that will be returned by

-  :meth:`parse_args`. Most actions add an attribute to this object.

-

-* ``values`` - The associated command-line args, with any type-conversions

-  applied.  (Type-conversions are specified with the type_ keyword argument to

-  :meth:`add_argument`.

-

-* ``option_string`` - The option string that was used to invoke this action.

-  The ``option_string`` argument is optional, and will be absent if the action

-  is associated with a positional argument.

-

-So for example::

-

-   >>> class FooAction(argparse.Action):

-   ...     def __call__(self, parser, namespace, values, option_string=None):

-   ...     print '%r %r %r' % (namespace, values, option_string)

-   ...     setattr(namespace, self.dest, values)

-   ...

-   >>> parser = argparse.ArgumentParser()

-   >>> parser.add_argument('--foo', action=FooAction)

-   >>> parser.add_argument('bar', action=FooAction)

-   >>> args = parser.parse_args('1 --foo 2'.split())

-   Namespace(bar=None, foo=None) '1' None

-   Namespace(bar='1', foo=None) '2' '--foo'

-   >>> args

-   Namespace(bar='1', foo='2')

-

-

-nargs

-^^^^^

-

-ArgumentParser objects usually associate a single command-line argument with a

-single action to be taken.  In the situations where you'd like to associate a

-different number of command-line arguments with a single action, you can use

-the ``nargs`` keyword argument to :meth:`add_argument`. The supported values

-are:

-

-* N (an integer). N args from the command-line will be gathered together into

-  a list.  For example::

-

-    >>> parser = argparse.ArgumentParser()

-    >>> parser.add_argument('--foo', nargs=2)

-    >>> parser.add_argument('bar', nargs=1)

-    >>> parser.parse_args('c --foo a b'.split())

-    Namespace(bar=['c'], foo=['a', 'b'])

-

-   Note that ``nargs=1`` produces a list of one item.  This is different from

-   the default, in which the item is produced by itself.

-

-* ``'?'``. One arg will be consumed from the command-line if possible, and

-  produced as a single item.  If no command-line arg is present, the value from

-  default_ will be produced.  Note that for optional arguments, there is an

-  additional case - the option string is present but not followed by a

-  command-line arg.  In this case the value from const_ will be produced.  Some

-  examples to illustrate this::

-

-    >>> parser = argparse.ArgumentParser()

-    >>> parser.add_argument('--foo', nargs='?', const='c', default='d')

-    >>> parser.add_argument('bar', nargs='?', default='d')

-    >>> parser.parse_args('XX --foo YY'.split())

-    Namespace(bar='XX', foo='YY')

-    >>> parser.parse_args('XX --foo'.split())

-    Namespace(bar='XX', foo='c')

-    >>> parser.parse_args(''.split())

-    Namespace(bar='d', foo='d')

-

-   One of the more common uses of ``nargs='?'`` is to allow optional input and

-   output files::

-

-    >>> parser = argparse.ArgumentParser()

-    >>> parser.add_argument('infile', nargs='?', type=argparse.FileType('r'), default=sys.stdin)

-    >>> parser.add_argument('outfile', nargs='?', type=argparse.FileType('w'), default=sys.stdout)

-    >>> parser.parse_args(['input.txt', 'output.txt'])

-    Namespace(infile=<open file 'input.txt', mode 'r' at 0x...>, outfile=<open file 'output.txt', mode 'w' at 0x...>)

-    >>> parser.parse_args([])

-    Namespace(infile=<open file '<stdin>', mode 'r' at 0x...>, outfile=<open file '<stdout>', mode 'w' at 0x...>)

-

-* ``'*'``. All command-line args present are gathered into a list. Note that

-  it generally doesn't make much sense to have more than one positional

-  argument with ``nargs='*'``, but multiple optional arguments with

-  ``nargs='*'`` is possible.  For example::

-

-    >>> parser = argparse.ArgumentParser()

-    >>> parser.add_argument('--foo', nargs='*')

-    >>> parser.add_argument('--bar', nargs='*')

-    >>> parser.add_argument('baz', nargs='*')

-    >>> parser.parse_args('a b --foo x y --bar 1 2'.split())

-    Namespace(bar=['1', '2'], baz=['a', 'b'], foo=['x', 'y'])

-

-* ``'+'``. Just like ``'*'``, all command-line args present are gathered into a

-  list.  Additionally, an error message will be generated if there wasn't at

-  least one command-line arg present.  For example::

-

-    >>> parser = argparse.ArgumentParser(prog='PROG')

-    >>> parser.add_argument('foo', nargs='+')

-    >>> parser.parse_args('a b'.split())

-    Namespace(foo=['a', 'b'])

-    >>> parser.parse_args(''.split())

-    usage: PROG [-h] foo [foo ...]

-    PROG: error: too few arguments

-

-If the ``nargs`` keyword argument is not provided, the number of args consumed

-is determined by the action_. Generally this means a single command-line arg

-will be consumed and a single item (not a list) will be produced.

-

-

-const

-^^^^^

-

-The ``const`` argument of :meth:`add_argument` is used to hold constant values

-that are not read from the command line but are required for the various

-ArgumentParser actions.  The two most common uses of it are:

-

-* When :meth:`add_argument` is called with ``action='store_const'`` or

-  ``action='append_const'``.  These actions add the ``const`` value to one of

-  the attributes of the object returned by :meth:`parse_args`.  See the action_

-  description for examples.

-

-* When :meth:`add_argument` is called with option strings (like ``-f`` or

-  ``--foo``) and ``nargs='?'``. This creates an optional argument that can be

-  followed by zero or one command-line args.  When parsing the command-line, if

-  the option string is encountered with no command-line arg following it, the

-  value of ``const`` will be assumed instead. See the nargs_ description for

-  examples.

-

-The ``const`` keyword argument defaults to ``None``.

-

-

-default

-^^^^^^^

-

-All optional arguments and some positional arguments may be omitted at the

-command-line.  The ``default`` keyword argument of :meth:`add_argument`, whose

-value defaults to ``None``, specifies what value should be used if the

-command-line arg is not present.  For optional arguments, the ``default`` value

-is used when the option string was not present at the command line::

-

-   >>> parser = argparse.ArgumentParser()

-   >>> parser.add_argument('--foo', default=42)

-   >>> parser.parse_args('--foo 2'.split())

-   Namespace(foo='2')

-   >>> parser.parse_args(''.split())

-   Namespace(foo=42)

-

-For positional arguments with nargs_ ``='?'`` or ``'*'``, the ``default`` value

-is used when no command-line arg was present::

-

-   >>> parser = argparse.ArgumentParser()

-   >>> parser.add_argument('foo', nargs='?', default=42)

-   >>> parser.parse_args('a'.split())

-   Namespace(foo='a')

-   >>> parser.parse_args(''.split())

-   Namespace(foo=42)

-

-

-If you don't want to see an attribute when an option was not present at the

-command line, you can supply ``default=argparse.SUPPRESS``::

-

-   >>> parser = argparse.ArgumentParser()

-   >>> parser.add_argument('--foo', default=argparse.SUPPRESS)

-   >>> parser.parse_args([])

-   Namespace()

-   >>> parser.parse_args(['--foo', '1'])

-   Namespace(foo='1')

-

-

-type

-^^^^

-

-By default, ArgumentParser objects read command-line args in as simple strings.

-However, quite often the command-line string should instead be interpreted as

-another type, e.g. ``float``, ``int`` or ``file``. The ``type`` keyword

-argument of :meth:`add_argument` allows any necessary type-checking and

-type-conversions to be performed.  Many common builtin types can be used

-directly as the value of the ``type`` argument::

-

-   >>> parser = argparse.ArgumentParser()

-   >>> parser.add_argument('foo', type=int)

-   >>> parser.add_argument('bar', type=file)

-   >>> parser.parse_args('2 temp.txt'.split())

-   Namespace(bar=<open file 'temp.txt', mode 'r' at 0x...>, foo=2)

-

-To ease the use of various types of files, the argparse module provides the

-factory FileType which takes the ``mode=`` and ``bufsize=`` arguments of the

-``file`` object. For example, ``FileType('w')`` can be used to create a

-writable file::

-

-   >>> parser = argparse.ArgumentParser()

-   >>> parser.add_argument('bar', type=argparse.FileType('w'))

-   >>> parser.parse_args(['out.txt'])

-   Namespace(bar=<open file 'out.txt', mode 'w' at 0x...>)

-

-If you need to do some special type-checking or type-conversions, you can

-provide your own types by passing to ``type=`` a callable that takes a single

-string argument and returns the type-converted value::

-

-   >>> def perfect_square(string):

-   ...     value = int(string)

-   ...     sqrt = math.sqrt(value)

-   ...     if sqrt != int(sqrt):

-   ...         msg = "%r is not a perfect square" % string

-   ...         raise argparse.ArgumentTypeError(msg)

-   ...     return value

-   ...

-   >>> parser = argparse.ArgumentParser(prog='PROG')

-   >>> parser.add_argument('foo', type=perfect_square)

-   >>> parser.parse_args('9'.split())

-   Namespace(foo=9)

-   >>> parser.parse_args('7'.split())

-   usage: PROG [-h] foo

-   PROG: error: argument foo: '7' is not a perfect square

-

-Note that if your type-checking function is just checking for a particular set

-of values, it may be more convenient to use the choices_ keyword argument::

-

-   >>> parser = argparse.ArgumentParser(prog='PROG')

-   >>> parser.add_argument('foo', type=int, choices=xrange(5, 10))

-   >>> parser.parse_args('7'.split())

-   Namespace(foo=7)

-   >>> parser.parse_args('11'.split())

-   usage: PROG [-h] {5,6,7,8,9}

-   PROG: error: argument foo: invalid choice: 11 (choose from 5, 6, 7, 8, 9)

-

-See the choices_ section for more details.

-

-

-choices

-^^^^^^^

-

-Some command-line args should be selected from a restricted set of values.

-ArgumentParser objects can be told about such sets of values by passing a

-container object as the ``choices`` keyword argument to :meth:`add_argument`.

-When the command-line is parsed with :meth:`parse_args`, arg values will be

-checked, and an error message will be displayed if the arg was not one of the

-acceptable values::

-

-   >>> parser = argparse.ArgumentParser(prog='PROG')

-   >>> parser.add_argument('foo', choices='abc')

-   >>> parser.parse_args('c'.split())

-   Namespace(foo='c')

-   >>> parser.parse_args('X'.split())

-   usage: PROG [-h] {a,b,c}

-   PROG: error: argument foo: invalid choice: 'X' (choose from 'a', 'b', 'c')

-

-Note that inclusion in the ``choices`` container is checked after any type_

-conversions have been performed, so the type of the objects in the ``choices``

-container should match the type_ specified::

-

-   >>> parser = argparse.ArgumentParser(prog='PROG')

-   >>> parser.add_argument('foo', type=complex, choices=[1, 1j])

-   >>> parser.parse_args('1j'.split())

-   Namespace(foo=1j)

-   >>> parser.parse_args('-- -4'.split())

-   usage: PROG [-h] {1,1j}

-   PROG: error: argument foo: invalid choice: (-4+0j) (choose from 1, 1j)

-

-Any object that supports the ``in`` operator can be passed as the ``choices``

-value, so ``dict`` objects, ``set`` objects, custom containers, etc. are all

-supported.

-

-

-required

-^^^^^^^^

-

-In general, the argparse module assumes that flags like ``-f`` and ``--bar``

-indicate *optional* arguments, which can always be omitted at the command-line.

-To change this behavior, i.e. to make an option *required*, the value ``True``

-should be specified for the ``required=`` keyword argument to

-:meth:`add_argument`::

-

-   >>> parser = argparse.ArgumentParser()

-   >>> parser.add_argument('--foo', required=True)

-   >>> parser.parse_args(['--foo', 'BAR'])

-   Namespace(foo='BAR')

-   >>> parser.parse_args([])

-   usage: argparse.py [-h] [--foo FOO]

-   argparse.py: error: option --foo is required

-

-As the example shows, if an option is marked as ``required``, :meth:`parse_args`

-will report an error if that option is not present at the command line.

-

-**Warning:** Required options are generally considered bad form - normal users

-expect *options* to be *optional*. You should avoid the use of required options

-whenever possible.

-

-

-help

-^^^^

-

-A great command-line interface isn't worth anything if your users can't figure

-out which option does what.  So for the end-users, ``help`` is probably the

-most important argument to include in your :meth:`add_argument` calls.  The

-``help`` value should be a string containing a brief description of what the

-argument specifies.  When a user requests help (usually by using ``-h`` or

-``--help`` at the command-line), these ``help`` descriptions will be displayed

-with each argument::

-

-   >>> parser = argparse.ArgumentParser(prog='frobble')

-   >>> parser.add_argument('--foo', action='store_true',

-   ...         help='foo the bars before frobbling')

-   >>> parser.add_argument('bar', nargs='+',

-   ...         help='one of the bars to be frobbled')

-   >>> parser.parse_args('-h'.split())

-   usage: frobble [-h] [--foo] bar [bar ...]

-

-   positional arguments:

-    bar     one of the bars to be frobbled

-

-   optional arguments:

-    -h, --help  show this help message and exit

-    --foo   foo the bars before frobbling

-

-The ``help`` strings can include various format specifiers to avoid repetition

-of things like the program name or the argument default_.  The available

-specifiers include the program name, ``%(prog)s`` and most keyword arguments to

-:meth:`add_argument`, e.g. ``%(default)s``, ``%(type)s``, etc.::

-

-   >>> parser = argparse.ArgumentParser(prog='frobble')

-   >>> parser.add_argument('bar', nargs='?', type=int, default=42,

-   ...         help='the bar to %(prog)s (default: %(default)s)')

-   >>> parser.print_help()

-   usage: frobble [-h] [bar]

-

-   positional arguments:

-    bar     the bar to frobble (default: 42)

-

-   optional arguments:

-    -h, --help  show this help message and exit

-

-

-metavar

-^^^^^^^

-

-When ArgumentParser objects generate help messages, they need some way to refer

-to each expected argument. By default, ArgumentParser objects use the dest_

-value as the "name" of each object.  By default, for positional argument

-actions, the dest_ value is used directly, and for optional argument actions,

-the dest_ value is uppercased.  So if we have a single positional argument with

-``dest='bar'``, that argument will be referred to as ``bar``.  And if we have a

-single optional argument ``--foo`` that should be followed by a single

-command-line arg, that arg will be referred to as ``FOO``.  You can see this

-behavior in the example below::

-

-   >>> parser = argparse.ArgumentParser()

-   >>> parser.add_argument('--foo')

-   >>> parser.add_argument('bar')

-   >>> parser.parse_args('X --foo Y'.split())

-   Namespace(bar='X', foo='Y')

-   >>> parser.print_help()

-   usage:  [-h] [--foo FOO] bar

-

-   positional arguments:

-    bar

-

-   optional arguments:

-    -h, --help  show this help message and exit

-    --foo FOO

-

-If you would like to provide a different name for your argument in help

-messages, you can supply a value for the ``metavar`` keyword argument to

-:meth:`add_argument`::

-

-   >>> parser = argparse.ArgumentParser()

-   >>> parser.add_argument('--foo', metavar='YYY')

-   >>> parser.add_argument('bar', metavar='XXX')

-   >>> parser.parse_args('X --foo Y'.split())

-   Namespace(bar='X', foo='Y')

-   >>> parser.print_help()

-   usage:  [-h] [--foo YYY] XXX

-

-   positional arguments:

-    XXX

-

-   optional arguments:

-    -h, --help  show this help message and exit

-    --foo YYY

-

-Note that ``metavar`` only changes the *displayed* name - the name of the

-attribute on the :meth:`parse_args` object is still determined by the dest_

-value.

-

-Different values of ``nargs`` may cause the metavar to be used multiple times.

-If you'd like to specify a different display name for each of the arguments,

-you can provide a tuple to ``metavar``::

-

-   >>> parser = argparse.ArgumentParser(prog='PROG')

-   >>> parser.add_argument('-x', nargs=2)

-   >>> parser.add_argument('--foo', nargs=2, metavar=('bar', 'baz'))

-   >>> parser.print_help()

-   usage: PROG [-h] [-x X X] [--foo bar baz]

-

-   optional arguments:

-    -h, --help     show this help message and exit

-    -x X X

-    --foo bar baz

-

-

-dest

-^^^^

-

-Most ArgumentParser actions add some value as an attribute of the object

-returned by :meth:`parse_args`. The name of this attribute is determined by the

-``dest`` keyword argument of :meth:`add_argument`. For positional argument

-actions, ``dest`` is normally supplied as the first argument to

-:meth:`add_argument`::

-

-   >>> parser = argparse.ArgumentParser()

-   >>> parser.add_argument('bar')

-   >>> parser.parse_args('XXX'.split())

-   Namespace(bar='XXX')

-

-For optional argument actions, the value of ``dest`` is normally inferred from

-the option strings. ArgumentParser objects generate the value of ``dest`` by

-taking the first long option string and stripping away the initial ``'--'``

-string.  If no long option strings were supplied, ``dest`` will be derived from

-the first short option string by stripping the initial ``'-'`` character.  Any

-internal ``'-'`` characters will be converted to ``'_'`` characters to make

-sure the string is a valid attribute name. The examples below illustrate this

-behavior::

-

-   >>> parser = argparse.ArgumentParser()

-   >>> parser.add_argument('-f', '--foo-bar', '--foo')

-   >>> parser.add_argument('-x', '-y')

-   >>> parser.parse_args('-f 1 -x 2'.split())

-   Namespace(foo_bar='1', x='2')

-   >>> parser.parse_args('--foo 1 -y 2'.split())

-   Namespace(foo_bar='1', x='2')

-

-If you would like to use a different attribute name from the one automatically

-inferred by the ArgumentParser, you can supply it with an explicit ``dest``

-parameter::

-

-   >>> parser = argparse.ArgumentParser()

-   >>> parser.add_argument('--foo', dest='bar')

-   >>> parser.parse_args('--foo XXX'.split())

-   Namespace(bar='XXX')

-

-

-The parse_args() method

------------------------

-

-.. method:: parse_args([args], [namespace])

-

-   Convert the strings to objects and assign them as attributes of the

-   namespace. Return the populated namespace.

-

-   Previous calls to :meth:`add_argument` determine exactly what objects are

-   created and how they are assigned. See the documentation for

-   :meth:`add_argument` for details.

-

-   By default, the arg strings are taken from ``sys.argv``, and a new empty

-   ``Namespace`` object is created for the attributes.

-

-Option value syntax

-^^^^^^^^^^^^^^^^^^^

-

-The :meth:`parse_args` method supports several ways of specifying the value of

-an option (if it takes one). In the simplest case, the option and its value are

-passed as two separate arguments::

-

-   >>> parser = argparse.ArgumentParser(prog='PROG')

-   >>> parser.add_argument('-x')

-   >>> parser.add_argument('--foo')

-   >>> parser.parse_args('-x X'.split())

-   Namespace(foo=None, x='X')

-   >>> parser.parse_args('--foo FOO'.split())

-   Namespace(foo='FOO', x=None)

-

-For long options (options with names longer than a single character), you may

-also pass the option and value as a single command line argument, using ``=``

-to separate them::

-

-   >>> parser.parse_args('--foo=FOO'.split())

-   Namespace(foo='FOO', x=None)

-

-For short options (options only one character long), you may simply concatenate

-the option and its value::

-

-   >>> parser.parse_args('-xX'.split())

-   Namespace(foo=None, x='X')

-

-You can also combine several short options together, using only a single ``-``

-prefix, as long as only the last option (or none of them) requires a value::

-

-   >>> parser = argparse.ArgumentParser(prog='PROG')

-   >>> parser.add_argument('-x', action='store_true')

-   >>> parser.add_argument('-y', action='store_true')

-   >>> parser.add_argument('-z')

-   >>> parser.parse_args('-xyzZ'.split())

-   Namespace(x=True, y=True, z='Z')

-

-

-Invalid arguments

-^^^^^^^^^^^^^^^^^

-

-While parsing the command-line, ``parse_args`` checks for a variety of errors,

-including ambiguous options, invalid types, invalid options, wrong number of

-positional arguments, etc. When it encounters such an error, it exits and

-prints the error along with a usage message::

-

-   >>> parser = argparse.ArgumentParser(prog='PROG')

-   >>> parser.add_argument('--foo', type=int)

-   >>> parser.add_argument('bar', nargs='?')

-

-   >>> # invalid type

-   >>> parser.parse_args(['--foo', 'spam'])

-   usage: PROG [-h] [--foo FOO] [bar]

-   PROG: error: argument --foo: invalid int value: 'spam'

-

-   >>> # invalid option

-   >>> parser.parse_args(['--bar'])

-   usage: PROG [-h] [--foo FOO] [bar]

-   PROG: error: no such option: --bar

-

-   >>> # wrong number of arguments

-   >>> parser.parse_args(['spam', 'badger'])

-   usage: PROG [-h] [--foo FOO] [bar]

-   PROG: error: extra arguments found: badger

-

-

-Arguments containing ``"-"``

-^^^^^^^^^^^^^^^^^^^^^^^^^^^^

-

-The ``parse_args`` method attempts to give errors whenever the user has clearly

-made a mistake, but some situations are inherently ambiguous. For example, the

-command-line arg ``'-1'`` could either be an attempt to specify an option or an

-attempt to provide a positional argument. The ``parse_args`` method is cautious

-here: positional arguments may only begin with ``'-'`` if they look like

-negative numbers and there are no options in the parser that look like negative

-numbers::

-

-   >>> parser = argparse.ArgumentParser(prog='PROG')

-   >>> parser.add_argument('-x')

-   >>> parser.add_argument('foo', nargs='?')

-

-   >>> # no negative number options, so -1 is a positional argument

-   >>> parser.parse_args(['-x', '-1'])

-   Namespace(foo=None, x='-1')

-

-   >>> # no negative number options, so -1 and -5 are positional arguments

-   >>> parser.parse_args(['-x', '-1', '-5'])

-   Namespace(foo='-5', x='-1')

-

-   >>> parser = argparse.ArgumentParser(prog='PROG')

-   >>> parser.add_argument('-1', dest='one')

-   >>> parser.add_argument('foo', nargs='?')

-

-   >>> # negative number options present, so -1 is an option

-   >>> parser.parse_args(['-1', 'X'])

-   Namespace(foo=None, one='X')

-

-   >>> # negative number options present, so -2 is an option

-   >>> parser.parse_args(['-2'])

-   usage: PROG [-h] [-1 ONE] [foo]

-   PROG: error: no such option: -2

-

-   >>> # negative number options present, so both -1s are options

-   >>> parser.parse_args(['-1', '-1'])

-   usage: PROG [-h] [-1 ONE] [foo]

-   PROG: error: argument -1: expected one argument

-

-If you have positional arguments that must begin with ``'-'`` and don't look

-like negative numbers, you can insert the pseudo-argument ``'--'`` which tells

-``parse_args`` that everything after that is a positional argument::

-

-   >>> parser.parse_args(['--', '-f'])

-   Namespace(foo='-f', one=None)

-

-

-Argument abbreviations

-^^^^^^^^^^^^^^^^^^^^^^

-

-The :meth:`parse_args` method allows you to abbreviate long options if the

-abbreviation is unambiguous::

-

-   >>> parser = argparse.ArgumentParser(prog='PROG')

-   >>> parser.add_argument('-bacon')

-   >>> parser.add_argument('-badger')

-   >>> parser.parse_args('-bac MMM'.split())

-   Namespace(bacon='MMM', badger=None)

-   >>> parser.parse_args('-bad WOOD'.split())

-   Namespace(bacon=None, badger='WOOD')

-   >>> parser.parse_args('-ba BA'.split())

-   usage: PROG [-h] [-bacon BACON] [-badger BADGER]

-   PROG: error: ambiguous option: -ba could match -badger, -bacon

-

-As you can see above, you will get an error if you pick a prefix that could

-refer to more than one option.

-

-

-Beyond ``sys.argv``

-^^^^^^^^^^^^^^^^^^^

-

-Sometimes it may be useful to have an ArgumentParser parse args other than

-those of ``sys.argv``.  This can be accomplished by passing a list of strings

-to ``parse_args``.  You may have noticed that the examples in the argparse

-documentation have made heavy use of this calling style - it is much easier

-to use at the interactive prompt::

-

-   >>> parser = argparse.ArgumentParser()

-   >>> parser.add_argument(

-   ...     'integers', metavar='int', type=int, choices=xrange(10),

-   ...  nargs='+', help='an integer in the range 0..9')

-   >>> parser.add_argument(

-   ...     '--sum', dest='accumulate', action='store_const', const=sum,

-   ...   default=max, help='sum the integers (default: find the max)')

-   >>> parser.parse_args(['1', '2', '3', '4'])

-   Namespace(accumulate=<built-in function max>, integers=[1, 2, 3, 4])

-   >>> parser.parse_args('1 2 3 4 --sum'.split())

-   Namespace(accumulate=<built-in function sum>, integers=[1, 2, 3, 4])

-

-

-Custom namespaces

-^^^^^^^^^^^^^^^^^

-

-It may also be useful to have an ArgumentParser assign attributes to an already

-existing object, rather than the newly-created Namespace object that is

-normally used. This can be achieved by specifying the ``namespace=`` keyword

-argument::

-

-   >>> class C(object):

-   ...     pass

-   ...

-   >>> c = C()

-   >>> parser = argparse.ArgumentParser()

-   >>> parser.add_argument('--foo')

-   >>> parser.parse_args(args=['--foo', 'BAR'], namespace=c)

-   >>> c.foo

-   'BAR'

-

-

-Other utilities

----------------

-

-Sub-commands

-^^^^^^^^^^^^

-

-.. method:: add_subparsers()

-

-   A lot of programs split up their functionality into a number of

-   sub-commands, for example, the ``svn`` program can invoke sub-commands like

-   ``svn checkout``, ``svn update``, ``svn commit``, etc.  Splitting up

-   functionality this way can be a particularly good idea when a program

-   performs several different functions which require different kinds of

-   command-line arguments.  ArgumentParser objects support the creation of such

-   sub-commands with the :meth:`add_subparsers` method.  The

-   :meth:`add_subparsers` method is normally called with no arguments and

-   returns an special action object.  This object has a single method,

-   ``add_parser``, which takes a command name and any ArgumentParser

-   constructor arguments, and returns an ArgumentParser object that can be

-   modified as usual.

-

-   Some example usage::

-

-     >>> # create the top-level parser

-     >>> parser = argparse.ArgumentParser(prog='PROG')

-     >>> parser.add_argument('--foo', action='store_true', help='foo help')

-     >>> subparsers = parser.add_subparsers(help='sub-command help')

-     >>>

-     >>> # create the parser for the "a" command

-     >>> parser_a = subparsers.add_parser('a', help='a help')

-     >>> parser_a.add_argument('bar', type=int, help='bar help')

-     >>>

-     >>> # create the parser for the "b" command

-     >>> parser_b = subparsers.add_parser('b', help='b help')

-     >>> parser_b.add_argument('--baz', choices='XYZ', help='baz help')

-     >>>

-     >>> # parse some arg lists

-     >>> parser.parse_args(['a', '12'])

-     Namespace(bar=12, foo=False)

-     >>> parser.parse_args(['--foo', 'b', '--baz', 'Z'])

-     Namespace(baz='Z', foo=True)

-

-   Note that the object returned by :meth:`parse_args` will only contain

-   attributes for the main parser and the subparser that was selected by the

-   command line (and not any other subparsers).  So in the example above, when

-   the ``"a"`` command is specified, only the ``foo`` and ``bar`` attributes

-   are present, and when the ``"b"`` command is specified, only the ``foo`` and

-   ``baz`` attributes are present.

-

-   Similarly, when a help message is requested from a subparser, only the help

-   for that particular parser will be printed. The help message will not

-   include parent parser or sibling parser messages. (You can however supply a

-   help message for each subparser command by suppling the ``help=`` argument

-   to ``add_parser`` as above.)

-

-   ::

-

-     >>> parser.parse_args(['--help'])

-     usage: PROG [-h] [--foo] {a,b} ...

-

-     positional arguments:

-       {a,b}   sub-command help

-     a     a help

-     b     b help

-

-     optional arguments:

-       -h, --help  show this help message and exit

-       --foo   foo help

-

-     >>> parser.parse_args(['a', '--help'])

-     usage: PROG a [-h] bar

-

-     positional arguments:

-       bar     bar help

-

-     optional arguments:

-       -h, --help  show this help message and exit

-

-     >>> parser.parse_args(['b', '--help'])

-     usage: PROG b [-h] [--baz {X,Y,Z}]

-

-     optional arguments:

-       -h, --help     show this help message and exit

-       --baz {X,Y,Z}  baz help

-

-   The :meth:`add_subparsers` method also supports ``title`` and

-   ``description`` keyword arguments.  When either is present, the subparser's

-   commands will appear in their own group in the help output.  For example::

-

-     >>> parser = argparse.ArgumentParser()

-     >>> subparsers = parser.add_subparsers(title='subcommands',

-     ...                                    description='valid subcommands',

-     ...                                    help='additional help')

-     >>> subparsers.add_parser('foo')

-     >>> subparsers.add_parser('bar')

-     >>> parser.parse_args(['-h'])

-     usage:  [-h] {foo,bar} ...

-

-     optional arguments:

-       -h, --help  show this help message and exit

-

-     subcommands:

-       valid subcommands

-

-       {foo,bar}   additional help

-

-

-   One particularly effective way of handling sub-commands is to combine the

-   use of the :meth:`add_subparsers` method with calls to :meth:`set_defaults`

-   so that each subparser knows which Python function it should execute.  For

-   example::

-

-     >>> # sub-command functions

-     >>> def foo(args):

-     ...     print args.x * args.y

-     ...

-     >>> def bar(args):

-     ...     print '((%s))' % args.z

-     ...

-     >>> # create the top-level parser

-     >>> parser = argparse.ArgumentParser()

-     >>> subparsers = parser.add_subparsers()

-     >>>

-     >>> # create the parser for the "foo" command

-     >>> parser_foo = subparsers.add_parser('foo')

-     >>> parser_foo.add_argument('-x', type=int, default=1)

-     >>> parser_foo.add_argument('y', type=float)

-     >>> parser_foo.set_defaults(func=foo)

-     >>>

-     >>> # create the parser for the "bar" command

-     >>> parser_bar = subparsers.add_parser('bar')

-     >>> parser_bar.add_argument('z')

-     >>> parser_bar.set_defaults(func=bar)

-     >>>

-     >>> # parse the args and call whatever function was selected

-     >>> args = parser.parse_args('foo 1 -x 2'.split())

-     >>> args.func(args)

-     2.0

-     >>>

-     >>> # parse the args and call whatever function was selected

-     >>> args = parser.parse_args('bar XYZYX'.split())

-     >>> args.func(args)

-     ((XYZYX))

-

-   This way, you can let :meth:`parse_args` do all the work for you, and then

-   just call the appropriate function after the argument parsing is complete.

-   Associating functions with actions like this is typically the easiest way

-   to handle the different actions for each of your subparsers. However, if you

-   find it necessary to check the name of the subparser that was invoked, you

-   can always provide a ``dest`` keyword argument to the :meth:`add_subparsers`

-   call::

-

-     >>> parser = argparse.ArgumentParser()

-     >>> subparsers = parser.add_subparsers(dest='subparser_name')

-     >>> subparser1 = subparsers.add_parser('1')

-     >>> subparser1.add_argument('-x')

-     >>> subparser2 = subparsers.add_parser('2')

-     >>> subparser2.add_argument('y')

-     >>> parser.parse_args(['2', 'frobble'])

-     Namespace(subparser_name='2', y='frobble')

-

-

-FileType objects

-^^^^^^^^^^^^^^^^

-

-.. class:: FileType(mode='r', bufsize=None)

-

-   The :class:`FileType` factory creates objects that can be passed to the type

-   argument of :meth:`add_argument`. Arguments that have :class:`FileType`

-   objects as their type will open command-line args as files with the

-   requested modes and buffer sizes:

-

-   >>> parser = argparse.ArgumentParser()

-   >>> parser.add_argument('--output', type=argparse.FileType('wb', 0))

-   >>> parser.parse_args(['--output', 'out'])

-   Namespace(output=<open file 'out', mode 'wb' at 0x...>)

-

-   FileType objects understand the pseudo-argument ``'-'`` and automatically

-   convert this into ``sys.stdin`` for readable :class:`FileType` objects and

-   ``sys.stdout`` for writable :class:`FileType` objects:

-

-   >>> parser = argparse.ArgumentParser()

-   >>> parser.add_argument('infile', type=argparse.FileType('r'))

-   >>> parser.parse_args(['-'])

-   Namespace(infile=<open file '<stdin>', mode 'r' at 0x...>)

-

-

-Argument groups

-^^^^^^^^^^^^^^^

-

-.. method:: add_argument_group([title], [description])

-

-   By default, ArgumentParser objects group command-line arguments into

-   "positional arguments" and "optional arguments" when displaying help

-   messages. When there is a better conceptual grouping of arguments than this

-   default one, appropriate groups can be created using the

-   :meth:`add_argument_group` method::

-

-     >>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)

-     >>> group = parser.add_argument_group('group')

-     >>> group.add_argument('--foo', help='foo help')

-     >>> group.add_argument('bar', help='bar help')

-     >>> parser.print_help()

-     usage: PROG [--foo FOO] bar

-

-     group:

-       bar    bar help

-       --foo FOO  foo help

-

-   The :meth:`add_argument_group` method returns an argument group object which

-   has an :meth:`add_argument` method just like a regular ArgumentParser

-   objects. When an argument is added to the group, the parser treats it just

-   like a normal argument, but displays the argument in a separate group for

-   help messages. The :meth:`add_argument_group` method accepts ``title`` and

-   ``description`` arguments which can be used to customize this display::

-

-     >>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)

-     >>> group1 = parser.add_argument_group('group1', 'group1 description')

-     >>> group1.add_argument('foo', help='foo help')

-     >>> group2 = parser.add_argument_group('group2', 'group2 description')

-     >>> group2.add_argument('--bar', help='bar help')

-     >>> parser.print_help()

-     usage: PROG [--bar BAR] foo

-

-     group1:

-       group1 description

-

-       foo    foo help

-

-     group2:

-       group2 description

-

-       --bar BAR  bar help

-

-   Note that any arguments not in your user defined groups will end up back in

-   the usual "positional arguments" and "optional arguments" sections.

-

-

-Mutual exclusion

-^^^^^^^^^^^^^^^^

-

-.. method:: add_mutually_exclusive_group([required=False])

-

-   Sometimes, you need to make sure that only one of a couple different options

-   is specified on the command line. You can create groups of such mutually

-   exclusive arguments using the :meth:`add_mutually_exclusive_group` method.

-   When :func:`parse_args` is called, argparse will make sure that only one of

-   the arguments in the mutually exclusive group was present on the command

-   line::

-

-     >>> parser = argparse.ArgumentParser(prog='PROG')

-     >>> group = parser.add_mutually_exclusive_group()

-     >>> group.add_argument('--foo', action='store_true')

-     >>> group.add_argument('--bar', action='store_false')

-     >>> parser.parse_args(['--foo'])

-     Namespace(bar=True, foo=True)

-     >>> parser.parse_args(['--bar'])

-     Namespace(bar=False, foo=False)

-     >>> parser.parse_args(['--foo', '--bar'])

-     usage: PROG [-h] [--foo | --bar]

-     PROG: error: argument --bar: not allowed with argument --foo

-

-   The :meth:`add_mutually_exclusive_group` method also accepts a ``required``

-   argument, to indicate that at least one of the mutually exclusive arguments

-   is required::

-

-     >>> parser = argparse.ArgumentParser(prog='PROG')

-     >>> group = parser.add_mutually_exclusive_group(required=True)

-     >>> group.add_argument('--foo', action='store_true')

-     >>> group.add_argument('--bar', action='store_false')

-     >>> parser.parse_args([])

-     usage: PROG [-h] (--foo | --bar)

-     PROG: error: one of the arguments --foo --bar is required

-

-   Note that currently mutually exclusive argument groups do not support the

-   ``title`` and ``description`` arguments of :meth:`add_argument_group`. This

-   may change in the future however, so you are *strongly* recommended to

-   specify ``required`` as a keyword argument if you use it.

-

-

-Parser defaults

-^^^^^^^^^^^^^^^

-

-.. method:: set_defaults(**kwargs)

-

-   Most of the time, the attributes of the object returned by

-   :meth:`parse_args` will be fully determined by inspecting the command-line

-   args and the argument actions described in your :meth:`add_argument` calls.

-   However, sometimes it may be useful to add some additional attributes that

-   are determined without any inspection of the command-line.  The

-   :meth:`set_defaults` method allows you to do this::

-

-     >>> parser = argparse.ArgumentParser()

-     >>> parser.add_argument('foo', type=int)

-     >>> parser.set_defaults(bar=42, baz='badger')

-     >>> parser.parse_args(['736'])

-     Namespace(bar=42, baz='badger', foo=736)

-

-   Note that parser-level defaults always override argument-level defaults. So

-   if you set a parser-level default for a name that matches an argument, the

-   old argument default will no longer be used::

-

-     >>> parser = argparse.ArgumentParser()

-     >>> parser.add_argument('--foo', default='bar')

-     >>> parser.set_defaults(foo='spam')

-     >>> parser.parse_args([])

-     Namespace(foo='spam')

-

-   Parser-level defaults can be particularly useful when you're working with

-   multiple parsers.  See the :meth:`add_subparsers` method for an example of

-   this type.

-

-.. method:: get_default(dest)

-

-   Get the default value for a namespace attribute, as set by either

-   :meth:`add_argument` or by :meth:`set_defaults`::

-

-     >>> parser = argparse.ArgumentParser()

-     >>> parser.add_argument('--foo', default='badger')

-     >>> parser.get_default('foo')

-     'badger'

-

-

-Printing help

-^^^^^^^^^^^^^

-

-In most typical applications, :meth:`parse_args` will take care of formatting

-and printing any usage or error messages. However, should you want to format or

-print these on your own, several methods are available:

-

-.. method:: print_usage([file]):

-

-   Print a brief description of how the :class:`ArgumentParser` should be

-   invoked on the command line.  If ``file`` is not present, ``sys.stderr`` is

-   assumed.

-

-.. method:: print_help([file]):

-

-   Print a help message, including the program usage and information about the

-   arguments registered with the :class:`ArgumentParser`. If ``file`` is not

-   present, ``sys.stderr`` is assumed.

-

-There are also variants of these methods that simply return a string instead of

-printing it:

-

-.. method:: format_usage():

-

-   Return a string containing a brief description of how the

-   :class:`ArgumentParser` should be invoked on the command line.

-

-.. method:: format_help():

-

-   Return a string containing a help message, including the program usage and

-   information about the arguments registered with the :class:`ArgumentParser`.

-

-

-

-Partial parsing

-^^^^^^^^^^^^^^^

-

-.. method:: parse_known_args([args], [namespace])

-

-Sometimes a script may only parse a few of the command line arguments, passing

-the remaining arguments on to another script or program. In these cases, the

-:meth:`parse_known_args` method can be useful. It works much like

-:meth:`parse_args` except that it does not produce an error when extra

-arguments are present. Instead, it returns a two item tuple containing the

-populated namespace and the list of remaining argument strings.

-

-::

-

-   >>> parser = argparse.ArgumentParser()

-   >>> parser.add_argument('--foo', action='store_true')

-   >>> parser.add_argument('bar')

-   >>> parser.parse_known_args(['--foo', '--badger', 'BAR', 'spam'])

-   (Namespace(bar='BAR', foo=True), ['--badger', 'spam'])

-

-

-Customizing file parsing

-^^^^^^^^^^^^^^^^^^^^^^^^

-

-.. method:: convert_arg_line_to_args(arg_line)

-

-   Arguments that are read from a file (see the ``fromfile_prefix_chars``

-   keyword argument to the :class:`ArgumentParser` constructor) are read one

-   argument per line.  If you need fancier parsing, then you can subclass the

-   :class:`ArgumentParser` and override the :meth:`convert_arg_line_to_args`

-   method.

-

-   This method takes a single argument ``arg_line`` which is a string read from

-   the argument file.  It returns a list of arguments parsed from this string.

-   The method is called once per line read from the argument file, in order.

-

-   A useful override of this method is one that treats each space-separated

-   word as an argument::

-

-    def convert_arg_line_to_args(self, arg_line):

-        for arg in arg_line.split():

-            if not arg.strip():

-                continue

-            yield arg

-

-

-Upgrading optparse code

------------------------

-

-Originally, the argparse module had attempted to maintain compatibility with

- optparse. However, optparse was difficult to extend transparently,

- particularly with the changes required to support the new ``nargs=``

- specifiers and better usage messges. When most everything in optparse had

- either been copy-pasted over or monkey-patched, it no longer seemed practical

- to try to maintain the backwards compatibility.

-

-A partial upgrade path from optparse to argparse:

-

-* Replace all ``add_option()`` calls with :meth:`add_argument` calls.

-

-* Replace ``options, args = parser.parse_args()`` with

-  ``args = parser.parse_args()`` and add additional :meth:`add_argument` calls

-  for the positional arguments.

-

-* Replace callback actions and the ``callback_*`` keyword arguments with

-  ``type`` or ``action`` arguments.

-

-* Replace string names for ``type`` keyword arguments with the corresponding

-  type objects (e.g. int, float, complex, etc).

-

-* Replace ``Values`` with ``Namespace`` and ``OptionError/OptionValueError``

-  with ``ArgumentError``.

-

-* Replace strings with implicit arguments such as ``%default`` or ``%prog``

-  with the standard python syntax to use dictionaries to format strings, that

-  is, ``%(default)s`` and ``%(prog)s``.

+:mod:`argparse` -- Parser for command line options, arguments and sub-commands
+==============================================================================
+
+.. module:: argparse
+   :synopsis: Command-line option and argument parsing library.
+.. moduleauthor:: Steven Bethard <steven.bethard@gmail.com>
+.. versionadded:: 2.7
+.. sectionauthor:: Steven Bethard <steven.bethard@gmail.com>
+
+
+The :mod:`argparse` module makes it easy to write user friendly command line
+interfaces. You define what arguments your program requires, and
+:mod:`argparse` will figure out how to parse those out of ``sys.argv``. The
+:mod:`argparse` module also automatically generates help and usage messages
+based on the arguments you have defined, and issues errors when users give your
+program invalid arguments.
+
+Example
+-------
+
+As an example, the following code is a Python program that takes a list of
+integers and produces either the sum or the max::
+
+   import argparse
+
+   parser = argparse.ArgumentParser(description='Process some integers.')
+   parser.add_argument('integers', metavar='N', type=int, nargs='+',
+                      help='an integer for the accumulator')
+   parser.add_argument('--sum', dest='accumulate', action='store_const',
+                      const=sum, default=max,
+                      help='sum the integers (default: find the max)')
+
+   args = parser.parse_args()
+   print args.accumulate(args.integers)
+
+Assuming the Python code above is saved into a file called ``prog.py``, it can
+be run at the command line and provides useful help messages::
+
+   $ prog.py -h
+   usage: prog.py [-h] [--sum] N [N ...]
+
+   Process some integers.
+
+   positional arguments:
+    N           an integer for the accumulator
+
+   optional arguments:
+    -h, --help  show this help message and exit
+    --sum       sum the integers (default: find the max)
+
+When run with the appropriate arguments, it prints either the sum or the max of
+the command-line integers::
+
+   $ prog.py 1 2 3 4
+   4
+
+   $ prog.py 1 2 3 4 --sum
+   10
+
+If invalid arguments are passed in, it will issue an error::
+
+   $ prog.py a b c
+   usage: prog.py [-h] [--sum] N [N ...]
+   prog.py: error: argument N: invalid int value: 'a'
+
+The following sections walk you through this example.
+
+Creating a parser
+^^^^^^^^^^^^^^^^^
+
+Pretty much every script that uses the :mod:`argparse` module will start out by
+creating an :class:`ArgumentParser` object::
+
+   >>> parser = argparse.ArgumentParser(description='Process some integers.')
+
+The :class:`ArgumentParser` object will hold all the information necessary to
+parse the command line into a more manageable form for your program.
+
+
+Adding arguments
+^^^^^^^^^^^^^^^^
+
+Once you've created an :class:`ArgumentParser`, you'll want to fill it with
+information about your program arguments. You typically do this by making calls
+to the :meth:`add_argument` method.  Generally, these calls tell the
+:class:`ArgumentParser` how to take the strings on the command line and turn
+them into objects for you. This information is stored and used when
+:meth:`parse_args` is called. For example, if we add some arguments like this::
+
+   >>> parser.add_argument('integers', metavar='N', type=int, nargs='+',
+   ...                     help='an integer for the accumulator')
+   >>> parser.add_argument('--sum', dest='accumulate', action='store_const',
+   ...                     const=sum, default=max,
+   ...                     help='sum the integers (default: find the max)')
+
+when we later call :meth:`parse_args`, we can expect it to return an object
+with two attributes, ``integers`` and ``accumulate``.  The ``integers``
+attribute will be a list of one or more ints, and the ``accumulate`` attribute
+will be either the ``sum`` function, if ``--sum`` was specified at the command
+line, or the ``max`` function if it was not.
+
+Parsing arguments
+^^^^^^^^^^^^^^^^^
+
+Once an :class:`ArgumentParser` has been initialized with appropriate calls to
+:meth:`add_argument`, it can be instructed to parse the command-line args by
+calling the :meth:`parse_args` method.  This will inspect the command-line,
+convert each arg to the appropriate type and then invoke the appropriate
+action.  In most cases, this means a simple namespace object will be built up
+from attributes parsed out of the command-line::
+
+   >>> parser.parse_args(['--sum', '7', '-1', '42'])
+   Namespace(accumulate=<built-in function sum>, integers=[7, -1, 42])
+
+In a script, :meth:`parse_args` will typically be called with no arguments, and
+the :class:`ArgumentParser` will automatically determine the command-line args
+from ``sys.argv``. That's pretty much it. You're now ready to go write some
+command line interfaces!
+
+
+ArgumentParser objects
+----------------------
+
+.. class:: ArgumentParser([description], [epilog], [prog], [usage], [add_help], [argument_default], [parents], [prefix_chars], [conflict_handler], [formatter_class])
+
+   Create a new :class:`ArgumentParser` object. Each parameter has its own more
+   detailed description below, but in short they are:
+
+   * description_ - Text to display before the argument help.
+
+   * epilog_ - Text to display after the argument help.
+
+   * add_help_ - Add a -h/--help option to the parser. (default: True)
+
+   * argument_default_ - Set the global default value for arguments.
+     (default: None)
+
+   * parents_ - A list of :class:ArgumentParser objects whose arguments should
+     also be included.
+
+   * prefix_chars_ - The set of characters that prefix optional arguments.
+     (default: '-')
+
+   * fromfile_prefix_chars_ - The set of characters that prefix files from
+     which additional arguments should be read. (default: None)
+
+   * formatter_class_ - A class for customizing the help output.
+
+   * conflict_handler_ - Usually unnecessary, defines strategy for resolving
+     conflicting optionals.
+
+   * prog_ - Usually unnecessary, the name of the program
+     (default: ``sys.argv[0]``)
+
+   * usage_ - Usually unnecessary, the string describing the program usage
+     (default: generated)
+
+   The following sections describe how each of these are used.
+
+
+description
+^^^^^^^^^^^
+
+Most calls to the ArgumentParser constructor will use the ``description=``
+keyword argument. This argument gives a brief description of what the program
+does and how it works. In help messages, the description is displayed between
+the command-line usage string and the help messages for the various arguments::
+
+   >>> parser = argparse.ArgumentParser(description='A foo that bars')
+   >>> parser.print_help()
+   usage: argparse.py [-h]
+
+   A foo that bars
+
+   optional arguments:
+    -h, --help  show this help message and exit
+
+By default, the description will be line-wrapped so that it fits within the
+given space. To change this behavior, see the formatter_class_ argument.
+
+
+epilog
+^^^^^^
+
+Some programs like to display additional description of the program after the
+description of the arguments. Such text can be specified using the ``epilog=``
+argument to ArgumentParser::
+
+   >>> parser = argparse.ArgumentParser(
+   ...     description='A foo that bars',
+   ...     epilog="And that's how you'd foo a bar")
+   >>> parser.print_help()
+   usage: argparse.py [-h]
+
+   A foo that bars
+
+   optional arguments:
+    -h, --help  show this help message and exit
+
+   And that's how you'd foo a bar
+
+As with the description_ argument, the ``epilog=`` text is by default
+line-wrapped, but this behavior can be adjusted with the formatter_class_
+argument to ArgumentParser.
+
+
+add_help
+^^^^^^^^
+
+By default, ArgumentParser objects add a ``-h/--help`` option which simply
+displays the parser's help message. For example, consider a file named
+``myprogram.py`` containing the following code::
+
+   import argparse
+   parser = argparse.ArgumentParser()
+   parser.add_argument('--foo', help='foo help')
+   args = parser.parse_args()
+
+If ``-h`` or ``--help`` is supplied is at the command-line, the ArgumentParser
+help will be printed::
+
+   $ python myprogram.py --help
+   usage: myprogram.py [-h] [--foo FOO]
+
+   optional arguments:
+    -h, --help  show this help message and exit
+    --foo FOO   foo help
+
+Occasionally, it may be useful to disable the addition of this help option.
+This can be achieved by passing ``False`` as the ``add_help=`` argument to
+ArgumentParser::
+
+   >>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)
+   >>> parser.add_argument('--foo', help='foo help')
+   >>> parser.print_help()
+   usage: PROG [--foo FOO]
+
+   optional arguments:
+    --foo FOO  foo help
+
+
+prefix_chars
+^^^^^^^^^^^^
+
+Most command-line options will use ``'-'`` as the prefix, e.g. ``-f/--foo``.
+Parsers that need to support additional prefix characters, e.g. for options
+like ``+f`` or ``/foo``, may specify them using the ``prefix_chars=`` argument
+to the ArgumentParser constructor::
+
+   >>> parser = argparse.ArgumentParser(prog='PROG', prefix_chars='-+')
+   >>> parser.add_argument('+f')
+   >>> parser.add_argument('++bar')
+   >>> parser.parse_args('+f X ++bar Y'.split())
+   Namespace(bar='Y', f='X')
+
+The ``prefix_chars=`` argument defaults to ``'-'``. Supplying a set of
+characters that does not include ``'-'`` will cause ``-f/--foo`` options to be
+disallowed.
+
+
+fromfile_prefix_chars
+^^^^^^^^^^^^^^^^^^^^^
+
+Sometimes, e.g. for particularly long argument lists, it may make sense to
+keep the list of arguments in a file rather than typing it out at the command
+line. If the ``fromfile_prefix_chars=`` argument is given to the ArgumentParser
+constructor, then arguments that start with any of the specified characters
+will be treated as files, and will be replaced by the arguments they contain.
+For example::
+
+   >>> open('args.txt', 'w').write('-f\nbar')
+   >>> parser = argparse.ArgumentParser(fromfile_prefix_chars='@')
+   >>> parser.add_argument('-f')
+   >>> parser.parse_args(['-f', 'foo', '@args.txt'])
+   Namespace(f='bar')
+
+Arguments read from a file must by default be one per line (but see also
+:meth:`convert_arg_line_to_args`) and are treated as if they were in the same
+place as the original file referencing argument on the command line. So in the
+example above, the expression ``['-f', 'foo', '@args.txt']`` is considered
+equivalent to the expression ``['-f', 'foo', '-f', 'bar']``.
+
+The ``fromfile_prefix_chars=`` argument defaults to ``None``, meaning that
+arguments will never be treated as file references.
+
+argument_default
+^^^^^^^^^^^^^^^^
+
+Generally, argument defaults are specified either by passing a default to
+:meth:`add_argument` or by calling the :meth:`set_defaults` methods with a
+specific set of name-value pairs. Sometimes however, it may be useful to
+specify a single parser-wide default for arguments. This can be accomplished by
+passing the ``argument_default=`` keyword argument to ArgumentParser. For
+example, to globally suppress attribute creation on :meth:`parse_args` calls,
+we supply ``argument_default=SUPPRESS``::
+
+   >>> parser = argparse.ArgumentParser(argument_default=argparse.SUPPRESS)
+   >>> parser.add_argument('--foo')
+   >>> parser.add_argument('bar', nargs='?')
+   >>> parser.parse_args(['--foo', '1', 'BAR'])
+   Namespace(bar='BAR', foo='1')
+   >>> parser.parse_args([])
+   Namespace()
+
+
+parents
+^^^^^^^
+
+Sometimes, several parsers share a common set of arguments. Rather than
+repeating the definitions of these arguments, you can define a single parser
+with all the shared arguments and then use the ``parents=`` argument to
+ArgumentParser to have these "inherited". The ``parents=`` argument takes a
+list of ArgumentParser objects, collects all the positional and optional
+actions from them, and adds these actions to the ArgumentParser object being
+constructed::
+
+   >>> parent_parser = argparse.ArgumentParser(add_help=False)
+   >>> parent_parser.add_argument('--parent', type=int)
+
+   >>> foo_parser = argparse.ArgumentParser(parents=[parent_parser])
+   >>> foo_parser.add_argument('foo')
+   >>> foo_parser.parse_args(['--parent', '2', 'XXX'])
+   Namespace(foo='XXX', parent=2)
+
+   >>> bar_parser = argparse.ArgumentParser(parents=[parent_parser])
+   >>> bar_parser.add_argument('--bar')
+   >>> bar_parser.parse_args(['--bar', 'YYY'])
+   Namespace(bar='YYY', parent=None)
+
+Note that most parent parsers will specify ``add_help=False``. Otherwise, the
+ArgumentParser will see two ``-h/--help`` options (one in the parent and one in
+the child) and raise an error.
+
+
+formatter_class
+^^^^^^^^^^^^^^^
+
+ArgumentParser objects allow the help formatting to be customized by specifying
+an alternate formatting class. Currently, there are three such classes:
+``argparse.RawDescriptionHelpFormatter``, ``argparse.RawTextHelpFormatter`` and
+``argparse.ArgumentDefaultsHelpFormatter``. The first two allow more control
+over how textual descriptions are displayed, while the last automatically adds
+information about argument default values.
+
+By default, ArgumentParser objects line-wrap the description_ and epilog_ texts
+in command-line help messages::
+
+   >>> parser = argparse.ArgumentParser(
+   ...     prog='PROG',
+   ...     description='''this description
+   ...         was indented weird
+   ...             but that is okay''',
+   ...     epilog='''
+   ...             likewise for this epilog whose whitespace will
+   ...         be cleaned up and whose words will be wrapped
+   ...         across a couple lines''')
+   >>> parser.print_help()
+   usage: PROG [-h]
+
+   this description was indented weird but that is okay
+
+   optional arguments:
+    -h, --help  show this help message and exit
+
+   likewise for this epilog whose whitespace will be cleaned up and whose words
+   will be wrapped across a couple lines
+
+When you have description_ and epilog_ that is already correctly formatted and
+should not be line-wrapped, you can indicate this by passing
+``argparse.RawDescriptionHelpFormatter`` as the ``formatter_class=`` argument
+to ArgumentParser::
+
+   >>> parser = argparse.ArgumentParser(
+   ...     prog='PROG',
+   ...     formatter_class=argparse.RawDescriptionHelpFormatter,
+   ...     description=textwrap.dedent('''\
+   ...         Please do not mess up this text!
+   ...         --------------------------------
+   ...             I have indented it
+   ...             exactly the way
+   ...             I want it
+   ...         '''))
+   >>> parser.print_help()
+   usage: PROG [-h]
+
+   Please do not mess up this text!
+   --------------------------------
+      I have indented it
+      exactly the way
+      I want it
+
+   optional arguments:
+    -h, --help  show this help message and exit
+
+If you want to maintain whitespace for all sorts of help text (including
+argument descriptions), you can use ``argparse.RawTextHelpFormatter``.
+
+The other formatter class available,
+``argparse.ArgumentDefaultsHelpFormatter``, will add information about the
+default value of each of the arguments::
+
+   >>> parser = argparse.ArgumentParser(
+   ...     prog='PROG',
+   ...     formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+   >>> parser.add_argument('--foo', type=int, default=42, help='FOO!')
+   >>> parser.add_argument('bar', nargs='*', default=[1, 2, 3], help='BAR!')
+   >>> parser.print_help()
+   usage: PROG [-h] [--foo FOO] [bar [bar ...]]
+
+   positional arguments:
+    bar         BAR! (default: [1, 2, 3])
+
+   optional arguments:
+    -h, --help  show this help message and exit
+    --foo FOO   FOO! (default: 42)
+
+
+conflict_handler
+^^^^^^^^^^^^^^^^
+
+ArgumentParser objects do not allow two actions with the same option string.
+By default, ArgumentParser objects will raise an exception if you try to create
+an argument with an option string that is already in use::
+
+   >>> parser = argparse.ArgumentParser(prog='PROG')
+   >>> parser.add_argument('-f', '--foo', help='old foo help')
+   >>> parser.add_argument('--foo', help='new foo help')
+   Traceback (most recent call last):
+    ..
+   ArgumentError: argument --foo: conflicting option string(s): --foo
+
+Sometimes (e.g. when using parents_) it may be useful to simply override any
+older arguments with the same option string. To get this behavior, the value
+``'resolve'`` can be supplied to the ``conflict_handler=`` argument of
+ArgumentParser::
+
+   >>> parser = argparse.ArgumentParser(prog='PROG', conflict_handler='resolve')
+   >>> parser.add_argument('-f', '--foo', help='old foo help')
+   >>> parser.add_argument('--foo', help='new foo help')
+   >>> parser.print_help()
+   usage: PROG [-h] [-f FOO] [--foo FOO]
+
+   optional arguments:
+    -h, --help  show this help message and exit
+    -f FOO      old foo help
+    --foo FOO   new foo help
+
+Note that ArgumentParser objects only remove an action if all of its option
+strings are overridden. So, in the example above, the old ``-f/--foo`` action
+is retained as the ``-f`` action, because only the ``--foo`` option string was
+overridden.
+
+
+prog
+^^^^
+
+By default, ArgumentParser objects use ``sys.argv[0]`` to determine how to
+display the name of the program in help messages. This default is almost always
+what you want because it will make the help messages match what your users have
+typed at the command line. For example, consider a file named ``myprogram.py``
+with the following code::
+
+   import argparse
+   parser = argparse.ArgumentParser()
+   parser.add_argument('--foo', help='foo help')
+   args = parser.parse_args()
+
+The help for this program will display ``myprogram.py`` as the program name
+(regardless of where the program was invoked from)::
+
+   $ python myprogram.py --help
+   usage: myprogram.py [-h] [--foo FOO]
+
+   optional arguments:
+    -h, --help  show this help message and exit
+    --foo FOO   foo help
+   $ cd ..
+   $ python subdir\myprogram.py --help
+   usage: myprogram.py [-h] [--foo FOO]
+
+   optional arguments:
+    -h, --help  show this help message and exit
+    --foo FOO   foo help
+
+To change this default behavior, another value can be supplied using the
+``prog=`` argument to ArgumentParser::
+
+   >>> parser = argparse.ArgumentParser(prog='myprogram')
+   >>> parser.print_help()
+   usage: myprogram [-h]
+
+   optional arguments:
+    -h, --help  show this help message and exit
+
+Note that the program name, whether determined from ``sys.argv[0]`` or from the
+``prog=`` argument, is available to help messages using the ``%(prog)s`` format
+specifier.
+
+::
+
+   >>> parser = argparse.ArgumentParser(prog='myprogram')
+   >>> parser.add_argument('--foo', help='foo of the %(prog)s program')
+   >>> parser.print_help()
+   usage: myprogram [-h] [--foo FOO]
+
+   optional arguments:
+    -h, --help  show this help message and exit
+    --foo FOO   foo of the myprogram program
+
+
+usage
+^^^^^
+
+By default, ArgumentParser objects calculate the usage message from the
+arguments it contains::
+
+   >>> parser = argparse.ArgumentParser(prog='PROG')
+   >>> parser.add_argument('--foo', nargs='?', help='foo help')
+   >>> parser.add_argument('bar', nargs='+', help='bar help')
+   >>> parser.print_help()
+   usage: PROG [-h] [--foo [FOO]] bar [bar ...]
+
+   positional arguments:
+    bar          bar help
+
+   optional arguments:
+    -h, --help   show this help message and exit
+    --foo [FOO]  foo help
+
+If the default usage message is not appropriate for your application, you can
+supply your own usage message using the ``usage=`` keyword argument to
+ArgumentParser::
+
+   >>> parser = argparse.ArgumentParser(prog='PROG', usage='%(prog)s [options]')
+   >>> parser.add_argument('--foo', nargs='?', help='foo help')
+   >>> parser.add_argument('bar', nargs='+', help='bar help')
+   >>> parser.print_help()
+   usage: PROG [options]
+
+   positional arguments:
+    bar          bar help
+
+   optional arguments:
+    -h, --help   show this help message and exit
+    --foo [FOO]  foo help
+
+Note you can use the ``%(prog)s`` format specifier to fill in the program name
+in your usage messages.
+
+
+The add_argument() method
+-------------------------
+
+.. method:: add_argument(name or flags..., [action], [nargs], [const], [default], [type], [choices], [required], [help], [metavar], [dest])
+
+   Define how a single command line argument should be parsed. Each parameter
+   has its own more detailed description below, but in short they are:
+
+   * `name or flags`_ - Either a name or a list of option strings, e.g. ``foo``
+     or ``-f, --foo``
+
+   * action_ - The basic type of action to be taken when this argument is
+     encountered at the command-line.
+
+   * nargs_ - The number of command-line arguments that should be consumed.
+
+   * const_ - A constant value required by some action_ and nargs_ selections.
+
+   * default_ - The value produced if the argument is absent from the
+     command-line.
+
+   * type_ - The type to which the command-line arg should be converted.
+
+   * choices_ - A container of the allowable values for the argument.
+
+   * required_ - Whether or not the command-line option may be omitted
+     (optionals only).
+
+   * help_ - A brief description of what the argument does.
+
+   * metavar_ - A name for the argument in usage messages.
+
+   * dest_ - The name of the attribute to be added to the object returned by
+     :meth:`parse_args`.
+
+   The following sections describe how each of these are used.
+
+name or flags
+^^^^^^^^^^^^^
+
+The :meth:`add_argument` method needs to know whether you're expecting an
+optional argument, e.g. ``-f`` or ``--foo``, or a positional argument, e.g. a
+list of filenames. The first arguments passed to :meth:`add_argument` must
+therefore be either a series of flags, or a simple argument name. For example,
+an optional argument could be created like::
+
+   >>> parser.add_argument('-f', '--foo')
+
+while a positional argument could be created like::
+
+   >>> parser.add_argument('bar')
+
+When :meth:`parse_args` is called, optional arguments will be identified by the
+``-`` prefix, and the remaining arguments will be assumed to be positional::
+
+   >>> parser = argparse.ArgumentParser(prog='PROG')
+   >>> parser.add_argument('-f', '--foo')
+   >>> parser.add_argument('bar')
+   >>> parser.parse_args(['BAR'])
+   Namespace(bar='BAR', foo=None)
+   >>> parser.parse_args(['BAR', '--foo', 'FOO'])
+   Namespace(bar='BAR', foo='FOO')
+   >>> parser.parse_args(['--foo', 'FOO'])
+   usage: PROG [-h] [-f FOO] bar
+   PROG: error: too few arguments
+
+action
+^^^^^^
+
+:class:`ArgumentParser` objects associate command-line args with actions. These
+actions can do just about anything with the command-line args associated with
+them, though most actions simply add an attribute to the object returned by
+:meth:`parse_args`.  When you specify a new argument using the
+:meth:`add_argument` method, you can indicate how the command-line args should
+be handled by specifying the ``action`` keyword argument. The supported actions
+are:
+
+* ``'store'`` - This just stores the argument's value. This is the default
+   action. For example::
+
+    >>> parser = argparse.ArgumentParser()
+    >>> parser.add_argument('--foo')
+    >>> parser.parse_args('--foo 1'.split())
+    Namespace(foo='1')
+
+* ``'store_const'`` - This stores the value specified by the const_ keyword
+   argument. Note that the const_ keyword argument defaults to ``None``, so
+   you'll almost always need to provide a value for it. The ``'store_const'``
+   action is most commonly used with optional arguments that specify some sort
+   of flag.  For example::
+
+    >>> parser = argparse.ArgumentParser()
+    >>> parser.add_argument('--foo', action='store_const', const=42)
+    >>> parser.parse_args('--foo'.split())
+    Namespace(foo=42)
+
+* ``'store_true'`` and ``'store_false'`` - These store the values ``True`` and
+  ``False`` respectively.  These are basically special cases of
+  ``'store_const'``.  For example::
+
+    >>> parser = argparse.ArgumentParser()
+    >>> parser.add_argument('--foo', action='store_true')
+    >>> parser.add_argument('--bar', action='store_false')
+    >>> parser.parse_args('--foo --bar'.split())
+    Namespace(bar=False, foo=True)
+
+* ``'append'`` - This stores a list, and appends each argument value to the
+  list.  This is useful when you want to allow an option to be specified
+  multiple times.  Example usage::
+
+    >>> parser = argparse.ArgumentParser()
+    >>> parser.add_argument('--foo', action='append')
+    >>> parser.parse_args('--foo 1 --foo 2'.split())
+    Namespace(foo=['1', '2'])
+
+* ``'append_const'`` - This stores a list, and appends the value specified by
+  the const_ keyword argument to the list.  Note that the const_ keyword
+  argument defaults to ``None``, so you'll almost always need to provide a
+  value for it.  The ``'append_const'`` action is typically useful when you
+  want multiple arguments to store constants to the same list, for example::
+
+    >>> parser = argparse.ArgumentParser()
+    >>> parser.add_argument('--str', dest='types', action='append_const', const=str)
+    >>> parser.add_argument('--int', dest='types', action='append_const', const=int)
+    >>> parser.parse_args('--str --int'.split())
+    Namespace(types=[<type 'str'>, <type 'int'>])
+
+* ``'version'`` - This expects a ``version=`` keyword argument in the
+  :meth:`add_argument` call, and prints version information and exits when
+  invoked.
+
+    >>> import argparse
+    >>> parser = argparse.ArgumentParser(prog='PROG')
+    >>> parser.add_argument('-v', '--version', action='version', version='%(prog)s 2.0')
+    >>> parser.parse_args(['-v'])
+    PROG 2.0
+
+You can also specify an arbitrary action by passing an object that implements
+the Action API.  The easiest way to do this is to extend ``argparse.Action``,
+supplying an appropriate ``__call__`` method.  The ``__call__`` method accepts
+four parameters:
+
+* ``parser`` - The ArgumentParser object which contains this action.
+
+* ``namespace`` - The namespace object that will be returned by
+  :meth:`parse_args`. Most actions add an attribute to this object.
+
+* ``values`` - The associated command-line args, with any type-conversions
+  applied.  (Type-conversions are specified with the type_ keyword argument to
+  :meth:`add_argument`.
+
+* ``option_string`` - The option string that was used to invoke this action.
+  The ``option_string`` argument is optional, and will be absent if the action
+  is associated with a positional argument.
+
+So for example::
+
+   >>> class FooAction(argparse.Action):
+   ...     def __call__(self, parser, namespace, values, option_string=None):
+   ...     print '%r %r %r' % (namespace, values, option_string)
+   ...     setattr(namespace, self.dest, values)
+   ...
+   >>> parser = argparse.ArgumentParser()
+   >>> parser.add_argument('--foo', action=FooAction)
+   >>> parser.add_argument('bar', action=FooAction)
+   >>> args = parser.parse_args('1 --foo 2'.split())
+   Namespace(bar=None, foo=None) '1' None
+   Namespace(bar='1', foo=None) '2' '--foo'
+   >>> args
+   Namespace(bar='1', foo='2')
+
+
+nargs
+^^^^^
+
+ArgumentParser objects usually associate a single command-line argument with a
+single action to be taken.  In the situations where you'd like to associate a
+different number of command-line arguments with a single action, you can use
+the ``nargs`` keyword argument to :meth:`add_argument`. The supported values
+are:
+
+* N (an integer). N args from the command-line will be gathered together into
+  a list.  For example::
+
+    >>> parser = argparse.ArgumentParser()
+    >>> parser.add_argument('--foo', nargs=2)
+    >>> parser.add_argument('bar', nargs=1)
+    >>> parser.parse_args('c --foo a b'.split())
+    Namespace(bar=['c'], foo=['a', 'b'])
+
+   Note that ``nargs=1`` produces a list of one item.  This is different from
+   the default, in which the item is produced by itself.
+
+* ``'?'``. One arg will be consumed from the command-line if possible, and
+  produced as a single item.  If no command-line arg is present, the value from
+  default_ will be produced.  Note that for optional arguments, there is an
+  additional case - the option string is present but not followed by a
+  command-line arg.  In this case the value from const_ will be produced.  Some
+  examples to illustrate this::
+
+    >>> parser = argparse.ArgumentParser()
+    >>> parser.add_argument('--foo', nargs='?', const='c', default='d')
+    >>> parser.add_argument('bar', nargs='?', default='d')
+    >>> parser.parse_args('XX --foo YY'.split())
+    Namespace(bar='XX', foo='YY')
+    >>> parser.parse_args('XX --foo'.split())
+    Namespace(bar='XX', foo='c')
+    >>> parser.parse_args(''.split())
+    Namespace(bar='d', foo='d')
+
+   One of the more common uses of ``nargs='?'`` is to allow optional input and
+   output files::
+
+    >>> parser = argparse.ArgumentParser()
+    >>> parser.add_argument('infile', nargs='?', type=argparse.FileType('r'), default=sys.stdin)
+    >>> parser.add_argument('outfile', nargs='?', type=argparse.FileType('w'), default=sys.stdout)
+    >>> parser.parse_args(['input.txt', 'output.txt'])
+    Namespace(infile=<open file 'input.txt', mode 'r' at 0x...>, outfile=<open file 'output.txt', mode 'w' at 0x...>)
+    >>> parser.parse_args([])
+    Namespace(infile=<open file '<stdin>', mode 'r' at 0x...>, outfile=<open file '<stdout>', mode 'w' at 0x...>)
+
+* ``'*'``. All command-line args present are gathered into a list. Note that
+  it generally doesn't make much sense to have more than one positional
+  argument with ``nargs='*'``, but multiple optional arguments with
+  ``nargs='*'`` is possible.  For example::
+
+    >>> parser = argparse.ArgumentParser()
+    >>> parser.add_argument('--foo', nargs='*')
+    >>> parser.add_argument('--bar', nargs='*')
+    >>> parser.add_argument('baz', nargs='*')
+    >>> parser.parse_args('a b --foo x y --bar 1 2'.split())
+    Namespace(bar=['1', '2'], baz=['a', 'b'], foo=['x', 'y'])
+
+* ``'+'``. Just like ``'*'``, all command-line args present are gathered into a
+  list.  Additionally, an error message will be generated if there wasn't at
+  least one command-line arg present.  For example::
+
+    >>> parser = argparse.ArgumentParser(prog='PROG')
+    >>> parser.add_argument('foo', nargs='+')
+    >>> parser.parse_args('a b'.split())
+    Namespace(foo=['a', 'b'])
+    >>> parser.parse_args(''.split())
+    usage: PROG [-h] foo [foo ...]
+    PROG: error: too few arguments
+
+If the ``nargs`` keyword argument is not provided, the number of args consumed
+is determined by the action_. Generally this means a single command-line arg
+will be consumed and a single item (not a list) will be produced.
+
+
+const
+^^^^^
+
+The ``const`` argument of :meth:`add_argument` is used to hold constant values
+that are not read from the command line but are required for the various
+ArgumentParser actions.  The two most common uses of it are:
+
+* When :meth:`add_argument` is called with ``action='store_const'`` or
+  ``action='append_const'``.  These actions add the ``const`` value to one of
+  the attributes of the object returned by :meth:`parse_args`.  See the action_
+  description for examples.
+
+* When :meth:`add_argument` is called with option strings (like ``-f`` or
+  ``--foo``) and ``nargs='?'``. This creates an optional argument that can be
+  followed by zero or one command-line args.  When parsing the command-line, if
+  the option string is encountered with no command-line arg following it, the
+  value of ``const`` will be assumed instead. See the nargs_ description for
+  examples.
+
+The ``const`` keyword argument defaults to ``None``.
+
+
+default
+^^^^^^^
+
+All optional arguments and some positional arguments may be omitted at the
+command-line.  The ``default`` keyword argument of :meth:`add_argument`, whose
+value defaults to ``None``, specifies what value should be used if the
+command-line arg is not present.  For optional arguments, the ``default`` value
+is used when the option string was not present at the command line::
+
+   >>> parser = argparse.ArgumentParser()
+   >>> parser.add_argument('--foo', default=42)
+   >>> parser.parse_args('--foo 2'.split())
+   Namespace(foo='2')
+   >>> parser.parse_args(''.split())
+   Namespace(foo=42)
+
+For positional arguments with nargs_ ``='?'`` or ``'*'``, the ``default`` value
+is used when no command-line arg was present::
+
+   >>> parser = argparse.ArgumentParser()
+   >>> parser.add_argument('foo', nargs='?', default=42)
+   >>> parser.parse_args('a'.split())
+   Namespace(foo='a')
+   >>> parser.parse_args(''.split())
+   Namespace(foo=42)
+
+
+If you don't want to see an attribute when an option was not present at the
+command line, you can supply ``default=argparse.SUPPRESS``::
+
+   >>> parser = argparse.ArgumentParser()
+   >>> parser.add_argument('--foo', default=argparse.SUPPRESS)
+   >>> parser.parse_args([])
+   Namespace()
+   >>> parser.parse_args(['--foo', '1'])
+   Namespace(foo='1')
+
+
+type
+^^^^
+
+By default, ArgumentParser objects read command-line args in as simple strings.
+However, quite often the command-line string should instead be interpreted as
+another type, e.g. ``float``, ``int`` or ``file``. The ``type`` keyword
+argument of :meth:`add_argument` allows any necessary type-checking and
+type-conversions to be performed.  Many common builtin types can be used
+directly as the value of the ``type`` argument::
+
+   >>> parser = argparse.ArgumentParser()
+   >>> parser.add_argument('foo', type=int)
+   >>> parser.add_argument('bar', type=file)
+   >>> parser.parse_args('2 temp.txt'.split())
+   Namespace(bar=<open file 'temp.txt', mode 'r' at 0x...>, foo=2)
+
+To ease the use of various types of files, the argparse module provides the
+factory FileType which takes the ``mode=`` and ``bufsize=`` arguments of the
+``file`` object. For example, ``FileType('w')`` can be used to create a
+writable file::
+
+   >>> parser = argparse.ArgumentParser()
+   >>> parser.add_argument('bar', type=argparse.FileType('w'))
+   >>> parser.parse_args(['out.txt'])
+   Namespace(bar=<open file 'out.txt', mode 'w' at 0x...>)
+
+If you need to do some special type-checking or type-conversions, you can
+provide your own types by passing to ``type=`` a callable that takes a single
+string argument and returns the type-converted value::
+
+   >>> def perfect_square(string):
+   ...     value = int(string)
+   ...     sqrt = math.sqrt(value)
+   ...     if sqrt != int(sqrt):
+   ...         msg = "%r is not a perfect square" % string
+   ...         raise argparse.ArgumentTypeError(msg)
+   ...     return value
+   ...
+   >>> parser = argparse.ArgumentParser(prog='PROG')
+   >>> parser.add_argument('foo', type=perfect_square)
+   >>> parser.parse_args('9'.split())
+   Namespace(foo=9)
+   >>> parser.parse_args('7'.split())
+   usage: PROG [-h] foo
+   PROG: error: argument foo: '7' is not a perfect square
+
+Note that if your type-checking function is just checking for a particular set
+of values, it may be more convenient to use the choices_ keyword argument::
+
+   >>> parser = argparse.ArgumentParser(prog='PROG')
+   >>> parser.add_argument('foo', type=int, choices=xrange(5, 10))
+   >>> parser.parse_args('7'.split())
+   Namespace(foo=7)
+   >>> parser.parse_args('11'.split())
+   usage: PROG [-h] {5,6,7,8,9}
+   PROG: error: argument foo: invalid choice: 11 (choose from 5, 6, 7, 8, 9)
+
+See the choices_ section for more details.
+
+
+choices
+^^^^^^^
+
+Some command-line args should be selected from a restricted set of values.
+ArgumentParser objects can be told about such sets of values by passing a
+container object as the ``choices`` keyword argument to :meth:`add_argument`.
+When the command-line is parsed with :meth:`parse_args`, arg values will be
+checked, and an error message will be displayed if the arg was not one of the
+acceptable values::
+
+   >>> parser = argparse.ArgumentParser(prog='PROG')
+   >>> parser.add_argument('foo', choices='abc')
+   >>> parser.parse_args('c'.split())
+   Namespace(foo='c')
+   >>> parser.parse_args('X'.split())
+   usage: PROG [-h] {a,b,c}
+   PROG: error: argument foo: invalid choice: 'X' (choose from 'a', 'b', 'c')
+
+Note that inclusion in the ``choices`` container is checked after any type_
+conversions have been performed, so the type of the objects in the ``choices``
+container should match the type_ specified::
+
+   >>> parser = argparse.ArgumentParser(prog='PROG')
+   >>> parser.add_argument('foo', type=complex, choices=[1, 1j])
+   >>> parser.parse_args('1j'.split())
+   Namespace(foo=1j)
+   >>> parser.parse_args('-- -4'.split())
+   usage: PROG [-h] {1,1j}
+   PROG: error: argument foo: invalid choice: (-4+0j) (choose from 1, 1j)
+
+Any object that supports the ``in`` operator can be passed as the ``choices``
+value, so ``dict`` objects, ``set`` objects, custom containers, etc. are all
+supported.
+
+
+required
+^^^^^^^^
+
+In general, the argparse module assumes that flags like ``-f`` and ``--bar``
+indicate *optional* arguments, which can always be omitted at the command-line.
+To change this behavior, i.e. to make an option *required*, the value ``True``
+should be specified for the ``required=`` keyword argument to
+:meth:`add_argument`::
+
+   >>> parser = argparse.ArgumentParser()
+   >>> parser.add_argument('--foo', required=True)
+   >>> parser.parse_args(['--foo', 'BAR'])
+   Namespace(foo='BAR')
+   >>> parser.parse_args([])
+   usage: argparse.py [-h] [--foo FOO]
+   argparse.py: error: option --foo is required
+
+As the example shows, if an option is marked as ``required``, :meth:`parse_args`
+will report an error if that option is not present at the command line.
+
+**Warning:** Required options are generally considered bad form - normal users
+expect *options* to be *optional*. You should avoid the use of required options
+whenever possible.
+
+
+help
+^^^^
+
+A great command-line interface isn't worth anything if your users can't figure
+out which option does what.  So for the end-users, ``help`` is probably the
+most important argument to include in your :meth:`add_argument` calls.  The
+``help`` value should be a string containing a brief description of what the
+argument specifies.  When a user requests help (usually by using ``-h`` or
+``--help`` at the command-line), these ``help`` descriptions will be displayed
+with each argument::
+
+   >>> parser = argparse.ArgumentParser(prog='frobble')
+   >>> parser.add_argument('--foo', action='store_true',
+   ...         help='foo the bars before frobbling')
+   >>> parser.add_argument('bar', nargs='+',
+   ...         help='one of the bars to be frobbled')
+   >>> parser.parse_args('-h'.split())
+   usage: frobble [-h] [--foo] bar [bar ...]
+
+   positional arguments:
+    bar     one of the bars to be frobbled
+
+   optional arguments:
+    -h, --help  show this help message and exit
+    --foo   foo the bars before frobbling
+
+The ``help`` strings can include various format specifiers to avoid repetition
+of things like the program name or the argument default_.  The available
+specifiers include the program name, ``%(prog)s`` and most keyword arguments to
+:meth:`add_argument`, e.g. ``%(default)s``, ``%(type)s``, etc.::
+
+   >>> parser = argparse.ArgumentParser(prog='frobble')
+   >>> parser.add_argument('bar', nargs='?', type=int, default=42,
+   ...         help='the bar to %(prog)s (default: %(default)s)')
+   >>> parser.print_help()
+   usage: frobble [-h] [bar]
+
+   positional arguments:
+    bar     the bar to frobble (default: 42)
+
+   optional arguments:
+    -h, --help  show this help message and exit
+
+
+metavar
+^^^^^^^
+
+When ArgumentParser objects generate help messages, they need some way to refer
+to each expected argument. By default, ArgumentParser objects use the dest_
+value as the "name" of each object.  By default, for positional argument
+actions, the dest_ value is used directly, and for optional argument actions,
+the dest_ value is uppercased.  So if we have a single positional argument with
+``dest='bar'``, that argument will be referred to as ``bar``.  And if we have a
+single optional argument ``--foo`` that should be followed by a single
+command-line arg, that arg will be referred to as ``FOO``.  You can see this
+behavior in the example below::
+
+   >>> parser = argparse.ArgumentParser()
+   >>> parser.add_argument('--foo')
+   >>> parser.add_argument('bar')
+   >>> parser.parse_args('X --foo Y'.split())
+   Namespace(bar='X', foo='Y')
+   >>> parser.print_help()
+   usage:  [-h] [--foo FOO] bar
+
+   positional arguments:
+    bar
+
+   optional arguments:
+    -h, --help  show this help message and exit
+    --foo FOO
+
+If you would like to provide a different name for your argument in help
+messages, you can supply a value for the ``metavar`` keyword argument to
+:meth:`add_argument`::
+
+   >>> parser = argparse.ArgumentParser()
+   >>> parser.add_argument('--foo', metavar='YYY')
+   >>> parser.add_argument('bar', metavar='XXX')
+   >>> parser.parse_args('X --foo Y'.split())
+   Namespace(bar='X', foo='Y')
+   >>> parser.print_help()
+   usage:  [-h] [--foo YYY] XXX
+
+   positional arguments:
+    XXX
+
+   optional arguments:
+    -h, --help  show this help message and exit
+    --foo YYY
+
+Note that ``metavar`` only changes the *displayed* name - the name of the
+attribute on the :meth:`parse_args` object is still determined by the dest_
+value.
+
+Different values of ``nargs`` may cause the metavar to be used multiple times.
+If you'd like to specify a different display name for each of the arguments,
+you can provide a tuple to ``metavar``::
+
+   >>> parser = argparse.ArgumentParser(prog='PROG')
+   >>> parser.add_argument('-x', nargs=2)
+   >>> parser.add_argument('--foo', nargs=2, metavar=('bar', 'baz'))
+   >>> parser.print_help()
+   usage: PROG [-h] [-x X X] [--foo bar baz]
+
+   optional arguments:
+    -h, --help     show this help message and exit
+    -x X X
+    --foo bar baz
+
+
+dest
+^^^^
+
+Most ArgumentParser actions add some value as an attribute of the object
+returned by :meth:`parse_args`. The name of this attribute is determined by the
+``dest`` keyword argument of :meth:`add_argument`. For positional argument
+actions, ``dest`` is normally supplied as the first argument to
+:meth:`add_argument`::
+
+   >>> parser = argparse.ArgumentParser()
+   >>> parser.add_argument('bar')
+   >>> parser.parse_args('XXX'.split())
+   Namespace(bar='XXX')
+
+For optional argument actions, the value of ``dest`` is normally inferred from
+the option strings. ArgumentParser objects generate the value of ``dest`` by
+taking the first long option string and stripping away the initial ``'--'``
+string.  If no long option strings were supplied, ``dest`` will be derived from
+the first short option string by stripping the initial ``'-'`` character.  Any
+internal ``'-'`` characters will be converted to ``'_'`` characters to make
+sure the string is a valid attribute name. The examples below illustrate this
+behavior::
+
+   >>> parser = argparse.ArgumentParser()
+   >>> parser.add_argument('-f', '--foo-bar', '--foo')
+   >>> parser.add_argument('-x', '-y')
+   >>> parser.parse_args('-f 1 -x 2'.split())
+   Namespace(foo_bar='1', x='2')
+   >>> parser.parse_args('--foo 1 -y 2'.split())
+   Namespace(foo_bar='1', x='2')
+
+If you would like to use a different attribute name from the one automatically
+inferred by the ArgumentParser, you can supply it with an explicit ``dest``
+parameter::
+
+   >>> parser = argparse.ArgumentParser()
+   >>> parser.add_argument('--foo', dest='bar')
+   >>> parser.parse_args('--foo XXX'.split())
+   Namespace(bar='XXX')
+
+
+The parse_args() method
+-----------------------
+
+.. method:: parse_args([args], [namespace])
+
+   Convert the strings to objects and assign them as attributes of the
+   namespace. Return the populated namespace.
+
+   Previous calls to :meth:`add_argument` determine exactly what objects are
+   created and how they are assigned. See the documentation for
+   :meth:`add_argument` for details.
+
+   By default, the arg strings are taken from ``sys.argv``, and a new empty
+   ``Namespace`` object is created for the attributes.
+
+Option value syntax
+^^^^^^^^^^^^^^^^^^^
+
+The :meth:`parse_args` method supports several ways of specifying the value of
+an option (if it takes one). In the simplest case, the option and its value are
+passed as two separate arguments::
+
+   >>> parser = argparse.ArgumentParser(prog='PROG')
+   >>> parser.add_argument('-x')
+   >>> parser.add_argument('--foo')
+   >>> parser.parse_args('-x X'.split())
+   Namespace(foo=None, x='X')
+   >>> parser.parse_args('--foo FOO'.split())
+   Namespace(foo='FOO', x=None)
+
+For long options (options with names longer than a single character), you may
+also pass the option and value as a single command line argument, using ``=``
+to separate them::
+
+   >>> parser.parse_args('--foo=FOO'.split())
+   Namespace(foo='FOO', x=None)
+
+For short options (options only one character long), you may simply concatenate
+the option and its value::
+
+   >>> parser.parse_args('-xX'.split())
+   Namespace(foo=None, x='X')
+
+You can also combine several short options together, using only a single ``-``
+prefix, as long as only the last option (or none of them) requires a value::
+
+   >>> parser = argparse.ArgumentParser(prog='PROG')
+   >>> parser.add_argument('-x', action='store_true')
+   >>> parser.add_argument('-y', action='store_true')
+   >>> parser.add_argument('-z')
+   >>> parser.parse_args('-xyzZ'.split())
+   Namespace(x=True, y=True, z='Z')
+
+
+Invalid arguments
+^^^^^^^^^^^^^^^^^
+
+While parsing the command-line, ``parse_args`` checks for a variety of errors,
+including ambiguous options, invalid types, invalid options, wrong number of
+positional arguments, etc. When it encounters such an error, it exits and
+prints the error along with a usage message::
+
+   >>> parser = argparse.ArgumentParser(prog='PROG')
+   >>> parser.add_argument('--foo', type=int)
+   >>> parser.add_argument('bar', nargs='?')
+
+   >>> # invalid type
+   >>> parser.parse_args(['--foo', 'spam'])
+   usage: PROG [-h] [--foo FOO] [bar]
+   PROG: error: argument --foo: invalid int value: 'spam'
+
+   >>> # invalid option
+   >>> parser.parse_args(['--bar'])
+   usage: PROG [-h] [--foo FOO] [bar]
+   PROG: error: no such option: --bar
+
+   >>> # wrong number of arguments
+   >>> parser.parse_args(['spam', 'badger'])
+   usage: PROG [-h] [--foo FOO] [bar]
+   PROG: error: extra arguments found: badger
+
+
+Arguments containing ``"-"``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The ``parse_args`` method attempts to give errors whenever the user has clearly
+made a mistake, but some situations are inherently ambiguous. For example, the
+command-line arg ``'-1'`` could either be an attempt to specify an option or an
+attempt to provide a positional argument. The ``parse_args`` method is cautious
+here: positional arguments may only begin with ``'-'`` if they look like
+negative numbers and there are no options in the parser that look like negative
+numbers::
+
+   >>> parser = argparse.ArgumentParser(prog='PROG')
+   >>> parser.add_argument('-x')
+   >>> parser.add_argument('foo', nargs='?')
+
+   >>> # no negative number options, so -1 is a positional argument
+   >>> parser.parse_args(['-x', '-1'])
+   Namespace(foo=None, x='-1')
+
+   >>> # no negative number options, so -1 and -5 are positional arguments
+   >>> parser.parse_args(['-x', '-1', '-5'])
+   Namespace(foo='-5', x='-1')
+
+   >>> parser = argparse.ArgumentParser(prog='PROG')
+   >>> parser.add_argument('-1', dest='one')
+   >>> parser.add_argument('foo', nargs='?')
+
+   >>> # negative number options present, so -1 is an option
+   >>> parser.parse_args(['-1', 'X'])
+   Namespace(foo=None, one='X')
+
+   >>> # negative number options present, so -2 is an option
+   >>> parser.parse_args(['-2'])
+   usage: PROG [-h] [-1 ONE] [foo]
+   PROG: error: no such option: -2
+
+   >>> # negative number options present, so both -1s are options
+   >>> parser.parse_args(['-1', '-1'])
+   usage: PROG [-h] [-1 ONE] [foo]
+   PROG: error: argument -1: expected one argument
+
+If you have positional arguments that must begin with ``'-'`` and don't look
+like negative numbers, you can insert the pseudo-argument ``'--'`` which tells
+``parse_args`` that everything after that is a positional argument::
+
+   >>> parser.parse_args(['--', '-f'])
+   Namespace(foo='-f', one=None)
+
+
+Argument abbreviations
+^^^^^^^^^^^^^^^^^^^^^^
+
+The :meth:`parse_args` method allows you to abbreviate long options if the
+abbreviation is unambiguous::
+
+   >>> parser = argparse.ArgumentParser(prog='PROG')
+   >>> parser.add_argument('-bacon')
+   >>> parser.add_argument('-badger')
+   >>> parser.parse_args('-bac MMM'.split())
+   Namespace(bacon='MMM', badger=None)
+   >>> parser.parse_args('-bad WOOD'.split())
+   Namespace(bacon=None, badger='WOOD')
+   >>> parser.parse_args('-ba BA'.split())
+   usage: PROG [-h] [-bacon BACON] [-badger BADGER]
+   PROG: error: ambiguous option: -ba could match -badger, -bacon
+
+As you can see above, you will get an error if you pick a prefix that could
+refer to more than one option.
+
+
+Beyond ``sys.argv``
+^^^^^^^^^^^^^^^^^^^
+
+Sometimes it may be useful to have an ArgumentParser parse args other than
+those of ``sys.argv``.  This can be accomplished by passing a list of strings
+to ``parse_args``.  You may have noticed that the examples in the argparse
+documentation have made heavy use of this calling style - it is much easier
+to use at the interactive prompt::
+
+   >>> parser = argparse.ArgumentParser()
+   >>> parser.add_argument(
+   ...     'integers', metavar='int', type=int, choices=xrange(10),
+   ...  nargs='+', help='an integer in the range 0..9')
+   >>> parser.add_argument(
+   ...     '--sum', dest='accumulate', action='store_const', const=sum,
+   ...   default=max, help='sum the integers (default: find the max)')
+   >>> parser.parse_args(['1', '2', '3', '4'])
+   Namespace(accumulate=<built-in function max>, integers=[1, 2, 3, 4])
+   >>> parser.parse_args('1 2 3 4 --sum'.split())
+   Namespace(accumulate=<built-in function sum>, integers=[1, 2, 3, 4])
+
+
+Custom namespaces
+^^^^^^^^^^^^^^^^^
+
+It may also be useful to have an ArgumentParser assign attributes to an already
+existing object, rather than the newly-created Namespace object that is
+normally used. This can be achieved by specifying the ``namespace=`` keyword
+argument::
+
+   >>> class C(object):
+   ...     pass
+   ...
+   >>> c = C()
+   >>> parser = argparse.ArgumentParser()
+   >>> parser.add_argument('--foo')
+   >>> parser.parse_args(args=['--foo', 'BAR'], namespace=c)
+   >>> c.foo
+   'BAR'
+
+
+Other utilities
+---------------
+
+Sub-commands
+^^^^^^^^^^^^
+
+.. method:: add_subparsers()
+
+   A lot of programs split up their functionality into a number of
+   sub-commands, for example, the ``svn`` program can invoke sub-commands like
+   ``svn checkout``, ``svn update``, ``svn commit``, etc.  Splitting up
+   functionality this way can be a particularly good idea when a program
+   performs several different functions which require different kinds of
+   command-line arguments.  ArgumentParser objects support the creation of such
+   sub-commands with the :meth:`add_subparsers` method.  The
+   :meth:`add_subparsers` method is normally called with no arguments and
+   returns an special action object.  This object has a single method,
+   ``add_parser``, which takes a command name and any ArgumentParser
+   constructor arguments, and returns an ArgumentParser object that can be
+   modified as usual.
+
+   Some example usage::
+
+     >>> # create the top-level parser
+     >>> parser = argparse.ArgumentParser(prog='PROG')
+     >>> parser.add_argument('--foo', action='store_true', help='foo help')
+     >>> subparsers = parser.add_subparsers(help='sub-command help')
+     >>>
+     >>> # create the parser for the "a" command
+     >>> parser_a = subparsers.add_parser('a', help='a help')
+     >>> parser_a.add_argument('bar', type=int, help='bar help')
+     >>>
+     >>> # create the parser for the "b" command
+     >>> parser_b = subparsers.add_parser('b', help='b help')
+     >>> parser_b.add_argument('--baz', choices='XYZ', help='baz help')
+     >>>
+     >>> # parse some arg lists
+     >>> parser.parse_args(['a', '12'])
+     Namespace(bar=12, foo=False)
+     >>> parser.parse_args(['--foo', 'b', '--baz', 'Z'])
+     Namespace(baz='Z', foo=True)
+
+   Note that the object returned by :meth:`parse_args` will only contain
+   attributes for the main parser and the subparser that was selected by the
+   command line (and not any other subparsers).  So in the example above, when
+   the ``"a"`` command is specified, only the ``foo`` and ``bar`` attributes
+   are present, and when the ``"b"`` command is specified, only the ``foo`` and
+   ``baz`` attributes are present.
+
+   Similarly, when a help message is requested from a subparser, only the help
+   for that particular parser will be printed. The help message will not
+   include parent parser or sibling parser messages. (You can however supply a
+   help message for each subparser command by suppling the ``help=`` argument
+   to ``add_parser`` as above.)
+
+   ::
+
+     >>> parser.parse_args(['--help'])
+     usage: PROG [-h] [--foo] {a,b} ...
+
+     positional arguments:
+       {a,b}   sub-command help
+     a     a help
+     b     b help
+
+     optional arguments:
+       -h, --help  show this help message and exit
+       --foo   foo help
+
+     >>> parser.parse_args(['a', '--help'])
+     usage: PROG a [-h] bar
+
+     positional arguments:
+       bar     bar help
+
+     optional arguments:
+       -h, --help  show this help message and exit
+
+     >>> parser.parse_args(['b', '--help'])
+     usage: PROG b [-h] [--baz {X,Y,Z}]
+
+     optional arguments:
+       -h, --help     show this help message and exit
+       --baz {X,Y,Z}  baz help
+
+   The :meth:`add_subparsers` method also supports ``title`` and
+   ``description`` keyword arguments.  When either is present, the subparser's
+   commands will appear in their own group in the help output.  For example::
+
+     >>> parser = argparse.ArgumentParser()
+     >>> subparsers = parser.add_subparsers(title='subcommands',
+     ...                                    description='valid subcommands',
+     ...                                    help='additional help')
+     >>> subparsers.add_parser('foo')
+     >>> subparsers.add_parser('bar')
+     >>> parser.parse_args(['-h'])
+     usage:  [-h] {foo,bar} ...
+
+     optional arguments:
+       -h, --help  show this help message and exit
+
+     subcommands:
+       valid subcommands
+
+       {foo,bar}   additional help
+
+
+   One particularly effective way of handling sub-commands is to combine the
+   use of the :meth:`add_subparsers` method with calls to :meth:`set_defaults`
+   so that each subparser knows which Python function it should execute.  For
+   example::
+
+     >>> # sub-command functions
+     >>> def foo(args):
+     ...     print args.x * args.y
+     ...
+     >>> def bar(args):
+     ...     print '((%s))' % args.z
+     ...
+     >>> # create the top-level parser
+     >>> parser = argparse.ArgumentParser()
+     >>> subparsers = parser.add_subparsers()
+     >>>
+     >>> # create the parser for the "foo" command
+     >>> parser_foo = subparsers.add_parser('foo')
+     >>> parser_foo.add_argument('-x', type=int, default=1)
+     >>> parser_foo.add_argument('y', type=float)
+     >>> parser_foo.set_defaults(func=foo)
+     >>>
+     >>> # create the parser for the "bar" command
+     >>> parser_bar = subparsers.add_parser('bar')
+     >>> parser_bar.add_argument('z')
+     >>> parser_bar.set_defaults(func=bar)
+     >>>
+     >>> # parse the args and call whatever function was selected
+     >>> args = parser.parse_args('foo 1 -x 2'.split())
+     >>> args.func(args)
+     2.0
+     >>>
+     >>> # parse the args and call whatever function was selected
+     >>> args = parser.parse_args('bar XYZYX'.split())
+     >>> args.func(args)
+     ((XYZYX))
+
+   This way, you can let :meth:`parse_args` do all the work for you, and then
+   just call the appropriate function after the argument parsing is complete.
+   Associating functions with actions like this is typically the easiest way
+   to handle the different actions for each of your subparsers. However, if you
+   find it necessary to check the name of the subparser that was invoked, you
+   can always provide a ``dest`` keyword argument to the :meth:`add_subparsers`
+   call::
+
+     >>> parser = argparse.ArgumentParser()
+     >>> subparsers = parser.add_subparsers(dest='subparser_name')
+     >>> subparser1 = subparsers.add_parser('1')
+     >>> subparser1.add_argument('-x')
+     >>> subparser2 = subparsers.add_parser('2')
+     >>> subparser2.add_argument('y')
+     >>> parser.parse_args(['2', 'frobble'])
+     Namespace(subparser_name='2', y='frobble')
+
+
+FileType objects
+^^^^^^^^^^^^^^^^
+
+.. class:: FileType(mode='r', bufsize=None)
+
+   The :class:`FileType` factory creates objects that can be passed to the type
+   argument of :meth:`add_argument`. Arguments that have :class:`FileType`
+   objects as their type will open command-line args as files with the
+   requested modes and buffer sizes:
+
+   >>> parser = argparse.ArgumentParser()
+   >>> parser.add_argument('--output', type=argparse.FileType('wb', 0))
+   >>> parser.parse_args(['--output', 'out'])
+   Namespace(output=<open file 'out', mode 'wb' at 0x...>)
+
+   FileType objects understand the pseudo-argument ``'-'`` and automatically
+   convert this into ``sys.stdin`` for readable :class:`FileType` objects and
+   ``sys.stdout`` for writable :class:`FileType` objects:
+
+   >>> parser = argparse.ArgumentParser()
+   >>> parser.add_argument('infile', type=argparse.FileType('r'))
+   >>> parser.parse_args(['-'])
+   Namespace(infile=<open file '<stdin>', mode 'r' at 0x...>)
+
+
+Argument groups
+^^^^^^^^^^^^^^^
+
+.. method:: add_argument_group([title], [description])
+
+   By default, ArgumentParser objects group command-line arguments into
+   "positional arguments" and "optional arguments" when displaying help
+   messages. When there is a better conceptual grouping of arguments than this
+   default one, appropriate groups can be created using the
+   :meth:`add_argument_group` method::
+
+     >>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)
+     >>> group = parser.add_argument_group('group')
+     >>> group.add_argument('--foo', help='foo help')
+     >>> group.add_argument('bar', help='bar help')
+     >>> parser.print_help()
+     usage: PROG [--foo FOO] bar
+
+     group:
+       bar    bar help
+       --foo FOO  foo help
+
+   The :meth:`add_argument_group` method returns an argument group object which
+   has an :meth:`add_argument` method just like a regular ArgumentParser
+   objects. When an argument is added to the group, the parser treats it just
+   like a normal argument, but displays the argument in a separate group for
+   help messages. The :meth:`add_argument_group` method accepts ``title`` and
+   ``description`` arguments which can be used to customize this display::
+
+     >>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)
+     >>> group1 = parser.add_argument_group('group1', 'group1 description')
+     >>> group1.add_argument('foo', help='foo help')
+     >>> group2 = parser.add_argument_group('group2', 'group2 description')
+     >>> group2.add_argument('--bar', help='bar help')
+     >>> parser.print_help()
+     usage: PROG [--bar BAR] foo
+
+     group1:
+       group1 description
+
+       foo    foo help
+
+     group2:
+       group2 description
+
+       --bar BAR  bar help
+
+   Note that any arguments not in your user defined groups will end up back in
+   the usual "positional arguments" and "optional arguments" sections.
+
+
+Mutual exclusion
+^^^^^^^^^^^^^^^^
+
+.. method:: add_mutually_exclusive_group([required=False])
+
+   Sometimes, you need to make sure that only one of a couple different options
+   is specified on the command line. You can create groups of such mutually
+   exclusive arguments using the :meth:`add_mutually_exclusive_group` method.
+   When :func:`parse_args` is called, argparse will make sure that only one of
+   the arguments in the mutually exclusive group was present on the command
+   line::
+
+     >>> parser = argparse.ArgumentParser(prog='PROG')
+     >>> group = parser.add_mutually_exclusive_group()
+     >>> group.add_argument('--foo', action='store_true')
+     >>> group.add_argument('--bar', action='store_false')
+     >>> parser.parse_args(['--foo'])
+     Namespace(bar=True, foo=True)
+     >>> parser.parse_args(['--bar'])
+     Namespace(bar=False, foo=False)
+     >>> parser.parse_args(['--foo', '--bar'])
+     usage: PROG [-h] [--foo | --bar]
+     PROG: error: argument --bar: not allowed with argument --foo
+
+   The :meth:`add_mutually_exclusive_group` method also accepts a ``required``
+   argument, to indicate that at least one of the mutually exclusive arguments
+   is required::
+
+     >>> parser = argparse.ArgumentParser(prog='PROG')
+     >>> group = parser.add_mutually_exclusive_group(required=True)
+     >>> group.add_argument('--foo', action='store_true')
+     >>> group.add_argument('--bar', action='store_false')
+     >>> parser.parse_args([])
+     usage: PROG [-h] (--foo | --bar)
+     PROG: error: one of the arguments --foo --bar is required
+
+   Note that currently mutually exclusive argument groups do not support the
+   ``title`` and ``description`` arguments of :meth:`add_argument_group`. This
+   may change in the future however, so you are *strongly* recommended to
+   specify ``required`` as a keyword argument if you use it.
+
+
+Parser defaults
+^^^^^^^^^^^^^^^
+
+.. method:: set_defaults(**kwargs)
+
+   Most of the time, the attributes of the object returned by
+   :meth:`parse_args` will be fully determined by inspecting the command-line
+   args and the argument actions described in your :meth:`add_argument` calls.
+   However, sometimes it may be useful to add some additional attributes that
+   are determined without any inspection of the command-line.  The
+   :meth:`set_defaults` method allows you to do this::
+
+     >>> parser = argparse.ArgumentParser()
+     >>> parser.add_argument('foo', type=int)
+     >>> parser.set_defaults(bar=42, baz='badger')
+     >>> parser.parse_args(['736'])
+     Namespace(bar=42, baz='badger', foo=736)
+
+   Note that parser-level defaults always override argument-level defaults. So
+   if you set a parser-level default for a name that matches an argument, the
+   old argument default will no longer be used::
+
+     >>> parser = argparse.ArgumentParser()
+     >>> parser.add_argument('--foo', default='bar')
+     >>> parser.set_defaults(foo='spam')
+     >>> parser.parse_args([])
+     Namespace(foo='spam')
+
+   Parser-level defaults can be particularly useful when you're working with
+   multiple parsers.  See the :meth:`add_subparsers` method for an example of
+   this type.
+
+.. method:: get_default(dest)
+
+   Get the default value for a namespace attribute, as set by either
+   :meth:`add_argument` or by :meth:`set_defaults`::
+
+     >>> parser = argparse.ArgumentParser()
+     >>> parser.add_argument('--foo', default='badger')
+     >>> parser.get_default('foo')
+     'badger'
+
+
+Printing help
+^^^^^^^^^^^^^
+
+In most typical applications, :meth:`parse_args` will take care of formatting
+and printing any usage or error messages. However, should you want to format or
+print these on your own, several methods are available:
+
+.. method:: print_usage([file]):
+
+   Print a brief description of how the :class:`ArgumentParser` should be
+   invoked on the command line.  If ``file`` is not present, ``sys.stderr`` is
+   assumed.
+
+.. method:: print_help([file]):
+
+   Print a help message, including the program usage and information about the
+   arguments registered with the :class:`ArgumentParser`. If ``file`` is not
+   present, ``sys.stderr`` is assumed.
+
+There are also variants of these methods that simply return a string instead of
+printing it:
+
+.. method:: format_usage():
+
+   Return a string containing a brief description of how the
+   :class:`ArgumentParser` should be invoked on the command line.
+
+.. method:: format_help():
+
+   Return a string containing a help message, including the program usage and
+   information about the arguments registered with the :class:`ArgumentParser`.
+
+
+
+Partial parsing
+^^^^^^^^^^^^^^^
+
+.. method:: parse_known_args([args], [namespace])
+
+Sometimes a script may only parse a few of the command line arguments, passing
+the remaining arguments on to another script or program. In these cases, the
+:meth:`parse_known_args` method can be useful. It works much like
+:meth:`parse_args` except that it does not produce an error when extra
+arguments are present. Instead, it returns a two item tuple containing the
+populated namespace and the list of remaining argument strings.
+
+::
+
+   >>> parser = argparse.ArgumentParser()
+   >>> parser.add_argument('--foo', action='store_true')
+   >>> parser.add_argument('bar')
+   >>> parser.parse_known_args(['--foo', '--badger', 'BAR', 'spam'])
+   (Namespace(bar='BAR', foo=True), ['--badger', 'spam'])
+
+
+Customizing file parsing
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. method:: convert_arg_line_to_args(arg_line)
+
+   Arguments that are read from a file (see the ``fromfile_prefix_chars``
+   keyword argument to the :class:`ArgumentParser` constructor) are read one
+   argument per line.  If you need fancier parsing, then you can subclass the
+   :class:`ArgumentParser` and override the :meth:`convert_arg_line_to_args`
+   method.
+
+   This method takes a single argument ``arg_line`` which is a string read from
+   the argument file.  It returns a list of arguments parsed from this string.
+   The method is called once per line read from the argument file, in order.
+
+   A useful override of this method is one that treats each space-separated
+   word as an argument::
+
+    def convert_arg_line_to_args(self, arg_line):
+        for arg in arg_line.split():
+            if not arg.strip():
+                continue
+            yield arg
+
+
+Upgrading optparse code
+-----------------------
+
+Originally, the argparse module had attempted to maintain compatibility with
+ optparse. However, optparse was difficult to extend transparently,
+ particularly with the changes required to support the new ``nargs=``
+ specifiers and better usage messges. When most everything in optparse had
+ either been copy-pasted over or monkey-patched, it no longer seemed practical
+ to try to maintain the backwards compatibility.
+
+A partial upgrade path from optparse to argparse:
+
+* Replace all ``add_option()`` calls with :meth:`add_argument` calls.
+
+* Replace ``options, args = parser.parse_args()`` with
+  ``args = parser.parse_args()`` and add additional :meth:`add_argument` calls
+  for the positional arguments.
+
+* Replace callback actions and the ``callback_*`` keyword arguments with
+  ``type`` or ``action`` arguments.
+
+* Replace string names for ``type`` keyword arguments with the corresponding
+  type objects (e.g. int, float, complex, etc).
+
+* Replace ``Values`` with ``Namespace`` and ``OptionError/OptionValueError``
+  with ``ArgumentError``.
+
+* Replace strings with implicit arguments such as ``%default`` or ``%prog``
+  with the standard python syntax to use dictionaries to format strings, that
+  is, ``%(default)s`` and ``%(prog)s``.
diff --git a/Lib/argparse.py b/Lib/argparse.py
index e91bb7a..cde1fe9 100644
--- a/Lib/argparse.py
+++ b/Lib/argparse.py
@@ -1,2351 +1,2351 @@
-# Copyright 2006-2009 Steven J. Bethard <steven.bethard@gmail.com>.

-#

-# Licensed under the Apache License, Version 2.0 (the "License"); you may not

-# use this file except in compliance with the License. You may obtain a copy

-# of the License at

-#

-#     http://www.apache.org/licenses/LICENSE-2.0

-#

-# Unless required by applicable law or agreed to in writing, software

-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

-# License for the specific language governing permissions and limitations

-# under the License.

-

-"""Command-line parsing library

-

-This module is an optparse-inspired command-line parsing library that:

-

-    - handles both optional and positional arguments

-    - produces highly informative usage messages

-    - supports parsers that dispatch to sub-parsers

-

-The following is a simple usage example that sums integers from the

-command-line and writes the result to a file::

-

-    parser = argparse.ArgumentParser(

-        description='sum the integers at the command line')

-    parser.add_argument(

-        'integers', metavar='int', nargs='+', type=int,

-        help='an integer to be summed')

-    parser.add_argument(

-        '--log', default=sys.stdout, type=argparse.FileType('w'),

-        help='the file where the sum should be written')

-    args = parser.parse_args()

-    args.log.write('%s' % sum(args.integers))

-    args.log.close()

-

-The module contains the following public classes:

-

-    - ArgumentParser -- The main entry point for command-line parsing. As the

-        example above shows, the add_argument() method is used to populate

-        the parser with actions for optional and positional arguments. Then

-        the parse_args() method is invoked to convert the args at the

-        command-line into an object with attributes.

-

-    - ArgumentError -- The exception raised by ArgumentParser objects when

-        there are errors with the parser's actions. Errors raised while

-        parsing the command-line are caught by ArgumentParser and emitted

-        as command-line messages.

-

-    - FileType -- A factory for defining types of files to be created. As the

-        example above shows, instances of FileType are typically passed as

-        the type= argument of add_argument() calls.

-

-    - Action -- The base class for parser actions. Typically actions are

-        selected by passing strings like 'store_true' or 'append_const' to

-        the action= argument of add_argument(). However, for greater

-        customization of ArgumentParser actions, subclasses of Action may

-        be defined and passed as the action= argument.

-

-    - HelpFormatter, RawDescriptionHelpFormatter, RawTextHelpFormatter,

-        ArgumentDefaultsHelpFormatter -- Formatter classes which

-        may be passed as the formatter_class= argument to the

-        ArgumentParser constructor. HelpFormatter is the default,

-        RawDescriptionHelpFormatter and RawTextHelpFormatter tell the parser

-        not to change the formatting for help text, and

-        ArgumentDefaultsHelpFormatter adds information about argument defaults

-        to the help.

-

-All other classes in this module are considered implementation details.

-(Also note that HelpFormatter and RawDescriptionHelpFormatter are only

-considered public as object names -- the API of the formatter objects is

-still considered an implementation detail.)

-"""

-

-__version__ = '1.1'

-__all__ = [

-    'ArgumentParser',

-    'ArgumentError',

-    'Namespace',

-    'Action',

-    'FileType',

-    'HelpFormatter',

-    'RawDescriptionHelpFormatter',

-    'RawTextHelpFormatter',

-    'ArgumentDefaultsHelpFormatter',

-]

-

-

-import copy as _copy

-import os as _os

-import re as _re

-import sys as _sys

-import textwrap as _textwrap

-

-from gettext import gettext as _

-

-try:

-    _set = set

-except NameError:

-    from sets import Set as _set

-

-try:

-    _basestring = basestring

-except NameError:

-    _basestring = str

-

-try:

-    _sorted = sorted

-except NameError:

-

-    def _sorted(iterable, reverse=False):

-        result = list(iterable)

-        result.sort()

-        if reverse:

-            result.reverse()

-        return result

-

-

-def _callable(obj):

-    return hasattr(obj, '__call__') or hasattr(obj, '__bases__')

-

-# silence Python 2.6 buggy warnings about Exception.message

-if _sys.version_info[:2] == (2, 6):

-    import warnings

-    warnings.filterwarnings(

-        action='ignore',

-        message='BaseException.message has been deprecated as of Python 2.6',

-        category=DeprecationWarning,

-        module='argparse')

-

-

-SUPPRESS = '==SUPPRESS=='

-

-OPTIONAL = '?'

-ZERO_OR_MORE = '*'

-ONE_OR_MORE = '+'

-PARSER = 'A...'

-REMAINDER = '...'

-

-# =============================

-# Utility functions and classes

-# =============================

-

-class _AttributeHolder(object):

-    """Abstract base class that provides __repr__.

-

-    The __repr__ method returns a string in the format::

-        ClassName(attr=name, attr=name, ...)

-    The attributes are determined either by a class-level attribute,

-    '_kwarg_names', or by inspecting the instance __dict__.

-    """

-

-    def __repr__(self):

-        type_name = type(self).__name__

-        arg_strings = []

-        for arg in self._get_args():

-            arg_strings.append(repr(arg))

-        for name, value in self._get_kwargs():

-            arg_strings.append('%s=%r' % (name, value))

-        return '%s(%s)' % (type_name, ', '.join(arg_strings))

-

-    def _get_kwargs(self):

-        return _sorted(self.__dict__.items())

-

-    def _get_args(self):

-        return []

-

-

-def _ensure_value(namespace, name, value):

-    if getattr(namespace, name, None) is None:

-        setattr(namespace, name, value)

-    return getattr(namespace, name)

-

-

-# ===============

-# Formatting Help

-# ===============

-

-class HelpFormatter(object):

-    """Formatter for generating usage messages and argument help strings.

-

-    Only the name of this class is considered a public API. All the methods

-    provided by the class are considered an implementation detail.

-    """

-

-    def __init__(self,

-                 prog,

-                 indent_increment=2,

-                 max_help_position=24,

-                 width=None):

-

-        # default setting for width

-        if width is None:

-            try:

-                width = int(_os.environ['COLUMNS'])

-            except (KeyError, ValueError):

-                width = 80

-            width -= 2

-

-        self._prog = prog

-        self._indent_increment = indent_increment

-        self._max_help_position = max_help_position

-        self._width = width

-

-        self._current_indent = 0

-        self._level = 0

-        self._action_max_length = 0

-

-        self._root_section = self._Section(self, None)

-        self._current_section = self._root_section

-

-        self._whitespace_matcher = _re.compile(r'\s+')

-        self._long_break_matcher = _re.compile(r'\n\n\n+')

-

-    # ===============================

-    # Section and indentation methods

-    # ===============================

-    def _indent(self):

-        self._current_indent += self._indent_increment

-        self._level += 1

-

-    def _dedent(self):

-        self._current_indent -= self._indent_increment

-        assert self._current_indent >= 0, 'Indent decreased below 0.'

-        self._level -= 1

-

-    class _Section(object):

-

-        def __init__(self, formatter, parent, heading=None):

-            self.formatter = formatter

-            self.parent = parent

-            self.heading = heading

-            self.items = []

-

-        def format_help(self):

-            # format the indented section

-            if self.parent is not None:

-                self.formatter._indent()

-            join = self.formatter._join_parts

-            for func, args in self.items:

-                func(*args)

-            item_help = join([func(*args) for func, args in self.items])

-            if self.parent is not None:

-                self.formatter._dedent()

-

-            # return nothing if the section was empty

-            if not item_help:

-                return ''

-

-            # add the heading if the section was non-empty

-            if self.heading is not SUPPRESS and self.heading is not None:

-                current_indent = self.formatter._current_indent

-                heading = '%*s%s:\n' % (current_indent, '', self.heading)

-            else:

-                heading = ''

-

-            # join the section-initial newline, the heading and the help

-            return join(['\n', heading, item_help, '\n'])

-

-    def _add_item(self, func, args):

-        self._current_section.items.append((func, args))

-

-    # ========================

-    # Message building methods

-    # ========================

-    def start_section(self, heading):

-        self._indent()

-        section = self._Section(self, self._current_section, heading)

-        self._add_item(section.format_help, [])

-        self._current_section = section

-

-    def end_section(self):

-        self._current_section = self._current_section.parent

-        self._dedent()

-

-    def add_text(self, text):

-        if text is not SUPPRESS and text is not None:

-            self._add_item(self._format_text, [text])

-

-    def add_usage(self, usage, actions, groups, prefix=None):

-        if usage is not SUPPRESS:

-            args = usage, actions, groups, prefix

-            self._add_item(self._format_usage, args)

-

-    def add_argument(self, action):

-        if action.help is not SUPPRESS:

-

-            # find all invocations

-            get_invocation = self._format_action_invocation

-            invocations = [get_invocation(action)]

-            for subaction in self._iter_indented_subactions(action):

-                invocations.append(get_invocation(subaction))

-

-            # update the maximum item length

-            invocation_length = max([len(s) for s in invocations])

-            action_length = invocation_length + self._current_indent

-            self._action_max_length = max(self._action_max_length,

-                                          action_length)

-

-            # add the item to the list

-            self._add_item(self._format_action, [action])

-

-    def add_arguments(self, actions):

-        for action in actions:

-            self.add_argument(action)

-

-    # =======================

-    # Help-formatting methods

-    # =======================

-    def format_help(self):

-        help = self._root_section.format_help()

-        if help:

-            help = self._long_break_matcher.sub('\n\n', help)

-            help = help.strip('\n') + '\n'

-        return help

-

-    def _join_parts(self, part_strings):

-        return ''.join([part

-                        for part in part_strings

-                        if part and part is not SUPPRESS])

-

-    def _format_usage(self, usage, actions, groups, prefix):

-        if prefix is None:

-            prefix = _('usage: ')

-

-        # if usage is specified, use that

-        if usage is not None:

-            usage = usage % dict(prog=self._prog)

-

-        # if no optionals or positionals are available, usage is just prog

-        elif usage is None and not actions:

-            usage = '%(prog)s' % dict(prog=self._prog)

-

-        # if optionals and positionals are available, calculate usage

-        elif usage is None:

-            prog = '%(prog)s' % dict(prog=self._prog)

-

-            # split optionals from positionals

-            optionals = []

-            positionals = []

-            for action in actions:

-                if action.option_strings:

-                    optionals.append(action)

-                else:

-                    positionals.append(action)

-

-            # build full usage string

-            format = self._format_actions_usage

-            action_usage = format(optionals + positionals, groups)

-            usage = ' '.join([s for s in [prog, action_usage] if s])

-

-            # wrap the usage parts if it's too long

-            text_width = self._width - self._current_indent

-            if len(prefix) + len(usage) > text_width:

-

-                # break usage into wrappable parts

-                part_regexp = r'\(.*?\)+|\[.*?\]+|\S+'

-                opt_usage = format(optionals, groups)

-                pos_usage = format(positionals, groups)

-                opt_parts = _re.findall(part_regexp, opt_usage)

-                pos_parts = _re.findall(part_regexp, pos_usage)

-                assert ' '.join(opt_parts) == opt_usage

-                assert ' '.join(pos_parts) == pos_usage

-

-                # helper for wrapping lines

-                def get_lines(parts, indent, prefix=None):

-                    lines = []

-                    line = []

-                    if prefix is not None:

-                        line_len = len(prefix) - 1

-                    else:

-                        line_len = len(indent) - 1

-                    for part in parts:

-                        if line_len + 1 + len(part) > text_width:

-                            lines.append(indent + ' '.join(line))

-                            line = []

-                            line_len = len(indent) - 1

-                        line.append(part)

-                        line_len += len(part) + 1

-                    if line:

-                        lines.append(indent + ' '.join(line))

-                    if prefix is not None:

-                        lines[0] = lines[0][len(indent):]

-                    return lines

-

-                # if prog is short, follow it with optionals or positionals

-                if len(prefix) + len(prog) <= 0.75 * text_width:

-                    indent = ' ' * (len(prefix) + len(prog) + 1)

-                    if opt_parts:

-                        lines = get_lines([prog] + opt_parts, indent, prefix)

-                        lines.extend(get_lines(pos_parts, indent))

-                    elif pos_parts:

-                        lines = get_lines([prog] + pos_parts, indent, prefix)

-                    else:

-                        lines = [prog]

-

-                # if prog is long, put it on its own line

-                else:

-                    indent = ' ' * len(prefix)

-                    parts = opt_parts + pos_parts

-                    lines = get_lines(parts, indent)

-                    if len(lines) > 1:

-                        lines = []

-                        lines.extend(get_lines(opt_parts, indent))

-                        lines.extend(get_lines(pos_parts, indent))

-                    lines = [prog] + lines

-

-                # join lines into usage

-                usage = '\n'.join(lines)

-

-        # prefix with 'usage:'

-        return '%s%s\n\n' % (prefix, usage)

-

-    def _format_actions_usage(self, actions, groups):

-        # find group indices and identify actions in groups

-        group_actions = _set()

-        inserts = {}

-        for group in groups:

-            try:

-                start = actions.index(group._group_actions[0])

-            except ValueError:

-                continue

-            else:

-                end = start + len(group._group_actions)

-                if actions[start:end] == group._group_actions:

-                    for action in group._group_actions:

-                        group_actions.add(action)

-                    if not group.required:

-                        inserts[start] = '['

-                        inserts[end] = ']'

-                    else:

-                        inserts[start] = '('

-                        inserts[end] = ')'

-                    for i in range(start + 1, end):

-                        inserts[i] = '|'

-

-        # collect all actions format strings

-        parts = []

-        for i, action in enumerate(actions):

-

-            # suppressed arguments are marked with None

-            # remove | separators for suppressed arguments

-            if action.help is SUPPRESS:

-                parts.append(None)

-                if inserts.get(i) == '|':

-                    inserts.pop(i)

-                elif inserts.get(i + 1) == '|':

-                    inserts.pop(i + 1)

-

-            # produce all arg strings

-            elif not action.option_strings:

-                part = self._format_args(action, action.dest)

-

-                # if it's in a group, strip the outer []

-                if action in group_actions:

-                    if part[0] == '[' and part[-1] == ']':

-                        part = part[1:-1]

-

-                # add the action string to the list

-                parts.append(part)

-

-            # produce the first way to invoke the option in brackets

-            else:

-                option_string = action.option_strings[0]

-

-                # if the Optional doesn't take a value, format is:

-                #    -s or --long

-                if action.nargs == 0:

-                    part = '%s' % option_string

-

-                # if the Optional takes a value, format is:

-                #    -s ARGS or --long ARGS

-                else:

-                    default = action.dest.upper()

-                    args_string = self._format_args(action, default)

-                    part = '%s %s' % (option_string, args_string)

-

-                # make it look optional if it's not required or in a group

-                if not action.required and action not in group_actions:

-                    part = '[%s]' % part

-

-                # add the action string to the list

-                parts.append(part)

-

-        # insert things at the necessary indices

-        for i in _sorted(inserts, reverse=True):

-            parts[i:i] = [inserts[i]]

-

-        # join all the action items with spaces

-        text = ' '.join([item for item in parts if item is not None])

-

-        # clean up separators for mutually exclusive groups

-        open = r'[\[(]'

-        close = r'[\])]'

-        text = _re.sub(r'(%s) ' % open, r'\1', text)

-        text = _re.sub(r' (%s)' % close, r'\1', text)

-        text = _re.sub(r'%s *%s' % (open, close), r'', text)

-        text = _re.sub(r'\(([^|]*)\)', r'\1', text)

-        text = text.strip()

-

-        # return the text

-        return text

-

-    def _format_text(self, text):

-        if '%(prog)' in text:

-            text = text % dict(prog=self._prog)

-        text_width = self._width - self._current_indent

-        indent = ' ' * self._current_indent

-        return self._fill_text(text, text_width, indent) + '\n\n'

-

-    def _format_action(self, action):

-        # determine the required width and the entry label

-        help_position = min(self._action_max_length + 2,

-                            self._max_help_position)

-        help_width = self._width - help_position

-        action_width = help_position - self._current_indent - 2

-        action_header = self._format_action_invocation(action)

-

-        # ho nelp; start on same line and add a final newline

-        if not action.help:

-            tup = self._current_indent, '', action_header

-            action_header = '%*s%s\n' % tup

-

-        # short action name; start on the same line and pad two spaces

-        elif len(action_header) <= action_width:

-            tup = self._current_indent, '', action_width, action_header

-            action_header = '%*s%-*s  ' % tup

-            indent_first = 0

-

-        # long action name; start on the next line

-        else:

-            tup = self._current_indent, '', action_header

-            action_header = '%*s%s\n' % tup

-            indent_first = help_position

-

-        # collect the pieces of the action help

-        parts = [action_header]

-

-        # if there was help for the action, add lines of help text

-        if action.help:

-            help_text = self._expand_help(action)

-            help_lines = self._split_lines(help_text, help_width)

-            parts.append('%*s%s\n' % (indent_first, '', help_lines[0]))

-            for line in help_lines[1:]:

-                parts.append('%*s%s\n' % (help_position, '', line))

-

-        # or add a newline if the description doesn't end with one

-        elif not action_header.endswith('\n'):

-            parts.append('\n')

-

-        # if there are any sub-actions, add their help as well

-        for subaction in self._iter_indented_subactions(action):

-            parts.append(self._format_action(subaction))

-

-        # return a single string

-        return self._join_parts(parts)

-

-    def _format_action_invocation(self, action):

-        if not action.option_strings:

-            metavar, = self._metavar_formatter(action, action.dest)(1)

-            return metavar

-

-        else:

-            parts = []

-

-            # if the Optional doesn't take a value, format is:

-            #    -s, --long

-            if action.nargs == 0:

-                parts.extend(action.option_strings)

-

-            # if the Optional takes a value, format is:

-            #    -s ARGS, --long ARGS

-            else:

-                default = action.dest.upper()

-                args_string = self._format_args(action, default)

-                for option_string in action.option_strings:

-                    parts.append('%s %s' % (option_string, args_string))

-

-            return ', '.join(parts)

-

-    def _metavar_formatter(self, action, default_metavar):

-        if action.metavar is not None:

-            result = action.metavar

-        elif action.choices is not None:

-            choice_strs = [str(choice) for choice in action.choices]

-            result = '{%s}' % ','.join(choice_strs)

-        else:

-            result = default_metavar

-

-        def format(tuple_size):

-            if isinstance(result, tuple):

-                return result

-            else:

-                return (result, ) * tuple_size

-        return format

-

-    def _format_args(self, action, default_metavar):

-        get_metavar = self._metavar_formatter(action, default_metavar)

-        if action.nargs is None:

-            result = '%s' % get_metavar(1)

-        elif action.nargs == OPTIONAL:

-            result = '[%s]' % get_metavar(1)

-        elif action.nargs == ZERO_OR_MORE:

-            result = '[%s [%s ...]]' % get_metavar(2)

-        elif action.nargs == ONE_OR_MORE:

-            result = '%s [%s ...]' % get_metavar(2)

-        elif action.nargs == REMAINDER:

-            result = '...'

-        elif action.nargs == PARSER:

-            result = '%s ...' % get_metavar(1)

-        else:

-            formats = ['%s' for _ in range(action.nargs)]

-            result = ' '.join(formats) % get_metavar(action.nargs)

-        return result

-

-    def _expand_help(self, action):

-        params = dict(vars(action), prog=self._prog)

-        for name in list(params):

-            if params[name] is SUPPRESS:

-                del params[name]

-        for name in list(params):

-            if hasattr(params[name], '__name__'):

-                params[name] = params[name].__name__

-        if params.get('choices') is not None:

-            choices_str = ', '.join([str(c) for c in params['choices']])

-            params['choices'] = choices_str

-        return self._get_help_string(action) % params

-

-    def _iter_indented_subactions(self, action):

-        try:

-            get_subactions = action._get_subactions

-        except AttributeError:

-            pass

-        else:

-            self._indent()

-            for subaction in get_subactions():

-                yield subaction

-            self._dedent()

-

-    def _split_lines(self, text, width):

-        text = self._whitespace_matcher.sub(' ', text).strip()

-        return _textwrap.wrap(text, width)

-

-    def _fill_text(self, text, width, indent):

-        text = self._whitespace_matcher.sub(' ', text).strip()

-        return _textwrap.fill(text, width, initial_indent=indent,

-                                           subsequent_indent=indent)

-

-    def _get_help_string(self, action):

-        return action.help

-

-

-class RawDescriptionHelpFormatter(HelpFormatter):

-    """Help message formatter which retains any formatting in descriptions.

-

-    Only the name of this class is considered a public API. All the methods

-    provided by the class are considered an implementation detail.

-    """

-

-    def _fill_text(self, text, width, indent):

-        return ''.join([indent + line for line in text.splitlines(True)])

-

-

-class RawTextHelpFormatter(RawDescriptionHelpFormatter):

-    """Help message formatter which retains formatting of all help text.

-

-    Only the name of this class is considered a public API. All the methods

-    provided by the class are considered an implementation detail.

-    """

-

-    def _split_lines(self, text, width):

-        return text.splitlines()

-

-

-class ArgumentDefaultsHelpFormatter(HelpFormatter):

-    """Help message formatter which adds default values to argument help.

-

-    Only the name of this class is considered a public API. All the methods

-    provided by the class are considered an implementation detail.

-    """

-

-    def _get_help_string(self, action):

-        help = action.help

-        if '%(default)' not in action.help:

-            if action.default is not SUPPRESS:

-                defaulting_nargs = [OPTIONAL, ZERO_OR_MORE]

-                if action.option_strings or action.nargs in defaulting_nargs:

-                    help += ' (default: %(default)s)'

-        return help

-

-

-# =====================

-# Options and Arguments

-# =====================

-

-def _get_action_name(argument):

-    if argument is None:

-        return None

-    elif argument.option_strings:

-        return  '/'.join(argument.option_strings)

-    elif argument.metavar not in (None, SUPPRESS):

-        return argument.metavar

-    elif argument.dest not in (None, SUPPRESS):

-        return argument.dest

-    else:

-        return None

-

-

-class ArgumentError(Exception):

-    """An error from creating or using an argument (optional or positional).

-

-    The string value of this exception is the message, augmented with

-    information about the argument that caused it.

-    """

-

-    def __init__(self, argument, message):

-        self.argument_name = _get_action_name(argument)

-        self.message = message

-

-    def __str__(self):

-        if self.argument_name is None:

-            format = '%(message)s'

-        else:

-            format = 'argument %(argument_name)s: %(message)s'

-        return format % dict(message=self.message,

-                             argument_name=self.argument_name)

-

-

-class ArgumentTypeError(Exception):

-    """An error from trying to convert a command line string to a type."""

-    pass

-

-

-# ==============

-# Action classes

-# ==============

-

-class Action(_AttributeHolder):

-    """Information about how to convert command line strings to Python objects.

-

-    Action objects are used by an ArgumentParser to represent the information

-    needed to parse a single argument from one or more strings from the

-    command line. The keyword arguments to the Action constructor are also

-    all attributes of Action instances.

-

-    Keyword Arguments:

-

-        - option_strings -- A list of command-line option strings which

-            should be associated with this action.

-

-        - dest -- The name of the attribute to hold the created object(s)

-

-        - nargs -- The number of command-line arguments that should be

-            consumed. By default, one argument will be consumed and a single

-            value will be produced.  Other values include:

-                - N (an integer) consumes N arguments (and produces a list)

-                - '?' consumes zero or one arguments

-                - '*' consumes zero or more arguments (and produces a list)

-                - '+' consumes one or more arguments (and produces a list)

-            Note that the difference between the default and nargs=1 is that

-            with the default, a single value will be produced, while with

-            nargs=1, a list containing a single value will be produced.

-

-        - const -- The value to be produced if the option is specified and the

-            option uses an action that takes no values.

-

-        - default -- The value to be produced if the option is not specified.

-

-        - type -- The type which the command-line arguments should be converted

-            to, should be one of 'string', 'int', 'float', 'complex' or a

-            callable object that accepts a single string argument. If None,

-            'string' is assumed.

-

-        - choices -- A container of values that should be allowed. If not None,

-            after a command-line argument has been converted to the appropriate

-            type, an exception will be raised if it is not a member of this

-            collection.

-

-        - required -- True if the action must always be specified at the

-            command line. This is only meaningful for optional command-line

-            arguments.

-

-        - help -- The help string describing the argument.

-

-        - metavar -- The name to be used for the option's argument with the

-            help string. If None, the 'dest' value will be used as the name.

-    """

-

-    def __init__(self,

-                 option_strings,

-                 dest,

-                 nargs=None,

-                 const=None,

-                 default=None,

-                 type=None,

-                 choices=None,

-                 required=False,

-                 help=None,

-                 metavar=None):

-        self.option_strings = option_strings

-        self.dest = dest

-        self.nargs = nargs

-        self.const = const

-        self.default = default

-        self.type = type

-        self.choices = choices

-        self.required = required

-        self.help = help

-        self.metavar = metavar

-

-    def _get_kwargs(self):

-        names = [

-            'option_strings',

-            'dest',

-            'nargs',

-            'const',

-            'default',

-            'type',

-            'choices',

-            'help',

-            'metavar',

-        ]

-        return [(name, getattr(self, name)) for name in names]

-

-    def __call__(self, parser, namespace, values, option_string=None):

-        raise NotImplementedError(_('.__call__() not defined'))

-

-

-class _StoreAction(Action):

-

-    def __init__(self,

-                 option_strings,

-                 dest,

-                 nargs=None,

-                 const=None,

-                 default=None,

-                 type=None,

-                 choices=None,

-                 required=False,

-                 help=None,

-                 metavar=None):

-        if nargs == 0:

-            raise ValueError('nargs for store actions must be > 0; if you '

-                             'have nothing to store, actions such as store '

-                             'true or store const may be more appropriate')

-        if const is not None and nargs != OPTIONAL:

-            raise ValueError('nargs must be %r to supply const' % OPTIONAL)

-        super(_StoreAction, self).__init__(

-            option_strings=option_strings,

-            dest=dest,

-            nargs=nargs,

-            const=const,

-            default=default,

-            type=type,

-            choices=choices,

-            required=required,

-            help=help,

-            metavar=metavar)

-

-    def __call__(self, parser, namespace, values, option_string=None):

-        setattr(namespace, self.dest, values)

-

-

-class _StoreConstAction(Action):

-

-    def __init__(self,

-                 option_strings,

-                 dest,

-                 const,

-                 default=None,

-                 required=False,

-                 help=None,

-                 metavar=None):

-        super(_StoreConstAction, self).__init__(

-            option_strings=option_strings,

-            dest=dest,

-            nargs=0,

-            const=const,

-            default=default,

-            required=required,

-            help=help)

-

-    def __call__(self, parser, namespace, values, option_string=None):

-        setattr(namespace, self.dest, self.const)

-

-

-class _StoreTrueAction(_StoreConstAction):

-

-    def __init__(self,

-                 option_strings,

-                 dest,

-                 default=False,

-                 required=False,

-                 help=None):

-        super(_StoreTrueAction, self).__init__(

-            option_strings=option_strings,

-            dest=dest,

-            const=True,

-            default=default,

-            required=required,

-            help=help)

-

-

-class _StoreFalseAction(_StoreConstAction):

-

-    def __init__(self,

-                 option_strings,

-                 dest,

-                 default=True,

-                 required=False,

-                 help=None):

-        super(_StoreFalseAction, self).__init__(

-            option_strings=option_strings,

-            dest=dest,

-            const=False,

-            default=default,

-            required=required,

-            help=help)

-

-

-class _AppendAction(Action):

-

-    def __init__(self,

-                 option_strings,

-                 dest,

-                 nargs=None,

-                 const=None,

-                 default=None,

-                 type=None,

-                 choices=None,

-                 required=False,

-                 help=None,

-                 metavar=None):

-        if nargs == 0:

-            raise ValueError('nargs for append actions must be > 0; if arg '

-                             'strings are not supplying the value to append, '

-                             'the append const action may be more appropriate')

-        if const is not None and nargs != OPTIONAL:

-            raise ValueError('nargs must be %r to supply const' % OPTIONAL)

-        super(_AppendAction, self).__init__(

-            option_strings=option_strings,

-            dest=dest,

-            nargs=nargs,

-            const=const,

-            default=default,

-            type=type,

-            choices=choices,

-            required=required,

-            help=help,

-            metavar=metavar)

-

-    def __call__(self, parser, namespace, values, option_string=None):

-        items = _copy.copy(_ensure_value(namespace, self.dest, []))

-        items.append(values)

-        setattr(namespace, self.dest, items)

-

-

-class _AppendConstAction(Action):

-

-    def __init__(self,

-                 option_strings,

-                 dest,

-                 const,

-                 default=None,

-                 required=False,

-                 help=None,

-                 metavar=None):

-        super(_AppendConstAction, self).__init__(

-            option_strings=option_strings,

-            dest=dest,

-            nargs=0,

-            const=const,

-            default=default,

-            required=required,

-            help=help,

-            metavar=metavar)

-

-    def __call__(self, parser, namespace, values, option_string=None):

-        items = _copy.copy(_ensure_value(namespace, self.dest, []))

-        items.append(self.const)

-        setattr(namespace, self.dest, items)

-

-

-class _CountAction(Action):

-

-    def __init__(self,

-                 option_strings,

-                 dest,

-                 default=None,

-                 required=False,

-                 help=None):

-        super(_CountAction, self).__init__(

-            option_strings=option_strings,

-            dest=dest,

-            nargs=0,

-            default=default,

-            required=required,

-            help=help)

-

-    def __call__(self, parser, namespace, values, option_string=None):

-        new_count = _ensure_value(namespace, self.dest, 0) + 1

-        setattr(namespace, self.dest, new_count)

-

-

-class _HelpAction(Action):

-

-    def __init__(self,

-                 option_strings,

-                 dest=SUPPRESS,

-                 default=SUPPRESS,

-                 help=None):

-        super(_HelpAction, self).__init__(

-            option_strings=option_strings,

-            dest=dest,

-            default=default,

-            nargs=0,

-            help=help)

-

-    def __call__(self, parser, namespace, values, option_string=None):

-        parser.print_help()

-        parser.exit()

-

-

-class _VersionAction(Action):

-

-    def __init__(self,

-                 option_strings,

-                 version=None,

-                 dest=SUPPRESS,

-                 default=SUPPRESS,

-                 help=None):

-        super(_VersionAction, self).__init__(

-            option_strings=option_strings,

-            dest=dest,

-            default=default,

-            nargs=0,

-            help=help)

-        self.version = version

-

-    def __call__(self, parser, namespace, values, option_string=None):

-        version = self.version

-        if version is None:

-            version = parser.version

-        formatter = parser._get_formatter()

-        formatter.add_text(version)

-        parser.exit(message=formatter.format_help())

-

-

-class _SubParsersAction(Action):

-

-    class _ChoicesPseudoAction(Action):

-

-        def __init__(self, name, help):

-            sup = super(_SubParsersAction._ChoicesPseudoAction, self)

-            sup.__init__(option_strings=[], dest=name, help=help)

-

-    def __init__(self,

-                 option_strings,

-                 prog,

-                 parser_class,

-                 dest=SUPPRESS,

-                 help=None,

-                 metavar=None):

-

-        self._prog_prefix = prog

-        self._parser_class = parser_class

-        self._name_parser_map = {}

-        self._choices_actions = []

-

-        super(_SubParsersAction, self).__init__(

-            option_strings=option_strings,

-            dest=dest,

-            nargs=PARSER,

-            choices=self._name_parser_map,

-            help=help,

-            metavar=metavar)

-

-    def add_parser(self, name, **kwargs):

-        # set prog from the existing prefix

-        if kwargs.get('prog') is None:

-            kwargs['prog'] = '%s %s' % (self._prog_prefix, name)

-

-        # create a pseudo-action to hold the choice help

-        if 'help' in kwargs:

-            help = kwargs.pop('help')

-            choice_action = self._ChoicesPseudoAction(name, help)

-            self._choices_actions.append(choice_action)

-

-        # create the parser and add it to the map

-        parser = self._parser_class(**kwargs)

-        self._name_parser_map[name] = parser

-        return parser

-

-    def _get_subactions(self):

-        return self._choices_actions

-

-    def __call__(self, parser, namespace, values, option_string=None):

-        parser_name = values[0]

-        arg_strings = values[1:]

-

-        # set the parser name if requested

-        if self.dest is not SUPPRESS:

-            setattr(namespace, self.dest, parser_name)

-

-        # select the parser

-        try:

-            parser = self._name_parser_map[parser_name]

-        except KeyError:

-            tup = parser_name, ', '.join(self._name_parser_map)

-            msg = _('unknown parser %r (choices: %s)' % tup)

-            raise ArgumentError(self, msg)

-

-        # parse all the remaining options into the namespace

-        parser.parse_args(arg_strings, namespace)

-

-

-# ==============

-# Type classes

-# ==============

-

-class FileType(object):

-    """Factory for creating file object types

-

-    Instances of FileType are typically passed as type= arguments to the

-    ArgumentParser add_argument() method.

-

-    Keyword Arguments:

-        - mode -- A string indicating how the file is to be opened. Accepts the

-            same values as the builtin open() function.

-        - bufsize -- The file's desired buffer size. Accepts the same values as

-            the builtin open() function.

-    """

-

-    def __init__(self, mode='r', bufsize=None):

-        self._mode = mode

-        self._bufsize = bufsize

-

-    def __call__(self, string):

-        # the special argument "-" means sys.std{in,out}

-        if string == '-':

-            if 'r' in self._mode:

-                return _sys.stdin

-            elif 'w' in self._mode:

-                return _sys.stdout

-            else:

-                msg = _('argument "-" with mode %r' % self._mode)

-                raise ValueError(msg)

-

-        # all other arguments are used as file names

-        if self._bufsize:

-            return open(string, self._mode, self._bufsize)

-        else:

-            return open(string, self._mode)

-

-    def __repr__(self):

-        args = [self._mode, self._bufsize]

-        args_str = ', '.join([repr(arg) for arg in args if arg is not None])

-        return '%s(%s)' % (type(self).__name__, args_str)

-

-# ===========================

-# Optional and Positional Parsing

-# ===========================

-

-class Namespace(_AttributeHolder):

-    """Simple object for storing attributes.

-

-    Implements equality by attribute names and values, and provides a simple

-    string representation.

-    """

-

-    def __init__(self, **kwargs):

-        for name in kwargs:

-            setattr(self, name, kwargs[name])

-

-    def __eq__(self, other):

-        return vars(self) == vars(other)

-

-    def __ne__(self, other):

-        return not (self == other)

-

-    def __contains__(self, key):

-        return key in self.__dict__

-

-

-class _ActionsContainer(object):

-

-    def __init__(self,

-                 description,

-                 prefix_chars,

-                 argument_default,

-                 conflict_handler):

-        super(_ActionsContainer, self).__init__()

-

-        self.description = description

-        self.argument_default = argument_default

-        self.prefix_chars = prefix_chars

-        self.conflict_handler = conflict_handler

-

-        # set up registries

-        self._registries = {}

-

-        # register actions

-        self.register('action', None, _StoreAction)

-        self.register('action', 'store', _StoreAction)

-        self.register('action', 'store_const', _StoreConstAction)

-        self.register('action', 'store_true', _StoreTrueAction)

-        self.register('action', 'store_false', _StoreFalseAction)

-        self.register('action', 'append', _AppendAction)

-        self.register('action', 'append_const', _AppendConstAction)

-        self.register('action', 'count', _CountAction)

-        self.register('action', 'help', _HelpAction)

-        self.register('action', 'version', _VersionAction)

-        self.register('action', 'parsers', _SubParsersAction)

-

-        # raise an exception if the conflict handler is invalid

-        self._get_handler()

-

-        # action storage

-        self._actions = []

-        self._option_string_actions = {}

-

-        # groups

-        self._action_groups = []

-        self._mutually_exclusive_groups = []

-

-        # defaults storage

-        self._defaults = {}

-

-        # determines whether an "option" looks like a negative number

-        self._negative_number_matcher = _re.compile(r'^-\d+$|^-\d*\.\d+$')

-

-        # whether or not there are any optionals that look like negative

-        # numbers -- uses a list so it can be shared and edited

-        self._has_negative_number_optionals = []

-

-    # ====================

-    # Registration methods

-    # ====================

-    def register(self, registry_name, value, object):

-        registry = self._registries.setdefault(registry_name, {})

-        registry[value] = object

-

-    def _registry_get(self, registry_name, value, default=None):

-        return self._registries[registry_name].get(value, default)

-

-    # ==================================

-    # Namespace default accessor methods

-    # ==================================

-    def set_defaults(self, **kwargs):

-        self._defaults.update(kwargs)

-

-        # if these defaults match any existing arguments, replace

-        # the previous default on the object with the new one

-        for action in self._actions:

-            if action.dest in kwargs:

-                action.default = kwargs[action.dest]

-

-    def get_default(self, dest):

-        for action in self._actions:

-            if action.dest == dest and action.default is not None:

-                return action.default

-        return self._defaults.get(dest, None)

-

-

-    # =======================

-    # Adding argument actions

-    # =======================

-    def add_argument(self, *args, **kwargs):

-        """

-        add_argument(dest, ..., name=value, ...)

-        add_argument(option_string, option_string, ..., name=value, ...)

-        """

-

-        # if no positional args are supplied or only one is supplied and

-        # it doesn't look like an option string, parse a positional

-        # argument

-        chars = self.prefix_chars

-        if not args or len(args) == 1 and args[0][0] not in chars:

-            if args and 'dest' in kwargs:

-                raise ValueError('dest supplied twice for positional argument')

-            kwargs = self._get_positional_kwargs(*args, **kwargs)

-

-        # otherwise, we're adding an optional argument

-        else:

-            kwargs = self._get_optional_kwargs(*args, **kwargs)

-

-        # if no default was supplied, use the parser-level default

-        if 'default' not in kwargs:

-            dest = kwargs['dest']

-            if dest in self._defaults:

-                kwargs['default'] = self._defaults[dest]

-            elif self.argument_default is not None:

-                kwargs['default'] = self.argument_default

-

-        # create the action object, and add it to the parser

-        action_class = self._pop_action_class(kwargs)

-        if not _callable(action_class):

-            raise ValueError('unknown action "%s"' % action_class)

-        action = action_class(**kwargs)

-

-        # raise an error if the action type is not callable

-        type_func = self._registry_get('type', action.type, action.type)

-        if not _callable(type_func):

-            raise ValueError('%r is not callable' % type_func)

-

-        return self._add_action(action)

-

-    def add_argument_group(self, *args, **kwargs):

-        group = _ArgumentGroup(self, *args, **kwargs)

-        self._action_groups.append(group)

-        return group

-

-    def add_mutually_exclusive_group(self, **kwargs):

-        group = _MutuallyExclusiveGroup(self, **kwargs)

-        self._mutually_exclusive_groups.append(group)

-        return group

-

-    def _add_action(self, action):

-        # resolve any conflicts

-        self._check_conflict(action)

-

-        # add to actions list

-        self._actions.append(action)

-        action.container = self

-

-        # index the action by any option strings it has

-        for option_string in action.option_strings:

-            self._option_string_actions[option_string] = action

-

-        # set the flag if any option strings look like negative numbers

-        for option_string in action.option_strings:

-            if self._negative_number_matcher.match(option_string):

-                if not self._has_negative_number_optionals:

-                    self._has_negative_number_optionals.append(True)

-

-        # return the created action

-        return action

-

-    def _remove_action(self, action):

-        self._actions.remove(action)

-

-    def _add_container_actions(self, container):

-        # collect groups by titles

-        title_group_map = {}

-        for group in self._action_groups:

-            if group.title in title_group_map:

-                msg = _('cannot merge actions - two groups are named %r')

-                raise ValueError(msg % (group.title))

-            title_group_map[group.title] = group

-

-        # map each action to its group

-        group_map = {}

-        for group in container._action_groups:

-

-            # if a group with the title exists, use that, otherwise

-            # create a new group matching the container's group

-            if group.title not in title_group_map:

-                title_group_map[group.title] = self.add_argument_group(

-                    title=group.title,

-                    description=group.description,

-                    conflict_handler=group.conflict_handler)

-

-            # map the actions to their new group

-            for action in group._group_actions:

-                group_map[action] = title_group_map[group.title]

-

-        # add container's mutually exclusive groups

-        # NOTE: if add_mutually_exclusive_group ever gains title= and

-        # description= then this code will need to be expanded as above

-        for group in container._mutually_exclusive_groups:

-            mutex_group = self.add_mutually_exclusive_group(

-                required=group.required)

-

-            # map the actions to their new mutex group

-            for action in group._group_actions:

-                group_map[action] = mutex_group

-

-        # add all actions to this container or their group

-        for action in container._actions:

-            group_map.get(action, self)._add_action(action)

-

-    def _get_positional_kwargs(self, dest, **kwargs):

-        # make sure required is not specified

-        if 'required' in kwargs:

-            msg = _("'required' is an invalid argument for positionals")

-            raise TypeError(msg)

-

-        # mark positional arguments as required if at least one is

-        # always required

-        if kwargs.get('nargs') not in [OPTIONAL, ZERO_OR_MORE]:

-            kwargs['required'] = True

-        if kwargs.get('nargs') == ZERO_OR_MORE and 'default' not in kwargs:

-            kwargs['required'] = True

-

-        # return the keyword arguments with no option strings

-        return dict(kwargs, dest=dest, option_strings=[])

-

-    def _get_optional_kwargs(self, *args, **kwargs):

-        # determine short and long option strings

-        option_strings = []

-        long_option_strings = []

-        for option_string in args:

-            # error on strings that don't start with an appropriate prefix

-            if not option_string[0] in self.prefix_chars:

-                msg = _('invalid option string %r: '

-                        'must start with a character %r')

-                tup = option_string, self.prefix_chars

-                raise ValueError(msg % tup)

-

-            # strings starting with two prefix characters are long options

-            option_strings.append(option_string)

-            if option_string[0] in self.prefix_chars:

-                if len(option_string) > 1:

-                    if option_string[1] in self.prefix_chars:

-                        long_option_strings.append(option_string)

-

-        # infer destination, '--foo-bar' -> 'foo_bar' and '-x' -> 'x'

-        dest = kwargs.pop('dest', None)

-        if dest is None:

-            if long_option_strings:

-                dest_option_string = long_option_strings[0]

-            else:

-                dest_option_string = option_strings[0]

-            dest = dest_option_string.lstrip(self.prefix_chars)

-            if not dest:

-                msg = _('dest= is required for options like %r')

-                raise ValueError(msg % option_string)

-            dest = dest.replace('-', '_')

-

-        # return the updated keyword arguments

-        return dict(kwargs, dest=dest, option_strings=option_strings)

-

-    def _pop_action_class(self, kwargs, default=None):

-        action = kwargs.pop('action', default)

-        return self._registry_get('action', action, action)

-

-    def _get_handler(self):

-        # determine function from conflict handler string

-        handler_func_name = '_handle_conflict_%s' % self.conflict_handler

-        try:

-            return getattr(self, handler_func_name)

-        except AttributeError:

-            msg = _('invalid conflict_resolution value: %r')

-            raise ValueError(msg % self.conflict_handler)

-

-    def _check_conflict(self, action):

-

-        # find all options that conflict with this option

-        confl_optionals = []

-        for option_string in action.option_strings:

-            if option_string in self._option_string_actions:

-                confl_optional = self._option_string_actions[option_string]

-                confl_optionals.append((option_string, confl_optional))

-

-        # resolve any conflicts

-        if confl_optionals:

-            conflict_handler = self._get_handler()

-            conflict_handler(action, confl_optionals)

-

-    def _handle_conflict_error(self, action, conflicting_actions):

-        message = _('conflicting option string(s): %s')

-        conflict_string = ', '.join([option_string

-                                     for option_string, action

-                                     in conflicting_actions])

-        raise ArgumentError(action, message % conflict_string)

-

-    def _handle_conflict_resolve(self, action, conflicting_actions):

-

-        # remove all conflicting options

-        for option_string, action in conflicting_actions:

-

-            # remove the conflicting option

-            action.option_strings.remove(option_string)

-            self._option_string_actions.pop(option_string, None)

-

-            # if the option now has no option string, remove it from the

-            # container holding it

-            if not action.option_strings:

-                action.container._remove_action(action)

-

-

-class _ArgumentGroup(_ActionsContainer):

-

-    def __init__(self, container, title=None, description=None, **kwargs):

-        # add any missing keyword arguments by checking the container

-        update = kwargs.setdefault

-        update('conflict_handler', container.conflict_handler)

-        update('prefix_chars', container.prefix_chars)

-        update('argument_default', container.argument_default)

-        super_init = super(_ArgumentGroup, self).__init__

-        super_init(description=description, **kwargs)

-

-        # group attributes

-        self.title = title

-        self._group_actions = []

-

-        # share most attributes with the container

-        self._registries = container._registries

-        self._actions = container._actions

-        self._option_string_actions = container._option_string_actions

-        self._defaults = container._defaults

-        self._has_negative_number_optionals = \

-            container._has_negative_number_optionals

-

-    def _add_action(self, action):

-        action = super(_ArgumentGroup, self)._add_action(action)

-        self._group_actions.append(action)

-        return action

-

-    def _remove_action(self, action):

-        super(_ArgumentGroup, self)._remove_action(action)

-        self._group_actions.remove(action)

-

-

-class _MutuallyExclusiveGroup(_ArgumentGroup):

-

-    def __init__(self, container, required=False):

-        super(_MutuallyExclusiveGroup, self).__init__(container)

-        self.required = required

-        self._container = container

-

-    def _add_action(self, action):

-        if action.required:

-            msg = _('mutually exclusive arguments must be optional')

-            raise ValueError(msg)

-        action = self._container._add_action(action)

-        self._group_actions.append(action)

-        return action

-

-    def _remove_action(self, action):

-        self._container._remove_action(action)

-        self._group_actions.remove(action)

-

-

-class ArgumentParser(_AttributeHolder, _ActionsContainer):

-    """Object for parsing command line strings into Python objects.

-

-    Keyword Arguments:

-        - prog -- The name of the program (default: sys.argv[0])

-        - usage -- A usage message (default: auto-generated from arguments)

-        - description -- A description of what the program does

-        - epilog -- Text following the argument descriptions

-        - parents -- Parsers whose arguments should be copied into this one

-        - formatter_class -- HelpFormatter class for printing help messages

-        - prefix_chars -- Characters that prefix optional arguments

-        - fromfile_prefix_chars -- Characters that prefix files containing

-            additional arguments

-        - argument_default -- The default value for all arguments

-        - conflict_handler -- String indicating how to handle conflicts

-        - add_help -- Add a -h/-help option

-    """

-

-    def __init__(self,

-                 prog=None,

-                 usage=None,

-                 description=None,

-                 epilog=None,

-                 version=None,

-                 parents=[],

-                 formatter_class=HelpFormatter,

-                 prefix_chars='-',

-                 fromfile_prefix_chars=None,

-                 argument_default=None,

-                 conflict_handler='error',

-                 add_help=True):

-

-        if version is not None:

-            import warnings

-            warnings.warn(

-                """The "version" argument to ArgumentParser is deprecated. """

-                """Please use """

-                """"add_argument(..., action='version', version="N", ...)" """

-                """instead""", DeprecationWarning)

-

-        superinit = super(ArgumentParser, self).__init__

-        superinit(description=description,

-                  prefix_chars=prefix_chars,

-                  argument_default=argument_default,

-                  conflict_handler=conflict_handler)

-

-        # default setting for prog

-        if prog is None:

-            prog = _os.path.basename(_sys.argv[0])

-

-        self.prog = prog

-        self.usage = usage

-        self.epilog = epilog

-        self.version = version

-        self.formatter_class = formatter_class

-        self.fromfile_prefix_chars = fromfile_prefix_chars

-        self.add_help = add_help

-

-        add_group = self.add_argument_group

-        self._positionals = add_group(_('positional arguments'))

-        self._optionals = add_group(_('optional arguments'))

-        self._subparsers = None

-

-        # register types

-        def identity(string):

-            return string

-        self.register('type', None, identity)

-

-        # add help and version arguments if necessary

-        # (using explicit default to override global argument_default)

-        if self.add_help:

-            self.add_argument(

-                '-h', '--help', action='help', default=SUPPRESS,

-                help=_('show this help message and exit'))

-        if self.version:

-            self.add_argument(

-                '-v', '--version', action='version', default=SUPPRESS,

-                version=self.version,

-                help=_("show program's version number and exit"))

-

-        # add parent arguments and defaults

-        for parent in parents:

-            self._add_container_actions(parent)

-            try:

-                defaults = parent._defaults

-            except AttributeError:

-                pass

-            else:

-                self._defaults.update(defaults)

-

-    # =======================

-    # Pretty __repr__ methods

-    # =======================

-    def _get_kwargs(self):

-        names = [

-            'prog',

-            'usage',

-            'description',

-            'version',

-            'formatter_class',

-            'conflict_handler',

-            'add_help',

-        ]

-        return [(name, getattr(self, name)) for name in names]

-

-    # ==================================

-    # Optional/Positional adding methods

-    # ==================================

-    def add_subparsers(self, **kwargs):

-        if self._subparsers is not None:

-            self.error(_('cannot have multiple subparser arguments'))

-

-        # add the parser class to the arguments if it's not present

-        kwargs.setdefault('parser_class', type(self))

-

-        if 'title' in kwargs or 'description' in kwargs:

-            title = _(kwargs.pop('title', 'subcommands'))

-            description = _(kwargs.pop('description', None))

-            self._subparsers = self.add_argument_group(title, description)

-        else:

-            self._subparsers = self._positionals

-

-        # prog defaults to the usage message of this parser, skipping

-        # optional arguments and with no "usage:" prefix

-        if kwargs.get('prog') is None:

-            formatter = self._get_formatter()

-            positionals = self._get_positional_actions()

-            groups = self._mutually_exclusive_groups

-            formatter.add_usage(self.usage, positionals, groups, '')

-            kwargs['prog'] = formatter.format_help().strip()

-

-        # create the parsers action and add it to the positionals list

-        parsers_class = self._pop_action_class(kwargs, 'parsers')

-        action = parsers_class(option_strings=[], **kwargs)

-        self._subparsers._add_action(action)

-

-        # return the created parsers action

-        return action

-

-    def _add_action(self, action):

-        if action.option_strings:

-            self._optionals._add_action(action)

-        else:

-            self._positionals._add_action(action)

-        return action

-

-    def _get_optional_actions(self):

-        return [action

-                for action in self._actions

-                if action.option_strings]

-

-    def _get_positional_actions(self):

-        return [action

-                for action in self._actions

-                if not action.option_strings]

-

-    # =====================================

-    # Command line argument parsing methods

-    # =====================================

-    def parse_args(self, args=None, namespace=None):

-        args, argv = self.parse_known_args(args, namespace)

-        if argv:

-            msg = _('unrecognized arguments: %s')

-            self.error(msg % ' '.join(argv))

-        return args

-

-    def parse_known_args(self, args=None, namespace=None):

-        # args default to the system args

-        if args is None:

-            args = _sys.argv[1:]

-

-        # default Namespace built from parser defaults

-        if namespace is None:

-            namespace = Namespace()

-

-        # add any action defaults that aren't present

-        for action in self._actions:

-            if action.dest is not SUPPRESS:

-                if not hasattr(namespace, action.dest):

-                    if action.default is not SUPPRESS:

-                        default = action.default

-                        if isinstance(action.default, _basestring):

-                            default = self._get_value(action, default)

-                        setattr(namespace, action.dest, default)

-

-        # add any parser defaults that aren't present

-        for dest in self._defaults:

-            if not hasattr(namespace, dest):

-                setattr(namespace, dest, self._defaults[dest])

-

-        # parse the arguments and exit if there are any errors

-        try:

-            return self._parse_known_args(args, namespace)

-        except ArgumentError:

-            err = _sys.exc_info()[1]

-            self.error(str(err))

-

-    def _parse_known_args(self, arg_strings, namespace):

-        # replace arg strings that are file references

-        if self.fromfile_prefix_chars is not None:

-            arg_strings = self._read_args_from_files(arg_strings)

-

-        # map all mutually exclusive arguments to the other arguments

-        # they can't occur with

-        action_conflicts = {}

-        for mutex_group in self._mutually_exclusive_groups:

-            group_actions = mutex_group._group_actions

-            for i, mutex_action in enumerate(mutex_group._group_actions):

-                conflicts = action_conflicts.setdefault(mutex_action, [])

-                conflicts.extend(group_actions[:i])

-                conflicts.extend(group_actions[i + 1:])

-

-        # find all option indices, and determine the arg_string_pattern

-        # which has an 'O' if there is an option at an index,

-        # an 'A' if there is an argument, or a '-' if there is a '--'

-        option_string_indices = {}

-        arg_string_pattern_parts = []

-        arg_strings_iter = iter(arg_strings)

-        for i, arg_string in enumerate(arg_strings_iter):

-

-            # all args after -- are non-options

-            if arg_string == '--':

-                arg_string_pattern_parts.append('-')

-                for arg_string in arg_strings_iter:

-                    arg_string_pattern_parts.append('A')

-

-            # otherwise, add the arg to the arg strings

-            # and note the index if it was an option

-            else:

-                option_tuple = self._parse_optional(arg_string)

-                if option_tuple is None:

-                    pattern = 'A'

-                else:

-                    option_string_indices[i] = option_tuple

-                    pattern = 'O'

-                arg_string_pattern_parts.append(pattern)

-

-        # join the pieces together to form the pattern

-        arg_strings_pattern = ''.join(arg_string_pattern_parts)

-

-        # converts arg strings to the appropriate and then takes the action

-        seen_actions = _set()

-        seen_non_default_actions = _set()

-

-        def take_action(action, argument_strings, option_string=None):

-            seen_actions.add(action)

-            argument_values = self._get_values(action, argument_strings)

-

-            # error if this argument is not allowed with other previously

-            # seen arguments, assuming that actions that use the default

-            # value don't really count as "present"

-            if argument_values is not action.default:

-                seen_non_default_actions.add(action)

-                for conflict_action in action_conflicts.get(action, []):

-                    if conflict_action in seen_non_default_actions:

-                        msg = _('not allowed with argument %s')

-                        action_name = _get_action_name(conflict_action)

-                        raise ArgumentError(action, msg % action_name)

-

-            # take the action if we didn't receive a SUPPRESS value

-            # (e.g. from a default)

-            if argument_values is not SUPPRESS:

-                action(self, namespace, argument_values, option_string)

-

-        # function to convert arg_strings into an optional action

-        def consume_optional(start_index):

-

-            # get the optional identified at this index

-            option_tuple = option_string_indices[start_index]

-            action, option_string, explicit_arg = option_tuple

-

-            # identify additional optionals in the same arg string

-            # (e.g. -xyz is the same as -x -y -z if no args are required)

-            match_argument = self._match_argument

-            action_tuples = []

-            while True:

-

-                # if we found no optional action, skip it

-                if action is None:

-                    extras.append(arg_strings[start_index])

-                    return start_index + 1

-

-                # if there is an explicit argument, try to match the

-                # optional's string arguments to only this

-                if explicit_arg is not None:

-                    arg_count = match_argument(action, 'A')

-

-                    # if the action is a single-dash option and takes no

-                    # arguments, try to parse more single-dash options out

-                    # of the tail of the option string

-                    chars = self.prefix_chars

-                    if arg_count == 0 and option_string[1] not in chars:

-                        action_tuples.append((action, [], option_string))

-                        for char in self.prefix_chars:

-                            option_string = char + explicit_arg[0]

-                            explicit_arg = explicit_arg[1:] or None

-                            optionals_map = self._option_string_actions

-                            if option_string in optionals_map:

-                                action = optionals_map[option_string]

-                                break

-                        else:

-                            msg = _('ignored explicit argument %r')

-                            raise ArgumentError(action, msg % explicit_arg)

-

-                    # if the action expect exactly one argument, we've

-                    # successfully matched the option; exit the loop

-                    elif arg_count == 1:

-                        stop = start_index + 1

-                        args = [explicit_arg]

-                        action_tuples.append((action, args, option_string))

-                        break

-

-                    # error if a double-dash option did not use the

-                    # explicit argument

-                    else:

-                        msg = _('ignored explicit argument %r')

-                        raise ArgumentError(action, msg % explicit_arg)

-

-                # if there is no explicit argument, try to match the

-                # optional's string arguments with the following strings

-                # if successful, exit the loop

-                else:

-                    start = start_index + 1

-                    selected_patterns = arg_strings_pattern[start:]

-                    arg_count = match_argument(action, selected_patterns)

-                    stop = start + arg_count

-                    args = arg_strings[start:stop]

-                    action_tuples.append((action, args, option_string))

-                    break

-

-            # add the Optional to the list and return the index at which

-            # the Optional's string args stopped

-            assert action_tuples

-            for action, args, option_string in action_tuples:

-                take_action(action, args, option_string)

-            return stop

-

-        # the list of Positionals left to be parsed; this is modified

-        # by consume_positionals()

-        positionals = self._get_positional_actions()

-

-        # function to convert arg_strings into positional actions

-        def consume_positionals(start_index):

-            # match as many Positionals as possible

-            match_partial = self._match_arguments_partial

-            selected_pattern = arg_strings_pattern[start_index:]

-            arg_counts = match_partial(positionals, selected_pattern)

-

-            # slice off the appropriate arg strings for each Positional

-            # and add the Positional and its args to the list

-            for action, arg_count in zip(positionals, arg_counts):

-                args = arg_strings[start_index: start_index + arg_count]

-                start_index += arg_count

-                take_action(action, args)

-

-            # slice off the Positionals that we just parsed and return the

-            # index at which the Positionals' string args stopped

-            positionals[:] = positionals[len(arg_counts):]

-            return start_index

-

-        # consume Positionals and Optionals alternately, until we have

-        # passed the last option string

-        extras = []

-        start_index = 0

-        if option_string_indices:

-            max_option_string_index = max(option_string_indices)

-        else:

-            max_option_string_index = -1

-        while start_index <= max_option_string_index:

-

-            # consume any Positionals preceding the next option

-            next_option_string_index = min([

-                index

-                for index in option_string_indices

-                if index >= start_index])

-            if start_index != next_option_string_index:

-                positionals_end_index = consume_positionals(start_index)

-

-                # only try to parse the next optional if we didn't consume

-                # the option string during the positionals parsing

-                if positionals_end_index > start_index:

-                    start_index = positionals_end_index

-                    continue

-                else:

-                    start_index = positionals_end_index

-

-            # if we consumed all the positionals we could and we're not

-            # at the index of an option string, there were extra arguments

-            if start_index not in option_string_indices:

-                strings = arg_strings[start_index:next_option_string_index]

-                extras.extend(strings)

-                start_index = next_option_string_index

-

-            # consume the next optional and any arguments for it

-            start_index = consume_optional(start_index)

-

-        # consume any positionals following the last Optional

-        stop_index = consume_positionals(start_index)

-

-        # if we didn't consume all the argument strings, there were extras

-        extras.extend(arg_strings[stop_index:])

-

-        # if we didn't use all the Positional objects, there were too few

-        # arg strings supplied.

-        if positionals:

-            self.error(_('too few arguments'))

-

-        # make sure all required actions were present

-        for action in self._actions:

-            if action.required:

-                if action not in seen_actions:

-                    name = _get_action_name(action)

-                    self.error(_('argument %s is required') % name)

-

-        # make sure all required groups had one option present

-        for group in self._mutually_exclusive_groups:

-            if group.required:

-                for action in group._group_actions:

-                    if action in seen_non_default_actions:

-                        break

-

-                # if no actions were used, report the error

-                else:

-                    names = [_get_action_name(action)

-                             for action in group._group_actions

-                             if action.help is not SUPPRESS]

-                    msg = _('one of the arguments %s is required')

-                    self.error(msg % ' '.join(names))

-

-        # return the updated namespace and the extra arguments

-        return namespace, extras

-

-    def _read_args_from_files(self, arg_strings):

-        # expand arguments referencing files

-        new_arg_strings = []

-        for arg_string in arg_strings:

-

-            # for regular arguments, just add them back into the list

-            if arg_string[0] not in self.fromfile_prefix_chars:

-                new_arg_strings.append(arg_string)

-

-            # replace arguments referencing files with the file content

-            else:

-                try:

-                    args_file = open(arg_string[1:])

-                    try:

-                        arg_strings = []

-                        for arg_line in args_file.read().splitlines():

-                            for arg in self.convert_arg_line_to_args(arg_line):

-                                arg_strings.append(arg)

-                        arg_strings = self._read_args_from_files(arg_strings)

-                        new_arg_strings.extend(arg_strings)

-                    finally:

-                        args_file.close()

-                except IOError:

-                    err = _sys.exc_info()[1]

-                    self.error(str(err))

-

-        # return the modified argument list

-        return new_arg_strings

-

-    def convert_arg_line_to_args(self, arg_line):

-        return [arg_line]

-

-    def _match_argument(self, action, arg_strings_pattern):

-        # match the pattern for this action to the arg strings

-        nargs_pattern = self._get_nargs_pattern(action)

-        match = _re.match(nargs_pattern, arg_strings_pattern)

-

-        # raise an exception if we weren't able to find a match

-        if match is None:

-            nargs_errors = {

-                None: _('expected one argument'),

-                OPTIONAL: _('expected at most one argument'),

-                ONE_OR_MORE: _('expected at least one argument'),

-            }

-            default = _('expected %s argument(s)') % action.nargs

-            msg = nargs_errors.get(action.nargs, default)

-            raise ArgumentError(action, msg)

-

-        # return the number of arguments matched

-        return len(match.group(1))

-

-    def _match_arguments_partial(self, actions, arg_strings_pattern):

-        # progressively shorten the actions list by slicing off the

-        # final actions until we find a match

-        result = []

-        for i in range(len(actions), 0, -1):

-            actions_slice = actions[:i]

-            pattern = ''.join([self._get_nargs_pattern(action)

-                               for action in actions_slice])

-            match = _re.match(pattern, arg_strings_pattern)

-            if match is not None:

-                result.extend([len(string) for string in match.groups()])

-                break

-

-        # return the list of arg string counts

-        return result

-

-    def _parse_optional(self, arg_string):

-        # if it's an empty string, it was meant to be a positional

-        if not arg_string:

-            return None

-

-        # if it doesn't start with a prefix, it was meant to be positional

-        if not arg_string[0] in self.prefix_chars:

-            return None

-

-        # if the option string is present in the parser, return the action

-        if arg_string in self._option_string_actions:

-            action = self._option_string_actions[arg_string]

-            return action, arg_string, None

-

-        # if it's just a single character, it was meant to be positional

-        if len(arg_string) == 1:

-            return None

-

-        # if the option string before the "=" is present, return the action

-        if '=' in arg_string:

-            option_string, explicit_arg = arg_string.split('=', 1)

-            if option_string in self._option_string_actions:

-                action = self._option_string_actions[option_string]

-                return action, option_string, explicit_arg

-

-        # search through all possible prefixes of the option string

-        # and all actions in the parser for possible interpretations

-        option_tuples = self._get_option_tuples(arg_string)

-

-        # if multiple actions match, the option string was ambiguous

-        if len(option_tuples) > 1:

-            options = ', '.join([option_string

-                for action, option_string, explicit_arg in option_tuples])

-            tup = arg_string, options

-            self.error(_('ambiguous option: %s could match %s') % tup)

-

-        # if exactly one action matched, this segmentation is good,

-        # so return the parsed action

-        elif len(option_tuples) == 1:

-            option_tuple, = option_tuples

-            return option_tuple

-

-        # if it was not found as an option, but it looks like a negative

-        # number, it was meant to be positional

-        # unless there are negative-number-like options

-        if self._negative_number_matcher.match(arg_string):

-            if not self._has_negative_number_optionals:

-                return None

-

-        # if it contains a space, it was meant to be a positional

-        if ' ' in arg_string:

-            return None

-

-        # it was meant to be an optional but there is no such option

-        # in this parser (though it might be a valid option in a subparser)

-        return None, arg_string, None

-

-    def _get_option_tuples(self, option_string):

-        result = []

-

-        # option strings starting with two prefix characters are only

-        # split at the '='

-        chars = self.prefix_chars

-        if option_string[0] in chars and option_string[1] in chars:

-            if '=' in option_string:

-                option_prefix, explicit_arg = option_string.split('=', 1)

-            else:

-                option_prefix = option_string

-                explicit_arg = None

-            for option_string in self._option_string_actions:

-                if option_string.startswith(option_prefix):

-                    action = self._option_string_actions[option_string]

-                    tup = action, option_string, explicit_arg

-                    result.append(tup)

-

-        # single character options can be concatenated with their arguments

-        # but multiple character options always have to have their argument

-        # separate

-        elif option_string[0] in chars and option_string[1] not in chars:

-            option_prefix = option_string

-            explicit_arg = None

-            short_option_prefix = option_string[:2]

-            short_explicit_arg = option_string[2:]

-

-            for option_string in self._option_string_actions:

-                if option_string == short_option_prefix:

-                    action = self._option_string_actions[option_string]

-                    tup = action, option_string, short_explicit_arg

-                    result.append(tup)

-                elif option_string.startswith(option_prefix):

-                    action = self._option_string_actions[option_string]

-                    tup = action, option_string, explicit_arg

-                    result.append(tup)

-

-        # shouldn't ever get here

-        else:

-            self.error(_('unexpected option string: %s') % option_string)

-

-        # return the collected option tuples

-        return result

-

-    def _get_nargs_pattern(self, action):

-        # in all examples below, we have to allow for '--' args

-        # which are represented as '-' in the pattern

-        nargs = action.nargs

-

-        # the default (None) is assumed to be a single argument

-        if nargs is None:

-            nargs_pattern = '(-*A-*)'

-

-        # allow zero or one arguments

-        elif nargs == OPTIONAL:

-            nargs_pattern = '(-*A?-*)'

-

-        # allow zero or more arguments

-        elif nargs == ZERO_OR_MORE:

-            nargs_pattern = '(-*[A-]*)'

-

-        # allow one or more arguments

-        elif nargs == ONE_OR_MORE:

-            nargs_pattern = '(-*A[A-]*)'

-

-        # allow any number of options or arguments

-        elif nargs == REMAINDER:

-            nargs_pattern = '([-AO]*)'

-

-        # allow one argument followed by any number of options or arguments

-        elif nargs == PARSER:

-            nargs_pattern = '(-*A[-AO]*)'

-

-        # all others should be integers

-        else:

-            nargs_pattern = '(-*%s-*)' % '-*'.join('A' * nargs)

-

-        # if this is an optional action, -- is not allowed

-        if action.option_strings:

-            nargs_pattern = nargs_pattern.replace('-*', '')

-            nargs_pattern = nargs_pattern.replace('-', '')

-

-        # return the pattern

-        return nargs_pattern

-

-    # ========================

-    # Value conversion methods

-    # ========================

-    def _get_values(self, action, arg_strings):

-        # for everything but PARSER args, strip out '--'

-        if action.nargs not in [PARSER, REMAINDER]:

-            arg_strings = [s for s in arg_strings if s != '--']

-

-        # optional argument produces a default when not present

-        if not arg_strings and action.nargs == OPTIONAL:

-            if action.option_strings:

-                value = action.const

-            else:

-                value = action.default

-            if isinstance(value, _basestring):

-                value = self._get_value(action, value)

-                self._check_value(action, value)

-

-        # when nargs='*' on a positional, if there were no command-line

-        # args, use the default if it is anything other than None

-        elif (not arg_strings and action.nargs == ZERO_OR_MORE and

-              not action.option_strings):

-            if action.default is not None:

-                value = action.default

-            else:

-                value = arg_strings

-            self._check_value(action, value)

-

-        # single argument or optional argument produces a single value

-        elif len(arg_strings) == 1 and action.nargs in [None, OPTIONAL]:

-            arg_string, = arg_strings

-            value = self._get_value(action, arg_string)

-            self._check_value(action, value)

-

-        # REMAINDER arguments convert all values, checking none

-        elif action.nargs == REMAINDER:

-            value = [self._get_value(action, v) for v in arg_strings]

-

-        # PARSER arguments convert all values, but check only the first

-        elif action.nargs == PARSER:

-            value = [self._get_value(action, v) for v in arg_strings]

-            self._check_value(action, value[0])

-

-        # all other types of nargs produce a list

-        else:

-            value = [self._get_value(action, v) for v in arg_strings]

-            for v in value:

-                self._check_value(action, v)

-

-        # return the converted value

-        return value

-

-    def _get_value(self, action, arg_string):

-        type_func = self._registry_get('type', action.type, action.type)

-        if not _callable(type_func):

-            msg = _('%r is not callable')

-            raise ArgumentError(action, msg % type_func)

-

-        # convert the value to the appropriate type

-        try:

-            result = type_func(arg_string)

-

-        # ArgumentTypeErrors indicate errors

-        except ArgumentTypeError:

-            name = getattr(action.type, '__name__', repr(action.type))

-            msg = str(_sys.exc_info()[1])

-            raise ArgumentError(action, msg)

-

-        # TypeErrors or ValueErrors also indicate errors

-        except (TypeError, ValueError):

-            name = getattr(action.type, '__name__', repr(action.type))

-            msg = _('invalid %s value: %r')

-            raise ArgumentError(action, msg % (name, arg_string))

-

-        # return the converted value

-        return result

-

-    def _check_value(self, action, value):

-        # converted value must be one of the choices (if specified)

-        if action.choices is not None and value not in action.choices:

-            tup = value, ', '.join(map(repr, action.choices))

-            msg = _('invalid choice: %r (choose from %s)') % tup

-            raise ArgumentError(action, msg)

-

-    # =======================

-    # Help-formatting methods

-    # =======================

-    def format_usage(self):

-        formatter = self._get_formatter()

-        formatter.add_usage(self.usage, self._actions,

-                            self._mutually_exclusive_groups)

-        return formatter.format_help()

-

-    def format_help(self):

-        formatter = self._get_formatter()

-

-        # usage

-        formatter.add_usage(self.usage, self._actions,

-                            self._mutually_exclusive_groups)

-

-        # description

-        formatter.add_text(self.description)

-

-        # positionals, optionals and user-defined groups

-        for action_group in self._action_groups:

-            formatter.start_section(action_group.title)

-            formatter.add_text(action_group.description)

-            formatter.add_arguments(action_group._group_actions)

-            formatter.end_section()

-

-        # epilog

-        formatter.add_text(self.epilog)

-

-        # determine help from format above

-        return formatter.format_help()

-

-    def format_version(self):

-        import warnings

-        warnings.warn(

-            'The format_version method is deprecated -- the "version" '

-            'argument to ArgumentParser is no longer supported.',

-            DeprecationWarning)

-        formatter = self._get_formatter()

-        formatter.add_text(self.version)

-        return formatter.format_help()

-

-    def _get_formatter(self):

-        return self.formatter_class(prog=self.prog)

-

-    # =====================

-    # Help-printing methods

-    # =====================

-    def print_usage(self, file=None):

-        if file is None:

-            file = _sys.stdout

-        self._print_message(self.format_usage(), file)

-

-    def print_help(self, file=None):

-        if file is None:

-            file = _sys.stdout

-        self._print_message(self.format_help(), file)

-

-    def print_version(self, file=None):

-        import warnings

-        warnings.warn(

-            'The print_version method is deprecated -- the "version" '

-            'argument to ArgumentParser is no longer supported.',

-            DeprecationWarning)

-        self._print_message(self.format_version(), file)

-

-    def _print_message(self, message, file=None):

-        if message:

-            if file is None:

-                file = _sys.stderr

-            file.write(message)

-

-    # ===============

-    # Exiting methods

-    # ===============

-    def exit(self, status=0, message=None):

-        if message:

-            self._print_message(message, _sys.stderr)

-        _sys.exit(status)

-

-    def error(self, message):

-        """error(message: string)

-

-        Prints a usage message incorporating the message to stderr and

-        exits.

-

-        If you override this in a subclass, it should not return -- it

-        should either exit or raise an exception.

-        """

-        self.print_usage(_sys.stderr)

-        self.exit(2, _('%s: error: %s\n') % (self.prog, message))

+# Copyright 2006-2009 Steven J. Bethard <steven.bethard@gmail.com>.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy
+# of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+"""Command-line parsing library
+
+This module is an optparse-inspired command-line parsing library that:
+
+    - handles both optional and positional arguments
+    - produces highly informative usage messages
+    - supports parsers that dispatch to sub-parsers
+
+The following is a simple usage example that sums integers from the
+command-line and writes the result to a file::
+
+    parser = argparse.ArgumentParser(
+        description='sum the integers at the command line')
+    parser.add_argument(
+        'integers', metavar='int', nargs='+', type=int,
+        help='an integer to be summed')
+    parser.add_argument(
+        '--log', default=sys.stdout, type=argparse.FileType('w'),
+        help='the file where the sum should be written')
+    args = parser.parse_args()
+    args.log.write('%s' % sum(args.integers))
+    args.log.close()
+
+The module contains the following public classes:
+
+    - ArgumentParser -- The main entry point for command-line parsing. As the
+        example above shows, the add_argument() method is used to populate
+        the parser with actions for optional and positional arguments. Then
+        the parse_args() method is invoked to convert the args at the
+        command-line into an object with attributes.
+
+    - ArgumentError -- The exception raised by ArgumentParser objects when
+        there are errors with the parser's actions. Errors raised while
+        parsing the command-line are caught by ArgumentParser and emitted
+        as command-line messages.
+
+    - FileType -- A factory for defining types of files to be created. As the
+        example above shows, instances of FileType are typically passed as
+        the type= argument of add_argument() calls.
+
+    - Action -- The base class for parser actions. Typically actions are
+        selected by passing strings like 'store_true' or 'append_const' to
+        the action= argument of add_argument(). However, for greater
+        customization of ArgumentParser actions, subclasses of Action may
+        be defined and passed as the action= argument.
+
+    - HelpFormatter, RawDescriptionHelpFormatter, RawTextHelpFormatter,
+        ArgumentDefaultsHelpFormatter -- Formatter classes which
+        may be passed as the formatter_class= argument to the
+        ArgumentParser constructor. HelpFormatter is the default,
+        RawDescriptionHelpFormatter and RawTextHelpFormatter tell the parser
+        not to change the formatting for help text, and
+        ArgumentDefaultsHelpFormatter adds information about argument defaults
+        to the help.
+
+All other classes in this module are considered implementation details.
+(Also note that HelpFormatter and RawDescriptionHelpFormatter are only
+considered public as object names -- the API of the formatter objects is
+still considered an implementation detail.)
+"""
+
+__version__ = '1.1'
+__all__ = [
+    'ArgumentParser',
+    'ArgumentError',
+    'Namespace',
+    'Action',
+    'FileType',
+    'HelpFormatter',
+    'RawDescriptionHelpFormatter',
+    'RawTextHelpFormatter',
+    'ArgumentDefaultsHelpFormatter',
+]
+
+
+import copy as _copy
+import os as _os
+import re as _re
+import sys as _sys
+import textwrap as _textwrap
+
+from gettext import gettext as _
+
+try:
+    _set = set
+except NameError:
+    from sets import Set as _set
+
+try:
+    _basestring = basestring
+except NameError:
+    _basestring = str
+
+try:
+    _sorted = sorted
+except NameError:
+
+    def _sorted(iterable, reverse=False):
+        result = list(iterable)
+        result.sort()
+        if reverse:
+            result.reverse()
+        return result
+
+
+def _callable(obj):
+    return hasattr(obj, '__call__') or hasattr(obj, '__bases__')
+
+# silence Python 2.6 buggy warnings about Exception.message
+if _sys.version_info[:2] == (2, 6):
+    import warnings
+    warnings.filterwarnings(
+        action='ignore',
+        message='BaseException.message has been deprecated as of Python 2.6',
+        category=DeprecationWarning,
+        module='argparse')
+
+
+SUPPRESS = '==SUPPRESS=='
+
+OPTIONAL = '?'
+ZERO_OR_MORE = '*'
+ONE_OR_MORE = '+'
+PARSER = 'A...'
+REMAINDER = '...'
+
+# =============================
+# Utility functions and classes
+# =============================
+
+class _AttributeHolder(object):
+    """Abstract base class that provides __repr__.
+
+    The __repr__ method returns a string in the format::
+        ClassName(attr=name, attr=name, ...)
+    The attributes are determined either by a class-level attribute,
+    '_kwarg_names', or by inspecting the instance __dict__.
+    """
+
+    def __repr__(self):
+        type_name = type(self).__name__
+        arg_strings = []
+        for arg in self._get_args():
+            arg_strings.append(repr(arg))
+        for name, value in self._get_kwargs():
+            arg_strings.append('%s=%r' % (name, value))
+        return '%s(%s)' % (type_name, ', '.join(arg_strings))
+
+    def _get_kwargs(self):
+        return _sorted(self.__dict__.items())
+
+    def _get_args(self):
+        return []
+
+
+def _ensure_value(namespace, name, value):
+    if getattr(namespace, name, None) is None:
+        setattr(namespace, name, value)
+    return getattr(namespace, name)
+
+
+# ===============
+# Formatting Help
+# ===============
+
+class HelpFormatter(object):
+    """Formatter for generating usage messages and argument help strings.
+
+    Only the name of this class is considered a public API. All the methods
+    provided by the class are considered an implementation detail.
+    """
+
+    def __init__(self,
+                 prog,
+                 indent_increment=2,
+                 max_help_position=24,
+                 width=None):
+
+        # default setting for width
+        if width is None:
+            try:
+                width = int(_os.environ['COLUMNS'])
+            except (KeyError, ValueError):
+                width = 80
+            width -= 2
+
+        self._prog = prog
+        self._indent_increment = indent_increment
+        self._max_help_position = max_help_position
+        self._width = width
+
+        self._current_indent = 0
+        self._level = 0
+        self._action_max_length = 0
+
+        self._root_section = self._Section(self, None)
+        self._current_section = self._root_section
+
+        self._whitespace_matcher = _re.compile(r'\s+')
+        self._long_break_matcher = _re.compile(r'\n\n\n+')
+
+    # ===============================
+    # Section and indentation methods
+    # ===============================
+    def _indent(self):
+        self._current_indent += self._indent_increment
+        self._level += 1
+
+    def _dedent(self):
+        self._current_indent -= self._indent_increment
+        assert self._current_indent >= 0, 'Indent decreased below 0.'
+        self._level -= 1
+
+    class _Section(object):
+
+        def __init__(self, formatter, parent, heading=None):
+            self.formatter = formatter
+            self.parent = parent
+            self.heading = heading
+            self.items = []
+
+        def format_help(self):
+            # format the indented section
+            if self.parent is not None:
+                self.formatter._indent()
+            join = self.formatter._join_parts
+            for func, args in self.items:
+                func(*args)
+            item_help = join([func(*args) for func, args in self.items])
+            if self.parent is not None:
+                self.formatter._dedent()
+
+            # return nothing if the section was empty
+            if not item_help:
+                return ''
+
+            # add the heading if the section was non-empty
+            if self.heading is not SUPPRESS and self.heading is not None:
+                current_indent = self.formatter._current_indent
+                heading = '%*s%s:\n' % (current_indent, '', self.heading)
+            else:
+                heading = ''
+
+            # join the section-initial newline, the heading and the help
+            return join(['\n', heading, item_help, '\n'])
+
+    def _add_item(self, func, args):
+        self._current_section.items.append((func, args))
+
+    # ========================
+    # Message building methods
+    # ========================
+    def start_section(self, heading):
+        self._indent()
+        section = self._Section(self, self._current_section, heading)
+        self._add_item(section.format_help, [])
+        self._current_section = section
+
+    def end_section(self):
+        self._current_section = self._current_section.parent
+        self._dedent()
+
+    def add_text(self, text):
+        if text is not SUPPRESS and text is not None:
+            self._add_item(self._format_text, [text])
+
+    def add_usage(self, usage, actions, groups, prefix=None):
+        if usage is not SUPPRESS:
+            args = usage, actions, groups, prefix
+            self._add_item(self._format_usage, args)
+
+    def add_argument(self, action):
+        if action.help is not SUPPRESS:
+
+            # find all invocations
+            get_invocation = self._format_action_invocation
+            invocations = [get_invocation(action)]
+            for subaction in self._iter_indented_subactions(action):
+                invocations.append(get_invocation(subaction))
+
+            # update the maximum item length
+            invocation_length = max([len(s) for s in invocations])
+            action_length = invocation_length + self._current_indent
+            self._action_max_length = max(self._action_max_length,
+                                          action_length)
+
+            # add the item to the list
+            self._add_item(self._format_action, [action])
+
+    def add_arguments(self, actions):
+        for action in actions:
+            self.add_argument(action)
+
+    # =======================
+    # Help-formatting methods
+    # =======================
+    def format_help(self):
+        help = self._root_section.format_help()
+        if help:
+            help = self._long_break_matcher.sub('\n\n', help)
+            help = help.strip('\n') + '\n'
+        return help
+
+    def _join_parts(self, part_strings):
+        return ''.join([part
+                        for part in part_strings
+                        if part and part is not SUPPRESS])
+
+    def _format_usage(self, usage, actions, groups, prefix):
+        if prefix is None:
+            prefix = _('usage: ')
+
+        # if usage is specified, use that
+        if usage is not None:
+            usage = usage % dict(prog=self._prog)
+
+        # if no optionals or positionals are available, usage is just prog
+        elif usage is None and not actions:
+            usage = '%(prog)s' % dict(prog=self._prog)
+
+        # if optionals and positionals are available, calculate usage
+        elif usage is None:
+            prog = '%(prog)s' % dict(prog=self._prog)
+
+            # split optionals from positionals
+            optionals = []
+            positionals = []
+            for action in actions:
+                if action.option_strings:
+                    optionals.append(action)
+                else:
+                    positionals.append(action)
+
+            # build full usage string
+            format = self._format_actions_usage
+            action_usage = format(optionals + positionals, groups)
+            usage = ' '.join([s for s in [prog, action_usage] if s])
+
+            # wrap the usage parts if it's too long
+            text_width = self._width - self._current_indent
+            if len(prefix) + len(usage) > text_width:
+
+                # break usage into wrappable parts
+                part_regexp = r'\(.*?\)+|\[.*?\]+|\S+'
+                opt_usage = format(optionals, groups)
+                pos_usage = format(positionals, groups)
+                opt_parts = _re.findall(part_regexp, opt_usage)
+                pos_parts = _re.findall(part_regexp, pos_usage)
+                assert ' '.join(opt_parts) == opt_usage
+                assert ' '.join(pos_parts) == pos_usage
+
+                # helper for wrapping lines
+                def get_lines(parts, indent, prefix=None):
+                    lines = []
+                    line = []
+                    if prefix is not None:
+                        line_len = len(prefix) - 1
+                    else:
+                        line_len = len(indent) - 1
+                    for part in parts:
+                        if line_len + 1 + len(part) > text_width:
+                            lines.append(indent + ' '.join(line))
+                            line = []
+                            line_len = len(indent) - 1
+                        line.append(part)
+                        line_len += len(part) + 1
+                    if line:
+                        lines.append(indent + ' '.join(line))
+                    if prefix is not None:
+                        lines[0] = lines[0][len(indent):]
+                    return lines
+
+                # if prog is short, follow it with optionals or positionals
+                if len(prefix) + len(prog) <= 0.75 * text_width:
+                    indent = ' ' * (len(prefix) + len(prog) + 1)
+                    if opt_parts:
+                        lines = get_lines([prog] + opt_parts, indent, prefix)
+                        lines.extend(get_lines(pos_parts, indent))
+                    elif pos_parts:
+                        lines = get_lines([prog] + pos_parts, indent, prefix)
+                    else:
+                        lines = [prog]
+
+                # if prog is long, put it on its own line
+                else:
+                    indent = ' ' * len(prefix)
+                    parts = opt_parts + pos_parts
+                    lines = get_lines(parts, indent)
+                    if len(lines) > 1:
+                        lines = []
+                        lines.extend(get_lines(opt_parts, indent))
+                        lines.extend(get_lines(pos_parts, indent))
+                    lines = [prog] + lines
+
+                # join lines into usage
+                usage = '\n'.join(lines)
+
+        # prefix with 'usage:'
+        return '%s%s\n\n' % (prefix, usage)
+
+    def _format_actions_usage(self, actions, groups):
+        # find group indices and identify actions in groups
+        group_actions = _set()
+        inserts = {}
+        for group in groups:
+            try:
+                start = actions.index(group._group_actions[0])
+            except ValueError:
+                continue
+            else:
+                end = start + len(group._group_actions)
+                if actions[start:end] == group._group_actions:
+                    for action in group._group_actions:
+                        group_actions.add(action)
+                    if not group.required:
+                        inserts[start] = '['
+                        inserts[end] = ']'
+                    else:
+                        inserts[start] = '('
+                        inserts[end] = ')'
+                    for i in range(start + 1, end):
+                        inserts[i] = '|'
+
+        # collect all actions format strings
+        parts = []
+        for i, action in enumerate(actions):
+
+            # suppressed arguments are marked with None
+            # remove | separators for suppressed arguments
+            if action.help is SUPPRESS:
+                parts.append(None)
+                if inserts.get(i) == '|':
+                    inserts.pop(i)
+                elif inserts.get(i + 1) == '|':
+                    inserts.pop(i + 1)
+
+            # produce all arg strings
+            elif not action.option_strings:
+                part = self._format_args(action, action.dest)
+
+                # if it's in a group, strip the outer []
+                if action in group_actions:
+                    if part[0] == '[' and part[-1] == ']':
+                        part = part[1:-1]
+
+                # add the action string to the list
+                parts.append(part)
+
+            # produce the first way to invoke the option in brackets
+            else:
+                option_string = action.option_strings[0]
+
+                # if the Optional doesn't take a value, format is:
+                #    -s or --long
+                if action.nargs == 0:
+                    part = '%s' % option_string
+
+                # if the Optional takes a value, format is:
+                #    -s ARGS or --long ARGS
+                else:
+                    default = action.dest.upper()
+                    args_string = self._format_args(action, default)
+                    part = '%s %s' % (option_string, args_string)
+
+                # make it look optional if it's not required or in a group
+                if not action.required and action not in group_actions:
+                    part = '[%s]' % part
+
+                # add the action string to the list
+                parts.append(part)
+
+        # insert things at the necessary indices
+        for i in _sorted(inserts, reverse=True):
+            parts[i:i] = [inserts[i]]
+
+        # join all the action items with spaces
+        text = ' '.join([item for item in parts if item is not None])
+
+        # clean up separators for mutually exclusive groups
+        open = r'[\[(]'
+        close = r'[\])]'
+        text = _re.sub(r'(%s) ' % open, r'\1', text)
+        text = _re.sub(r' (%s)' % close, r'\1', text)
+        text = _re.sub(r'%s *%s' % (open, close), r'', text)
+        text = _re.sub(r'\(([^|]*)\)', r'\1', text)
+        text = text.strip()
+
+        # return the text
+        return text
+
+    def _format_text(self, text):
+        if '%(prog)' in text:
+            text = text % dict(prog=self._prog)
+        text_width = self._width - self._current_indent
+        indent = ' ' * self._current_indent
+        return self._fill_text(text, text_width, indent) + '\n\n'
+
+    def _format_action(self, action):
+        # determine the required width and the entry label
+        help_position = min(self._action_max_length + 2,
+                            self._max_help_position)
+        help_width = self._width - help_position
+        action_width = help_position - self._current_indent - 2
+        action_header = self._format_action_invocation(action)
+
+        # ho nelp; start on same line and add a final newline
+        if not action.help:
+            tup = self._current_indent, '', action_header
+            action_header = '%*s%s\n' % tup
+
+        # short action name; start on the same line and pad two spaces
+        elif len(action_header) <= action_width:
+            tup = self._current_indent, '', action_width, action_header
+            action_header = '%*s%-*s  ' % tup
+            indent_first = 0
+
+        # long action name; start on the next line
+        else:
+            tup = self._current_indent, '', action_header
+            action_header = '%*s%s\n' % tup
+            indent_first = help_position
+
+        # collect the pieces of the action help
+        parts = [action_header]
+
+        # if there was help for the action, add lines of help text
+        if action.help:
+            help_text = self._expand_help(action)
+            help_lines = self._split_lines(help_text, help_width)
+            parts.append('%*s%s\n' % (indent_first, '', help_lines[0]))
+            for line in help_lines[1:]:
+                parts.append('%*s%s\n' % (help_position, '', line))
+
+        # or add a newline if the description doesn't end with one
+        elif not action_header.endswith('\n'):
+            parts.append('\n')
+
+        # if there are any sub-actions, add their help as well
+        for subaction in self._iter_indented_subactions(action):
+            parts.append(self._format_action(subaction))
+
+        # return a single string
+        return self._join_parts(parts)
+
+    def _format_action_invocation(self, action):
+        if not action.option_strings:
+            metavar, = self._metavar_formatter(action, action.dest)(1)
+            return metavar
+
+        else:
+            parts = []
+
+            # if the Optional doesn't take a value, format is:
+            #    -s, --long
+            if action.nargs == 0:
+                parts.extend(action.option_strings)
+
+            # if the Optional takes a value, format is:
+            #    -s ARGS, --long ARGS
+            else:
+                default = action.dest.upper()
+                args_string = self._format_args(action, default)
+                for option_string in action.option_strings:
+                    parts.append('%s %s' % (option_string, args_string))
+
+            return ', '.join(parts)
+
+    def _metavar_formatter(self, action, default_metavar):
+        if action.metavar is not None:
+            result = action.metavar
+        elif action.choices is not None:
+            choice_strs = [str(choice) for choice in action.choices]
+            result = '{%s}' % ','.join(choice_strs)
+        else:
+            result = default_metavar
+
+        def format(tuple_size):
+            if isinstance(result, tuple):
+                return result
+            else:
+                return (result, ) * tuple_size
+        return format
+
+    def _format_args(self, action, default_metavar):
+        get_metavar = self._metavar_formatter(action, default_metavar)
+        if action.nargs is None:
+            result = '%s' % get_metavar(1)
+        elif action.nargs == OPTIONAL:
+            result = '[%s]' % get_metavar(1)
+        elif action.nargs == ZERO_OR_MORE:
+            result = '[%s [%s ...]]' % get_metavar(2)
+        elif action.nargs == ONE_OR_MORE:
+            result = '%s [%s ...]' % get_metavar(2)
+        elif action.nargs == REMAINDER:
+            result = '...'
+        elif action.nargs == PARSER:
+            result = '%s ...' % get_metavar(1)
+        else:
+            formats = ['%s' for _ in range(action.nargs)]
+            result = ' '.join(formats) % get_metavar(action.nargs)
+        return result
+
+    def _expand_help(self, action):
+        params = dict(vars(action), prog=self._prog)
+        for name in list(params):
+            if params[name] is SUPPRESS:
+                del params[name]
+        for name in list(params):
+            if hasattr(params[name], '__name__'):
+                params[name] = params[name].__name__
+        if params.get('choices') is not None:
+            choices_str = ', '.join([str(c) for c in params['choices']])
+            params['choices'] = choices_str
+        return self._get_help_string(action) % params
+
+    def _iter_indented_subactions(self, action):
+        try:
+            get_subactions = action._get_subactions
+        except AttributeError:
+            pass
+        else:
+            self._indent()
+            for subaction in get_subactions():
+                yield subaction
+            self._dedent()
+
+    def _split_lines(self, text, width):
+        text = self._whitespace_matcher.sub(' ', text).strip()
+        return _textwrap.wrap(text, width)
+
+    def _fill_text(self, text, width, indent):
+        text = self._whitespace_matcher.sub(' ', text).strip()
+        return _textwrap.fill(text, width, initial_indent=indent,
+                                           subsequent_indent=indent)
+
+    def _get_help_string(self, action):
+        return action.help
+
+
+class RawDescriptionHelpFormatter(HelpFormatter):
+    """Help message formatter which retains any formatting in descriptions.
+
+    Only the name of this class is considered a public API. All the methods
+    provided by the class are considered an implementation detail.
+    """
+
+    def _fill_text(self, text, width, indent):
+        return ''.join([indent + line for line in text.splitlines(True)])
+
+
+class RawTextHelpFormatter(RawDescriptionHelpFormatter):
+    """Help message formatter which retains formatting of all help text.
+
+    Only the name of this class is considered a public API. All the methods
+    provided by the class are considered an implementation detail.
+    """
+
+    def _split_lines(self, text, width):
+        return text.splitlines()
+
+
+class ArgumentDefaultsHelpFormatter(HelpFormatter):
+    """Help message formatter which adds default values to argument help.
+
+    Only the name of this class is considered a public API. All the methods
+    provided by the class are considered an implementation detail.
+    """
+
+    def _get_help_string(self, action):
+        help = action.help
+        if '%(default)' not in action.help:
+            if action.default is not SUPPRESS:
+                defaulting_nargs = [OPTIONAL, ZERO_OR_MORE]
+                if action.option_strings or action.nargs in defaulting_nargs:
+                    help += ' (default: %(default)s)'
+        return help
+
+
+# =====================
+# Options and Arguments
+# =====================
+
+def _get_action_name(argument):
+    if argument is None:
+        return None
+    elif argument.option_strings:
+        return  '/'.join(argument.option_strings)
+    elif argument.metavar not in (None, SUPPRESS):
+        return argument.metavar
+    elif argument.dest not in (None, SUPPRESS):
+        return argument.dest
+    else:
+        return None
+
+
+class ArgumentError(Exception):
+    """An error from creating or using an argument (optional or positional).
+
+    The string value of this exception is the message, augmented with
+    information about the argument that caused it.
+    """
+
+    def __init__(self, argument, message):
+        self.argument_name = _get_action_name(argument)
+        self.message = message
+
+    def __str__(self):
+        if self.argument_name is None:
+            format = '%(message)s'
+        else:
+            format = 'argument %(argument_name)s: %(message)s'
+        return format % dict(message=self.message,
+                             argument_name=self.argument_name)
+
+
+class ArgumentTypeError(Exception):
+    """An error from trying to convert a command line string to a type."""
+    pass
+
+
+# ==============
+# Action classes
+# ==============
+
+class Action(_AttributeHolder):
+    """Information about how to convert command line strings to Python objects.
+
+    Action objects are used by an ArgumentParser to represent the information
+    needed to parse a single argument from one or more strings from the
+    command line. The keyword arguments to the Action constructor are also
+    all attributes of Action instances.
+
+    Keyword Arguments:
+
+        - option_strings -- A list of command-line option strings which
+            should be associated with this action.
+
+        - dest -- The name of the attribute to hold the created object(s)
+
+        - nargs -- The number of command-line arguments that should be
+            consumed. By default, one argument will be consumed and a single
+            value will be produced.  Other values include:
+                - N (an integer) consumes N arguments (and produces a list)
+                - '?' consumes zero or one arguments
+                - '*' consumes zero or more arguments (and produces a list)
+                - '+' consumes one or more arguments (and produces a list)
+            Note that the difference between the default and nargs=1 is that
+            with the default, a single value will be produced, while with
+            nargs=1, a list containing a single value will be produced.
+
+        - const -- The value to be produced if the option is specified and the
+            option uses an action that takes no values.
+
+        - default -- The value to be produced if the option is not specified.
+
+        - type -- The type which the command-line arguments should be converted
+            to, should be one of 'string', 'int', 'float', 'complex' or a
+            callable object that accepts a single string argument. If None,
+            'string' is assumed.
+
+        - choices -- A container of values that should be allowed. If not None,
+            after a command-line argument has been converted to the appropriate
+            type, an exception will be raised if it is not a member of this
+            collection.
+
+        - required -- True if the action must always be specified at the
+            command line. This is only meaningful for optional command-line
+            arguments.
+
+        - help -- The help string describing the argument.
+
+        - metavar -- The name to be used for the option's argument with the
+            help string. If None, the 'dest' value will be used as the name.
+    """
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 nargs=None,
+                 const=None,
+                 default=None,
+                 type=None,
+                 choices=None,
+                 required=False,
+                 help=None,
+                 metavar=None):
+        self.option_strings = option_strings
+        self.dest = dest
+        self.nargs = nargs
+        self.const = const
+        self.default = default
+        self.type = type
+        self.choices = choices
+        self.required = required
+        self.help = help
+        self.metavar = metavar
+
+    def _get_kwargs(self):
+        names = [
+            'option_strings',
+            'dest',
+            'nargs',
+            'const',
+            'default',
+            'type',
+            'choices',
+            'help',
+            'metavar',
+        ]
+        return [(name, getattr(self, name)) for name in names]
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        raise NotImplementedError(_('.__call__() not defined'))
+
+
+class _StoreAction(Action):
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 nargs=None,
+                 const=None,
+                 default=None,
+                 type=None,
+                 choices=None,
+                 required=False,
+                 help=None,
+                 metavar=None):
+        if nargs == 0:
+            raise ValueError('nargs for store actions must be > 0; if you '
+                             'have nothing to store, actions such as store '
+                             'true or store const may be more appropriate')
+        if const is not None and nargs != OPTIONAL:
+            raise ValueError('nargs must be %r to supply const' % OPTIONAL)
+        super(_StoreAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            nargs=nargs,
+            const=const,
+            default=default,
+            type=type,
+            choices=choices,
+            required=required,
+            help=help,
+            metavar=metavar)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        setattr(namespace, self.dest, values)
+
+
+class _StoreConstAction(Action):
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 const,
+                 default=None,
+                 required=False,
+                 help=None,
+                 metavar=None):
+        super(_StoreConstAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            nargs=0,
+            const=const,
+            default=default,
+            required=required,
+            help=help)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        setattr(namespace, self.dest, self.const)
+
+
+class _StoreTrueAction(_StoreConstAction):
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 default=False,
+                 required=False,
+                 help=None):
+        super(_StoreTrueAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            const=True,
+            default=default,
+            required=required,
+            help=help)
+
+
+class _StoreFalseAction(_StoreConstAction):
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 default=True,
+                 required=False,
+                 help=None):
+        super(_StoreFalseAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            const=False,
+            default=default,
+            required=required,
+            help=help)
+
+
+class _AppendAction(Action):
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 nargs=None,
+                 const=None,
+                 default=None,
+                 type=None,
+                 choices=None,
+                 required=False,
+                 help=None,
+                 metavar=None):
+        if nargs == 0:
+            raise ValueError('nargs for append actions must be > 0; if arg '
+                             'strings are not supplying the value to append, '
+                             'the append const action may be more appropriate')
+        if const is not None and nargs != OPTIONAL:
+            raise ValueError('nargs must be %r to supply const' % OPTIONAL)
+        super(_AppendAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            nargs=nargs,
+            const=const,
+            default=default,
+            type=type,
+            choices=choices,
+            required=required,
+            help=help,
+            metavar=metavar)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        items = _copy.copy(_ensure_value(namespace, self.dest, []))
+        items.append(values)
+        setattr(namespace, self.dest, items)
+
+
+class _AppendConstAction(Action):
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 const,
+                 default=None,
+                 required=False,
+                 help=None,
+                 metavar=None):
+        super(_AppendConstAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            nargs=0,
+            const=const,
+            default=default,
+            required=required,
+            help=help,
+            metavar=metavar)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        items = _copy.copy(_ensure_value(namespace, self.dest, []))
+        items.append(self.const)
+        setattr(namespace, self.dest, items)
+
+
+class _CountAction(Action):
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 default=None,
+                 required=False,
+                 help=None):
+        super(_CountAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            nargs=0,
+            default=default,
+            required=required,
+            help=help)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        new_count = _ensure_value(namespace, self.dest, 0) + 1
+        setattr(namespace, self.dest, new_count)
+
+
+class _HelpAction(Action):
+
+    def __init__(self,
+                 option_strings,
+                 dest=SUPPRESS,
+                 default=SUPPRESS,
+                 help=None):
+        super(_HelpAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            default=default,
+            nargs=0,
+            help=help)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        parser.print_help()
+        parser.exit()
+
+
+class _VersionAction(Action):
+
+    def __init__(self,
+                 option_strings,
+                 version=None,
+                 dest=SUPPRESS,
+                 default=SUPPRESS,
+                 help=None):
+        super(_VersionAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            default=default,
+            nargs=0,
+            help=help)
+        self.version = version
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        version = self.version
+        if version is None:
+            version = parser.version
+        formatter = parser._get_formatter()
+        formatter.add_text(version)
+        parser.exit(message=formatter.format_help())
+
+
+class _SubParsersAction(Action):
+
+    class _ChoicesPseudoAction(Action):
+
+        def __init__(self, name, help):
+            sup = super(_SubParsersAction._ChoicesPseudoAction, self)
+            sup.__init__(option_strings=[], dest=name, help=help)
+
+    def __init__(self,
+                 option_strings,
+                 prog,
+                 parser_class,
+                 dest=SUPPRESS,
+                 help=None,
+                 metavar=None):
+
+        self._prog_prefix = prog
+        self._parser_class = parser_class
+        self._name_parser_map = {}
+        self._choices_actions = []
+
+        super(_SubParsersAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            nargs=PARSER,
+            choices=self._name_parser_map,
+            help=help,
+            metavar=metavar)
+
+    def add_parser(self, name, **kwargs):
+        # set prog from the existing prefix
+        if kwargs.get('prog') is None:
+            kwargs['prog'] = '%s %s' % (self._prog_prefix, name)
+
+        # create a pseudo-action to hold the choice help
+        if 'help' in kwargs:
+            help = kwargs.pop('help')
+            choice_action = self._ChoicesPseudoAction(name, help)
+            self._choices_actions.append(choice_action)
+
+        # create the parser and add it to the map
+        parser = self._parser_class(**kwargs)
+        self._name_parser_map[name] = parser
+        return parser
+
+    def _get_subactions(self):
+        return self._choices_actions
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        parser_name = values[0]
+        arg_strings = values[1:]
+
+        # set the parser name if requested
+        if self.dest is not SUPPRESS:
+            setattr(namespace, self.dest, parser_name)
+
+        # select the parser
+        try:
+            parser = self._name_parser_map[parser_name]
+        except KeyError:
+            tup = parser_name, ', '.join(self._name_parser_map)
+            msg = _('unknown parser %r (choices: %s)' % tup)
+            raise ArgumentError(self, msg)
+
+        # parse all the remaining options into the namespace
+        parser.parse_args(arg_strings, namespace)
+
+
+# ==============
+# Type classes
+# ==============
+
+class FileType(object):
+    """Factory for creating file object types
+
+    Instances of FileType are typically passed as type= arguments to the
+    ArgumentParser add_argument() method.
+
+    Keyword Arguments:
+        - mode -- A string indicating how the file is to be opened. Accepts the
+            same values as the builtin open() function.
+        - bufsize -- The file's desired buffer size. Accepts the same values as
+            the builtin open() function.
+    """
+
+    def __init__(self, mode='r', bufsize=None):
+        self._mode = mode
+        self._bufsize = bufsize
+
+    def __call__(self, string):
+        # the special argument "-" means sys.std{in,out}
+        if string == '-':
+            if 'r' in self._mode:
+                return _sys.stdin
+            elif 'w' in self._mode:
+                return _sys.stdout
+            else:
+                msg = _('argument "-" with mode %r' % self._mode)
+                raise ValueError(msg)
+
+        # all other arguments are used as file names
+        if self._bufsize:
+            return open(string, self._mode, self._bufsize)
+        else:
+            return open(string, self._mode)
+
+    def __repr__(self):
+        args = [self._mode, self._bufsize]
+        args_str = ', '.join([repr(arg) for arg in args if arg is not None])
+        return '%s(%s)' % (type(self).__name__, args_str)
+
+# ===========================
+# Optional and Positional Parsing
+# ===========================
+
+class Namespace(_AttributeHolder):
+    """Simple object for storing attributes.
+
+    Implements equality by attribute names and values, and provides a simple
+    string representation.
+    """
+
+    def __init__(self, **kwargs):
+        for name in kwargs:
+            setattr(self, name, kwargs[name])
+
+    def __eq__(self, other):
+        return vars(self) == vars(other)
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    def __contains__(self, key):
+        return key in self.__dict__
+
+
+class _ActionsContainer(object):
+
+    def __init__(self,
+                 description,
+                 prefix_chars,
+                 argument_default,
+                 conflict_handler):
+        super(_ActionsContainer, self).__init__()
+
+        self.description = description
+        self.argument_default = argument_default
+        self.prefix_chars = prefix_chars
+        self.conflict_handler = conflict_handler
+
+        # set up registries
+        self._registries = {}
+
+        # register actions
+        self.register('action', None, _StoreAction)
+        self.register('action', 'store', _StoreAction)
+        self.register('action', 'store_const', _StoreConstAction)
+        self.register('action', 'store_true', _StoreTrueAction)
+        self.register('action', 'store_false', _StoreFalseAction)
+        self.register('action', 'append', _AppendAction)
+        self.register('action', 'append_const', _AppendConstAction)
+        self.register('action', 'count', _CountAction)
+        self.register('action', 'help', _HelpAction)
+        self.register('action', 'version', _VersionAction)
+        self.register('action', 'parsers', _SubParsersAction)
+
+        # raise an exception if the conflict handler is invalid
+        self._get_handler()
+
+        # action storage
+        self._actions = []
+        self._option_string_actions = {}
+
+        # groups
+        self._action_groups = []
+        self._mutually_exclusive_groups = []
+
+        # defaults storage
+        self._defaults = {}
+
+        # determines whether an "option" looks like a negative number
+        self._negative_number_matcher = _re.compile(r'^-\d+$|^-\d*\.\d+$')
+
+        # whether or not there are any optionals that look like negative
+        # numbers -- uses a list so it can be shared and edited
+        self._has_negative_number_optionals = []
+
+    # ====================
+    # Registration methods
+    # ====================
+    def register(self, registry_name, value, object):
+        registry = self._registries.setdefault(registry_name, {})
+        registry[value] = object
+
+    def _registry_get(self, registry_name, value, default=None):
+        return self._registries[registry_name].get(value, default)
+
+    # ==================================
+    # Namespace default accessor methods
+    # ==================================
+    def set_defaults(self, **kwargs):
+        self._defaults.update(kwargs)
+
+        # if these defaults match any existing arguments, replace
+        # the previous default on the object with the new one
+        for action in self._actions:
+            if action.dest in kwargs:
+                action.default = kwargs[action.dest]
+
+    def get_default(self, dest):
+        for action in self._actions:
+            if action.dest == dest and action.default is not None:
+                return action.default
+        return self._defaults.get(dest, None)
+
+
+    # =======================
+    # Adding argument actions
+    # =======================
+    def add_argument(self, *args, **kwargs):
+        """
+        add_argument(dest, ..., name=value, ...)
+        add_argument(option_string, option_string, ..., name=value, ...)
+        """
+
+        # if no positional args are supplied or only one is supplied and
+        # it doesn't look like an option string, parse a positional
+        # argument
+        chars = self.prefix_chars
+        if not args or len(args) == 1 and args[0][0] not in chars:
+            if args and 'dest' in kwargs:
+                raise ValueError('dest supplied twice for positional argument')
+            kwargs = self._get_positional_kwargs(*args, **kwargs)
+
+        # otherwise, we're adding an optional argument
+        else:
+            kwargs = self._get_optional_kwargs(*args, **kwargs)
+
+        # if no default was supplied, use the parser-level default
+        if 'default' not in kwargs:
+            dest = kwargs['dest']
+            if dest in self._defaults:
+                kwargs['default'] = self._defaults[dest]
+            elif self.argument_default is not None:
+                kwargs['default'] = self.argument_default
+
+        # create the action object, and add it to the parser
+        action_class = self._pop_action_class(kwargs)
+        if not _callable(action_class):
+            raise ValueError('unknown action "%s"' % action_class)
+        action = action_class(**kwargs)
+
+        # raise an error if the action type is not callable
+        type_func = self._registry_get('type', action.type, action.type)
+        if not _callable(type_func):
+            raise ValueError('%r is not callable' % type_func)
+
+        return self._add_action(action)
+
+    def add_argument_group(self, *args, **kwargs):
+        group = _ArgumentGroup(self, *args, **kwargs)
+        self._action_groups.append(group)
+        return group
+
+    def add_mutually_exclusive_group(self, **kwargs):
+        group = _MutuallyExclusiveGroup(self, **kwargs)
+        self._mutually_exclusive_groups.append(group)
+        return group
+
+    def _add_action(self, action):
+        # resolve any conflicts
+        self._check_conflict(action)
+
+        # add to actions list
+        self._actions.append(action)
+        action.container = self
+
+        # index the action by any option strings it has
+        for option_string in action.option_strings:
+            self._option_string_actions[option_string] = action
+
+        # set the flag if any option strings look like negative numbers
+        for option_string in action.option_strings:
+            if self._negative_number_matcher.match(option_string):
+                if not self._has_negative_number_optionals:
+                    self._has_negative_number_optionals.append(True)
+
+        # return the created action
+        return action
+
+    def _remove_action(self, action):
+        self._actions.remove(action)
+
+    def _add_container_actions(self, container):
+        # collect groups by titles
+        title_group_map = {}
+        for group in self._action_groups:
+            if group.title in title_group_map:
+                msg = _('cannot merge actions - two groups are named %r')
+                raise ValueError(msg % (group.title))
+            title_group_map[group.title] = group
+
+        # map each action to its group
+        group_map = {}
+        for group in container._action_groups:
+
+            # if a group with the title exists, use that, otherwise
+            # create a new group matching the container's group
+            if group.title not in title_group_map:
+                title_group_map[group.title] = self.add_argument_group(
+                    title=group.title,
+                    description=group.description,
+                    conflict_handler=group.conflict_handler)
+
+            # map the actions to their new group
+            for action in group._group_actions:
+                group_map[action] = title_group_map[group.title]
+
+        # add container's mutually exclusive groups
+        # NOTE: if add_mutually_exclusive_group ever gains title= and
+        # description= then this code will need to be expanded as above
+        for group in container._mutually_exclusive_groups:
+            mutex_group = self.add_mutually_exclusive_group(
+                required=group.required)
+
+            # map the actions to their new mutex group
+            for action in group._group_actions:
+                group_map[action] = mutex_group
+
+        # add all actions to this container or their group
+        for action in container._actions:
+            group_map.get(action, self)._add_action(action)
+
+    def _get_positional_kwargs(self, dest, **kwargs):
+        # make sure required is not specified
+        if 'required' in kwargs:
+            msg = _("'required' is an invalid argument for positionals")
+            raise TypeError(msg)
+
+        # mark positional arguments as required if at least one is
+        # always required
+        if kwargs.get('nargs') not in [OPTIONAL, ZERO_OR_MORE]:
+            kwargs['required'] = True
+        if kwargs.get('nargs') == ZERO_OR_MORE and 'default' not in kwargs:
+            kwargs['required'] = True
+
+        # return the keyword arguments with no option strings
+        return dict(kwargs, dest=dest, option_strings=[])
+
+    def _get_optional_kwargs(self, *args, **kwargs):
+        # determine short and long option strings
+        option_strings = []
+        long_option_strings = []
+        for option_string in args:
+            # error on strings that don't start with an appropriate prefix
+            if not option_string[0] in self.prefix_chars:
+                msg = _('invalid option string %r: '
+                        'must start with a character %r')
+                tup = option_string, self.prefix_chars
+                raise ValueError(msg % tup)
+
+            # strings starting with two prefix characters are long options
+            option_strings.append(option_string)
+            if option_string[0] in self.prefix_chars:
+                if len(option_string) > 1:
+                    if option_string[1] in self.prefix_chars:
+                        long_option_strings.append(option_string)
+
+        # infer destination, '--foo-bar' -> 'foo_bar' and '-x' -> 'x'
+        dest = kwargs.pop('dest', None)
+        if dest is None:
+            if long_option_strings:
+                dest_option_string = long_option_strings[0]
+            else:
+                dest_option_string = option_strings[0]
+            dest = dest_option_string.lstrip(self.prefix_chars)
+            if not dest:
+                msg = _('dest= is required for options like %r')
+                raise ValueError(msg % option_string)
+            dest = dest.replace('-', '_')
+
+        # return the updated keyword arguments
+        return dict(kwargs, dest=dest, option_strings=option_strings)
+
+    def _pop_action_class(self, kwargs, default=None):
+        action = kwargs.pop('action', default)
+        return self._registry_get('action', action, action)
+
+    def _get_handler(self):
+        # determine function from conflict handler string
+        handler_func_name = '_handle_conflict_%s' % self.conflict_handler
+        try:
+            return getattr(self, handler_func_name)
+        except AttributeError:
+            msg = _('invalid conflict_resolution value: %r')
+            raise ValueError(msg % self.conflict_handler)
+
+    def _check_conflict(self, action):
+
+        # find all options that conflict with this option
+        confl_optionals = []
+        for option_string in action.option_strings:
+            if option_string in self._option_string_actions:
+                confl_optional = self._option_string_actions[option_string]
+                confl_optionals.append((option_string, confl_optional))
+
+        # resolve any conflicts
+        if confl_optionals:
+            conflict_handler = self._get_handler()
+            conflict_handler(action, confl_optionals)
+
+    def _handle_conflict_error(self, action, conflicting_actions):
+        message = _('conflicting option string(s): %s')
+        conflict_string = ', '.join([option_string
+                                     for option_string, action
+                                     in conflicting_actions])
+        raise ArgumentError(action, message % conflict_string)
+
+    def _handle_conflict_resolve(self, action, conflicting_actions):
+
+        # remove all conflicting options
+        for option_string, action in conflicting_actions:
+
+            # remove the conflicting option
+            action.option_strings.remove(option_string)
+            self._option_string_actions.pop(option_string, None)
+
+            # if the option now has no option string, remove it from the
+            # container holding it
+            if not action.option_strings:
+                action.container._remove_action(action)
+
+
+class _ArgumentGroup(_ActionsContainer):
+
+    def __init__(self, container, title=None, description=None, **kwargs):
+        # add any missing keyword arguments by checking the container
+        update = kwargs.setdefault
+        update('conflict_handler', container.conflict_handler)
+        update('prefix_chars', container.prefix_chars)
+        update('argument_default', container.argument_default)
+        super_init = super(_ArgumentGroup, self).__init__
+        super_init(description=description, **kwargs)
+
+        # group attributes
+        self.title = title
+        self._group_actions = []
+
+        # share most attributes with the container
+        self._registries = container._registries
+        self._actions = container._actions
+        self._option_string_actions = container._option_string_actions
+        self._defaults = container._defaults
+        self._has_negative_number_optionals = \
+            container._has_negative_number_optionals
+
+    def _add_action(self, action):
+        action = super(_ArgumentGroup, self)._add_action(action)
+        self._group_actions.append(action)
+        return action
+
+    def _remove_action(self, action):
+        super(_ArgumentGroup, self)._remove_action(action)
+        self._group_actions.remove(action)
+
+
+class _MutuallyExclusiveGroup(_ArgumentGroup):
+
+    def __init__(self, container, required=False):
+        super(_MutuallyExclusiveGroup, self).__init__(container)
+        self.required = required
+        self._container = container
+
+    def _add_action(self, action):
+        if action.required:
+            msg = _('mutually exclusive arguments must be optional')
+            raise ValueError(msg)
+        action = self._container._add_action(action)
+        self._group_actions.append(action)
+        return action
+
+    def _remove_action(self, action):
+        self._container._remove_action(action)
+        self._group_actions.remove(action)
+
+
+class ArgumentParser(_AttributeHolder, _ActionsContainer):
+    """Object for parsing command line strings into Python objects.
+
+    Keyword Arguments:
+        - prog -- The name of the program (default: sys.argv[0])
+        - usage -- A usage message (default: auto-generated from arguments)
+        - description -- A description of what the program does
+        - epilog -- Text following the argument descriptions
+        - parents -- Parsers whose arguments should be copied into this one
+        - formatter_class -- HelpFormatter class for printing help messages
+        - prefix_chars -- Characters that prefix optional arguments
+        - fromfile_prefix_chars -- Characters that prefix files containing
+            additional arguments
+        - argument_default -- The default value for all arguments
+        - conflict_handler -- String indicating how to handle conflicts
+        - add_help -- Add a -h/-help option
+    """
+
+    def __init__(self,
+                 prog=None,
+                 usage=None,
+                 description=None,
+                 epilog=None,
+                 version=None,
+                 parents=[],
+                 formatter_class=HelpFormatter,
+                 prefix_chars='-',
+                 fromfile_prefix_chars=None,
+                 argument_default=None,
+                 conflict_handler='error',
+                 add_help=True):
+
+        if version is not None:
+            import warnings
+            warnings.warn(
+                """The "version" argument to ArgumentParser is deprecated. """
+                """Please use """
+                """"add_argument(..., action='version', version="N", ...)" """
+                """instead""", DeprecationWarning)
+
+        superinit = super(ArgumentParser, self).__init__
+        superinit(description=description,
+                  prefix_chars=prefix_chars,
+                  argument_default=argument_default,
+                  conflict_handler=conflict_handler)
+
+        # default setting for prog
+        if prog is None:
+            prog = _os.path.basename(_sys.argv[0])
+
+        self.prog = prog
+        self.usage = usage
+        self.epilog = epilog
+        self.version = version
+        self.formatter_class = formatter_class
+        self.fromfile_prefix_chars = fromfile_prefix_chars
+        self.add_help = add_help
+
+        add_group = self.add_argument_group
+        self._positionals = add_group(_('positional arguments'))
+        self._optionals = add_group(_('optional arguments'))
+        self._subparsers = None
+
+        # register types
+        def identity(string):
+            return string
+        self.register('type', None, identity)
+
+        # add help and version arguments if necessary
+        # (using explicit default to override global argument_default)
+        if self.add_help:
+            self.add_argument(
+                '-h', '--help', action='help', default=SUPPRESS,
+                help=_('show this help message and exit'))
+        if self.version:
+            self.add_argument(
+                '-v', '--version', action='version', default=SUPPRESS,
+                version=self.version,
+                help=_("show program's version number and exit"))
+
+        # add parent arguments and defaults
+        for parent in parents:
+            self._add_container_actions(parent)
+            try:
+                defaults = parent._defaults
+            except AttributeError:
+                pass
+            else:
+                self._defaults.update(defaults)
+
+    # =======================
+    # Pretty __repr__ methods
+    # =======================
+    def _get_kwargs(self):
+        names = [
+            'prog',
+            'usage',
+            'description',
+            'version',
+            'formatter_class',
+            'conflict_handler',
+            'add_help',
+        ]
+        return [(name, getattr(self, name)) for name in names]
+
+    # ==================================
+    # Optional/Positional adding methods
+    # ==================================
+    def add_subparsers(self, **kwargs):
+        if self._subparsers is not None:
+            self.error(_('cannot have multiple subparser arguments'))
+
+        # add the parser class to the arguments if it's not present
+        kwargs.setdefault('parser_class', type(self))
+
+        if 'title' in kwargs or 'description' in kwargs:
+            title = _(kwargs.pop('title', 'subcommands'))
+            description = _(kwargs.pop('description', None))
+            self._subparsers = self.add_argument_group(title, description)
+        else:
+            self._subparsers = self._positionals
+
+        # prog defaults to the usage message of this parser, skipping
+        # optional arguments and with no "usage:" prefix
+        if kwargs.get('prog') is None:
+            formatter = self._get_formatter()
+            positionals = self._get_positional_actions()
+            groups = self._mutually_exclusive_groups
+            formatter.add_usage(self.usage, positionals, groups, '')
+            kwargs['prog'] = formatter.format_help().strip()
+
+        # create the parsers action and add it to the positionals list
+        parsers_class = self._pop_action_class(kwargs, 'parsers')
+        action = parsers_class(option_strings=[], **kwargs)
+        self._subparsers._add_action(action)
+
+        # return the created parsers action
+        return action
+
+    def _add_action(self, action):
+        if action.option_strings:
+            self._optionals._add_action(action)
+        else:
+            self._positionals._add_action(action)
+        return action
+
+    def _get_optional_actions(self):
+        return [action
+                for action in self._actions
+                if action.option_strings]
+
+    def _get_positional_actions(self):
+        return [action
+                for action in self._actions
+                if not action.option_strings]
+
+    # =====================================
+    # Command line argument parsing methods
+    # =====================================
+    def parse_args(self, args=None, namespace=None):
+        args, argv = self.parse_known_args(args, namespace)
+        if argv:
+            msg = _('unrecognized arguments: %s')
+            self.error(msg % ' '.join(argv))
+        return args
+
+    def parse_known_args(self, args=None, namespace=None):
+        # args default to the system args
+        if args is None:
+            args = _sys.argv[1:]
+
+        # default Namespace built from parser defaults
+        if namespace is None:
+            namespace = Namespace()
+
+        # add any action defaults that aren't present
+        for action in self._actions:
+            if action.dest is not SUPPRESS:
+                if not hasattr(namespace, action.dest):
+                    if action.default is not SUPPRESS:
+                        default = action.default
+                        if isinstance(action.default, _basestring):
+                            default = self._get_value(action, default)
+                        setattr(namespace, action.dest, default)
+
+        # add any parser defaults that aren't present
+        for dest in self._defaults:
+            if not hasattr(namespace, dest):
+                setattr(namespace, dest, self._defaults[dest])
+
+        # parse the arguments and exit if there are any errors
+        try:
+            return self._parse_known_args(args, namespace)
+        except ArgumentError:
+            err = _sys.exc_info()[1]
+            self.error(str(err))
+
+    def _parse_known_args(self, arg_strings, namespace):
+        # replace arg strings that are file references
+        if self.fromfile_prefix_chars is not None:
+            arg_strings = self._read_args_from_files(arg_strings)
+
+        # map all mutually exclusive arguments to the other arguments
+        # they can't occur with
+        action_conflicts = {}
+        for mutex_group in self._mutually_exclusive_groups:
+            group_actions = mutex_group._group_actions
+            for i, mutex_action in enumerate(mutex_group._group_actions):
+                conflicts = action_conflicts.setdefault(mutex_action, [])
+                conflicts.extend(group_actions[:i])
+                conflicts.extend(group_actions[i + 1:])
+
+        # find all option indices, and determine the arg_string_pattern
+        # which has an 'O' if there is an option at an index,
+        # an 'A' if there is an argument, or a '-' if there is a '--'
+        option_string_indices = {}
+        arg_string_pattern_parts = []
+        arg_strings_iter = iter(arg_strings)
+        for i, arg_string in enumerate(arg_strings_iter):
+
+            # all args after -- are non-options
+            if arg_string == '--':
+                arg_string_pattern_parts.append('-')
+                for arg_string in arg_strings_iter:
+                    arg_string_pattern_parts.append('A')
+
+            # otherwise, add the arg to the arg strings
+            # and note the index if it was an option
+            else:
+                option_tuple = self._parse_optional(arg_string)
+                if option_tuple is None:
+                    pattern = 'A'
+                else:
+                    option_string_indices[i] = option_tuple
+                    pattern = 'O'
+                arg_string_pattern_parts.append(pattern)
+
+        # join the pieces together to form the pattern
+        arg_strings_pattern = ''.join(arg_string_pattern_parts)
+
+        # converts arg strings to the appropriate and then takes the action
+        seen_actions = _set()
+        seen_non_default_actions = _set()
+
+        def take_action(action, argument_strings, option_string=None):
+            seen_actions.add(action)
+            argument_values = self._get_values(action, argument_strings)
+
+            # error if this argument is not allowed with other previously
+            # seen arguments, assuming that actions that use the default
+            # value don't really count as "present"
+            if argument_values is not action.default:
+                seen_non_default_actions.add(action)
+                for conflict_action in action_conflicts.get(action, []):
+                    if conflict_action in seen_non_default_actions:
+                        msg = _('not allowed with argument %s')
+                        action_name = _get_action_name(conflict_action)
+                        raise ArgumentError(action, msg % action_name)
+
+            # take the action if we didn't receive a SUPPRESS value
+            # (e.g. from a default)
+            if argument_values is not SUPPRESS:
+                action(self, namespace, argument_values, option_string)
+
+        # function to convert arg_strings into an optional action
+        def consume_optional(start_index):
+
+            # get the optional identified at this index
+            option_tuple = option_string_indices[start_index]
+            action, option_string, explicit_arg = option_tuple
+
+            # identify additional optionals in the same arg string
+            # (e.g. -xyz is the same as -x -y -z if no args are required)
+            match_argument = self._match_argument
+            action_tuples = []
+            while True:
+
+                # if we found no optional action, skip it
+                if action is None:
+                    extras.append(arg_strings[start_index])
+                    return start_index + 1
+
+                # if there is an explicit argument, try to match the
+                # optional's string arguments to only this
+                if explicit_arg is not None:
+                    arg_count = match_argument(action, 'A')
+
+                    # if the action is a single-dash option and takes no
+                    # arguments, try to parse more single-dash options out
+                    # of the tail of the option string
+                    chars = self.prefix_chars
+                    if arg_count == 0 and option_string[1] not in chars:
+                        action_tuples.append((action, [], option_string))
+                        for char in self.prefix_chars:
+                            option_string = char + explicit_arg[0]
+                            explicit_arg = explicit_arg[1:] or None
+                            optionals_map = self._option_string_actions
+                            if option_string in optionals_map:
+                                action = optionals_map[option_string]
+                                break
+                        else:
+                            msg = _('ignored explicit argument %r')
+                            raise ArgumentError(action, msg % explicit_arg)
+
+                    # if the action expect exactly one argument, we've
+                    # successfully matched the option; exit the loop
+                    elif arg_count == 1:
+                        stop = start_index + 1
+                        args = [explicit_arg]
+                        action_tuples.append((action, args, option_string))
+                        break
+
+                    # error if a double-dash option did not use the
+                    # explicit argument
+                    else:
+                        msg = _('ignored explicit argument %r')
+                        raise ArgumentError(action, msg % explicit_arg)
+
+                # if there is no explicit argument, try to match the
+                # optional's string arguments with the following strings
+                # if successful, exit the loop
+                else:
+                    start = start_index + 1
+                    selected_patterns = arg_strings_pattern[start:]
+                    arg_count = match_argument(action, selected_patterns)
+                    stop = start + arg_count
+                    args = arg_strings[start:stop]
+                    action_tuples.append((action, args, option_string))
+                    break
+
+            # add the Optional to the list and return the index at which
+            # the Optional's string args stopped
+            assert action_tuples
+            for action, args, option_string in action_tuples:
+                take_action(action, args, option_string)
+            return stop
+
+        # the list of Positionals left to be parsed; this is modified
+        # by consume_positionals()
+        positionals = self._get_positional_actions()
+
+        # function to convert arg_strings into positional actions
+        def consume_positionals(start_index):
+            # match as many Positionals as possible
+            match_partial = self._match_arguments_partial
+            selected_pattern = arg_strings_pattern[start_index:]
+            arg_counts = match_partial(positionals, selected_pattern)
+
+            # slice off the appropriate arg strings for each Positional
+            # and add the Positional and its args to the list
+            for action, arg_count in zip(positionals, arg_counts):
+                args = arg_strings[start_index: start_index + arg_count]
+                start_index += arg_count
+                take_action(action, args)
+
+            # slice off the Positionals that we just parsed and return the
+            # index at which the Positionals' string args stopped
+            positionals[:] = positionals[len(arg_counts):]
+            return start_index
+
+        # consume Positionals and Optionals alternately, until we have
+        # passed the last option string
+        extras = []
+        start_index = 0
+        if option_string_indices:
+            max_option_string_index = max(option_string_indices)
+        else:
+            max_option_string_index = -1
+        while start_index <= max_option_string_index:
+
+            # consume any Positionals preceding the next option
+            next_option_string_index = min([
+                index
+                for index in option_string_indices
+                if index >= start_index])
+            if start_index != next_option_string_index:
+                positionals_end_index = consume_positionals(start_index)
+
+                # only try to parse the next optional if we didn't consume
+                # the option string during the positionals parsing
+                if positionals_end_index > start_index:
+                    start_index = positionals_end_index
+                    continue
+                else:
+                    start_index = positionals_end_index
+
+            # if we consumed all the positionals we could and we're not
+            # at the index of an option string, there were extra arguments
+            if start_index not in option_string_indices:
+                strings = arg_strings[start_index:next_option_string_index]
+                extras.extend(strings)
+                start_index = next_option_string_index
+
+            # consume the next optional and any arguments for it
+            start_index = consume_optional(start_index)
+
+        # consume any positionals following the last Optional
+        stop_index = consume_positionals(start_index)
+
+        # if we didn't consume all the argument strings, there were extras
+        extras.extend(arg_strings[stop_index:])
+
+        # if we didn't use all the Positional objects, there were too few
+        # arg strings supplied.
+        if positionals:
+            self.error(_('too few arguments'))
+
+        # make sure all required actions were present
+        for action in self._actions:
+            if action.required:
+                if action not in seen_actions:
+                    name = _get_action_name(action)
+                    self.error(_('argument %s is required') % name)
+
+        # make sure all required groups had one option present
+        for group in self._mutually_exclusive_groups:
+            if group.required:
+                for action in group._group_actions:
+                    if action in seen_non_default_actions:
+                        break
+
+                # if no actions were used, report the error
+                else:
+                    names = [_get_action_name(action)
+                             for action in group._group_actions
+                             if action.help is not SUPPRESS]
+                    msg = _('one of the arguments %s is required')
+                    self.error(msg % ' '.join(names))
+
+        # return the updated namespace and the extra arguments
+        return namespace, extras
+
+    def _read_args_from_files(self, arg_strings):
+        # expand arguments referencing files
+        new_arg_strings = []
+        for arg_string in arg_strings:
+
+            # for regular arguments, just add them back into the list
+            if arg_string[0] not in self.fromfile_prefix_chars:
+                new_arg_strings.append(arg_string)
+
+            # replace arguments referencing files with the file content
+            else:
+                try:
+                    args_file = open(arg_string[1:])
+                    try:
+                        arg_strings = []
+                        for arg_line in args_file.read().splitlines():
+                            for arg in self.convert_arg_line_to_args(arg_line):
+                                arg_strings.append(arg)
+                        arg_strings = self._read_args_from_files(arg_strings)
+                        new_arg_strings.extend(arg_strings)
+                    finally:
+                        args_file.close()
+                except IOError:
+                    err = _sys.exc_info()[1]
+                    self.error(str(err))
+
+        # return the modified argument list
+        return new_arg_strings
+
+    def convert_arg_line_to_args(self, arg_line):
+        return [arg_line]
+
+    def _match_argument(self, action, arg_strings_pattern):
+        # match the pattern for this action to the arg strings
+        nargs_pattern = self._get_nargs_pattern(action)
+        match = _re.match(nargs_pattern, arg_strings_pattern)
+
+        # raise an exception if we weren't able to find a match
+        if match is None:
+            nargs_errors = {
+                None: _('expected one argument'),
+                OPTIONAL: _('expected at most one argument'),
+                ONE_OR_MORE: _('expected at least one argument'),
+            }
+            default = _('expected %s argument(s)') % action.nargs
+            msg = nargs_errors.get(action.nargs, default)
+            raise ArgumentError(action, msg)
+
+        # return the number of arguments matched
+        return len(match.group(1))
+
+    def _match_arguments_partial(self, actions, arg_strings_pattern):
+        # progressively shorten the actions list by slicing off the
+        # final actions until we find a match
+        result = []
+        for i in range(len(actions), 0, -1):
+            actions_slice = actions[:i]
+            pattern = ''.join([self._get_nargs_pattern(action)
+                               for action in actions_slice])
+            match = _re.match(pattern, arg_strings_pattern)
+            if match is not None:
+                result.extend([len(string) for string in match.groups()])
+                break
+
+        # return the list of arg string counts
+        return result
+
+    def _parse_optional(self, arg_string):
+        # if it's an empty string, it was meant to be a positional
+        if not arg_string:
+            return None
+
+        # if it doesn't start with a prefix, it was meant to be positional
+        if not arg_string[0] in self.prefix_chars:
+            return None
+
+        # if the option string is present in the parser, return the action
+        if arg_string in self._option_string_actions:
+            action = self._option_string_actions[arg_string]
+            return action, arg_string, None
+
+        # if it's just a single character, it was meant to be positional
+        if len(arg_string) == 1:
+            return None
+
+        # if the option string before the "=" is present, return the action
+        if '=' in arg_string:
+            option_string, explicit_arg = arg_string.split('=', 1)
+            if option_string in self._option_string_actions:
+                action = self._option_string_actions[option_string]
+                return action, option_string, explicit_arg
+
+        # search through all possible prefixes of the option string
+        # and all actions in the parser for possible interpretations
+        option_tuples = self._get_option_tuples(arg_string)
+
+        # if multiple actions match, the option string was ambiguous
+        if len(option_tuples) > 1:
+            options = ', '.join([option_string
+                for action, option_string, explicit_arg in option_tuples])
+            tup = arg_string, options
+            self.error(_('ambiguous option: %s could match %s') % tup)
+
+        # if exactly one action matched, this segmentation is good,
+        # so return the parsed action
+        elif len(option_tuples) == 1:
+            option_tuple, = option_tuples
+            return option_tuple
+
+        # if it was not found as an option, but it looks like a negative
+        # number, it was meant to be positional
+        # unless there are negative-number-like options
+        if self._negative_number_matcher.match(arg_string):
+            if not self._has_negative_number_optionals:
+                return None
+
+        # if it contains a space, it was meant to be a positional
+        if ' ' in arg_string:
+            return None
+
+        # it was meant to be an optional but there is no such option
+        # in this parser (though it might be a valid option in a subparser)
+        return None, arg_string, None
+
+    def _get_option_tuples(self, option_string):
+        result = []
+
+        # option strings starting with two prefix characters are only
+        # split at the '='
+        chars = self.prefix_chars
+        if option_string[0] in chars and option_string[1] in chars:
+            if '=' in option_string:
+                option_prefix, explicit_arg = option_string.split('=', 1)
+            else:
+                option_prefix = option_string
+                explicit_arg = None
+            for option_string in self._option_string_actions:
+                if option_string.startswith(option_prefix):
+                    action = self._option_string_actions[option_string]
+                    tup = action, option_string, explicit_arg
+                    result.append(tup)
+
+        # single character options can be concatenated with their arguments
+        # but multiple character options always have to have their argument
+        # separate
+        elif option_string[0] in chars and option_string[1] not in chars:
+            option_prefix = option_string
+            explicit_arg = None
+            short_option_prefix = option_string[:2]
+            short_explicit_arg = option_string[2:]
+
+            for option_string in self._option_string_actions:
+                if option_string == short_option_prefix:
+                    action = self._option_string_actions[option_string]
+                    tup = action, option_string, short_explicit_arg
+                    result.append(tup)
+                elif option_string.startswith(option_prefix):
+                    action = self._option_string_actions[option_string]
+                    tup = action, option_string, explicit_arg
+                    result.append(tup)
+
+        # shouldn't ever get here
+        else:
+            self.error(_('unexpected option string: %s') % option_string)
+
+        # return the collected option tuples
+        return result
+
+    def _get_nargs_pattern(self, action):
+        # in all examples below, we have to allow for '--' args
+        # which are represented as '-' in the pattern
+        nargs = action.nargs
+
+        # the default (None) is assumed to be a single argument
+        if nargs is None:
+            nargs_pattern = '(-*A-*)'
+
+        # allow zero or one arguments
+        elif nargs == OPTIONAL:
+            nargs_pattern = '(-*A?-*)'
+
+        # allow zero or more arguments
+        elif nargs == ZERO_OR_MORE:
+            nargs_pattern = '(-*[A-]*)'
+
+        # allow one or more arguments
+        elif nargs == ONE_OR_MORE:
+            nargs_pattern = '(-*A[A-]*)'
+
+        # allow any number of options or arguments
+        elif nargs == REMAINDER:
+            nargs_pattern = '([-AO]*)'
+
+        # allow one argument followed by any number of options or arguments
+        elif nargs == PARSER:
+            nargs_pattern = '(-*A[-AO]*)'
+
+        # all others should be integers
+        else:
+            nargs_pattern = '(-*%s-*)' % '-*'.join('A' * nargs)
+
+        # if this is an optional action, -- is not allowed
+        if action.option_strings:
+            nargs_pattern = nargs_pattern.replace('-*', '')
+            nargs_pattern = nargs_pattern.replace('-', '')
+
+        # return the pattern
+        return nargs_pattern
+
+    # ========================
+    # Value conversion methods
+    # ========================
+    def _get_values(self, action, arg_strings):
+        # for everything but PARSER args, strip out '--'
+        if action.nargs not in [PARSER, REMAINDER]:
+            arg_strings = [s for s in arg_strings if s != '--']
+
+        # optional argument produces a default when not present
+        if not arg_strings and action.nargs == OPTIONAL:
+            if action.option_strings:
+                value = action.const
+            else:
+                value = action.default
+            if isinstance(value, _basestring):
+                value = self._get_value(action, value)
+                self._check_value(action, value)
+
+        # when nargs='*' on a positional, if there were no command-line
+        # args, use the default if it is anything other than None
+        elif (not arg_strings and action.nargs == ZERO_OR_MORE and
+              not action.option_strings):
+            if action.default is not None:
+                value = action.default
+            else:
+                value = arg_strings
+            self._check_value(action, value)
+
+        # single argument or optional argument produces a single value
+        elif len(arg_strings) == 1 and action.nargs in [None, OPTIONAL]:
+            arg_string, = arg_strings
+            value = self._get_value(action, arg_string)
+            self._check_value(action, value)
+
+        # REMAINDER arguments convert all values, checking none
+        elif action.nargs == REMAINDER:
+            value = [self._get_value(action, v) for v in arg_strings]
+
+        # PARSER arguments convert all values, but check only the first
+        elif action.nargs == PARSER:
+            value = [self._get_value(action, v) for v in arg_strings]
+            self._check_value(action, value[0])
+
+        # all other types of nargs produce a list
+        else:
+            value = [self._get_value(action, v) for v in arg_strings]
+            for v in value:
+                self._check_value(action, v)
+
+        # return the converted value
+        return value
+
+    def _get_value(self, action, arg_string):
+        type_func = self._registry_get('type', action.type, action.type)
+        if not _callable(type_func):
+            msg = _('%r is not callable')
+            raise ArgumentError(action, msg % type_func)
+
+        # convert the value to the appropriate type
+        try:
+            result = type_func(arg_string)
+
+        # ArgumentTypeErrors indicate errors
+        except ArgumentTypeError:
+            name = getattr(action.type, '__name__', repr(action.type))
+            msg = str(_sys.exc_info()[1])
+            raise ArgumentError(action, msg)
+
+        # TypeErrors or ValueErrors also indicate errors
+        except (TypeError, ValueError):
+            name = getattr(action.type, '__name__', repr(action.type))
+            msg = _('invalid %s value: %r')
+            raise ArgumentError(action, msg % (name, arg_string))
+
+        # return the converted value
+        return result
+
+    def _check_value(self, action, value):
+        # converted value must be one of the choices (if specified)
+        if action.choices is not None and value not in action.choices:
+            tup = value, ', '.join(map(repr, action.choices))
+            msg = _('invalid choice: %r (choose from %s)') % tup
+            raise ArgumentError(action, msg)
+
+    # =======================
+    # Help-formatting methods
+    # =======================
+    def format_usage(self):
+        formatter = self._get_formatter()
+        formatter.add_usage(self.usage, self._actions,
+                            self._mutually_exclusive_groups)
+        return formatter.format_help()
+
+    def format_help(self):
+        formatter = self._get_formatter()
+
+        # usage
+        formatter.add_usage(self.usage, self._actions,
+                            self._mutually_exclusive_groups)
+
+        # description
+        formatter.add_text(self.description)
+
+        # positionals, optionals and user-defined groups
+        for action_group in self._action_groups:
+            formatter.start_section(action_group.title)
+            formatter.add_text(action_group.description)
+            formatter.add_arguments(action_group._group_actions)
+            formatter.end_section()
+
+        # epilog
+        formatter.add_text(self.epilog)
+
+        # determine help from format above
+        return formatter.format_help()
+
+    def format_version(self):
+        import warnings
+        warnings.warn(
+            'The format_version method is deprecated -- the "version" '
+            'argument to ArgumentParser is no longer supported.',
+            DeprecationWarning)
+        formatter = self._get_formatter()
+        formatter.add_text(self.version)
+        return formatter.format_help()
+
+    def _get_formatter(self):
+        return self.formatter_class(prog=self.prog)
+
+    # =====================
+    # Help-printing methods
+    # =====================
+    def print_usage(self, file=None):
+        if file is None:
+            file = _sys.stdout
+        self._print_message(self.format_usage(), file)
+
+    def print_help(self, file=None):
+        if file is None:
+            file = _sys.stdout
+        self._print_message(self.format_help(), file)
+
+    def print_version(self, file=None):
+        import warnings
+        warnings.warn(
+            'The print_version method is deprecated -- the "version" '
+            'argument to ArgumentParser is no longer supported.',
+            DeprecationWarning)
+        self._print_message(self.format_version(), file)
+
+    def _print_message(self, message, file=None):
+        if message:
+            if file is None:
+                file = _sys.stderr
+            file.write(message)
+
+    # ===============
+    # Exiting methods
+    # ===============
+    def exit(self, status=0, message=None):
+        if message:
+            self._print_message(message, _sys.stderr)
+        _sys.exit(status)
+
+    def error(self, message):
+        """error(message: string)
+
+        Prints a usage message incorporating the message to stderr and
+        exits.
+
+        If you override this in a subclass, it should not return -- it
+        should either exit or raise an exception.
+        """
+        self.print_usage(_sys.stderr)
+        self.exit(2, _('%s: error: %s\n') % (self.prog, message))
diff --git a/Lib/test/test_argparse.py b/Lib/test/test_argparse.py
index a50a3db..4392e42 100644
--- a/Lib/test/test_argparse.py
+++ b/Lib/test/test_argparse.py
@@ -1,4206 +1,4206 @@
-# -*- coding: utf-8 -*-

-

-# Copyright © 2006-2009 Steven J. Bethard <steven.bethard@gmail.com>.

-#

-# Licensed under the Apache License, Version 2.0 (the "License"); you may not

-# use this file except in compliance with the License. You may obtain a copy

-# of the License at

-#

-#     http://www.apache.org/licenses/LICENSE-2.0

-#

-# Unless required by applicable law or agreed to in writing, software

-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

-# License for the specific language governing permissions and limitations

-# under the License.

-

-import codecs

-import os

-import shutil

-import sys

-import textwrap

-import tempfile

-import unittest

-import argparse

-

-try:

-    from StringIO import StringIO

-except ImportError:

-    from io import StringIO

-

-try:

-    set

-except NameError:

-    from sets import Set as set

-

-try:

-    sorted

-except NameError:

-

-    def sorted(iterable, reverse=False):

-        result = list(iterable)

-        result.sort()

-        if reverse:

-            result.reverse()

-        return result

-

-# silence Python 2.6 buggy warnings about Exception.message

-if sys.version_info[:2] == (2, 6):

-    import warnings

-    warnings.filterwarnings(

-        action='ignore',

-        message='BaseException.message has been deprecated as of Python 2.6',

-        category=DeprecationWarning)

-

-# silence warnings about version argument - these are expected

-import warnings

-warnings.filterwarnings(

-    action='ignore',

-    message='The "version" argument to ArgumentParser is deprecated.',

-    category=DeprecationWarning)

-warnings.filterwarnings(

-    action='ignore',

-    message='The format_version method is deprecated',

-    category=DeprecationWarning)

-warnings.filterwarnings(

-    action='ignore',

-    message='The print_version method is deprecated',

-    category=DeprecationWarning)

-

-

-class TestCase(unittest.TestCase):

-

-    def assertEqual(self, obj1, obj2):

-        if obj1 != obj2:

-            print('')

-            print(repr(obj1))

-            print(repr(obj2))

-            print(obj1)

-            print(obj2)

-        super(TestCase, self).assertEqual(obj1, obj2)

-

-

-class TempDirMixin(object):

-

-    def setUp(self):

-        self.temp_dir = tempfile.mkdtemp()

-        self.old_dir = os.getcwd()

-        os.chdir(self.temp_dir)

-

-    def tearDown(self):

-        os.chdir(self.old_dir)

-        while True:

-            try:

-                shutil.rmtree(self.temp_dir)

-            except WindowsError:

-                continue

-            else:

-                break

-

-

-class Sig(object):

-

-    def __init__(self, *args, **kwargs):

-        self.args = args

-        self.kwargs = kwargs

-

-

-class NS(object):

-

-    def __init__(self, **kwargs):

-        self.__dict__.update(kwargs)

-

-    def __repr__(self):

-        sorted_items = sorted(self.__dict__.items())

-        kwarg_str = ', '.join(['%s=%r' % tup for tup in sorted_items])

-        return '%s(%s)' % (type(self).__name__, kwarg_str)

-

-    def __eq__(self, other):

-        return vars(self) == vars(other)

-

-    def __ne__(self, other):

-        return not (self == other)

-

-

-class ArgumentParserError(Exception):

-

-    def __init__(self, message, stdout=None, stderr=None, error_code=None):

-        Exception.__init__(self, message, stdout, stderr)

-        self.message = message

-        self.stdout = stdout

-        self.stderr = stderr

-        self.error_code = error_code

-

-

-def stderr_to_parser_error(parse_args, *args, **kwargs):

-    # if this is being called recursively and stderr or stdout is already being

-    # redirected, simply call the function and let the enclosing function

-    # catch the exception

-    if isinstance(sys.stderr, StringIO) or isinstance(sys.stdout, StringIO):

-        return parse_args(*args, **kwargs)

-

-    # if this is not being called recursively, redirect stderr and

-    # use it as the ArgumentParserError message

-    old_stdout = sys.stdout

-    old_stderr = sys.stderr

-    sys.stdout = StringIO()

-    sys.stderr = StringIO()

-    try:

-        try:

-            result = parse_args(*args, **kwargs)

-            for key in list(vars(result)):

-                if getattr(result, key) is sys.stdout:

-                    setattr(result, key, old_stdout)

-                if getattr(result, key) is sys.stderr:

-                    setattr(result, key, old_stderr)

-            return result

-        except SystemExit:

-            code = sys.exc_info()[1].code

-            stdout = sys.stdout.getvalue()

-            stderr = sys.stderr.getvalue()

-            raise ArgumentParserError("SystemExit", stdout, stderr, code)

-    finally:

-        sys.stdout = old_stdout

-        sys.stderr = old_stderr

-

-

-class ErrorRaisingArgumentParser(argparse.ArgumentParser):

-

-    def parse_args(self, *args, **kwargs):

-        parse_args = super(ErrorRaisingArgumentParser, self).parse_args

-        return stderr_to_parser_error(parse_args, *args, **kwargs)

-

-    def exit(self, *args, **kwargs):

-        exit = super(ErrorRaisingArgumentParser, self).exit

-        return stderr_to_parser_error(exit, *args, **kwargs)

-

-    def error(self, *args, **kwargs):

-        error = super(ErrorRaisingArgumentParser, self).error

-        return stderr_to_parser_error(error, *args, **kwargs)

-

-

-class ParserTesterMetaclass(type):

-    """Adds parser tests using the class attributes.

-

-    Classes of this type should specify the following attributes:

-

-    argument_signatures -- a list of Sig objects which specify

-        the signatures of Argument objects to be created

-    failures -- a list of args lists that should cause the parser

-        to fail

-    successes -- a list of (initial_args, options, remaining_args) tuples

-        where initial_args specifies the string args to be parsed,

-        options is a dict that should match the vars() of the options

-        parsed out of initial_args, and remaining_args should be any

-        remaining unparsed arguments

-    """

-

-    def __init__(cls, name, bases, bodydict):

-        if name == 'ParserTestCase':

-            return

-

-        # default parser signature is empty

-        if not hasattr(cls, 'parser_signature'):

-            cls.parser_signature = Sig()

-        if not hasattr(cls, 'parser_class'):

-            cls.parser_class = ErrorRaisingArgumentParser

-

-        # ---------------------------------------

-        # functions for adding optional arguments

-        # ---------------------------------------

-        def no_groups(parser, argument_signatures):

-            """Add all arguments directly to the parser"""

-            for sig in argument_signatures:

-                parser.add_argument(*sig.args, **sig.kwargs)

-

-        def one_group(parser, argument_signatures):

-            """Add all arguments under a single group in the parser"""

-            group = parser.add_argument_group('foo')

-            for sig in argument_signatures:

-                group.add_argument(*sig.args, **sig.kwargs)

-

-        def many_groups(parser, argument_signatures):

-            """Add each argument in its own group to the parser"""

-            for i, sig in enumerate(argument_signatures):

-                group = parser.add_argument_group('foo:%i' % i)

-                group.add_argument(*sig.args, **sig.kwargs)

-

-        # --------------------------

-        # functions for parsing args

-        # --------------------------

-        def listargs(parser, args):

-            """Parse the args by passing in a list"""

-            return parser.parse_args(args)

-

-        def sysargs(parser, args):

-            """Parse the args by defaulting to sys.argv"""

-            old_sys_argv = sys.argv

-            sys.argv = [old_sys_argv[0]] + args

-            try:

-                return parser.parse_args()

-            finally:

-                sys.argv = old_sys_argv

-

-        # class that holds the combination of one optional argument

-        # addition method and one arg parsing method

-        class AddTests(object):

-

-            def __init__(self, tester_cls, add_arguments, parse_args):

-                self._add_arguments = add_arguments

-                self._parse_args = parse_args

-

-                add_arguments_name = self._add_arguments.__name__

-                parse_args_name = self._parse_args.__name__

-                for test_func in [self.test_failures, self.test_successes]:

-                    func_name = test_func.__name__

-                    names = func_name, add_arguments_name, parse_args_name

-                    test_name = '_'.join(names)

-

-                    def wrapper(self, test_func=test_func):

-                        test_func(self)

-                    try:

-                        wrapper.__name__ = test_name

-                    except TypeError:

-                        pass

-                    setattr(tester_cls, test_name, wrapper)

-

-            def _get_parser(self, tester):

-                args = tester.parser_signature.args

-                kwargs = tester.parser_signature.kwargs

-                parser = tester.parser_class(*args, **kwargs)

-                self._add_arguments(parser, tester.argument_signatures)

-                return parser

-

-            def test_failures(self, tester):

-                parser = self._get_parser(tester)

-                for args_str in tester.failures:

-                    args = args_str.split()

-                    raises = tester.assertRaises

-                    raises(ArgumentParserError, parser.parse_args, args)

-

-            def test_successes(self, tester):

-                parser = self._get_parser(tester)

-                for args, expected_ns in tester.successes:

-                    if isinstance(args, str):

-                        args = args.split()

-                    result_ns = self._parse_args(parser, args)

-                    tester.assertEqual(expected_ns, result_ns)

-

-        # add tests for each combination of an optionals adding method

-        # and an arg parsing method

-        for add_arguments in [no_groups, one_group, many_groups]:

-            for parse_args in [listargs, sysargs]:

-                AddTests(cls, add_arguments, parse_args)

-

-bases = TestCase,

-ParserTestCase = ParserTesterMetaclass('ParserTestCase', bases, {})

-

-# ===============

-# Optionals tests

-# ===============

-

-class TestOptionalsSingleDash(ParserTestCase):

-    """Test an Optional with a single-dash option string"""

-

-    argument_signatures = [Sig('-x')]

-    failures = ['-x', 'a', '--foo', '-x --foo', '-x -y']

-    successes = [

-        ('', NS(x=None)),

-        ('-x a', NS(x='a')),

-        ('-xa', NS(x='a')),

-        ('-x -1', NS(x='-1')),

-        ('-x-1', NS(x='-1')),

-    ]

-

-

-class TestOptionalsSingleDashCombined(ParserTestCase):

-    """Test an Optional with a single-dash option string"""

-

-    argument_signatures = [

-        Sig('-x', action='store_true'),

-        Sig('-yyy', action='store_const', const=42),

-        Sig('-z'),

-    ]

-    failures = ['a', '--foo', '-xa', '-x --foo', '-x -z', '-z -x',

-                '-yx', '-yz a', '-yyyx', '-yyyza', '-xyza']

-    successes = [

-        ('', NS(x=False, yyy=None, z=None)),

-        ('-x', NS(x=True, yyy=None, z=None)),

-        ('-za', NS(x=False, yyy=None, z='a')),

-        ('-z a', NS(x=False, yyy=None, z='a')),

-        ('-xza', NS(x=True, yyy=None, z='a')),

-        ('-xz a', NS(x=True, yyy=None, z='a')),

-        ('-x -za', NS(x=True, yyy=None, z='a')),

-        ('-x -z a', NS(x=True, yyy=None, z='a')),

-        ('-y', NS(x=False, yyy=42, z=None)),

-        ('-yyy', NS(x=False, yyy=42, z=None)),

-        ('-x -yyy -za', NS(x=True, yyy=42, z='a')),

-        ('-x -yyy -z a', NS(x=True, yyy=42, z='a')),

-    ]

-

-

-class TestOptionalsSingleDashLong(ParserTestCase):

-    """Test an Optional with a multi-character single-dash option string"""

-

-    argument_signatures = [Sig('-foo')]

-    failures = ['-foo', 'a', '--foo', '-foo --foo', '-foo -y', '-fooa']

-    successes = [

-        ('', NS(foo=None)),

-        ('-foo a', NS(foo='a')),

-        ('-foo -1', NS(foo='-1')),

-        ('-fo a', NS(foo='a')),

-        ('-f a', NS(foo='a')),

-    ]

-

-

-class TestOptionalsSingleDashSubsetAmbiguous(ParserTestCase):

-    """Test Optionals where option strings are subsets of each other"""

-

-    argument_signatures = [Sig('-f'), Sig('-foobar'), Sig('-foorab')]

-    failures = ['-f', '-foo', '-fo', '-foo b', '-foob', '-fooba', '-foora']

-    successes = [

-        ('', NS(f=None, foobar=None, foorab=None)),

-        ('-f a', NS(f='a', foobar=None, foorab=None)),

-        ('-fa', NS(f='a', foobar=None, foorab=None)),

-        ('-foa', NS(f='oa', foobar=None, foorab=None)),

-        ('-fooa', NS(f='ooa', foobar=None, foorab=None)),

-        ('-foobar a', NS(f=None, foobar='a', foorab=None)),

-        ('-foorab a', NS(f=None, foobar=None, foorab='a')),

-    ]

-

-

-class TestOptionalsSingleDashAmbiguous(ParserTestCase):

-    """Test Optionals that partially match but are not subsets"""

-

-    argument_signatures = [Sig('-foobar'), Sig('-foorab')]

-    failures = ['-f', '-f a', '-fa', '-foa', '-foo', '-fo', '-foo b']

-    successes = [

-        ('', NS(foobar=None, foorab=None)),

-        ('-foob a', NS(foobar='a', foorab=None)),

-        ('-foor a', NS(foobar=None, foorab='a')),

-        ('-fooba a', NS(foobar='a', foorab=None)),

-        ('-foora a', NS(foobar=None, foorab='a')),

-        ('-foobar a', NS(foobar='a', foorab=None)),

-        ('-foorab a', NS(foobar=None, foorab='a')),

-    ]

-

-

-class TestOptionalsNumeric(ParserTestCase):

-    """Test an Optional with a short opt string"""

-

-    argument_signatures = [Sig('-1', dest='one')]

-    failures = ['-1', 'a', '-1 --foo', '-1 -y', '-1 -1', '-1 -2']

-    successes = [

-        ('', NS(one=None)),

-        ('-1 a', NS(one='a')),

-        ('-1a', NS(one='a')),

-        ('-1-2', NS(one='-2')),

-    ]

-

-

-class TestOptionalsDoubleDash(ParserTestCase):

-    """Test an Optional with a double-dash option string"""

-

-    argument_signatures = [Sig('--foo')]

-    failures = ['--foo', '-f', '-f a', 'a', '--foo -x', '--foo --bar']

-    successes = [

-        ('', NS(foo=None)),

-        ('--foo a', NS(foo='a')),

-        ('--foo=a', NS(foo='a')),

-        ('--foo -2.5', NS(foo='-2.5')),

-        ('--foo=-2.5', NS(foo='-2.5')),

-    ]

-

-

-class TestOptionalsDoubleDashPartialMatch(ParserTestCase):

-    """Tests partial matching with a double-dash option string"""

-

-    argument_signatures = [

-        Sig('--badger', action='store_true'),

-        Sig('--bat'),

-    ]

-    failures = ['--bar', '--b', '--ba', '--b=2', '--ba=4', '--badge 5']

-    successes = [

-        ('', NS(badger=False, bat=None)),

-        ('--bat X', NS(badger=False, bat='X')),

-        ('--bad', NS(badger=True, bat=None)),

-        ('--badg', NS(badger=True, bat=None)),

-        ('--badge', NS(badger=True, bat=None)),

-        ('--badger', NS(badger=True, bat=None)),

-    ]

-

-

-class TestOptionalsDoubleDashPrefixMatch(ParserTestCase):

-    """Tests when one double-dash option string is a prefix of another"""

-

-    argument_signatures = [

-        Sig('--badger', action='store_true'),

-        Sig('--ba'),

-    ]

-    failures = ['--bar', '--b', '--ba', '--b=2', '--badge 5']

-    successes = [

-        ('', NS(badger=False, ba=None)),

-        ('--ba X', NS(badger=False, ba='X')),

-        ('--ba=X', NS(badger=False, ba='X')),

-        ('--bad', NS(badger=True, ba=None)),

-        ('--badg', NS(badger=True, ba=None)),

-        ('--badge', NS(badger=True, ba=None)),

-        ('--badger', NS(badger=True, ba=None)),

-    ]

-

-

-class TestOptionalsSingleDoubleDash(ParserTestCase):

-    """Test an Optional with single- and double-dash option strings"""

-

-    argument_signatures = [

-        Sig('-f', action='store_true'),

-        Sig('--bar'),

-        Sig('-baz', action='store_const', const=42),

-    ]

-    failures = ['--bar', '-fbar', '-fbaz', '-bazf', '-b B', 'B']

-    successes = [

-        ('', NS(f=False, bar=None, baz=None)),

-        ('-f', NS(f=True, bar=None, baz=None)),

-        ('--ba B', NS(f=False, bar='B', baz=None)),

-        ('-f --bar B', NS(f=True, bar='B', baz=None)),

-        ('-f -b', NS(f=True, bar=None, baz=42)),

-        ('-ba -f', NS(f=True, bar=None, baz=42)),

-    ]

-

-

-class TestOptionalsAlternatePrefixChars(ParserTestCase):

-    """Test an Optional with a double-dash option string"""

-

-    parser_signature = Sig(prefix_chars='+:/', add_help=False)

-    argument_signatures = [

-        Sig('+f', action='store_true'),

-        Sig('::bar'),

-        Sig('/baz', action='store_const', const=42),

-    ]

-    failures = ['--bar', '-fbar', '-b B', 'B', '-f', '--bar B', '-baz']

-    successes = [

-        ('', NS(f=False, bar=None, baz=None)),

-        ('+f', NS(f=True, bar=None, baz=None)),

-        ('::ba B', NS(f=False, bar='B', baz=None)),

-        ('+f ::bar B', NS(f=True, bar='B', baz=None)),

-        ('+f /b', NS(f=True, bar=None, baz=42)),

-        ('/ba +f', NS(f=True, bar=None, baz=42)),

-    ]

-

-

-class TestOptionalsShortLong(ParserTestCase):

-    """Test a combination of single- and double-dash option strings"""

-

-    argument_signatures = [

-        Sig('-v', '--verbose', '-n', '--noisy', action='store_true'),

-    ]

-    failures = ['--x --verbose', '-N', 'a', '-v x']

-    successes = [

-        ('', NS(verbose=False)),

-        ('-v', NS(verbose=True)),

-        ('--verbose', NS(verbose=True)),

-        ('-n', NS(verbose=True)),

-        ('--noisy', NS(verbose=True)),

-    ]

-

-

-class TestOptionalsDest(ParserTestCase):

-    """Tests various means of setting destination"""

-

-    argument_signatures = [Sig('--foo-bar'), Sig('--baz', dest='zabbaz')]

-    failures = ['a']

-    successes = [

-        ('--foo-bar f', NS(foo_bar='f', zabbaz=None)),

-        ('--baz g', NS(foo_bar=None, zabbaz='g')),

-        ('--foo-bar h --baz i', NS(foo_bar='h', zabbaz='i')),

-        ('--baz j --foo-bar k', NS(foo_bar='k', zabbaz='j')),

-    ]

-

-

-class TestOptionalsDefault(ParserTestCase):

-    """Tests specifying a default for an Optional"""

-

-    argument_signatures = [Sig('-x'), Sig('-y', default=42)]

-    failures = ['a']

-    successes = [

-        ('', NS(x=None, y=42)),

-        ('-xx', NS(x='x', y=42)),

-        ('-yy', NS(x=None, y='y')),

-    ]

-

-

-class TestOptionalsNargsDefault(ParserTestCase):

-    """Tests not specifying the number of args for an Optional"""

-

-    argument_signatures = [Sig('-x')]

-    failures = ['a', '-x']

-    successes = [

-        ('', NS(x=None)),

-        ('-x a', NS(x='a')),

-    ]

-

-

-class TestOptionalsNargs1(ParserTestCase):

-    """Tests specifying the 1 arg for an Optional"""

-

-    argument_signatures = [Sig('-x', nargs=1)]

-    failures = ['a', '-x']

-    successes = [

-        ('', NS(x=None)),

-        ('-x a', NS(x=['a'])),

-    ]

-

-

-class TestOptionalsNargs3(ParserTestCase):

-    """Tests specifying the 3 args for an Optional"""

-

-    argument_signatures = [Sig('-x', nargs=3)]

-    failures = ['a', '-x', '-x a', '-x a b', 'a -x', 'a -x b']

-    successes = [

-        ('', NS(x=None)),

-        ('-x a b c', NS(x=['a', 'b', 'c'])),

-    ]

-

-

-class TestOptionalsNargsOptional(ParserTestCase):

-    """Tests specifying an Optional arg for an Optional"""

-

-    argument_signatures = [

-        Sig('-w', nargs='?'),

-        Sig('-x', nargs='?', const=42),

-        Sig('-y', nargs='?', default='spam'),

-        Sig('-z', nargs='?', type=int, const='42', default='84'),

-    ]

-    failures = ['2']

-    successes = [

-        ('', NS(w=None, x=None, y='spam', z=84)),

-        ('-w', NS(w=None, x=None, y='spam', z=84)),

-        ('-w 2', NS(w='2', x=None, y='spam', z=84)),

-        ('-x', NS(w=None, x=42, y='spam', z=84)),

-        ('-x 2', NS(w=None, x='2', y='spam', z=84)),

-        ('-y', NS(w=None, x=None, y=None, z=84)),

-        ('-y 2', NS(w=None, x=None, y='2', z=84)),

-        ('-z', NS(w=None, x=None, y='spam', z=42)),

-        ('-z 2', NS(w=None, x=None, y='spam', z=2)),

-    ]

-

-

-class TestOptionalsNargsZeroOrMore(ParserTestCase):

-    """Tests specifying an args for an Optional that accepts zero or more"""

-

-    argument_signatures = [

-        Sig('-x', nargs='*'),

-        Sig('-y', nargs='*', default='spam'),

-    ]

-    failures = ['a']

-    successes = [

-        ('', NS(x=None, y='spam')),

-        ('-x', NS(x=[], y='spam')),

-        ('-x a', NS(x=['a'], y='spam')),

-        ('-x a b', NS(x=['a', 'b'], y='spam')),

-        ('-y', NS(x=None, y=[])),

-        ('-y a', NS(x=None, y=['a'])),

-        ('-y a b', NS(x=None, y=['a', 'b'])),

-    ]

-

-

-class TestOptionalsNargsOneOrMore(ParserTestCase):

-    """Tests specifying an args for an Optional that accepts one or more"""

-

-    argument_signatures = [

-        Sig('-x', nargs='+'),

-        Sig('-y', nargs='+', default='spam'),

-    ]

-    failures = ['a', '-x', '-y', 'a -x', 'a -y b']

-    successes = [

-        ('', NS(x=None, y='spam')),

-        ('-x a', NS(x=['a'], y='spam')),

-        ('-x a b', NS(x=['a', 'b'], y='spam')),

-        ('-y a', NS(x=None, y=['a'])),

-        ('-y a b', NS(x=None, y=['a', 'b'])),

-    ]

-

-

-class TestOptionalsChoices(ParserTestCase):

-    """Tests specifying the choices for an Optional"""

-

-    argument_signatures = [

-        Sig('-f', choices='abc'),

-        Sig('-g', type=int, choices=range(5))]

-    failures = ['a', '-f d', '-fad', '-ga', '-g 6']

-    successes = [

-        ('', NS(f=None, g=None)),

-        ('-f a', NS(f='a', g=None)),

-        ('-f c', NS(f='c', g=None)),

-        ('-g 0', NS(f=None, g=0)),

-        ('-g 03', NS(f=None, g=3)),

-        ('-fb -g4', NS(f='b', g=4)),

-    ]

-

-

-class TestOptionalsRequired(ParserTestCase):

-    """Tests the an optional action that is required"""

-

-    argument_signatures = [

-        Sig('-x', type=int, required=True),

-    ]

-    failures = ['a', '']

-    successes = [

-        ('-x 1', NS(x=1)),

-        ('-x42', NS(x=42)),

-    ]

-

-

-class TestOptionalsActionStore(ParserTestCase):

-    """Tests the store action for an Optional"""

-

-    argument_signatures = [Sig('-x', action='store')]

-    failures = ['a', 'a -x']

-    successes = [

-        ('', NS(x=None)),

-        ('-xfoo', NS(x='foo')),

-    ]

-

-

-class TestOptionalsActionStoreConst(ParserTestCase):

-    """Tests the store_const action for an Optional"""

-

-    argument_signatures = [Sig('-y', action='store_const', const=object)]

-    failures = ['a']

-    successes = [

-        ('', NS(y=None)),

-        ('-y', NS(y=object)),

-    ]

-

-

-class TestOptionalsActionStoreFalse(ParserTestCase):

-    """Tests the store_false action for an Optional"""

-

-    argument_signatures = [Sig('-z', action='store_false')]

-    failures = ['a', '-za', '-z a']

-    successes = [

-        ('', NS(z=True)),

-        ('-z', NS(z=False)),

-    ]

-

-

-class TestOptionalsActionStoreTrue(ParserTestCase):

-    """Tests the store_true action for an Optional"""

-

-    argument_signatures = [Sig('--apple', action='store_true')]

-    failures = ['a', '--apple=b', '--apple b']

-    successes = [

-        ('', NS(apple=False)),

-        ('--apple', NS(apple=True)),

-    ]

-

-

-class TestOptionalsActionAppend(ParserTestCase):

-    """Tests the append action for an Optional"""

-

-    argument_signatures = [Sig('--baz', action='append')]

-    failures = ['a', '--baz', 'a --baz', '--baz a b']

-    successes = [

-        ('', NS(baz=None)),

-        ('--baz a', NS(baz=['a'])),

-        ('--baz a --baz b', NS(baz=['a', 'b'])),

-    ]

-

-

-class TestOptionalsActionAppendWithDefault(ParserTestCase):

-    """Tests the append action for an Optional"""

-

-    argument_signatures = [Sig('--baz', action='append', default=['X'])]

-    failures = ['a', '--baz', 'a --baz', '--baz a b']

-    successes = [

-        ('', NS(baz=['X'])),

-        ('--baz a', NS(baz=['X', 'a'])),

-        ('--baz a --baz b', NS(baz=['X', 'a', 'b'])),

-    ]

-

-

-class TestOptionalsActionAppendConst(ParserTestCase):

-    """Tests the append_const action for an Optional"""

-

-    argument_signatures = [

-        Sig('-b', action='append_const', const=Exception),

-        Sig('-c', action='append', dest='b'),

-    ]

-    failures = ['a', '-c', 'a -c', '-bx', '-b x']

-    successes = [

-        ('', NS(b=None)),

-        ('-b', NS(b=[Exception])),

-        ('-b -cx -b -cyz', NS(b=[Exception, 'x', Exception, 'yz'])),

-    ]

-

-

-class TestOptionalsActionAppendConstWithDefault(ParserTestCase):

-    """Tests the append_const action for an Optional"""

-

-    argument_signatures = [

-        Sig('-b', action='append_const', const=Exception, default=['X']),

-        Sig('-c', action='append', dest='b'),

-    ]

-    failures = ['a', '-c', 'a -c', '-bx', '-b x']

-    successes = [

-        ('', NS(b=['X'])),

-        ('-b', NS(b=['X', Exception])),

-        ('-b -cx -b -cyz', NS(b=['X', Exception, 'x', Exception, 'yz'])),

-    ]

-

-

-class TestOptionalsActionCount(ParserTestCase):

-    """Tests the count action for an Optional"""

-

-    argument_signatures = [Sig('-x', action='count')]

-    failures = ['a', '-x a', '-x b', '-x a -x b']

-    successes = [

-        ('', NS(x=None)),

-        ('-x', NS(x=1)),

-    ]

-

-

-# ================

-# Positional tests

-# ================

-

-class TestPositionalsNargsNone(ParserTestCase):

-    """Test a Positional that doesn't specify nargs"""

-

-    argument_signatures = [Sig('foo')]

-    failures = ['', '-x', 'a b']

-    successes = [

-        ('a', NS(foo='a')),

-    ]

-

-

-class TestPositionalsNargs1(ParserTestCase):

-    """Test a Positional that specifies an nargs of 1"""

-

-    argument_signatures = [Sig('foo', nargs=1)]

-    failures = ['', '-x', 'a b']

-    successes = [

-        ('a', NS(foo=['a'])),

-    ]

-

-

-class TestPositionalsNargs2(ParserTestCase):

-    """Test a Positional that specifies an nargs of 2"""

-

-    argument_signatures = [Sig('foo', nargs=2)]

-    failures = ['', 'a', '-x', 'a b c']

-    successes = [

-        ('a b', NS(foo=['a', 'b'])),

-    ]

-

-

-class TestPositionalsNargsZeroOrMore(ParserTestCase):

-    """Test a Positional that specifies unlimited nargs"""

-

-    argument_signatures = [Sig('foo', nargs='*')]

-    failures = ['-x']

-    successes = [

-        ('', NS(foo=[])),

-        ('a', NS(foo=['a'])),

-        ('a b', NS(foo=['a', 'b'])),

-    ]

-

-

-class TestPositionalsNargsZeroOrMoreDefault(ParserTestCase):

-    """Test a Positional that specifies unlimited nargs and a default"""

-

-    argument_signatures = [Sig('foo', nargs='*', default='bar')]

-    failures = ['-x']

-    successes = [

-        ('', NS(foo='bar')),

-        ('a', NS(foo=['a'])),

-        ('a b', NS(foo=['a', 'b'])),

-    ]

-

-

-class TestPositionalsNargsOneOrMore(ParserTestCase):

-    """Test a Positional that specifies one or more nargs"""

-

-    argument_signatures = [Sig('foo', nargs='+')]

-    failures = ['', '-x']

-    successes = [

-        ('a', NS(foo=['a'])),

-        ('a b', NS(foo=['a', 'b'])),

-    ]

-

-

-class TestPositionalsNargsOptional(ParserTestCase):

-    """Tests an Optional Positional"""

-

-    argument_signatures = [Sig('foo', nargs='?')]

-    failures = ['-x', 'a b']

-    successes = [

-        ('', NS(foo=None)),

-        ('a', NS(foo='a')),

-    ]

-

-

-class TestPositionalsNargsOptionalDefault(ParserTestCase):

-    """Tests an Optional Positional with a default value"""

-

-    argument_signatures = [Sig('foo', nargs='?', default=42)]

-    failures = ['-x', 'a b']

-    successes = [

-        ('', NS(foo=42)),

-        ('a', NS(foo='a')),

-    ]

-

-

-class TestPositionalsNargsOptionalConvertedDefault(ParserTestCase):

-    """Tests an Optional Positional with a default value

-    that needs to be converted to the appropriate type.

-    """

-

-    argument_signatures = [

-        Sig('foo', nargs='?', type=int, default='42'),

-    ]

-    failures = ['-x', 'a b', '1 2']

-    successes = [

-        ('', NS(foo=42)),

-        ('1', NS(foo=1)),

-    ]

-

-

-class TestPositionalsNargsNoneNone(ParserTestCase):

-    """Test two Positionals that don't specify nargs"""

-

-    argument_signatures = [Sig('foo'), Sig('bar')]

-    failures = ['', '-x', 'a', 'a b c']

-    successes = [

-        ('a b', NS(foo='a', bar='b')),

-    ]

-

-

-class TestPositionalsNargsNone1(ParserTestCase):

-    """Test a Positional with no nargs followed by one with 1"""

-

-    argument_signatures = [Sig('foo'), Sig('bar', nargs=1)]

-    failures = ['', '--foo', 'a', 'a b c']

-    successes = [

-        ('a b', NS(foo='a', bar=['b'])),

-    ]

-

-

-class TestPositionalsNargs2None(ParserTestCase):

-    """Test a Positional with 2 nargs followed by one with none"""

-

-    argument_signatures = [Sig('foo', nargs=2), Sig('bar')]

-    failures = ['', '--foo', 'a', 'a b', 'a b c d']

-    successes = [

-        ('a b c', NS(foo=['a', 'b'], bar='c')),

-    ]

-

-

-class TestPositionalsNargsNoneZeroOrMore(ParserTestCase):

-    """Test a Positional with no nargs followed by one with unlimited"""

-

-    argument_signatures = [Sig('foo'), Sig('bar', nargs='*')]

-    failures = ['', '--foo']

-    successes = [

-        ('a', NS(foo='a', bar=[])),

-        ('a b', NS(foo='a', bar=['b'])),

-        ('a b c', NS(foo='a', bar=['b', 'c'])),

-    ]

-

-

-class TestPositionalsNargsNoneOneOrMore(ParserTestCase):

-    """Test a Positional with no nargs followed by one with one or more"""

-

-    argument_signatures = [Sig('foo'), Sig('bar', nargs='+')]

-    failures = ['', '--foo', 'a']

-    successes = [

-        ('a b', NS(foo='a', bar=['b'])),

-        ('a b c', NS(foo='a', bar=['b', 'c'])),

-    ]

-

-

-class TestPositionalsNargsNoneOptional(ParserTestCase):

-    """Test a Positional with no nargs followed by one with an Optional"""

-

-    argument_signatures = [Sig('foo'), Sig('bar', nargs='?')]

-    failures = ['', '--foo', 'a b c']

-    successes = [

-        ('a', NS(foo='a', bar=None)),

-        ('a b', NS(foo='a', bar='b')),

-    ]

-

-

-class TestPositionalsNargsZeroOrMoreNone(ParserTestCase):

-    """Test a Positional with unlimited nargs followed by one with none"""

-

-    argument_signatures = [Sig('foo', nargs='*'), Sig('bar')]

-    failures = ['', '--foo']

-    successes = [

-        ('a', NS(foo=[], bar='a')),

-        ('a b', NS(foo=['a'], bar='b')),

-        ('a b c', NS(foo=['a', 'b'], bar='c')),

-    ]

-

-

-class TestPositionalsNargsOneOrMoreNone(ParserTestCase):

-    """Test a Positional with one or more nargs followed by one with none"""

-

-    argument_signatures = [Sig('foo', nargs='+'), Sig('bar')]

-    failures = ['', '--foo', 'a']

-    successes = [

-        ('a b', NS(foo=['a'], bar='b')),

-        ('a b c', NS(foo=['a', 'b'], bar='c')),

-    ]

-

-

-class TestPositionalsNargsOptionalNone(ParserTestCase):

-    """Test a Positional with an Optional nargs followed by one with none"""

-

-    argument_signatures = [Sig('foo', nargs='?', default=42), Sig('bar')]

-    failures = ['', '--foo', 'a b c']

-    successes = [

-        ('a', NS(foo=42, bar='a')),

-        ('a b', NS(foo='a', bar='b')),

-    ]

-

-

-class TestPositionalsNargs2ZeroOrMore(ParserTestCase):

-    """Test a Positional with 2 nargs followed by one with unlimited"""

-

-    argument_signatures = [Sig('foo', nargs=2), Sig('bar', nargs='*')]

-    failures = ['', '--foo', 'a']

-    successes = [

-        ('a b', NS(foo=['a', 'b'], bar=[])),

-        ('a b c', NS(foo=['a', 'b'], bar=['c'])),

-    ]

-

-

-class TestPositionalsNargs2OneOrMore(ParserTestCase):

-    """Test a Positional with 2 nargs followed by one with one or more"""

-

-    argument_signatures = [Sig('foo', nargs=2), Sig('bar', nargs='+')]

-    failures = ['', '--foo', 'a', 'a b']

-    successes = [

-        ('a b c', NS(foo=['a', 'b'], bar=['c'])),

-    ]

-

-

-class TestPositionalsNargs2Optional(ParserTestCase):

-    """Test a Positional with 2 nargs followed by one optional"""

-

-    argument_signatures = [Sig('foo', nargs=2), Sig('bar', nargs='?')]

-    failures = ['', '--foo', 'a', 'a b c d']

-    successes = [

-        ('a b', NS(foo=['a', 'b'], bar=None)),

-        ('a b c', NS(foo=['a', 'b'], bar='c')),

-    ]

-

-

-class TestPositionalsNargsZeroOrMore1(ParserTestCase):

-    """Test a Positional with unlimited nargs followed by one with 1"""

-

-    argument_signatures = [Sig('foo', nargs='*'), Sig('bar', nargs=1)]

-    failures = ['', '--foo', ]

-    successes = [

-        ('a', NS(foo=[], bar=['a'])),

-        ('a b', NS(foo=['a'], bar=['b'])),

-        ('a b c', NS(foo=['a', 'b'], bar=['c'])),

-    ]

-

-

-class TestPositionalsNargsOneOrMore1(ParserTestCase):

-    """Test a Positional with one or more nargs followed by one with 1"""

-

-    argument_signatures = [Sig('foo', nargs='+'), Sig('bar', nargs=1)]

-    failures = ['', '--foo', 'a']

-    successes = [

-        ('a b', NS(foo=['a'], bar=['b'])),

-        ('a b c', NS(foo=['a', 'b'], bar=['c'])),

-    ]

-

-

-class TestPositionalsNargsOptional1(ParserTestCase):

-    """Test a Positional with an Optional nargs followed by one with 1"""

-

-    argument_signatures = [Sig('foo', nargs='?'), Sig('bar', nargs=1)]

-    failures = ['', '--foo', 'a b c']

-    successes = [

-        ('a', NS(foo=None, bar=['a'])),

-        ('a b', NS(foo='a', bar=['b'])),

-    ]

-

-

-class TestPositionalsNargsNoneZeroOrMore1(ParserTestCase):

-    """Test three Positionals: no nargs, unlimited nargs and 1 nargs"""

-

-    argument_signatures = [

-        Sig('foo'),

-        Sig('bar', nargs='*'),

-        Sig('baz', nargs=1),

-    ]

-    failures = ['', '--foo', 'a']

-    successes = [

-        ('a b', NS(foo='a', bar=[], baz=['b'])),

-        ('a b c', NS(foo='a', bar=['b'], baz=['c'])),

-    ]

-

-

-class TestPositionalsNargsNoneOneOrMore1(ParserTestCase):

-    """Test three Positionals: no nargs, one or more nargs and 1 nargs"""

-

-    argument_signatures = [

-        Sig('foo'),

-        Sig('bar', nargs='+'),

-        Sig('baz', nargs=1),

-    ]

-    failures = ['', '--foo', 'a', 'b']

-    successes = [

-        ('a b c', NS(foo='a', bar=['b'], baz=['c'])),

-        ('a b c d', NS(foo='a', bar=['b', 'c'], baz=['d'])),

-    ]

-

-

-class TestPositionalsNargsNoneOptional1(ParserTestCase):

-    """Test three Positionals: no nargs, optional narg and 1 nargs"""

-

-    argument_signatures = [

-        Sig('foo'),

-        Sig('bar', nargs='?', default=0.625),

-        Sig('baz', nargs=1),

-    ]

-    failures = ['', '--foo', 'a']

-    successes = [

-        ('a b', NS(foo='a', bar=0.625, baz=['b'])),

-        ('a b c', NS(foo='a', bar='b', baz=['c'])),

-    ]

-

-

-class TestPositionalsNargsOptionalOptional(ParserTestCase):

-    """Test two optional nargs"""

-

-    argument_signatures = [

-        Sig('foo', nargs='?'),

-        Sig('bar', nargs='?', default=42),

-    ]

-    failures = ['--foo', 'a b c']

-    successes = [

-        ('', NS(foo=None, bar=42)),

-        ('a', NS(foo='a', bar=42)),

-        ('a b', NS(foo='a', bar='b')),

-    ]

-

-

-class TestPositionalsNargsOptionalZeroOrMore(ParserTestCase):

-    """Test an Optional narg followed by unlimited nargs"""

-

-    argument_signatures = [Sig('foo', nargs='?'), Sig('bar', nargs='*')]

-    failures = ['--foo']

-    successes = [

-        ('', NS(foo=None, bar=[])),

-        ('a', NS(foo='a', bar=[])),

-        ('a b', NS(foo='a', bar=['b'])),

-        ('a b c', NS(foo='a', bar=['b', 'c'])),

-    ]

-

-

-class TestPositionalsNargsOptionalOneOrMore(ParserTestCase):

-    """Test an Optional narg followed by one or more nargs"""

-

-    argument_signatures = [Sig('foo', nargs='?'), Sig('bar', nargs='+')]

-    failures = ['', '--foo']

-    successes = [

-        ('a', NS(foo=None, bar=['a'])),

-        ('a b', NS(foo='a', bar=['b'])),

-        ('a b c', NS(foo='a', bar=['b', 'c'])),

-    ]

-

-

-class TestPositionalsChoicesString(ParserTestCase):

-    """Test a set of single-character choices"""

-

-    argument_signatures = [Sig('spam', choices=set('abcdefg'))]

-    failures = ['', '--foo', 'h', '42', 'ef']

-    successes = [

-        ('a', NS(spam='a')),

-        ('g', NS(spam='g')),

-    ]

-

-

-class TestPositionalsChoicesInt(ParserTestCase):

-    """Test a set of integer choices"""

-

-    argument_signatures = [Sig('spam', type=int, choices=range(20))]

-    failures = ['', '--foo', 'h', '42', 'ef']

-    successes = [

-        ('4', NS(spam=4)),

-        ('15', NS(spam=15)),

-    ]

-

-

-class TestPositionalsActionAppend(ParserTestCase):

-    """Test the 'append' action"""

-

-    argument_signatures = [

-        Sig('spam', action='append'),

-        Sig('spam', action='append', nargs=2),

-    ]

-    failures = ['', '--foo', 'a', 'a b', 'a b c d']

-    successes = [

-        ('a b c', NS(spam=['a', ['b', 'c']])),

-    ]

-

-# ========================================

-# Combined optionals and positionals tests

-# ========================================

-

-class TestOptionalsNumericAndPositionals(ParserTestCase):

-    """Tests negative number args when numeric options are present"""

-

-    argument_signatures = [

-        Sig('x', nargs='?'),

-        Sig('-4', dest='y', action='store_true'),

-    ]

-    failures = ['-2', '-315']

-    successes = [

-        ('', NS(x=None, y=False)),

-        ('a', NS(x='a', y=False)),

-        ('-4', NS(x=None, y=True)),

-        ('-4 a', NS(x='a', y=True)),

-    ]

-

-

-class TestOptionalsAlmostNumericAndPositionals(ParserTestCase):

-    """Tests negative number args when almost numeric options are present"""

-

-    argument_signatures = [

-        Sig('x', nargs='?'),

-        Sig('-k4', dest='y', action='store_true'),

-    ]

-    failures = ['-k3']

-    successes = [

-        ('', NS(x=None, y=False)),

-        ('-2', NS(x='-2', y=False)),

-        ('a', NS(x='a', y=False)),

-        ('-k4', NS(x=None, y=True)),

-        ('-k4 a', NS(x='a', y=True)),

-    ]

-

-

-class TestEmptyAndSpaceContainingArguments(ParserTestCase):

-

-    argument_signatures = [

-        Sig('x', nargs='?'),

-        Sig('-y', '--yyy', dest='y'),

-    ]

-    failures = ['-y']

-    successes = [

-        ([''], NS(x='', y=None)),

-        (['a badger'], NS(x='a badger', y=None)),

-        (['-a badger'], NS(x='-a badger', y=None)),

-        (['-y', ''], NS(x=None, y='')),

-        (['-y', 'a badger'], NS(x=None, y='a badger')),

-        (['-y', '-a badger'], NS(x=None, y='-a badger')),

-        (['--yyy=a badger'], NS(x=None, y='a badger')),

-        (['--yyy=-a badger'], NS(x=None, y='-a badger')),

-    ]

-

-

-class TestPrefixCharacterOnlyArguments(ParserTestCase):

-

-    parser_signature = Sig(prefix_chars='-+')

-    argument_signatures = [

-        Sig('-', dest='x', nargs='?', const='badger'),

-        Sig('+', dest='y', type=int, default=42),

-        Sig('-+-', dest='z', action='store_true'),

-    ]

-    failures = ['-y', '+ -']

-    successes = [

-        ('', NS(x=None, y=42, z=False)),

-        ('-', NS(x='badger', y=42, z=False)),

-        ('- X', NS(x='X', y=42, z=False)),

-        ('+ -3', NS(x=None, y=-3, z=False)),

-        ('-+-', NS(x=None, y=42, z=True)),

-        ('- ===', NS(x='===', y=42, z=False)),

-    ]

-

-

-class TestNargsZeroOrMore(ParserTestCase):

-    """Tests specifying an args for an Optional that accepts zero or more"""

-

-    argument_signatures = [Sig('-x', nargs='*'), Sig('y', nargs='*')]

-    failures = []

-    successes = [

-        ('', NS(x=None, y=[])),

-        ('-x', NS(x=[], y=[])),

-        ('-x a', NS(x=['a'], y=[])),

-        ('-x a -- b', NS(x=['a'], y=['b'])),

-        ('a', NS(x=None, y=['a'])),

-        ('a -x', NS(x=[], y=['a'])),

-        ('a -x b', NS(x=['b'], y=['a'])),

-    ]

-

-

-class TestNargsRemainder(ParserTestCase):

-    """Tests specifying a positional with nargs=REMAINDER"""

-

-    argument_signatures = [Sig('x'), Sig('y', nargs='...'), Sig('-z')]

-    failures = ['', '-z', '-z Z']

-    successes = [

-        ('X', NS(x='X', y=[], z=None)),

-        ('-z Z X', NS(x='X', y=[], z='Z')),

-        ('X A B -z Z', NS(x='X', y=['A', 'B', '-z', 'Z'], z=None)),

-        ('X Y --foo', NS(x='X', y=['Y', '--foo'], z=None)),

-    ]

-

-

-class TestOptionLike(ParserTestCase):

-    """Tests options that may or may not be arguments"""

-

-    argument_signatures = [

-        Sig('-x', type=float),

-        Sig('-3', type=float, dest='y'),

-        Sig('z', nargs='*'),

-    ]

-    failures = ['-x', '-y2.5', '-xa', '-x -a',

-                '-x -3', '-x -3.5', '-3 -3.5',

-                '-x -2.5', '-x -2.5 a', '-3 -.5',

-                'a x -1', '-x -1 a', '-3 -1 a']

-    successes = [

-        ('', NS(x=None, y=None, z=[])),

-        ('-x 2.5', NS(x=2.5, y=None, z=[])),

-        ('-x 2.5 a', NS(x=2.5, y=None, z=['a'])),

-        ('-3.5', NS(x=None, y=0.5, z=[])),

-        ('-3-.5', NS(x=None, y=-0.5, z=[])),

-        ('-3 .5', NS(x=None, y=0.5, z=[])),

-        ('a -3.5', NS(x=None, y=0.5, z=['a'])),

-        ('a', NS(x=None, y=None, z=['a'])),

-        ('a -x 1', NS(x=1.0, y=None, z=['a'])),

-        ('-x 1 a', NS(x=1.0, y=None, z=['a'])),

-        ('-3 1 a', NS(x=None, y=1.0, z=['a'])),

-    ]

-

-

-class TestDefaultSuppress(ParserTestCase):

-    """Test actions with suppressed defaults"""

-

-    argument_signatures = [

-        Sig('foo', nargs='?', default=argparse.SUPPRESS),

-        Sig('bar', nargs='*', default=argparse.SUPPRESS),

-        Sig('--baz', action='store_true', default=argparse.SUPPRESS),

-    ]

-    failures = ['-x']

-    successes = [

-        ('', NS()),

-        ('a', NS(foo='a')),

-        ('a b', NS(foo='a', bar=['b'])),

-        ('--baz', NS(baz=True)),

-        ('a --baz', NS(foo='a', baz=True)),

-        ('--baz a b', NS(foo='a', bar=['b'], baz=True)),

-    ]

-

-

-class TestParserDefaultSuppress(ParserTestCase):

-    """Test actions with a parser-level default of SUPPRESS"""

-

-    parser_signature = Sig(argument_default=argparse.SUPPRESS)

-    argument_signatures = [

-        Sig('foo', nargs='?'),

-        Sig('bar', nargs='*'),

-        Sig('--baz', action='store_true'),

-    ]

-    failures = ['-x']

-    successes = [

-        ('', NS()),

-        ('a', NS(foo='a')),

-        ('a b', NS(foo='a', bar=['b'])),

-        ('--baz', NS(baz=True)),

-        ('a --baz', NS(foo='a', baz=True)),

-        ('--baz a b', NS(foo='a', bar=['b'], baz=True)),

-    ]

-

-

-class TestParserDefault42(ParserTestCase):

-    """Test actions with a parser-level default of 42"""

-

-    parser_signature = Sig(argument_default=42, version='1.0')

-    argument_signatures = [

-        Sig('foo', nargs='?'),

-        Sig('bar', nargs='*'),

-        Sig('--baz', action='store_true'),

-    ]

-    failures = ['-x']

-    successes = [

-        ('', NS(foo=42, bar=42, baz=42)),

-        ('a', NS(foo='a', bar=42, baz=42)),

-        ('a b', NS(foo='a', bar=['b'], baz=42)),

-        ('--baz', NS(foo=42, bar=42, baz=True)),

-        ('a --baz', NS(foo='a', bar=42, baz=True)),

-        ('--baz a b', NS(foo='a', bar=['b'], baz=True)),

-    ]

-

-

-class TestArgumentsFromFile(TempDirMixin, ParserTestCase):

-    """Test reading arguments from a file"""

-

-    def setUp(self):

-        super(TestArgumentsFromFile, self).setUp()

-        file_texts = [

-            ('hello', 'hello world!\n'),

-            ('recursive', '-a\n'

-                          'A\n'

-                          '@hello'),

-            ('invalid', '@no-such-path\n'),

-        ]

-        for path, text in file_texts:

-            file = open(path, 'w')

-            file.write(text)

-            file.close()

-

-    parser_signature = Sig(fromfile_prefix_chars='@')

-    argument_signatures = [

-        Sig('-a'),

-        Sig('x'),

-        Sig('y', nargs='+'),

-    ]

-    failures = ['', '-b', 'X', '@invalid', '@missing']

-    successes = [

-        ('X Y', NS(a=None, x='X', y=['Y'])),

-        ('X -a A Y Z', NS(a='A', x='X', y=['Y', 'Z'])),

-        ('@hello X', NS(a=None, x='hello world!', y=['X'])),

-        ('X @hello', NS(a=None, x='X', y=['hello world!'])),

-        ('-a B @recursive Y Z', NS(a='A', x='hello world!', y=['Y', 'Z'])),

-        ('X @recursive Z -a B', NS(a='B', x='X', y=['hello world!', 'Z'])),

-    ]

-

-

-class TestArgumentsFromFileConverter(TempDirMixin, ParserTestCase):

-    """Test reading arguments from a file"""

-

-    def setUp(self):

-        super(TestArgumentsFromFileConverter, self).setUp()

-        file_texts = [

-            ('hello', 'hello world!\n'),

-        ]

-        for path, text in file_texts:

-            file = open(path, 'w')

-            file.write(text)

-            file.close()

-

-    class FromFileConverterArgumentParser(ErrorRaisingArgumentParser):

-

-        def convert_arg_line_to_args(self, arg_line):

-            for arg in arg_line.split():

-                if not arg.strip():

-                    continue

-                yield arg

-    parser_class = FromFileConverterArgumentParser

-    parser_signature = Sig(fromfile_prefix_chars='@')

-    argument_signatures = [

-        Sig('y', nargs='+'),

-    ]

-    failures = []

-    successes = [

-        ('@hello X', NS(y=['hello', 'world!', 'X'])),

-    ]

-

-

-# =====================

-# Type conversion tests

-# =====================

-

-class TestFileTypeRepr(TestCase):

-

-    def test_r(self):

-        type = argparse.FileType('r')

-        self.assertEqual("FileType('r')", repr(type))

-

-    def test_wb_1(self):

-        type = argparse.FileType('wb', 1)

-        self.assertEqual("FileType('wb', 1)", repr(type))

-

-

-class RFile(object):

-    seen = {}

-

-    def __init__(self, name):

-        self.name = name

-

-    def __eq__(self, other):

-        if other in self.seen:

-            text = self.seen[other]

-        else:

-            text = self.seen[other] = other.read()

-            other.close()

-        if not isinstance(text, str):

-            text = text.decode('ascii')

-        return self.name == other.name == text

-

-

-class TestFileTypeR(TempDirMixin, ParserTestCase):

-    """Test the FileType option/argument type for reading files"""

-

-    def setUp(self):

-        super(TestFileTypeR, self).setUp()

-        for file_name in ['foo', 'bar']:

-            file = open(os.path.join(self.temp_dir, file_name), 'w')

-            file.write(file_name)

-            file.close()

-

-    argument_signatures = [

-        Sig('-x', type=argparse.FileType()),

-        Sig('spam', type=argparse.FileType('r')),

-    ]

-    failures = ['-x', '-x bar']

-    successes = [

-        ('foo', NS(x=None, spam=RFile('foo'))),

-        ('-x foo bar', NS(x=RFile('foo'), spam=RFile('bar'))),

-        ('bar -x foo', NS(x=RFile('foo'), spam=RFile('bar'))),

-        ('-x - -', NS(x=sys.stdin, spam=sys.stdin)),

-    ]

-

-

-class TestFileTypeRB(TempDirMixin, ParserTestCase):

-    """Test the FileType option/argument type for reading files"""

-

-    def setUp(self):

-        super(TestFileTypeRB, self).setUp()

-        for file_name in ['foo', 'bar']:

-            file = open(os.path.join(self.temp_dir, file_name), 'w')

-            file.write(file_name)

-            file.close()

-

-    argument_signatures = [

-        Sig('-x', type=argparse.FileType('rb')),

-        Sig('spam', type=argparse.FileType('rb')),

-    ]

-    failures = ['-x', '-x bar']

-    successes = [

-        ('foo', NS(x=None, spam=RFile('foo'))),

-        ('-x foo bar', NS(x=RFile('foo'), spam=RFile('bar'))),

-        ('bar -x foo', NS(x=RFile('foo'), spam=RFile('bar'))),

-        ('-x - -', NS(x=sys.stdin, spam=sys.stdin)),

-    ]

-

-

-class WFile(object):

-    seen = set()

-

-    def __init__(self, name):

-        self.name = name

-

-    def __eq__(self, other):

-        if other not in self.seen:

-            text = 'Check that file is writable.'

-            if 'b' in other.mode:

-                text = text.encode('ascii')

-            other.write(text)

-            other.close()

-            self.seen.add(other)

-        return self.name == other.name

-

-

-class TestFileTypeW(TempDirMixin, ParserTestCase):

-    """Test the FileType option/argument type for writing files"""

-

-    argument_signatures = [

-        Sig('-x', type=argparse.FileType('w')),

-        Sig('spam', type=argparse.FileType('w')),

-    ]

-    failures = ['-x', '-x bar']

-    successes = [

-        ('foo', NS(x=None, spam=WFile('foo'))),

-        ('-x foo bar', NS(x=WFile('foo'), spam=WFile('bar'))),

-        ('bar -x foo', NS(x=WFile('foo'), spam=WFile('bar'))),

-        ('-x - -', NS(x=sys.stdout, spam=sys.stdout)),

-    ]

-

-

-class TestFileTypeWB(TempDirMixin, ParserTestCase):

-

-    argument_signatures = [

-        Sig('-x', type=argparse.FileType('wb')),

-        Sig('spam', type=argparse.FileType('wb')),

-    ]

-    failures = ['-x', '-x bar']

-    successes = [

-        ('foo', NS(x=None, spam=WFile('foo'))),

-        ('-x foo bar', NS(x=WFile('foo'), spam=WFile('bar'))),

-        ('bar -x foo', NS(x=WFile('foo'), spam=WFile('bar'))),

-        ('-x - -', NS(x=sys.stdout, spam=sys.stdout)),

-    ]

-

-

-class TestTypeCallable(ParserTestCase):

-    """Test some callables as option/argument types"""

-

-    argument_signatures = [

-        Sig('--eggs', type=complex),

-        Sig('spam', type=float),

-    ]

-    failures = ['a', '42j', '--eggs a', '--eggs 2i']

-    successes = [

-        ('--eggs=42 42', NS(eggs=42, spam=42.0)),

-        ('--eggs 2j -- -1.5', NS(eggs=2j, spam=-1.5)),

-        ('1024.675', NS(eggs=None, spam=1024.675)),

-    ]

-

-

-class TestTypeUserDefined(ParserTestCase):

-    """Test a user-defined option/argument type"""

-

-    class MyType(TestCase):

-

-        def __init__(self, value):

-            self.value = value

-

-        def __eq__(self, other):

-            return (type(self), self.value) == (type(other), other.value)

-

-    argument_signatures = [

-        Sig('-x', type=MyType),

-        Sig('spam', type=MyType),

-    ]

-    failures = []

-    successes = [

-        ('a -x b', NS(x=MyType('b'), spam=MyType('a'))),

-        ('-xf g', NS(x=MyType('f'), spam=MyType('g'))),

-    ]

-

-

-class TestTypeClassicClass(ParserTestCase):

-    """Test a classic class type"""

-

-    class C:

-

-        def __init__(self, value):

-            self.value = value

-

-        def __eq__(self, other):

-            return (type(self), self.value) == (type(other), other.value)

-

-    argument_signatures = [

-        Sig('-x', type=C),

-        Sig('spam', type=C),

-    ]

-    failures = []

-    successes = [

-        ('a -x b', NS(x=C('b'), spam=C('a'))),

-        ('-xf g', NS(x=C('f'), spam=C('g'))),

-    ]

-

-

-class TestTypeRegistration(TestCase):

-    """Test a user-defined type by registering it"""

-

-    def test(self):

-

-        def get_my_type(string):

-            return 'my_type{%s}' % string

-

-        parser = argparse.ArgumentParser()

-        parser.register('type', 'my_type', get_my_type)

-        parser.add_argument('-x', type='my_type')

-        parser.add_argument('y', type='my_type')

-

-        self.assertEqual(parser.parse_args('1'.split()),

-                         NS(x=None, y='my_type{1}'))

-        self.assertEqual(parser.parse_args('-x 1 42'.split()),

-                         NS(x='my_type{1}', y='my_type{42}'))

-

-

-# ============

-# Action tests

-# ============

-

-class TestActionUserDefined(ParserTestCase):

-    """Test a user-defined option/argument action"""

-

-    class OptionalAction(argparse.Action):

-

-        def __call__(self, parser, namespace, value, option_string=None):

-            try:

-                # check destination and option string

-                assert self.dest == 'spam', 'dest: %s' % self.dest

-                assert option_string == '-s', 'flag: %s' % option_string

-                # when option is before argument, badger=2, and when

-                # option is after argument, badger=<whatever was set>

-                expected_ns = NS(spam=0.25)

-                if value in [0.125, 0.625]:

-                    expected_ns.badger = 2

-                elif value in [2.0]:

-                    expected_ns.badger = 84

-                else:

-                    raise AssertionError('value: %s' % value)

-                assert expected_ns == namespace, ('expected %s, got %s' %

-                                                  (expected_ns, namespace))

-            except AssertionError:

-                e = sys.exc_info()[1]

-                raise ArgumentParserError('opt_action failed: %s' % e)

-            setattr(namespace, 'spam', value)

-

-    class PositionalAction(argparse.Action):

-

-        def __call__(self, parser, namespace, value, option_string=None):

-            try:

-                assert option_string is None, ('option_string: %s' %

-                                               option_string)

-                # check destination

-                assert self.dest == 'badger', 'dest: %s' % self.dest

-                # when argument is before option, spam=0.25, and when

-                # option is after argument, spam=<whatever was set>

-                expected_ns = NS(badger=2)

-                if value in [42, 84]:

-                    expected_ns.spam = 0.25

-                elif value in [1]:

-                    expected_ns.spam = 0.625

-                elif value in [2]:

-                    expected_ns.spam = 0.125

-                else:

-                    raise AssertionError('value: %s' % value)

-                assert expected_ns == namespace, ('expected %s, got %s' %

-                                                  (expected_ns, namespace))

-            except AssertionError:

-                e = sys.exc_info()[1]

-                raise ArgumentParserError('arg_action failed: %s' % e)

-            setattr(namespace, 'badger', value)

-

-    argument_signatures = [

-        Sig('-s', dest='spam', action=OptionalAction,

-            type=float, default=0.25),

-        Sig('badger', action=PositionalAction,

-            type=int, nargs='?', default=2),

-    ]

-    failures = []

-    successes = [

-        ('-s0.125', NS(spam=0.125, badger=2)),

-        ('42', NS(spam=0.25, badger=42)),

-        ('-s 0.625 1', NS(spam=0.625, badger=1)),

-        ('84 -s2', NS(spam=2.0, badger=84)),

-    ]

-

-

-class TestActionRegistration(TestCase):

-    """Test a user-defined action supplied by registering it"""

-

-    class MyAction(argparse.Action):

-

-        def __call__(self, parser, namespace, values, option_string=None):

-            setattr(namespace, self.dest, 'foo[%s]' % values)

-

-    def test(self):

-

-        parser = argparse.ArgumentParser()

-        parser.register('action', 'my_action', self.MyAction)

-        parser.add_argument('badger', action='my_action')

-

-        self.assertEqual(parser.parse_args(['1']), NS(badger='foo[1]'))

-        self.assertEqual(parser.parse_args(['42']), NS(badger='foo[42]'))

-

-

-# ================

-# Subparsers tests

-# ================

-

-class TestAddSubparsers(TestCase):

-    """Test the add_subparsers method"""

-

-    def assertArgumentParserError(self, *args, **kwargs):

-        self.assertRaises(ArgumentParserError, *args, **kwargs)

-

-    def _get_parser(self, subparser_help=False):

-        # create a parser with a subparsers argument

-        parser = ErrorRaisingArgumentParser(

-            prog='PROG', description='main description')

-        parser.add_argument(

-            '--foo', action='store_true', help='foo help')

-        parser.add_argument(

-            'bar', type=float, help='bar help')

-

-        # check that only one subparsers argument can be added

-        subparsers = parser.add_subparsers(help='command help')

-        self.assertArgumentParserError(parser.add_subparsers)

-

-        # add first sub-parser

-        parser1_kwargs = dict(description='1 description')

-        if subparser_help:

-            parser1_kwargs['help'] = '1 help'

-        parser1 = subparsers.add_parser('1', **parser1_kwargs)

-        parser1.add_argument('-w', type=int, help='w help')

-        parser1.add_argument('x', choices='abc', help='x help')

-

-        # add second sub-parser

-        parser2_kwargs = dict(description='2 description')

-        if subparser_help:

-            parser2_kwargs['help'] = '2 help'

-        parser2 = subparsers.add_parser('2', **parser2_kwargs)

-        parser2.add_argument('-y', choices='123', help='y help')

-        parser2.add_argument('z', type=complex, nargs='*', help='z help')

-

-        # return the main parser

-        return parser

-

-    def setUp(self):

-        self.parser = self._get_parser()

-        self.command_help_parser = self._get_parser(subparser_help=True)

-

-    def test_parse_args_failures(self):

-        # check some failure cases:

-        for args_str in ['', 'a', 'a a', '0.5 a', '0.5 1',

-                         '0.5 1 -y', '0.5 2 -w']:

-            args = args_str.split()

-            self.assertArgumentParserError(self.parser.parse_args, args)

-

-    def test_parse_args(self):

-        # check some non-failure cases:

-        self.assertEqual(

-            self.parser.parse_args('0.5 1 b -w 7'.split()),

-            NS(foo=False, bar=0.5, w=7, x='b'),

-        )

-        self.assertEqual(

-            self.parser.parse_args('0.25 --foo 2 -y 2 3j -- -1j'.split()),

-            NS(foo=True, bar=0.25, y='2', z=[3j, -1j]),

-        )

-        self.assertEqual(

-            self.parser.parse_args('--foo 0.125 1 c'.split()),

-            NS(foo=True, bar=0.125, w=None, x='c'),

-        )

-

-    def test_dest(self):

-        parser = ErrorRaisingArgumentParser()

-        parser.add_argument('--foo', action='store_true')

-        subparsers = parser.add_subparsers(dest='bar')

-        parser1 = subparsers.add_parser('1')

-        parser1.add_argument('baz')

-        self.assertEqual(NS(foo=False, bar='1', baz='2'),

-                         parser.parse_args('1 2'.split()))

-

-    def test_help(self):

-        self.assertEqual(self.parser.format_usage(),

-                         'usage: PROG [-h] [--foo] bar {1,2} ...\n')

-        self.assertEqual(self.parser.format_help(), textwrap.dedent('''\

-            usage: PROG [-h] [--foo] bar {1,2} ...

-

-            main description

-

-            positional arguments:

-              bar         bar help

-              {1,2}       command help

-

-            optional arguments:

-              -h, --help  show this help message and exit

-              --foo       foo help

-            '''))

-

-    def test_parser_command_help(self):

-        self.assertEqual(self.command_help_parser.format_usage(),

-                         'usage: PROG [-h] [--foo] bar {1,2} ...\n')

-        self.assertEqual(self.command_help_parser.format_help(),

-                         textwrap.dedent('''\

-            usage: PROG [-h] [--foo] bar {1,2} ...

-

-            main description

-

-            positional arguments:

-              bar         bar help

-              {1,2}       command help

-                1         1 help

-                2         2 help

-

-            optional arguments:

-              -h, --help  show this help message and exit

-              --foo       foo help

-            '''))

-

-    def test_subparser_title_help(self):

-        parser = ErrorRaisingArgumentParser(prog='PROG',

-                                            description='main description')

-        parser.add_argument('--foo', action='store_true', help='foo help')

-        parser.add_argument('bar', help='bar help')

-        subparsers = parser.add_subparsers(title='subcommands',

-                                           description='command help',

-                                           help='additional text')

-        parser1 = subparsers.add_parser('1')

-        parser2 = subparsers.add_parser('2')

-        self.assertEqual(parser.format_usage(),

-                         'usage: PROG [-h] [--foo] bar {1,2} ...\n')

-        self.assertEqual(parser.format_help(), textwrap.dedent('''\

-            usage: PROG [-h] [--foo] bar {1,2} ...

-

-            main description

-

-            positional arguments:

-              bar         bar help

-

-            optional arguments:

-              -h, --help  show this help message and exit

-              --foo       foo help

-

-            subcommands:

-              command help

-

-              {1,2}       additional text

-            '''))

-

-    def _test_subparser_help(self, args_str, expected_help):

-        try:

-            self.parser.parse_args(args_str.split())

-        except ArgumentParserError:

-            err = sys.exc_info()[1]

-            if err.stdout != expected_help:

-                print(repr(expected_help))

-                print(repr(err.stdout))

-            self.assertEqual(err.stdout, expected_help)

-

-    def test_subparser1_help(self):

-        self._test_subparser_help('5.0 1 -h', textwrap.dedent('''\

-            usage: PROG bar 1 [-h] [-w W] {a,b,c}

-

-            1 description

-

-            positional arguments:

-              {a,b,c}     x help

-

-            optional arguments:

-              -h, --help  show this help message and exit

-              -w W        w help

-            '''))

-

-    def test_subparser2_help(self):

-        self._test_subparser_help('5.0 2 -h', textwrap.dedent('''\

-            usage: PROG bar 2 [-h] [-y {1,2,3}] [z [z ...]]

-

-            2 description

-

-            positional arguments:

-              z           z help

-

-            optional arguments:

-              -h, --help  show this help message and exit

-              -y {1,2,3}  y help

-            '''))

-

-# ============

-# Groups tests

-# ============

-

-class TestPositionalsGroups(TestCase):

-    """Tests that order of group positionals matches construction order"""

-

-    def test_nongroup_first(self):

-        parser = ErrorRaisingArgumentParser()

-        parser.add_argument('foo')

-        group = parser.add_argument_group('g')

-        group.add_argument('bar')

-        parser.add_argument('baz')

-        expected = NS(foo='1', bar='2', baz='3')

-        result = parser.parse_args('1 2 3'.split())

-        self.failUnlessEqual(expected, result)

-

-    def test_group_first(self):

-        parser = ErrorRaisingArgumentParser()

-        group = parser.add_argument_group('xxx')

-        group.add_argument('foo')

-        parser.add_argument('bar')

-        parser.add_argument('baz')

-        expected = NS(foo='1', bar='2', baz='3')

-        result = parser.parse_args('1 2 3'.split())

-        self.failUnlessEqual(expected, result)

-

-    def test_interleaved_groups(self):

-        parser = ErrorRaisingArgumentParser()

-        group = parser.add_argument_group('xxx')

-        parser.add_argument('foo')

-        group.add_argument('bar')

-        parser.add_argument('baz')

-        group = parser.add_argument_group('yyy')

-        group.add_argument('frell')

-        expected = NS(foo='1', bar='2', baz='3', frell='4')

-        result = parser.parse_args('1 2 3 4'.split())

-        self.failUnlessEqual(expected, result)

-

-# ===================

-# Parent parser tests

-# ===================

-

-class TestParentParsers(TestCase):

-    """Tests that parsers can be created with parent parsers"""

-

-    def assertArgumentParserError(self, *args, **kwargs):

-        self.assertRaises(ArgumentParserError, *args, **kwargs)

-

-    def setUp(self):

-        self.wxyz_parent = ErrorRaisingArgumentParser(add_help=False)

-        self.wxyz_parent.add_argument('--w')

-        x_group = self.wxyz_parent.add_argument_group('x')

-        x_group.add_argument('-y')

-        self.wxyz_parent.add_argument('z')

-

-        self.abcd_parent = ErrorRaisingArgumentParser(add_help=False)

-        self.abcd_parent.add_argument('a')

-        self.abcd_parent.add_argument('-b')

-        c_group = self.abcd_parent.add_argument_group('c')

-        c_group.add_argument('--d')

-

-        self.w_parent = ErrorRaisingArgumentParser(add_help=False)

-        self.w_parent.add_argument('--w')

-

-        self.z_parent = ErrorRaisingArgumentParser(add_help=False)

-        self.z_parent.add_argument('z')

-

-        # parents with mutually exclusive groups

-        self.ab_mutex_parent = ErrorRaisingArgumentParser(add_help=False)

-        group = self.ab_mutex_parent.add_mutually_exclusive_group()

-        group.add_argument('-a', action='store_true')

-        group.add_argument('-b', action='store_true')

-

-    def test_single_parent(self):

-        parser = ErrorRaisingArgumentParser(parents=[self.wxyz_parent])

-        self.assertEqual(parser.parse_args('-y 1 2 --w 3'.split()),

-                         NS(w='3', y='1', z='2'))

-

-    def test_single_parent_mutex(self):

-        self._test_mutex_ab(self.ab_mutex_parent.parse_args)

-        parser = ErrorRaisingArgumentParser(parents=[self.ab_mutex_parent])

-        self._test_mutex_ab(parser.parse_args)

-

-    def test_single_granparent_mutex(self):

-        parents = [self.ab_mutex_parent]

-        parser = ErrorRaisingArgumentParser(add_help=False, parents=parents)

-        parser = ErrorRaisingArgumentParser(parents=[parser])

-        self._test_mutex_ab(parser.parse_args)

-

-    def _test_mutex_ab(self, parse_args):

-        self.assertEqual(parse_args([]), NS(a=False, b=False))

-        self.assertEqual(parse_args(['-a']), NS(a=True, b=False))

-        self.assertEqual(parse_args(['-b']), NS(a=False, b=True))

-        self.assertArgumentParserError(parse_args, ['-a', '-b'])

-        self.assertArgumentParserError(parse_args, ['-b', '-a'])

-        self.assertArgumentParserError(parse_args, ['-c'])

-        self.assertArgumentParserError(parse_args, ['-a', '-c'])

-        self.assertArgumentParserError(parse_args, ['-b', '-c'])

-

-    def test_multiple_parents(self):

-        parents = [self.abcd_parent, self.wxyz_parent]

-        parser = ErrorRaisingArgumentParser(parents=parents)

-        self.assertEqual(parser.parse_args('--d 1 --w 2 3 4'.split()),

-                         NS(a='3', b=None, d='1', w='2', y=None, z='4'))

-

-    def test_multiple_parents_mutex(self):

-        parents = [self.ab_mutex_parent, self.wxyz_parent]

-        parser = ErrorRaisingArgumentParser(parents=parents)

-        self.assertEqual(parser.parse_args('-a --w 2 3'.split()),

-                         NS(a=True, b=False, w='2', y=None, z='3'))

-        self.assertArgumentParserError(

-            parser.parse_args, '-a --w 2 3 -b'.split())

-        self.assertArgumentParserError(

-            parser.parse_args, '-a -b --w 2 3'.split())

-

-    def test_conflicting_parents(self):

-        self.assertRaises(

-            argparse.ArgumentError,

-            argparse.ArgumentParser,

-            parents=[self.w_parent, self.wxyz_parent])

-

-    def test_conflicting_parents_mutex(self):

-        self.assertRaises(

-            argparse.ArgumentError,

-            argparse.ArgumentParser,

-            parents=[self.abcd_parent, self.ab_mutex_parent])

-

-    def test_same_argument_name_parents(self):

-        parents = [self.wxyz_parent, self.z_parent]

-        parser = ErrorRaisingArgumentParser(parents=parents)

-        self.assertEqual(parser.parse_args('1 2'.split()),

-                         NS(w=None, y=None, z='2'))

-

-    def test_subparser_parents(self):

-        parser = ErrorRaisingArgumentParser()

-        subparsers = parser.add_subparsers()

-        abcde_parser = subparsers.add_parser('bar', parents=[self.abcd_parent])

-        abcde_parser.add_argument('e')

-        self.assertEqual(parser.parse_args('bar -b 1 --d 2 3 4'.split()),

-                         NS(a='3', b='1', d='2', e='4'))

-

-    def test_subparser_parents_mutex(self):

-        parser = ErrorRaisingArgumentParser()

-        subparsers = parser.add_subparsers()

-        parents = [self.ab_mutex_parent]

-        abc_parser = subparsers.add_parser('foo', parents=parents)

-        c_group = abc_parser.add_argument_group('c_group')

-        c_group.add_argument('c')

-        parents = [self.wxyz_parent, self.ab_mutex_parent]

-        wxyzabe_parser = subparsers.add_parser('bar', parents=parents)

-        wxyzabe_parser.add_argument('e')

-        self.assertEqual(parser.parse_args('foo -a 4'.split()),

-                         NS(a=True, b=False, c='4'))

-        self.assertEqual(parser.parse_args('bar -b  --w 2 3 4'.split()),

-                         NS(a=False, b=True, w='2', y=None, z='3', e='4'))

-        self.assertArgumentParserError(

-            parser.parse_args, 'foo -a -b 4'.split())

-        self.assertArgumentParserError(

-            parser.parse_args, 'bar -b -a 4'.split())

-

-    def test_parent_help(self):

-        parents = [self.abcd_parent, self.wxyz_parent]

-        parser = ErrorRaisingArgumentParser(parents=parents)

-        parser_help = parser.format_help()

-        self.assertEqual(parser_help, textwrap.dedent('''\

-            usage: test_argparse.py [-h] [-b B] [--d D] [--w W] [-y Y] a z

-

-            positional arguments:

-              a

-              z

-

-            optional arguments:

-              -h, --help  show this help message and exit

-              -b B

-              --w W

-

-            c:

-              --d D

-

-            x:

-              -y Y

-        '''))

-

-    def test_groups_parents(self):

-        parent = ErrorRaisingArgumentParser(add_help=False)

-        g = parent.add_argument_group(title='g', description='gd')

-        g.add_argument('-w')

-        g.add_argument('-x')

-        m = parent.add_mutually_exclusive_group()

-        m.add_argument('-y')

-        m.add_argument('-z')

-        parser = ErrorRaisingArgumentParser(parents=[parent])

-

-        self.assertRaises(ArgumentParserError, parser.parse_args,

-            ['-y', 'Y', '-z', 'Z'])

-

-        parser_help = parser.format_help()

-        self.assertEqual(parser_help, textwrap.dedent('''\

-            usage: test_argparse.py [-h] [-w W] [-x X] [-y Y | -z Z]

-

-            optional arguments:

-              -h, --help  show this help message and exit

-              -y Y

-              -z Z

-

-            g:

-              gd

-

-              -w W

-              -x X

-        '''))

-

-# ==============================

-# Mutually exclusive group tests

-# ==============================

-

-class TestMutuallyExclusiveGroupErrors(TestCase):

-

-    def test_invalid_add_argument_group(self):

-        parser = ErrorRaisingArgumentParser()

-        raises = self.assertRaises

-        raises(TypeError, parser.add_mutually_exclusive_group, title='foo')

-

-    def test_invalid_add_argument(self):

-        parser = ErrorRaisingArgumentParser()

-        group = parser.add_mutually_exclusive_group()

-        add_argument = group.add_argument

-        raises = self.assertRaises

-        raises(ValueError, add_argument, '--foo', required=True)

-        raises(ValueError, add_argument, 'bar')

-        raises(ValueError, add_argument, 'bar', nargs='+')

-        raises(ValueError, add_argument, 'bar', nargs=1)

-        raises(ValueError, add_argument, 'bar', nargs=argparse.PARSER)

-

-

-class MEMixin(object):

-

-    def test_failures_when_not_required(self):

-        parse_args = self.get_parser(required=False).parse_args

-        error = ArgumentParserError

-        for args_string in self.failures:

-            self.assertRaises(error, parse_args, args_string.split())

-

-    def test_failures_when_required(self):

-        parse_args = self.get_parser(required=True).parse_args

-        error = ArgumentParserError

-        for args_string in self.failures + ['']:

-            self.assertRaises(error, parse_args, args_string.split())

-

-    def test_successes_when_not_required(self):

-        parse_args = self.get_parser(required=False).parse_args

-        successes = self.successes + self.successes_when_not_required

-        for args_string, expected_ns in successes:

-            actual_ns = parse_args(args_string.split())

-            self.assertEqual(actual_ns, expected_ns)

-

-    def test_successes_when_required(self):

-        parse_args = self.get_parser(required=True).parse_args

-        for args_string, expected_ns in self.successes:

-            actual_ns = parse_args(args_string.split())

-            self.assertEqual(actual_ns, expected_ns)

-

-    def test_usage_when_not_required(self):

-        format_usage = self.get_parser(required=False).format_usage

-        expected_usage = self.usage_when_not_required

-        self.assertEqual(format_usage(), textwrap.dedent(expected_usage))

-

-    def test_usage_when_required(self):

-        format_usage = self.get_parser(required=True).format_usage

-        expected_usage = self.usage_when_required

-        self.assertEqual(format_usage(), textwrap.dedent(expected_usage))

-

-    def test_help_when_not_required(self):

-        format_help = self.get_parser(required=False).format_help

-        help = self.usage_when_not_required + self.help

-        self.assertEqual(format_help(), textwrap.dedent(help))

-

-    def test_help_when_required(self):

-        format_help = self.get_parser(required=True).format_help

-        help = self.usage_when_required + self.help

-        self.assertEqual(format_help(), textwrap.dedent(help))

-

-

-class TestMutuallyExclusiveSimple(MEMixin, TestCase):

-

-    def get_parser(self, required=None):

-        parser = ErrorRaisingArgumentParser(prog='PROG')

-        group = parser.add_mutually_exclusive_group(required=required)

-        group.add_argument('--bar', help='bar help')

-        group.add_argument('--baz', nargs='?', const='Z', help='baz help')

-        return parser

-

-    failures = ['--bar X --baz Y', '--bar X --baz']

-    successes = [

-        ('--bar X', NS(bar='X', baz=None)),

-        ('--bar X --bar Z', NS(bar='Z', baz=None)),

-        ('--baz Y', NS(bar=None, baz='Y')),

-        ('--baz', NS(bar=None, baz='Z')),

-    ]

-    successes_when_not_required = [

-        ('', NS(bar=None, baz=None)),

-    ]

-

-    usage_when_not_required = '''\

-        usage: PROG [-h] [--bar BAR | --baz [BAZ]]

-        '''

-    usage_when_required = '''\

-        usage: PROG [-h] (--bar BAR | --baz [BAZ])

-        '''

-    help = '''\

-

-        optional arguments:

-          -h, --help   show this help message and exit

-          --bar BAR    bar help

-          --baz [BAZ]  baz help

-        '''

-

-

-class TestMutuallyExclusiveLong(MEMixin, TestCase):

-

-    def get_parser(self, required=None):

-        parser = ErrorRaisingArgumentParser(prog='PROG')

-        parser.add_argument('--abcde', help='abcde help')

-        parser.add_argument('--fghij', help='fghij help')

-        group = parser.add_mutually_exclusive_group(required=required)

-        group.add_argument('--klmno', help='klmno help')

-        group.add_argument('--pqrst', help='pqrst help')

-        return parser

-

-    failures = ['--klmno X --pqrst Y']

-    successes = [

-        ('--klmno X', NS(abcde=None, fghij=None, klmno='X', pqrst=None)),

-        ('--abcde Y --klmno X',

-            NS(abcde='Y', fghij=None, klmno='X', pqrst=None)),

-        ('--pqrst X', NS(abcde=None, fghij=None, klmno=None, pqrst='X')),

-        ('--pqrst X --fghij Y',

-            NS(abcde=None, fghij='Y', klmno=None, pqrst='X')),

-    ]

-    successes_when_not_required = [

-        ('', NS(abcde=None, fghij=None, klmno=None, pqrst=None)),

-    ]

-

-    usage_when_not_required = '''\

-    usage: PROG [-h] [--abcde ABCDE] [--fghij FGHIJ]

-                [--klmno KLMNO | --pqrst PQRST]

-    '''

-    usage_when_required = '''\

-    usage: PROG [-h] [--abcde ABCDE] [--fghij FGHIJ]

-                (--klmno KLMNO | --pqrst PQRST)

-    '''

-    help = '''\

-

-    optional arguments:

-      -h, --help     show this help message and exit

-      --abcde ABCDE  abcde help

-      --fghij FGHIJ  fghij help

-      --klmno KLMNO  klmno help

-      --pqrst PQRST  pqrst help

-    '''

-

-

-class TestMutuallyExclusiveFirstSuppressed(MEMixin, TestCase):

-

-    def get_parser(self, required):

-        parser = ErrorRaisingArgumentParser(prog='PROG')

-        group = parser.add_mutually_exclusive_group(required=required)

-        group.add_argument('-x', help=argparse.SUPPRESS)

-        group.add_argument('-y', action='store_false', help='y help')

-        return parser

-

-    failures = ['-x X -y']

-    successes = [

-        ('-x X', NS(x='X', y=True)),

-        ('-x X -x Y', NS(x='Y', y=True)),

-        ('-y', NS(x=None, y=False)),

-    ]

-    successes_when_not_required = [

-        ('', NS(x=None, y=True)),

-    ]

-

-    usage_when_not_required = '''\

-        usage: PROG [-h] [-y]

-        '''

-    usage_when_required = '''\

-        usage: PROG [-h] -y

-        '''

-    help = '''\

-

-        optional arguments:

-          -h, --help  show this help message and exit

-          -y          y help

-        '''

-

-

-class TestMutuallyExclusiveManySuppressed(MEMixin, TestCase):

-

-    def get_parser(self, required):

-        parser = ErrorRaisingArgumentParser(prog='PROG')

-        group = parser.add_mutually_exclusive_group(required=required)

-        add = group.add_argument

-        add('--spam', action='store_true', help=argparse.SUPPRESS)

-        add('--badger', action='store_false', help=argparse.SUPPRESS)

-        add('--bladder', help=argparse.SUPPRESS)

-        return parser

-

-    failures = [

-        '--spam --badger',

-        '--badger --bladder B',

-        '--bladder B --spam',

-    ]

-    successes = [

-        ('--spam', NS(spam=True, badger=True, bladder=None)),

-        ('--badger', NS(spam=False, badger=False, bladder=None)),

-        ('--bladder B', NS(spam=False, badger=True, bladder='B')),

-        ('--spam --spam', NS(spam=True, badger=True, bladder=None)),

-    ]

-    successes_when_not_required = [

-        ('', NS(spam=False, badger=True, bladder=None)),

-    ]

-

-    usage_when_required = usage_when_not_required = '''\

-        usage: PROG [-h]

-        '''

-    help = '''\

-

-        optional arguments:

-          -h, --help  show this help message and exit

-        '''

-

-

-class TestMutuallyExclusiveOptionalAndPositional(MEMixin, TestCase):

-

-    def get_parser(self, required):

-        parser = ErrorRaisingArgumentParser(prog='PROG')

-        group = parser.add_mutually_exclusive_group(required=required)

-        group.add_argument('--foo', action='store_true', help='FOO')

-        group.add_argument('--spam', help='SPAM')

-        group.add_argument('badger', nargs='*', default='X', help='BADGER')

-        return parser

-

-    failures = [

-        '--foo --spam S',

-        '--spam S X',

-        'X --foo',

-        'X Y Z --spam S',

-        '--foo X Y',

-    ]

-    successes = [

-        ('--foo', NS(foo=True, spam=None, badger='X')),

-        ('--spam S', NS(foo=False, spam='S', badger='X')),

-        ('X', NS(foo=False, spam=None, badger=['X'])),

-        ('X Y Z', NS(foo=False, spam=None, badger=['X', 'Y', 'Z'])),

-    ]

-    successes_when_not_required = [

-        ('', NS(foo=False, spam=None, badger='X')),

-    ]

-

-    usage_when_not_required = '''\

-        usage: PROG [-h] [--foo | --spam SPAM | badger [badger ...]]

-        '''

-    usage_when_required = '''\

-        usage: PROG [-h] (--foo | --spam SPAM | badger [badger ...])

-        '''

-    help = '''\

-

-        positional arguments:

-          badger       BADGER

-

-        optional arguments:

-          -h, --help   show this help message and exit

-          --foo        FOO

-          --spam SPAM  SPAM

-        '''

-

-

-class TestMutuallyExclusiveOptionalsMixed(MEMixin, TestCase):

-

-    def get_parser(self, required):

-        parser = ErrorRaisingArgumentParser(prog='PROG')

-        parser.add_argument('-x', action='store_true', help='x help')

-        group = parser.add_mutually_exclusive_group(required=required)

-        group.add_argument('-a', action='store_true', help='a help')

-        group.add_argument('-b', action='store_true', help='b help')

-        parser.add_argument('-y', action='store_true', help='y help')

-        group.add_argument('-c', action='store_true', help='c help')

-        return parser

-

-    failures = ['-a -b', '-b -c', '-a -c', '-a -b -c']

-    successes = [

-        ('-a', NS(a=True, b=False, c=False, x=False, y=False)),

-        ('-b', NS(a=False, b=True, c=False, x=False, y=False)),

-        ('-c', NS(a=False, b=False, c=True, x=False, y=False)),

-        ('-a -x', NS(a=True, b=False, c=False, x=True, y=False)),

-        ('-y -b', NS(a=False, b=True, c=False, x=False, y=True)),

-        ('-x -y -c', NS(a=False, b=False, c=True, x=True, y=True)),

-    ]

-    successes_when_not_required = [

-        ('', NS(a=False, b=False, c=False, x=False, y=False)),

-        ('-x', NS(a=False, b=False, c=False, x=True, y=False)),

-        ('-y', NS(a=False, b=False, c=False, x=False, y=True)),

-    ]

-

-    usage_when_required = usage_when_not_required = '''\

-        usage: PROG [-h] [-x] [-a] [-b] [-y] [-c]

-        '''

-    help = '''\

-

-        optional arguments:

-          -h, --help  show this help message and exit

-          -x          x help

-          -a          a help

-          -b          b help

-          -y          y help

-          -c          c help

-        '''

-

-

-class TestMutuallyExclusiveOptionalsAndPositionalsMixed(MEMixin, TestCase):

-

-    def get_parser(self, required):

-        parser = ErrorRaisingArgumentParser(prog='PROG')

-        parser.add_argument('x', help='x help')

-        parser.add_argument('-y', action='store_true', help='y help')

-        group = parser.add_mutually_exclusive_group(required=required)

-        group.add_argument('a', nargs='?', help='a help')

-        group.add_argument('-b', action='store_true', help='b help')

-        group.add_argument('-c', action='store_true', help='c help')

-        return parser

-

-    failures = ['X A -b', '-b -c', '-c X A']

-    successes = [

-        ('X A', NS(a='A', b=False, c=False, x='X', y=False)),

-        ('X -b', NS(a=None, b=True, c=False, x='X', y=False)),

-        ('X -c', NS(a=None, b=False, c=True, x='X', y=False)),

-        ('X A -y', NS(a='A', b=False, c=False, x='X', y=True)),

-        ('X -y -b', NS(a=None, b=True, c=False, x='X', y=True)),

-    ]

-    successes_when_not_required = [

-        ('X', NS(a=None, b=False, c=False, x='X', y=False)),

-        ('X -y', NS(a=None, b=False, c=False, x='X', y=True)),

-    ]

-

-    usage_when_required = usage_when_not_required = '''\

-        usage: PROG [-h] [-y] [-b] [-c] x [a]

-        '''

-    help = '''\

-

-        positional arguments:

-          x           x help

-          a           a help

-

-        optional arguments:

-          -h, --help  show this help message and exit

-          -y          y help

-          -b          b help

-          -c          c help

-        '''

-

-# =================================================

-# Mutually exclusive group in parent parser tests

-# =================================================

-

-class MEPBase(object):

-

-    def get_parser(self, required=None):

-        parent = super(MEPBase, self).get_parser(required=required)

-        parser = ErrorRaisingArgumentParser(

-            prog=parent.prog, add_help=False, parents=[parent])

-        return parser

-

-

-class TestMutuallyExclusiveGroupErrorsParent(

-    MEPBase, TestMutuallyExclusiveGroupErrors):

-    pass

-

-

-class TestMutuallyExclusiveSimpleParent(

-    MEPBase, TestMutuallyExclusiveSimple):

-    pass

-

-

-class TestMutuallyExclusiveLongParent(

-    MEPBase, TestMutuallyExclusiveLong):

-    pass

-

-

-class TestMutuallyExclusiveFirstSuppressedParent(

-    MEPBase, TestMutuallyExclusiveFirstSuppressed):

-    pass

-

-

-class TestMutuallyExclusiveManySuppressedParent(

-    MEPBase, TestMutuallyExclusiveManySuppressed):

-    pass

-

-

-class TestMutuallyExclusiveOptionalAndPositionalParent(

-    MEPBase, TestMutuallyExclusiveOptionalAndPositional):

-    pass

-

-

-class TestMutuallyExclusiveOptionalsMixedParent(

-    MEPBase, TestMutuallyExclusiveOptionalsMixed):

-    pass

-

-

-class TestMutuallyExclusiveOptionalsAndPositionalsMixedParent(

-    MEPBase, TestMutuallyExclusiveOptionalsAndPositionalsMixed):

-    pass

-

-# =================

-# Set default tests

-# =================

-

-class TestSetDefaults(TestCase):

-

-    def test_set_defaults_no_args(self):

-        parser = ErrorRaisingArgumentParser()

-        parser.set_defaults(x='foo')

-        parser.set_defaults(y='bar', z=1)

-        self.assertEqual(NS(x='foo', y='bar', z=1),

-                         parser.parse_args([]))

-        self.assertEqual(NS(x='foo', y='bar', z=1),

-                         parser.parse_args([], NS()))

-        self.assertEqual(NS(x='baz', y='bar', z=1),

-                         parser.parse_args([], NS(x='baz')))

-        self.assertEqual(NS(x='baz', y='bar', z=2),

-                         parser.parse_args([], NS(x='baz', z=2)))

-

-    def test_set_defaults_with_args(self):

-        parser = ErrorRaisingArgumentParser()

-        parser.set_defaults(x='foo', y='bar')

-        parser.add_argument('-x', default='xfoox')

-        self.assertEqual(NS(x='xfoox', y='bar'),

-                         parser.parse_args([]))

-        self.assertEqual(NS(x='xfoox', y='bar'),

-                         parser.parse_args([], NS()))

-        self.assertEqual(NS(x='baz', y='bar'),

-                         parser.parse_args([], NS(x='baz')))

-        self.assertEqual(NS(x='1', y='bar'),

-                         parser.parse_args('-x 1'.split()))

-        self.assertEqual(NS(x='1', y='bar'),

-                         parser.parse_args('-x 1'.split(), NS()))

-        self.assertEqual(NS(x='1', y='bar'),

-                         parser.parse_args('-x 1'.split(), NS(x='baz')))

-

-    def test_set_defaults_subparsers(self):

-        parser = ErrorRaisingArgumentParser()

-        parser.set_defaults(x='foo')

-        subparsers = parser.add_subparsers()

-        parser_a = subparsers.add_parser('a')

-        parser_a.set_defaults(y='bar')

-        self.assertEqual(NS(x='foo', y='bar'),

-                         parser.parse_args('a'.split()))

-

-    def test_set_defaults_parents(self):

-        parent = ErrorRaisingArgumentParser(add_help=False)

-        parent.set_defaults(x='foo')

-        parser = ErrorRaisingArgumentParser(parents=[parent])

-        self.assertEqual(NS(x='foo'), parser.parse_args([]))

-

-    def test_set_defaults_same_as_add_argument(self):

-        parser = ErrorRaisingArgumentParser()

-        parser.set_defaults(w='W', x='X', y='Y', z='Z')

-        parser.add_argument('-w')

-        parser.add_argument('-x', default='XX')

-        parser.add_argument('y', nargs='?')

-        parser.add_argument('z', nargs='?', default='ZZ')

-

-        # defaults set previously

-        self.assertEqual(NS(w='W', x='XX', y='Y', z='ZZ'),

-                         parser.parse_args([]))

-

-        # reset defaults

-        parser.set_defaults(w='WW', x='X', y='YY', z='Z')

-        self.assertEqual(NS(w='WW', x='X', y='YY', z='Z'),

-                         parser.parse_args([]))

-

-    def test_set_defaults_same_as_add_argument_group(self):

-        parser = ErrorRaisingArgumentParser()

-        parser.set_defaults(w='W', x='X', y='Y', z='Z')

-        group = parser.add_argument_group('foo')

-        group.add_argument('-w')

-        group.add_argument('-x', default='XX')

-        group.add_argument('y', nargs='?')

-        group.add_argument('z', nargs='?', default='ZZ')

-

-

-        # defaults set previously

-        self.assertEqual(NS(w='W', x='XX', y='Y', z='ZZ'),

-                         parser.parse_args([]))

-

-        # reset defaults

-        parser.set_defaults(w='WW', x='X', y='YY', z='Z')

-        self.assertEqual(NS(w='WW', x='X', y='YY', z='Z'),

-                         parser.parse_args([]))

-

-# =================

-# Get default tests

-# =================

-

-class TestGetDefault(TestCase):

-

-    def test_get_default(self):

-        parser = ErrorRaisingArgumentParser()

-        self.assertEqual(None, parser.get_default("foo"))

-        self.assertEqual(None, parser.get_default("bar"))

-

-        parser.add_argument("--foo")

-        self.assertEqual(None, parser.get_default("foo"))

-        self.assertEqual(None, parser.get_default("bar"))

-

-        parser.add_argument("--bar", type=int, default=42)

-        self.assertEqual(None, parser.get_default("foo"))

-        self.assertEqual(42, parser.get_default("bar"))

-

-        parser.set_defaults(foo="badger")

-        self.assertEqual("badger", parser.get_default("foo"))

-        self.assertEqual(42, parser.get_default("bar"))

-

-# ==========================

-# Namespace 'contains' tests

-# ==========================

-

-class TestNamespaceContainsSimple(TestCase):

-

-    def test_empty(self):

-        ns = argparse.Namespace()

-        self.assertEquals('' in ns, False)

-        self.assertEquals('' not in ns, True)

-        self.assertEquals('x' in ns, False)

-

-    def test_non_empty(self):

-        ns = argparse.Namespace(x=1, y=2)

-        self.assertEquals('x' in ns, True)

-        self.assertEquals('x' not in ns, False)

-        self.assertEquals('y' in ns, True)

-        self.assertEquals('' in ns, False)

-        self.assertEquals('xx' in ns, False)

-        self.assertEquals('z' in ns, False)

-

-# =====================

-# Help formatting tests

-# =====================

-

-class TestHelpFormattingMetaclass(type):

-

-    def __init__(cls, name, bases, bodydict):

-        if name == 'HelpTestCase':

-            return

-

-        class AddTests(object):

-

-            def __init__(self, test_class, func_suffix, std_name):

-                self.func_suffix = func_suffix

-                self.std_name = std_name

-

-                for test_func in [self.test_format,

-                                  self.test_print,

-                                  self.test_print_file]:

-                    test_name = '%s_%s' % (test_func.__name__, func_suffix)

-

-                    def test_wrapper(self, test_func=test_func):

-                        test_func(self)

-                    try:

-                        test_wrapper.__name__ = test_name

-                    except TypeError:

-                        pass

-                    setattr(test_class, test_name, test_wrapper)

-

-            def _get_parser(self, tester):

-                parser = argparse.ArgumentParser(

-                    *tester.parser_signature.args,

-                    **tester.parser_signature.kwargs)

-                for argument_sig in tester.argument_signatures:

-                    parser.add_argument(*argument_sig.args,

-                                        **argument_sig.kwargs)

-                group_signatures = tester.argument_group_signatures

-                for group_sig, argument_sigs in group_signatures:

-                    group = parser.add_argument_group(*group_sig.args,

-                                                      **group_sig.kwargs)

-                    for argument_sig in argument_sigs:

-                        group.add_argument(*argument_sig.args,

-                                           **argument_sig.kwargs)

-                return parser

-

-            def _test(self, tester, parser_text):

-                expected_text = getattr(tester, self.func_suffix)

-                expected_text = textwrap.dedent(expected_text)

-                if expected_text != parser_text:

-                    print(repr(expected_text))

-                    print(repr(parser_text))

-                    for char1, char2 in zip(expected_text, parser_text):

-                        if char1 != char2:

-                            print('first diff: %r %r' % (char1, char2))

-                            break

-                tester.assertEqual(expected_text, parser_text)

-

-            def test_format(self, tester):

-                parser = self._get_parser(tester)

-                format = getattr(parser, 'format_%s' % self.func_suffix)

-                self._test(tester, format())

-

-            def test_print(self, tester):

-                parser = self._get_parser(tester)

-                print_ = getattr(parser, 'print_%s' % self.func_suffix)

-                old_stream = getattr(sys, self.std_name)

-                setattr(sys, self.std_name, StringIO())

-                try:

-                    print_()

-                    parser_text = getattr(sys, self.std_name).getvalue()

-                finally:

-                    setattr(sys, self.std_name, old_stream)

-                self._test(tester, parser_text)

-

-            def test_print_file(self, tester):

-                parser = self._get_parser(tester)

-                print_ = getattr(parser, 'print_%s' % self.func_suffix)

-                sfile = StringIO()

-                print_(sfile)

-                parser_text = sfile.getvalue()

-                self._test(tester, parser_text)

-

-        # add tests for {format,print}_{usage,help,version}

-        for func_suffix, std_name in [('usage', 'stdout'),

-                                      ('help', 'stdout'),

-                                      ('version', 'stderr')]:

-            AddTests(cls, func_suffix, std_name)

-

-bases = TestCase,

-HelpTestCase = TestHelpFormattingMetaclass('HelpTestCase', bases, {})

-

-

-class TestHelpBiggerOptionals(HelpTestCase):

-    """Make sure that argument help aligns when options are longer"""

-

-    parser_signature = Sig(prog='PROG', description='DESCRIPTION',

-                           epilog='EPILOG', version='0.1')

-    argument_signatures = [

-        Sig('-x', action='store_true', help='X HELP'),

-        Sig('--y', help='Y HELP'),

-        Sig('foo', help='FOO HELP'),

-        Sig('bar', help='BAR HELP'),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PROG [-h] [-v] [-x] [--y Y] foo bar

-        '''

-    help = usage + '''\

-

-        DESCRIPTION

-

-        positional arguments:

-          foo            FOO HELP

-          bar            BAR HELP

-

-        optional arguments:

-          -h, --help     show this help message and exit

-          -v, --version  show program's version number and exit

-          -x             X HELP

-          --y Y          Y HELP

-

-        EPILOG

-    '''

-    version = '''\

-        0.1

-        '''

-

-

-class TestHelpBiggerOptionalGroups(HelpTestCase):

-    """Make sure that argument help aligns when options are longer"""

-

-    parser_signature = Sig(prog='PROG', description='DESCRIPTION',

-                           epilog='EPILOG', version='0.1')

-    argument_signatures = [

-        Sig('-x', action='store_true', help='X HELP'),

-        Sig('--y', help='Y HELP'),

-        Sig('foo', help='FOO HELP'),

-        Sig('bar', help='BAR HELP'),

-    ]

-    argument_group_signatures = [

-        (Sig('GROUP TITLE', description='GROUP DESCRIPTION'), [

-            Sig('baz', help='BAZ HELP'),

-            Sig('-z', nargs='+', help='Z HELP')]),

-    ]

-    usage = '''\

-        usage: PROG [-h] [-v] [-x] [--y Y] [-z Z [Z ...]] foo bar baz

-        '''

-    help = usage + '''\

-

-        DESCRIPTION

-

-        positional arguments:

-          foo            FOO HELP

-          bar            BAR HELP

-

-        optional arguments:

-          -h, --help     show this help message and exit

-          -v, --version  show program's version number and exit

-          -x             X HELP

-          --y Y          Y HELP

-

-        GROUP TITLE:

-          GROUP DESCRIPTION

-

-          baz            BAZ HELP

-          -z Z [Z ...]   Z HELP

-

-        EPILOG

-    '''

-    version = '''\

-        0.1

-        '''

-

-

-class TestHelpBiggerPositionals(HelpTestCase):

-    """Make sure that help aligns when arguments are longer"""

-

-    parser_signature = Sig(usage='USAGE', description='DESCRIPTION')

-    argument_signatures = [

-        Sig('-x', action='store_true', help='X HELP'),

-        Sig('--y', help='Y HELP'),

-        Sig('ekiekiekifekang', help='EKI HELP'),

-        Sig('bar', help='BAR HELP'),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: USAGE

-        '''

-    help = usage + '''\

-

-        DESCRIPTION

-

-        positional arguments:

-          ekiekiekifekang  EKI HELP

-          bar              BAR HELP

-

-        optional arguments:

-          -h, --help       show this help message and exit

-          -x               X HELP

-          --y Y            Y HELP

-        '''

-

-    version = ''

-

-

-class TestHelpReformatting(HelpTestCase):

-    """Make sure that text after short names starts on the first line"""

-

-    parser_signature = Sig(

-        prog='PROG',

-        description='   oddly    formatted\n'

-                    'description\n'

-                    '\n'

-                    'that is so long that it should go onto multiple '

-                    'lines when wrapped')

-    argument_signatures = [

-        Sig('-x', metavar='XX', help='oddly\n'

-                                     '    formatted -x help'),

-        Sig('y', metavar='yyy', help='normal y help'),

-    ]

-    argument_group_signatures = [

-        (Sig('title', description='\n'

-                                  '    oddly formatted group\n'

-                                  '\n'

-                                  'description'),

-         [Sig('-a', action='store_true',

-              help=' oddly \n'

-                   'formatted    -a  help  \n'

-                   '    again, so long that it should be wrapped over '

-                   'multiple lines')]),

-    ]

-    usage = '''\

-        usage: PROG [-h] [-x XX] [-a] yyy

-        '''

-    help = usage + '''\

-

-        oddly formatted description that is so long that it should go onto \

-multiple

-        lines when wrapped

-

-        positional arguments:

-          yyy         normal y help

-

-        optional arguments:

-          -h, --help  show this help message and exit

-          -x XX       oddly formatted -x help

-

-        title:

-          oddly formatted group description

-

-          -a          oddly formatted -a help again, so long that it should \

-be wrapped

-                      over multiple lines

-        '''

-    version = ''

-

-

-class TestHelpWrappingShortNames(HelpTestCase):

-    """Make sure that text after short names starts on the first line"""

-

-    parser_signature = Sig(prog='PROG', description= 'D\nD' * 30)

-    argument_signatures = [

-        Sig('-x', metavar='XX', help='XHH HX' * 20),

-        Sig('y', metavar='yyy', help='YH YH' * 20),

-    ]

-    argument_group_signatures = [

-        (Sig('ALPHAS'), [

-            Sig('-a', action='store_true', help='AHHH HHA' * 10)]),

-    ]

-    usage = '''\

-        usage: PROG [-h] [-x XX] [-a] yyy

-        '''

-    help = usage + '''\

-

-        D DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD \

-DD DD DD

-        DD DD DD DD D

-

-        positional arguments:

-          yyy         YH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH \

-YHYH YHYH

-                      YHYH YHYH YHYH YHYH YHYH YHYH YHYH YH

-

-        optional arguments:

-          -h, --help  show this help message and exit

-          -x XX       XHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH \

-HXXHH HXXHH

-                      HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HX

-

-        ALPHAS:

-          -a          AHHH HHAAHHH HHAAHHH HHAAHHH HHAAHHH HHAAHHH HHAAHHH \

-HHAAHHH

-                      HHAAHHH HHAAHHH HHA

-        '''

-    version = ''

-

-

-class TestHelpWrappingLongNames(HelpTestCase):

-    """Make sure that text after long names starts on the next line"""

-

-    parser_signature = Sig(usage='USAGE', description= 'D D' * 30,

-                           version='V V'*30)

-    argument_signatures = [

-        Sig('-x', metavar='X' * 25, help='XH XH' * 20),

-        Sig('y', metavar='y' * 25, help='YH YH' * 20),

-    ]

-    argument_group_signatures = [

-        (Sig('ALPHAS'), [

-            Sig('-a', metavar='A' * 25, help='AH AH' * 20),

-            Sig('z', metavar='z' * 25, help='ZH ZH' * 20)]),

-    ]

-    usage = '''\

-        usage: USAGE

-        '''

-    help = usage + '''\

-

-        D DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD \

-DD DD DD

-        DD DD DD DD D

-

-        positional arguments:

-          yyyyyyyyyyyyyyyyyyyyyyyyy

-                                YH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH \

-YHYH YHYH

-                                YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YH

-

-        optional arguments:

-          -h, --help            show this help message and exit

-          -v, --version         show program's version number and exit

-          -x XXXXXXXXXXXXXXXXXXXXXXXXX

-                                XH XHXH XHXH XHXH XHXH XHXH XHXH XHXH XHXH \

-XHXH XHXH

-                                XHXH XHXH XHXH XHXH XHXH XHXH XHXH XHXH XHXH XH

-

-        ALPHAS:

-          -a AAAAAAAAAAAAAAAAAAAAAAAAA

-                                AH AHAH AHAH AHAH AHAH AHAH AHAH AHAH AHAH \

-AHAH AHAH

-                                AHAH AHAH AHAH AHAH AHAH AHAH AHAH AHAH AHAH AH

-          zzzzzzzzzzzzzzzzzzzzzzzzz

-                                ZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH \

-ZHZH ZHZH

-                                ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZH

-        '''

-    version = '''\

-        V VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV \

-VV VV VV

-        VV VV VV VV V

-        '''

-

-

-class TestHelpUsage(HelpTestCase):

-    """Test basic usage messages"""

-

-    parser_signature = Sig(prog='PROG')

-    argument_signatures = [

-        Sig('-w', nargs='+', help='w'),

-        Sig('-x', nargs='*', help='x'),

-        Sig('a', help='a'),

-        Sig('b', help='b', nargs=2),

-        Sig('c', help='c', nargs='?'),

-    ]

-    argument_group_signatures = [

-        (Sig('group'), [

-            Sig('-y', nargs='?', help='y'),

-            Sig('-z', nargs=3, help='z'),

-            Sig('d', help='d', nargs='*'),

-            Sig('e', help='e', nargs='+'),

-        ])

-    ]

-    usage = '''\

-        usage: PROG [-h] [-w W [W ...]] [-x [X [X ...]]] [-y [Y]] [-z Z Z Z]

-                    a b b [c] [d [d ...]] e [e ...]

-        '''

-    help = usage + '''\

-

-        positional arguments:

-          a               a

-          b               b

-          c               c

-

-        optional arguments:

-          -h, --help      show this help message and exit

-          -w W [W ...]    w

-          -x [X [X ...]]  x

-

-        group:

-          -y [Y]          y

-          -z Z Z Z        z

-          d               d

-          e               e

-        '''

-    version = ''

-

-

-class TestHelpOnlyUserGroups(HelpTestCase):

-    """Test basic usage messages"""

-

-    parser_signature = Sig(prog='PROG', add_help=False)

-    argument_signatures = []

-    argument_group_signatures = [

-        (Sig('xxxx'), [

-            Sig('-x', help='x'),

-            Sig('a', help='a'),

-        ]),

-        (Sig('yyyy'), [

-            Sig('b', help='b'),

-            Sig('-y', help='y'),

-        ]),

-    ]

-    usage = '''\

-        usage: PROG [-x X] [-y Y] a b

-        '''

-    help = usage + '''\

-

-        xxxx:

-          -x X  x

-          a     a

-

-        yyyy:

-          b     b

-          -y Y  y

-        '''

-    version = ''

-

-

-class TestHelpUsageLongProg(HelpTestCase):

-    """Test usage messages where the prog is long"""

-

-    parser_signature = Sig(prog='P' * 60)

-    argument_signatures = [

-        Sig('-w', metavar='W'),

-        Sig('-x', metavar='X'),

-        Sig('a'),

-        Sig('b'),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP

-               [-h] [-w W] [-x X] a b

-        '''

-    help = usage + '''\

-

-        positional arguments:

-          a

-          b

-

-        optional arguments:

-          -h, --help  show this help message and exit

-          -w W

-          -x X

-        '''

-    version = ''

-

-

-class TestHelpUsageLongProgOptionsWrap(HelpTestCase):

-    """Test usage messages where the prog is long and the optionals wrap"""

-

-    parser_signature = Sig(prog='P' * 60)

-    argument_signatures = [

-        Sig('-w', metavar='W' * 25),

-        Sig('-x', metavar='X' * 25),

-        Sig('-y', metavar='Y' * 25),

-        Sig('-z', metavar='Z' * 25),

-        Sig('a'),

-        Sig('b'),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP

-               [-h] [-w WWWWWWWWWWWWWWWWWWWWWWWWW] \

-[-x XXXXXXXXXXXXXXXXXXXXXXXXX]

-               [-y YYYYYYYYYYYYYYYYYYYYYYYYY] [-z ZZZZZZZZZZZZZZZZZZZZZZZZZ]

-               a b

-        '''

-    help = usage + '''\

-

-        positional arguments:

-          a

-          b

-

-        optional arguments:

-          -h, --help            show this help message and exit

-          -w WWWWWWWWWWWWWWWWWWWWWWWWW

-          -x XXXXXXXXXXXXXXXXXXXXXXXXX

-          -y YYYYYYYYYYYYYYYYYYYYYYYYY

-          -z ZZZZZZZZZZZZZZZZZZZZZZZZZ

-        '''

-    version = ''

-

-

-class TestHelpUsageLongProgPositionalsWrap(HelpTestCase):

-    """Test usage messages where the prog is long and the positionals wrap"""

-

-    parser_signature = Sig(prog='P' * 60, add_help=False)

-    argument_signatures = [

-        Sig('a' * 25),

-        Sig('b' * 25),

-        Sig('c' * 25),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP

-               aaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbb

-               ccccccccccccccccccccccccc

-        '''

-    help = usage + '''\

-

-        positional arguments:

-          aaaaaaaaaaaaaaaaaaaaaaaaa

-          bbbbbbbbbbbbbbbbbbbbbbbbb

-          ccccccccccccccccccccccccc

-        '''

-    version = ''

-

-

-class TestHelpUsageOptionalsWrap(HelpTestCase):

-    """Test usage messages where the optionals wrap"""

-

-    parser_signature = Sig(prog='PROG')

-    argument_signatures = [

-        Sig('-w', metavar='W' * 25),

-        Sig('-x', metavar='X' * 25),

-        Sig('-y', metavar='Y' * 25),

-        Sig('-z', metavar='Z' * 25),

-        Sig('a'),

-        Sig('b'),

-        Sig('c'),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PROG [-h] [-w WWWWWWWWWWWWWWWWWWWWWWWWW] \

-[-x XXXXXXXXXXXXXXXXXXXXXXXXX]

-                    [-y YYYYYYYYYYYYYYYYYYYYYYYYY] \

-[-z ZZZZZZZZZZZZZZZZZZZZZZZZZ]

-                    a b c

-        '''

-    help = usage + '''\

-

-        positional arguments:

-          a

-          b

-          c

-

-        optional arguments:

-          -h, --help            show this help message and exit

-          -w WWWWWWWWWWWWWWWWWWWWWWWWW

-          -x XXXXXXXXXXXXXXXXXXXXXXXXX

-          -y YYYYYYYYYYYYYYYYYYYYYYYYY

-          -z ZZZZZZZZZZZZZZZZZZZZZZZZZ

-        '''

-    version = ''

-

-

-class TestHelpUsagePositionalsWrap(HelpTestCase):

-    """Test usage messages where the positionals wrap"""

-

-    parser_signature = Sig(prog='PROG')

-    argument_signatures = [

-        Sig('-x'),

-        Sig('-y'),

-        Sig('-z'),

-        Sig('a' * 25),

-        Sig('b' * 25),

-        Sig('c' * 25),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PROG [-h] [-x X] [-y Y] [-z Z]

-                    aaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbb

-                    ccccccccccccccccccccccccc

-        '''

-    help = usage + '''\

-

-        positional arguments:

-          aaaaaaaaaaaaaaaaaaaaaaaaa

-          bbbbbbbbbbbbbbbbbbbbbbbbb

-          ccccccccccccccccccccccccc

-

-        optional arguments:

-          -h, --help            show this help message and exit

-          -x X

-          -y Y

-          -z Z

-        '''

-    version = ''

-

-

-class TestHelpUsageOptionalsPositionalsWrap(HelpTestCase):

-    """Test usage messages where the optionals and positionals wrap"""

-

-    parser_signature = Sig(prog='PROG')

-    argument_signatures = [

-        Sig('-x', metavar='X' * 25),

-        Sig('-y', metavar='Y' * 25),

-        Sig('-z', metavar='Z' * 25),

-        Sig('a' * 25),

-        Sig('b' * 25),

-        Sig('c' * 25),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PROG [-h] [-x XXXXXXXXXXXXXXXXXXXXXXXXX] \

-[-y YYYYYYYYYYYYYYYYYYYYYYYYY]

-                    [-z ZZZZZZZZZZZZZZZZZZZZZZZZZ]

-                    aaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbb

-                    ccccccccccccccccccccccccc

-        '''

-    help = usage + '''\

-

-        positional arguments:

-          aaaaaaaaaaaaaaaaaaaaaaaaa

-          bbbbbbbbbbbbbbbbbbbbbbbbb

-          ccccccccccccccccccccccccc

-

-        optional arguments:

-          -h, --help            show this help message and exit

-          -x XXXXXXXXXXXXXXXXXXXXXXXXX

-          -y YYYYYYYYYYYYYYYYYYYYYYYYY

-          -z ZZZZZZZZZZZZZZZZZZZZZZZZZ

-        '''

-    version = ''

-

-

-class TestHelpUsageOptionalsOnlyWrap(HelpTestCase):

-    """Test usage messages where there are only optionals and they wrap"""

-

-    parser_signature = Sig(prog='PROG')

-    argument_signatures = [

-        Sig('-x', metavar='X' * 25),

-        Sig('-y', metavar='Y' * 25),

-        Sig('-z', metavar='Z' * 25),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PROG [-h] [-x XXXXXXXXXXXXXXXXXXXXXXXXX] \

-[-y YYYYYYYYYYYYYYYYYYYYYYYYY]

-                    [-z ZZZZZZZZZZZZZZZZZZZZZZZZZ]

-        '''

-    help = usage + '''\

-

-        optional arguments:

-          -h, --help            show this help message and exit

-          -x XXXXXXXXXXXXXXXXXXXXXXXXX

-          -y YYYYYYYYYYYYYYYYYYYYYYYYY

-          -z ZZZZZZZZZZZZZZZZZZZZZZZZZ

-        '''

-    version = ''

-

-

-class TestHelpUsagePositionalsOnlyWrap(HelpTestCase):

-    """Test usage messages where there are only positionals and they wrap"""

-

-    parser_signature = Sig(prog='PROG', add_help=False)

-    argument_signatures = [

-        Sig('a' * 25),

-        Sig('b' * 25),

-        Sig('c' * 25),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PROG aaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbb

-                    ccccccccccccccccccccccccc

-        '''

-    help = usage + '''\

-

-        positional arguments:

-          aaaaaaaaaaaaaaaaaaaaaaaaa

-          bbbbbbbbbbbbbbbbbbbbbbbbb

-          ccccccccccccccccccccccccc

-        '''

-    version = ''

-

-

-class TestHelpVariableExpansion(HelpTestCase):

-    """Test that variables are expanded properly in help messages"""

-

-    parser_signature = Sig(prog='PROG')

-    argument_signatures = [

-        Sig('-x', type=int,

-            help='x %(prog)s %(default)s %(type)s %%'),

-        Sig('-y', action='store_const', default=42, const='XXX',

-            help='y %(prog)s %(default)s %(const)s'),

-        Sig('--foo', choices='abc',

-            help='foo %(prog)s %(default)s %(choices)s'),

-        Sig('--bar', default='baz', choices=[1, 2], metavar='BBB',

-            help='bar %(prog)s %(default)s %(dest)s'),

-        Sig('spam', help='spam %(prog)s %(default)s'),

-        Sig('badger', default=0.5, help='badger %(prog)s %(default)s'),

-    ]

-    argument_group_signatures = [

-        (Sig('group'), [

-            Sig('-a', help='a %(prog)s %(default)s'),

-            Sig('-b', default=-1, help='b %(prog)s %(default)s'),

-        ])

-    ]

-    usage = ('''\

-        usage: PROG [-h] [-x X] [-y] [--foo {a,b,c}] [--bar BBB] [-a A] [-b B]

-                    spam badger

-        ''')

-    help = usage + '''\

-

-        positional arguments:

-          spam           spam PROG None

-          badger         badger PROG 0.5

-

-        optional arguments:

-          -h, --help     show this help message and exit

-          -x X           x PROG None int %

-          -y             y PROG 42 XXX

-          --foo {a,b,c}  foo PROG None a, b, c

-          --bar BBB      bar PROG baz bar

-

-        group:

-          -a A           a PROG None

-          -b B           b PROG -1

-        '''

-    version = ''

-

-

-class TestHelpVariableExpansionUsageSupplied(HelpTestCase):

-    """Test that variables are expanded properly when usage= is present"""

-

-    parser_signature = Sig(prog='PROG', usage='%(prog)s FOO')

-    argument_signatures = []

-    argument_group_signatures = []

-    usage = ('''\

-        usage: PROG FOO

-        ''')

-    help = usage + '''\

-

-        optional arguments:

-          -h, --help  show this help message and exit

-        '''

-    version = ''

-

-

-class TestHelpVariableExpansionNoArguments(HelpTestCase):

-    """Test that variables are expanded properly with no arguments"""

-

-    parser_signature = Sig(prog='PROG', add_help=False)

-    argument_signatures = []

-    argument_group_signatures = []

-    usage = ('''\

-        usage: PROG

-        ''')

-    help = usage

-    version = ''

-

-

-class TestHelpSuppressUsage(HelpTestCase):

-    """Test that items can be suppressed in usage messages"""

-

-    parser_signature = Sig(prog='PROG', usage=argparse.SUPPRESS)

-    argument_signatures = [

-        Sig('--foo', help='foo help'),

-        Sig('spam', help='spam help'),

-    ]

-    argument_group_signatures = []

-    help = '''\

-        positional arguments:

-          spam        spam help

-

-        optional arguments:

-          -h, --help  show this help message and exit

-          --foo FOO   foo help

-        '''

-    usage = ''

-    version = ''

-

-

-class TestHelpSuppressOptional(HelpTestCase):

-    """Test that optional arguments can be suppressed in help messages"""

-

-    parser_signature = Sig(prog='PROG', add_help=False)

-    argument_signatures = [

-        Sig('--foo', help=argparse.SUPPRESS),

-        Sig('spam', help='spam help'),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PROG spam

-        '''

-    help = usage + '''\

-

-        positional arguments:

-          spam  spam help

-        '''

-    version = ''

-

-

-class TestHelpSuppressOptionalGroup(HelpTestCase):

-    """Test that optional groups can be suppressed in help messages"""

-

-    parser_signature = Sig(prog='PROG')

-    argument_signatures = [

-        Sig('--foo', help='foo help'),

-        Sig('spam', help='spam help'),

-    ]

-    argument_group_signatures = [

-        (Sig('group'), [Sig('--bar', help=argparse.SUPPRESS)]),

-    ]

-    usage = '''\

-        usage: PROG [-h] [--foo FOO] spam

-        '''

-    help = usage + '''\

-

-        positional arguments:

-          spam        spam help

-

-        optional arguments:

-          -h, --help  show this help message and exit

-          --foo FOO   foo help

-        '''

-    version = ''

-

-

-class TestHelpSuppressPositional(HelpTestCase):

-    """Test that positional arguments can be suppressed in help messages"""

-

-    parser_signature = Sig(prog='PROG')

-    argument_signatures = [

-        Sig('--foo', help='foo help'),

-        Sig('spam', help=argparse.SUPPRESS),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PROG [-h] [--foo FOO]

-        '''

-    help = usage + '''\

-

-        optional arguments:

-          -h, --help  show this help message and exit

-          --foo FOO   foo help

-        '''

-    version = ''

-

-

-class TestHelpRequiredOptional(HelpTestCase):

-    """Test that required options don't look optional"""

-

-    parser_signature = Sig(prog='PROG')

-    argument_signatures = [

-        Sig('--foo', required=True, help='foo help'),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PROG [-h] --foo FOO

-        '''

-    help = usage + '''\

-

-        optional arguments:

-          -h, --help  show this help message and exit

-          --foo FOO   foo help

-        '''

-    version = ''

-

-

-class TestHelpAlternatePrefixChars(HelpTestCase):

-    """Test that options display with different prefix characters"""

-

-    parser_signature = Sig(prog='PROG', prefix_chars='^;', add_help=False)

-    argument_signatures = [

-        Sig('^^foo', action='store_true', help='foo help'),

-        Sig(';b', ';;bar', help='bar help'),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PROG [^^foo] [;b BAR]

-        '''

-    help = usage + '''\

-

-        optional arguments:

-          ^^foo              foo help

-          ;b BAR, ;;bar BAR  bar help

-        '''

-    version = ''

-

-

-class TestHelpNoHelpOptional(HelpTestCase):

-    """Test that the --help argument can be suppressed help messages"""

-

-    parser_signature = Sig(prog='PROG', add_help=False)

-    argument_signatures = [

-        Sig('--foo', help='foo help'),

-        Sig('spam', help='spam help'),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PROG [--foo FOO] spam

-        '''

-    help = usage + '''\

-

-        positional arguments:

-          spam       spam help

-

-        optional arguments:

-          --foo FOO  foo help

-        '''

-    version = ''

-

-

-class TestHelpVersionOptional(HelpTestCase):

-    """Test that the --version argument can be suppressed help messages"""

-

-    parser_signature = Sig(prog='PROG', version='1.0')

-    argument_signatures = [

-        Sig('--foo', help='foo help'),

-        Sig('spam', help='spam help'),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PROG [-h] [-v] [--foo FOO] spam

-        '''

-    help = usage + '''\

-

-        positional arguments:

-          spam           spam help

-

-        optional arguments:

-          -h, --help     show this help message and exit

-          -v, --version  show program's version number and exit

-          --foo FOO      foo help

-        '''

-    version = '''\

-        1.0

-        '''

-

-

-class TestHelpNone(HelpTestCase):

-    """Test that no errors occur if no help is specified"""

-

-    parser_signature = Sig(prog='PROG')

-    argument_signatures = [

-        Sig('--foo'),

-        Sig('spam'),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PROG [-h] [--foo FOO] spam

-        '''

-    help = usage + '''\

-

-        positional arguments:

-          spam

-

-        optional arguments:

-          -h, --help  show this help message and exit

-          --foo FOO

-        '''

-    version = ''

-

-

-class TestHelpTupleMetavar(HelpTestCase):

-    """Test specifying metavar as a tuple"""

-

-    parser_signature = Sig(prog='PROG')

-    argument_signatures = [

-        Sig('-w', help='w', nargs='+', metavar=('W1', 'W2')),

-        Sig('-x', help='x', nargs='*', metavar=('X1', 'X2')),

-        Sig('-y', help='y', nargs=3, metavar=('Y1', 'Y2', 'Y3')),

-        Sig('-z', help='z', nargs='?', metavar=('Z1', )),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PROG [-h] [-w W1 [W2 ...]] [-x [X1 [X2 ...]]] [-y Y1 Y2 Y3] \

-[-z [Z1]]

-        '''

-    help = usage + '''\

-

-        optional arguments:

-          -h, --help        show this help message and exit

-          -w W1 [W2 ...]    w

-          -x [X1 [X2 ...]]  x

-          -y Y1 Y2 Y3       y

-          -z [Z1]           z

-        '''

-    version = ''

-

-

-class TestHelpRawText(HelpTestCase):

-    """Test the RawTextHelpFormatter"""

-

-    parser_signature = Sig(

-        prog='PROG', formatter_class=argparse.RawTextHelpFormatter,

-        description='Keep the formatting\n'

-                    '    exactly as it is written\n'

-                    '\n'

-                    'here\n')

-

-    argument_signatures = [

-        Sig('--foo', help='    foo help should also\n'

-                          'appear as given here'),

-        Sig('spam', help='spam help'),

-    ]

-    argument_group_signatures = [

-        (Sig('title', description='    This text\n'

-                                  '  should be indented\n'

-                                  '    exactly like it is here\n'),

-         [Sig('--bar', help='bar help')]),

-    ]

-    usage = '''\

-        usage: PROG [-h] [--foo FOO] [--bar BAR] spam

-        '''

-    help = usage + '''\

-

-        Keep the formatting

-            exactly as it is written

-

-        here

-

-        positional arguments:

-          spam        spam help

-

-        optional arguments:

-          -h, --help  show this help message and exit

-          --foo FOO       foo help should also

-                      appear as given here

-

-        title:

-              This text

-            should be indented

-              exactly like it is here

-

-          --bar BAR   bar help

-        '''

-    version = ''

-

-

-class TestHelpRawDescription(HelpTestCase):

-    """Test the RawTextHelpFormatter"""

-

-    parser_signature = Sig(

-        prog='PROG', formatter_class=argparse.RawDescriptionHelpFormatter,

-        description='Keep the formatting\n'

-                    '    exactly as it is written\n'

-                    '\n'

-                    'here\n')

-

-    argument_signatures = [

-        Sig('--foo', help='  foo help should not\n'

-                          '    retain this odd formatting'),

-        Sig('spam', help='spam help'),

-    ]

-    argument_group_signatures = [

-        (Sig('title', description='    This text\n'

-                                  '  should be indented\n'

-                                  '    exactly like it is here\n'),

-         [Sig('--bar', help='bar help')]),

-    ]

-    usage = '''\

-        usage: PROG [-h] [--foo FOO] [--bar BAR] spam

-        '''

-    help = usage + '''\

-

-        Keep the formatting

-            exactly as it is written

-

-        here

-

-        positional arguments:

-          spam        spam help

-

-        optional arguments:

-          -h, --help  show this help message and exit

-          --foo FOO   foo help should not retain this odd formatting

-

-        title:

-              This text

-            should be indented

-              exactly like it is here

-

-          --bar BAR   bar help

-        '''

-    version = ''

-

-

-class TestHelpArgumentDefaults(HelpTestCase):

-    """Test the ArgumentDefaultsHelpFormatter"""

-

-    parser_signature = Sig(

-        prog='PROG', formatter_class=argparse.ArgumentDefaultsHelpFormatter,

-        description='description')

-

-    argument_signatures = [

-        Sig('--foo', help='foo help - oh and by the way, %(default)s'),

-        Sig('--bar', action='store_true', help='bar help'),

-        Sig('spam', help='spam help'),

-        Sig('badger', nargs='?', default='wooden', help='badger help'),

-    ]

-    argument_group_signatures = [

-        (Sig('title', description='description'),

-         [Sig('--baz', type=int, default=42, help='baz help')]),

-    ]

-    usage = '''\

-        usage: PROG [-h] [--foo FOO] [--bar] [--baz BAZ] spam [badger]

-        '''

-    help = usage + '''\

-

-        description

-

-        positional arguments:

-          spam        spam help

-          badger      badger help (default: wooden)

-

-        optional arguments:

-          -h, --help  show this help message and exit

-          --foo FOO   foo help - oh and by the way, None

-          --bar       bar help (default: False)

-

-        title:

-          description

-

-          --baz BAZ   baz help (default: 42)

-        '''

-    version = ''

-

-# =====================================

-# Optional/Positional constructor tests

-# =====================================

-

-class TestInvalidArgumentConstructors(TestCase):

-    """Test a bunch of invalid Argument constructors"""

-

-    def assertTypeError(self, *args, **kwargs):

-        parser = argparse.ArgumentParser()

-        self.assertRaises(TypeError, parser.add_argument,

-                          *args, **kwargs)

-

-    def assertValueError(self, *args, **kwargs):

-        parser = argparse.ArgumentParser()

-        self.assertRaises(ValueError, parser.add_argument,

-                          *args, **kwargs)

-

-    def test_invalid_keyword_arguments(self):

-        self.assertTypeError('-x', bar=None)

-        self.assertTypeError('-y', callback='foo')

-        self.assertTypeError('-y', callback_args=())

-        self.assertTypeError('-y', callback_kwargs={})

-

-    def test_missing_destination(self):

-        self.assertTypeError()

-        for action in ['append', 'store']:

-            self.assertTypeError(action=action)

-

-    def test_invalid_option_strings(self):

-        self.assertValueError('--')

-        self.assertValueError('---')

-

-    def test_invalid_type(self):

-        self.assertValueError('--foo', type='int')

-

-    def test_invalid_action(self):

-        self.assertValueError('-x', action='foo')

-        self.assertValueError('foo', action='baz')

-        parser = argparse.ArgumentParser()

-        try:

-            parser.add_argument("--foo", action="store-true")

-        except ValueError:

-            e = sys.exc_info()[1]

-            expected = 'unknown action'

-            msg = 'expected %r, found %r' % (expected, e)

-            self.failUnless(expected in str(e), msg)

-

-    def test_multiple_dest(self):

-        parser = argparse.ArgumentParser()

-        parser.add_argument(dest='foo')

-        try:

-            parser.add_argument('bar', dest='baz')

-        except ValueError:

-            e = sys.exc_info()[1]

-            expected = 'dest supplied twice for positional argument'

-            msg = 'expected %r, found %r' % (expected, e)

-            self.failUnless(expected in str(e), msg)

-

-    def test_no_argument_actions(self):

-        for action in ['store_const', 'store_true', 'store_false',

-                       'append_const', 'count']:

-            for attrs in [dict(type=int), dict(nargs='+'),

-                          dict(choices='ab')]:

-                self.assertTypeError('-x', action=action, **attrs)

-

-    def test_no_argument_no_const_actions(self):

-        # options with zero arguments

-        for action in ['store_true', 'store_false', 'count']:

-

-            # const is always disallowed

-            self.assertTypeError('-x', const='foo', action=action)

-

-            # nargs is always disallowed

-            self.assertTypeError('-x', nargs='*', action=action)

-

-    def test_more_than_one_argument_actions(self):

-        for action in ['store', 'append']:

-

-            # nargs=0 is disallowed

-            self.assertValueError('-x', nargs=0, action=action)

-            self.assertValueError('spam', nargs=0, action=action)

-

-            # const is disallowed with non-optional arguments

-            for nargs in [1, '*', '+']:

-                self.assertValueError('-x', const='foo',

-                                      nargs=nargs, action=action)

-                self.assertValueError('spam', const='foo',

-                                      nargs=nargs, action=action)

-

-    def test_required_const_actions(self):

-        for action in ['store_const', 'append_const']:

-

-            # nargs is always disallowed

-            self.assertTypeError('-x', nargs='+', action=action)

-

-    def test_parsers_action_missing_params(self):

-        self.assertTypeError('command', action='parsers')

-        self.assertTypeError('command', action='parsers', prog='PROG')

-        self.assertTypeError('command', action='parsers',

-                             parser_class=argparse.ArgumentParser)

-

-    def test_required_positional(self):

-        self.assertTypeError('foo', required=True)

-

-    def test_user_defined_action(self):

-

-        class Success(Exception):

-            pass

-

-        class Action(object):

-

-            def __init__(self,

-                         option_strings,

-                         dest,

-                         const,

-                         default,

-                         required=False):

-                if dest == 'spam':

-                    if const is Success:

-                        if default is Success:

-                            raise Success()

-

-            def __call__(self, *args, **kwargs):

-                pass

-

-        parser = argparse.ArgumentParser()

-        self.assertRaises(Success, parser.add_argument, '--spam',

-                          action=Action, default=Success, const=Success)

-        self.assertRaises(Success, parser.add_argument, 'spam',

-                          action=Action, default=Success, const=Success)

-

-# ================================

-# Actions returned by add_argument

-# ================================

-

-class TestActionsReturned(TestCase):

-

-    def test_dest(self):

-        parser = argparse.ArgumentParser()

-        action = parser.add_argument('--foo')

-        self.assertEqual(action.dest, 'foo')

-        action = parser.add_argument('-b', '--bar')

-        self.assertEqual(action.dest, 'bar')

-        action = parser.add_argument('-x', '-y')

-        self.assertEqual(action.dest, 'x')

-

-    def test_misc(self):

-        parser = argparse.ArgumentParser()

-        action = parser.add_argument('--foo', nargs='?', const=42,

-                                     default=84, type=int, choices=[1, 2],

-                                     help='FOO', metavar='BAR', dest='baz')

-        self.assertEqual(action.nargs, '?')

-        self.assertEqual(action.const, 42)

-        self.assertEqual(action.default, 84)

-        self.assertEqual(action.type, int)

-        self.assertEqual(action.choices, [1, 2])

-        self.assertEqual(action.help, 'FOO')

-        self.assertEqual(action.metavar, 'BAR')

-        self.assertEqual(action.dest, 'baz')

-

-

-# ================================

-# Argument conflict handling tests

-# ================================

-

-class TestConflictHandling(TestCase):

-

-    def test_bad_type(self):

-        self.assertRaises(ValueError, argparse.ArgumentParser,

-                          conflict_handler='foo')

-

-    def test_conflict_error(self):

-        parser = argparse.ArgumentParser()

-        parser.add_argument('-x')

-        self.assertRaises(argparse.ArgumentError,

-                          parser.add_argument, '-x')

-        parser.add_argument('--spam')

-        self.assertRaises(argparse.ArgumentError,

-                          parser.add_argument, '--spam')

-

-    def test_resolve_error(self):

-        get_parser = argparse.ArgumentParser

-        parser = get_parser(prog='PROG', conflict_handler='resolve')

-

-        parser.add_argument('-x', help='OLD X')

-        parser.add_argument('-x', help='NEW X')

-        self.assertEqual(parser.format_help(), textwrap.dedent('''\

-            usage: PROG [-h] [-x X]

-

-            optional arguments:

-              -h, --help  show this help message and exit

-              -x X        NEW X

-            '''))

-

-        parser.add_argument('--spam', metavar='OLD_SPAM')

-        parser.add_argument('--spam', metavar='NEW_SPAM')

-        self.assertEqual(parser.format_help(), textwrap.dedent('''\

-            usage: PROG [-h] [-x X] [--spam NEW_SPAM]

-

-            optional arguments:

-              -h, --help       show this help message and exit

-              -x X             NEW X

-              --spam NEW_SPAM

-            '''))

-

-

-# =============================

-# Help and Version option tests

-# =============================

-

-class TestOptionalsHelpVersionActions(TestCase):

-    """Test the help and version actions"""

-

-    def _get_error(self, func, *args, **kwargs):

-        try:

-            func(*args, **kwargs)

-        except ArgumentParserError:

-            return sys.exc_info()[1]

-        else:

-            self.assertRaises(ArgumentParserError, func, *args, **kwargs)

-

-    def assertPrintHelpExit(self, parser, args_str):

-        self.assertEqual(

-            parser.format_help(),

-            self._get_error(parser.parse_args, args_str.split()).stdout)

-

-    def assertPrintVersionExit(self, parser, args_str):

-        self.assertEqual(

-            parser.format_version(),

-            self._get_error(parser.parse_args, args_str.split()).stderr)

-

-    def assertArgumentParserError(self, parser, *args):

-        self.assertRaises(ArgumentParserError, parser.parse_args, args)

-

-    def test_version(self):

-        parser = ErrorRaisingArgumentParser(version='1.0')

-        self.assertPrintHelpExit(parser, '-h')

-        self.assertPrintHelpExit(parser, '--help')

-        self.assertPrintVersionExit(parser, '-v')

-        self.assertPrintVersionExit(parser, '--version')

-

-    def test_version_format(self):

-        parser = ErrorRaisingArgumentParser(prog='PPP', version='%(prog)s 3.5')

-        msg = self._get_error(parser.parse_args, ['-v']).stderr

-        self.assertEqual('PPP 3.5\n', msg)

-

-    def test_version_no_help(self):

-        parser = ErrorRaisingArgumentParser(add_help=False, version='1.0')

-        self.assertArgumentParserError(parser, '-h')

-        self.assertArgumentParserError(parser, '--help')

-        self.assertPrintVersionExit(parser, '-v')

-        self.assertPrintVersionExit(parser, '--version')

-

-    def test_version_action(self):

-        parser = ErrorRaisingArgumentParser(prog='XXX')

-        parser.add_argument('-V', action='version', version='%(prog)s 3.7')

-        msg = self._get_error(parser.parse_args, ['-V']).stderr

-        self.assertEqual('XXX 3.7\n', msg)

-

-    def test_no_help(self):

-        parser = ErrorRaisingArgumentParser(add_help=False)

-        self.assertArgumentParserError(parser, '-h')

-        self.assertArgumentParserError(parser, '--help')

-        self.assertArgumentParserError(parser, '-v')

-        self.assertArgumentParserError(parser, '--version')

-

-    def test_alternate_help_version(self):

-        parser = ErrorRaisingArgumentParser()

-        parser.add_argument('-x', action='help')

-        parser.add_argument('-y', action='version')

-        self.assertPrintHelpExit(parser, '-x')

-        self.assertPrintVersionExit(parser, '-y')

-        self.assertArgumentParserError(parser, '-v')

-        self.assertArgumentParserError(parser, '--version')

-

-    def test_help_version_extra_arguments(self):

-        parser = ErrorRaisingArgumentParser(version='1.0')

-        parser.add_argument('-x', action='store_true')

-        parser.add_argument('y')

-

-        # try all combinations of valid prefixes and suffixes

-        valid_prefixes = ['', '-x', 'foo', '-x bar', 'baz -x']

-        valid_suffixes = valid_prefixes + ['--bad-option', 'foo bar baz']

-        for prefix in valid_prefixes:

-            for suffix in valid_suffixes:

-                format = '%s %%s %s' % (prefix, suffix)

-            self.assertPrintHelpExit(parser, format % '-h')

-            self.assertPrintHelpExit(parser, format % '--help')

-            self.assertPrintVersionExit(parser, format % '-v')

-            self.assertPrintVersionExit(parser, format % '--version')

-

-

-# ======================

-# str() and repr() tests

-# ======================

-

-class TestStrings(TestCase):

-    """Test str()  and repr() on Optionals and Positionals"""

-

-    def assertStringEqual(self, obj, result_string):

-        for func in [str, repr]:

-            self.assertEqual(func(obj), result_string)

-

-    def test_optional(self):

-        option = argparse.Action(

-            option_strings=['--foo', '-a', '-b'],

-            dest='b',

-            type='int',

-            nargs='+',

-            default=42,

-            choices=[1, 2, 3],

-            help='HELP',

-            metavar='METAVAR')

-        string = (

-            "Action(option_strings=['--foo', '-a', '-b'], dest='b', "

-            "nargs='+', const=None, default=42, type='int', "

-            "choices=[1, 2, 3], help='HELP', metavar='METAVAR')")

-        self.assertStringEqual(option, string)

-

-    def test_argument(self):

-        argument = argparse.Action(

-            option_strings=[],

-            dest='x',

-            type=float,

-            nargs='?',

-            default=2.5,

-            choices=[0.5, 1.5, 2.5],

-            help='H HH H',

-            metavar='MV MV MV')

-        string = (

-            "Action(option_strings=[], dest='x', nargs='?', "

-            "const=None, default=2.5, type=%r, choices=[0.5, 1.5, 2.5], "

-            "help='H HH H', metavar='MV MV MV')" % float)

-        self.assertStringEqual(argument, string)

-

-    def test_namespace(self):

-        ns = argparse.Namespace(foo=42, bar='spam')

-        string = "Namespace(bar='spam', foo=42)"

-        self.assertStringEqual(ns, string)

-

-    def test_parser(self):

-        parser = argparse.ArgumentParser(prog='PROG')

-        string = (

-            "ArgumentParser(prog='PROG', usage=None, description=None, "

-            "version=None, formatter_class=%r, conflict_handler='error', "

-            "add_help=True)" % argparse.HelpFormatter)

-        self.assertStringEqual(parser, string)

-

-# ===============

-# Namespace tests

-# ===============

-

-class TestNamespace(TestCase):

-

-    def test_constructor(self):

-        ns = argparse.Namespace()

-        self.assertRaises(AttributeError, getattr, ns, 'x')

-

-        ns = argparse.Namespace(a=42, b='spam')

-        self.assertEqual(ns.a, 42)

-        self.assertEqual(ns.b, 'spam')

-

-    def test_equality(self):

-        ns1 = argparse.Namespace(a=1, b=2)

-        ns2 = argparse.Namespace(b=2, a=1)

-        ns3 = argparse.Namespace(a=1)

-        ns4 = argparse.Namespace(b=2)

-

-        self.assertEqual(ns1, ns2)

-        self.assertNotEqual(ns1, ns3)

-        self.assertNotEqual(ns1, ns4)

-        self.assertNotEqual(ns2, ns3)

-        self.assertNotEqual(ns2, ns4)

-        self.failUnless(ns1 != ns3)

-        self.failUnless(ns1 != ns4)

-        self.failUnless(ns2 != ns3)

-        self.failUnless(ns2 != ns4)

-

-

-# ===================

-# File encoding tests

-# ===================

-

-class TestEncoding(TestCase):

-

-    def _test_module_encoding(self, path):

-        path, _ = os.path.splitext(path)

-        path += ".py"

-        codecs.open(path, 'r', 'utf8').read()

-

-    def test_argparse_module_encoding(self):

-        self._test_module_encoding(argparse.__file__)

-

-    def test_test_argparse_module_encoding(self):

-        self._test_module_encoding(__file__)

-

-# ===================

-# ArgumentError tests

-# ===================

-

-class TestArgumentError(TestCase):

-

-    def test_argument_error(self):

-        msg = "my error here"

-        error = argparse.ArgumentError(None, msg)

-        self.failUnlessEqual(str(error), msg)

-

-# =======================

-# ArgumentTypeError tests

-# =======================

-

-class TestArgumentError(TestCase):

-

-    def test_argument_type_error(self):

-

-        def spam(string):

-            raise argparse.ArgumentTypeError('spam!')

-

-        parser = ErrorRaisingArgumentParser(prog='PROG', add_help=False)

-        parser.add_argument('x', type=spam)

-        try:

-            parser.parse_args(['XXX'])

-        except ArgumentParserError:

-            expected = 'usage: PROG x\nPROG: error: argument x: spam!\n'

-            msg = sys.exc_info()[1].stderr

-            self.failUnlessEqual(expected, msg)

-        else:

-            self.fail()

-

-# ======================

-# parse_known_args tests

-# ======================

-

-class TestParseKnownArgs(TestCase):

-

-    def test_optionals(self):

-        parser = argparse.ArgumentParser()

-        parser.add_argument('--foo')

-        args, extras = parser.parse_known_args('--foo F --bar --baz'.split())

-        self.failUnlessEqual(NS(foo='F'), args)

-        self.failUnlessEqual(['--bar', '--baz'], extras)

-

-    def test_mixed(self):

-        parser = argparse.ArgumentParser()

-        parser.add_argument('-v', nargs='?', const=1, type=int)

-        parser.add_argument('--spam', action='store_false')

-        parser.add_argument('badger')

-

-        argv = ["B", "C", "--foo", "-v", "3", "4"]

-        args, extras = parser.parse_known_args(argv)

-        self.failUnlessEqual(NS(v=3, spam=True, badger="B"), args)

-        self.failUnlessEqual(["C", "--foo", "4"], extras)

-

-# ============================

-# from argparse import * tests

-# ============================

-

-class TestImportStar(TestCase):

-

-    def test(self):

-        for name in argparse.__all__:

-            self.failUnless(hasattr(argparse, name))

-

-

-if __name__ == '__main__':

-    unittest.main()

+# -*- coding: utf-8 -*-
+
+# Copyright © 2006-2009 Steven J. Bethard <steven.bethard@gmail.com>.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy
+# of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+import codecs
+import os
+import shutil
+import sys
+import textwrap
+import tempfile
+import unittest
+import argparse
+
+try:
+    from StringIO import StringIO
+except ImportError:
+    from io import StringIO
+
+try:
+    set
+except NameError:
+    from sets import Set as set
+
+try:
+    sorted
+except NameError:
+
+    def sorted(iterable, reverse=False):
+        result = list(iterable)
+        result.sort()
+        if reverse:
+            result.reverse()
+        return result
+
+# silence Python 2.6 buggy warnings about Exception.message
+if sys.version_info[:2] == (2, 6):
+    import warnings
+    warnings.filterwarnings(
+        action='ignore',
+        message='BaseException.message has been deprecated as of Python 2.6',
+        category=DeprecationWarning)
+
+# silence warnings about version argument - these are expected
+import warnings
+warnings.filterwarnings(
+    action='ignore',
+    message='The "version" argument to ArgumentParser is deprecated.',
+    category=DeprecationWarning)
+warnings.filterwarnings(
+    action='ignore',
+    message='The format_version method is deprecated',
+    category=DeprecationWarning)
+warnings.filterwarnings(
+    action='ignore',
+    message='The print_version method is deprecated',
+    category=DeprecationWarning)
+
+
+class TestCase(unittest.TestCase):
+
+    def assertEqual(self, obj1, obj2):
+        if obj1 != obj2:
+            print('')
+            print(repr(obj1))
+            print(repr(obj2))
+            print(obj1)
+            print(obj2)
+        super(TestCase, self).assertEqual(obj1, obj2)
+
+
+class TempDirMixin(object):
+
+    def setUp(self):
+        self.temp_dir = tempfile.mkdtemp()
+        self.old_dir = os.getcwd()
+        os.chdir(self.temp_dir)
+
+    def tearDown(self):
+        os.chdir(self.old_dir)
+        while True:
+            try:
+                shutil.rmtree(self.temp_dir)
+            except WindowsError:
+                continue
+            else:
+                break
+
+
+class Sig(object):
+
+    def __init__(self, *args, **kwargs):
+        self.args = args
+        self.kwargs = kwargs
+
+
+class NS(object):
+
+    def __init__(self, **kwargs):
+        self.__dict__.update(kwargs)
+
+    def __repr__(self):
+        sorted_items = sorted(self.__dict__.items())
+        kwarg_str = ', '.join(['%s=%r' % tup for tup in sorted_items])
+        return '%s(%s)' % (type(self).__name__, kwarg_str)
+
+    def __eq__(self, other):
+        return vars(self) == vars(other)
+
+    def __ne__(self, other):
+        return not (self == other)
+
+
+class ArgumentParserError(Exception):
+
+    def __init__(self, message, stdout=None, stderr=None, error_code=None):
+        Exception.__init__(self, message, stdout, stderr)
+        self.message = message
+        self.stdout = stdout
+        self.stderr = stderr
+        self.error_code = error_code
+
+
+def stderr_to_parser_error(parse_args, *args, **kwargs):
+    # if this is being called recursively and stderr or stdout is already being
+    # redirected, simply call the function and let the enclosing function
+    # catch the exception
+    if isinstance(sys.stderr, StringIO) or isinstance(sys.stdout, StringIO):
+        return parse_args(*args, **kwargs)
+
+    # if this is not being called recursively, redirect stderr and
+    # use it as the ArgumentParserError message
+    old_stdout = sys.stdout
+    old_stderr = sys.stderr
+    sys.stdout = StringIO()
+    sys.stderr = StringIO()
+    try:
+        try:
+            result = parse_args(*args, **kwargs)
+            for key in list(vars(result)):
+                if getattr(result, key) is sys.stdout:
+                    setattr(result, key, old_stdout)
+                if getattr(result, key) is sys.stderr:
+                    setattr(result, key, old_stderr)
+            return result
+        except SystemExit:
+            code = sys.exc_info()[1].code
+            stdout = sys.stdout.getvalue()
+            stderr = sys.stderr.getvalue()
+            raise ArgumentParserError("SystemExit", stdout, stderr, code)
+    finally:
+        sys.stdout = old_stdout
+        sys.stderr = old_stderr
+
+
+class ErrorRaisingArgumentParser(argparse.ArgumentParser):
+
+    def parse_args(self, *args, **kwargs):
+        parse_args = super(ErrorRaisingArgumentParser, self).parse_args
+        return stderr_to_parser_error(parse_args, *args, **kwargs)
+
+    def exit(self, *args, **kwargs):
+        exit = super(ErrorRaisingArgumentParser, self).exit
+        return stderr_to_parser_error(exit, *args, **kwargs)
+
+    def error(self, *args, **kwargs):
+        error = super(ErrorRaisingArgumentParser, self).error
+        return stderr_to_parser_error(error, *args, **kwargs)
+
+
+class ParserTesterMetaclass(type):
+    """Adds parser tests using the class attributes.
+
+    Classes of this type should specify the following attributes:
+
+    argument_signatures -- a list of Sig objects which specify
+        the signatures of Argument objects to be created
+    failures -- a list of args lists that should cause the parser
+        to fail
+    successes -- a list of (initial_args, options, remaining_args) tuples
+        where initial_args specifies the string args to be parsed,
+        options is a dict that should match the vars() of the options
+        parsed out of initial_args, and remaining_args should be any
+        remaining unparsed arguments
+    """
+
+    def __init__(cls, name, bases, bodydict):
+        if name == 'ParserTestCase':
+            return
+
+        # default parser signature is empty
+        if not hasattr(cls, 'parser_signature'):
+            cls.parser_signature = Sig()
+        if not hasattr(cls, 'parser_class'):
+            cls.parser_class = ErrorRaisingArgumentParser
+
+        # ---------------------------------------
+        # functions for adding optional arguments
+        # ---------------------------------------
+        def no_groups(parser, argument_signatures):
+            """Add all arguments directly to the parser"""
+            for sig in argument_signatures:
+                parser.add_argument(*sig.args, **sig.kwargs)
+
+        def one_group(parser, argument_signatures):
+            """Add all arguments under a single group in the parser"""
+            group = parser.add_argument_group('foo')
+            for sig in argument_signatures:
+                group.add_argument(*sig.args, **sig.kwargs)
+
+        def many_groups(parser, argument_signatures):
+            """Add each argument in its own group to the parser"""
+            for i, sig in enumerate(argument_signatures):
+                group = parser.add_argument_group('foo:%i' % i)
+                group.add_argument(*sig.args, **sig.kwargs)
+
+        # --------------------------
+        # functions for parsing args
+        # --------------------------
+        def listargs(parser, args):
+            """Parse the args by passing in a list"""
+            return parser.parse_args(args)
+
+        def sysargs(parser, args):
+            """Parse the args by defaulting to sys.argv"""
+            old_sys_argv = sys.argv
+            sys.argv = [old_sys_argv[0]] + args
+            try:
+                return parser.parse_args()
+            finally:
+                sys.argv = old_sys_argv
+
+        # class that holds the combination of one optional argument
+        # addition method and one arg parsing method
+        class AddTests(object):
+
+            def __init__(self, tester_cls, add_arguments, parse_args):
+                self._add_arguments = add_arguments
+                self._parse_args = parse_args
+
+                add_arguments_name = self._add_arguments.__name__
+                parse_args_name = self._parse_args.__name__
+                for test_func in [self.test_failures, self.test_successes]:
+                    func_name = test_func.__name__
+                    names = func_name, add_arguments_name, parse_args_name
+                    test_name = '_'.join(names)
+
+                    def wrapper(self, test_func=test_func):
+                        test_func(self)
+                    try:
+                        wrapper.__name__ = test_name
+                    except TypeError:
+                        pass
+                    setattr(tester_cls, test_name, wrapper)
+
+            def _get_parser(self, tester):
+                args = tester.parser_signature.args
+                kwargs = tester.parser_signature.kwargs
+                parser = tester.parser_class(*args, **kwargs)
+                self._add_arguments(parser, tester.argument_signatures)
+                return parser
+
+            def test_failures(self, tester):
+                parser = self._get_parser(tester)
+                for args_str in tester.failures:
+                    args = args_str.split()
+                    raises = tester.assertRaises
+                    raises(ArgumentParserError, parser.parse_args, args)
+
+            def test_successes(self, tester):
+                parser = self._get_parser(tester)
+                for args, expected_ns in tester.successes:
+                    if isinstance(args, str):
+                        args = args.split()
+                    result_ns = self._parse_args(parser, args)
+                    tester.assertEqual(expected_ns, result_ns)
+
+        # add tests for each combination of an optionals adding method
+        # and an arg parsing method
+        for add_arguments in [no_groups, one_group, many_groups]:
+            for parse_args in [listargs, sysargs]:
+                AddTests(cls, add_arguments, parse_args)
+
+bases = TestCase,
+ParserTestCase = ParserTesterMetaclass('ParserTestCase', bases, {})
+
+# ===============
+# Optionals tests
+# ===============
+
+class TestOptionalsSingleDash(ParserTestCase):
+    """Test an Optional with a single-dash option string"""
+
+    argument_signatures = [Sig('-x')]
+    failures = ['-x', 'a', '--foo', '-x --foo', '-x -y']
+    successes = [
+        ('', NS(x=None)),
+        ('-x a', NS(x='a')),
+        ('-xa', NS(x='a')),
+        ('-x -1', NS(x='-1')),
+        ('-x-1', NS(x='-1')),
+    ]
+
+
+class TestOptionalsSingleDashCombined(ParserTestCase):
+    """Test an Optional with a single-dash option string"""
+
+    argument_signatures = [
+        Sig('-x', action='store_true'),
+        Sig('-yyy', action='store_const', const=42),
+        Sig('-z'),
+    ]
+    failures = ['a', '--foo', '-xa', '-x --foo', '-x -z', '-z -x',
+                '-yx', '-yz a', '-yyyx', '-yyyza', '-xyza']
+    successes = [
+        ('', NS(x=False, yyy=None, z=None)),
+        ('-x', NS(x=True, yyy=None, z=None)),
+        ('-za', NS(x=False, yyy=None, z='a')),
+        ('-z a', NS(x=False, yyy=None, z='a')),
+        ('-xza', NS(x=True, yyy=None, z='a')),
+        ('-xz a', NS(x=True, yyy=None, z='a')),
+        ('-x -za', NS(x=True, yyy=None, z='a')),
+        ('-x -z a', NS(x=True, yyy=None, z='a')),
+        ('-y', NS(x=False, yyy=42, z=None)),
+        ('-yyy', NS(x=False, yyy=42, z=None)),
+        ('-x -yyy -za', NS(x=True, yyy=42, z='a')),
+        ('-x -yyy -z a', NS(x=True, yyy=42, z='a')),
+    ]
+
+
+class TestOptionalsSingleDashLong(ParserTestCase):
+    """Test an Optional with a multi-character single-dash option string"""
+
+    argument_signatures = [Sig('-foo')]
+    failures = ['-foo', 'a', '--foo', '-foo --foo', '-foo -y', '-fooa']
+    successes = [
+        ('', NS(foo=None)),
+        ('-foo a', NS(foo='a')),
+        ('-foo -1', NS(foo='-1')),
+        ('-fo a', NS(foo='a')),
+        ('-f a', NS(foo='a')),
+    ]
+
+
+class TestOptionalsSingleDashSubsetAmbiguous(ParserTestCase):
+    """Test Optionals where option strings are subsets of each other"""
+
+    argument_signatures = [Sig('-f'), Sig('-foobar'), Sig('-foorab')]
+    failures = ['-f', '-foo', '-fo', '-foo b', '-foob', '-fooba', '-foora']
+    successes = [
+        ('', NS(f=None, foobar=None, foorab=None)),
+        ('-f a', NS(f='a', foobar=None, foorab=None)),
+        ('-fa', NS(f='a', foobar=None, foorab=None)),
+        ('-foa', NS(f='oa', foobar=None, foorab=None)),
+        ('-fooa', NS(f='ooa', foobar=None, foorab=None)),
+        ('-foobar a', NS(f=None, foobar='a', foorab=None)),
+        ('-foorab a', NS(f=None, foobar=None, foorab='a')),
+    ]
+
+
+class TestOptionalsSingleDashAmbiguous(ParserTestCase):
+    """Test Optionals that partially match but are not subsets"""
+
+    argument_signatures = [Sig('-foobar'), Sig('-foorab')]
+    failures = ['-f', '-f a', '-fa', '-foa', '-foo', '-fo', '-foo b']
+    successes = [
+        ('', NS(foobar=None, foorab=None)),
+        ('-foob a', NS(foobar='a', foorab=None)),
+        ('-foor a', NS(foobar=None, foorab='a')),
+        ('-fooba a', NS(foobar='a', foorab=None)),
+        ('-foora a', NS(foobar=None, foorab='a')),
+        ('-foobar a', NS(foobar='a', foorab=None)),
+        ('-foorab a', NS(foobar=None, foorab='a')),
+    ]
+
+
+class TestOptionalsNumeric(ParserTestCase):
+    """Test an Optional with a short opt string"""
+
+    argument_signatures = [Sig('-1', dest='one')]
+    failures = ['-1', 'a', '-1 --foo', '-1 -y', '-1 -1', '-1 -2']
+    successes = [
+        ('', NS(one=None)),
+        ('-1 a', NS(one='a')),
+        ('-1a', NS(one='a')),
+        ('-1-2', NS(one='-2')),
+    ]
+
+
+class TestOptionalsDoubleDash(ParserTestCase):
+    """Test an Optional with a double-dash option string"""
+
+    argument_signatures = [Sig('--foo')]
+    failures = ['--foo', '-f', '-f a', 'a', '--foo -x', '--foo --bar']
+    successes = [
+        ('', NS(foo=None)),
+        ('--foo a', NS(foo='a')),
+        ('--foo=a', NS(foo='a')),
+        ('--foo -2.5', NS(foo='-2.5')),
+        ('--foo=-2.5', NS(foo='-2.5')),
+    ]
+
+
+class TestOptionalsDoubleDashPartialMatch(ParserTestCase):
+    """Tests partial matching with a double-dash option string"""
+
+    argument_signatures = [
+        Sig('--badger', action='store_true'),
+        Sig('--bat'),
+    ]
+    failures = ['--bar', '--b', '--ba', '--b=2', '--ba=4', '--badge 5']
+    successes = [
+        ('', NS(badger=False, bat=None)),
+        ('--bat X', NS(badger=False, bat='X')),
+        ('--bad', NS(badger=True, bat=None)),
+        ('--badg', NS(badger=True, bat=None)),
+        ('--badge', NS(badger=True, bat=None)),
+        ('--badger', NS(badger=True, bat=None)),
+    ]
+
+
+class TestOptionalsDoubleDashPrefixMatch(ParserTestCase):
+    """Tests when one double-dash option string is a prefix of another"""
+
+    argument_signatures = [
+        Sig('--badger', action='store_true'),
+        Sig('--ba'),
+    ]
+    failures = ['--bar', '--b', '--ba', '--b=2', '--badge 5']
+    successes = [
+        ('', NS(badger=False, ba=None)),
+        ('--ba X', NS(badger=False, ba='X')),
+        ('--ba=X', NS(badger=False, ba='X')),
+        ('--bad', NS(badger=True, ba=None)),
+        ('--badg', NS(badger=True, ba=None)),
+        ('--badge', NS(badger=True, ba=None)),
+        ('--badger', NS(badger=True, ba=None)),
+    ]
+
+
+class TestOptionalsSingleDoubleDash(ParserTestCase):
+    """Test an Optional with single- and double-dash option strings"""
+
+    argument_signatures = [
+        Sig('-f', action='store_true'),
+        Sig('--bar'),
+        Sig('-baz', action='store_const', const=42),
+    ]
+    failures = ['--bar', '-fbar', '-fbaz', '-bazf', '-b B', 'B']
+    successes = [
+        ('', NS(f=False, bar=None, baz=None)),
+        ('-f', NS(f=True, bar=None, baz=None)),
+        ('--ba B', NS(f=False, bar='B', baz=None)),
+        ('-f --bar B', NS(f=True, bar='B', baz=None)),
+        ('-f -b', NS(f=True, bar=None, baz=42)),
+        ('-ba -f', NS(f=True, bar=None, baz=42)),
+    ]
+
+
+class TestOptionalsAlternatePrefixChars(ParserTestCase):
+    """Test an Optional with a double-dash option string"""
+
+    parser_signature = Sig(prefix_chars='+:/', add_help=False)
+    argument_signatures = [
+        Sig('+f', action='store_true'),
+        Sig('::bar'),
+        Sig('/baz', action='store_const', const=42),
+    ]
+    failures = ['--bar', '-fbar', '-b B', 'B', '-f', '--bar B', '-baz']
+    successes = [
+        ('', NS(f=False, bar=None, baz=None)),
+        ('+f', NS(f=True, bar=None, baz=None)),
+        ('::ba B', NS(f=False, bar='B', baz=None)),
+        ('+f ::bar B', NS(f=True, bar='B', baz=None)),
+        ('+f /b', NS(f=True, bar=None, baz=42)),
+        ('/ba +f', NS(f=True, bar=None, baz=42)),
+    ]
+
+
+class TestOptionalsShortLong(ParserTestCase):
+    """Test a combination of single- and double-dash option strings"""
+
+    argument_signatures = [
+        Sig('-v', '--verbose', '-n', '--noisy', action='store_true'),
+    ]
+    failures = ['--x --verbose', '-N', 'a', '-v x']
+    successes = [
+        ('', NS(verbose=False)),
+        ('-v', NS(verbose=True)),
+        ('--verbose', NS(verbose=True)),
+        ('-n', NS(verbose=True)),
+        ('--noisy', NS(verbose=True)),
+    ]
+
+
+class TestOptionalsDest(ParserTestCase):
+    """Tests various means of setting destination"""
+
+    argument_signatures = [Sig('--foo-bar'), Sig('--baz', dest='zabbaz')]
+    failures = ['a']
+    successes = [
+        ('--foo-bar f', NS(foo_bar='f', zabbaz=None)),
+        ('--baz g', NS(foo_bar=None, zabbaz='g')),
+        ('--foo-bar h --baz i', NS(foo_bar='h', zabbaz='i')),
+        ('--baz j --foo-bar k', NS(foo_bar='k', zabbaz='j')),
+    ]
+
+
+class TestOptionalsDefault(ParserTestCase):
+    """Tests specifying a default for an Optional"""
+
+    argument_signatures = [Sig('-x'), Sig('-y', default=42)]
+    failures = ['a']
+    successes = [
+        ('', NS(x=None, y=42)),
+        ('-xx', NS(x='x', y=42)),
+        ('-yy', NS(x=None, y='y')),
+    ]
+
+
+class TestOptionalsNargsDefault(ParserTestCase):
+    """Tests not specifying the number of args for an Optional"""
+
+    argument_signatures = [Sig('-x')]
+    failures = ['a', '-x']
+    successes = [
+        ('', NS(x=None)),
+        ('-x a', NS(x='a')),
+    ]
+
+
+class TestOptionalsNargs1(ParserTestCase):
+    """Tests specifying the 1 arg for an Optional"""
+
+    argument_signatures = [Sig('-x', nargs=1)]
+    failures = ['a', '-x']
+    successes = [
+        ('', NS(x=None)),
+        ('-x a', NS(x=['a'])),
+    ]
+
+
+class TestOptionalsNargs3(ParserTestCase):
+    """Tests specifying the 3 args for an Optional"""
+
+    argument_signatures = [Sig('-x', nargs=3)]
+    failures = ['a', '-x', '-x a', '-x a b', 'a -x', 'a -x b']
+    successes = [
+        ('', NS(x=None)),
+        ('-x a b c', NS(x=['a', 'b', 'c'])),
+    ]
+
+
+class TestOptionalsNargsOptional(ParserTestCase):
+    """Tests specifying an Optional arg for an Optional"""
+
+    argument_signatures = [
+        Sig('-w', nargs='?'),
+        Sig('-x', nargs='?', const=42),
+        Sig('-y', nargs='?', default='spam'),
+        Sig('-z', nargs='?', type=int, const='42', default='84'),
+    ]
+    failures = ['2']
+    successes = [
+        ('', NS(w=None, x=None, y='spam', z=84)),
+        ('-w', NS(w=None, x=None, y='spam', z=84)),
+        ('-w 2', NS(w='2', x=None, y='spam', z=84)),
+        ('-x', NS(w=None, x=42, y='spam', z=84)),
+        ('-x 2', NS(w=None, x='2', y='spam', z=84)),
+        ('-y', NS(w=None, x=None, y=None, z=84)),
+        ('-y 2', NS(w=None, x=None, y='2', z=84)),
+        ('-z', NS(w=None, x=None, y='spam', z=42)),
+        ('-z 2', NS(w=None, x=None, y='spam', z=2)),
+    ]
+
+
+class TestOptionalsNargsZeroOrMore(ParserTestCase):
+    """Tests specifying an args for an Optional that accepts zero or more"""
+
+    argument_signatures = [
+        Sig('-x', nargs='*'),
+        Sig('-y', nargs='*', default='spam'),
+    ]
+    failures = ['a']
+    successes = [
+        ('', NS(x=None, y='spam')),
+        ('-x', NS(x=[], y='spam')),
+        ('-x a', NS(x=['a'], y='spam')),
+        ('-x a b', NS(x=['a', 'b'], y='spam')),
+        ('-y', NS(x=None, y=[])),
+        ('-y a', NS(x=None, y=['a'])),
+        ('-y a b', NS(x=None, y=['a', 'b'])),
+    ]
+
+
+class TestOptionalsNargsOneOrMore(ParserTestCase):
+    """Tests specifying an args for an Optional that accepts one or more"""
+
+    argument_signatures = [
+        Sig('-x', nargs='+'),
+        Sig('-y', nargs='+', default='spam'),
+    ]
+    failures = ['a', '-x', '-y', 'a -x', 'a -y b']
+    successes = [
+        ('', NS(x=None, y='spam')),
+        ('-x a', NS(x=['a'], y='spam')),
+        ('-x a b', NS(x=['a', 'b'], y='spam')),
+        ('-y a', NS(x=None, y=['a'])),
+        ('-y a b', NS(x=None, y=['a', 'b'])),
+    ]
+
+
+class TestOptionalsChoices(ParserTestCase):
+    """Tests specifying the choices for an Optional"""
+
+    argument_signatures = [
+        Sig('-f', choices='abc'),
+        Sig('-g', type=int, choices=range(5))]
+    failures = ['a', '-f d', '-fad', '-ga', '-g 6']
+    successes = [
+        ('', NS(f=None, g=None)),
+        ('-f a', NS(f='a', g=None)),
+        ('-f c', NS(f='c', g=None)),
+        ('-g 0', NS(f=None, g=0)),
+        ('-g 03', NS(f=None, g=3)),
+        ('-fb -g4', NS(f='b', g=4)),
+    ]
+
+
+class TestOptionalsRequired(ParserTestCase):
+    """Tests the an optional action that is required"""
+
+    argument_signatures = [
+        Sig('-x', type=int, required=True),
+    ]
+    failures = ['a', '']
+    successes = [
+        ('-x 1', NS(x=1)),
+        ('-x42', NS(x=42)),
+    ]
+
+
+class TestOptionalsActionStore(ParserTestCase):
+    """Tests the store action for an Optional"""
+
+    argument_signatures = [Sig('-x', action='store')]
+    failures = ['a', 'a -x']
+    successes = [
+        ('', NS(x=None)),
+        ('-xfoo', NS(x='foo')),
+    ]
+
+
+class TestOptionalsActionStoreConst(ParserTestCase):
+    """Tests the store_const action for an Optional"""
+
+    argument_signatures = [Sig('-y', action='store_const', const=object)]
+    failures = ['a']
+    successes = [
+        ('', NS(y=None)),
+        ('-y', NS(y=object)),
+    ]
+
+
+class TestOptionalsActionStoreFalse(ParserTestCase):
+    """Tests the store_false action for an Optional"""
+
+    argument_signatures = [Sig('-z', action='store_false')]
+    failures = ['a', '-za', '-z a']
+    successes = [
+        ('', NS(z=True)),
+        ('-z', NS(z=False)),
+    ]
+
+
+class TestOptionalsActionStoreTrue(ParserTestCase):
+    """Tests the store_true action for an Optional"""
+
+    argument_signatures = [Sig('--apple', action='store_true')]
+    failures = ['a', '--apple=b', '--apple b']
+    successes = [
+        ('', NS(apple=False)),
+        ('--apple', NS(apple=True)),
+    ]
+
+
+class TestOptionalsActionAppend(ParserTestCase):
+    """Tests the append action for an Optional"""
+
+    argument_signatures = [Sig('--baz', action='append')]
+    failures = ['a', '--baz', 'a --baz', '--baz a b']
+    successes = [
+        ('', NS(baz=None)),
+        ('--baz a', NS(baz=['a'])),
+        ('--baz a --baz b', NS(baz=['a', 'b'])),
+    ]
+
+
+class TestOptionalsActionAppendWithDefault(ParserTestCase):
+    """Tests the append action for an Optional"""
+
+    argument_signatures = [Sig('--baz', action='append', default=['X'])]
+    failures = ['a', '--baz', 'a --baz', '--baz a b']
+    successes = [
+        ('', NS(baz=['X'])),
+        ('--baz a', NS(baz=['X', 'a'])),
+        ('--baz a --baz b', NS(baz=['X', 'a', 'b'])),
+    ]
+
+
+class TestOptionalsActionAppendConst(ParserTestCase):
+    """Tests the append_const action for an Optional"""
+
+    argument_signatures = [
+        Sig('-b', action='append_const', const=Exception),
+        Sig('-c', action='append', dest='b'),
+    ]
+    failures = ['a', '-c', 'a -c', '-bx', '-b x']
+    successes = [
+        ('', NS(b=None)),
+        ('-b', NS(b=[Exception])),
+        ('-b -cx -b -cyz', NS(b=[Exception, 'x', Exception, 'yz'])),
+    ]
+
+
+class TestOptionalsActionAppendConstWithDefault(ParserTestCase):
+    """Tests the append_const action for an Optional"""
+
+    argument_signatures = [
+        Sig('-b', action='append_const', const=Exception, default=['X']),
+        Sig('-c', action='append', dest='b'),
+    ]
+    failures = ['a', '-c', 'a -c', '-bx', '-b x']
+    successes = [
+        ('', NS(b=['X'])),
+        ('-b', NS(b=['X', Exception])),
+        ('-b -cx -b -cyz', NS(b=['X', Exception, 'x', Exception, 'yz'])),
+    ]
+
+
+class TestOptionalsActionCount(ParserTestCase):
+    """Tests the count action for an Optional"""
+
+    argument_signatures = [Sig('-x', action='count')]
+    failures = ['a', '-x a', '-x b', '-x a -x b']
+    successes = [
+        ('', NS(x=None)),
+        ('-x', NS(x=1)),
+    ]
+
+
+# ================
+# Positional tests
+# ================
+
+class TestPositionalsNargsNone(ParserTestCase):
+    """Test a Positional that doesn't specify nargs"""
+
+    argument_signatures = [Sig('foo')]
+    failures = ['', '-x', 'a b']
+    successes = [
+        ('a', NS(foo='a')),
+    ]
+
+
+class TestPositionalsNargs1(ParserTestCase):
+    """Test a Positional that specifies an nargs of 1"""
+
+    argument_signatures = [Sig('foo', nargs=1)]
+    failures = ['', '-x', 'a b']
+    successes = [
+        ('a', NS(foo=['a'])),
+    ]
+
+
+class TestPositionalsNargs2(ParserTestCase):
+    """Test a Positional that specifies an nargs of 2"""
+
+    argument_signatures = [Sig('foo', nargs=2)]
+    failures = ['', 'a', '-x', 'a b c']
+    successes = [
+        ('a b', NS(foo=['a', 'b'])),
+    ]
+
+
+class TestPositionalsNargsZeroOrMore(ParserTestCase):
+    """Test a Positional that specifies unlimited nargs"""
+
+    argument_signatures = [Sig('foo', nargs='*')]
+    failures = ['-x']
+    successes = [
+        ('', NS(foo=[])),
+        ('a', NS(foo=['a'])),
+        ('a b', NS(foo=['a', 'b'])),
+    ]
+
+
+class TestPositionalsNargsZeroOrMoreDefault(ParserTestCase):
+    """Test a Positional that specifies unlimited nargs and a default"""
+
+    argument_signatures = [Sig('foo', nargs='*', default='bar')]
+    failures = ['-x']
+    successes = [
+        ('', NS(foo='bar')),
+        ('a', NS(foo=['a'])),
+        ('a b', NS(foo=['a', 'b'])),
+    ]
+
+
+class TestPositionalsNargsOneOrMore(ParserTestCase):
+    """Test a Positional that specifies one or more nargs"""
+
+    argument_signatures = [Sig('foo', nargs='+')]
+    failures = ['', '-x']
+    successes = [
+        ('a', NS(foo=['a'])),
+        ('a b', NS(foo=['a', 'b'])),
+    ]
+
+
+class TestPositionalsNargsOptional(ParserTestCase):
+    """Tests an Optional Positional"""
+
+    argument_signatures = [Sig('foo', nargs='?')]
+    failures = ['-x', 'a b']
+    successes = [
+        ('', NS(foo=None)),
+        ('a', NS(foo='a')),
+    ]
+
+
+class TestPositionalsNargsOptionalDefault(ParserTestCase):
+    """Tests an Optional Positional with a default value"""
+
+    argument_signatures = [Sig('foo', nargs='?', default=42)]
+    failures = ['-x', 'a b']
+    successes = [
+        ('', NS(foo=42)),
+        ('a', NS(foo='a')),
+    ]
+
+
+class TestPositionalsNargsOptionalConvertedDefault(ParserTestCase):
+    """Tests an Optional Positional with a default value
+    that needs to be converted to the appropriate type.
+    """
+
+    argument_signatures = [
+        Sig('foo', nargs='?', type=int, default='42'),
+    ]
+    failures = ['-x', 'a b', '1 2']
+    successes = [
+        ('', NS(foo=42)),
+        ('1', NS(foo=1)),
+    ]
+
+
+class TestPositionalsNargsNoneNone(ParserTestCase):
+    """Test two Positionals that don't specify nargs"""
+
+    argument_signatures = [Sig('foo'), Sig('bar')]
+    failures = ['', '-x', 'a', 'a b c']
+    successes = [
+        ('a b', NS(foo='a', bar='b')),
+    ]
+
+
+class TestPositionalsNargsNone1(ParserTestCase):
+    """Test a Positional with no nargs followed by one with 1"""
+
+    argument_signatures = [Sig('foo'), Sig('bar', nargs=1)]
+    failures = ['', '--foo', 'a', 'a b c']
+    successes = [
+        ('a b', NS(foo='a', bar=['b'])),
+    ]
+
+
+class TestPositionalsNargs2None(ParserTestCase):
+    """Test a Positional with 2 nargs followed by one with none"""
+
+    argument_signatures = [Sig('foo', nargs=2), Sig('bar')]
+    failures = ['', '--foo', 'a', 'a b', 'a b c d']
+    successes = [
+        ('a b c', NS(foo=['a', 'b'], bar='c')),
+    ]
+
+
+class TestPositionalsNargsNoneZeroOrMore(ParserTestCase):
+    """Test a Positional with no nargs followed by one with unlimited"""
+
+    argument_signatures = [Sig('foo'), Sig('bar', nargs='*')]
+    failures = ['', '--foo']
+    successes = [
+        ('a', NS(foo='a', bar=[])),
+        ('a b', NS(foo='a', bar=['b'])),
+        ('a b c', NS(foo='a', bar=['b', 'c'])),
+    ]
+
+
+class TestPositionalsNargsNoneOneOrMore(ParserTestCase):
+    """Test a Positional with no nargs followed by one with one or more"""
+
+    argument_signatures = [Sig('foo'), Sig('bar', nargs='+')]
+    failures = ['', '--foo', 'a']
+    successes = [
+        ('a b', NS(foo='a', bar=['b'])),
+        ('a b c', NS(foo='a', bar=['b', 'c'])),
+    ]
+
+
+class TestPositionalsNargsNoneOptional(ParserTestCase):
+    """Test a Positional with no nargs followed by one with an Optional"""
+
+    argument_signatures = [Sig('foo'), Sig('bar', nargs='?')]
+    failures = ['', '--foo', 'a b c']
+    successes = [
+        ('a', NS(foo='a', bar=None)),
+        ('a b', NS(foo='a', bar='b')),
+    ]
+
+
+class TestPositionalsNargsZeroOrMoreNone(ParserTestCase):
+    """Test a Positional with unlimited nargs followed by one with none"""
+
+    argument_signatures = [Sig('foo', nargs='*'), Sig('bar')]
+    failures = ['', '--foo']
+    successes = [
+        ('a', NS(foo=[], bar='a')),
+        ('a b', NS(foo=['a'], bar='b')),
+        ('a b c', NS(foo=['a', 'b'], bar='c')),
+    ]
+
+
+class TestPositionalsNargsOneOrMoreNone(ParserTestCase):
+    """Test a Positional with one or more nargs followed by one with none"""
+
+    argument_signatures = [Sig('foo', nargs='+'), Sig('bar')]
+    failures = ['', '--foo', 'a']
+    successes = [
+        ('a b', NS(foo=['a'], bar='b')),
+        ('a b c', NS(foo=['a', 'b'], bar='c')),
+    ]
+
+
+class TestPositionalsNargsOptionalNone(ParserTestCase):
+    """Test a Positional with an Optional nargs followed by one with none"""
+
+    argument_signatures = [Sig('foo', nargs='?', default=42), Sig('bar')]
+    failures = ['', '--foo', 'a b c']
+    successes = [
+        ('a', NS(foo=42, bar='a')),
+        ('a b', NS(foo='a', bar='b')),
+    ]
+
+
+class TestPositionalsNargs2ZeroOrMore(ParserTestCase):
+    """Test a Positional with 2 nargs followed by one with unlimited"""
+
+    argument_signatures = [Sig('foo', nargs=2), Sig('bar', nargs='*')]
+    failures = ['', '--foo', 'a']
+    successes = [
+        ('a b', NS(foo=['a', 'b'], bar=[])),
+        ('a b c', NS(foo=['a', 'b'], bar=['c'])),
+    ]
+
+
+class TestPositionalsNargs2OneOrMore(ParserTestCase):
+    """Test a Positional with 2 nargs followed by one with one or more"""
+
+    argument_signatures = [Sig('foo', nargs=2), Sig('bar', nargs='+')]
+    failures = ['', '--foo', 'a', 'a b']
+    successes = [
+        ('a b c', NS(foo=['a', 'b'], bar=['c'])),
+    ]
+
+
+class TestPositionalsNargs2Optional(ParserTestCase):
+    """Test a Positional with 2 nargs followed by one optional"""
+
+    argument_signatures = [Sig('foo', nargs=2), Sig('bar', nargs='?')]
+    failures = ['', '--foo', 'a', 'a b c d']
+    successes = [
+        ('a b', NS(foo=['a', 'b'], bar=None)),
+        ('a b c', NS(foo=['a', 'b'], bar='c')),
+    ]
+
+
+class TestPositionalsNargsZeroOrMore1(ParserTestCase):
+    """Test a Positional with unlimited nargs followed by one with 1"""
+
+    argument_signatures = [Sig('foo', nargs='*'), Sig('bar', nargs=1)]
+    failures = ['', '--foo', ]
+    successes = [
+        ('a', NS(foo=[], bar=['a'])),
+        ('a b', NS(foo=['a'], bar=['b'])),
+        ('a b c', NS(foo=['a', 'b'], bar=['c'])),
+    ]
+
+
+class TestPositionalsNargsOneOrMore1(ParserTestCase):
+    """Test a Positional with one or more nargs followed by one with 1"""
+
+    argument_signatures = [Sig('foo', nargs='+'), Sig('bar', nargs=1)]
+    failures = ['', '--foo', 'a']
+    successes = [
+        ('a b', NS(foo=['a'], bar=['b'])),
+        ('a b c', NS(foo=['a', 'b'], bar=['c'])),
+    ]
+
+
+class TestPositionalsNargsOptional1(ParserTestCase):
+    """Test a Positional with an Optional nargs followed by one with 1"""
+
+    argument_signatures = [Sig('foo', nargs='?'), Sig('bar', nargs=1)]
+    failures = ['', '--foo', 'a b c']
+    successes = [
+        ('a', NS(foo=None, bar=['a'])),
+        ('a b', NS(foo='a', bar=['b'])),
+    ]
+
+
+class TestPositionalsNargsNoneZeroOrMore1(ParserTestCase):
+    """Test three Positionals: no nargs, unlimited nargs and 1 nargs"""
+
+    argument_signatures = [
+        Sig('foo'),
+        Sig('bar', nargs='*'),
+        Sig('baz', nargs=1),
+    ]
+    failures = ['', '--foo', 'a']
+    successes = [
+        ('a b', NS(foo='a', bar=[], baz=['b'])),
+        ('a b c', NS(foo='a', bar=['b'], baz=['c'])),
+    ]
+
+
+class TestPositionalsNargsNoneOneOrMore1(ParserTestCase):
+    """Test three Positionals: no nargs, one or more nargs and 1 nargs"""
+
+    argument_signatures = [
+        Sig('foo'),
+        Sig('bar', nargs='+'),
+        Sig('baz', nargs=1),
+    ]
+    failures = ['', '--foo', 'a', 'b']
+    successes = [
+        ('a b c', NS(foo='a', bar=['b'], baz=['c'])),
+        ('a b c d', NS(foo='a', bar=['b', 'c'], baz=['d'])),
+    ]
+
+
+class TestPositionalsNargsNoneOptional1(ParserTestCase):
+    """Test three Positionals: no nargs, optional narg and 1 nargs"""
+
+    argument_signatures = [
+        Sig('foo'),
+        Sig('bar', nargs='?', default=0.625),
+        Sig('baz', nargs=1),
+    ]
+    failures = ['', '--foo', 'a']
+    successes = [
+        ('a b', NS(foo='a', bar=0.625, baz=['b'])),
+        ('a b c', NS(foo='a', bar='b', baz=['c'])),
+    ]
+
+
+class TestPositionalsNargsOptionalOptional(ParserTestCase):
+    """Test two optional nargs"""
+
+    argument_signatures = [
+        Sig('foo', nargs='?'),
+        Sig('bar', nargs='?', default=42),
+    ]
+    failures = ['--foo', 'a b c']
+    successes = [
+        ('', NS(foo=None, bar=42)),
+        ('a', NS(foo='a', bar=42)),
+        ('a b', NS(foo='a', bar='b')),
+    ]
+
+
+class TestPositionalsNargsOptionalZeroOrMore(ParserTestCase):
+    """Test an Optional narg followed by unlimited nargs"""
+
+    argument_signatures = [Sig('foo', nargs='?'), Sig('bar', nargs='*')]
+    failures = ['--foo']
+    successes = [
+        ('', NS(foo=None, bar=[])),
+        ('a', NS(foo='a', bar=[])),
+        ('a b', NS(foo='a', bar=['b'])),
+        ('a b c', NS(foo='a', bar=['b', 'c'])),
+    ]
+
+
+class TestPositionalsNargsOptionalOneOrMore(ParserTestCase):
+    """Test an Optional narg followed by one or more nargs"""
+
+    argument_signatures = [Sig('foo', nargs='?'), Sig('bar', nargs='+')]
+    failures = ['', '--foo']
+    successes = [
+        ('a', NS(foo=None, bar=['a'])),
+        ('a b', NS(foo='a', bar=['b'])),
+        ('a b c', NS(foo='a', bar=['b', 'c'])),
+    ]
+
+
+class TestPositionalsChoicesString(ParserTestCase):
+    """Test a set of single-character choices"""
+
+    argument_signatures = [Sig('spam', choices=set('abcdefg'))]
+    failures = ['', '--foo', 'h', '42', 'ef']
+    successes = [
+        ('a', NS(spam='a')),
+        ('g', NS(spam='g')),
+    ]
+
+
+class TestPositionalsChoicesInt(ParserTestCase):
+    """Test a set of integer choices"""
+
+    argument_signatures = [Sig('spam', type=int, choices=range(20))]
+    failures = ['', '--foo', 'h', '42', 'ef']
+    successes = [
+        ('4', NS(spam=4)),
+        ('15', NS(spam=15)),
+    ]
+
+
+class TestPositionalsActionAppend(ParserTestCase):
+    """Test the 'append' action"""
+
+    argument_signatures = [
+        Sig('spam', action='append'),
+        Sig('spam', action='append', nargs=2),
+    ]
+    failures = ['', '--foo', 'a', 'a b', 'a b c d']
+    successes = [
+        ('a b c', NS(spam=['a', ['b', 'c']])),
+    ]
+
+# ========================================
+# Combined optionals and positionals tests
+# ========================================
+
+class TestOptionalsNumericAndPositionals(ParserTestCase):
+    """Tests negative number args when numeric options are present"""
+
+    argument_signatures = [
+        Sig('x', nargs='?'),
+        Sig('-4', dest='y', action='store_true'),
+    ]
+    failures = ['-2', '-315']
+    successes = [
+        ('', NS(x=None, y=False)),
+        ('a', NS(x='a', y=False)),
+        ('-4', NS(x=None, y=True)),
+        ('-4 a', NS(x='a', y=True)),
+    ]
+
+
+class TestOptionalsAlmostNumericAndPositionals(ParserTestCase):
+    """Tests negative number args when almost numeric options are present"""
+
+    argument_signatures = [
+        Sig('x', nargs='?'),
+        Sig('-k4', dest='y', action='store_true'),
+    ]
+    failures = ['-k3']
+    successes = [
+        ('', NS(x=None, y=False)),
+        ('-2', NS(x='-2', y=False)),
+        ('a', NS(x='a', y=False)),
+        ('-k4', NS(x=None, y=True)),
+        ('-k4 a', NS(x='a', y=True)),
+    ]
+
+
+class TestEmptyAndSpaceContainingArguments(ParserTestCase):
+
+    argument_signatures = [
+        Sig('x', nargs='?'),
+        Sig('-y', '--yyy', dest='y'),
+    ]
+    failures = ['-y']
+    successes = [
+        ([''], NS(x='', y=None)),
+        (['a badger'], NS(x='a badger', y=None)),
+        (['-a badger'], NS(x='-a badger', y=None)),
+        (['-y', ''], NS(x=None, y='')),
+        (['-y', 'a badger'], NS(x=None, y='a badger')),
+        (['-y', '-a badger'], NS(x=None, y='-a badger')),
+        (['--yyy=a badger'], NS(x=None, y='a badger')),
+        (['--yyy=-a badger'], NS(x=None, y='-a badger')),
+    ]
+
+
+class TestPrefixCharacterOnlyArguments(ParserTestCase):
+
+    parser_signature = Sig(prefix_chars='-+')
+    argument_signatures = [
+        Sig('-', dest='x', nargs='?', const='badger'),
+        Sig('+', dest='y', type=int, default=42),
+        Sig('-+-', dest='z', action='store_true'),
+    ]
+    failures = ['-y', '+ -']
+    successes = [
+        ('', NS(x=None, y=42, z=False)),
+        ('-', NS(x='badger', y=42, z=False)),
+        ('- X', NS(x='X', y=42, z=False)),
+        ('+ -3', NS(x=None, y=-3, z=False)),
+        ('-+-', NS(x=None, y=42, z=True)),
+        ('- ===', NS(x='===', y=42, z=False)),
+    ]
+
+
+class TestNargsZeroOrMore(ParserTestCase):
+    """Tests specifying an args for an Optional that accepts zero or more"""
+
+    argument_signatures = [Sig('-x', nargs='*'), Sig('y', nargs='*')]
+    failures = []
+    successes = [
+        ('', NS(x=None, y=[])),
+        ('-x', NS(x=[], y=[])),
+        ('-x a', NS(x=['a'], y=[])),
+        ('-x a -- b', NS(x=['a'], y=['b'])),
+        ('a', NS(x=None, y=['a'])),
+        ('a -x', NS(x=[], y=['a'])),
+        ('a -x b', NS(x=['b'], y=['a'])),
+    ]
+
+
+class TestNargsRemainder(ParserTestCase):
+    """Tests specifying a positional with nargs=REMAINDER"""
+
+    argument_signatures = [Sig('x'), Sig('y', nargs='...'), Sig('-z')]
+    failures = ['', '-z', '-z Z']
+    successes = [
+        ('X', NS(x='X', y=[], z=None)),
+        ('-z Z X', NS(x='X', y=[], z='Z')),
+        ('X A B -z Z', NS(x='X', y=['A', 'B', '-z', 'Z'], z=None)),
+        ('X Y --foo', NS(x='X', y=['Y', '--foo'], z=None)),
+    ]
+
+
+class TestOptionLike(ParserTestCase):
+    """Tests options that may or may not be arguments"""
+
+    argument_signatures = [
+        Sig('-x', type=float),
+        Sig('-3', type=float, dest='y'),
+        Sig('z', nargs='*'),
+    ]
+    failures = ['-x', '-y2.5', '-xa', '-x -a',
+                '-x -3', '-x -3.5', '-3 -3.5',
+                '-x -2.5', '-x -2.5 a', '-3 -.5',
+                'a x -1', '-x -1 a', '-3 -1 a']
+    successes = [
+        ('', NS(x=None, y=None, z=[])),
+        ('-x 2.5', NS(x=2.5, y=None, z=[])),
+        ('-x 2.5 a', NS(x=2.5, y=None, z=['a'])),
+        ('-3.5', NS(x=None, y=0.5, z=[])),
+        ('-3-.5', NS(x=None, y=-0.5, z=[])),
+        ('-3 .5', NS(x=None, y=0.5, z=[])),
+        ('a -3.5', NS(x=None, y=0.5, z=['a'])),
+        ('a', NS(x=None, y=None, z=['a'])),
+        ('a -x 1', NS(x=1.0, y=None, z=['a'])),
+        ('-x 1 a', NS(x=1.0, y=None, z=['a'])),
+        ('-3 1 a', NS(x=None, y=1.0, z=['a'])),
+    ]
+
+
+class TestDefaultSuppress(ParserTestCase):
+    """Test actions with suppressed defaults"""
+
+    argument_signatures = [
+        Sig('foo', nargs='?', default=argparse.SUPPRESS),
+        Sig('bar', nargs='*', default=argparse.SUPPRESS),
+        Sig('--baz', action='store_true', default=argparse.SUPPRESS),
+    ]
+    failures = ['-x']
+    successes = [
+        ('', NS()),
+        ('a', NS(foo='a')),
+        ('a b', NS(foo='a', bar=['b'])),
+        ('--baz', NS(baz=True)),
+        ('a --baz', NS(foo='a', baz=True)),
+        ('--baz a b', NS(foo='a', bar=['b'], baz=True)),
+    ]
+
+
+class TestParserDefaultSuppress(ParserTestCase):
+    """Test actions with a parser-level default of SUPPRESS"""
+
+    parser_signature = Sig(argument_default=argparse.SUPPRESS)
+    argument_signatures = [
+        Sig('foo', nargs='?'),
+        Sig('bar', nargs='*'),
+        Sig('--baz', action='store_true'),
+    ]
+    failures = ['-x']
+    successes = [
+        ('', NS()),
+        ('a', NS(foo='a')),
+        ('a b', NS(foo='a', bar=['b'])),
+        ('--baz', NS(baz=True)),
+        ('a --baz', NS(foo='a', baz=True)),
+        ('--baz a b', NS(foo='a', bar=['b'], baz=True)),
+    ]
+
+
+class TestParserDefault42(ParserTestCase):
+    """Test actions with a parser-level default of 42"""
+
+    parser_signature = Sig(argument_default=42, version='1.0')
+    argument_signatures = [
+        Sig('foo', nargs='?'),
+        Sig('bar', nargs='*'),
+        Sig('--baz', action='store_true'),
+    ]
+    failures = ['-x']
+    successes = [
+        ('', NS(foo=42, bar=42, baz=42)),
+        ('a', NS(foo='a', bar=42, baz=42)),
+        ('a b', NS(foo='a', bar=['b'], baz=42)),
+        ('--baz', NS(foo=42, bar=42, baz=True)),
+        ('a --baz', NS(foo='a', bar=42, baz=True)),
+        ('--baz a b', NS(foo='a', bar=['b'], baz=True)),
+    ]
+
+
+class TestArgumentsFromFile(TempDirMixin, ParserTestCase):
+    """Test reading arguments from a file"""
+
+    def setUp(self):
+        super(TestArgumentsFromFile, self).setUp()
+        file_texts = [
+            ('hello', 'hello world!\n'),
+            ('recursive', '-a\n'
+                          'A\n'
+                          '@hello'),
+            ('invalid', '@no-such-path\n'),
+        ]
+        for path, text in file_texts:
+            file = open(path, 'w')
+            file.write(text)
+            file.close()
+
+    parser_signature = Sig(fromfile_prefix_chars='@')
+    argument_signatures = [
+        Sig('-a'),
+        Sig('x'),
+        Sig('y', nargs='+'),
+    ]
+    failures = ['', '-b', 'X', '@invalid', '@missing']
+    successes = [
+        ('X Y', NS(a=None, x='X', y=['Y'])),
+        ('X -a A Y Z', NS(a='A', x='X', y=['Y', 'Z'])),
+        ('@hello X', NS(a=None, x='hello world!', y=['X'])),
+        ('X @hello', NS(a=None, x='X', y=['hello world!'])),
+        ('-a B @recursive Y Z', NS(a='A', x='hello world!', y=['Y', 'Z'])),
+        ('X @recursive Z -a B', NS(a='B', x='X', y=['hello world!', 'Z'])),
+    ]
+
+
+class TestArgumentsFromFileConverter(TempDirMixin, ParserTestCase):
+    """Test reading arguments from a file"""
+
+    def setUp(self):
+        super(TestArgumentsFromFileConverter, self).setUp()
+        file_texts = [
+            ('hello', 'hello world!\n'),
+        ]
+        for path, text in file_texts:
+            file = open(path, 'w')
+            file.write(text)
+            file.close()
+
+    class FromFileConverterArgumentParser(ErrorRaisingArgumentParser):
+
+        def convert_arg_line_to_args(self, arg_line):
+            for arg in arg_line.split():
+                if not arg.strip():
+                    continue
+                yield arg
+    parser_class = FromFileConverterArgumentParser
+    parser_signature = Sig(fromfile_prefix_chars='@')
+    argument_signatures = [
+        Sig('y', nargs='+'),
+    ]
+    failures = []
+    successes = [
+        ('@hello X', NS(y=['hello', 'world!', 'X'])),
+    ]
+
+
+# =====================
+# Type conversion tests
+# =====================
+
+class TestFileTypeRepr(TestCase):
+
+    def test_r(self):
+        type = argparse.FileType('r')
+        self.assertEqual("FileType('r')", repr(type))
+
+    def test_wb_1(self):
+        type = argparse.FileType('wb', 1)
+        self.assertEqual("FileType('wb', 1)", repr(type))
+
+
+class RFile(object):
+    seen = {}
+
+    def __init__(self, name):
+        self.name = name
+
+    def __eq__(self, other):
+        if other in self.seen:
+            text = self.seen[other]
+        else:
+            text = self.seen[other] = other.read()
+            other.close()
+        if not isinstance(text, str):
+            text = text.decode('ascii')
+        return self.name == other.name == text
+
+
+class TestFileTypeR(TempDirMixin, ParserTestCase):
+    """Test the FileType option/argument type for reading files"""
+
+    def setUp(self):
+        super(TestFileTypeR, self).setUp()
+        for file_name in ['foo', 'bar']:
+            file = open(os.path.join(self.temp_dir, file_name), 'w')
+            file.write(file_name)
+            file.close()
+
+    argument_signatures = [
+        Sig('-x', type=argparse.FileType()),
+        Sig('spam', type=argparse.FileType('r')),
+    ]
+    failures = ['-x', '-x bar']
+    successes = [
+        ('foo', NS(x=None, spam=RFile('foo'))),
+        ('-x foo bar', NS(x=RFile('foo'), spam=RFile('bar'))),
+        ('bar -x foo', NS(x=RFile('foo'), spam=RFile('bar'))),
+        ('-x - -', NS(x=sys.stdin, spam=sys.stdin)),
+    ]
+
+
+class TestFileTypeRB(TempDirMixin, ParserTestCase):
+    """Test the FileType option/argument type for reading files"""
+
+    def setUp(self):
+        super(TestFileTypeRB, self).setUp()
+        for file_name in ['foo', 'bar']:
+            file = open(os.path.join(self.temp_dir, file_name), 'w')
+            file.write(file_name)
+            file.close()
+
+    argument_signatures = [
+        Sig('-x', type=argparse.FileType('rb')),
+        Sig('spam', type=argparse.FileType('rb')),
+    ]
+    failures = ['-x', '-x bar']
+    successes = [
+        ('foo', NS(x=None, spam=RFile('foo'))),
+        ('-x foo bar', NS(x=RFile('foo'), spam=RFile('bar'))),
+        ('bar -x foo', NS(x=RFile('foo'), spam=RFile('bar'))),
+        ('-x - -', NS(x=sys.stdin, spam=sys.stdin)),
+    ]
+
+
+class WFile(object):
+    seen = set()
+
+    def __init__(self, name):
+        self.name = name
+
+    def __eq__(self, other):
+        if other not in self.seen:
+            text = 'Check that file is writable.'
+            if 'b' in other.mode:
+                text = text.encode('ascii')
+            other.write(text)
+            other.close()
+            self.seen.add(other)
+        return self.name == other.name
+
+
+class TestFileTypeW(TempDirMixin, ParserTestCase):
+    """Test the FileType option/argument type for writing files"""
+
+    argument_signatures = [
+        Sig('-x', type=argparse.FileType('w')),
+        Sig('spam', type=argparse.FileType('w')),
+    ]
+    failures = ['-x', '-x bar']
+    successes = [
+        ('foo', NS(x=None, spam=WFile('foo'))),
+        ('-x foo bar', NS(x=WFile('foo'), spam=WFile('bar'))),
+        ('bar -x foo', NS(x=WFile('foo'), spam=WFile('bar'))),
+        ('-x - -', NS(x=sys.stdout, spam=sys.stdout)),
+    ]
+
+
+class TestFileTypeWB(TempDirMixin, ParserTestCase):
+
+    argument_signatures = [
+        Sig('-x', type=argparse.FileType('wb')),
+        Sig('spam', type=argparse.FileType('wb')),
+    ]
+    failures = ['-x', '-x bar']
+    successes = [
+        ('foo', NS(x=None, spam=WFile('foo'))),
+        ('-x foo bar', NS(x=WFile('foo'), spam=WFile('bar'))),
+        ('bar -x foo', NS(x=WFile('foo'), spam=WFile('bar'))),
+        ('-x - -', NS(x=sys.stdout, spam=sys.stdout)),
+    ]
+
+
+class TestTypeCallable(ParserTestCase):
+    """Test some callables as option/argument types"""
+
+    argument_signatures = [
+        Sig('--eggs', type=complex),
+        Sig('spam', type=float),
+    ]
+    failures = ['a', '42j', '--eggs a', '--eggs 2i']
+    successes = [
+        ('--eggs=42 42', NS(eggs=42, spam=42.0)),
+        ('--eggs 2j -- -1.5', NS(eggs=2j, spam=-1.5)),
+        ('1024.675', NS(eggs=None, spam=1024.675)),
+    ]
+
+
+class TestTypeUserDefined(ParserTestCase):
+    """Test a user-defined option/argument type"""
+
+    class MyType(TestCase):
+
+        def __init__(self, value):
+            self.value = value
+
+        def __eq__(self, other):
+            return (type(self), self.value) == (type(other), other.value)
+
+    argument_signatures = [
+        Sig('-x', type=MyType),
+        Sig('spam', type=MyType),
+    ]
+    failures = []
+    successes = [
+        ('a -x b', NS(x=MyType('b'), spam=MyType('a'))),
+        ('-xf g', NS(x=MyType('f'), spam=MyType('g'))),
+    ]
+
+
+class TestTypeClassicClass(ParserTestCase):
+    """Test a classic class type"""
+
+    class C:
+
+        def __init__(self, value):
+            self.value = value
+
+        def __eq__(self, other):
+            return (type(self), self.value) == (type(other), other.value)
+
+    argument_signatures = [
+        Sig('-x', type=C),
+        Sig('spam', type=C),
+    ]
+    failures = []
+    successes = [
+        ('a -x b', NS(x=C('b'), spam=C('a'))),
+        ('-xf g', NS(x=C('f'), spam=C('g'))),
+    ]
+
+
+class TestTypeRegistration(TestCase):
+    """Test a user-defined type by registering it"""
+
+    def test(self):
+
+        def get_my_type(string):
+            return 'my_type{%s}' % string
+
+        parser = argparse.ArgumentParser()
+        parser.register('type', 'my_type', get_my_type)
+        parser.add_argument('-x', type='my_type')
+        parser.add_argument('y', type='my_type')
+
+        self.assertEqual(parser.parse_args('1'.split()),
+                         NS(x=None, y='my_type{1}'))
+        self.assertEqual(parser.parse_args('-x 1 42'.split()),
+                         NS(x='my_type{1}', y='my_type{42}'))
+
+
+# ============
+# Action tests
+# ============
+
+class TestActionUserDefined(ParserTestCase):
+    """Test a user-defined option/argument action"""
+
+    class OptionalAction(argparse.Action):
+
+        def __call__(self, parser, namespace, value, option_string=None):
+            try:
+                # check destination and option string
+                assert self.dest == 'spam', 'dest: %s' % self.dest
+                assert option_string == '-s', 'flag: %s' % option_string
+                # when option is before argument, badger=2, and when
+                # option is after argument, badger=<whatever was set>
+                expected_ns = NS(spam=0.25)
+                if value in [0.125, 0.625]:
+                    expected_ns.badger = 2
+                elif value in [2.0]:
+                    expected_ns.badger = 84
+                else:
+                    raise AssertionError('value: %s' % value)
+                assert expected_ns == namespace, ('expected %s, got %s' %
+                                                  (expected_ns, namespace))
+            except AssertionError:
+                e = sys.exc_info()[1]
+                raise ArgumentParserError('opt_action failed: %s' % e)
+            setattr(namespace, 'spam', value)
+
+    class PositionalAction(argparse.Action):
+
+        def __call__(self, parser, namespace, value, option_string=None):
+            try:
+                assert option_string is None, ('option_string: %s' %
+                                               option_string)
+                # check destination
+                assert self.dest == 'badger', 'dest: %s' % self.dest
+                # when argument is before option, spam=0.25, and when
+                # option is after argument, spam=<whatever was set>
+                expected_ns = NS(badger=2)
+                if value in [42, 84]:
+                    expected_ns.spam = 0.25
+                elif value in [1]:
+                    expected_ns.spam = 0.625
+                elif value in [2]:
+                    expected_ns.spam = 0.125
+                else:
+                    raise AssertionError('value: %s' % value)
+                assert expected_ns == namespace, ('expected %s, got %s' %
+                                                  (expected_ns, namespace))
+            except AssertionError:
+                e = sys.exc_info()[1]
+                raise ArgumentParserError('arg_action failed: %s' % e)
+            setattr(namespace, 'badger', value)
+
+    argument_signatures = [
+        Sig('-s', dest='spam', action=OptionalAction,
+            type=float, default=0.25),
+        Sig('badger', action=PositionalAction,
+            type=int, nargs='?', default=2),
+    ]
+    failures = []
+    successes = [
+        ('-s0.125', NS(spam=0.125, badger=2)),
+        ('42', NS(spam=0.25, badger=42)),
+        ('-s 0.625 1', NS(spam=0.625, badger=1)),
+        ('84 -s2', NS(spam=2.0, badger=84)),
+    ]
+
+
+class TestActionRegistration(TestCase):
+    """Test a user-defined action supplied by registering it"""
+
+    class MyAction(argparse.Action):
+
+        def __call__(self, parser, namespace, values, option_string=None):
+            setattr(namespace, self.dest, 'foo[%s]' % values)
+
+    def test(self):
+
+        parser = argparse.ArgumentParser()
+        parser.register('action', 'my_action', self.MyAction)
+        parser.add_argument('badger', action='my_action')
+
+        self.assertEqual(parser.parse_args(['1']), NS(badger='foo[1]'))
+        self.assertEqual(parser.parse_args(['42']), NS(badger='foo[42]'))
+
+
+# ================
+# Subparsers tests
+# ================
+
+class TestAddSubparsers(TestCase):
+    """Test the add_subparsers method"""
+
+    def assertArgumentParserError(self, *args, **kwargs):
+        self.assertRaises(ArgumentParserError, *args, **kwargs)
+
+    def _get_parser(self, subparser_help=False):
+        # create a parser with a subparsers argument
+        parser = ErrorRaisingArgumentParser(
+            prog='PROG', description='main description')
+        parser.add_argument(
+            '--foo', action='store_true', help='foo help')
+        parser.add_argument(
+            'bar', type=float, help='bar help')
+
+        # check that only one subparsers argument can be added
+        subparsers = parser.add_subparsers(help='command help')
+        self.assertArgumentParserError(parser.add_subparsers)
+
+        # add first sub-parser
+        parser1_kwargs = dict(description='1 description')
+        if subparser_help:
+            parser1_kwargs['help'] = '1 help'
+        parser1 = subparsers.add_parser('1', **parser1_kwargs)
+        parser1.add_argument('-w', type=int, help='w help')
+        parser1.add_argument('x', choices='abc', help='x help')
+
+        # add second sub-parser
+        parser2_kwargs = dict(description='2 description')
+        if subparser_help:
+            parser2_kwargs['help'] = '2 help'
+        parser2 = subparsers.add_parser('2', **parser2_kwargs)
+        parser2.add_argument('-y', choices='123', help='y help')
+        parser2.add_argument('z', type=complex, nargs='*', help='z help')
+
+        # return the main parser
+        return parser
+
+    def setUp(self):
+        self.parser = self._get_parser()
+        self.command_help_parser = self._get_parser(subparser_help=True)
+
+    def test_parse_args_failures(self):
+        # check some failure cases:
+        for args_str in ['', 'a', 'a a', '0.5 a', '0.5 1',
+                         '0.5 1 -y', '0.5 2 -w']:
+            args = args_str.split()
+            self.assertArgumentParserError(self.parser.parse_args, args)
+
+    def test_parse_args(self):
+        # check some non-failure cases:
+        self.assertEqual(
+            self.parser.parse_args('0.5 1 b -w 7'.split()),
+            NS(foo=False, bar=0.5, w=7, x='b'),
+        )
+        self.assertEqual(
+            self.parser.parse_args('0.25 --foo 2 -y 2 3j -- -1j'.split()),
+            NS(foo=True, bar=0.25, y='2', z=[3j, -1j]),
+        )
+        self.assertEqual(
+            self.parser.parse_args('--foo 0.125 1 c'.split()),
+            NS(foo=True, bar=0.125, w=None, x='c'),
+        )
+
+    def test_dest(self):
+        parser = ErrorRaisingArgumentParser()
+        parser.add_argument('--foo', action='store_true')
+        subparsers = parser.add_subparsers(dest='bar')
+        parser1 = subparsers.add_parser('1')
+        parser1.add_argument('baz')
+        self.assertEqual(NS(foo=False, bar='1', baz='2'),
+                         parser.parse_args('1 2'.split()))
+
+    def test_help(self):
+        self.assertEqual(self.parser.format_usage(),
+                         'usage: PROG [-h] [--foo] bar {1,2} ...\n')
+        self.assertEqual(self.parser.format_help(), textwrap.dedent('''\
+            usage: PROG [-h] [--foo] bar {1,2} ...
+
+            main description
+
+            positional arguments:
+              bar         bar help
+              {1,2}       command help
+
+            optional arguments:
+              -h, --help  show this help message and exit
+              --foo       foo help
+            '''))
+
+    def test_parser_command_help(self):
+        self.assertEqual(self.command_help_parser.format_usage(),
+                         'usage: PROG [-h] [--foo] bar {1,2} ...\n')
+        self.assertEqual(self.command_help_parser.format_help(),
+                         textwrap.dedent('''\
+            usage: PROG [-h] [--foo] bar {1,2} ...
+
+            main description
+
+            positional arguments:
+              bar         bar help
+              {1,2}       command help
+                1         1 help
+                2         2 help
+
+            optional arguments:
+              -h, --help  show this help message and exit
+              --foo       foo help
+            '''))
+
+    def test_subparser_title_help(self):
+        parser = ErrorRaisingArgumentParser(prog='PROG',
+                                            description='main description')
+        parser.add_argument('--foo', action='store_true', help='foo help')
+        parser.add_argument('bar', help='bar help')
+        subparsers = parser.add_subparsers(title='subcommands',
+                                           description='command help',
+                                           help='additional text')
+        parser1 = subparsers.add_parser('1')
+        parser2 = subparsers.add_parser('2')
+        self.assertEqual(parser.format_usage(),
+                         'usage: PROG [-h] [--foo] bar {1,2} ...\n')
+        self.assertEqual(parser.format_help(), textwrap.dedent('''\
+            usage: PROG [-h] [--foo] bar {1,2} ...
+
+            main description
+
+            positional arguments:
+              bar         bar help
+
+            optional arguments:
+              -h, --help  show this help message and exit
+              --foo       foo help
+
+            subcommands:
+              command help
+
+              {1,2}       additional text
+            '''))
+
+    def _test_subparser_help(self, args_str, expected_help):
+        try:
+            self.parser.parse_args(args_str.split())
+        except ArgumentParserError:
+            err = sys.exc_info()[1]
+            if err.stdout != expected_help:
+                print(repr(expected_help))
+                print(repr(err.stdout))
+            self.assertEqual(err.stdout, expected_help)
+
+    def test_subparser1_help(self):
+        self._test_subparser_help('5.0 1 -h', textwrap.dedent('''\
+            usage: PROG bar 1 [-h] [-w W] {a,b,c}
+
+            1 description
+
+            positional arguments:
+              {a,b,c}     x help
+
+            optional arguments:
+              -h, --help  show this help message and exit
+              -w W        w help
+            '''))
+
+    def test_subparser2_help(self):
+        self._test_subparser_help('5.0 2 -h', textwrap.dedent('''\
+            usage: PROG bar 2 [-h] [-y {1,2,3}] [z [z ...]]
+
+            2 description
+
+            positional arguments:
+              z           z help
+
+            optional arguments:
+              -h, --help  show this help message and exit
+              -y {1,2,3}  y help
+            '''))
+
+# ============
+# Groups tests
+# ============
+
+class TestPositionalsGroups(TestCase):
+    """Tests that order of group positionals matches construction order"""
+
+    def test_nongroup_first(self):
+        parser = ErrorRaisingArgumentParser()
+        parser.add_argument('foo')
+        group = parser.add_argument_group('g')
+        group.add_argument('bar')
+        parser.add_argument('baz')
+        expected = NS(foo='1', bar='2', baz='3')
+        result = parser.parse_args('1 2 3'.split())
+        self.failUnlessEqual(expected, result)
+
+    def test_group_first(self):
+        parser = ErrorRaisingArgumentParser()
+        group = parser.add_argument_group('xxx')
+        group.add_argument('foo')
+        parser.add_argument('bar')
+        parser.add_argument('baz')
+        expected = NS(foo='1', bar='2', baz='3')
+        result = parser.parse_args('1 2 3'.split())
+        self.failUnlessEqual(expected, result)
+
+    def test_interleaved_groups(self):
+        parser = ErrorRaisingArgumentParser()
+        group = parser.add_argument_group('xxx')
+        parser.add_argument('foo')
+        group.add_argument('bar')
+        parser.add_argument('baz')
+        group = parser.add_argument_group('yyy')
+        group.add_argument('frell')
+        expected = NS(foo='1', bar='2', baz='3', frell='4')
+        result = parser.parse_args('1 2 3 4'.split())
+        self.failUnlessEqual(expected, result)
+
+# ===================
+# Parent parser tests
+# ===================
+
+class TestParentParsers(TestCase):
+    """Tests that parsers can be created with parent parsers"""
+
+    def assertArgumentParserError(self, *args, **kwargs):
+        self.assertRaises(ArgumentParserError, *args, **kwargs)
+
+    def setUp(self):
+        self.wxyz_parent = ErrorRaisingArgumentParser(add_help=False)
+        self.wxyz_parent.add_argument('--w')
+        x_group = self.wxyz_parent.add_argument_group('x')
+        x_group.add_argument('-y')
+        self.wxyz_parent.add_argument('z')
+
+        self.abcd_parent = ErrorRaisingArgumentParser(add_help=False)
+        self.abcd_parent.add_argument('a')
+        self.abcd_parent.add_argument('-b')
+        c_group = self.abcd_parent.add_argument_group('c')
+        c_group.add_argument('--d')
+
+        self.w_parent = ErrorRaisingArgumentParser(add_help=False)
+        self.w_parent.add_argument('--w')
+
+        self.z_parent = ErrorRaisingArgumentParser(add_help=False)
+        self.z_parent.add_argument('z')
+
+        # parents with mutually exclusive groups
+        self.ab_mutex_parent = ErrorRaisingArgumentParser(add_help=False)
+        group = self.ab_mutex_parent.add_mutually_exclusive_group()
+        group.add_argument('-a', action='store_true')
+        group.add_argument('-b', action='store_true')
+
+    def test_single_parent(self):
+        parser = ErrorRaisingArgumentParser(parents=[self.wxyz_parent])
+        self.assertEqual(parser.parse_args('-y 1 2 --w 3'.split()),
+                         NS(w='3', y='1', z='2'))
+
+    def test_single_parent_mutex(self):
+        self._test_mutex_ab(self.ab_mutex_parent.parse_args)
+        parser = ErrorRaisingArgumentParser(parents=[self.ab_mutex_parent])
+        self._test_mutex_ab(parser.parse_args)
+
+    def test_single_granparent_mutex(self):
+        parents = [self.ab_mutex_parent]
+        parser = ErrorRaisingArgumentParser(add_help=False, parents=parents)
+        parser = ErrorRaisingArgumentParser(parents=[parser])
+        self._test_mutex_ab(parser.parse_args)
+
+    def _test_mutex_ab(self, parse_args):
+        self.assertEqual(parse_args([]), NS(a=False, b=False))
+        self.assertEqual(parse_args(['-a']), NS(a=True, b=False))
+        self.assertEqual(parse_args(['-b']), NS(a=False, b=True))
+        self.assertArgumentParserError(parse_args, ['-a', '-b'])
+        self.assertArgumentParserError(parse_args, ['-b', '-a'])
+        self.assertArgumentParserError(parse_args, ['-c'])
+        self.assertArgumentParserError(parse_args, ['-a', '-c'])
+        self.assertArgumentParserError(parse_args, ['-b', '-c'])
+
+    def test_multiple_parents(self):
+        parents = [self.abcd_parent, self.wxyz_parent]
+        parser = ErrorRaisingArgumentParser(parents=parents)
+        self.assertEqual(parser.parse_args('--d 1 --w 2 3 4'.split()),
+                         NS(a='3', b=None, d='1', w='2', y=None, z='4'))
+
+    def test_multiple_parents_mutex(self):
+        parents = [self.ab_mutex_parent, self.wxyz_parent]
+        parser = ErrorRaisingArgumentParser(parents=parents)
+        self.assertEqual(parser.parse_args('-a --w 2 3'.split()),
+                         NS(a=True, b=False, w='2', y=None, z='3'))
+        self.assertArgumentParserError(
+            parser.parse_args, '-a --w 2 3 -b'.split())
+        self.assertArgumentParserError(
+            parser.parse_args, '-a -b --w 2 3'.split())
+
+    def test_conflicting_parents(self):
+        self.assertRaises(
+            argparse.ArgumentError,
+            argparse.ArgumentParser,
+            parents=[self.w_parent, self.wxyz_parent])
+
+    def test_conflicting_parents_mutex(self):
+        self.assertRaises(
+            argparse.ArgumentError,
+            argparse.ArgumentParser,
+            parents=[self.abcd_parent, self.ab_mutex_parent])
+
+    def test_same_argument_name_parents(self):
+        parents = [self.wxyz_parent, self.z_parent]
+        parser = ErrorRaisingArgumentParser(parents=parents)
+        self.assertEqual(parser.parse_args('1 2'.split()),
+                         NS(w=None, y=None, z='2'))
+
+    def test_subparser_parents(self):
+        parser = ErrorRaisingArgumentParser()
+        subparsers = parser.add_subparsers()
+        abcde_parser = subparsers.add_parser('bar', parents=[self.abcd_parent])
+        abcde_parser.add_argument('e')
+        self.assertEqual(parser.parse_args('bar -b 1 --d 2 3 4'.split()),
+                         NS(a='3', b='1', d='2', e='4'))
+
+    def test_subparser_parents_mutex(self):
+        parser = ErrorRaisingArgumentParser()
+        subparsers = parser.add_subparsers()
+        parents = [self.ab_mutex_parent]
+        abc_parser = subparsers.add_parser('foo', parents=parents)
+        c_group = abc_parser.add_argument_group('c_group')
+        c_group.add_argument('c')
+        parents = [self.wxyz_parent, self.ab_mutex_parent]
+        wxyzabe_parser = subparsers.add_parser('bar', parents=parents)
+        wxyzabe_parser.add_argument('e')
+        self.assertEqual(parser.parse_args('foo -a 4'.split()),
+                         NS(a=True, b=False, c='4'))
+        self.assertEqual(parser.parse_args('bar -b  --w 2 3 4'.split()),
+                         NS(a=False, b=True, w='2', y=None, z='3', e='4'))
+        self.assertArgumentParserError(
+            parser.parse_args, 'foo -a -b 4'.split())
+        self.assertArgumentParserError(
+            parser.parse_args, 'bar -b -a 4'.split())
+
+    def test_parent_help(self):
+        parents = [self.abcd_parent, self.wxyz_parent]
+        parser = ErrorRaisingArgumentParser(parents=parents)
+        parser_help = parser.format_help()
+        self.assertEqual(parser_help, textwrap.dedent('''\
+            usage: test_argparse.py [-h] [-b B] [--d D] [--w W] [-y Y] a z
+
+            positional arguments:
+              a
+              z
+
+            optional arguments:
+              -h, --help  show this help message and exit
+              -b B
+              --w W
+
+            c:
+              --d D
+
+            x:
+              -y Y
+        '''))
+
+    def test_groups_parents(self):
+        parent = ErrorRaisingArgumentParser(add_help=False)
+        g = parent.add_argument_group(title='g', description='gd')
+        g.add_argument('-w')
+        g.add_argument('-x')
+        m = parent.add_mutually_exclusive_group()
+        m.add_argument('-y')
+        m.add_argument('-z')
+        parser = ErrorRaisingArgumentParser(parents=[parent])
+
+        self.assertRaises(ArgumentParserError, parser.parse_args,
+            ['-y', 'Y', '-z', 'Z'])
+
+        parser_help = parser.format_help()
+        self.assertEqual(parser_help, textwrap.dedent('''\
+            usage: test_argparse.py [-h] [-w W] [-x X] [-y Y | -z Z]
+
+            optional arguments:
+              -h, --help  show this help message and exit
+              -y Y
+              -z Z
+
+            g:
+              gd
+
+              -w W
+              -x X
+        '''))
+
+# ==============================
+# Mutually exclusive group tests
+# ==============================
+
+class TestMutuallyExclusiveGroupErrors(TestCase):
+
+    def test_invalid_add_argument_group(self):
+        parser = ErrorRaisingArgumentParser()
+        raises = self.assertRaises
+        raises(TypeError, parser.add_mutually_exclusive_group, title='foo')
+
+    def test_invalid_add_argument(self):
+        parser = ErrorRaisingArgumentParser()
+        group = parser.add_mutually_exclusive_group()
+        add_argument = group.add_argument
+        raises = self.assertRaises
+        raises(ValueError, add_argument, '--foo', required=True)
+        raises(ValueError, add_argument, 'bar')
+        raises(ValueError, add_argument, 'bar', nargs='+')
+        raises(ValueError, add_argument, 'bar', nargs=1)
+        raises(ValueError, add_argument, 'bar', nargs=argparse.PARSER)
+
+
+class MEMixin(object):
+
+    def test_failures_when_not_required(self):
+        parse_args = self.get_parser(required=False).parse_args
+        error = ArgumentParserError
+        for args_string in self.failures:
+            self.assertRaises(error, parse_args, args_string.split())
+
+    def test_failures_when_required(self):
+        parse_args = self.get_parser(required=True).parse_args
+        error = ArgumentParserError
+        for args_string in self.failures + ['']:
+            self.assertRaises(error, parse_args, args_string.split())
+
+    def test_successes_when_not_required(self):
+        parse_args = self.get_parser(required=False).parse_args
+        successes = self.successes + self.successes_when_not_required
+        for args_string, expected_ns in successes:
+            actual_ns = parse_args(args_string.split())
+            self.assertEqual(actual_ns, expected_ns)
+
+    def test_successes_when_required(self):
+        parse_args = self.get_parser(required=True).parse_args
+        for args_string, expected_ns in self.successes:
+            actual_ns = parse_args(args_string.split())
+            self.assertEqual(actual_ns, expected_ns)
+
+    def test_usage_when_not_required(self):
+        format_usage = self.get_parser(required=False).format_usage
+        expected_usage = self.usage_when_not_required
+        self.assertEqual(format_usage(), textwrap.dedent(expected_usage))
+
+    def test_usage_when_required(self):
+        format_usage = self.get_parser(required=True).format_usage
+        expected_usage = self.usage_when_required
+        self.assertEqual(format_usage(), textwrap.dedent(expected_usage))
+
+    def test_help_when_not_required(self):
+        format_help = self.get_parser(required=False).format_help
+        help = self.usage_when_not_required + self.help
+        self.assertEqual(format_help(), textwrap.dedent(help))
+
+    def test_help_when_required(self):
+        format_help = self.get_parser(required=True).format_help
+        help = self.usage_when_required + self.help
+        self.assertEqual(format_help(), textwrap.dedent(help))
+
+
+class TestMutuallyExclusiveSimple(MEMixin, TestCase):
+
+    def get_parser(self, required=None):
+        parser = ErrorRaisingArgumentParser(prog='PROG')
+        group = parser.add_mutually_exclusive_group(required=required)
+        group.add_argument('--bar', help='bar help')
+        group.add_argument('--baz', nargs='?', const='Z', help='baz help')
+        return parser
+
+    failures = ['--bar X --baz Y', '--bar X --baz']
+    successes = [
+        ('--bar X', NS(bar='X', baz=None)),
+        ('--bar X --bar Z', NS(bar='Z', baz=None)),
+        ('--baz Y', NS(bar=None, baz='Y')),
+        ('--baz', NS(bar=None, baz='Z')),
+    ]
+    successes_when_not_required = [
+        ('', NS(bar=None, baz=None)),
+    ]
+
+    usage_when_not_required = '''\
+        usage: PROG [-h] [--bar BAR | --baz [BAZ]]
+        '''
+    usage_when_required = '''\
+        usage: PROG [-h] (--bar BAR | --baz [BAZ])
+        '''
+    help = '''\
+
+        optional arguments:
+          -h, --help   show this help message and exit
+          --bar BAR    bar help
+          --baz [BAZ]  baz help
+        '''
+
+
+class TestMutuallyExclusiveLong(MEMixin, TestCase):
+
+    def get_parser(self, required=None):
+        parser = ErrorRaisingArgumentParser(prog='PROG')
+        parser.add_argument('--abcde', help='abcde help')
+        parser.add_argument('--fghij', help='fghij help')
+        group = parser.add_mutually_exclusive_group(required=required)
+        group.add_argument('--klmno', help='klmno help')
+        group.add_argument('--pqrst', help='pqrst help')
+        return parser
+
+    failures = ['--klmno X --pqrst Y']
+    successes = [
+        ('--klmno X', NS(abcde=None, fghij=None, klmno='X', pqrst=None)),
+        ('--abcde Y --klmno X',
+            NS(abcde='Y', fghij=None, klmno='X', pqrst=None)),
+        ('--pqrst X', NS(abcde=None, fghij=None, klmno=None, pqrst='X')),
+        ('--pqrst X --fghij Y',
+            NS(abcde=None, fghij='Y', klmno=None, pqrst='X')),
+    ]
+    successes_when_not_required = [
+        ('', NS(abcde=None, fghij=None, klmno=None, pqrst=None)),
+    ]
+
+    usage_when_not_required = '''\
+    usage: PROG [-h] [--abcde ABCDE] [--fghij FGHIJ]
+                [--klmno KLMNO | --pqrst PQRST]
+    '''
+    usage_when_required = '''\
+    usage: PROG [-h] [--abcde ABCDE] [--fghij FGHIJ]
+                (--klmno KLMNO | --pqrst PQRST)
+    '''
+    help = '''\
+
+    optional arguments:
+      -h, --help     show this help message and exit
+      --abcde ABCDE  abcde help
+      --fghij FGHIJ  fghij help
+      --klmno KLMNO  klmno help
+      --pqrst PQRST  pqrst help
+    '''
+
+
+class TestMutuallyExclusiveFirstSuppressed(MEMixin, TestCase):
+
+    def get_parser(self, required):
+        parser = ErrorRaisingArgumentParser(prog='PROG')
+        group = parser.add_mutually_exclusive_group(required=required)
+        group.add_argument('-x', help=argparse.SUPPRESS)
+        group.add_argument('-y', action='store_false', help='y help')
+        return parser
+
+    failures = ['-x X -y']
+    successes = [
+        ('-x X', NS(x='X', y=True)),
+        ('-x X -x Y', NS(x='Y', y=True)),
+        ('-y', NS(x=None, y=False)),
+    ]
+    successes_when_not_required = [
+        ('', NS(x=None, y=True)),
+    ]
+
+    usage_when_not_required = '''\
+        usage: PROG [-h] [-y]
+        '''
+    usage_when_required = '''\
+        usage: PROG [-h] -y
+        '''
+    help = '''\
+
+        optional arguments:
+          -h, --help  show this help message and exit
+          -y          y help
+        '''
+
+
+class TestMutuallyExclusiveManySuppressed(MEMixin, TestCase):
+
+    def get_parser(self, required):
+        parser = ErrorRaisingArgumentParser(prog='PROG')
+        group = parser.add_mutually_exclusive_group(required=required)
+        add = group.add_argument
+        add('--spam', action='store_true', help=argparse.SUPPRESS)
+        add('--badger', action='store_false', help=argparse.SUPPRESS)
+        add('--bladder', help=argparse.SUPPRESS)
+        return parser
+
+    failures = [
+        '--spam --badger',
+        '--badger --bladder B',
+        '--bladder B --spam',
+    ]
+    successes = [
+        ('--spam', NS(spam=True, badger=True, bladder=None)),
+        ('--badger', NS(spam=False, badger=False, bladder=None)),
+        ('--bladder B', NS(spam=False, badger=True, bladder='B')),
+        ('--spam --spam', NS(spam=True, badger=True, bladder=None)),
+    ]
+    successes_when_not_required = [
+        ('', NS(spam=False, badger=True, bladder=None)),
+    ]
+
+    usage_when_required = usage_when_not_required = '''\
+        usage: PROG [-h]
+        '''
+    help = '''\
+
+        optional arguments:
+          -h, --help  show this help message and exit
+        '''
+
+
+class TestMutuallyExclusiveOptionalAndPositional(MEMixin, TestCase):
+
+    def get_parser(self, required):
+        parser = ErrorRaisingArgumentParser(prog='PROG')
+        group = parser.add_mutually_exclusive_group(required=required)
+        group.add_argument('--foo', action='store_true', help='FOO')
+        group.add_argument('--spam', help='SPAM')
+        group.add_argument('badger', nargs='*', default='X', help='BADGER')
+        return parser
+
+    failures = [
+        '--foo --spam S',
+        '--spam S X',
+        'X --foo',
+        'X Y Z --spam S',
+        '--foo X Y',
+    ]
+    successes = [
+        ('--foo', NS(foo=True, spam=None, badger='X')),
+        ('--spam S', NS(foo=False, spam='S', badger='X')),
+        ('X', NS(foo=False, spam=None, badger=['X'])),
+        ('X Y Z', NS(foo=False, spam=None, badger=['X', 'Y', 'Z'])),
+    ]
+    successes_when_not_required = [
+        ('', NS(foo=False, spam=None, badger='X')),
+    ]
+
+    usage_when_not_required = '''\
+        usage: PROG [-h] [--foo | --spam SPAM | badger [badger ...]]
+        '''
+    usage_when_required = '''\
+        usage: PROG [-h] (--foo | --spam SPAM | badger [badger ...])
+        '''
+    help = '''\
+
+        positional arguments:
+          badger       BADGER
+
+        optional arguments:
+          -h, --help   show this help message and exit
+          --foo        FOO
+          --spam SPAM  SPAM
+        '''
+
+
+class TestMutuallyExclusiveOptionalsMixed(MEMixin, TestCase):
+
+    def get_parser(self, required):
+        parser = ErrorRaisingArgumentParser(prog='PROG')
+        parser.add_argument('-x', action='store_true', help='x help')
+        group = parser.add_mutually_exclusive_group(required=required)
+        group.add_argument('-a', action='store_true', help='a help')
+        group.add_argument('-b', action='store_true', help='b help')
+        parser.add_argument('-y', action='store_true', help='y help')
+        group.add_argument('-c', action='store_true', help='c help')
+        return parser
+
+    failures = ['-a -b', '-b -c', '-a -c', '-a -b -c']
+    successes = [
+        ('-a', NS(a=True, b=False, c=False, x=False, y=False)),
+        ('-b', NS(a=False, b=True, c=False, x=False, y=False)),
+        ('-c', NS(a=False, b=False, c=True, x=False, y=False)),
+        ('-a -x', NS(a=True, b=False, c=False, x=True, y=False)),
+        ('-y -b', NS(a=False, b=True, c=False, x=False, y=True)),
+        ('-x -y -c', NS(a=False, b=False, c=True, x=True, y=True)),
+    ]
+    successes_when_not_required = [
+        ('', NS(a=False, b=False, c=False, x=False, y=False)),
+        ('-x', NS(a=False, b=False, c=False, x=True, y=False)),
+        ('-y', NS(a=False, b=False, c=False, x=False, y=True)),
+    ]
+
+    usage_when_required = usage_when_not_required = '''\
+        usage: PROG [-h] [-x] [-a] [-b] [-y] [-c]
+        '''
+    help = '''\
+
+        optional arguments:
+          -h, --help  show this help message and exit
+          -x          x help
+          -a          a help
+          -b          b help
+          -y          y help
+          -c          c help
+        '''
+
+
+class TestMutuallyExclusiveOptionalsAndPositionalsMixed(MEMixin, TestCase):
+
+    def get_parser(self, required):
+        parser = ErrorRaisingArgumentParser(prog='PROG')
+        parser.add_argument('x', help='x help')
+        parser.add_argument('-y', action='store_true', help='y help')
+        group = parser.add_mutually_exclusive_group(required=required)
+        group.add_argument('a', nargs='?', help='a help')
+        group.add_argument('-b', action='store_true', help='b help')
+        group.add_argument('-c', action='store_true', help='c help')
+        return parser
+
+    failures = ['X A -b', '-b -c', '-c X A']
+    successes = [
+        ('X A', NS(a='A', b=False, c=False, x='X', y=False)),
+        ('X -b', NS(a=None, b=True, c=False, x='X', y=False)),
+        ('X -c', NS(a=None, b=False, c=True, x='X', y=False)),
+        ('X A -y', NS(a='A', b=False, c=False, x='X', y=True)),
+        ('X -y -b', NS(a=None, b=True, c=False, x='X', y=True)),
+    ]
+    successes_when_not_required = [
+        ('X', NS(a=None, b=False, c=False, x='X', y=False)),
+        ('X -y', NS(a=None, b=False, c=False, x='X', y=True)),
+    ]
+
+    usage_when_required = usage_when_not_required = '''\
+        usage: PROG [-h] [-y] [-b] [-c] x [a]
+        '''
+    help = '''\
+
+        positional arguments:
+          x           x help
+          a           a help
+
+        optional arguments:
+          -h, --help  show this help message and exit
+          -y          y help
+          -b          b help
+          -c          c help
+        '''
+
+# =================================================
+# Mutually exclusive group in parent parser tests
+# =================================================
+
+class MEPBase(object):
+
+    def get_parser(self, required=None):
+        parent = super(MEPBase, self).get_parser(required=required)
+        parser = ErrorRaisingArgumentParser(
+            prog=parent.prog, add_help=False, parents=[parent])
+        return parser
+
+
+class TestMutuallyExclusiveGroupErrorsParent(
+    MEPBase, TestMutuallyExclusiveGroupErrors):
+    pass
+
+
+class TestMutuallyExclusiveSimpleParent(
+    MEPBase, TestMutuallyExclusiveSimple):
+    pass
+
+
+class TestMutuallyExclusiveLongParent(
+    MEPBase, TestMutuallyExclusiveLong):
+    pass
+
+
+class TestMutuallyExclusiveFirstSuppressedParent(
+    MEPBase, TestMutuallyExclusiveFirstSuppressed):
+    pass
+
+
+class TestMutuallyExclusiveManySuppressedParent(
+    MEPBase, TestMutuallyExclusiveManySuppressed):
+    pass
+
+
+class TestMutuallyExclusiveOptionalAndPositionalParent(
+    MEPBase, TestMutuallyExclusiveOptionalAndPositional):
+    pass
+
+
+class TestMutuallyExclusiveOptionalsMixedParent(
+    MEPBase, TestMutuallyExclusiveOptionalsMixed):
+    pass
+
+
+class TestMutuallyExclusiveOptionalsAndPositionalsMixedParent(
+    MEPBase, TestMutuallyExclusiveOptionalsAndPositionalsMixed):
+    pass
+
+# =================
+# Set default tests
+# =================
+
+class TestSetDefaults(TestCase):
+
+    def test_set_defaults_no_args(self):
+        parser = ErrorRaisingArgumentParser()
+        parser.set_defaults(x='foo')
+        parser.set_defaults(y='bar', z=1)
+        self.assertEqual(NS(x='foo', y='bar', z=1),
+                         parser.parse_args([]))
+        self.assertEqual(NS(x='foo', y='bar', z=1),
+                         parser.parse_args([], NS()))
+        self.assertEqual(NS(x='baz', y='bar', z=1),
+                         parser.parse_args([], NS(x='baz')))
+        self.assertEqual(NS(x='baz', y='bar', z=2),
+                         parser.parse_args([], NS(x='baz', z=2)))
+
+    def test_set_defaults_with_args(self):
+        parser = ErrorRaisingArgumentParser()
+        parser.set_defaults(x='foo', y='bar')
+        parser.add_argument('-x', default='xfoox')
+        self.assertEqual(NS(x='xfoox', y='bar'),
+                         parser.parse_args([]))
+        self.assertEqual(NS(x='xfoox', y='bar'),
+                         parser.parse_args([], NS()))
+        self.assertEqual(NS(x='baz', y='bar'),
+                         parser.parse_args([], NS(x='baz')))
+        self.assertEqual(NS(x='1', y='bar'),
+                         parser.parse_args('-x 1'.split()))
+        self.assertEqual(NS(x='1', y='bar'),
+                         parser.parse_args('-x 1'.split(), NS()))
+        self.assertEqual(NS(x='1', y='bar'),
+                         parser.parse_args('-x 1'.split(), NS(x='baz')))
+
+    def test_set_defaults_subparsers(self):
+        parser = ErrorRaisingArgumentParser()
+        parser.set_defaults(x='foo')
+        subparsers = parser.add_subparsers()
+        parser_a = subparsers.add_parser('a')
+        parser_a.set_defaults(y='bar')
+        self.assertEqual(NS(x='foo', y='bar'),
+                         parser.parse_args('a'.split()))
+
+    def test_set_defaults_parents(self):
+        parent = ErrorRaisingArgumentParser(add_help=False)
+        parent.set_defaults(x='foo')
+        parser = ErrorRaisingArgumentParser(parents=[parent])
+        self.assertEqual(NS(x='foo'), parser.parse_args([]))
+
+    def test_set_defaults_same_as_add_argument(self):
+        parser = ErrorRaisingArgumentParser()
+        parser.set_defaults(w='W', x='X', y='Y', z='Z')
+        parser.add_argument('-w')
+        parser.add_argument('-x', default='XX')
+        parser.add_argument('y', nargs='?')
+        parser.add_argument('z', nargs='?', default='ZZ')
+
+        # defaults set previously
+        self.assertEqual(NS(w='W', x='XX', y='Y', z='ZZ'),
+                         parser.parse_args([]))
+
+        # reset defaults
+        parser.set_defaults(w='WW', x='X', y='YY', z='Z')
+        self.assertEqual(NS(w='WW', x='X', y='YY', z='Z'),
+                         parser.parse_args([]))
+
+    def test_set_defaults_same_as_add_argument_group(self):
+        parser = ErrorRaisingArgumentParser()
+        parser.set_defaults(w='W', x='X', y='Y', z='Z')
+        group = parser.add_argument_group('foo')
+        group.add_argument('-w')
+        group.add_argument('-x', default='XX')
+        group.add_argument('y', nargs='?')
+        group.add_argument('z', nargs='?', default='ZZ')
+
+
+        # defaults set previously
+        self.assertEqual(NS(w='W', x='XX', y='Y', z='ZZ'),
+                         parser.parse_args([]))
+
+        # reset defaults
+        parser.set_defaults(w='WW', x='X', y='YY', z='Z')
+        self.assertEqual(NS(w='WW', x='X', y='YY', z='Z'),
+                         parser.parse_args([]))
+
+# =================
+# Get default tests
+# =================
+
+class TestGetDefault(TestCase):
+
+    def test_get_default(self):
+        parser = ErrorRaisingArgumentParser()
+        self.assertEqual(None, parser.get_default("foo"))
+        self.assertEqual(None, parser.get_default("bar"))
+
+        parser.add_argument("--foo")
+        self.assertEqual(None, parser.get_default("foo"))
+        self.assertEqual(None, parser.get_default("bar"))
+
+        parser.add_argument("--bar", type=int, default=42)
+        self.assertEqual(None, parser.get_default("foo"))
+        self.assertEqual(42, parser.get_default("bar"))
+
+        parser.set_defaults(foo="badger")
+        self.assertEqual("badger", parser.get_default("foo"))
+        self.assertEqual(42, parser.get_default("bar"))
+
+# ==========================
+# Namespace 'contains' tests
+# ==========================
+
+class TestNamespaceContainsSimple(TestCase):
+
+    def test_empty(self):
+        ns = argparse.Namespace()
+        self.assertEquals('' in ns, False)
+        self.assertEquals('' not in ns, True)
+        self.assertEquals('x' in ns, False)
+
+    def test_non_empty(self):
+        ns = argparse.Namespace(x=1, y=2)
+        self.assertEquals('x' in ns, True)
+        self.assertEquals('x' not in ns, False)
+        self.assertEquals('y' in ns, True)
+        self.assertEquals('' in ns, False)
+        self.assertEquals('xx' in ns, False)
+        self.assertEquals('z' in ns, False)
+
+# =====================
+# Help formatting tests
+# =====================
+
+class TestHelpFormattingMetaclass(type):
+
+    def __init__(cls, name, bases, bodydict):
+        if name == 'HelpTestCase':
+            return
+
+        class AddTests(object):
+
+            def __init__(self, test_class, func_suffix, std_name):
+                self.func_suffix = func_suffix
+                self.std_name = std_name
+
+                for test_func in [self.test_format,
+                                  self.test_print,
+                                  self.test_print_file]:
+                    test_name = '%s_%s' % (test_func.__name__, func_suffix)
+
+                    def test_wrapper(self, test_func=test_func):
+                        test_func(self)
+                    try:
+                        test_wrapper.__name__ = test_name
+                    except TypeError:
+                        pass
+                    setattr(test_class, test_name, test_wrapper)
+
+            def _get_parser(self, tester):
+                parser = argparse.ArgumentParser(
+                    *tester.parser_signature.args,
+                    **tester.parser_signature.kwargs)
+                for argument_sig in tester.argument_signatures:
+                    parser.add_argument(*argument_sig.args,
+                                        **argument_sig.kwargs)
+                group_signatures = tester.argument_group_signatures
+                for group_sig, argument_sigs in group_signatures:
+                    group = parser.add_argument_group(*group_sig.args,
+                                                      **group_sig.kwargs)
+                    for argument_sig in argument_sigs:
+                        group.add_argument(*argument_sig.args,
+                                           **argument_sig.kwargs)
+                return parser
+
+            def _test(self, tester, parser_text):
+                expected_text = getattr(tester, self.func_suffix)
+                expected_text = textwrap.dedent(expected_text)
+                if expected_text != parser_text:
+                    print(repr(expected_text))
+                    print(repr(parser_text))
+                    for char1, char2 in zip(expected_text, parser_text):
+                        if char1 != char2:
+                            print('first diff: %r %r' % (char1, char2))
+                            break
+                tester.assertEqual(expected_text, parser_text)
+
+            def test_format(self, tester):
+                parser = self._get_parser(tester)
+                format = getattr(parser, 'format_%s' % self.func_suffix)
+                self._test(tester, format())
+
+            def test_print(self, tester):
+                parser = self._get_parser(tester)
+                print_ = getattr(parser, 'print_%s' % self.func_suffix)
+                old_stream = getattr(sys, self.std_name)
+                setattr(sys, self.std_name, StringIO())
+                try:
+                    print_()
+                    parser_text = getattr(sys, self.std_name).getvalue()
+                finally:
+                    setattr(sys, self.std_name, old_stream)
+                self._test(tester, parser_text)
+
+            def test_print_file(self, tester):
+                parser = self._get_parser(tester)
+                print_ = getattr(parser, 'print_%s' % self.func_suffix)
+                sfile = StringIO()
+                print_(sfile)
+                parser_text = sfile.getvalue()
+                self._test(tester, parser_text)
+
+        # add tests for {format,print}_{usage,help,version}
+        for func_suffix, std_name in [('usage', 'stdout'),
+                                      ('help', 'stdout'),
+                                      ('version', 'stderr')]:
+            AddTests(cls, func_suffix, std_name)
+
+bases = TestCase,
+HelpTestCase = TestHelpFormattingMetaclass('HelpTestCase', bases, {})
+
+
+class TestHelpBiggerOptionals(HelpTestCase):
+    """Make sure that argument help aligns when options are longer"""
+
+    parser_signature = Sig(prog='PROG', description='DESCRIPTION',
+                           epilog='EPILOG', version='0.1')
+    argument_signatures = [
+        Sig('-x', action='store_true', help='X HELP'),
+        Sig('--y', help='Y HELP'),
+        Sig('foo', help='FOO HELP'),
+        Sig('bar', help='BAR HELP'),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PROG [-h] [-v] [-x] [--y Y] foo bar
+        '''
+    help = usage + '''\
+
+        DESCRIPTION
+
+        positional arguments:
+          foo            FOO HELP
+          bar            BAR HELP
+
+        optional arguments:
+          -h, --help     show this help message and exit
+          -v, --version  show program's version number and exit
+          -x             X HELP
+          --y Y          Y HELP
+
+        EPILOG
+    '''
+    version = '''\
+        0.1
+        '''
+
+
+class TestHelpBiggerOptionalGroups(HelpTestCase):
+    """Make sure that argument help aligns when options are longer"""
+
+    parser_signature = Sig(prog='PROG', description='DESCRIPTION',
+                           epilog='EPILOG', version='0.1')
+    argument_signatures = [
+        Sig('-x', action='store_true', help='X HELP'),
+        Sig('--y', help='Y HELP'),
+        Sig('foo', help='FOO HELP'),
+        Sig('bar', help='BAR HELP'),
+    ]
+    argument_group_signatures = [
+        (Sig('GROUP TITLE', description='GROUP DESCRIPTION'), [
+            Sig('baz', help='BAZ HELP'),
+            Sig('-z', nargs='+', help='Z HELP')]),
+    ]
+    usage = '''\
+        usage: PROG [-h] [-v] [-x] [--y Y] [-z Z [Z ...]] foo bar baz
+        '''
+    help = usage + '''\
+
+        DESCRIPTION
+
+        positional arguments:
+          foo            FOO HELP
+          bar            BAR HELP
+
+        optional arguments:
+          -h, --help     show this help message and exit
+          -v, --version  show program's version number and exit
+          -x             X HELP
+          --y Y          Y HELP
+
+        GROUP TITLE:
+          GROUP DESCRIPTION
+
+          baz            BAZ HELP
+          -z Z [Z ...]   Z HELP
+
+        EPILOG
+    '''
+    version = '''\
+        0.1
+        '''
+
+
+class TestHelpBiggerPositionals(HelpTestCase):
+    """Make sure that help aligns when arguments are longer"""
+
+    parser_signature = Sig(usage='USAGE', description='DESCRIPTION')
+    argument_signatures = [
+        Sig('-x', action='store_true', help='X HELP'),
+        Sig('--y', help='Y HELP'),
+        Sig('ekiekiekifekang', help='EKI HELP'),
+        Sig('bar', help='BAR HELP'),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: USAGE
+        '''
+    help = usage + '''\
+
+        DESCRIPTION
+
+        positional arguments:
+          ekiekiekifekang  EKI HELP
+          bar              BAR HELP
+
+        optional arguments:
+          -h, --help       show this help message and exit
+          -x               X HELP
+          --y Y            Y HELP
+        '''
+
+    version = ''
+
+
+class TestHelpReformatting(HelpTestCase):
+    """Make sure that text after short names starts on the first line"""
+
+    parser_signature = Sig(
+        prog='PROG',
+        description='   oddly    formatted\n'
+                    'description\n'
+                    '\n'
+                    'that is so long that it should go onto multiple '
+                    'lines when wrapped')
+    argument_signatures = [
+        Sig('-x', metavar='XX', help='oddly\n'
+                                     '    formatted -x help'),
+        Sig('y', metavar='yyy', help='normal y help'),
+    ]
+    argument_group_signatures = [
+        (Sig('title', description='\n'
+                                  '    oddly formatted group\n'
+                                  '\n'
+                                  'description'),
+         [Sig('-a', action='store_true',
+              help=' oddly \n'
+                   'formatted    -a  help  \n'
+                   '    again, so long that it should be wrapped over '
+                   'multiple lines')]),
+    ]
+    usage = '''\
+        usage: PROG [-h] [-x XX] [-a] yyy
+        '''
+    help = usage + '''\
+
+        oddly formatted description that is so long that it should go onto \
+multiple
+        lines when wrapped
+
+        positional arguments:
+          yyy         normal y help
+
+        optional arguments:
+          -h, --help  show this help message and exit
+          -x XX       oddly formatted -x help
+
+        title:
+          oddly formatted group description
+
+          -a          oddly formatted -a help again, so long that it should \
+be wrapped
+                      over multiple lines
+        '''
+    version = ''
+
+
+class TestHelpWrappingShortNames(HelpTestCase):
+    """Make sure that text after short names starts on the first line"""
+
+    parser_signature = Sig(prog='PROG', description= 'D\nD' * 30)
+    argument_signatures = [
+        Sig('-x', metavar='XX', help='XHH HX' * 20),
+        Sig('y', metavar='yyy', help='YH YH' * 20),
+    ]
+    argument_group_signatures = [
+        (Sig('ALPHAS'), [
+            Sig('-a', action='store_true', help='AHHH HHA' * 10)]),
+    ]
+    usage = '''\
+        usage: PROG [-h] [-x XX] [-a] yyy
+        '''
+    help = usage + '''\
+
+        D DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD \
+DD DD DD
+        DD DD DD DD D
+
+        positional arguments:
+          yyy         YH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH \
+YHYH YHYH
+                      YHYH YHYH YHYH YHYH YHYH YHYH YHYH YH
+
+        optional arguments:
+          -h, --help  show this help message and exit
+          -x XX       XHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH \
+HXXHH HXXHH
+                      HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HX
+
+        ALPHAS:
+          -a          AHHH HHAAHHH HHAAHHH HHAAHHH HHAAHHH HHAAHHH HHAAHHH \
+HHAAHHH
+                      HHAAHHH HHAAHHH HHA
+        '''
+    version = ''
+
+
+class TestHelpWrappingLongNames(HelpTestCase):
+    """Make sure that text after long names starts on the next line"""
+
+    parser_signature = Sig(usage='USAGE', description= 'D D' * 30,
+                           version='V V'*30)
+    argument_signatures = [
+        Sig('-x', metavar='X' * 25, help='XH XH' * 20),
+        Sig('y', metavar='y' * 25, help='YH YH' * 20),
+    ]
+    argument_group_signatures = [
+        (Sig('ALPHAS'), [
+            Sig('-a', metavar='A' * 25, help='AH AH' * 20),
+            Sig('z', metavar='z' * 25, help='ZH ZH' * 20)]),
+    ]
+    usage = '''\
+        usage: USAGE
+        '''
+    help = usage + '''\
+
+        D DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD \
+DD DD DD
+        DD DD DD DD D
+
+        positional arguments:
+          yyyyyyyyyyyyyyyyyyyyyyyyy
+                                YH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH \
+YHYH YHYH
+                                YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YH
+
+        optional arguments:
+          -h, --help            show this help message and exit
+          -v, --version         show program's version number and exit
+          -x XXXXXXXXXXXXXXXXXXXXXXXXX
+                                XH XHXH XHXH XHXH XHXH XHXH XHXH XHXH XHXH \
+XHXH XHXH
+                                XHXH XHXH XHXH XHXH XHXH XHXH XHXH XHXH XHXH XH
+
+        ALPHAS:
+          -a AAAAAAAAAAAAAAAAAAAAAAAAA
+                                AH AHAH AHAH AHAH AHAH AHAH AHAH AHAH AHAH \
+AHAH AHAH
+                                AHAH AHAH AHAH AHAH AHAH AHAH AHAH AHAH AHAH AH
+          zzzzzzzzzzzzzzzzzzzzzzzzz
+                                ZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH \
+ZHZH ZHZH
+                                ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZH
+        '''
+    version = '''\
+        V VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV \
+VV VV VV
+        VV VV VV VV V
+        '''
+
+
+class TestHelpUsage(HelpTestCase):
+    """Test basic usage messages"""
+
+    parser_signature = Sig(prog='PROG')
+    argument_signatures = [
+        Sig('-w', nargs='+', help='w'),
+        Sig('-x', nargs='*', help='x'),
+        Sig('a', help='a'),
+        Sig('b', help='b', nargs=2),
+        Sig('c', help='c', nargs='?'),
+    ]
+    argument_group_signatures = [
+        (Sig('group'), [
+            Sig('-y', nargs='?', help='y'),
+            Sig('-z', nargs=3, help='z'),
+            Sig('d', help='d', nargs='*'),
+            Sig('e', help='e', nargs='+'),
+        ])
+    ]
+    usage = '''\
+        usage: PROG [-h] [-w W [W ...]] [-x [X [X ...]]] [-y [Y]] [-z Z Z Z]
+                    a b b [c] [d [d ...]] e [e ...]
+        '''
+    help = usage + '''\
+
+        positional arguments:
+          a               a
+          b               b
+          c               c
+
+        optional arguments:
+          -h, --help      show this help message and exit
+          -w W [W ...]    w
+          -x [X [X ...]]  x
+
+        group:
+          -y [Y]          y
+          -z Z Z Z        z
+          d               d
+          e               e
+        '''
+    version = ''
+
+
+class TestHelpOnlyUserGroups(HelpTestCase):
+    """Test basic usage messages"""
+
+    parser_signature = Sig(prog='PROG', add_help=False)
+    argument_signatures = []
+    argument_group_signatures = [
+        (Sig('xxxx'), [
+            Sig('-x', help='x'),
+            Sig('a', help='a'),
+        ]),
+        (Sig('yyyy'), [
+            Sig('b', help='b'),
+            Sig('-y', help='y'),
+        ]),
+    ]
+    usage = '''\
+        usage: PROG [-x X] [-y Y] a b
+        '''
+    help = usage + '''\
+
+        xxxx:
+          -x X  x
+          a     a
+
+        yyyy:
+          b     b
+          -y Y  y
+        '''
+    version = ''
+
+
+class TestHelpUsageLongProg(HelpTestCase):
+    """Test usage messages where the prog is long"""
+
+    parser_signature = Sig(prog='P' * 60)
+    argument_signatures = [
+        Sig('-w', metavar='W'),
+        Sig('-x', metavar='X'),
+        Sig('a'),
+        Sig('b'),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
+               [-h] [-w W] [-x X] a b
+        '''
+    help = usage + '''\
+
+        positional arguments:
+          a
+          b
+
+        optional arguments:
+          -h, --help  show this help message and exit
+          -w W
+          -x X
+        '''
+    version = ''
+
+
+class TestHelpUsageLongProgOptionsWrap(HelpTestCase):
+    """Test usage messages where the prog is long and the optionals wrap"""
+
+    parser_signature = Sig(prog='P' * 60)
+    argument_signatures = [
+        Sig('-w', metavar='W' * 25),
+        Sig('-x', metavar='X' * 25),
+        Sig('-y', metavar='Y' * 25),
+        Sig('-z', metavar='Z' * 25),
+        Sig('a'),
+        Sig('b'),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
+               [-h] [-w WWWWWWWWWWWWWWWWWWWWWWWWW] \
+[-x XXXXXXXXXXXXXXXXXXXXXXXXX]
+               [-y YYYYYYYYYYYYYYYYYYYYYYYYY] [-z ZZZZZZZZZZZZZZZZZZZZZZZZZ]
+               a b
+        '''
+    help = usage + '''\
+
+        positional arguments:
+          a
+          b
+
+        optional arguments:
+          -h, --help            show this help message and exit
+          -w WWWWWWWWWWWWWWWWWWWWWWWWW
+          -x XXXXXXXXXXXXXXXXXXXXXXXXX
+          -y YYYYYYYYYYYYYYYYYYYYYYYYY
+          -z ZZZZZZZZZZZZZZZZZZZZZZZZZ
+        '''
+    version = ''
+
+
+class TestHelpUsageLongProgPositionalsWrap(HelpTestCase):
+    """Test usage messages where the prog is long and the positionals wrap"""
+
+    parser_signature = Sig(prog='P' * 60, add_help=False)
+    argument_signatures = [
+        Sig('a' * 25),
+        Sig('b' * 25),
+        Sig('c' * 25),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
+               aaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbb
+               ccccccccccccccccccccccccc
+        '''
+    help = usage + '''\
+
+        positional arguments:
+          aaaaaaaaaaaaaaaaaaaaaaaaa
+          bbbbbbbbbbbbbbbbbbbbbbbbb
+          ccccccccccccccccccccccccc
+        '''
+    version = ''
+
+
+class TestHelpUsageOptionalsWrap(HelpTestCase):
+    """Test usage messages where the optionals wrap"""
+
+    parser_signature = Sig(prog='PROG')
+    argument_signatures = [
+        Sig('-w', metavar='W' * 25),
+        Sig('-x', metavar='X' * 25),
+        Sig('-y', metavar='Y' * 25),
+        Sig('-z', metavar='Z' * 25),
+        Sig('a'),
+        Sig('b'),
+        Sig('c'),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PROG [-h] [-w WWWWWWWWWWWWWWWWWWWWWWWWW] \
+[-x XXXXXXXXXXXXXXXXXXXXXXXXX]
+                    [-y YYYYYYYYYYYYYYYYYYYYYYYYY] \
+[-z ZZZZZZZZZZZZZZZZZZZZZZZZZ]
+                    a b c
+        '''
+    help = usage + '''\
+
+        positional arguments:
+          a
+          b
+          c
+
+        optional arguments:
+          -h, --help            show this help message and exit
+          -w WWWWWWWWWWWWWWWWWWWWWWWWW
+          -x XXXXXXXXXXXXXXXXXXXXXXXXX
+          -y YYYYYYYYYYYYYYYYYYYYYYYYY
+          -z ZZZZZZZZZZZZZZZZZZZZZZZZZ
+        '''
+    version = ''
+
+
+class TestHelpUsagePositionalsWrap(HelpTestCase):
+    """Test usage messages where the positionals wrap"""
+
+    parser_signature = Sig(prog='PROG')
+    argument_signatures = [
+        Sig('-x'),
+        Sig('-y'),
+        Sig('-z'),
+        Sig('a' * 25),
+        Sig('b' * 25),
+        Sig('c' * 25),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PROG [-h] [-x X] [-y Y] [-z Z]
+                    aaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbb
+                    ccccccccccccccccccccccccc
+        '''
+    help = usage + '''\
+
+        positional arguments:
+          aaaaaaaaaaaaaaaaaaaaaaaaa
+          bbbbbbbbbbbbbbbbbbbbbbbbb
+          ccccccccccccccccccccccccc
+
+        optional arguments:
+          -h, --help            show this help message and exit
+          -x X
+          -y Y
+          -z Z
+        '''
+    version = ''
+
+
+class TestHelpUsageOptionalsPositionalsWrap(HelpTestCase):
+    """Test usage messages where the optionals and positionals wrap"""
+
+    parser_signature = Sig(prog='PROG')
+    argument_signatures = [
+        Sig('-x', metavar='X' * 25),
+        Sig('-y', metavar='Y' * 25),
+        Sig('-z', metavar='Z' * 25),
+        Sig('a' * 25),
+        Sig('b' * 25),
+        Sig('c' * 25),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PROG [-h] [-x XXXXXXXXXXXXXXXXXXXXXXXXX] \
+[-y YYYYYYYYYYYYYYYYYYYYYYYYY]
+                    [-z ZZZZZZZZZZZZZZZZZZZZZZZZZ]
+                    aaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbb
+                    ccccccccccccccccccccccccc
+        '''
+    help = usage + '''\
+
+        positional arguments:
+          aaaaaaaaaaaaaaaaaaaaaaaaa
+          bbbbbbbbbbbbbbbbbbbbbbbbb
+          ccccccccccccccccccccccccc
+
+        optional arguments:
+          -h, --help            show this help message and exit
+          -x XXXXXXXXXXXXXXXXXXXXXXXXX
+          -y YYYYYYYYYYYYYYYYYYYYYYYYY
+          -z ZZZZZZZZZZZZZZZZZZZZZZZZZ
+        '''
+    version = ''
+
+
+class TestHelpUsageOptionalsOnlyWrap(HelpTestCase):
+    """Test usage messages where there are only optionals and they wrap"""
+
+    parser_signature = Sig(prog='PROG')
+    argument_signatures = [
+        Sig('-x', metavar='X' * 25),
+        Sig('-y', metavar='Y' * 25),
+        Sig('-z', metavar='Z' * 25),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PROG [-h] [-x XXXXXXXXXXXXXXXXXXXXXXXXX] \
+[-y YYYYYYYYYYYYYYYYYYYYYYYYY]
+                    [-z ZZZZZZZZZZZZZZZZZZZZZZZZZ]
+        '''
+    help = usage + '''\
+
+        optional arguments:
+          -h, --help            show this help message and exit
+          -x XXXXXXXXXXXXXXXXXXXXXXXXX
+          -y YYYYYYYYYYYYYYYYYYYYYYYYY
+          -z ZZZZZZZZZZZZZZZZZZZZZZZZZ
+        '''
+    version = ''
+
+
+class TestHelpUsagePositionalsOnlyWrap(HelpTestCase):
+    """Test usage messages where there are only positionals and they wrap"""
+
+    parser_signature = Sig(prog='PROG', add_help=False)
+    argument_signatures = [
+        Sig('a' * 25),
+        Sig('b' * 25),
+        Sig('c' * 25),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PROG aaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbb
+                    ccccccccccccccccccccccccc
+        '''
+    help = usage + '''\
+
+        positional arguments:
+          aaaaaaaaaaaaaaaaaaaaaaaaa
+          bbbbbbbbbbbbbbbbbbbbbbbbb
+          ccccccccccccccccccccccccc
+        '''
+    version = ''
+
+
+class TestHelpVariableExpansion(HelpTestCase):
+    """Test that variables are expanded properly in help messages"""
+
+    parser_signature = Sig(prog='PROG')
+    argument_signatures = [
+        Sig('-x', type=int,
+            help='x %(prog)s %(default)s %(type)s %%'),
+        Sig('-y', action='store_const', default=42, const='XXX',
+            help='y %(prog)s %(default)s %(const)s'),
+        Sig('--foo', choices='abc',
+            help='foo %(prog)s %(default)s %(choices)s'),
+        Sig('--bar', default='baz', choices=[1, 2], metavar='BBB',
+            help='bar %(prog)s %(default)s %(dest)s'),
+        Sig('spam', help='spam %(prog)s %(default)s'),
+        Sig('badger', default=0.5, help='badger %(prog)s %(default)s'),
+    ]
+    argument_group_signatures = [
+        (Sig('group'), [
+            Sig('-a', help='a %(prog)s %(default)s'),
+            Sig('-b', default=-1, help='b %(prog)s %(default)s'),
+        ])
+    ]
+    usage = ('''\
+        usage: PROG [-h] [-x X] [-y] [--foo {a,b,c}] [--bar BBB] [-a A] [-b B]
+                    spam badger
+        ''')
+    help = usage + '''\
+
+        positional arguments:
+          spam           spam PROG None
+          badger         badger PROG 0.5
+
+        optional arguments:
+          -h, --help     show this help message and exit
+          -x X           x PROG None int %
+          -y             y PROG 42 XXX
+          --foo {a,b,c}  foo PROG None a, b, c
+          --bar BBB      bar PROG baz bar
+
+        group:
+          -a A           a PROG None
+          -b B           b PROG -1
+        '''
+    version = ''
+
+
+class TestHelpVariableExpansionUsageSupplied(HelpTestCase):
+    """Test that variables are expanded properly when usage= is present"""
+
+    parser_signature = Sig(prog='PROG', usage='%(prog)s FOO')
+    argument_signatures = []
+    argument_group_signatures = []
+    usage = ('''\
+        usage: PROG FOO
+        ''')
+    help = usage + '''\
+
+        optional arguments:
+          -h, --help  show this help message and exit
+        '''
+    version = ''
+
+
+class TestHelpVariableExpansionNoArguments(HelpTestCase):
+    """Test that variables are expanded properly with no arguments"""
+
+    parser_signature = Sig(prog='PROG', add_help=False)
+    argument_signatures = []
+    argument_group_signatures = []
+    usage = ('''\
+        usage: PROG
+        ''')
+    help = usage
+    version = ''
+
+
+class TestHelpSuppressUsage(HelpTestCase):
+    """Test that items can be suppressed in usage messages"""
+
+    parser_signature = Sig(prog='PROG', usage=argparse.SUPPRESS)
+    argument_signatures = [
+        Sig('--foo', help='foo help'),
+        Sig('spam', help='spam help'),
+    ]
+    argument_group_signatures = []
+    help = '''\
+        positional arguments:
+          spam        spam help
+
+        optional arguments:
+          -h, --help  show this help message and exit
+          --foo FOO   foo help
+        '''
+    usage = ''
+    version = ''
+
+
+class TestHelpSuppressOptional(HelpTestCase):
+    """Test that optional arguments can be suppressed in help messages"""
+
+    parser_signature = Sig(prog='PROG', add_help=False)
+    argument_signatures = [
+        Sig('--foo', help=argparse.SUPPRESS),
+        Sig('spam', help='spam help'),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PROG spam
+        '''
+    help = usage + '''\
+
+        positional arguments:
+          spam  spam help
+        '''
+    version = ''
+
+
+class TestHelpSuppressOptionalGroup(HelpTestCase):
+    """Test that optional groups can be suppressed in help messages"""
+
+    parser_signature = Sig(prog='PROG')
+    argument_signatures = [
+        Sig('--foo', help='foo help'),
+        Sig('spam', help='spam help'),
+    ]
+    argument_group_signatures = [
+        (Sig('group'), [Sig('--bar', help=argparse.SUPPRESS)]),
+    ]
+    usage = '''\
+        usage: PROG [-h] [--foo FOO] spam
+        '''
+    help = usage + '''\
+
+        positional arguments:
+          spam        spam help
+
+        optional arguments:
+          -h, --help  show this help message and exit
+          --foo FOO   foo help
+        '''
+    version = ''
+
+
+class TestHelpSuppressPositional(HelpTestCase):
+    """Test that positional arguments can be suppressed in help messages"""
+
+    parser_signature = Sig(prog='PROG')
+    argument_signatures = [
+        Sig('--foo', help='foo help'),
+        Sig('spam', help=argparse.SUPPRESS),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PROG [-h] [--foo FOO]
+        '''
+    help = usage + '''\
+
+        optional arguments:
+          -h, --help  show this help message and exit
+          --foo FOO   foo help
+        '''
+    version = ''
+
+
+class TestHelpRequiredOptional(HelpTestCase):
+    """Test that required options don't look optional"""
+
+    parser_signature = Sig(prog='PROG')
+    argument_signatures = [
+        Sig('--foo', required=True, help='foo help'),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PROG [-h] --foo FOO
+        '''
+    help = usage + '''\
+
+        optional arguments:
+          -h, --help  show this help message and exit
+          --foo FOO   foo help
+        '''
+    version = ''
+
+
+class TestHelpAlternatePrefixChars(HelpTestCase):
+    """Test that options display with different prefix characters"""
+
+    parser_signature = Sig(prog='PROG', prefix_chars='^;', add_help=False)
+    argument_signatures = [
+        Sig('^^foo', action='store_true', help='foo help'),
+        Sig(';b', ';;bar', help='bar help'),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PROG [^^foo] [;b BAR]
+        '''
+    help = usage + '''\
+
+        optional arguments:
+          ^^foo              foo help
+          ;b BAR, ;;bar BAR  bar help
+        '''
+    version = ''
+
+
+class TestHelpNoHelpOptional(HelpTestCase):
+    """Test that the --help argument can be suppressed help messages"""
+
+    parser_signature = Sig(prog='PROG', add_help=False)
+    argument_signatures = [
+        Sig('--foo', help='foo help'),
+        Sig('spam', help='spam help'),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PROG [--foo FOO] spam
+        '''
+    help = usage + '''\
+
+        positional arguments:
+          spam       spam help
+
+        optional arguments:
+          --foo FOO  foo help
+        '''
+    version = ''
+
+
+class TestHelpVersionOptional(HelpTestCase):
+    """Test that the --version argument can be suppressed help messages"""
+
+    parser_signature = Sig(prog='PROG', version='1.0')
+    argument_signatures = [
+        Sig('--foo', help='foo help'),
+        Sig('spam', help='spam help'),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PROG [-h] [-v] [--foo FOO] spam
+        '''
+    help = usage + '''\
+
+        positional arguments:
+          spam           spam help
+
+        optional arguments:
+          -h, --help     show this help message and exit
+          -v, --version  show program's version number and exit
+          --foo FOO      foo help
+        '''
+    version = '''\
+        1.0
+        '''
+
+
+class TestHelpNone(HelpTestCase):
+    """Test that no errors occur if no help is specified"""
+
+    parser_signature = Sig(prog='PROG')
+    argument_signatures = [
+        Sig('--foo'),
+        Sig('spam'),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PROG [-h] [--foo FOO] spam
+        '''
+    help = usage + '''\
+
+        positional arguments:
+          spam
+
+        optional arguments:
+          -h, --help  show this help message and exit
+          --foo FOO
+        '''
+    version = ''
+
+
+class TestHelpTupleMetavar(HelpTestCase):
+    """Test specifying metavar as a tuple"""
+
+    parser_signature = Sig(prog='PROG')
+    argument_signatures = [
+        Sig('-w', help='w', nargs='+', metavar=('W1', 'W2')),
+        Sig('-x', help='x', nargs='*', metavar=('X1', 'X2')),
+        Sig('-y', help='y', nargs=3, metavar=('Y1', 'Y2', 'Y3')),
+        Sig('-z', help='z', nargs='?', metavar=('Z1', )),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PROG [-h] [-w W1 [W2 ...]] [-x [X1 [X2 ...]]] [-y Y1 Y2 Y3] \
+[-z [Z1]]
+        '''
+    help = usage + '''\
+
+        optional arguments:
+          -h, --help        show this help message and exit
+          -w W1 [W2 ...]    w
+          -x [X1 [X2 ...]]  x
+          -y Y1 Y2 Y3       y
+          -z [Z1]           z
+        '''
+    version = ''
+
+
+class TestHelpRawText(HelpTestCase):
+    """Test the RawTextHelpFormatter"""
+
+    parser_signature = Sig(
+        prog='PROG', formatter_class=argparse.RawTextHelpFormatter,
+        description='Keep the formatting\n'
+                    '    exactly as it is written\n'
+                    '\n'
+                    'here\n')
+
+    argument_signatures = [
+        Sig('--foo', help='    foo help should also\n'
+                          'appear as given here'),
+        Sig('spam', help='spam help'),
+    ]
+    argument_group_signatures = [
+        (Sig('title', description='    This text\n'
+                                  '  should be indented\n'
+                                  '    exactly like it is here\n'),
+         [Sig('--bar', help='bar help')]),
+    ]
+    usage = '''\
+        usage: PROG [-h] [--foo FOO] [--bar BAR] spam
+        '''
+    help = usage + '''\
+
+        Keep the formatting
+            exactly as it is written
+
+        here
+
+        positional arguments:
+          spam        spam help
+
+        optional arguments:
+          -h, --help  show this help message and exit
+          --foo FOO       foo help should also
+                      appear as given here
+
+        title:
+              This text
+            should be indented
+              exactly like it is here
+
+          --bar BAR   bar help
+        '''
+    version = ''
+
+
+class TestHelpRawDescription(HelpTestCase):
+    """Test the RawTextHelpFormatter"""
+
+    parser_signature = Sig(
+        prog='PROG', formatter_class=argparse.RawDescriptionHelpFormatter,
+        description='Keep the formatting\n'
+                    '    exactly as it is written\n'
+                    '\n'
+                    'here\n')
+
+    argument_signatures = [
+        Sig('--foo', help='  foo help should not\n'
+                          '    retain this odd formatting'),
+        Sig('spam', help='spam help'),
+    ]
+    argument_group_signatures = [
+        (Sig('title', description='    This text\n'
+                                  '  should be indented\n'
+                                  '    exactly like it is here\n'),
+         [Sig('--bar', help='bar help')]),
+    ]
+    usage = '''\
+        usage: PROG [-h] [--foo FOO] [--bar BAR] spam
+        '''
+    help = usage + '''\
+
+        Keep the formatting
+            exactly as it is written
+
+        here
+
+        positional arguments:
+          spam        spam help
+
+        optional arguments:
+          -h, --help  show this help message and exit
+          --foo FOO   foo help should not retain this odd formatting
+
+        title:
+              This text
+            should be indented
+              exactly like it is here
+
+          --bar BAR   bar help
+        '''
+    version = ''
+
+
+class TestHelpArgumentDefaults(HelpTestCase):
+    """Test the ArgumentDefaultsHelpFormatter"""
+
+    parser_signature = Sig(
+        prog='PROG', formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        description='description')
+
+    argument_signatures = [
+        Sig('--foo', help='foo help - oh and by the way, %(default)s'),
+        Sig('--bar', action='store_true', help='bar help'),
+        Sig('spam', help='spam help'),
+        Sig('badger', nargs='?', default='wooden', help='badger help'),
+    ]
+    argument_group_signatures = [
+        (Sig('title', description='description'),
+         [Sig('--baz', type=int, default=42, help='baz help')]),
+    ]
+    usage = '''\
+        usage: PROG [-h] [--foo FOO] [--bar] [--baz BAZ] spam [badger]
+        '''
+    help = usage + '''\
+
+        description
+
+        positional arguments:
+          spam        spam help
+          badger      badger help (default: wooden)
+
+        optional arguments:
+          -h, --help  show this help message and exit
+          --foo FOO   foo help - oh and by the way, None
+          --bar       bar help (default: False)
+
+        title:
+          description
+
+          --baz BAZ   baz help (default: 42)
+        '''
+    version = ''
+
+# =====================================
+# Optional/Positional constructor tests
+# =====================================
+
+class TestInvalidArgumentConstructors(TestCase):
+    """Test a bunch of invalid Argument constructors"""
+
+    def assertTypeError(self, *args, **kwargs):
+        parser = argparse.ArgumentParser()
+        self.assertRaises(TypeError, parser.add_argument,
+                          *args, **kwargs)
+
+    def assertValueError(self, *args, **kwargs):
+        parser = argparse.ArgumentParser()
+        self.assertRaises(ValueError, parser.add_argument,
+                          *args, **kwargs)
+
+    def test_invalid_keyword_arguments(self):
+        self.assertTypeError('-x', bar=None)
+        self.assertTypeError('-y', callback='foo')
+        self.assertTypeError('-y', callback_args=())
+        self.assertTypeError('-y', callback_kwargs={})
+
+    def test_missing_destination(self):
+        self.assertTypeError()
+        for action in ['append', 'store']:
+            self.assertTypeError(action=action)
+
+    def test_invalid_option_strings(self):
+        self.assertValueError('--')
+        self.assertValueError('---')
+
+    def test_invalid_type(self):
+        self.assertValueError('--foo', type='int')
+
+    def test_invalid_action(self):
+        self.assertValueError('-x', action='foo')
+        self.assertValueError('foo', action='baz')
+        parser = argparse.ArgumentParser()
+        try:
+            parser.add_argument("--foo", action="store-true")
+        except ValueError:
+            e = sys.exc_info()[1]
+            expected = 'unknown action'
+            msg = 'expected %r, found %r' % (expected, e)
+            self.failUnless(expected in str(e), msg)
+
+    def test_multiple_dest(self):
+        parser = argparse.ArgumentParser()
+        parser.add_argument(dest='foo')
+        try:
+            parser.add_argument('bar', dest='baz')
+        except ValueError:
+            e = sys.exc_info()[1]
+            expected = 'dest supplied twice for positional argument'
+            msg = 'expected %r, found %r' % (expected, e)
+            self.failUnless(expected in str(e), msg)
+
+    def test_no_argument_actions(self):
+        for action in ['store_const', 'store_true', 'store_false',
+                       'append_const', 'count']:
+            for attrs in [dict(type=int), dict(nargs='+'),
+                          dict(choices='ab')]:
+                self.assertTypeError('-x', action=action, **attrs)
+
+    def test_no_argument_no_const_actions(self):
+        # options with zero arguments
+        for action in ['store_true', 'store_false', 'count']:
+
+            # const is always disallowed
+            self.assertTypeError('-x', const='foo', action=action)
+
+            # nargs is always disallowed
+            self.assertTypeError('-x', nargs='*', action=action)
+
+    def test_more_than_one_argument_actions(self):
+        for action in ['store', 'append']:
+
+            # nargs=0 is disallowed
+            self.assertValueError('-x', nargs=0, action=action)
+            self.assertValueError('spam', nargs=0, action=action)
+
+            # const is disallowed with non-optional arguments
+            for nargs in [1, '*', '+']:
+                self.assertValueError('-x', const='foo',
+                                      nargs=nargs, action=action)
+                self.assertValueError('spam', const='foo',
+                                      nargs=nargs, action=action)
+
+    def test_required_const_actions(self):
+        for action in ['store_const', 'append_const']:
+
+            # nargs is always disallowed
+            self.assertTypeError('-x', nargs='+', action=action)
+
+    def test_parsers_action_missing_params(self):
+        self.assertTypeError('command', action='parsers')
+        self.assertTypeError('command', action='parsers', prog='PROG')
+        self.assertTypeError('command', action='parsers',
+                             parser_class=argparse.ArgumentParser)
+
+    def test_required_positional(self):
+        self.assertTypeError('foo', required=True)
+
+    def test_user_defined_action(self):
+
+        class Success(Exception):
+            pass
+
+        class Action(object):
+
+            def __init__(self,
+                         option_strings,
+                         dest,
+                         const,
+                         default,
+                         required=False):
+                if dest == 'spam':
+                    if const is Success:
+                        if default is Success:
+                            raise Success()
+
+            def __call__(self, *args, **kwargs):
+                pass
+
+        parser = argparse.ArgumentParser()
+        self.assertRaises(Success, parser.add_argument, '--spam',
+                          action=Action, default=Success, const=Success)
+        self.assertRaises(Success, parser.add_argument, 'spam',
+                          action=Action, default=Success, const=Success)
+
+# ================================
+# Actions returned by add_argument
+# ================================
+
+class TestActionsReturned(TestCase):
+
+    def test_dest(self):
+        parser = argparse.ArgumentParser()
+        action = parser.add_argument('--foo')
+        self.assertEqual(action.dest, 'foo')
+        action = parser.add_argument('-b', '--bar')
+        self.assertEqual(action.dest, 'bar')
+        action = parser.add_argument('-x', '-y')
+        self.assertEqual(action.dest, 'x')
+
+    def test_misc(self):
+        parser = argparse.ArgumentParser()
+        action = parser.add_argument('--foo', nargs='?', const=42,
+                                     default=84, type=int, choices=[1, 2],
+                                     help='FOO', metavar='BAR', dest='baz')
+        self.assertEqual(action.nargs, '?')
+        self.assertEqual(action.const, 42)
+        self.assertEqual(action.default, 84)
+        self.assertEqual(action.type, int)
+        self.assertEqual(action.choices, [1, 2])
+        self.assertEqual(action.help, 'FOO')
+        self.assertEqual(action.metavar, 'BAR')
+        self.assertEqual(action.dest, 'baz')
+
+
+# ================================
+# Argument conflict handling tests
+# ================================
+
+class TestConflictHandling(TestCase):
+
+    def test_bad_type(self):
+        self.assertRaises(ValueError, argparse.ArgumentParser,
+                          conflict_handler='foo')
+
+    def test_conflict_error(self):
+        parser = argparse.ArgumentParser()
+        parser.add_argument('-x')
+        self.assertRaises(argparse.ArgumentError,
+                          parser.add_argument, '-x')
+        parser.add_argument('--spam')
+        self.assertRaises(argparse.ArgumentError,
+                          parser.add_argument, '--spam')
+
+    def test_resolve_error(self):
+        get_parser = argparse.ArgumentParser
+        parser = get_parser(prog='PROG', conflict_handler='resolve')
+
+        parser.add_argument('-x', help='OLD X')
+        parser.add_argument('-x', help='NEW X')
+        self.assertEqual(parser.format_help(), textwrap.dedent('''\
+            usage: PROG [-h] [-x X]
+
+            optional arguments:
+              -h, --help  show this help message and exit
+              -x X        NEW X
+            '''))
+
+        parser.add_argument('--spam', metavar='OLD_SPAM')
+        parser.add_argument('--spam', metavar='NEW_SPAM')
+        self.assertEqual(parser.format_help(), textwrap.dedent('''\
+            usage: PROG [-h] [-x X] [--spam NEW_SPAM]
+
+            optional arguments:
+              -h, --help       show this help message and exit
+              -x X             NEW X
+              --spam NEW_SPAM
+            '''))
+
+
+# =============================
+# Help and Version option tests
+# =============================
+
+class TestOptionalsHelpVersionActions(TestCase):
+    """Test the help and version actions"""
+
+    def _get_error(self, func, *args, **kwargs):
+        try:
+            func(*args, **kwargs)
+        except ArgumentParserError:
+            return sys.exc_info()[1]
+        else:
+            self.assertRaises(ArgumentParserError, func, *args, **kwargs)
+
+    def assertPrintHelpExit(self, parser, args_str):
+        self.assertEqual(
+            parser.format_help(),
+            self._get_error(parser.parse_args, args_str.split()).stdout)
+
+    def assertPrintVersionExit(self, parser, args_str):
+        self.assertEqual(
+            parser.format_version(),
+            self._get_error(parser.parse_args, args_str.split()).stderr)
+
+    def assertArgumentParserError(self, parser, *args):
+        self.assertRaises(ArgumentParserError, parser.parse_args, args)
+
+    def test_version(self):
+        parser = ErrorRaisingArgumentParser(version='1.0')
+        self.assertPrintHelpExit(parser, '-h')
+        self.assertPrintHelpExit(parser, '--help')
+        self.assertPrintVersionExit(parser, '-v')
+        self.assertPrintVersionExit(parser, '--version')
+
+    def test_version_format(self):
+        parser = ErrorRaisingArgumentParser(prog='PPP', version='%(prog)s 3.5')
+        msg = self._get_error(parser.parse_args, ['-v']).stderr
+        self.assertEqual('PPP 3.5\n', msg)
+
+    def test_version_no_help(self):
+        parser = ErrorRaisingArgumentParser(add_help=False, version='1.0')
+        self.assertArgumentParserError(parser, '-h')
+        self.assertArgumentParserError(parser, '--help')
+        self.assertPrintVersionExit(parser, '-v')
+        self.assertPrintVersionExit(parser, '--version')
+
+    def test_version_action(self):
+        parser = ErrorRaisingArgumentParser(prog='XXX')
+        parser.add_argument('-V', action='version', version='%(prog)s 3.7')
+        msg = self._get_error(parser.parse_args, ['-V']).stderr
+        self.assertEqual('XXX 3.7\n', msg)
+
+    def test_no_help(self):
+        parser = ErrorRaisingArgumentParser(add_help=False)
+        self.assertArgumentParserError(parser, '-h')
+        self.assertArgumentParserError(parser, '--help')
+        self.assertArgumentParserError(parser, '-v')
+        self.assertArgumentParserError(parser, '--version')
+
+    def test_alternate_help_version(self):
+        parser = ErrorRaisingArgumentParser()
+        parser.add_argument('-x', action='help')
+        parser.add_argument('-y', action='version')
+        self.assertPrintHelpExit(parser, '-x')
+        self.assertPrintVersionExit(parser, '-y')
+        self.assertArgumentParserError(parser, '-v')
+        self.assertArgumentParserError(parser, '--version')
+
+    def test_help_version_extra_arguments(self):
+        parser = ErrorRaisingArgumentParser(version='1.0')
+        parser.add_argument('-x', action='store_true')
+        parser.add_argument('y')
+
+        # try all combinations of valid prefixes and suffixes
+        valid_prefixes = ['', '-x', 'foo', '-x bar', 'baz -x']
+        valid_suffixes = valid_prefixes + ['--bad-option', 'foo bar baz']
+        for prefix in valid_prefixes:
+            for suffix in valid_suffixes:
+                format = '%s %%s %s' % (prefix, suffix)
+            self.assertPrintHelpExit(parser, format % '-h')
+            self.assertPrintHelpExit(parser, format % '--help')
+            self.assertPrintVersionExit(parser, format % '-v')
+            self.assertPrintVersionExit(parser, format % '--version')
+
+
+# ======================
+# str() and repr() tests
+# ======================
+
+class TestStrings(TestCase):
+    """Test str()  and repr() on Optionals and Positionals"""
+
+    def assertStringEqual(self, obj, result_string):
+        for func in [str, repr]:
+            self.assertEqual(func(obj), result_string)
+
+    def test_optional(self):
+        option = argparse.Action(
+            option_strings=['--foo', '-a', '-b'],
+            dest='b',
+            type='int',
+            nargs='+',
+            default=42,
+            choices=[1, 2, 3],
+            help='HELP',
+            metavar='METAVAR')
+        string = (
+            "Action(option_strings=['--foo', '-a', '-b'], dest='b', "
+            "nargs='+', const=None, default=42, type='int', "
+            "choices=[1, 2, 3], help='HELP', metavar='METAVAR')")
+        self.assertStringEqual(option, string)
+
+    def test_argument(self):
+        argument = argparse.Action(
+            option_strings=[],
+            dest='x',
+            type=float,
+            nargs='?',
+            default=2.5,
+            choices=[0.5, 1.5, 2.5],
+            help='H HH H',
+            metavar='MV MV MV')
+        string = (
+            "Action(option_strings=[], dest='x', nargs='?', "
+            "const=None, default=2.5, type=%r, choices=[0.5, 1.5, 2.5], "
+            "help='H HH H', metavar='MV MV MV')" % float)
+        self.assertStringEqual(argument, string)
+
+    def test_namespace(self):
+        ns = argparse.Namespace(foo=42, bar='spam')
+        string = "Namespace(bar='spam', foo=42)"
+        self.assertStringEqual(ns, string)
+
+    def test_parser(self):
+        parser = argparse.ArgumentParser(prog='PROG')
+        string = (
+            "ArgumentParser(prog='PROG', usage=None, description=None, "
+            "version=None, formatter_class=%r, conflict_handler='error', "
+            "add_help=True)" % argparse.HelpFormatter)
+        self.assertStringEqual(parser, string)
+
+# ===============
+# Namespace tests
+# ===============
+
+class TestNamespace(TestCase):
+
+    def test_constructor(self):
+        ns = argparse.Namespace()
+        self.assertRaises(AttributeError, getattr, ns, 'x')
+
+        ns = argparse.Namespace(a=42, b='spam')
+        self.assertEqual(ns.a, 42)
+        self.assertEqual(ns.b, 'spam')
+
+    def test_equality(self):
+        ns1 = argparse.Namespace(a=1, b=2)
+        ns2 = argparse.Namespace(b=2, a=1)
+        ns3 = argparse.Namespace(a=1)
+        ns4 = argparse.Namespace(b=2)
+
+        self.assertEqual(ns1, ns2)
+        self.assertNotEqual(ns1, ns3)
+        self.assertNotEqual(ns1, ns4)
+        self.assertNotEqual(ns2, ns3)
+        self.assertNotEqual(ns2, ns4)
+        self.failUnless(ns1 != ns3)
+        self.failUnless(ns1 != ns4)
+        self.failUnless(ns2 != ns3)
+        self.failUnless(ns2 != ns4)
+
+
+# ===================
+# File encoding tests
+# ===================
+
+class TestEncoding(TestCase):
+
+    def _test_module_encoding(self, path):
+        path, _ = os.path.splitext(path)
+        path += ".py"
+        codecs.open(path, 'r', 'utf8').read()
+
+    def test_argparse_module_encoding(self):
+        self._test_module_encoding(argparse.__file__)
+
+    def test_test_argparse_module_encoding(self):
+        self._test_module_encoding(__file__)
+
+# ===================
+# ArgumentError tests
+# ===================
+
+class TestArgumentError(TestCase):
+
+    def test_argument_error(self):
+        msg = "my error here"
+        error = argparse.ArgumentError(None, msg)
+        self.failUnlessEqual(str(error), msg)
+
+# =======================
+# ArgumentTypeError tests
+# =======================
+
+class TestArgumentError(TestCase):
+
+    def test_argument_type_error(self):
+
+        def spam(string):
+            raise argparse.ArgumentTypeError('spam!')
+
+        parser = ErrorRaisingArgumentParser(prog='PROG', add_help=False)
+        parser.add_argument('x', type=spam)
+        try:
+            parser.parse_args(['XXX'])
+        except ArgumentParserError:
+            expected = 'usage: PROG x\nPROG: error: argument x: spam!\n'
+            msg = sys.exc_info()[1].stderr
+            self.failUnlessEqual(expected, msg)
+        else:
+            self.fail()
+
+# ======================
+# parse_known_args tests
+# ======================
+
+class TestParseKnownArgs(TestCase):
+
+    def test_optionals(self):
+        parser = argparse.ArgumentParser()
+        parser.add_argument('--foo')
+        args, extras = parser.parse_known_args('--foo F --bar --baz'.split())
+        self.failUnlessEqual(NS(foo='F'), args)
+        self.failUnlessEqual(['--bar', '--baz'], extras)
+
+    def test_mixed(self):
+        parser = argparse.ArgumentParser()
+        parser.add_argument('-v', nargs='?', const=1, type=int)
+        parser.add_argument('--spam', action='store_false')
+        parser.add_argument('badger')
+
+        argv = ["B", "C", "--foo", "-v", "3", "4"]
+        args, extras = parser.parse_known_args(argv)
+        self.failUnlessEqual(NS(v=3, spam=True, badger="B"), args)
+        self.failUnlessEqual(["C", "--foo", "4"], extras)
+
+# ============================
+# from argparse import * tests
+# ============================
+
+class TestImportStar(TestCase):
+
+    def test(self):
+        for name in argparse.__all__:
+            self.failUnless(hasattr(argparse, name))
+
+
+if __name__ == '__main__':
+    unittest.main()