--- /dev/null
+:mod:`argparse` -- Parser for command line options, arguments and sub-commands\r
+==============================================================================\r
+\r
+.. module:: argparse\r
+ :synopsis: Command-line option and argument parsing library.\r
+.. moduleauthor:: Steven Bethard <steven.bethard@gmail.com>\r
+.. versionadded:: 2.7\r
+.. sectionauthor:: Steven Bethard <steven.bethard@gmail.com>\r
+\r
+\r
+The :mod:`argparse` module makes it easy to write user friendly command line\r
+interfaces. You define what arguments your program requires, and\r
+:mod:`argparse` will figure out how to parse those out of ``sys.argv``. The\r
+:mod:`argparse` module also automatically generates help and usage messages\r
+based on the arguments you have defined, and issues errors when users give your\r
+program invalid arguments.\r
+\r
+Example\r
+-------\r
+\r
+As an example, the following code is a Python program that takes a list of\r
+integers and produces either the sum or the max::\r
+\r
+ import argparse\r
+\r
+ parser = argparse.ArgumentParser(description='Process some integers.')\r
+ parser.add_argument('integers', metavar='N', type=int, nargs='+',\r
+ help='an integer for the accumulator')\r
+ parser.add_argument('--sum', dest='accumulate', action='store_const',\r
+ const=sum, default=max,\r
+ help='sum the integers (default: find the max)')\r
+\r
+ args = parser.parse_args()\r
+ print args.accumulate(args.integers)\r
+\r
+Assuming the Python code above is saved into a file called ``prog.py``, it can\r
+be run at the command line and provides useful help messages::\r
+\r
+ $ prog.py -h\r
+ usage: prog.py [-h] [--sum] N [N ...]\r
+\r
+ Process some integers.\r
+\r
+ positional arguments:\r
+ N an integer for the accumulator\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ --sum sum the integers (default: find the max)\r
+\r
+When run with the appropriate arguments, it prints either the sum or the max of\r
+the command-line integers::\r
+\r
+ $ prog.py 1 2 3 4\r
+ 4\r
+\r
+ $ prog.py 1 2 3 4 --sum\r
+ 10\r
+\r
+If invalid arguments are passed in, it will issue an error::\r
+\r
+ $ prog.py a b c\r
+ usage: prog.py [-h] [--sum] N [N ...]\r
+ prog.py: error: argument N: invalid int value: 'a'\r
+\r
+The following sections walk you through this example.\r
+\r
+Creating a parser\r
+^^^^^^^^^^^^^^^^^\r
+\r
+Pretty much every script that uses the :mod:`argparse` module will start out by\r
+creating an :class:`ArgumentParser` object::\r
+\r
+ >>> parser = argparse.ArgumentParser(description='Process some integers.')\r
+\r
+The :class:`ArgumentParser` object will hold all the information necessary to\r
+parse the command line into a more manageable form for your program.\r
+\r
+\r
+Adding arguments\r
+^^^^^^^^^^^^^^^^\r
+\r
+Once you've created an :class:`ArgumentParser`, you'll want to fill it with\r
+information about your program arguments. You typically do this by making calls\r
+to the :meth:`add_argument` method. Generally, these calls tell the\r
+:class:`ArgumentParser` how to take the strings on the command line and turn\r
+them into objects for you. This information is stored and used when\r
+:meth:`parse_args` is called. For example, if we add some arguments like this::\r
+\r
+ >>> parser.add_argument('integers', metavar='N', type=int, nargs='+',\r
+ ... help='an integer for the accumulator')\r
+ >>> parser.add_argument('--sum', dest='accumulate', action='store_const',\r
+ ... const=sum, default=max,\r
+ ... help='sum the integers (default: find the max)')\r
+\r
+when we later call :meth:`parse_args`, we can expect it to return an object\r
+with two attributes, ``integers`` and ``accumulate``. The ``integers``\r
+attribute will be a list of one or more ints, and the ``accumulate`` attribute\r
+will be either the ``sum`` function, if ``--sum`` was specified at the command\r
+line, or the ``max`` function if it was not.\r
+\r
+Parsing arguments\r
+^^^^^^^^^^^^^^^^^\r
+\r
+Once an :class:`ArgumentParser` has been initialized with appropriate calls to\r
+:meth:`add_argument`, it can be instructed to parse the command-line args by\r
+calling the :meth:`parse_args` method. This will inspect the command-line,\r
+convert each arg to the appropriate type and then invoke the appropriate\r
+action. In most cases, this means a simple namespace object will be built up\r
+from attributes parsed out of the command-line::\r
+\r
+ >>> parser.parse_args(['--sum', '7', '-1', '42'])\r
+ Namespace(accumulate=<built-in function sum>, integers=[7, -1, 42])\r
+\r
+In a script, :meth:`parse_args` will typically be called with no arguments, and\r
+the :class:`ArgumentParser` will automatically determine the command-line args\r
+from ``sys.argv``. That's pretty much it. You're now ready to go write some\r
+command line interfaces!\r
+\r
+\r
+ArgumentParser objects\r
+----------------------\r
+\r
+.. class:: ArgumentParser([description], [epilog], [prog], [usage], [add_help], [argument_default], [parents], [prefix_chars], [conflict_handler], [formatter_class])\r
+\r
+ Create a new :class:`ArgumentParser` object. Each parameter has its own more\r
+ detailed description below, but in short they are:\r
+\r
+ * description_ - Text to display before the argument help.\r
+\r
+ * epilog_ - Text to display after the argument help.\r
+\r
+ * add_help_ - Add a -h/--help option to the parser. (default: True)\r
+\r
+ * argument_default_ - Set the global default value for arguments.\r
+ (default: None)\r
+\r
+ * parents_ - A list of :class:ArgumentParser objects whose arguments should\r
+ also be included.\r
+\r
+ * prefix_chars_ - The set of characters that prefix optional arguments.\r
+ (default: '-')\r
+\r
+ * fromfile_prefix_chars_ - The set of characters that prefix files from\r
+ which additional arguments should be read. (default: None)\r
+\r
+ * formatter_class_ - A class for customizing the help output.\r
+\r
+ * conflict_handler_ - Usually unnecessary, defines strategy for resolving\r
+ conflicting optionals.\r
+\r
+ * prog_ - Usually unnecessary, the name of the program\r
+ (default: ``sys.argv[0]``)\r
+\r
+ * usage_ - Usually unnecessary, the string describing the program usage\r
+ (default: generated)\r
+\r
+ The following sections describe how each of these are used.\r
+\r
+\r
+description\r
+^^^^^^^^^^^\r
+\r
+Most calls to the ArgumentParser constructor will use the ``description=``\r
+keyword argument. This argument gives a brief description of what the program\r
+does and how it works. In help messages, the description is displayed between\r
+the command-line usage string and the help messages for the various arguments::\r
+\r
+ >>> parser = argparse.ArgumentParser(description='A foo that bars')\r
+ >>> parser.print_help()\r
+ usage: argparse.py [-h]\r
+\r
+ A foo that bars\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+\r
+By default, the description will be line-wrapped so that it fits within the\r
+given space. To change this behavior, see the formatter_class_ argument.\r
+\r
+\r
+epilog\r
+^^^^^^\r
+\r
+Some programs like to display additional description of the program after the\r
+description of the arguments. Such text can be specified using the ``epilog=``\r
+argument to ArgumentParser::\r
+\r
+ >>> parser = argparse.ArgumentParser(\r
+ ... description='A foo that bars',\r
+ ... epilog="And that's how you'd foo a bar")\r
+ >>> parser.print_help()\r
+ usage: argparse.py [-h]\r
+\r
+ A foo that bars\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+\r
+ And that's how you'd foo a bar\r
+\r
+As with the description_ argument, the ``epilog=`` text is by default\r
+line-wrapped, but this behavior can be adjusted with the formatter_class_\r
+argument to ArgumentParser.\r
+\r
+\r
+add_help\r
+^^^^^^^^\r
+\r
+By default, ArgumentParser objects add a ``-h/--help`` option which simply\r
+displays the parser's help message. For example, consider a file named\r
+``myprogram.py`` containing the following code::\r
+\r
+ import argparse\r
+ parser = argparse.ArgumentParser()\r
+ parser.add_argument('--foo', help='foo help')\r
+ args = parser.parse_args()\r
+\r
+If ``-h`` or ``--help`` is supplied is at the command-line, the ArgumentParser\r
+help will be printed::\r
+\r
+ $ python myprogram.py --help\r
+ usage: myprogram.py [-h] [--foo FOO]\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ --foo FOO foo help\r
+\r
+Occasionally, it may be useful to disable the addition of this help option.\r
+This can be achieved by passing ``False`` as the ``add_help=`` argument to\r
+ArgumentParser::\r
+\r
+ >>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)\r
+ >>> parser.add_argument('--foo', help='foo help')\r
+ >>> parser.print_help()\r
+ usage: PROG [--foo FOO]\r
+\r
+ optional arguments:\r
+ --foo FOO foo help\r
+\r
+\r
+prefix_chars\r
+^^^^^^^^^^^^\r
+\r
+Most command-line options will use ``'-'`` as the prefix, e.g. ``-f/--foo``.\r
+Parsers that need to support additional prefix characters, e.g. for options\r
+like ``+f`` or ``/foo``, may specify them using the ``prefix_chars=`` argument\r
+to the ArgumentParser constructor::\r
+\r
+ >>> parser = argparse.ArgumentParser(prog='PROG', prefix_chars='-+')\r
+ >>> parser.add_argument('+f')\r
+ >>> parser.add_argument('++bar')\r
+ >>> parser.parse_args('+f X ++bar Y'.split())\r
+ Namespace(bar='Y', f='X')\r
+\r
+The ``prefix_chars=`` argument defaults to ``'-'``. Supplying a set of\r
+characters that does not include ``'-'`` will cause ``-f/--foo`` options to be\r
+disallowed.\r
+\r
+\r
+fromfile_prefix_chars\r
+^^^^^^^^^^^^^^^^^^^^^\r
+\r
+Sometimes, e.g. for particularly long argument lists, it may make sense to\r
+keep the list of arguments in a file rather than typing it out at the command\r
+line. If the ``fromfile_prefix_chars=`` argument is given to the ArgumentParser\r
+constructor, then arguments that start with any of the specified characters\r
+will be treated as files, and will be replaced by the arguments they contain.\r
+For example::\r
+\r
+ >>> open('args.txt', 'w').write('-f\nbar')\r
+ >>> parser = argparse.ArgumentParser(fromfile_prefix_chars='@')\r
+ >>> parser.add_argument('-f')\r
+ >>> parser.parse_args(['-f', 'foo', '@args.txt'])\r
+ Namespace(f='bar')\r
+\r
+Arguments read from a file must by default be one per line (but see also\r
+:meth:`convert_arg_line_to_args`) and are treated as if they were in the same\r
+place as the original file referencing argument on the command line. So in the\r
+example above, the expression ``['-f', 'foo', '@args.txt']`` is considered\r
+equivalent to the expression ``['-f', 'foo', '-f', 'bar']``.\r
+\r
+The ``fromfile_prefix_chars=`` argument defaults to ``None``, meaning that\r
+arguments will never be treated as file references.\r
+\r
+argument_default\r
+^^^^^^^^^^^^^^^^\r
+\r
+Generally, argument defaults are specified either by passing a default to\r
+:meth:`add_argument` or by calling the :meth:`set_defaults` methods with a\r
+specific set of name-value pairs. Sometimes however, it may be useful to\r
+specify a single parser-wide default for arguments. This can be accomplished by\r
+passing the ``argument_default=`` keyword argument to ArgumentParser. For\r
+example, to globally suppress attribute creation on :meth:`parse_args` calls,\r
+we supply ``argument_default=SUPPRESS``::\r
+\r
+ >>> parser = argparse.ArgumentParser(argument_default=argparse.SUPPRESS)\r
+ >>> parser.add_argument('--foo')\r
+ >>> parser.add_argument('bar', nargs='?')\r
+ >>> parser.parse_args(['--foo', '1', 'BAR'])\r
+ Namespace(bar='BAR', foo='1')\r
+ >>> parser.parse_args([])\r
+ Namespace()\r
+\r
+\r
+parents\r
+^^^^^^^\r
+\r
+Sometimes, several parsers share a common set of arguments. Rather than\r
+repeating the definitions of these arguments, you can define a single parser\r
+with all the shared arguments and then use the ``parents=`` argument to\r
+ArgumentParser to have these "inherited". The ``parents=`` argument takes a\r
+list of ArgumentParser objects, collects all the positional and optional\r
+actions from them, and adds these actions to the ArgumentParser object being\r
+constructed::\r
+\r
+ >>> parent_parser = argparse.ArgumentParser(add_help=False)\r
+ >>> parent_parser.add_argument('--parent', type=int)\r
+\r
+ >>> foo_parser = argparse.ArgumentParser(parents=[parent_parser])\r
+ >>> foo_parser.add_argument('foo')\r
+ >>> foo_parser.parse_args(['--parent', '2', 'XXX'])\r
+ Namespace(foo='XXX', parent=2)\r
+\r
+ >>> bar_parser = argparse.ArgumentParser(parents=[parent_parser])\r
+ >>> bar_parser.add_argument('--bar')\r
+ >>> bar_parser.parse_args(['--bar', 'YYY'])\r
+ Namespace(bar='YYY', parent=None)\r
+\r
+Note that most parent parsers will specify ``add_help=False``. Otherwise, the\r
+ArgumentParser will see two ``-h/--help`` options (one in the parent and one in\r
+the child) and raise an error.\r
+\r
+\r
+formatter_class\r
+^^^^^^^^^^^^^^^\r
+\r
+ArgumentParser objects allow the help formatting to be customized by specifying\r
+an alternate formatting class. Currently, there are three such classes:\r
+``argparse.RawDescriptionHelpFormatter``, ``argparse.RawTextHelpFormatter`` and\r
+``argparse.ArgumentDefaultsHelpFormatter``. The first two allow more control\r
+over how textual descriptions are displayed, while the last automatically adds\r
+information about argument default values.\r
+\r
+By default, ArgumentParser objects line-wrap the description_ and epilog_ texts\r
+in command-line help messages::\r
+\r
+ >>> parser = argparse.ArgumentParser(\r
+ ... prog='PROG',\r
+ ... description='''this description\r
+ ... was indented weird\r
+ ... but that is okay''',\r
+ ... epilog='''\r
+ ... likewise for this epilog whose whitespace will\r
+ ... be cleaned up and whose words will be wrapped\r
+ ... across a couple lines''')\r
+ >>> parser.print_help()\r
+ usage: PROG [-h]\r
+\r
+ this description was indented weird but that is okay\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+\r
+ likewise for this epilog whose whitespace will be cleaned up and whose words\r
+ will be wrapped across a couple lines\r
+\r
+When you have description_ and epilog_ that is already correctly formatted and\r
+should not be line-wrapped, you can indicate this by passing\r
+``argparse.RawDescriptionHelpFormatter`` as the ``formatter_class=`` argument\r
+to ArgumentParser::\r
+\r
+ >>> parser = argparse.ArgumentParser(\r
+ ... prog='PROG',\r
+ ... formatter_class=argparse.RawDescriptionHelpFormatter,\r
+ ... description=textwrap.dedent('''\\r
+ ... Please do not mess up this text!\r
+ ... --------------------------------\r
+ ... I have indented it\r
+ ... exactly the way\r
+ ... I want it\r
+ ... '''))\r
+ >>> parser.print_help()\r
+ usage: PROG [-h]\r
+\r
+ Please do not mess up this text!\r
+ --------------------------------\r
+ I have indented it\r
+ exactly the way\r
+ I want it\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+\r
+If you want to maintain whitespace for all sorts of help text (including\r
+argument descriptions), you can use ``argparse.RawTextHelpFormatter``.\r
+\r
+The other formatter class available,\r
+``argparse.ArgumentDefaultsHelpFormatter``, will add information about the\r
+default value of each of the arguments::\r
+\r
+ >>> parser = argparse.ArgumentParser(\r
+ ... prog='PROG',\r
+ ... formatter_class=argparse.ArgumentDefaultsHelpFormatter)\r
+ >>> parser.add_argument('--foo', type=int, default=42, help='FOO!')\r
+ >>> parser.add_argument('bar', nargs='*', default=[1, 2, 3], help='BAR!')\r
+ >>> parser.print_help()\r
+ usage: PROG [-h] [--foo FOO] [bar [bar ...]]\r
+\r
+ positional arguments:\r
+ bar BAR! (default: [1, 2, 3])\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ --foo FOO FOO! (default: 42)\r
+\r
+\r
+conflict_handler\r
+^^^^^^^^^^^^^^^^\r
+\r
+ArgumentParser objects do not allow two actions with the same option string.\r
+By default, ArgumentParser objects will raise an exception if you try to create\r
+an argument with an option string that is already in use::\r
+\r
+ >>> parser = argparse.ArgumentParser(prog='PROG')\r
+ >>> parser.add_argument('-f', '--foo', help='old foo help')\r
+ >>> parser.add_argument('--foo', help='new foo help')\r
+ Traceback (most recent call last):\r
+ ..\r
+ ArgumentError: argument --foo: conflicting option string(s): --foo\r
+\r
+Sometimes (e.g. when using parents_) it may be useful to simply override any\r
+older arguments with the same option string. To get this behavior, the value\r
+``'resolve'`` can be supplied to the ``conflict_handler=`` argument of\r
+ArgumentParser::\r
+\r
+ >>> parser = argparse.ArgumentParser(prog='PROG', conflict_handler='resolve')\r
+ >>> parser.add_argument('-f', '--foo', help='old foo help')\r
+ >>> parser.add_argument('--foo', help='new foo help')\r
+ >>> parser.print_help()\r
+ usage: PROG [-h] [-f FOO] [--foo FOO]\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ -f FOO old foo help\r
+ --foo FOO new foo help\r
+\r
+Note that ArgumentParser objects only remove an action if all of its option\r
+strings are overridden. So, in the example above, the old ``-f/--foo`` action\r
+is retained as the ``-f`` action, because only the ``--foo`` option string was\r
+overridden.\r
+\r
+\r
+prog\r
+^^^^\r
+\r
+By default, ArgumentParser objects use ``sys.argv[0]`` to determine how to\r
+display the name of the program in help messages. This default is almost always\r
+what you want because it will make the help messages match what your users have\r
+typed at the command line. For example, consider a file named ``myprogram.py``\r
+with the following code::\r
+\r
+ import argparse\r
+ parser = argparse.ArgumentParser()\r
+ parser.add_argument('--foo', help='foo help')\r
+ args = parser.parse_args()\r
+\r
+The help for this program will display ``myprogram.py`` as the program name\r
+(regardless of where the program was invoked from)::\r
+\r
+ $ python myprogram.py --help\r
+ usage: myprogram.py [-h] [--foo FOO]\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ --foo FOO foo help\r
+ $ cd ..\r
+ $ python subdir\myprogram.py --help\r
+ usage: myprogram.py [-h] [--foo FOO]\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ --foo FOO foo help\r
+\r
+To change this default behavior, another value can be supplied using the\r
+``prog=`` argument to ArgumentParser::\r
+\r
+ >>> parser = argparse.ArgumentParser(prog='myprogram')\r
+ >>> parser.print_help()\r
+ usage: myprogram [-h]\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+\r
+Note that the program name, whether determined from ``sys.argv[0]`` or from the\r
+``prog=`` argument, is available to help messages using the ``%(prog)s`` format\r
+specifier.\r
+\r
+::\r
+\r
+ >>> parser = argparse.ArgumentParser(prog='myprogram')\r
+ >>> parser.add_argument('--foo', help='foo of the %(prog)s program')\r
+ >>> parser.print_help()\r
+ usage: myprogram [-h] [--foo FOO]\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ --foo FOO foo of the myprogram program\r
+\r
+\r
+usage\r
+^^^^^\r
+\r
+By default, ArgumentParser objects calculate the usage message from the\r
+arguments it contains::\r
+\r
+ >>> parser = argparse.ArgumentParser(prog='PROG')\r
+ >>> parser.add_argument('--foo', nargs='?', help='foo help')\r
+ >>> parser.add_argument('bar', nargs='+', help='bar help')\r
+ >>> parser.print_help()\r
+ usage: PROG [-h] [--foo [FOO]] bar [bar ...]\r
+\r
+ positional arguments:\r
+ bar bar help\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ --foo [FOO] foo help\r
+\r
+If the default usage message is not appropriate for your application, you can\r
+supply your own usage message using the ``usage=`` keyword argument to\r
+ArgumentParser::\r
+\r
+ >>> parser = argparse.ArgumentParser(prog='PROG', usage='%(prog)s [options]')\r
+ >>> parser.add_argument('--foo', nargs='?', help='foo help')\r
+ >>> parser.add_argument('bar', nargs='+', help='bar help')\r
+ >>> parser.print_help()\r
+ usage: PROG [options]\r
+\r
+ positional arguments:\r
+ bar bar help\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ --foo [FOO] foo help\r
+\r
+Note you can use the ``%(prog)s`` format specifier to fill in the program name\r
+in your usage messages.\r
+\r
+\r
+The add_argument() method\r
+-------------------------\r
+\r
+.. method:: add_argument(name or flags..., [action], [nargs], [const], [default], [type], [choices], [required], [help], [metavar], [dest])\r
+\r
+ Define how a single command line argument should be parsed. Each parameter\r
+ has its own more detailed description below, but in short they are:\r
+\r
+ * `name or flags`_ - Either a name or a list of option strings, e.g. ``foo``\r
+ or ``-f, --foo``\r
+\r
+ * action_ - The basic type of action to be taken when this argument is\r
+ encountered at the command-line.\r
+\r
+ * nargs_ - The number of command-line arguments that should be consumed.\r
+\r
+ * const_ - A constant value required by some action_ and nargs_ selections.\r
+\r
+ * default_ - The value produced if the argument is absent from the\r
+ command-line.\r
+\r
+ * type_ - The type to which the command-line arg should be converted.\r
+\r
+ * choices_ - A container of the allowable values for the argument.\r
+\r
+ * required_ - Whether or not the command-line option may be omitted\r
+ (optionals only).\r
+\r
+ * help_ - A brief description of what the argument does.\r
+\r
+ * metavar_ - A name for the argument in usage messages.\r
+\r
+ * dest_ - The name of the attribute to be added to the object returned by\r
+ :meth:`parse_args`.\r
+\r
+ The following sections describe how each of these are used.\r
+\r
+name or flags\r
+^^^^^^^^^^^^^\r
+\r
+The :meth:`add_argument` method needs to know whether you're expecting an\r
+optional argument, e.g. ``-f`` or ``--foo``, or a positional argument, e.g. a\r
+list of filenames. The first arguments passed to :meth:`add_argument` must\r
+therefore be either a series of flags, or a simple argument name. For example,\r
+an optional argument could be created like::\r
+\r
+ >>> parser.add_argument('-f', '--foo')\r
+\r
+while a positional argument could be created like::\r
+\r
+ >>> parser.add_argument('bar')\r
+\r
+When :meth:`parse_args` is called, optional arguments will be identified by the\r
+``-`` prefix, and the remaining arguments will be assumed to be positional::\r
+\r
+ >>> parser = argparse.ArgumentParser(prog='PROG')\r
+ >>> parser.add_argument('-f', '--foo')\r
+ >>> parser.add_argument('bar')\r
+ >>> parser.parse_args(['BAR'])\r
+ Namespace(bar='BAR', foo=None)\r
+ >>> parser.parse_args(['BAR', '--foo', 'FOO'])\r
+ Namespace(bar='BAR', foo='FOO')\r
+ >>> parser.parse_args(['--foo', 'FOO'])\r
+ usage: PROG [-h] [-f FOO] bar\r
+ PROG: error: too few arguments\r
+\r
+action\r
+^^^^^^\r
+\r
+:class:`ArgumentParser` objects associate command-line args with actions. These\r
+actions can do just about anything with the command-line args associated with\r
+them, though most actions simply add an attribute to the object returned by\r
+:meth:`parse_args`. When you specify a new argument using the\r
+:meth:`add_argument` method, you can indicate how the command-line args should\r
+be handled by specifying the ``action`` keyword argument. The supported actions\r
+are:\r
+\r
+* ``'store'`` - This just stores the argument's value. This is the default\r
+ action. For example::\r
+\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> parser.add_argument('--foo')\r
+ >>> parser.parse_args('--foo 1'.split())\r
+ Namespace(foo='1')\r
+\r
+* ``'store_const'`` - This stores the value specified by the const_ keyword\r
+ argument. Note that the const_ keyword argument defaults to ``None``, so\r
+ you'll almost always need to provide a value for it. The ``'store_const'``\r
+ action is most commonly used with optional arguments that specify some sort\r
+ of flag. For example::\r
+\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> parser.add_argument('--foo', action='store_const', const=42)\r
+ >>> parser.parse_args('--foo'.split())\r
+ Namespace(foo=42)\r
+\r
+* ``'store_true'`` and ``'store_false'`` - These store the values ``True`` and\r
+ ``False`` respectively. These are basically special cases of\r
+ ``'store_const'``. For example::\r
+\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> parser.add_argument('--foo', action='store_true')\r
+ >>> parser.add_argument('--bar', action='store_false')\r
+ >>> parser.parse_args('--foo --bar'.split())\r
+ Namespace(bar=False, foo=True)\r
+\r
+* ``'append'`` - This stores a list, and appends each argument value to the\r
+ list. This is useful when you want to allow an option to be specified\r
+ multiple times. Example usage::\r
+\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> parser.add_argument('--foo', action='append')\r
+ >>> parser.parse_args('--foo 1 --foo 2'.split())\r
+ Namespace(foo=['1', '2'])\r
+\r
+* ``'append_const'`` - This stores a list, and appends the value specified by\r
+ the const_ keyword argument to the list. Note that the const_ keyword\r
+ argument defaults to ``None``, so you'll almost always need to provide a\r
+ value for it. The ``'append_const'`` action is typically useful when you\r
+ want multiple arguments to store constants to the same list, for example::\r
+\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> parser.add_argument('--str', dest='types', action='append_const', const=str)\r
+ >>> parser.add_argument('--int', dest='types', action='append_const', const=int)\r
+ >>> parser.parse_args('--str --int'.split())\r
+ Namespace(types=[<type 'str'>, <type 'int'>])\r
+\r
+* ``'version'`` - This expects a ``version=`` keyword argument in the\r
+ :meth:`add_argument` call, and prints version information and exits when\r
+ invoked.\r
+\r
+ >>> import argparse\r
+ >>> parser = argparse.ArgumentParser(prog='PROG')\r
+ >>> parser.add_argument('-v', '--version', action='version', version='%(prog)s 2.0')\r
+ >>> parser.parse_args(['-v'])\r
+ PROG 2.0\r
+\r
+You can also specify an arbitrary action by passing an object that implements\r
+the Action API. The easiest way to do this is to extend ``argparse.Action``,\r
+supplying an appropriate ``__call__`` method. The ``__call__`` method accepts\r
+four parameters:\r
+\r
+* ``parser`` - The ArgumentParser object which contains this action.\r
+\r
+* ``namespace`` - The namespace object that will be returned by\r
+ :meth:`parse_args`. Most actions add an attribute to this object.\r
+\r
+* ``values`` - The associated command-line args, with any type-conversions\r
+ applied. (Type-conversions are specified with the type_ keyword argument to\r
+ :meth:`add_argument`.\r
+\r
+* ``option_string`` - The option string that was used to invoke this action.\r
+ The ``option_string`` argument is optional, and will be absent if the action\r
+ is associated with a positional argument.\r
+\r
+So for example::\r
+\r
+ >>> class FooAction(argparse.Action):\r
+ ... def __call__(self, parser, namespace, values, option_string=None):\r
+ ... print '%r %r %r' % (namespace, values, option_string)\r
+ ... setattr(namespace, self.dest, values)\r
+ ...\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> parser.add_argument('--foo', action=FooAction)\r
+ >>> parser.add_argument('bar', action=FooAction)\r
+ >>> args = parser.parse_args('1 --foo 2'.split())\r
+ Namespace(bar=None, foo=None) '1' None\r
+ Namespace(bar='1', foo=None) '2' '--foo'\r
+ >>> args\r
+ Namespace(bar='1', foo='2')\r
+\r
+\r
+nargs\r
+^^^^^\r
+\r
+ArgumentParser objects usually associate a single command-line argument with a\r
+single action to be taken. In the situations where you'd like to associate a\r
+different number of command-line arguments with a single action, you can use\r
+the ``nargs`` keyword argument to :meth:`add_argument`. The supported values\r
+are:\r
+\r
+* N (an integer). N args from the command-line will be gathered together into\r
+ a list. For example::\r
+\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> parser.add_argument('--foo', nargs=2)\r
+ >>> parser.add_argument('bar', nargs=1)\r
+ >>> parser.parse_args('c --foo a b'.split())\r
+ Namespace(bar=['c'], foo=['a', 'b'])\r
+\r
+ Note that ``nargs=1`` produces a list of one item. This is different from\r
+ the default, in which the item is produced by itself.\r
+\r
+* ``'?'``. One arg will be consumed from the command-line if possible, and\r
+ produced as a single item. If no command-line arg is present, the value from\r
+ default_ will be produced. Note that for optional arguments, there is an\r
+ additional case - the option string is present but not followed by a\r
+ command-line arg. In this case the value from const_ will be produced. Some\r
+ examples to illustrate this::\r
+\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> parser.add_argument('--foo', nargs='?', const='c', default='d')\r
+ >>> parser.add_argument('bar', nargs='?', default='d')\r
+ >>> parser.parse_args('XX --foo YY'.split())\r
+ Namespace(bar='XX', foo='YY')\r
+ >>> parser.parse_args('XX --foo'.split())\r
+ Namespace(bar='XX', foo='c')\r
+ >>> parser.parse_args(''.split())\r
+ Namespace(bar='d', foo='d')\r
+\r
+ One of the more common uses of ``nargs='?'`` is to allow optional input and\r
+ output files::\r
+\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> parser.add_argument('infile', nargs='?', type=argparse.FileType('r'), default=sys.stdin)\r
+ >>> parser.add_argument('outfile', nargs='?', type=argparse.FileType('w'), default=sys.stdout)\r
+ >>> parser.parse_args(['input.txt', 'output.txt'])\r
+ Namespace(infile=<open file 'input.txt', mode 'r' at 0x...>, outfile=<open file 'output.txt', mode 'w' at 0x...>)\r
+ >>> parser.parse_args([])\r
+ Namespace(infile=<open file '<stdin>', mode 'r' at 0x...>, outfile=<open file '<stdout>', mode 'w' at 0x...>)\r
+\r
+* ``'*'``. All command-line args present are gathered into a list. Note that\r
+ it generally doesn't make much sense to have more than one positional\r
+ argument with ``nargs='*'``, but multiple optional arguments with\r
+ ``nargs='*'`` is possible. For example::\r
+\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> parser.add_argument('--foo', nargs='*')\r
+ >>> parser.add_argument('--bar', nargs='*')\r
+ >>> parser.add_argument('baz', nargs='*')\r
+ >>> parser.parse_args('a b --foo x y --bar 1 2'.split())\r
+ Namespace(bar=['1', '2'], baz=['a', 'b'], foo=['x', 'y'])\r
+\r
+* ``'+'``. Just like ``'*'``, all command-line args present are gathered into a\r
+ list. Additionally, an error message will be generated if there wasn't at\r
+ least one command-line arg present. For example::\r
+\r
+ >>> parser = argparse.ArgumentParser(prog='PROG')\r
+ >>> parser.add_argument('foo', nargs='+')\r
+ >>> parser.parse_args('a b'.split())\r
+ Namespace(foo=['a', 'b'])\r
+ >>> parser.parse_args(''.split())\r
+ usage: PROG [-h] foo [foo ...]\r
+ PROG: error: too few arguments\r
+\r
+If the ``nargs`` keyword argument is not provided, the number of args consumed\r
+is determined by the action_. Generally this means a single command-line arg\r
+will be consumed and a single item (not a list) will be produced.\r
+\r
+\r
+const\r
+^^^^^\r
+\r
+The ``const`` argument of :meth:`add_argument` is used to hold constant values\r
+that are not read from the command line but are required for the various\r
+ArgumentParser actions. The two most common uses of it are:\r
+\r
+* When :meth:`add_argument` is called with ``action='store_const'`` or\r
+ ``action='append_const'``. These actions add the ``const`` value to one of\r
+ the attributes of the object returned by :meth:`parse_args`. See the action_\r
+ description for examples.\r
+\r
+* When :meth:`add_argument` is called with option strings (like ``-f`` or\r
+ ``--foo``) and ``nargs='?'``. This creates an optional argument that can be\r
+ followed by zero or one command-line args. When parsing the command-line, if\r
+ the option string is encountered with no command-line arg following it, the\r
+ value of ``const`` will be assumed instead. See the nargs_ description for\r
+ examples.\r
+\r
+The ``const`` keyword argument defaults to ``None``.\r
+\r
+\r
+default\r
+^^^^^^^\r
+\r
+All optional arguments and some positional arguments may be omitted at the\r
+command-line. The ``default`` keyword argument of :meth:`add_argument`, whose\r
+value defaults to ``None``, specifies what value should be used if the\r
+command-line arg is not present. For optional arguments, the ``default`` value\r
+is used when the option string was not present at the command line::\r
+\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> parser.add_argument('--foo', default=42)\r
+ >>> parser.parse_args('--foo 2'.split())\r
+ Namespace(foo='2')\r
+ >>> parser.parse_args(''.split())\r
+ Namespace(foo=42)\r
+\r
+For positional arguments with nargs_ ``='?'`` or ``'*'``, the ``default`` value\r
+is used when no command-line arg was present::\r
+\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> parser.add_argument('foo', nargs='?', default=42)\r
+ >>> parser.parse_args('a'.split())\r
+ Namespace(foo='a')\r
+ >>> parser.parse_args(''.split())\r
+ Namespace(foo=42)\r
+\r
+\r
+If you don't want to see an attribute when an option was not present at the\r
+command line, you can supply ``default=argparse.SUPPRESS``::\r
+\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> parser.add_argument('--foo', default=argparse.SUPPRESS)\r
+ >>> parser.parse_args([])\r
+ Namespace()\r
+ >>> parser.parse_args(['--foo', '1'])\r
+ Namespace(foo='1')\r
+\r
+\r
+type\r
+^^^^\r
+\r
+By default, ArgumentParser objects read command-line args in as simple strings.\r
+However, quite often the command-line string should instead be interpreted as\r
+another type, e.g. ``float``, ``int`` or ``file``. The ``type`` keyword\r
+argument of :meth:`add_argument` allows any necessary type-checking and\r
+type-conversions to be performed. Many common builtin types can be used\r
+directly as the value of the ``type`` argument::\r
+\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> parser.add_argument('foo', type=int)\r
+ >>> parser.add_argument('bar', type=file)\r
+ >>> parser.parse_args('2 temp.txt'.split())\r
+ Namespace(bar=<open file 'temp.txt', mode 'r' at 0x...>, foo=2)\r
+\r
+To ease the use of various types of files, the argparse module provides the\r
+factory FileType which takes the ``mode=`` and ``bufsize=`` arguments of the\r
+``file`` object. For example, ``FileType('w')`` can be used to create a\r
+writable file::\r
+\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> parser.add_argument('bar', type=argparse.FileType('w'))\r
+ >>> parser.parse_args(['out.txt'])\r
+ Namespace(bar=<open file 'out.txt', mode 'w' at 0x...>)\r
+\r
+If you need to do some special type-checking or type-conversions, you can\r
+provide your own types by passing to ``type=`` a callable that takes a single\r
+string argument and returns the type-converted value::\r
+\r
+ >>> def perfect_square(string):\r
+ ... value = int(string)\r
+ ... sqrt = math.sqrt(value)\r
+ ... if sqrt != int(sqrt):\r
+ ... msg = "%r is not a perfect square" % string\r
+ ... raise argparse.ArgumentTypeError(msg)\r
+ ... return value\r
+ ...\r
+ >>> parser = argparse.ArgumentParser(prog='PROG')\r
+ >>> parser.add_argument('foo', type=perfect_square)\r
+ >>> parser.parse_args('9'.split())\r
+ Namespace(foo=9)\r
+ >>> parser.parse_args('7'.split())\r
+ usage: PROG [-h] foo\r
+ PROG: error: argument foo: '7' is not a perfect square\r
+\r
+Note that if your type-checking function is just checking for a particular set\r
+of values, it may be more convenient to use the choices_ keyword argument::\r
+\r
+ >>> parser = argparse.ArgumentParser(prog='PROG')\r
+ >>> parser.add_argument('foo', type=int, choices=xrange(5, 10))\r
+ >>> parser.parse_args('7'.split())\r
+ Namespace(foo=7)\r
+ >>> parser.parse_args('11'.split())\r
+ usage: PROG [-h] {5,6,7,8,9}\r
+ PROG: error: argument foo: invalid choice: 11 (choose from 5, 6, 7, 8, 9)\r
+\r
+See the choices_ section for more details.\r
+\r
+\r
+choices\r
+^^^^^^^\r
+\r
+Some command-line args should be selected from a restricted set of values.\r
+ArgumentParser objects can be told about such sets of values by passing a\r
+container object as the ``choices`` keyword argument to :meth:`add_argument`.\r
+When the command-line is parsed with :meth:`parse_args`, arg values will be\r
+checked, and an error message will be displayed if the arg was not one of the\r
+acceptable values::\r
+\r
+ >>> parser = argparse.ArgumentParser(prog='PROG')\r
+ >>> parser.add_argument('foo', choices='abc')\r
+ >>> parser.parse_args('c'.split())\r
+ Namespace(foo='c')\r
+ >>> parser.parse_args('X'.split())\r
+ usage: PROG [-h] {a,b,c}\r
+ PROG: error: argument foo: invalid choice: 'X' (choose from 'a', 'b', 'c')\r
+\r
+Note that inclusion in the ``choices`` container is checked after any type_\r
+conversions have been performed, so the type of the objects in the ``choices``\r
+container should match the type_ specified::\r
+\r
+ >>> parser = argparse.ArgumentParser(prog='PROG')\r
+ >>> parser.add_argument('foo', type=complex, choices=[1, 1j])\r
+ >>> parser.parse_args('1j'.split())\r
+ Namespace(foo=1j)\r
+ >>> parser.parse_args('-- -4'.split())\r
+ usage: PROG [-h] {1,1j}\r
+ PROG: error: argument foo: invalid choice: (-4+0j) (choose from 1, 1j)\r
+\r
+Any object that supports the ``in`` operator can be passed as the ``choices``\r
+value, so ``dict`` objects, ``set`` objects, custom containers, etc. are all\r
+supported.\r
+\r
+\r
+required\r
+^^^^^^^^\r
+\r
+In general, the argparse module assumes that flags like ``-f`` and ``--bar``\r
+indicate *optional* arguments, which can always be omitted at the command-line.\r
+To change this behavior, i.e. to make an option *required*, the value ``True``\r
+should be specified for the ``required=`` keyword argument to\r
+:meth:`add_argument`::\r
+\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> parser.add_argument('--foo', required=True)\r
+ >>> parser.parse_args(['--foo', 'BAR'])\r
+ Namespace(foo='BAR')\r
+ >>> parser.parse_args([])\r
+ usage: argparse.py [-h] [--foo FOO]\r
+ argparse.py: error: option --foo is required\r
+\r
+As the example shows, if an option is marked as ``required``, :meth:`parse_args`\r
+will report an error if that option is not present at the command line.\r
+\r
+**Warning:** Required options are generally considered bad form - normal users\r
+expect *options* to be *optional*. You should avoid the use of required options\r
+whenever possible.\r
+\r
+\r
+help\r
+^^^^\r
+\r
+A great command-line interface isn't worth anything if your users can't figure\r
+out which option does what. So for the end-users, ``help`` is probably the\r
+most important argument to include in your :meth:`add_argument` calls. The\r
+``help`` value should be a string containing a brief description of what the\r
+argument specifies. When a user requests help (usually by using ``-h`` or\r
+``--help`` at the command-line), these ``help`` descriptions will be displayed\r
+with each argument::\r
+\r
+ >>> parser = argparse.ArgumentParser(prog='frobble')\r
+ >>> parser.add_argument('--foo', action='store_true',\r
+ ... help='foo the bars before frobbling')\r
+ >>> parser.add_argument('bar', nargs='+',\r
+ ... help='one of the bars to be frobbled')\r
+ >>> parser.parse_args('-h'.split())\r
+ usage: frobble [-h] [--foo] bar [bar ...]\r
+\r
+ positional arguments:\r
+ bar one of the bars to be frobbled\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ --foo foo the bars before frobbling\r
+\r
+The ``help`` strings can include various format specifiers to avoid repetition\r
+of things like the program name or the argument default_. The available\r
+specifiers include the program name, ``%(prog)s`` and most keyword arguments to\r
+:meth:`add_argument`, e.g. ``%(default)s``, ``%(type)s``, etc.::\r
+\r
+ >>> parser = argparse.ArgumentParser(prog='frobble')\r
+ >>> parser.add_argument('bar', nargs='?', type=int, default=42,\r
+ ... help='the bar to %(prog)s (default: %(default)s)')\r
+ >>> parser.print_help()\r
+ usage: frobble [-h] [bar]\r
+\r
+ positional arguments:\r
+ bar the bar to frobble (default: 42)\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+\r
+\r
+metavar\r
+^^^^^^^\r
+\r
+When ArgumentParser objects generate help messages, they need some way to refer\r
+to each expected argument. By default, ArgumentParser objects use the dest_\r
+value as the "name" of each object. By default, for positional argument\r
+actions, the dest_ value is used directly, and for optional argument actions,\r
+the dest_ value is uppercased. So if we have a single positional argument with\r
+``dest='bar'``, that argument will be referred to as ``bar``. And if we have a\r
+single optional argument ``--foo`` that should be followed by a single\r
+command-line arg, that arg will be referred to as ``FOO``. You can see this\r
+behavior in the example below::\r
+\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> parser.add_argument('--foo')\r
+ >>> parser.add_argument('bar')\r
+ >>> parser.parse_args('X --foo Y'.split())\r
+ Namespace(bar='X', foo='Y')\r
+ >>> parser.print_help()\r
+ usage: [-h] [--foo FOO] bar\r
+\r
+ positional arguments:\r
+ bar\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ --foo FOO\r
+\r
+If you would like to provide a different name for your argument in help\r
+messages, you can supply a value for the ``metavar`` keyword argument to\r
+:meth:`add_argument`::\r
+\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> parser.add_argument('--foo', metavar='YYY')\r
+ >>> parser.add_argument('bar', metavar='XXX')\r
+ >>> parser.parse_args('X --foo Y'.split())\r
+ Namespace(bar='X', foo='Y')\r
+ >>> parser.print_help()\r
+ usage: [-h] [--foo YYY] XXX\r
+\r
+ positional arguments:\r
+ XXX\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ --foo YYY\r
+\r
+Note that ``metavar`` only changes the *displayed* name - the name of the\r
+attribute on the :meth:`parse_args` object is still determined by the dest_\r
+value.\r
+\r
+Different values of ``nargs`` may cause the metavar to be used multiple times.\r
+If you'd like to specify a different display name for each of the arguments,\r
+you can provide a tuple to ``metavar``::\r
+\r
+ >>> parser = argparse.ArgumentParser(prog='PROG')\r
+ >>> parser.add_argument('-x', nargs=2)\r
+ >>> parser.add_argument('--foo', nargs=2, metavar=('bar', 'baz'))\r
+ >>> parser.print_help()\r
+ usage: PROG [-h] [-x X X] [--foo bar baz]\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ -x X X\r
+ --foo bar baz\r
+\r
+\r
+dest\r
+^^^^\r
+\r
+Most ArgumentParser actions add some value as an attribute of the object\r
+returned by :meth:`parse_args`. The name of this attribute is determined by the\r
+``dest`` keyword argument of :meth:`add_argument`. For positional argument\r
+actions, ``dest`` is normally supplied as the first argument to\r
+:meth:`add_argument`::\r
+\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> parser.add_argument('bar')\r
+ >>> parser.parse_args('XXX'.split())\r
+ Namespace(bar='XXX')\r
+\r
+For optional argument actions, the value of ``dest`` is normally inferred from\r
+the option strings. ArgumentParser objects generate the value of ``dest`` by\r
+taking the first long option string and stripping away the initial ``'--'``\r
+string. If no long option strings were supplied, ``dest`` will be derived from\r
+the first short option string by stripping the initial ``'-'`` character. Any\r
+internal ``'-'`` characters will be converted to ``'_'`` characters to make\r
+sure the string is a valid attribute name. The examples below illustrate this\r
+behavior::\r
+\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> parser.add_argument('-f', '--foo-bar', '--foo')\r
+ >>> parser.add_argument('-x', '-y')\r
+ >>> parser.parse_args('-f 1 -x 2'.split())\r
+ Namespace(foo_bar='1', x='2')\r
+ >>> parser.parse_args('--foo 1 -y 2'.split())\r
+ Namespace(foo_bar='1', x='2')\r
+\r
+If you would like to use a different attribute name from the one automatically\r
+inferred by the ArgumentParser, you can supply it with an explicit ``dest``\r
+parameter::\r
+\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> parser.add_argument('--foo', dest='bar')\r
+ >>> parser.parse_args('--foo XXX'.split())\r
+ Namespace(bar='XXX')\r
+\r
+\r
+The parse_args() method\r
+-----------------------\r
+\r
+.. method:: parse_args([args], [namespace])\r
+\r
+ Convert the strings to objects and assign them as attributes of the\r
+ namespace. Return the populated namespace.\r
+\r
+ Previous calls to :meth:`add_argument` determine exactly what objects are\r
+ created and how they are assigned. See the documentation for\r
+ :meth:`add_argument` for details.\r
+\r
+ By default, the arg strings are taken from ``sys.argv``, and a new empty\r
+ ``Namespace`` object is created for the attributes.\r
+\r
+Option value syntax\r
+^^^^^^^^^^^^^^^^^^^\r
+\r
+The :meth:`parse_args` method supports several ways of specifying the value of\r
+an option (if it takes one). In the simplest case, the option and its value are\r
+passed as two separate arguments::\r
+\r
+ >>> parser = argparse.ArgumentParser(prog='PROG')\r
+ >>> parser.add_argument('-x')\r
+ >>> parser.add_argument('--foo')\r
+ >>> parser.parse_args('-x X'.split())\r
+ Namespace(foo=None, x='X')\r
+ >>> parser.parse_args('--foo FOO'.split())\r
+ Namespace(foo='FOO', x=None)\r
+\r
+For long options (options with names longer than a single character), you may\r
+also pass the option and value as a single command line argument, using ``=``\r
+to separate them::\r
+\r
+ >>> parser.parse_args('--foo=FOO'.split())\r
+ Namespace(foo='FOO', x=None)\r
+\r
+For short options (options only one character long), you may simply concatenate\r
+the option and its value::\r
+\r
+ >>> parser.parse_args('-xX'.split())\r
+ Namespace(foo=None, x='X')\r
+\r
+You can also combine several short options together, using only a single ``-``\r
+prefix, as long as only the last option (or none of them) requires a value::\r
+\r
+ >>> parser = argparse.ArgumentParser(prog='PROG')\r
+ >>> parser.add_argument('-x', action='store_true')\r
+ >>> parser.add_argument('-y', action='store_true')\r
+ >>> parser.add_argument('-z')\r
+ >>> parser.parse_args('-xyzZ'.split())\r
+ Namespace(x=True, y=True, z='Z')\r
+\r
+\r
+Invalid arguments\r
+^^^^^^^^^^^^^^^^^\r
+\r
+While parsing the command-line, ``parse_args`` checks for a variety of errors,\r
+including ambiguous options, invalid types, invalid options, wrong number of\r
+positional arguments, etc. When it encounters such an error, it exits and\r
+prints the error along with a usage message::\r
+\r
+ >>> parser = argparse.ArgumentParser(prog='PROG')\r
+ >>> parser.add_argument('--foo', type=int)\r
+ >>> parser.add_argument('bar', nargs='?')\r
+\r
+ >>> # invalid type\r
+ >>> parser.parse_args(['--foo', 'spam'])\r
+ usage: PROG [-h] [--foo FOO] [bar]\r
+ PROG: error: argument --foo: invalid int value: 'spam'\r
+\r
+ >>> # invalid option\r
+ >>> parser.parse_args(['--bar'])\r
+ usage: PROG [-h] [--foo FOO] [bar]\r
+ PROG: error: no such option: --bar\r
+\r
+ >>> # wrong number of arguments\r
+ >>> parser.parse_args(['spam', 'badger'])\r
+ usage: PROG [-h] [--foo FOO] [bar]\r
+ PROG: error: extra arguments found: badger\r
+\r
+\r
+Arguments containing ``"-"``\r
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^\r
+\r
+The ``parse_args`` method attempts to give errors whenever the user has clearly\r
+made a mistake, but some situations are inherently ambiguous. For example, the\r
+command-line arg ``'-1'`` could either be an attempt to specify an option or an\r
+attempt to provide a positional argument. The ``parse_args`` method is cautious\r
+here: positional arguments may only begin with ``'-'`` if they look like\r
+negative numbers and there are no options in the parser that look like negative\r
+numbers::\r
+\r
+ >>> parser = argparse.ArgumentParser(prog='PROG')\r
+ >>> parser.add_argument('-x')\r
+ >>> parser.add_argument('foo', nargs='?')\r
+\r
+ >>> # no negative number options, so -1 is a positional argument\r
+ >>> parser.parse_args(['-x', '-1'])\r
+ Namespace(foo=None, x='-1')\r
+\r
+ >>> # no negative number options, so -1 and -5 are positional arguments\r
+ >>> parser.parse_args(['-x', '-1', '-5'])\r
+ Namespace(foo='-5', x='-1')\r
+\r
+ >>> parser = argparse.ArgumentParser(prog='PROG')\r
+ >>> parser.add_argument('-1', dest='one')\r
+ >>> parser.add_argument('foo', nargs='?')\r
+\r
+ >>> # negative number options present, so -1 is an option\r
+ >>> parser.parse_args(['-1', 'X'])\r
+ Namespace(foo=None, one='X')\r
+\r
+ >>> # negative number options present, so -2 is an option\r
+ >>> parser.parse_args(['-2'])\r
+ usage: PROG [-h] [-1 ONE] [foo]\r
+ PROG: error: no such option: -2\r
+\r
+ >>> # negative number options present, so both -1s are options\r
+ >>> parser.parse_args(['-1', '-1'])\r
+ usage: PROG [-h] [-1 ONE] [foo]\r
+ PROG: error: argument -1: expected one argument\r
+\r
+If you have positional arguments that must begin with ``'-'`` and don't look\r
+like negative numbers, you can insert the pseudo-argument ``'--'`` which tells\r
+``parse_args`` that everything after that is a positional argument::\r
+\r
+ >>> parser.parse_args(['--', '-f'])\r
+ Namespace(foo='-f', one=None)\r
+\r
+\r
+Argument abbreviations\r
+^^^^^^^^^^^^^^^^^^^^^^\r
+\r
+The :meth:`parse_args` method allows you to abbreviate long options if the\r
+abbreviation is unambiguous::\r
+\r
+ >>> parser = argparse.ArgumentParser(prog='PROG')\r
+ >>> parser.add_argument('-bacon')\r
+ >>> parser.add_argument('-badger')\r
+ >>> parser.parse_args('-bac MMM'.split())\r
+ Namespace(bacon='MMM', badger=None)\r
+ >>> parser.parse_args('-bad WOOD'.split())\r
+ Namespace(bacon=None, badger='WOOD')\r
+ >>> parser.parse_args('-ba BA'.split())\r
+ usage: PROG [-h] [-bacon BACON] [-badger BADGER]\r
+ PROG: error: ambiguous option: -ba could match -badger, -bacon\r
+\r
+As you can see above, you will get an error if you pick a prefix that could\r
+refer to more than one option.\r
+\r
+\r
+Beyond ``sys.argv``\r
+^^^^^^^^^^^^^^^^^^^\r
+\r
+Sometimes it may be useful to have an ArgumentParser parse args other than\r
+those of ``sys.argv``. This can be accomplished by passing a list of strings\r
+to ``parse_args``. You may have noticed that the examples in the argparse\r
+documentation have made heavy use of this calling style - it is much easier\r
+to use at the interactive prompt::\r
+\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> parser.add_argument(\r
+ ... 'integers', metavar='int', type=int, choices=xrange(10),\r
+ ... nargs='+', help='an integer in the range 0..9')\r
+ >>> parser.add_argument(\r
+ ... '--sum', dest='accumulate', action='store_const', const=sum,\r
+ ... default=max, help='sum the integers (default: find the max)')\r
+ >>> parser.parse_args(['1', '2', '3', '4'])\r
+ Namespace(accumulate=<built-in function max>, integers=[1, 2, 3, 4])\r
+ >>> parser.parse_args('1 2 3 4 --sum'.split())\r
+ Namespace(accumulate=<built-in function sum>, integers=[1, 2, 3, 4])\r
+\r
+\r
+Custom namespaces\r
+^^^^^^^^^^^^^^^^^\r
+\r
+It may also be useful to have an ArgumentParser assign attributes to an already\r
+existing object, rather than the newly-created Namespace object that is\r
+normally used. This can be achieved by specifying the ``namespace=`` keyword\r
+argument::\r
+\r
+ >>> class C(object):\r
+ ... pass\r
+ ...\r
+ >>> c = C()\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> parser.add_argument('--foo')\r
+ >>> parser.parse_args(args=['--foo', 'BAR'], namespace=c)\r
+ >>> c.foo\r
+ 'BAR'\r
+\r
+\r
+Other utilities\r
+---------------\r
+\r
+Sub-commands\r
+^^^^^^^^^^^^\r
+\r
+.. method:: add_subparsers()\r
+\r
+ A lot of programs split up their functionality into a number of\r
+ sub-commands, for example, the ``svn`` program can invoke sub-commands like\r
+ ``svn checkout``, ``svn update``, ``svn commit``, etc. Splitting up\r
+ functionality this way can be a particularly good idea when a program\r
+ performs several different functions which require different kinds of\r
+ command-line arguments. ArgumentParser objects support the creation of such\r
+ sub-commands with the :meth:`add_subparsers` method. The\r
+ :meth:`add_subparsers` method is normally called with no arguments and\r
+ returns an special action object. This object has a single method,\r
+ ``add_parser``, which takes a command name and any ArgumentParser\r
+ constructor arguments, and returns an ArgumentParser object that can be\r
+ modified as usual.\r
+\r
+ Some example usage::\r
+\r
+ >>> # create the top-level parser\r
+ >>> parser = argparse.ArgumentParser(prog='PROG')\r
+ >>> parser.add_argument('--foo', action='store_true', help='foo help')\r
+ >>> subparsers = parser.add_subparsers(help='sub-command help')\r
+ >>>\r
+ >>> # create the parser for the "a" command\r
+ >>> parser_a = subparsers.add_parser('a', help='a help')\r
+ >>> parser_a.add_argument('bar', type=int, help='bar help')\r
+ >>>\r
+ >>> # create the parser for the "b" command\r
+ >>> parser_b = subparsers.add_parser('b', help='b help')\r
+ >>> parser_b.add_argument('--baz', choices='XYZ', help='baz help')\r
+ >>>\r
+ >>> # parse some arg lists\r
+ >>> parser.parse_args(['a', '12'])\r
+ Namespace(bar=12, foo=False)\r
+ >>> parser.parse_args(['--foo', 'b', '--baz', 'Z'])\r
+ Namespace(baz='Z', foo=True)\r
+\r
+ Note that the object returned by :meth:`parse_args` will only contain\r
+ attributes for the main parser and the subparser that was selected by the\r
+ command line (and not any other subparsers). So in the example above, when\r
+ the ``"a"`` command is specified, only the ``foo`` and ``bar`` attributes\r
+ are present, and when the ``"b"`` command is specified, only the ``foo`` and\r
+ ``baz`` attributes are present.\r
+\r
+ Similarly, when a help message is requested from a subparser, only the help\r
+ for that particular parser will be printed. The help message will not\r
+ include parent parser or sibling parser messages. (You can however supply a\r
+ help message for each subparser command by suppling the ``help=`` argument\r
+ to ``add_parser`` as above.)\r
+\r
+ ::\r
+\r
+ >>> parser.parse_args(['--help'])\r
+ usage: PROG [-h] [--foo] {a,b} ...\r
+\r
+ positional arguments:\r
+ {a,b} sub-command help\r
+ a a help\r
+ b b help\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ --foo foo help\r
+\r
+ >>> parser.parse_args(['a', '--help'])\r
+ usage: PROG a [-h] bar\r
+\r
+ positional arguments:\r
+ bar bar help\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+\r
+ >>> parser.parse_args(['b', '--help'])\r
+ usage: PROG b [-h] [--baz {X,Y,Z}]\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ --baz {X,Y,Z} baz help\r
+\r
+ The :meth:`add_subparsers` method also supports ``title`` and\r
+ ``description`` keyword arguments. When either is present, the subparser's\r
+ commands will appear in their own group in the help output. For example::\r
+\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> subparsers = parser.add_subparsers(title='subcommands',\r
+ ... description='valid subcommands',\r
+ ... help='additional help')\r
+ >>> subparsers.add_parser('foo')\r
+ >>> subparsers.add_parser('bar')\r
+ >>> parser.parse_args(['-h'])\r
+ usage: [-h] {foo,bar} ...\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+\r
+ subcommands:\r
+ valid subcommands\r
+\r
+ {foo,bar} additional help\r
+\r
+\r
+ One particularly effective way of handling sub-commands is to combine the\r
+ use of the :meth:`add_subparsers` method with calls to :meth:`set_defaults`\r
+ so that each subparser knows which Python function it should execute. For\r
+ example::\r
+\r
+ >>> # sub-command functions\r
+ >>> def foo(args):\r
+ ... print args.x * args.y\r
+ ...\r
+ >>> def bar(args):\r
+ ... print '((%s))' % args.z\r
+ ...\r
+ >>> # create the top-level parser\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> subparsers = parser.add_subparsers()\r
+ >>>\r
+ >>> # create the parser for the "foo" command\r
+ >>> parser_foo = subparsers.add_parser('foo')\r
+ >>> parser_foo.add_argument('-x', type=int, default=1)\r
+ >>> parser_foo.add_argument('y', type=float)\r
+ >>> parser_foo.set_defaults(func=foo)\r
+ >>>\r
+ >>> # create the parser for the "bar" command\r
+ >>> parser_bar = subparsers.add_parser('bar')\r
+ >>> parser_bar.add_argument('z')\r
+ >>> parser_bar.set_defaults(func=bar)\r
+ >>>\r
+ >>> # parse the args and call whatever function was selected\r
+ >>> args = parser.parse_args('foo 1 -x 2'.split())\r
+ >>> args.func(args)\r
+ 2.0\r
+ >>>\r
+ >>> # parse the args and call whatever function was selected\r
+ >>> args = parser.parse_args('bar XYZYX'.split())\r
+ >>> args.func(args)\r
+ ((XYZYX))\r
+\r
+ This way, you can let :meth:`parse_args` do all the work for you, and then\r
+ just call the appropriate function after the argument parsing is complete.\r
+ Associating functions with actions like this is typically the easiest way\r
+ to handle the different actions for each of your subparsers. However, if you\r
+ find it necessary to check the name of the subparser that was invoked, you\r
+ can always provide a ``dest`` keyword argument to the :meth:`add_subparsers`\r
+ call::\r
+\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> subparsers = parser.add_subparsers(dest='subparser_name')\r
+ >>> subparser1 = subparsers.add_parser('1')\r
+ >>> subparser1.add_argument('-x')\r
+ >>> subparser2 = subparsers.add_parser('2')\r
+ >>> subparser2.add_argument('y')\r
+ >>> parser.parse_args(['2', 'frobble'])\r
+ Namespace(subparser_name='2', y='frobble')\r
+\r
+\r
+FileType objects\r
+^^^^^^^^^^^^^^^^\r
+\r
+.. class:: FileType(mode='r', bufsize=None)\r
+\r
+ The :class:`FileType` factory creates objects that can be passed to the type\r
+ argument of :meth:`add_argument`. Arguments that have :class:`FileType`\r
+ objects as their type will open command-line args as files with the\r
+ requested modes and buffer sizes:\r
+\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> parser.add_argument('--output', type=argparse.FileType('wb', 0))\r
+ >>> parser.parse_args(['--output', 'out'])\r
+ Namespace(output=<open file 'out', mode 'wb' at 0x...>)\r
+\r
+ FileType objects understand the pseudo-argument ``'-'`` and automatically\r
+ convert this into ``sys.stdin`` for readable :class:`FileType` objects and\r
+ ``sys.stdout`` for writable :class:`FileType` objects:\r
+\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> parser.add_argument('infile', type=argparse.FileType('r'))\r
+ >>> parser.parse_args(['-'])\r
+ Namespace(infile=<open file '<stdin>', mode 'r' at 0x...>)\r
+\r
+\r
+Argument groups\r
+^^^^^^^^^^^^^^^\r
+\r
+.. method:: add_argument_group([title], [description])\r
+\r
+ By default, ArgumentParser objects group command-line arguments into\r
+ "positional arguments" and "optional arguments" when displaying help\r
+ messages. When there is a better conceptual grouping of arguments than this\r
+ default one, appropriate groups can be created using the\r
+ :meth:`add_argument_group` method::\r
+\r
+ >>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)\r
+ >>> group = parser.add_argument_group('group')\r
+ >>> group.add_argument('--foo', help='foo help')\r
+ >>> group.add_argument('bar', help='bar help')\r
+ >>> parser.print_help()\r
+ usage: PROG [--foo FOO] bar\r
+\r
+ group:\r
+ bar bar help\r
+ --foo FOO foo help\r
+\r
+ The :meth:`add_argument_group` method returns an argument group object which\r
+ has an :meth:`add_argument` method just like a regular ArgumentParser\r
+ objects. When an argument is added to the group, the parser treats it just\r
+ like a normal argument, but displays the argument in a separate group for\r
+ help messages. The :meth:`add_argument_group` method accepts ``title`` and\r
+ ``description`` arguments which can be used to customize this display::\r
+\r
+ >>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)\r
+ >>> group1 = parser.add_argument_group('group1', 'group1 description')\r
+ >>> group1.add_argument('foo', help='foo help')\r
+ >>> group2 = parser.add_argument_group('group2', 'group2 description')\r
+ >>> group2.add_argument('--bar', help='bar help')\r
+ >>> parser.print_help()\r
+ usage: PROG [--bar BAR] foo\r
+\r
+ group1:\r
+ group1 description\r
+\r
+ foo foo help\r
+\r
+ group2:\r
+ group2 description\r
+\r
+ --bar BAR bar help\r
+\r
+ Note that any arguments not in your user defined groups will end up back in\r
+ the usual "positional arguments" and "optional arguments" sections.\r
+\r
+\r
+Mutual exclusion\r
+^^^^^^^^^^^^^^^^\r
+\r
+.. method:: add_mutually_exclusive_group([required=False])\r
+\r
+ Sometimes, you need to make sure that only one of a couple different options\r
+ is specified on the command line. You can create groups of such mutually\r
+ exclusive arguments using the :meth:`add_mutually_exclusive_group` method.\r
+ When :func:`parse_args` is called, argparse will make sure that only one of\r
+ the arguments in the mutually exclusive group was present on the command\r
+ line::\r
+\r
+ >>> parser = argparse.ArgumentParser(prog='PROG')\r
+ >>> group = parser.add_mutually_exclusive_group()\r
+ >>> group.add_argument('--foo', action='store_true')\r
+ >>> group.add_argument('--bar', action='store_false')\r
+ >>> parser.parse_args(['--foo'])\r
+ Namespace(bar=True, foo=True)\r
+ >>> parser.parse_args(['--bar'])\r
+ Namespace(bar=False, foo=False)\r
+ >>> parser.parse_args(['--foo', '--bar'])\r
+ usage: PROG [-h] [--foo | --bar]\r
+ PROG: error: argument --bar: not allowed with argument --foo\r
+\r
+ The :meth:`add_mutually_exclusive_group` method also accepts a ``required``\r
+ argument, to indicate that at least one of the mutually exclusive arguments\r
+ is required::\r
+\r
+ >>> parser = argparse.ArgumentParser(prog='PROG')\r
+ >>> group = parser.add_mutually_exclusive_group(required=True)\r
+ >>> group.add_argument('--foo', action='store_true')\r
+ >>> group.add_argument('--bar', action='store_false')\r
+ >>> parser.parse_args([])\r
+ usage: PROG [-h] (--foo | --bar)\r
+ PROG: error: one of the arguments --foo --bar is required\r
+\r
+ Note that currently mutually exclusive argument groups do not support the\r
+ ``title`` and ``description`` arguments of :meth:`add_argument_group`. This\r
+ may change in the future however, so you are *strongly* recommended to\r
+ specify ``required`` as a keyword argument if you use it.\r
+\r
+\r
+Parser defaults\r
+^^^^^^^^^^^^^^^\r
+\r
+.. method:: set_defaults(**kwargs)\r
+\r
+ Most of the time, the attributes of the object returned by\r
+ :meth:`parse_args` will be fully determined by inspecting the command-line\r
+ args and the argument actions described in your :meth:`add_argument` calls.\r
+ However, sometimes it may be useful to add some additional attributes that\r
+ are determined without any inspection of the command-line. The\r
+ :meth:`set_defaults` method allows you to do this::\r
+\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> parser.add_argument('foo', type=int)\r
+ >>> parser.set_defaults(bar=42, baz='badger')\r
+ >>> parser.parse_args(['736'])\r
+ Namespace(bar=42, baz='badger', foo=736)\r
+\r
+ Note that parser-level defaults always override argument-level defaults. So\r
+ if you set a parser-level default for a name that matches an argument, the\r
+ old argument default will no longer be used::\r
+\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> parser.add_argument('--foo', default='bar')\r
+ >>> parser.set_defaults(foo='spam')\r
+ >>> parser.parse_args([])\r
+ Namespace(foo='spam')\r
+\r
+ Parser-level defaults can be particularly useful when you're working with\r
+ multiple parsers. See the :meth:`add_subparsers` method for an example of\r
+ this type.\r
+\r
+.. method:: get_default(dest)\r
+\r
+ Get the default value for a namespace attribute, as set by either\r
+ :meth:`add_argument` or by :meth:`set_defaults`::\r
+\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> parser.add_argument('--foo', default='badger')\r
+ >>> parser.get_default('foo')\r
+ 'badger'\r
+\r
+\r
+Printing help\r
+^^^^^^^^^^^^^\r
+\r
+In most typical applications, :meth:`parse_args` will take care of formatting\r
+and printing any usage or error messages. However, should you want to format or\r
+print these on your own, several methods are available:\r
+\r
+.. method:: print_usage([file]):\r
+\r
+ Print a brief description of how the :class:`ArgumentParser` should be\r
+ invoked on the command line. If ``file`` is not present, ``sys.stderr`` is\r
+ assumed.\r
+\r
+.. method:: print_help([file]):\r
+\r
+ Print a help message, including the program usage and information about the\r
+ arguments registered with the :class:`ArgumentParser`. If ``file`` is not\r
+ present, ``sys.stderr`` is assumed.\r
+\r
+There are also variants of these methods that simply return a string instead of\r
+printing it:\r
+\r
+.. method:: format_usage():\r
+\r
+ Return a string containing a brief description of how the\r
+ :class:`ArgumentParser` should be invoked on the command line.\r
+\r
+.. method:: format_help():\r
+\r
+ Return a string containing a help message, including the program usage and\r
+ information about the arguments registered with the :class:`ArgumentParser`.\r
+\r
+\r
+\r
+Partial parsing\r
+^^^^^^^^^^^^^^^\r
+\r
+.. method:: parse_known_args([args], [namespace])\r
+\r
+Sometimes a script may only parse a few of the command line arguments, passing\r
+the remaining arguments on to another script or program. In these cases, the\r
+:meth:`parse_known_args` method can be useful. It works much like\r
+:meth:`parse_args` except that it does not produce an error when extra\r
+arguments are present. Instead, it returns a two item tuple containing the\r
+populated namespace and the list of remaining argument strings.\r
+\r
+::\r
+\r
+ >>> parser = argparse.ArgumentParser()\r
+ >>> parser.add_argument('--foo', action='store_true')\r
+ >>> parser.add_argument('bar')\r
+ >>> parser.parse_known_args(['--foo', '--badger', 'BAR', 'spam'])\r
+ (Namespace(bar='BAR', foo=True), ['--badger', 'spam'])\r
+\r
+\r
+Customizing file parsing\r
+^^^^^^^^^^^^^^^^^^^^^^^^\r
+\r
+.. method:: convert_arg_line_to_args(arg_line)\r
+\r
+ Arguments that are read from a file (see the ``fromfile_prefix_chars``\r
+ keyword argument to the :class:`ArgumentParser` constructor) are read one\r
+ argument per line. If you need fancier parsing, then you can subclass the\r
+ :class:`ArgumentParser` and override the :meth:`convert_arg_line_to_args`\r
+ method.\r
+\r
+ This method takes a single argument ``arg_line`` which is a string read from\r
+ the argument file. It returns a list of arguments parsed from this string.\r
+ The method is called once per line read from the argument file, in order.\r
+\r
+ A useful override of this method is one that treats each space-separated\r
+ word as an argument::\r
+\r
+ def convert_arg_line_to_args(self, arg_line):\r
+ for arg in arg_line.split():\r
+ if not arg.strip():\r
+ continue\r
+ yield arg\r
+\r
+\r
+Upgrading optparse code\r
+-----------------------\r
+\r
+Originally, the argparse module had attempted to maintain compatibility with\r
+ optparse. However, optparse was difficult to extend transparently,\r
+ particularly with the changes required to support the new ``nargs=``\r
+ specifiers and better usage messges. When most everything in optparse had\r
+ either been copy-pasted over or monkey-patched, it no longer seemed practical\r
+ to try to maintain the backwards compatibility.\r
+\r
+A partial upgrade path from optparse to argparse:\r
+\r
+* Replace all ``add_option()`` calls with :meth:`add_argument` calls.\r
+\r
+* Replace ``options, args = parser.parse_args()`` with\r
+ ``args = parser.parse_args()`` and add additional :meth:`add_argument` calls\r
+ for the positional arguments.\r
+\r
+* Replace callback actions and the ``callback_*`` keyword arguments with\r
+ ``type`` or ``action`` arguments.\r
+\r
+* Replace string names for ``type`` keyword arguments with the corresponding\r
+ type objects (e.g. int, float, complex, etc).\r
+\r
+* Replace ``Values`` with ``Namespace`` and ``OptionError/OptionValueError``\r
+ with ``ArgumentError``.\r
+\r
+* Replace strings with implicit arguments such as ``%default`` or ``%prog``\r
+ with the standard python syntax to use dictionaries to format strings, that\r
+ is, ``%(default)s`` and ``%(prog)s``.\r
--- /dev/null
+# -*- coding: utf-8 -*-\r
+\r
+# Copyright © 2006-2009 Steven J. Bethard <steven.bethard@gmail.com>.\r
+#\r
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not\r
+# use this file except in compliance with the License. You may obtain a copy\r
+# of the License at\r
+#\r
+# http://www.apache.org/licenses/LICENSE-2.0\r
+#\r
+# Unless required by applicable law or agreed to in writing, software\r
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT\r
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the\r
+# License for the specific language governing permissions and limitations\r
+# under the License.\r
+\r
+"""Command-line parsing library\r
+\r
+This module is an optparse-inspired command-line parsing library that:\r
+\r
+ - handles both optional and positional arguments\r
+ - produces highly informative usage messages\r
+ - supports parsers that dispatch to sub-parsers\r
+\r
+The following is a simple usage example that sums integers from the\r
+command-line and writes the result to a file::\r
+\r
+ parser = argparse.ArgumentParser(\r
+ description='sum the integers at the command line')\r
+ parser.add_argument(\r
+ 'integers', metavar='int', nargs='+', type=int,\r
+ help='an integer to be summed')\r
+ parser.add_argument(\r
+ '--log', default=sys.stdout, type=argparse.FileType('w'),\r
+ help='the file where the sum should be written')\r
+ args = parser.parse_args()\r
+ args.log.write('%s' % sum(args.integers))\r
+ args.log.close()\r
+\r
+The module contains the following public classes:\r
+\r
+ - ArgumentParser -- The main entry point for command-line parsing. As the\r
+ example above shows, the add_argument() method is used to populate\r
+ the parser with actions for optional and positional arguments. Then\r
+ the parse_args() method is invoked to convert the args at the\r
+ command-line into an object with attributes.\r
+\r
+ - ArgumentError -- The exception raised by ArgumentParser objects when\r
+ there are errors with the parser's actions. Errors raised while\r
+ parsing the command-line are caught by ArgumentParser and emitted\r
+ as command-line messages.\r
+\r
+ - FileType -- A factory for defining types of files to be created. As the\r
+ example above shows, instances of FileType are typically passed as\r
+ the type= argument of add_argument() calls.\r
+\r
+ - Action -- The base class for parser actions. Typically actions are\r
+ selected by passing strings like 'store_true' or 'append_const' to\r
+ the action= argument of add_argument(). However, for greater\r
+ customization of ArgumentParser actions, subclasses of Action may\r
+ be defined and passed as the action= argument.\r
+\r
+ - HelpFormatter, RawDescriptionHelpFormatter, RawTextHelpFormatter,\r
+ ArgumentDefaultsHelpFormatter -- Formatter classes which\r
+ may be passed as the formatter_class= argument to the\r
+ ArgumentParser constructor. HelpFormatter is the default,\r
+ RawDescriptionHelpFormatter and RawTextHelpFormatter tell the parser\r
+ not to change the formatting for help text, and\r
+ ArgumentDefaultsHelpFormatter adds information about argument defaults\r
+ to the help.\r
+\r
+All other classes in this module are considered implementation details.\r
+(Also note that HelpFormatter and RawDescriptionHelpFormatter are only\r
+considered public as object names -- the API of the formatter objects is\r
+still considered an implementation detail.)\r
+"""\r
+\r
+__version__ = '1.1'\r
+__all__ = [\r
+ 'ArgumentParser',\r
+ 'ArgumentError',\r
+ 'Namespace',\r
+ 'Action',\r
+ 'FileType',\r
+ 'HelpFormatter',\r
+ 'RawDescriptionHelpFormatter',\r
+ 'RawTextHelpFormatter',\r
+ 'ArgumentDefaultsHelpFormatter',\r
+]\r
+\r
+\r
+import copy as _copy\r
+import os as _os\r
+import re as _re\r
+import sys as _sys\r
+import textwrap as _textwrap\r
+\r
+from gettext import gettext as _\r
+\r
+try:\r
+ _set = set\r
+except NameError:\r
+ from sets import Set as _set\r
+\r
+try:\r
+ _basestring = basestring\r
+except NameError:\r
+ _basestring = str\r
+\r
+try:\r
+ _sorted = sorted\r
+except NameError:\r
+\r
+ def _sorted(iterable, reverse=False):\r
+ result = list(iterable)\r
+ result.sort()\r
+ if reverse:\r
+ result.reverse()\r
+ return result\r
+\r
+\r
+def _callable(obj):\r
+ return hasattr(obj, '__call__') or hasattr(obj, '__bases__')\r
+\r
+# silence Python 2.6 buggy warnings about Exception.message\r
+if _sys.version_info[:2] == (2, 6):\r
+ import warnings\r
+ warnings.filterwarnings(\r
+ action='ignore',\r
+ message='BaseException.message has been deprecated as of Python 2.6',\r
+ category=DeprecationWarning,\r
+ module='argparse')\r
+\r
+\r
+SUPPRESS = '==SUPPRESS=='\r
+\r
+OPTIONAL = '?'\r
+ZERO_OR_MORE = '*'\r
+ONE_OR_MORE = '+'\r
+PARSER = 'A...'\r
+REMAINDER = '...'\r
+\r
+# =============================\r
+# Utility functions and classes\r
+# =============================\r
+\r
+class _AttributeHolder(object):\r
+ """Abstract base class that provides __repr__.\r
+\r
+ The __repr__ method returns a string in the format::\r
+ ClassName(attr=name, attr=name, ...)\r
+ The attributes are determined either by a class-level attribute,\r
+ '_kwarg_names', or by inspecting the instance __dict__.\r
+ """\r
+\r
+ def __repr__(self):\r
+ type_name = type(self).__name__\r
+ arg_strings = []\r
+ for arg in self._get_args():\r
+ arg_strings.append(repr(arg))\r
+ for name, value in self._get_kwargs():\r
+ arg_strings.append('%s=%r' % (name, value))\r
+ return '%s(%s)' % (type_name, ', '.join(arg_strings))\r
+\r
+ def _get_kwargs(self):\r
+ return _sorted(self.__dict__.items())\r
+\r
+ def _get_args(self):\r
+ return []\r
+\r
+\r
+def _ensure_value(namespace, name, value):\r
+ if getattr(namespace, name, None) is None:\r
+ setattr(namespace, name, value)\r
+ return getattr(namespace, name)\r
+\r
+\r
+# ===============\r
+# Formatting Help\r
+# ===============\r
+\r
+class HelpFormatter(object):\r
+ """Formatter for generating usage messages and argument help strings.\r
+\r
+ Only the name of this class is considered a public API. All the methods\r
+ provided by the class are considered an implementation detail.\r
+ """\r
+\r
+ def __init__(self,\r
+ prog,\r
+ indent_increment=2,\r
+ max_help_position=24,\r
+ width=None):\r
+\r
+ # default setting for width\r
+ if width is None:\r
+ try:\r
+ width = int(_os.environ['COLUMNS'])\r
+ except (KeyError, ValueError):\r
+ width = 80\r
+ width -= 2\r
+\r
+ self._prog = prog\r
+ self._indent_increment = indent_increment\r
+ self._max_help_position = max_help_position\r
+ self._width = width\r
+\r
+ self._current_indent = 0\r
+ self._level = 0\r
+ self._action_max_length = 0\r
+\r
+ self._root_section = self._Section(self, None)\r
+ self._current_section = self._root_section\r
+\r
+ self._whitespace_matcher = _re.compile(r'\s+')\r
+ self._long_break_matcher = _re.compile(r'\n\n\n+')\r
+\r
+ # ===============================\r
+ # Section and indentation methods\r
+ # ===============================\r
+ def _indent(self):\r
+ self._current_indent += self._indent_increment\r
+ self._level += 1\r
+\r
+ def _dedent(self):\r
+ self._current_indent -= self._indent_increment\r
+ assert self._current_indent >= 0, 'Indent decreased below 0.'\r
+ self._level -= 1\r
+\r
+ class _Section(object):\r
+\r
+ def __init__(self, formatter, parent, heading=None):\r
+ self.formatter = formatter\r
+ self.parent = parent\r
+ self.heading = heading\r
+ self.items = []\r
+\r
+ def format_help(self):\r
+ # format the indented section\r
+ if self.parent is not None:\r
+ self.formatter._indent()\r
+ join = self.formatter._join_parts\r
+ for func, args in self.items:\r
+ func(*args)\r
+ item_help = join([func(*args) for func, args in self.items])\r
+ if self.parent is not None:\r
+ self.formatter._dedent()\r
+\r
+ # return nothing if the section was empty\r
+ if not item_help:\r
+ return ''\r
+\r
+ # add the heading if the section was non-empty\r
+ if self.heading is not SUPPRESS and self.heading is not None:\r
+ current_indent = self.formatter._current_indent\r
+ heading = '%*s%s:\n' % (current_indent, '', self.heading)\r
+ else:\r
+ heading = ''\r
+\r
+ # join the section-initial newline, the heading and the help\r
+ return join(['\n', heading, item_help, '\n'])\r
+\r
+ def _add_item(self, func, args):\r
+ self._current_section.items.append((func, args))\r
+\r
+ # ========================\r
+ # Message building methods\r
+ # ========================\r
+ def start_section(self, heading):\r
+ self._indent()\r
+ section = self._Section(self, self._current_section, heading)\r
+ self._add_item(section.format_help, [])\r
+ self._current_section = section\r
+\r
+ def end_section(self):\r
+ self._current_section = self._current_section.parent\r
+ self._dedent()\r
+\r
+ def add_text(self, text):\r
+ if text is not SUPPRESS and text is not None:\r
+ self._add_item(self._format_text, [text])\r
+\r
+ def add_usage(self, usage, actions, groups, prefix=None):\r
+ if usage is not SUPPRESS:\r
+ args = usage, actions, groups, prefix\r
+ self._add_item(self._format_usage, args)\r
+\r
+ def add_argument(self, action):\r
+ if action.help is not SUPPRESS:\r
+\r
+ # find all invocations\r
+ get_invocation = self._format_action_invocation\r
+ invocations = [get_invocation(action)]\r
+ for subaction in self._iter_indented_subactions(action):\r
+ invocations.append(get_invocation(subaction))\r
+\r
+ # update the maximum item length\r
+ invocation_length = max([len(s) for s in invocations])\r
+ action_length = invocation_length + self._current_indent\r
+ self._action_max_length = max(self._action_max_length,\r
+ action_length)\r
+\r
+ # add the item to the list\r
+ self._add_item(self._format_action, [action])\r
+\r
+ def add_arguments(self, actions):\r
+ for action in actions:\r
+ self.add_argument(action)\r
+\r
+ # =======================\r
+ # Help-formatting methods\r
+ # =======================\r
+ def format_help(self):\r
+ help = self._root_section.format_help()\r
+ if help:\r
+ help = self._long_break_matcher.sub('\n\n', help)\r
+ help = help.strip('\n') + '\n'\r
+ return help\r
+\r
+ def _join_parts(self, part_strings):\r
+ return ''.join([part\r
+ for part in part_strings\r
+ if part and part is not SUPPRESS])\r
+\r
+ def _format_usage(self, usage, actions, groups, prefix):\r
+ if prefix is None:\r
+ prefix = _('usage: ')\r
+\r
+ # if usage is specified, use that\r
+ if usage is not None:\r
+ usage = usage % dict(prog=self._prog)\r
+\r
+ # if no optionals or positionals are available, usage is just prog\r
+ elif usage is None and not actions:\r
+ usage = '%(prog)s' % dict(prog=self._prog)\r
+\r
+ # if optionals and positionals are available, calculate usage\r
+ elif usage is None:\r
+ prog = '%(prog)s' % dict(prog=self._prog)\r
+\r
+ # split optionals from positionals\r
+ optionals = []\r
+ positionals = []\r
+ for action in actions:\r
+ if action.option_strings:\r
+ optionals.append(action)\r
+ else:\r
+ positionals.append(action)\r
+\r
+ # build full usage string\r
+ format = self._format_actions_usage\r
+ action_usage = format(optionals + positionals, groups)\r
+ usage = ' '.join([s for s in [prog, action_usage] if s])\r
+\r
+ # wrap the usage parts if it's too long\r
+ text_width = self._width - self._current_indent\r
+ if len(prefix) + len(usage) > text_width:\r
+\r
+ # break usage into wrappable parts\r
+ part_regexp = r'\(.*?\)+|\[.*?\]+|\S+'\r
+ opt_usage = format(optionals, groups)\r
+ pos_usage = format(positionals, groups)\r
+ opt_parts = _re.findall(part_regexp, opt_usage)\r
+ pos_parts = _re.findall(part_regexp, pos_usage)\r
+ assert ' '.join(opt_parts) == opt_usage\r
+ assert ' '.join(pos_parts) == pos_usage\r
+\r
+ # helper for wrapping lines\r
+ def get_lines(parts, indent, prefix=None):\r
+ lines = []\r
+ line = []\r
+ if prefix is not None:\r
+ line_len = len(prefix) - 1\r
+ else:\r
+ line_len = len(indent) - 1\r
+ for part in parts:\r
+ if line_len + 1 + len(part) > text_width:\r
+ lines.append(indent + ' '.join(line))\r
+ line = []\r
+ line_len = len(indent) - 1\r
+ line.append(part)\r
+ line_len += len(part) + 1\r
+ if line:\r
+ lines.append(indent + ' '.join(line))\r
+ if prefix is not None:\r
+ lines[0] = lines[0][len(indent):]\r
+ return lines\r
+\r
+ # if prog is short, follow it with optionals or positionals\r
+ if len(prefix) + len(prog) <= 0.75 * text_width:\r
+ indent = ' ' * (len(prefix) + len(prog) + 1)\r
+ if opt_parts:\r
+ lines = get_lines([prog] + opt_parts, indent, prefix)\r
+ lines.extend(get_lines(pos_parts, indent))\r
+ elif pos_parts:\r
+ lines = get_lines([prog] + pos_parts, indent, prefix)\r
+ else:\r
+ lines = [prog]\r
+\r
+ # if prog is long, put it on its own line\r
+ else:\r
+ indent = ' ' * len(prefix)\r
+ parts = opt_parts + pos_parts\r
+ lines = get_lines(parts, indent)\r
+ if len(lines) > 1:\r
+ lines = []\r
+ lines.extend(get_lines(opt_parts, indent))\r
+ lines.extend(get_lines(pos_parts, indent))\r
+ lines = [prog] + lines\r
+\r
+ # join lines into usage\r
+ usage = '\n'.join(lines)\r
+\r
+ # prefix with 'usage:'\r
+ return '%s%s\n\n' % (prefix, usage)\r
+\r
+ def _format_actions_usage(self, actions, groups):\r
+ # find group indices and identify actions in groups\r
+ group_actions = _set()\r
+ inserts = {}\r
+ for group in groups:\r
+ try:\r
+ start = actions.index(group._group_actions[0])\r
+ except ValueError:\r
+ continue\r
+ else:\r
+ end = start + len(group._group_actions)\r
+ if actions[start:end] == group._group_actions:\r
+ for action in group._group_actions:\r
+ group_actions.add(action)\r
+ if not group.required:\r
+ inserts[start] = '['\r
+ inserts[end] = ']'\r
+ else:\r
+ inserts[start] = '('\r
+ inserts[end] = ')'\r
+ for i in range(start + 1, end):\r
+ inserts[i] = '|'\r
+\r
+ # collect all actions format strings\r
+ parts = []\r
+ for i, action in enumerate(actions):\r
+\r
+ # suppressed arguments are marked with None\r
+ # remove | separators for suppressed arguments\r
+ if action.help is SUPPRESS:\r
+ parts.append(None)\r
+ if inserts.get(i) == '|':\r
+ inserts.pop(i)\r
+ elif inserts.get(i + 1) == '|':\r
+ inserts.pop(i + 1)\r
+\r
+ # produce all arg strings\r
+ elif not action.option_strings:\r
+ part = self._format_args(action, action.dest)\r
+\r
+ # if it's in a group, strip the outer []\r
+ if action in group_actions:\r
+ if part[0] == '[' and part[-1] == ']':\r
+ part = part[1:-1]\r
+\r
+ # add the action string to the list\r
+ parts.append(part)\r
+\r
+ # produce the first way to invoke the option in brackets\r
+ else:\r
+ option_string = action.option_strings[0]\r
+\r
+ # if the Optional doesn't take a value, format is:\r
+ # -s or --long\r
+ if action.nargs == 0:\r
+ part = '%s' % option_string\r
+\r
+ # if the Optional takes a value, format is:\r
+ # -s ARGS or --long ARGS\r
+ else:\r
+ default = action.dest.upper()\r
+ args_string = self._format_args(action, default)\r
+ part = '%s %s' % (option_string, args_string)\r
+\r
+ # make it look optional if it's not required or in a group\r
+ if not action.required and action not in group_actions:\r
+ part = '[%s]' % part\r
+\r
+ # add the action string to the list\r
+ parts.append(part)\r
+\r
+ # insert things at the necessary indices\r
+ for i in _sorted(inserts, reverse=True):\r
+ parts[i:i] = [inserts[i]]\r
+\r
+ # join all the action items with spaces\r
+ text = ' '.join([item for item in parts if item is not None])\r
+\r
+ # clean up separators for mutually exclusive groups\r
+ open = r'[\[(]'\r
+ close = r'[\])]'\r
+ text = _re.sub(r'(%s) ' % open, r'\1', text)\r
+ text = _re.sub(r' (%s)' % close, r'\1', text)\r
+ text = _re.sub(r'%s *%s' % (open, close), r'', text)\r
+ text = _re.sub(r'\(([^|]*)\)', r'\1', text)\r
+ text = text.strip()\r
+\r
+ # return the text\r
+ return text\r
+\r
+ def _format_text(self, text):\r
+ if '%(prog)' in text:\r
+ text = text % dict(prog=self._prog)\r
+ text_width = self._width - self._current_indent\r
+ indent = ' ' * self._current_indent\r
+ return self._fill_text(text, text_width, indent) + '\n\n'\r
+\r
+ def _format_action(self, action):\r
+ # determine the required width and the entry label\r
+ help_position = min(self._action_max_length + 2,\r
+ self._max_help_position)\r
+ help_width = self._width - help_position\r
+ action_width = help_position - self._current_indent - 2\r
+ action_header = self._format_action_invocation(action)\r
+\r
+ # ho nelp; start on same line and add a final newline\r
+ if not action.help:\r
+ tup = self._current_indent, '', action_header\r
+ action_header = '%*s%s\n' % tup\r
+\r
+ # short action name; start on the same line and pad two spaces\r
+ elif len(action_header) <= action_width:\r
+ tup = self._current_indent, '', action_width, action_header\r
+ action_header = '%*s%-*s ' % tup\r
+ indent_first = 0\r
+\r
+ # long action name; start on the next line\r
+ else:\r
+ tup = self._current_indent, '', action_header\r
+ action_header = '%*s%s\n' % tup\r
+ indent_first = help_position\r
+\r
+ # collect the pieces of the action help\r
+ parts = [action_header]\r
+\r
+ # if there was help for the action, add lines of help text\r
+ if action.help:\r
+ help_text = self._expand_help(action)\r
+ help_lines = self._split_lines(help_text, help_width)\r
+ parts.append('%*s%s\n' % (indent_first, '', help_lines[0]))\r
+ for line in help_lines[1:]:\r
+ parts.append('%*s%s\n' % (help_position, '', line))\r
+\r
+ # or add a newline if the description doesn't end with one\r
+ elif not action_header.endswith('\n'):\r
+ parts.append('\n')\r
+\r
+ # if there are any sub-actions, add their help as well\r
+ for subaction in self._iter_indented_subactions(action):\r
+ parts.append(self._format_action(subaction))\r
+\r
+ # return a single string\r
+ return self._join_parts(parts)\r
+\r
+ def _format_action_invocation(self, action):\r
+ if not action.option_strings:\r
+ metavar, = self._metavar_formatter(action, action.dest)(1)\r
+ return metavar\r
+\r
+ else:\r
+ parts = []\r
+\r
+ # if the Optional doesn't take a value, format is:\r
+ # -s, --long\r
+ if action.nargs == 0:\r
+ parts.extend(action.option_strings)\r
+\r
+ # if the Optional takes a value, format is:\r
+ # -s ARGS, --long ARGS\r
+ else:\r
+ default = action.dest.upper()\r
+ args_string = self._format_args(action, default)\r
+ for option_string in action.option_strings:\r
+ parts.append('%s %s' % (option_string, args_string))\r
+\r
+ return ', '.join(parts)\r
+\r
+ def _metavar_formatter(self, action, default_metavar):\r
+ if action.metavar is not None:\r
+ result = action.metavar\r
+ elif action.choices is not None:\r
+ choice_strs = [str(choice) for choice in action.choices]\r
+ result = '{%s}' % ','.join(choice_strs)\r
+ else:\r
+ result = default_metavar\r
+\r
+ def format(tuple_size):\r
+ if isinstance(result, tuple):\r
+ return result\r
+ else:\r
+ return (result, ) * tuple_size\r
+ return format\r
+\r
+ def _format_args(self, action, default_metavar):\r
+ get_metavar = self._metavar_formatter(action, default_metavar)\r
+ if action.nargs is None:\r
+ result = '%s' % get_metavar(1)\r
+ elif action.nargs == OPTIONAL:\r
+ result = '[%s]' % get_metavar(1)\r
+ elif action.nargs == ZERO_OR_MORE:\r
+ result = '[%s [%s ...]]' % get_metavar(2)\r
+ elif action.nargs == ONE_OR_MORE:\r
+ result = '%s [%s ...]' % get_metavar(2)\r
+ elif action.nargs == REMAINDER:\r
+ result = '...'\r
+ elif action.nargs == PARSER:\r
+ result = '%s ...' % get_metavar(1)\r
+ else:\r
+ formats = ['%s' for _ in range(action.nargs)]\r
+ result = ' '.join(formats) % get_metavar(action.nargs)\r
+ return result\r
+\r
+ def _expand_help(self, action):\r
+ params = dict(vars(action), prog=self._prog)\r
+ for name in list(params):\r
+ if params[name] is SUPPRESS:\r
+ del params[name]\r
+ for name in list(params):\r
+ if hasattr(params[name], '__name__'):\r
+ params[name] = params[name].__name__\r
+ if params.get('choices') is not None:\r
+ choices_str = ', '.join([str(c) for c in params['choices']])\r
+ params['choices'] = choices_str\r
+ return self._get_help_string(action) % params\r
+\r
+ def _iter_indented_subactions(self, action):\r
+ try:\r
+ get_subactions = action._get_subactions\r
+ except AttributeError:\r
+ pass\r
+ else:\r
+ self._indent()\r
+ for subaction in get_subactions():\r
+ yield subaction\r
+ self._dedent()\r
+\r
+ def _split_lines(self, text, width):\r
+ text = self._whitespace_matcher.sub(' ', text).strip()\r
+ return _textwrap.wrap(text, width)\r
+\r
+ def _fill_text(self, text, width, indent):\r
+ text = self._whitespace_matcher.sub(' ', text).strip()\r
+ return _textwrap.fill(text, width, initial_indent=indent,\r
+ subsequent_indent=indent)\r
+\r
+ def _get_help_string(self, action):\r
+ return action.help\r
+\r
+\r
+class RawDescriptionHelpFormatter(HelpFormatter):\r
+ """Help message formatter which retains any formatting in descriptions.\r
+\r
+ Only the name of this class is considered a public API. All the methods\r
+ provided by the class are considered an implementation detail.\r
+ """\r
+\r
+ def _fill_text(self, text, width, indent):\r
+ return ''.join([indent + line for line in text.splitlines(True)])\r
+\r
+\r
+class RawTextHelpFormatter(RawDescriptionHelpFormatter):\r
+ """Help message formatter which retains formatting of all help text.\r
+\r
+ Only the name of this class is considered a public API. All the methods\r
+ provided by the class are considered an implementation detail.\r
+ """\r
+\r
+ def _split_lines(self, text, width):\r
+ return text.splitlines()\r
+\r
+\r
+class ArgumentDefaultsHelpFormatter(HelpFormatter):\r
+ """Help message formatter which adds default values to argument help.\r
+\r
+ Only the name of this class is considered a public API. All the methods\r
+ provided by the class are considered an implementation detail.\r
+ """\r
+\r
+ def _get_help_string(self, action):\r
+ help = action.help\r
+ if '%(default)' not in action.help:\r
+ if action.default is not SUPPRESS:\r
+ defaulting_nargs = [OPTIONAL, ZERO_OR_MORE]\r
+ if action.option_strings or action.nargs in defaulting_nargs:\r
+ help += ' (default: %(default)s)'\r
+ return help\r
+\r
+\r
+# =====================\r
+# Options and Arguments\r
+# =====================\r
+\r
+def _get_action_name(argument):\r
+ if argument is None:\r
+ return None\r
+ elif argument.option_strings:\r
+ return '/'.join(argument.option_strings)\r
+ elif argument.metavar not in (None, SUPPRESS):\r
+ return argument.metavar\r
+ elif argument.dest not in (None, SUPPRESS):\r
+ return argument.dest\r
+ else:\r
+ return None\r
+\r
+\r
+class ArgumentError(Exception):\r
+ """An error from creating or using an argument (optional or positional).\r
+\r
+ The string value of this exception is the message, augmented with\r
+ information about the argument that caused it.\r
+ """\r
+\r
+ def __init__(self, argument, message):\r
+ self.argument_name = _get_action_name(argument)\r
+ self.message = message\r
+\r
+ def __str__(self):\r
+ if self.argument_name is None:\r
+ format = '%(message)s'\r
+ else:\r
+ format = 'argument %(argument_name)s: %(message)s'\r
+ return format % dict(message=self.message,\r
+ argument_name=self.argument_name)\r
+\r
+\r
+class ArgumentTypeError(Exception):\r
+ """An error from trying to convert a command line string to a type."""\r
+ pass\r
+\r
+\r
+# ==============\r
+# Action classes\r
+# ==============\r
+\r
+class Action(_AttributeHolder):\r
+ """Information about how to convert command line strings to Python objects.\r
+\r
+ Action objects are used by an ArgumentParser to represent the information\r
+ needed to parse a single argument from one or more strings from the\r
+ command line. The keyword arguments to the Action constructor are also\r
+ all attributes of Action instances.\r
+\r
+ Keyword Arguments:\r
+\r
+ - option_strings -- A list of command-line option strings which\r
+ should be associated with this action.\r
+\r
+ - dest -- The name of the attribute to hold the created object(s)\r
+\r
+ - nargs -- The number of command-line arguments that should be\r
+ consumed. By default, one argument will be consumed and a single\r
+ value will be produced. Other values include:\r
+ - N (an integer) consumes N arguments (and produces a list)\r
+ - '?' consumes zero or one arguments\r
+ - '*' consumes zero or more arguments (and produces a list)\r
+ - '+' consumes one or more arguments (and produces a list)\r
+ Note that the difference between the default and nargs=1 is that\r
+ with the default, a single value will be produced, while with\r
+ nargs=1, a list containing a single value will be produced.\r
+\r
+ - const -- The value to be produced if the option is specified and the\r
+ option uses an action that takes no values.\r
+\r
+ - default -- The value to be produced if the option is not specified.\r
+\r
+ - type -- The type which the command-line arguments should be converted\r
+ to, should be one of 'string', 'int', 'float', 'complex' or a\r
+ callable object that accepts a single string argument. If None,\r
+ 'string' is assumed.\r
+\r
+ - choices -- A container of values that should be allowed. If not None,\r
+ after a command-line argument has been converted to the appropriate\r
+ type, an exception will be raised if it is not a member of this\r
+ collection.\r
+\r
+ - required -- True if the action must always be specified at the\r
+ command line. This is only meaningful for optional command-line\r
+ arguments.\r
+\r
+ - help -- The help string describing the argument.\r
+\r
+ - metavar -- The name to be used for the option's argument with the\r
+ help string. If None, the 'dest' value will be used as the name.\r
+ """\r
+\r
+ def __init__(self,\r
+ option_strings,\r
+ dest,\r
+ nargs=None,\r
+ const=None,\r
+ default=None,\r
+ type=None,\r
+ choices=None,\r
+ required=False,\r
+ help=None,\r
+ metavar=None):\r
+ self.option_strings = option_strings\r
+ self.dest = dest\r
+ self.nargs = nargs\r
+ self.const = const\r
+ self.default = default\r
+ self.type = type\r
+ self.choices = choices\r
+ self.required = required\r
+ self.help = help\r
+ self.metavar = metavar\r
+\r
+ def _get_kwargs(self):\r
+ names = [\r
+ 'option_strings',\r
+ 'dest',\r
+ 'nargs',\r
+ 'const',\r
+ 'default',\r
+ 'type',\r
+ 'choices',\r
+ 'help',\r
+ 'metavar',\r
+ ]\r
+ return [(name, getattr(self, name)) for name in names]\r
+\r
+ def __call__(self, parser, namespace, values, option_string=None):\r
+ raise NotImplementedError(_('.__call__() not defined'))\r
+\r
+\r
+class _StoreAction(Action):\r
+\r
+ def __init__(self,\r
+ option_strings,\r
+ dest,\r
+ nargs=None,\r
+ const=None,\r
+ default=None,\r
+ type=None,\r
+ choices=None,\r
+ required=False,\r
+ help=None,\r
+ metavar=None):\r
+ if nargs == 0:\r
+ raise ValueError('nargs for store actions must be > 0; if you '\r
+ 'have nothing to store, actions such as store '\r
+ 'true or store const may be more appropriate')\r
+ if const is not None and nargs != OPTIONAL:\r
+ raise ValueError('nargs must be %r to supply const' % OPTIONAL)\r
+ super(_StoreAction, self).__init__(\r
+ option_strings=option_strings,\r
+ dest=dest,\r
+ nargs=nargs,\r
+ const=const,\r
+ default=default,\r
+ type=type,\r
+ choices=choices,\r
+ required=required,\r
+ help=help,\r
+ metavar=metavar)\r
+\r
+ def __call__(self, parser, namespace, values, option_string=None):\r
+ setattr(namespace, self.dest, values)\r
+\r
+\r
+class _StoreConstAction(Action):\r
+\r
+ def __init__(self,\r
+ option_strings,\r
+ dest,\r
+ const,\r
+ default=None,\r
+ required=False,\r
+ help=None,\r
+ metavar=None):\r
+ super(_StoreConstAction, self).__init__(\r
+ option_strings=option_strings,\r
+ dest=dest,\r
+ nargs=0,\r
+ const=const,\r
+ default=default,\r
+ required=required,\r
+ help=help)\r
+\r
+ def __call__(self, parser, namespace, values, option_string=None):\r
+ setattr(namespace, self.dest, self.const)\r
+\r
+\r
+class _StoreTrueAction(_StoreConstAction):\r
+\r
+ def __init__(self,\r
+ option_strings,\r
+ dest,\r
+ default=False,\r
+ required=False,\r
+ help=None):\r
+ super(_StoreTrueAction, self).__init__(\r
+ option_strings=option_strings,\r
+ dest=dest,\r
+ const=True,\r
+ default=default,\r
+ required=required,\r
+ help=help)\r
+\r
+\r
+class _StoreFalseAction(_StoreConstAction):\r
+\r
+ def __init__(self,\r
+ option_strings,\r
+ dest,\r
+ default=True,\r
+ required=False,\r
+ help=None):\r
+ super(_StoreFalseAction, self).__init__(\r
+ option_strings=option_strings,\r
+ dest=dest,\r
+ const=False,\r
+ default=default,\r
+ required=required,\r
+ help=help)\r
+\r
+\r
+class _AppendAction(Action):\r
+\r
+ def __init__(self,\r
+ option_strings,\r
+ dest,\r
+ nargs=None,\r
+ const=None,\r
+ default=None,\r
+ type=None,\r
+ choices=None,\r
+ required=False,\r
+ help=None,\r
+ metavar=None):\r
+ if nargs == 0:\r
+ raise ValueError('nargs for append actions must be > 0; if arg '\r
+ 'strings are not supplying the value to append, '\r
+ 'the append const action may be more appropriate')\r
+ if const is not None and nargs != OPTIONAL:\r
+ raise ValueError('nargs must be %r to supply const' % OPTIONAL)\r
+ super(_AppendAction, self).__init__(\r
+ option_strings=option_strings,\r
+ dest=dest,\r
+ nargs=nargs,\r
+ const=const,\r
+ default=default,\r
+ type=type,\r
+ choices=choices,\r
+ required=required,\r
+ help=help,\r
+ metavar=metavar)\r
+\r
+ def __call__(self, parser, namespace, values, option_string=None):\r
+ items = _copy.copy(_ensure_value(namespace, self.dest, []))\r
+ items.append(values)\r
+ setattr(namespace, self.dest, items)\r
+\r
+\r
+class _AppendConstAction(Action):\r
+\r
+ def __init__(self,\r
+ option_strings,\r
+ dest,\r
+ const,\r
+ default=None,\r
+ required=False,\r
+ help=None,\r
+ metavar=None):\r
+ super(_AppendConstAction, self).__init__(\r
+ option_strings=option_strings,\r
+ dest=dest,\r
+ nargs=0,\r
+ const=const,\r
+ default=default,\r
+ required=required,\r
+ help=help,\r
+ metavar=metavar)\r
+\r
+ def __call__(self, parser, namespace, values, option_string=None):\r
+ items = _copy.copy(_ensure_value(namespace, self.dest, []))\r
+ items.append(self.const)\r
+ setattr(namespace, self.dest, items)\r
+\r
+\r
+class _CountAction(Action):\r
+\r
+ def __init__(self,\r
+ option_strings,\r
+ dest,\r
+ default=None,\r
+ required=False,\r
+ help=None):\r
+ super(_CountAction, self).__init__(\r
+ option_strings=option_strings,\r
+ dest=dest,\r
+ nargs=0,\r
+ default=default,\r
+ required=required,\r
+ help=help)\r
+\r
+ def __call__(self, parser, namespace, values, option_string=None):\r
+ new_count = _ensure_value(namespace, self.dest, 0) + 1\r
+ setattr(namespace, self.dest, new_count)\r
+\r
+\r
+class _HelpAction(Action):\r
+\r
+ def __init__(self,\r
+ option_strings,\r
+ dest=SUPPRESS,\r
+ default=SUPPRESS,\r
+ help=None):\r
+ super(_HelpAction, self).__init__(\r
+ option_strings=option_strings,\r
+ dest=dest,\r
+ default=default,\r
+ nargs=0,\r
+ help=help)\r
+\r
+ def __call__(self, parser, namespace, values, option_string=None):\r
+ parser.print_help()\r
+ parser.exit()\r
+\r
+\r
+class _VersionAction(Action):\r
+\r
+ def __init__(self,\r
+ option_strings,\r
+ version=None,\r
+ dest=SUPPRESS,\r
+ default=SUPPRESS,\r
+ help=None):\r
+ super(_VersionAction, self).__init__(\r
+ option_strings=option_strings,\r
+ dest=dest,\r
+ default=default,\r
+ nargs=0,\r
+ help=help)\r
+ self.version = version\r
+\r
+ def __call__(self, parser, namespace, values, option_string=None):\r
+ version = self.version\r
+ if version is None:\r
+ version = parser.version\r
+ formatter = parser._get_formatter()\r
+ formatter.add_text(version)\r
+ parser.exit(message=formatter.format_help())\r
+\r
+\r
+class _SubParsersAction(Action):\r
+\r
+ class _ChoicesPseudoAction(Action):\r
+\r
+ def __init__(self, name, help):\r
+ sup = super(_SubParsersAction._ChoicesPseudoAction, self)\r
+ sup.__init__(option_strings=[], dest=name, help=help)\r
+\r
+ def __init__(self,\r
+ option_strings,\r
+ prog,\r
+ parser_class,\r
+ dest=SUPPRESS,\r
+ help=None,\r
+ metavar=None):\r
+\r
+ self._prog_prefix = prog\r
+ self._parser_class = parser_class\r
+ self._name_parser_map = {}\r
+ self._choices_actions = []\r
+\r
+ super(_SubParsersAction, self).__init__(\r
+ option_strings=option_strings,\r
+ dest=dest,\r
+ nargs=PARSER,\r
+ choices=self._name_parser_map,\r
+ help=help,\r
+ metavar=metavar)\r
+\r
+ def add_parser(self, name, **kwargs):\r
+ # set prog from the existing prefix\r
+ if kwargs.get('prog') is None:\r
+ kwargs['prog'] = '%s %s' % (self._prog_prefix, name)\r
+\r
+ # create a pseudo-action to hold the choice help\r
+ if 'help' in kwargs:\r
+ help = kwargs.pop('help')\r
+ choice_action = self._ChoicesPseudoAction(name, help)\r
+ self._choices_actions.append(choice_action)\r
+\r
+ # create the parser and add it to the map\r
+ parser = self._parser_class(**kwargs)\r
+ self._name_parser_map[name] = parser\r
+ return parser\r
+\r
+ def _get_subactions(self):\r
+ return self._choices_actions\r
+\r
+ def __call__(self, parser, namespace, values, option_string=None):\r
+ parser_name = values[0]\r
+ arg_strings = values[1:]\r
+\r
+ # set the parser name if requested\r
+ if self.dest is not SUPPRESS:\r
+ setattr(namespace, self.dest, parser_name)\r
+\r
+ # select the parser\r
+ try:\r
+ parser = self._name_parser_map[parser_name]\r
+ except KeyError:\r
+ tup = parser_name, ', '.join(self._name_parser_map)\r
+ msg = _('unknown parser %r (choices: %s)' % tup)\r
+ raise ArgumentError(self, msg)\r
+\r
+ # parse all the remaining options into the namespace\r
+ parser.parse_args(arg_strings, namespace)\r
+\r
+\r
+# ==============\r
+# Type classes\r
+# ==============\r
+\r
+class FileType(object):\r
+ """Factory for creating file object types\r
+\r
+ Instances of FileType are typically passed as type= arguments to the\r
+ ArgumentParser add_argument() method.\r
+\r
+ Keyword Arguments:\r
+ - mode -- A string indicating how the file is to be opened. Accepts the\r
+ same values as the builtin open() function.\r
+ - bufsize -- The file's desired buffer size. Accepts the same values as\r
+ the builtin open() function.\r
+ """\r
+\r
+ def __init__(self, mode='r', bufsize=None):\r
+ self._mode = mode\r
+ self._bufsize = bufsize\r
+\r
+ def __call__(self, string):\r
+ # the special argument "-" means sys.std{in,out}\r
+ if string == '-':\r
+ if 'r' in self._mode:\r
+ return _sys.stdin\r
+ elif 'w' in self._mode:\r
+ return _sys.stdout\r
+ else:\r
+ msg = _('argument "-" with mode %r' % self._mode)\r
+ raise ValueError(msg)\r
+\r
+ # all other arguments are used as file names\r
+ if self._bufsize:\r
+ return open(string, self._mode, self._bufsize)\r
+ else:\r
+ return open(string, self._mode)\r
+\r
+ def __repr__(self):\r
+ args = [self._mode, self._bufsize]\r
+ args_str = ', '.join([repr(arg) for arg in args if arg is not None])\r
+ return '%s(%s)' % (type(self).__name__, args_str)\r
+\r
+# ===========================\r
+# Optional and Positional Parsing\r
+# ===========================\r
+\r
+class Namespace(_AttributeHolder):\r
+ """Simple object for storing attributes.\r
+\r
+ Implements equality by attribute names and values, and provides a simple\r
+ string representation.\r
+ """\r
+\r
+ def __init__(self, **kwargs):\r
+ for name in kwargs:\r
+ setattr(self, name, kwargs[name])\r
+\r
+ def __eq__(self, other):\r
+ return vars(self) == vars(other)\r
+\r
+ def __ne__(self, other):\r
+ return not (self == other)\r
+\r
+ def __contains__(self, key):\r
+ return key in self.__dict__\r
+\r
+\r
+class _ActionsContainer(object):\r
+\r
+ def __init__(self,\r
+ description,\r
+ prefix_chars,\r
+ argument_default,\r
+ conflict_handler):\r
+ super(_ActionsContainer, self).__init__()\r
+\r
+ self.description = description\r
+ self.argument_default = argument_default\r
+ self.prefix_chars = prefix_chars\r
+ self.conflict_handler = conflict_handler\r
+\r
+ # set up registries\r
+ self._registries = {}\r
+\r
+ # register actions\r
+ self.register('action', None, _StoreAction)\r
+ self.register('action', 'store', _StoreAction)\r
+ self.register('action', 'store_const', _StoreConstAction)\r
+ self.register('action', 'store_true', _StoreTrueAction)\r
+ self.register('action', 'store_false', _StoreFalseAction)\r
+ self.register('action', 'append', _AppendAction)\r
+ self.register('action', 'append_const', _AppendConstAction)\r
+ self.register('action', 'count', _CountAction)\r
+ self.register('action', 'help', _HelpAction)\r
+ self.register('action', 'version', _VersionAction)\r
+ self.register('action', 'parsers', _SubParsersAction)\r
+\r
+ # raise an exception if the conflict handler is invalid\r
+ self._get_handler()\r
+\r
+ # action storage\r
+ self._actions = []\r
+ self._option_string_actions = {}\r
+\r
+ # groups\r
+ self._action_groups = []\r
+ self._mutually_exclusive_groups = []\r
+\r
+ # defaults storage\r
+ self._defaults = {}\r
+\r
+ # determines whether an "option" looks like a negative number\r
+ self._negative_number_matcher = _re.compile(r'^-\d+$|^-\d*\.\d+$')\r
+\r
+ # whether or not there are any optionals that look like negative\r
+ # numbers -- uses a list so it can be shared and edited\r
+ self._has_negative_number_optionals = []\r
+\r
+ # ====================\r
+ # Registration methods\r
+ # ====================\r
+ def register(self, registry_name, value, object):\r
+ registry = self._registries.setdefault(registry_name, {})\r
+ registry[value] = object\r
+\r
+ def _registry_get(self, registry_name, value, default=None):\r
+ return self._registries[registry_name].get(value, default)\r
+\r
+ # ==================================\r
+ # Namespace default accessor methods\r
+ # ==================================\r
+ def set_defaults(self, **kwargs):\r
+ self._defaults.update(kwargs)\r
+\r
+ # if these defaults match any existing arguments, replace\r
+ # the previous default on the object with the new one\r
+ for action in self._actions:\r
+ if action.dest in kwargs:\r
+ action.default = kwargs[action.dest]\r
+\r
+ def get_default(self, dest):\r
+ for action in self._actions:\r
+ if action.dest == dest and action.default is not None:\r
+ return action.default\r
+ return self._defaults.get(dest, None)\r
+\r
+\r
+ # =======================\r
+ # Adding argument actions\r
+ # =======================\r
+ def add_argument(self, *args, **kwargs):\r
+ """\r
+ add_argument(dest, ..., name=value, ...)\r
+ add_argument(option_string, option_string, ..., name=value, ...)\r
+ """\r
+\r
+ # if no positional args are supplied or only one is supplied and\r
+ # it doesn't look like an option string, parse a positional\r
+ # argument\r
+ chars = self.prefix_chars\r
+ if not args or len(args) == 1 and args[0][0] not in chars:\r
+ if args and 'dest' in kwargs:\r
+ raise ValueError('dest supplied twice for positional argument')\r
+ kwargs = self._get_positional_kwargs(*args, **kwargs)\r
+\r
+ # otherwise, we're adding an optional argument\r
+ else:\r
+ kwargs = self._get_optional_kwargs(*args, **kwargs)\r
+\r
+ # if no default was supplied, use the parser-level default\r
+ if 'default' not in kwargs:\r
+ dest = kwargs['dest']\r
+ if dest in self._defaults:\r
+ kwargs['default'] = self._defaults[dest]\r
+ elif self.argument_default is not None:\r
+ kwargs['default'] = self.argument_default\r
+\r
+ # create the action object, and add it to the parser\r
+ action_class = self._pop_action_class(kwargs)\r
+ if not _callable(action_class):\r
+ raise ValueError('unknown action "%s"' % action_class)\r
+ action = action_class(**kwargs)\r
+\r
+ # raise an error if the action type is not callable\r
+ type_func = self._registry_get('type', action.type, action.type)\r
+ if not _callable(type_func):\r
+ raise ValueError('%r is not callable' % type_func)\r
+\r
+ return self._add_action(action)\r
+\r
+ def add_argument_group(self, *args, **kwargs):\r
+ group = _ArgumentGroup(self, *args, **kwargs)\r
+ self._action_groups.append(group)\r
+ return group\r
+\r
+ def add_mutually_exclusive_group(self, **kwargs):\r
+ group = _MutuallyExclusiveGroup(self, **kwargs)\r
+ self._mutually_exclusive_groups.append(group)\r
+ return group\r
+\r
+ def _add_action(self, action):\r
+ # resolve any conflicts\r
+ self._check_conflict(action)\r
+\r
+ # add to actions list\r
+ self._actions.append(action)\r
+ action.container = self\r
+\r
+ # index the action by any option strings it has\r
+ for option_string in action.option_strings:\r
+ self._option_string_actions[option_string] = action\r
+\r
+ # set the flag if any option strings look like negative numbers\r
+ for option_string in action.option_strings:\r
+ if self._negative_number_matcher.match(option_string):\r
+ if not self._has_negative_number_optionals:\r
+ self._has_negative_number_optionals.append(True)\r
+\r
+ # return the created action\r
+ return action\r
+\r
+ def _remove_action(self, action):\r
+ self._actions.remove(action)\r
+\r
+ def _add_container_actions(self, container):\r
+ # collect groups by titles\r
+ title_group_map = {}\r
+ for group in self._action_groups:\r
+ if group.title in title_group_map:\r
+ msg = _('cannot merge actions - two groups are named %r')\r
+ raise ValueError(msg % (group.title))\r
+ title_group_map[group.title] = group\r
+\r
+ # map each action to its group\r
+ group_map = {}\r
+ for group in container._action_groups:\r
+\r
+ # if a group with the title exists, use that, otherwise\r
+ # create a new group matching the container's group\r
+ if group.title not in title_group_map:\r
+ title_group_map[group.title] = self.add_argument_group(\r
+ title=group.title,\r
+ description=group.description,\r
+ conflict_handler=group.conflict_handler)\r
+\r
+ # map the actions to their new group\r
+ for action in group._group_actions:\r
+ group_map[action] = title_group_map[group.title]\r
+\r
+ # add container's mutually exclusive groups\r
+ # NOTE: if add_mutually_exclusive_group ever gains title= and\r
+ # description= then this code will need to be expanded as above\r
+ for group in container._mutually_exclusive_groups:\r
+ mutex_group = self.add_mutually_exclusive_group(\r
+ required=group.required)\r
+\r
+ # map the actions to their new mutex group\r
+ for action in group._group_actions:\r
+ group_map[action] = mutex_group\r
+\r
+ # add all actions to this container or their group\r
+ for action in container._actions:\r
+ group_map.get(action, self)._add_action(action)\r
+\r
+ def _get_positional_kwargs(self, dest, **kwargs):\r
+ # make sure required is not specified\r
+ if 'required' in kwargs:\r
+ msg = _("'required' is an invalid argument for positionals")\r
+ raise TypeError(msg)\r
+\r
+ # mark positional arguments as required if at least one is\r
+ # always required\r
+ if kwargs.get('nargs') not in [OPTIONAL, ZERO_OR_MORE]:\r
+ kwargs['required'] = True\r
+ if kwargs.get('nargs') == ZERO_OR_MORE and 'default' not in kwargs:\r
+ kwargs['required'] = True\r
+\r
+ # return the keyword arguments with no option strings\r
+ return dict(kwargs, dest=dest, option_strings=[])\r
+\r
+ def _get_optional_kwargs(self, *args, **kwargs):\r
+ # determine short and long option strings\r
+ option_strings = []\r
+ long_option_strings = []\r
+ for option_string in args:\r
+ # error on strings that don't start with an appropriate prefix\r
+ if not option_string[0] in self.prefix_chars:\r
+ msg = _('invalid option string %r: '\r
+ 'must start with a character %r')\r
+ tup = option_string, self.prefix_chars\r
+ raise ValueError(msg % tup)\r
+\r
+ # strings starting with two prefix characters are long options\r
+ option_strings.append(option_string)\r
+ if option_string[0] in self.prefix_chars:\r
+ if len(option_string) > 1:\r
+ if option_string[1] in self.prefix_chars:\r
+ long_option_strings.append(option_string)\r
+\r
+ # infer destination, '--foo-bar' -> 'foo_bar' and '-x' -> 'x'\r
+ dest = kwargs.pop('dest', None)\r
+ if dest is None:\r
+ if long_option_strings:\r
+ dest_option_string = long_option_strings[0]\r
+ else:\r
+ dest_option_string = option_strings[0]\r
+ dest = dest_option_string.lstrip(self.prefix_chars)\r
+ if not dest:\r
+ msg = _('dest= is required for options like %r')\r
+ raise ValueError(msg % option_string)\r
+ dest = dest.replace('-', '_')\r
+\r
+ # return the updated keyword arguments\r
+ return dict(kwargs, dest=dest, option_strings=option_strings)\r
+\r
+ def _pop_action_class(self, kwargs, default=None):\r
+ action = kwargs.pop('action', default)\r
+ return self._registry_get('action', action, action)\r
+\r
+ def _get_handler(self):\r
+ # determine function from conflict handler string\r
+ handler_func_name = '_handle_conflict_%s' % self.conflict_handler\r
+ try:\r
+ return getattr(self, handler_func_name)\r
+ except AttributeError:\r
+ msg = _('invalid conflict_resolution value: %r')\r
+ raise ValueError(msg % self.conflict_handler)\r
+\r
+ def _check_conflict(self, action):\r
+\r
+ # find all options that conflict with this option\r
+ confl_optionals = []\r
+ for option_string in action.option_strings:\r
+ if option_string in self._option_string_actions:\r
+ confl_optional = self._option_string_actions[option_string]\r
+ confl_optionals.append((option_string, confl_optional))\r
+\r
+ # resolve any conflicts\r
+ if confl_optionals:\r
+ conflict_handler = self._get_handler()\r
+ conflict_handler(action, confl_optionals)\r
+\r
+ def _handle_conflict_error(self, action, conflicting_actions):\r
+ message = _('conflicting option string(s): %s')\r
+ conflict_string = ', '.join([option_string\r
+ for option_string, action\r
+ in conflicting_actions])\r
+ raise ArgumentError(action, message % conflict_string)\r
+\r
+ def _handle_conflict_resolve(self, action, conflicting_actions):\r
+\r
+ # remove all conflicting options\r
+ for option_string, action in conflicting_actions:\r
+\r
+ # remove the conflicting option\r
+ action.option_strings.remove(option_string)\r
+ self._option_string_actions.pop(option_string, None)\r
+\r
+ # if the option now has no option string, remove it from the\r
+ # container holding it\r
+ if not action.option_strings:\r
+ action.container._remove_action(action)\r
+\r
+\r
+class _ArgumentGroup(_ActionsContainer):\r
+\r
+ def __init__(self, container, title=None, description=None, **kwargs):\r
+ # add any missing keyword arguments by checking the container\r
+ update = kwargs.setdefault\r
+ update('conflict_handler', container.conflict_handler)\r
+ update('prefix_chars', container.prefix_chars)\r
+ update('argument_default', container.argument_default)\r
+ super_init = super(_ArgumentGroup, self).__init__\r
+ super_init(description=description, **kwargs)\r
+\r
+ # group attributes\r
+ self.title = title\r
+ self._group_actions = []\r
+\r
+ # share most attributes with the container\r
+ self._registries = container._registries\r
+ self._actions = container._actions\r
+ self._option_string_actions = container._option_string_actions\r
+ self._defaults = container._defaults\r
+ self._has_negative_number_optionals = \\r
+ container._has_negative_number_optionals\r
+\r
+ def _add_action(self, action):\r
+ action = super(_ArgumentGroup, self)._add_action(action)\r
+ self._group_actions.append(action)\r
+ return action\r
+\r
+ def _remove_action(self, action):\r
+ super(_ArgumentGroup, self)._remove_action(action)\r
+ self._group_actions.remove(action)\r
+\r
+\r
+class _MutuallyExclusiveGroup(_ArgumentGroup):\r
+\r
+ def __init__(self, container, required=False):\r
+ super(_MutuallyExclusiveGroup, self).__init__(container)\r
+ self.required = required\r
+ self._container = container\r
+\r
+ def _add_action(self, action):\r
+ if action.required:\r
+ msg = _('mutually exclusive arguments must be optional')\r
+ raise ValueError(msg)\r
+ action = self._container._add_action(action)\r
+ self._group_actions.append(action)\r
+ return action\r
+\r
+ def _remove_action(self, action):\r
+ self._container._remove_action(action)\r
+ self._group_actions.remove(action)\r
+\r
+\r
+class ArgumentParser(_AttributeHolder, _ActionsContainer):\r
+ """Object for parsing command line strings into Python objects.\r
+\r
+ Keyword Arguments:\r
+ - prog -- The name of the program (default: sys.argv[0])\r
+ - usage -- A usage message (default: auto-generated from arguments)\r
+ - description -- A description of what the program does\r
+ - epilog -- Text following the argument descriptions\r
+ - parents -- Parsers whose arguments should be copied into this one\r
+ - formatter_class -- HelpFormatter class for printing help messages\r
+ - prefix_chars -- Characters that prefix optional arguments\r
+ - fromfile_prefix_chars -- Characters that prefix files containing\r
+ additional arguments\r
+ - argument_default -- The default value for all arguments\r
+ - conflict_handler -- String indicating how to handle conflicts\r
+ - add_help -- Add a -h/-help option\r
+ """\r
+\r
+ def __init__(self,\r
+ prog=None,\r
+ usage=None,\r
+ description=None,\r
+ epilog=None,\r
+ version=None,\r
+ parents=[],\r
+ formatter_class=HelpFormatter,\r
+ prefix_chars='-',\r
+ fromfile_prefix_chars=None,\r
+ argument_default=None,\r
+ conflict_handler='error',\r
+ add_help=True):\r
+\r
+ if version is not None:\r
+ import warnings\r
+ warnings.warn(\r
+ """The "version" argument to ArgumentParser is deprecated. """\r
+ """Please use """\r
+ """"add_argument(..., action='version', version="N", ...)" """\r
+ """instead""", DeprecationWarning)\r
+\r
+ superinit = super(ArgumentParser, self).__init__\r
+ superinit(description=description,\r
+ prefix_chars=prefix_chars,\r
+ argument_default=argument_default,\r
+ conflict_handler=conflict_handler)\r
+\r
+ # default setting for prog\r
+ if prog is None:\r
+ prog = _os.path.basename(_sys.argv[0])\r
+\r
+ self.prog = prog\r
+ self.usage = usage\r
+ self.epilog = epilog\r
+ self.version = version\r
+ self.formatter_class = formatter_class\r
+ self.fromfile_prefix_chars = fromfile_prefix_chars\r
+ self.add_help = add_help\r
+\r
+ add_group = self.add_argument_group\r
+ self._positionals = add_group(_('positional arguments'))\r
+ self._optionals = add_group(_('optional arguments'))\r
+ self._subparsers = None\r
+\r
+ # register types\r
+ def identity(string):\r
+ return string\r
+ self.register('type', None, identity)\r
+\r
+ # add help and version arguments if necessary\r
+ # (using explicit default to override global argument_default)\r
+ if self.add_help:\r
+ self.add_argument(\r
+ '-h', '--help', action='help', default=SUPPRESS,\r
+ help=_('show this help message and exit'))\r
+ if self.version:\r
+ self.add_argument(\r
+ '-v', '--version', action='version', default=SUPPRESS,\r
+ version=self.version,\r
+ help=_("show program's version number and exit"))\r
+\r
+ # add parent arguments and defaults\r
+ for parent in parents:\r
+ self._add_container_actions(parent)\r
+ try:\r
+ defaults = parent._defaults\r
+ except AttributeError:\r
+ pass\r
+ else:\r
+ self._defaults.update(defaults)\r
+\r
+ # =======================\r
+ # Pretty __repr__ methods\r
+ # =======================\r
+ def _get_kwargs(self):\r
+ names = [\r
+ 'prog',\r
+ 'usage',\r
+ 'description',\r
+ 'version',\r
+ 'formatter_class',\r
+ 'conflict_handler',\r
+ 'add_help',\r
+ ]\r
+ return [(name, getattr(self, name)) for name in names]\r
+\r
+ # ==================================\r
+ # Optional/Positional adding methods\r
+ # ==================================\r
+ def add_subparsers(self, **kwargs):\r
+ if self._subparsers is not None:\r
+ self.error(_('cannot have multiple subparser arguments'))\r
+\r
+ # add the parser class to the arguments if it's not present\r
+ kwargs.setdefault('parser_class', type(self))\r
+\r
+ if 'title' in kwargs or 'description' in kwargs:\r
+ title = _(kwargs.pop('title', 'subcommands'))\r
+ description = _(kwargs.pop('description', None))\r
+ self._subparsers = self.add_argument_group(title, description)\r
+ else:\r
+ self._subparsers = self._positionals\r
+\r
+ # prog defaults to the usage message of this parser, skipping\r
+ # optional arguments and with no "usage:" prefix\r
+ if kwargs.get('prog') is None:\r
+ formatter = self._get_formatter()\r
+ positionals = self._get_positional_actions()\r
+ groups = self._mutually_exclusive_groups\r
+ formatter.add_usage(self.usage, positionals, groups, '')\r
+ kwargs['prog'] = formatter.format_help().strip()\r
+\r
+ # create the parsers action and add it to the positionals list\r
+ parsers_class = self._pop_action_class(kwargs, 'parsers')\r
+ action = parsers_class(option_strings=[], **kwargs)\r
+ self._subparsers._add_action(action)\r
+\r
+ # return the created parsers action\r
+ return action\r
+\r
+ def _add_action(self, action):\r
+ if action.option_strings:\r
+ self._optionals._add_action(action)\r
+ else:\r
+ self._positionals._add_action(action)\r
+ return action\r
+\r
+ def _get_optional_actions(self):\r
+ return [action\r
+ for action in self._actions\r
+ if action.option_strings]\r
+\r
+ def _get_positional_actions(self):\r
+ return [action\r
+ for action in self._actions\r
+ if not action.option_strings]\r
+\r
+ # =====================================\r
+ # Command line argument parsing methods\r
+ # =====================================\r
+ def parse_args(self, args=None, namespace=None):\r
+ args, argv = self.parse_known_args(args, namespace)\r
+ if argv:\r
+ msg = _('unrecognized arguments: %s')\r
+ self.error(msg % ' '.join(argv))\r
+ return args\r
+\r
+ def parse_known_args(self, args=None, namespace=None):\r
+ # args default to the system args\r
+ if args is None:\r
+ args = _sys.argv[1:]\r
+\r
+ # default Namespace built from parser defaults\r
+ if namespace is None:\r
+ namespace = Namespace()\r
+\r
+ # add any action defaults that aren't present\r
+ for action in self._actions:\r
+ if action.dest is not SUPPRESS:\r
+ if not hasattr(namespace, action.dest):\r
+ if action.default is not SUPPRESS:\r
+ default = action.default\r
+ if isinstance(action.default, _basestring):\r
+ default = self._get_value(action, default)\r
+ setattr(namespace, action.dest, default)\r
+\r
+ # add any parser defaults that aren't present\r
+ for dest in self._defaults:\r
+ if not hasattr(namespace, dest):\r
+ setattr(namespace, dest, self._defaults[dest])\r
+\r
+ # parse the arguments and exit if there are any errors\r
+ try:\r
+ return self._parse_known_args(args, namespace)\r
+ except ArgumentError:\r
+ err = _sys.exc_info()[1]\r
+ self.error(str(err))\r
+\r
+ def _parse_known_args(self, arg_strings, namespace):\r
+ # replace arg strings that are file references\r
+ if self.fromfile_prefix_chars is not None:\r
+ arg_strings = self._read_args_from_files(arg_strings)\r
+\r
+ # map all mutually exclusive arguments to the other arguments\r
+ # they can't occur with\r
+ action_conflicts = {}\r
+ for mutex_group in self._mutually_exclusive_groups:\r
+ group_actions = mutex_group._group_actions\r
+ for i, mutex_action in enumerate(mutex_group._group_actions):\r
+ conflicts = action_conflicts.setdefault(mutex_action, [])\r
+ conflicts.extend(group_actions[:i])\r
+ conflicts.extend(group_actions[i + 1:])\r
+\r
+ # find all option indices, and determine the arg_string_pattern\r
+ # which has an 'O' if there is an option at an index,\r
+ # an 'A' if there is an argument, or a '-' if there is a '--'\r
+ option_string_indices = {}\r
+ arg_string_pattern_parts = []\r
+ arg_strings_iter = iter(arg_strings)\r
+ for i, arg_string in enumerate(arg_strings_iter):\r
+\r
+ # all args after -- are non-options\r
+ if arg_string == '--':\r
+ arg_string_pattern_parts.append('-')\r
+ for arg_string in arg_strings_iter:\r
+ arg_string_pattern_parts.append('A')\r
+\r
+ # otherwise, add the arg to the arg strings\r
+ # and note the index if it was an option\r
+ else:\r
+ option_tuple = self._parse_optional(arg_string)\r
+ if option_tuple is None:\r
+ pattern = 'A'\r
+ else:\r
+ option_string_indices[i] = option_tuple\r
+ pattern = 'O'\r
+ arg_string_pattern_parts.append(pattern)\r
+\r
+ # join the pieces together to form the pattern\r
+ arg_strings_pattern = ''.join(arg_string_pattern_parts)\r
+\r
+ # converts arg strings to the appropriate and then takes the action\r
+ seen_actions = _set()\r
+ seen_non_default_actions = _set()\r
+\r
+ def take_action(action, argument_strings, option_string=None):\r
+ seen_actions.add(action)\r
+ argument_values = self._get_values(action, argument_strings)\r
+\r
+ # error if this argument is not allowed with other previously\r
+ # seen arguments, assuming that actions that use the default\r
+ # value don't really count as "present"\r
+ if argument_values is not action.default:\r
+ seen_non_default_actions.add(action)\r
+ for conflict_action in action_conflicts.get(action, []):\r
+ if conflict_action in seen_non_default_actions:\r
+ msg = _('not allowed with argument %s')\r
+ action_name = _get_action_name(conflict_action)\r
+ raise ArgumentError(action, msg % action_name)\r
+\r
+ # take the action if we didn't receive a SUPPRESS value\r
+ # (e.g. from a default)\r
+ if argument_values is not SUPPRESS:\r
+ action(self, namespace, argument_values, option_string)\r
+\r
+ # function to convert arg_strings into an optional action\r
+ def consume_optional(start_index):\r
+\r
+ # get the optional identified at this index\r
+ option_tuple = option_string_indices[start_index]\r
+ action, option_string, explicit_arg = option_tuple\r
+\r
+ # identify additional optionals in the same arg string\r
+ # (e.g. -xyz is the same as -x -y -z if no args are required)\r
+ match_argument = self._match_argument\r
+ action_tuples = []\r
+ while True:\r
+\r
+ # if we found no optional action, skip it\r
+ if action is None:\r
+ extras.append(arg_strings[start_index])\r
+ return start_index + 1\r
+\r
+ # if there is an explicit argument, try to match the\r
+ # optional's string arguments to only this\r
+ if explicit_arg is not None:\r
+ arg_count = match_argument(action, 'A')\r
+\r
+ # if the action is a single-dash option and takes no\r
+ # arguments, try to parse more single-dash options out\r
+ # of the tail of the option string\r
+ chars = self.prefix_chars\r
+ if arg_count == 0 and option_string[1] not in chars:\r
+ action_tuples.append((action, [], option_string))\r
+ for char in self.prefix_chars:\r
+ option_string = char + explicit_arg[0]\r
+ explicit_arg = explicit_arg[1:] or None\r
+ optionals_map = self._option_string_actions\r
+ if option_string in optionals_map:\r
+ action = optionals_map[option_string]\r
+ break\r
+ else:\r
+ msg = _('ignored explicit argument %r')\r
+ raise ArgumentError(action, msg % explicit_arg)\r
+\r
+ # if the action expect exactly one argument, we've\r
+ # successfully matched the option; exit the loop\r
+ elif arg_count == 1:\r
+ stop = start_index + 1\r
+ args = [explicit_arg]\r
+ action_tuples.append((action, args, option_string))\r
+ break\r
+\r
+ # error if a double-dash option did not use the\r
+ # explicit argument\r
+ else:\r
+ msg = _('ignored explicit argument %r')\r
+ raise ArgumentError(action, msg % explicit_arg)\r
+\r
+ # if there is no explicit argument, try to match the\r
+ # optional's string arguments with the following strings\r
+ # if successful, exit the loop\r
+ else:\r
+ start = start_index + 1\r
+ selected_patterns = arg_strings_pattern[start:]\r
+ arg_count = match_argument(action, selected_patterns)\r
+ stop = start + arg_count\r
+ args = arg_strings[start:stop]\r
+ action_tuples.append((action, args, option_string))\r
+ break\r
+\r
+ # add the Optional to the list and return the index at which\r
+ # the Optional's string args stopped\r
+ assert action_tuples\r
+ for action, args, option_string in action_tuples:\r
+ take_action(action, args, option_string)\r
+ return stop\r
+\r
+ # the list of Positionals left to be parsed; this is modified\r
+ # by consume_positionals()\r
+ positionals = self._get_positional_actions()\r
+\r
+ # function to convert arg_strings into positional actions\r
+ def consume_positionals(start_index):\r
+ # match as many Positionals as possible\r
+ match_partial = self._match_arguments_partial\r
+ selected_pattern = arg_strings_pattern[start_index:]\r
+ arg_counts = match_partial(positionals, selected_pattern)\r
+\r
+ # slice off the appropriate arg strings for each Positional\r
+ # and add the Positional and its args to the list\r
+ for action, arg_count in zip(positionals, arg_counts):\r
+ args = arg_strings[start_index: start_index + arg_count]\r
+ start_index += arg_count\r
+ take_action(action, args)\r
+\r
+ # slice off the Positionals that we just parsed and return the\r
+ # index at which the Positionals' string args stopped\r
+ positionals[:] = positionals[len(arg_counts):]\r
+ return start_index\r
+\r
+ # consume Positionals and Optionals alternately, until we have\r
+ # passed the last option string\r
+ extras = []\r
+ start_index = 0\r
+ if option_string_indices:\r
+ max_option_string_index = max(option_string_indices)\r
+ else:\r
+ max_option_string_index = -1\r
+ while start_index <= max_option_string_index:\r
+\r
+ # consume any Positionals preceding the next option\r
+ next_option_string_index = min([\r
+ index\r
+ for index in option_string_indices\r
+ if index >= start_index])\r
+ if start_index != next_option_string_index:\r
+ positionals_end_index = consume_positionals(start_index)\r
+\r
+ # only try to parse the next optional if we didn't consume\r
+ # the option string during the positionals parsing\r
+ if positionals_end_index > start_index:\r
+ start_index = positionals_end_index\r
+ continue\r
+ else:\r
+ start_index = positionals_end_index\r
+\r
+ # if we consumed all the positionals we could and we're not\r
+ # at the index of an option string, there were extra arguments\r
+ if start_index not in option_string_indices:\r
+ strings = arg_strings[start_index:next_option_string_index]\r
+ extras.extend(strings)\r
+ start_index = next_option_string_index\r
+\r
+ # consume the next optional and any arguments for it\r
+ start_index = consume_optional(start_index)\r
+\r
+ # consume any positionals following the last Optional\r
+ stop_index = consume_positionals(start_index)\r
+\r
+ # if we didn't consume all the argument strings, there were extras\r
+ extras.extend(arg_strings[stop_index:])\r
+\r
+ # if we didn't use all the Positional objects, there were too few\r
+ # arg strings supplied.\r
+ if positionals:\r
+ self.error(_('too few arguments'))\r
+\r
+ # make sure all required actions were present\r
+ for action in self._actions:\r
+ if action.required:\r
+ if action not in seen_actions:\r
+ name = _get_action_name(action)\r
+ self.error(_('argument %s is required') % name)\r
+\r
+ # make sure all required groups had one option present\r
+ for group in self._mutually_exclusive_groups:\r
+ if group.required:\r
+ for action in group._group_actions:\r
+ if action in seen_non_default_actions:\r
+ break\r
+\r
+ # if no actions were used, report the error\r
+ else:\r
+ names = [_get_action_name(action)\r
+ for action in group._group_actions\r
+ if action.help is not SUPPRESS]\r
+ msg = _('one of the arguments %s is required')\r
+ self.error(msg % ' '.join(names))\r
+\r
+ # return the updated namespace and the extra arguments\r
+ return namespace, extras\r
+\r
+ def _read_args_from_files(self, arg_strings):\r
+ # expand arguments referencing files\r
+ new_arg_strings = []\r
+ for arg_string in arg_strings:\r
+\r
+ # for regular arguments, just add them back into the list\r
+ if arg_string[0] not in self.fromfile_prefix_chars:\r
+ new_arg_strings.append(arg_string)\r
+\r
+ # replace arguments referencing files with the file content\r
+ else:\r
+ try:\r
+ args_file = open(arg_string[1:])\r
+ try:\r
+ arg_strings = []\r
+ for arg_line in args_file.read().splitlines():\r
+ for arg in self.convert_arg_line_to_args(arg_line):\r
+ arg_strings.append(arg)\r
+ arg_strings = self._read_args_from_files(arg_strings)\r
+ new_arg_strings.extend(arg_strings)\r
+ finally:\r
+ args_file.close()\r
+ except IOError:\r
+ err = _sys.exc_info()[1]\r
+ self.error(str(err))\r
+\r
+ # return the modified argument list\r
+ return new_arg_strings\r
+\r
+ def convert_arg_line_to_args(self, arg_line):\r
+ return [arg_line]\r
+\r
+ def _match_argument(self, action, arg_strings_pattern):\r
+ # match the pattern for this action to the arg strings\r
+ nargs_pattern = self._get_nargs_pattern(action)\r
+ match = _re.match(nargs_pattern, arg_strings_pattern)\r
+\r
+ # raise an exception if we weren't able to find a match\r
+ if match is None:\r
+ nargs_errors = {\r
+ None: _('expected one argument'),\r
+ OPTIONAL: _('expected at most one argument'),\r
+ ONE_OR_MORE: _('expected at least one argument'),\r
+ }\r
+ default = _('expected %s argument(s)') % action.nargs\r
+ msg = nargs_errors.get(action.nargs, default)\r
+ raise ArgumentError(action, msg)\r
+\r
+ # return the number of arguments matched\r
+ return len(match.group(1))\r
+\r
+ def _match_arguments_partial(self, actions, arg_strings_pattern):\r
+ # progressively shorten the actions list by slicing off the\r
+ # final actions until we find a match\r
+ result = []\r
+ for i in range(len(actions), 0, -1):\r
+ actions_slice = actions[:i]\r
+ pattern = ''.join([self._get_nargs_pattern(action)\r
+ for action in actions_slice])\r
+ match = _re.match(pattern, arg_strings_pattern)\r
+ if match is not None:\r
+ result.extend([len(string) for string in match.groups()])\r
+ break\r
+\r
+ # return the list of arg string counts\r
+ return result\r
+\r
+ def _parse_optional(self, arg_string):\r
+ # if it's an empty string, it was meant to be a positional\r
+ if not arg_string:\r
+ return None\r
+\r
+ # if it doesn't start with a prefix, it was meant to be positional\r
+ if not arg_string[0] in self.prefix_chars:\r
+ return None\r
+\r
+ # if the option string is present in the parser, return the action\r
+ if arg_string in self._option_string_actions:\r
+ action = self._option_string_actions[arg_string]\r
+ return action, arg_string, None\r
+\r
+ # if it's just a single character, it was meant to be positional\r
+ if len(arg_string) == 1:\r
+ return None\r
+\r
+ # if the option string before the "=" is present, return the action\r
+ if '=' in arg_string:\r
+ option_string, explicit_arg = arg_string.split('=', 1)\r
+ if option_string in self._option_string_actions:\r
+ action = self._option_string_actions[option_string]\r
+ return action, option_string, explicit_arg\r
+\r
+ # search through all possible prefixes of the option string\r
+ # and all actions in the parser for possible interpretations\r
+ option_tuples = self._get_option_tuples(arg_string)\r
+\r
+ # if multiple actions match, the option string was ambiguous\r
+ if len(option_tuples) > 1:\r
+ options = ', '.join([option_string\r
+ for action, option_string, explicit_arg in option_tuples])\r
+ tup = arg_string, options\r
+ self.error(_('ambiguous option: %s could match %s') % tup)\r
+\r
+ # if exactly one action matched, this segmentation is good,\r
+ # so return the parsed action\r
+ elif len(option_tuples) == 1:\r
+ option_tuple, = option_tuples\r
+ return option_tuple\r
+\r
+ # if it was not found as an option, but it looks like a negative\r
+ # number, it was meant to be positional\r
+ # unless there are negative-number-like options\r
+ if self._negative_number_matcher.match(arg_string):\r
+ if not self._has_negative_number_optionals:\r
+ return None\r
+\r
+ # if it contains a space, it was meant to be a positional\r
+ if ' ' in arg_string:\r
+ return None\r
+\r
+ # it was meant to be an optional but there is no such option\r
+ # in this parser (though it might be a valid option in a subparser)\r
+ return None, arg_string, None\r
+\r
+ def _get_option_tuples(self, option_string):\r
+ result = []\r
+\r
+ # option strings starting with two prefix characters are only\r
+ # split at the '='\r
+ chars = self.prefix_chars\r
+ if option_string[0] in chars and option_string[1] in chars:\r
+ if '=' in option_string:\r
+ option_prefix, explicit_arg = option_string.split('=', 1)\r
+ else:\r
+ option_prefix = option_string\r
+ explicit_arg = None\r
+ for option_string in self._option_string_actions:\r
+ if option_string.startswith(option_prefix):\r
+ action = self._option_string_actions[option_string]\r
+ tup = action, option_string, explicit_arg\r
+ result.append(tup)\r
+\r
+ # single character options can be concatenated with their arguments\r
+ # but multiple character options always have to have their argument\r
+ # separate\r
+ elif option_string[0] in chars and option_string[1] not in chars:\r
+ option_prefix = option_string\r
+ explicit_arg = None\r
+ short_option_prefix = option_string[:2]\r
+ short_explicit_arg = option_string[2:]\r
+\r
+ for option_string in self._option_string_actions:\r
+ if option_string == short_option_prefix:\r
+ action = self._option_string_actions[option_string]\r
+ tup = action, option_string, short_explicit_arg\r
+ result.append(tup)\r
+ elif option_string.startswith(option_prefix):\r
+ action = self._option_string_actions[option_string]\r
+ tup = action, option_string, explicit_arg\r
+ result.append(tup)\r
+\r
+ # shouldn't ever get here\r
+ else:\r
+ self.error(_('unexpected option string: %s') % option_string)\r
+\r
+ # return the collected option tuples\r
+ return result\r
+\r
+ def _get_nargs_pattern(self, action):\r
+ # in all examples below, we have to allow for '--' args\r
+ # which are represented as '-' in the pattern\r
+ nargs = action.nargs\r
+\r
+ # the default (None) is assumed to be a single argument\r
+ if nargs is None:\r
+ nargs_pattern = '(-*A-*)'\r
+\r
+ # allow zero or one arguments\r
+ elif nargs == OPTIONAL:\r
+ nargs_pattern = '(-*A?-*)'\r
+\r
+ # allow zero or more arguments\r
+ elif nargs == ZERO_OR_MORE:\r
+ nargs_pattern = '(-*[A-]*)'\r
+\r
+ # allow one or more arguments\r
+ elif nargs == ONE_OR_MORE:\r
+ nargs_pattern = '(-*A[A-]*)'\r
+\r
+ # allow any number of options or arguments\r
+ elif nargs == REMAINDER:\r
+ nargs_pattern = '([-AO]*)'\r
+\r
+ # allow one argument followed by any number of options or arguments\r
+ elif nargs == PARSER:\r
+ nargs_pattern = '(-*A[-AO]*)'\r
+\r
+ # all others should be integers\r
+ else:\r
+ nargs_pattern = '(-*%s-*)' % '-*'.join('A' * nargs)\r
+\r
+ # if this is an optional action, -- is not allowed\r
+ if action.option_strings:\r
+ nargs_pattern = nargs_pattern.replace('-*', '')\r
+ nargs_pattern = nargs_pattern.replace('-', '')\r
+\r
+ # return the pattern\r
+ return nargs_pattern\r
+\r
+ # ========================\r
+ # Value conversion methods\r
+ # ========================\r
+ def _get_values(self, action, arg_strings):\r
+ # for everything but PARSER args, strip out '--'\r
+ if action.nargs not in [PARSER, REMAINDER]:\r
+ arg_strings = [s for s in arg_strings if s != '--']\r
+\r
+ # optional argument produces a default when not present\r
+ if not arg_strings and action.nargs == OPTIONAL:\r
+ if action.option_strings:\r
+ value = action.const\r
+ else:\r
+ value = action.default\r
+ if isinstance(value, _basestring):\r
+ value = self._get_value(action, value)\r
+ self._check_value(action, value)\r
+\r
+ # when nargs='*' on a positional, if there were no command-line\r
+ # args, use the default if it is anything other than None\r
+ elif (not arg_strings and action.nargs == ZERO_OR_MORE and\r
+ not action.option_strings):\r
+ if action.default is not None:\r
+ value = action.default\r
+ else:\r
+ value = arg_strings\r
+ self._check_value(action, value)\r
+\r
+ # single argument or optional argument produces a single value\r
+ elif len(arg_strings) == 1 and action.nargs in [None, OPTIONAL]:\r
+ arg_string, = arg_strings\r
+ value = self._get_value(action, arg_string)\r
+ self._check_value(action, value)\r
+\r
+ # REMAINDER arguments convert all values, checking none\r
+ elif action.nargs == REMAINDER:\r
+ value = [self._get_value(action, v) for v in arg_strings]\r
+\r
+ # PARSER arguments convert all values, but check only the first\r
+ elif action.nargs == PARSER:\r
+ value = [self._get_value(action, v) for v in arg_strings]\r
+ self._check_value(action, value[0])\r
+\r
+ # all other types of nargs produce a list\r
+ else:\r
+ value = [self._get_value(action, v) for v in arg_strings]\r
+ for v in value:\r
+ self._check_value(action, v)\r
+\r
+ # return the converted value\r
+ return value\r
+\r
+ def _get_value(self, action, arg_string):\r
+ type_func = self._registry_get('type', action.type, action.type)\r
+ if not _callable(type_func):\r
+ msg = _('%r is not callable')\r
+ raise ArgumentError(action, msg % type_func)\r
+\r
+ # convert the value to the appropriate type\r
+ try:\r
+ result = type_func(arg_string)\r
+\r
+ # ArgumentTypeErrors indicate errors\r
+ except ArgumentTypeError:\r
+ name = getattr(action.type, '__name__', repr(action.type))\r
+ msg = str(_sys.exc_info()[1])\r
+ raise ArgumentError(action, msg)\r
+\r
+ # TypeErrors or ValueErrors also indicate errors\r
+ except (TypeError, ValueError):\r
+ name = getattr(action.type, '__name__', repr(action.type))\r
+ msg = _('invalid %s value: %r')\r
+ raise ArgumentError(action, msg % (name, arg_string))\r
+\r
+ # return the converted value\r
+ return result\r
+\r
+ def _check_value(self, action, value):\r
+ # converted value must be one of the choices (if specified)\r
+ if action.choices is not None and value not in action.choices:\r
+ tup = value, ', '.join(map(repr, action.choices))\r
+ msg = _('invalid choice: %r (choose from %s)') % tup\r
+ raise ArgumentError(action, msg)\r
+\r
+ # =======================\r
+ # Help-formatting methods\r
+ # =======================\r
+ def format_usage(self):\r
+ formatter = self._get_formatter()\r
+ formatter.add_usage(self.usage, self._actions,\r
+ self._mutually_exclusive_groups)\r
+ return formatter.format_help()\r
+\r
+ def format_help(self):\r
+ formatter = self._get_formatter()\r
+\r
+ # usage\r
+ formatter.add_usage(self.usage, self._actions,\r
+ self._mutually_exclusive_groups)\r
+\r
+ # description\r
+ formatter.add_text(self.description)\r
+\r
+ # positionals, optionals and user-defined groups\r
+ for action_group in self._action_groups:\r
+ formatter.start_section(action_group.title)\r
+ formatter.add_text(action_group.description)\r
+ formatter.add_arguments(action_group._group_actions)\r
+ formatter.end_section()\r
+\r
+ # epilog\r
+ formatter.add_text(self.epilog)\r
+\r
+ # determine help from format above\r
+ return formatter.format_help()\r
+\r
+ def format_version(self):\r
+ import warnings\r
+ warnings.warn(\r
+ 'The format_version method is deprecated -- the "version" '\r
+ 'argument to ArgumentParser is no longer supported.',\r
+ DeprecationWarning)\r
+ formatter = self._get_formatter()\r
+ formatter.add_text(self.version)\r
+ return formatter.format_help()\r
+\r
+ def _get_formatter(self):\r
+ return self.formatter_class(prog=self.prog)\r
+\r
+ # =====================\r
+ # Help-printing methods\r
+ # =====================\r
+ def print_usage(self, file=None):\r
+ if file is None:\r
+ file = _sys.stdout\r
+ self._print_message(self.format_usage(), file)\r
+\r
+ def print_help(self, file=None):\r
+ if file is None:\r
+ file = _sys.stdout\r
+ self._print_message(self.format_help(), file)\r
+\r
+ def print_version(self, file=None):\r
+ import warnings\r
+ warnings.warn(\r
+ 'The print_version method is deprecated -- the "version" '\r
+ 'argument to ArgumentParser is no longer supported.',\r
+ DeprecationWarning)\r
+ self._print_message(self.format_version(), file)\r
+\r
+ def _print_message(self, message, file=None):\r
+ if message:\r
+ if file is None:\r
+ file = _sys.stderr\r
+ file.write(message)\r
+\r
+ # ===============\r
+ # Exiting methods\r
+ # ===============\r
+ def exit(self, status=0, message=None):\r
+ if message:\r
+ self._print_message(message, _sys.stderr)\r
+ _sys.exit(status)\r
+\r
+ def error(self, message):\r
+ """error(message: string)\r
+\r
+ Prints a usage message incorporating the message to stderr and\r
+ exits.\r
+\r
+ If you override this in a subclass, it should not return -- it\r
+ should either exit or raise an exception.\r
+ """\r
+ self.print_usage(_sys.stderr)\r
+ self.exit(2, _('%s: error: %s\n') % (self.prog, message))\r
--- /dev/null
+# -*- coding: utf-8 -*-\r
+\r
+# Copyright © 2006-2009 Steven J. Bethard <steven.bethard@gmail.com>.\r
+#\r
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not\r
+# use this file except in compliance with the License. You may obtain a copy\r
+# of the License at\r
+#\r
+# http://www.apache.org/licenses/LICENSE-2.0\r
+#\r
+# Unless required by applicable law or agreed to in writing, software\r
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT\r
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the\r
+# License for the specific language governing permissions and limitations\r
+# under the License.\r
+\r
+import codecs\r
+import os\r
+import shutil\r
+import sys\r
+import textwrap\r
+import tempfile\r
+import unittest\r
+import argparse\r
+\r
+try:\r
+ from StringIO import StringIO\r
+except ImportError:\r
+ from io import StringIO\r
+\r
+try:\r
+ set\r
+except NameError:\r
+ from sets import Set as set\r
+\r
+try:\r
+ sorted\r
+except NameError:\r
+\r
+ def sorted(iterable, reverse=False):\r
+ result = list(iterable)\r
+ result.sort()\r
+ if reverse:\r
+ result.reverse()\r
+ return result\r
+\r
+# silence Python 2.6 buggy warnings about Exception.message\r
+if sys.version_info[:2] == (2, 6):\r
+ import warnings\r
+ warnings.filterwarnings(\r
+ action='ignore',\r
+ message='BaseException.message has been deprecated as of Python 2.6',\r
+ category=DeprecationWarning)\r
+\r
+# silence warnings about version argument - these are expected\r
+import warnings\r
+warnings.filterwarnings(\r
+ action='ignore',\r
+ message='The "version" argument to ArgumentParser is deprecated.',\r
+ category=DeprecationWarning)\r
+warnings.filterwarnings(\r
+ action='ignore',\r
+ message='The format_version method is deprecated',\r
+ category=DeprecationWarning)\r
+warnings.filterwarnings(\r
+ action='ignore',\r
+ message='The print_version method is deprecated',\r
+ category=DeprecationWarning)\r
+\r
+\r
+class TestCase(unittest.TestCase):\r
+\r
+ def assertEqual(self, obj1, obj2):\r
+ if obj1 != obj2:\r
+ print('')\r
+ print(repr(obj1))\r
+ print(repr(obj2))\r
+ print(obj1)\r
+ print(obj2)\r
+ super(TestCase, self).assertEqual(obj1, obj2)\r
+\r
+\r
+class TempDirMixin(object):\r
+\r
+ def setUp(self):\r
+ self.temp_dir = tempfile.mkdtemp()\r
+ self.old_dir = os.getcwd()\r
+ os.chdir(self.temp_dir)\r
+\r
+ def tearDown(self):\r
+ os.chdir(self.old_dir)\r
+ while True:\r
+ try:\r
+ shutil.rmtree(self.temp_dir)\r
+ except WindowsError:\r
+ continue\r
+ else:\r
+ break\r
+\r
+\r
+class Sig(object):\r
+\r
+ def __init__(self, *args, **kwargs):\r
+ self.args = args\r
+ self.kwargs = kwargs\r
+\r
+\r
+class NS(object):\r
+\r
+ def __init__(self, **kwargs):\r
+ self.__dict__.update(kwargs)\r
+\r
+ def __repr__(self):\r
+ sorted_items = sorted(self.__dict__.items())\r
+ kwarg_str = ', '.join(['%s=%r' % tup for tup in sorted_items])\r
+ return '%s(%s)' % (type(self).__name__, kwarg_str)\r
+\r
+ def __eq__(self, other):\r
+ return vars(self) == vars(other)\r
+\r
+ def __ne__(self, other):\r
+ return not (self == other)\r
+\r
+\r
+class ArgumentParserError(Exception):\r
+\r
+ def __init__(self, message, stdout=None, stderr=None, error_code=None):\r
+ Exception.__init__(self, message, stdout, stderr)\r
+ self.message = message\r
+ self.stdout = stdout\r
+ self.stderr = stderr\r
+ self.error_code = error_code\r
+\r
+\r
+def stderr_to_parser_error(parse_args, *args, **kwargs):\r
+ # if this is being called recursively and stderr or stdout is already being\r
+ # redirected, simply call the function and let the enclosing function\r
+ # catch the exception\r
+ if isinstance(sys.stderr, StringIO) or isinstance(sys.stdout, StringIO):\r
+ return parse_args(*args, **kwargs)\r
+\r
+ # if this is not being called recursively, redirect stderr and\r
+ # use it as the ArgumentParserError message\r
+ old_stdout = sys.stdout\r
+ old_stderr = sys.stderr\r
+ sys.stdout = StringIO()\r
+ sys.stderr = StringIO()\r
+ try:\r
+ try:\r
+ result = parse_args(*args, **kwargs)\r
+ for key in list(vars(result)):\r
+ if getattr(result, key) is sys.stdout:\r
+ setattr(result, key, old_stdout)\r
+ if getattr(result, key) is sys.stderr:\r
+ setattr(result, key, old_stderr)\r
+ return result\r
+ except SystemExit:\r
+ code = sys.exc_info()[1].code\r
+ stdout = sys.stdout.getvalue()\r
+ stderr = sys.stderr.getvalue()\r
+ raise ArgumentParserError("SystemExit", stdout, stderr, code)\r
+ finally:\r
+ sys.stdout = old_stdout\r
+ sys.stderr = old_stderr\r
+\r
+\r
+class ErrorRaisingArgumentParser(argparse.ArgumentParser):\r
+\r
+ def parse_args(self, *args, **kwargs):\r
+ parse_args = super(ErrorRaisingArgumentParser, self).parse_args\r
+ return stderr_to_parser_error(parse_args, *args, **kwargs)\r
+\r
+ def exit(self, *args, **kwargs):\r
+ exit = super(ErrorRaisingArgumentParser, self).exit\r
+ return stderr_to_parser_error(exit, *args, **kwargs)\r
+\r
+ def error(self, *args, **kwargs):\r
+ error = super(ErrorRaisingArgumentParser, self).error\r
+ return stderr_to_parser_error(error, *args, **kwargs)\r
+\r
+\r
+class ParserTesterMetaclass(type):\r
+ """Adds parser tests using the class attributes.\r
+\r
+ Classes of this type should specify the following attributes:\r
+\r
+ argument_signatures -- a list of Sig objects which specify\r
+ the signatures of Argument objects to be created\r
+ failures -- a list of args lists that should cause the parser\r
+ to fail\r
+ successes -- a list of (initial_args, options, remaining_args) tuples\r
+ where initial_args specifies the string args to be parsed,\r
+ options is a dict that should match the vars() of the options\r
+ parsed out of initial_args, and remaining_args should be any\r
+ remaining unparsed arguments\r
+ """\r
+\r
+ def __init__(cls, name, bases, bodydict):\r
+ if name == 'ParserTestCase':\r
+ return\r
+\r
+ # default parser signature is empty\r
+ if not hasattr(cls, 'parser_signature'):\r
+ cls.parser_signature = Sig()\r
+ if not hasattr(cls, 'parser_class'):\r
+ cls.parser_class = ErrorRaisingArgumentParser\r
+\r
+ # ---------------------------------------\r
+ # functions for adding optional arguments\r
+ # ---------------------------------------\r
+ def no_groups(parser, argument_signatures):\r
+ """Add all arguments directly to the parser"""\r
+ for sig in argument_signatures:\r
+ parser.add_argument(*sig.args, **sig.kwargs)\r
+\r
+ def one_group(parser, argument_signatures):\r
+ """Add all arguments under a single group in the parser"""\r
+ group = parser.add_argument_group('foo')\r
+ for sig in argument_signatures:\r
+ group.add_argument(*sig.args, **sig.kwargs)\r
+\r
+ def many_groups(parser, argument_signatures):\r
+ """Add each argument in its own group to the parser"""\r
+ for i, sig in enumerate(argument_signatures):\r
+ group = parser.add_argument_group('foo:%i' % i)\r
+ group.add_argument(*sig.args, **sig.kwargs)\r
+\r
+ # --------------------------\r
+ # functions for parsing args\r
+ # --------------------------\r
+ def listargs(parser, args):\r
+ """Parse the args by passing in a list"""\r
+ return parser.parse_args(args)\r
+\r
+ def sysargs(parser, args):\r
+ """Parse the args by defaulting to sys.argv"""\r
+ old_sys_argv = sys.argv\r
+ sys.argv = [old_sys_argv[0]] + args\r
+ try:\r
+ return parser.parse_args()\r
+ finally:\r
+ sys.argv = old_sys_argv\r
+\r
+ # class that holds the combination of one optional argument\r
+ # addition method and one arg parsing method\r
+ class AddTests(object):\r
+\r
+ def __init__(self, tester_cls, add_arguments, parse_args):\r
+ self._add_arguments = add_arguments\r
+ self._parse_args = parse_args\r
+\r
+ add_arguments_name = self._add_arguments.__name__\r
+ parse_args_name = self._parse_args.__name__\r
+ for test_func in [self.test_failures, self.test_successes]:\r
+ func_name = test_func.__name__\r
+ names = func_name, add_arguments_name, parse_args_name\r
+ test_name = '_'.join(names)\r
+\r
+ def wrapper(self, test_func=test_func):\r
+ test_func(self)\r
+ try:\r
+ wrapper.__name__ = test_name\r
+ except TypeError:\r
+ pass\r
+ setattr(tester_cls, test_name, wrapper)\r
+\r
+ def _get_parser(self, tester):\r
+ args = tester.parser_signature.args\r
+ kwargs = tester.parser_signature.kwargs\r
+ parser = tester.parser_class(*args, **kwargs)\r
+ self._add_arguments(parser, tester.argument_signatures)\r
+ return parser\r
+\r
+ def test_failures(self, tester):\r
+ parser = self._get_parser(tester)\r
+ for args_str in tester.failures:\r
+ args = args_str.split()\r
+ raises = tester.assertRaises\r
+ raises(ArgumentParserError, parser.parse_args, args)\r
+\r
+ def test_successes(self, tester):\r
+ parser = self._get_parser(tester)\r
+ for args, expected_ns in tester.successes:\r
+ if isinstance(args, str):\r
+ args = args.split()\r
+ result_ns = self._parse_args(parser, args)\r
+ tester.assertEqual(expected_ns, result_ns)\r
+\r
+ # add tests for each combination of an optionals adding method\r
+ # and an arg parsing method\r
+ for add_arguments in [no_groups, one_group, many_groups]:\r
+ for parse_args in [listargs, sysargs]:\r
+ AddTests(cls, add_arguments, parse_args)\r
+\r
+bases = TestCase,\r
+ParserTestCase = ParserTesterMetaclass('ParserTestCase', bases, {})\r
+\r
+# ===============\r
+# Optionals tests\r
+# ===============\r
+\r
+class TestOptionalsSingleDash(ParserTestCase):\r
+ """Test an Optional with a single-dash option string"""\r
+\r
+ argument_signatures = [Sig('-x')]\r
+ failures = ['-x', 'a', '--foo', '-x --foo', '-x -y']\r
+ successes = [\r
+ ('', NS(x=None)),\r
+ ('-x a', NS(x='a')),\r
+ ('-xa', NS(x='a')),\r
+ ('-x -1', NS(x='-1')),\r
+ ('-x-1', NS(x='-1')),\r
+ ]\r
+\r
+\r
+class TestOptionalsSingleDashCombined(ParserTestCase):\r
+ """Test an Optional with a single-dash option string"""\r
+\r
+ argument_signatures = [\r
+ Sig('-x', action='store_true'),\r
+ Sig('-yyy', action='store_const', const=42),\r
+ Sig('-z'),\r
+ ]\r
+ failures = ['a', '--foo', '-xa', '-x --foo', '-x -z', '-z -x',\r
+ '-yx', '-yz a', '-yyyx', '-yyyza', '-xyza']\r
+ successes = [\r
+ ('', NS(x=False, yyy=None, z=None)),\r
+ ('-x', NS(x=True, yyy=None, z=None)),\r
+ ('-za', NS(x=False, yyy=None, z='a')),\r
+ ('-z a', NS(x=False, yyy=None, z='a')),\r
+ ('-xza', NS(x=True, yyy=None, z='a')),\r
+ ('-xz a', NS(x=True, yyy=None, z='a')),\r
+ ('-x -za', NS(x=True, yyy=None, z='a')),\r
+ ('-x -z a', NS(x=True, yyy=None, z='a')),\r
+ ('-y', NS(x=False, yyy=42, z=None)),\r
+ ('-yyy', NS(x=False, yyy=42, z=None)),\r
+ ('-x -yyy -za', NS(x=True, yyy=42, z='a')),\r
+ ('-x -yyy -z a', NS(x=True, yyy=42, z='a')),\r
+ ]\r
+\r
+\r
+class TestOptionalsSingleDashLong(ParserTestCase):\r
+ """Test an Optional with a multi-character single-dash option string"""\r
+\r
+ argument_signatures = [Sig('-foo')]\r
+ failures = ['-foo', 'a', '--foo', '-foo --foo', '-foo -y', '-fooa']\r
+ successes = [\r
+ ('', NS(foo=None)),\r
+ ('-foo a', NS(foo='a')),\r
+ ('-foo -1', NS(foo='-1')),\r
+ ('-fo a', NS(foo='a')),\r
+ ('-f a', NS(foo='a')),\r
+ ]\r
+\r
+\r
+class TestOptionalsSingleDashSubsetAmbiguous(ParserTestCase):\r
+ """Test Optionals where option strings are subsets of each other"""\r
+\r
+ argument_signatures = [Sig('-f'), Sig('-foobar'), Sig('-foorab')]\r
+ failures = ['-f', '-foo', '-fo', '-foo b', '-foob', '-fooba', '-foora']\r
+ successes = [\r
+ ('', NS(f=None, foobar=None, foorab=None)),\r
+ ('-f a', NS(f='a', foobar=None, foorab=None)),\r
+ ('-fa', NS(f='a', foobar=None, foorab=None)),\r
+ ('-foa', NS(f='oa', foobar=None, foorab=None)),\r
+ ('-fooa', NS(f='ooa', foobar=None, foorab=None)),\r
+ ('-foobar a', NS(f=None, foobar='a', foorab=None)),\r
+ ('-foorab a', NS(f=None, foobar=None, foorab='a')),\r
+ ]\r
+\r
+\r
+class TestOptionalsSingleDashAmbiguous(ParserTestCase):\r
+ """Test Optionals that partially match but are not subsets"""\r
+\r
+ argument_signatures = [Sig('-foobar'), Sig('-foorab')]\r
+ failures = ['-f', '-f a', '-fa', '-foa', '-foo', '-fo', '-foo b']\r
+ successes = [\r
+ ('', NS(foobar=None, foorab=None)),\r
+ ('-foob a', NS(foobar='a', foorab=None)),\r
+ ('-foor a', NS(foobar=None, foorab='a')),\r
+ ('-fooba a', NS(foobar='a', foorab=None)),\r
+ ('-foora a', NS(foobar=None, foorab='a')),\r
+ ('-foobar a', NS(foobar='a', foorab=None)),\r
+ ('-foorab a', NS(foobar=None, foorab='a')),\r
+ ]\r
+\r
+\r
+class TestOptionalsNumeric(ParserTestCase):\r
+ """Test an Optional with a short opt string"""\r
+\r
+ argument_signatures = [Sig('-1', dest='one')]\r
+ failures = ['-1', 'a', '-1 --foo', '-1 -y', '-1 -1', '-1 -2']\r
+ successes = [\r
+ ('', NS(one=None)),\r
+ ('-1 a', NS(one='a')),\r
+ ('-1a', NS(one='a')),\r
+ ('-1-2', NS(one='-2')),\r
+ ]\r
+\r
+\r
+class TestOptionalsDoubleDash(ParserTestCase):\r
+ """Test an Optional with a double-dash option string"""\r
+\r
+ argument_signatures = [Sig('--foo')]\r
+ failures = ['--foo', '-f', '-f a', 'a', '--foo -x', '--foo --bar']\r
+ successes = [\r
+ ('', NS(foo=None)),\r
+ ('--foo a', NS(foo='a')),\r
+ ('--foo=a', NS(foo='a')),\r
+ ('--foo -2.5', NS(foo='-2.5')),\r
+ ('--foo=-2.5', NS(foo='-2.5')),\r
+ ]\r
+\r
+\r
+class TestOptionalsDoubleDashPartialMatch(ParserTestCase):\r
+ """Tests partial matching with a double-dash option string"""\r
+\r
+ argument_signatures = [\r
+ Sig('--badger', action='store_true'),\r
+ Sig('--bat'),\r
+ ]\r
+ failures = ['--bar', '--b', '--ba', '--b=2', '--ba=4', '--badge 5']\r
+ successes = [\r
+ ('', NS(badger=False, bat=None)),\r
+ ('--bat X', NS(badger=False, bat='X')),\r
+ ('--bad', NS(badger=True, bat=None)),\r
+ ('--badg', NS(badger=True, bat=None)),\r
+ ('--badge', NS(badger=True, bat=None)),\r
+ ('--badger', NS(badger=True, bat=None)),\r
+ ]\r
+\r
+\r
+class TestOptionalsDoubleDashPrefixMatch(ParserTestCase):\r
+ """Tests when one double-dash option string is a prefix of another"""\r
+\r
+ argument_signatures = [\r
+ Sig('--badger', action='store_true'),\r
+ Sig('--ba'),\r
+ ]\r
+ failures = ['--bar', '--b', '--ba', '--b=2', '--badge 5']\r
+ successes = [\r
+ ('', NS(badger=False, ba=None)),\r
+ ('--ba X', NS(badger=False, ba='X')),\r
+ ('--ba=X', NS(badger=False, ba='X')),\r
+ ('--bad', NS(badger=True, ba=None)),\r
+ ('--badg', NS(badger=True, ba=None)),\r
+ ('--badge', NS(badger=True, ba=None)),\r
+ ('--badger', NS(badger=True, ba=None)),\r
+ ]\r
+\r
+\r
+class TestOptionalsSingleDoubleDash(ParserTestCase):\r
+ """Test an Optional with single- and double-dash option strings"""\r
+\r
+ argument_signatures = [\r
+ Sig('-f', action='store_true'),\r
+ Sig('--bar'),\r
+ Sig('-baz', action='store_const', const=42),\r
+ ]\r
+ failures = ['--bar', '-fbar', '-fbaz', '-bazf', '-b B', 'B']\r
+ successes = [\r
+ ('', NS(f=False, bar=None, baz=None)),\r
+ ('-f', NS(f=True, bar=None, baz=None)),\r
+ ('--ba B', NS(f=False, bar='B', baz=None)),\r
+ ('-f --bar B', NS(f=True, bar='B', baz=None)),\r
+ ('-f -b', NS(f=True, bar=None, baz=42)),\r
+ ('-ba -f', NS(f=True, bar=None, baz=42)),\r
+ ]\r
+\r
+\r
+class TestOptionalsAlternatePrefixChars(ParserTestCase):\r
+ """Test an Optional with a double-dash option string"""\r
+\r
+ parser_signature = Sig(prefix_chars='+:/', add_help=False)\r
+ argument_signatures = [\r
+ Sig('+f', action='store_true'),\r
+ Sig('::bar'),\r
+ Sig('/baz', action='store_const', const=42),\r
+ ]\r
+ failures = ['--bar', '-fbar', '-b B', 'B', '-f', '--bar B', '-baz']\r
+ successes = [\r
+ ('', NS(f=False, bar=None, baz=None)),\r
+ ('+f', NS(f=True, bar=None, baz=None)),\r
+ ('::ba B', NS(f=False, bar='B', baz=None)),\r
+ ('+f ::bar B', NS(f=True, bar='B', baz=None)),\r
+ ('+f /b', NS(f=True, bar=None, baz=42)),\r
+ ('/ba +f', NS(f=True, bar=None, baz=42)),\r
+ ]\r
+\r
+\r
+class TestOptionalsShortLong(ParserTestCase):\r
+ """Test a combination of single- and double-dash option strings"""\r
+\r
+ argument_signatures = [\r
+ Sig('-v', '--verbose', '-n', '--noisy', action='store_true'),\r
+ ]\r
+ failures = ['--x --verbose', '-N', 'a', '-v x']\r
+ successes = [\r
+ ('', NS(verbose=False)),\r
+ ('-v', NS(verbose=True)),\r
+ ('--verbose', NS(verbose=True)),\r
+ ('-n', NS(verbose=True)),\r
+ ('--noisy', NS(verbose=True)),\r
+ ]\r
+\r
+\r
+class TestOptionalsDest(ParserTestCase):\r
+ """Tests various means of setting destination"""\r
+\r
+ argument_signatures = [Sig('--foo-bar'), Sig('--baz', dest='zabbaz')]\r
+ failures = ['a']\r
+ successes = [\r
+ ('--foo-bar f', NS(foo_bar='f', zabbaz=None)),\r
+ ('--baz g', NS(foo_bar=None, zabbaz='g')),\r
+ ('--foo-bar h --baz i', NS(foo_bar='h', zabbaz='i')),\r
+ ('--baz j --foo-bar k', NS(foo_bar='k', zabbaz='j')),\r
+ ]\r
+\r
+\r
+class TestOptionalsDefault(ParserTestCase):\r
+ """Tests specifying a default for an Optional"""\r
+\r
+ argument_signatures = [Sig('-x'), Sig('-y', default=42)]\r
+ failures = ['a']\r
+ successes = [\r
+ ('', NS(x=None, y=42)),\r
+ ('-xx', NS(x='x', y=42)),\r
+ ('-yy', NS(x=None, y='y')),\r
+ ]\r
+\r
+\r
+class TestOptionalsNargsDefault(ParserTestCase):\r
+ """Tests not specifying the number of args for an Optional"""\r
+\r
+ argument_signatures = [Sig('-x')]\r
+ failures = ['a', '-x']\r
+ successes = [\r
+ ('', NS(x=None)),\r
+ ('-x a', NS(x='a')),\r
+ ]\r
+\r
+\r
+class TestOptionalsNargs1(ParserTestCase):\r
+ """Tests specifying the 1 arg for an Optional"""\r
+\r
+ argument_signatures = [Sig('-x', nargs=1)]\r
+ failures = ['a', '-x']\r
+ successes = [\r
+ ('', NS(x=None)),\r
+ ('-x a', NS(x=['a'])),\r
+ ]\r
+\r
+\r
+class TestOptionalsNargs3(ParserTestCase):\r
+ """Tests specifying the 3 args for an Optional"""\r
+\r
+ argument_signatures = [Sig('-x', nargs=3)]\r
+ failures = ['a', '-x', '-x a', '-x a b', 'a -x', 'a -x b']\r
+ successes = [\r
+ ('', NS(x=None)),\r
+ ('-x a b c', NS(x=['a', 'b', 'c'])),\r
+ ]\r
+\r
+\r
+class TestOptionalsNargsOptional(ParserTestCase):\r
+ """Tests specifying an Optional arg for an Optional"""\r
+\r
+ argument_signatures = [\r
+ Sig('-w', nargs='?'),\r
+ Sig('-x', nargs='?', const=42),\r
+ Sig('-y', nargs='?', default='spam'),\r
+ Sig('-z', nargs='?', type=int, const='42', default='84'),\r
+ ]\r
+ failures = ['2']\r
+ successes = [\r
+ ('', NS(w=None, x=None, y='spam', z=84)),\r
+ ('-w', NS(w=None, x=None, y='spam', z=84)),\r
+ ('-w 2', NS(w='2', x=None, y='spam', z=84)),\r
+ ('-x', NS(w=None, x=42, y='spam', z=84)),\r
+ ('-x 2', NS(w=None, x='2', y='spam', z=84)),\r
+ ('-y', NS(w=None, x=None, y=None, z=84)),\r
+ ('-y 2', NS(w=None, x=None, y='2', z=84)),\r
+ ('-z', NS(w=None, x=None, y='spam', z=42)),\r
+ ('-z 2', NS(w=None, x=None, y='spam', z=2)),\r
+ ]\r
+\r
+\r
+class TestOptionalsNargsZeroOrMore(ParserTestCase):\r
+ """Tests specifying an args for an Optional that accepts zero or more"""\r
+\r
+ argument_signatures = [\r
+ Sig('-x', nargs='*'),\r
+ Sig('-y', nargs='*', default='spam'),\r
+ ]\r
+ failures = ['a']\r
+ successes = [\r
+ ('', NS(x=None, y='spam')),\r
+ ('-x', NS(x=[], y='spam')),\r
+ ('-x a', NS(x=['a'], y='spam')),\r
+ ('-x a b', NS(x=['a', 'b'], y='spam')),\r
+ ('-y', NS(x=None, y=[])),\r
+ ('-y a', NS(x=None, y=['a'])),\r
+ ('-y a b', NS(x=None, y=['a', 'b'])),\r
+ ]\r
+\r
+\r
+class TestOptionalsNargsOneOrMore(ParserTestCase):\r
+ """Tests specifying an args for an Optional that accepts one or more"""\r
+\r
+ argument_signatures = [\r
+ Sig('-x', nargs='+'),\r
+ Sig('-y', nargs='+', default='spam'),\r
+ ]\r
+ failures = ['a', '-x', '-y', 'a -x', 'a -y b']\r
+ successes = [\r
+ ('', NS(x=None, y='spam')),\r
+ ('-x a', NS(x=['a'], y='spam')),\r
+ ('-x a b', NS(x=['a', 'b'], y='spam')),\r
+ ('-y a', NS(x=None, y=['a'])),\r
+ ('-y a b', NS(x=None, y=['a', 'b'])),\r
+ ]\r
+\r
+\r
+class TestOptionalsChoices(ParserTestCase):\r
+ """Tests specifying the choices for an Optional"""\r
+\r
+ argument_signatures = [\r
+ Sig('-f', choices='abc'),\r
+ Sig('-g', type=int, choices=range(5))]\r
+ failures = ['a', '-f d', '-fad', '-ga', '-g 6']\r
+ successes = [\r
+ ('', NS(f=None, g=None)),\r
+ ('-f a', NS(f='a', g=None)),\r
+ ('-f c', NS(f='c', g=None)),\r
+ ('-g 0', NS(f=None, g=0)),\r
+ ('-g 03', NS(f=None, g=3)),\r
+ ('-fb -g4', NS(f='b', g=4)),\r
+ ]\r
+\r
+\r
+class TestOptionalsRequired(ParserTestCase):\r
+ """Tests the an optional action that is required"""\r
+\r
+ argument_signatures = [\r
+ Sig('-x', type=int, required=True),\r
+ ]\r
+ failures = ['a', '']\r
+ successes = [\r
+ ('-x 1', NS(x=1)),\r
+ ('-x42', NS(x=42)),\r
+ ]\r
+\r
+\r
+class TestOptionalsActionStore(ParserTestCase):\r
+ """Tests the store action for an Optional"""\r
+\r
+ argument_signatures = [Sig('-x', action='store')]\r
+ failures = ['a', 'a -x']\r
+ successes = [\r
+ ('', NS(x=None)),\r
+ ('-xfoo', NS(x='foo')),\r
+ ]\r
+\r
+\r
+class TestOptionalsActionStoreConst(ParserTestCase):\r
+ """Tests the store_const action for an Optional"""\r
+\r
+ argument_signatures = [Sig('-y', action='store_const', const=object)]\r
+ failures = ['a']\r
+ successes = [\r
+ ('', NS(y=None)),\r
+ ('-y', NS(y=object)),\r
+ ]\r
+\r
+\r
+class TestOptionalsActionStoreFalse(ParserTestCase):\r
+ """Tests the store_false action for an Optional"""\r
+\r
+ argument_signatures = [Sig('-z', action='store_false')]\r
+ failures = ['a', '-za', '-z a']\r
+ successes = [\r
+ ('', NS(z=True)),\r
+ ('-z', NS(z=False)),\r
+ ]\r
+\r
+\r
+class TestOptionalsActionStoreTrue(ParserTestCase):\r
+ """Tests the store_true action for an Optional"""\r
+\r
+ argument_signatures = [Sig('--apple', action='store_true')]\r
+ failures = ['a', '--apple=b', '--apple b']\r
+ successes = [\r
+ ('', NS(apple=False)),\r
+ ('--apple', NS(apple=True)),\r
+ ]\r
+\r
+\r
+class TestOptionalsActionAppend(ParserTestCase):\r
+ """Tests the append action for an Optional"""\r
+\r
+ argument_signatures = [Sig('--baz', action='append')]\r
+ failures = ['a', '--baz', 'a --baz', '--baz a b']\r
+ successes = [\r
+ ('', NS(baz=None)),\r
+ ('--baz a', NS(baz=['a'])),\r
+ ('--baz a --baz b', NS(baz=['a', 'b'])),\r
+ ]\r
+\r
+\r
+class TestOptionalsActionAppendWithDefault(ParserTestCase):\r
+ """Tests the append action for an Optional"""\r
+\r
+ argument_signatures = [Sig('--baz', action='append', default=['X'])]\r
+ failures = ['a', '--baz', 'a --baz', '--baz a b']\r
+ successes = [\r
+ ('', NS(baz=['X'])),\r
+ ('--baz a', NS(baz=['X', 'a'])),\r
+ ('--baz a --baz b', NS(baz=['X', 'a', 'b'])),\r
+ ]\r
+\r
+\r
+class TestOptionalsActionAppendConst(ParserTestCase):\r
+ """Tests the append_const action for an Optional"""\r
+\r
+ argument_signatures = [\r
+ Sig('-b', action='append_const', const=Exception),\r
+ Sig('-c', action='append', dest='b'),\r
+ ]\r
+ failures = ['a', '-c', 'a -c', '-bx', '-b x']\r
+ successes = [\r
+ ('', NS(b=None)),\r
+ ('-b', NS(b=[Exception])),\r
+ ('-b -cx -b -cyz', NS(b=[Exception, 'x', Exception, 'yz'])),\r
+ ]\r
+\r
+\r
+class TestOptionalsActionAppendConstWithDefault(ParserTestCase):\r
+ """Tests the append_const action for an Optional"""\r
+\r
+ argument_signatures = [\r
+ Sig('-b', action='append_const', const=Exception, default=['X']),\r
+ Sig('-c', action='append', dest='b'),\r
+ ]\r
+ failures = ['a', '-c', 'a -c', '-bx', '-b x']\r
+ successes = [\r
+ ('', NS(b=['X'])),\r
+ ('-b', NS(b=['X', Exception])),\r
+ ('-b -cx -b -cyz', NS(b=['X', Exception, 'x', Exception, 'yz'])),\r
+ ]\r
+\r
+\r
+class TestOptionalsActionCount(ParserTestCase):\r
+ """Tests the count action for an Optional"""\r
+\r
+ argument_signatures = [Sig('-x', action='count')]\r
+ failures = ['a', '-x a', '-x b', '-x a -x b']\r
+ successes = [\r
+ ('', NS(x=None)),\r
+ ('-x', NS(x=1)),\r
+ ]\r
+\r
+\r
+# ================\r
+# Positional tests\r
+# ================\r
+\r
+class TestPositionalsNargsNone(ParserTestCase):\r
+ """Test a Positional that doesn't specify nargs"""\r
+\r
+ argument_signatures = [Sig('foo')]\r
+ failures = ['', '-x', 'a b']\r
+ successes = [\r
+ ('a', NS(foo='a')),\r
+ ]\r
+\r
+\r
+class TestPositionalsNargs1(ParserTestCase):\r
+ """Test a Positional that specifies an nargs of 1"""\r
+\r
+ argument_signatures = [Sig('foo', nargs=1)]\r
+ failures = ['', '-x', 'a b']\r
+ successes = [\r
+ ('a', NS(foo=['a'])),\r
+ ]\r
+\r
+\r
+class TestPositionalsNargs2(ParserTestCase):\r
+ """Test a Positional that specifies an nargs of 2"""\r
+\r
+ argument_signatures = [Sig('foo', nargs=2)]\r
+ failures = ['', 'a', '-x', 'a b c']\r
+ successes = [\r
+ ('a b', NS(foo=['a', 'b'])),\r
+ ]\r
+\r
+\r
+class TestPositionalsNargsZeroOrMore(ParserTestCase):\r
+ """Test a Positional that specifies unlimited nargs"""\r
+\r
+ argument_signatures = [Sig('foo', nargs='*')]\r
+ failures = ['-x']\r
+ successes = [\r
+ ('', NS(foo=[])),\r
+ ('a', NS(foo=['a'])),\r
+ ('a b', NS(foo=['a', 'b'])),\r
+ ]\r
+\r
+\r
+class TestPositionalsNargsZeroOrMoreDefault(ParserTestCase):\r
+ """Test a Positional that specifies unlimited nargs and a default"""\r
+\r
+ argument_signatures = [Sig('foo', nargs='*', default='bar')]\r
+ failures = ['-x']\r
+ successes = [\r
+ ('', NS(foo='bar')),\r
+ ('a', NS(foo=['a'])),\r
+ ('a b', NS(foo=['a', 'b'])),\r
+ ]\r
+\r
+\r
+class TestPositionalsNargsOneOrMore(ParserTestCase):\r
+ """Test a Positional that specifies one or more nargs"""\r
+\r
+ argument_signatures = [Sig('foo', nargs='+')]\r
+ failures = ['', '-x']\r
+ successes = [\r
+ ('a', NS(foo=['a'])),\r
+ ('a b', NS(foo=['a', 'b'])),\r
+ ]\r
+\r
+\r
+class TestPositionalsNargsOptional(ParserTestCase):\r
+ """Tests an Optional Positional"""\r
+\r
+ argument_signatures = [Sig('foo', nargs='?')]\r
+ failures = ['-x', 'a b']\r
+ successes = [\r
+ ('', NS(foo=None)),\r
+ ('a', NS(foo='a')),\r
+ ]\r
+\r
+\r
+class TestPositionalsNargsOptionalDefault(ParserTestCase):\r
+ """Tests an Optional Positional with a default value"""\r
+\r
+ argument_signatures = [Sig('foo', nargs='?', default=42)]\r
+ failures = ['-x', 'a b']\r
+ successes = [\r
+ ('', NS(foo=42)),\r
+ ('a', NS(foo='a')),\r
+ ]\r
+\r
+\r
+class TestPositionalsNargsOptionalConvertedDefault(ParserTestCase):\r
+ """Tests an Optional Positional with a default value\r
+ that needs to be converted to the appropriate type.\r
+ """\r
+\r
+ argument_signatures = [\r
+ Sig('foo', nargs='?', type=int, default='42'),\r
+ ]\r
+ failures = ['-x', 'a b', '1 2']\r
+ successes = [\r
+ ('', NS(foo=42)),\r
+ ('1', NS(foo=1)),\r
+ ]\r
+\r
+\r
+class TestPositionalsNargsNoneNone(ParserTestCase):\r
+ """Test two Positionals that don't specify nargs"""\r
+\r
+ argument_signatures = [Sig('foo'), Sig('bar')]\r
+ failures = ['', '-x', 'a', 'a b c']\r
+ successes = [\r
+ ('a b', NS(foo='a', bar='b')),\r
+ ]\r
+\r
+\r
+class TestPositionalsNargsNone1(ParserTestCase):\r
+ """Test a Positional with no nargs followed by one with 1"""\r
+\r
+ argument_signatures = [Sig('foo'), Sig('bar', nargs=1)]\r
+ failures = ['', '--foo', 'a', 'a b c']\r
+ successes = [\r
+ ('a b', NS(foo='a', bar=['b'])),\r
+ ]\r
+\r
+\r
+class TestPositionalsNargs2None(ParserTestCase):\r
+ """Test a Positional with 2 nargs followed by one with none"""\r
+\r
+ argument_signatures = [Sig('foo', nargs=2), Sig('bar')]\r
+ failures = ['', '--foo', 'a', 'a b', 'a b c d']\r
+ successes = [\r
+ ('a b c', NS(foo=['a', 'b'], bar='c')),\r
+ ]\r
+\r
+\r
+class TestPositionalsNargsNoneZeroOrMore(ParserTestCase):\r
+ """Test a Positional with no nargs followed by one with unlimited"""\r
+\r
+ argument_signatures = [Sig('foo'), Sig('bar', nargs='*')]\r
+ failures = ['', '--foo']\r
+ successes = [\r
+ ('a', NS(foo='a', bar=[])),\r
+ ('a b', NS(foo='a', bar=['b'])),\r
+ ('a b c', NS(foo='a', bar=['b', 'c'])),\r
+ ]\r
+\r
+\r
+class TestPositionalsNargsNoneOneOrMore(ParserTestCase):\r
+ """Test a Positional with no nargs followed by one with one or more"""\r
+\r
+ argument_signatures = [Sig('foo'), Sig('bar', nargs='+')]\r
+ failures = ['', '--foo', 'a']\r
+ successes = [\r
+ ('a b', NS(foo='a', bar=['b'])),\r
+ ('a b c', NS(foo='a', bar=['b', 'c'])),\r
+ ]\r
+\r
+\r
+class TestPositionalsNargsNoneOptional(ParserTestCase):\r
+ """Test a Positional with no nargs followed by one with an Optional"""\r
+\r
+ argument_signatures = [Sig('foo'), Sig('bar', nargs='?')]\r
+ failures = ['', '--foo', 'a b c']\r
+ successes = [\r
+ ('a', NS(foo='a', bar=None)),\r
+ ('a b', NS(foo='a', bar='b')),\r
+ ]\r
+\r
+\r
+class TestPositionalsNargsZeroOrMoreNone(ParserTestCase):\r
+ """Test a Positional with unlimited nargs followed by one with none"""\r
+\r
+ argument_signatures = [Sig('foo', nargs='*'), Sig('bar')]\r
+ failures = ['', '--foo']\r
+ successes = [\r
+ ('a', NS(foo=[], bar='a')),\r
+ ('a b', NS(foo=['a'], bar='b')),\r
+ ('a b c', NS(foo=['a', 'b'], bar='c')),\r
+ ]\r
+\r
+\r
+class TestPositionalsNargsOneOrMoreNone(ParserTestCase):\r
+ """Test a Positional with one or more nargs followed by one with none"""\r
+\r
+ argument_signatures = [Sig('foo', nargs='+'), Sig('bar')]\r
+ failures = ['', '--foo', 'a']\r
+ successes = [\r
+ ('a b', NS(foo=['a'], bar='b')),\r
+ ('a b c', NS(foo=['a', 'b'], bar='c')),\r
+ ]\r
+\r
+\r
+class TestPositionalsNargsOptionalNone(ParserTestCase):\r
+ """Test a Positional with an Optional nargs followed by one with none"""\r
+\r
+ argument_signatures = [Sig('foo', nargs='?', default=42), Sig('bar')]\r
+ failures = ['', '--foo', 'a b c']\r
+ successes = [\r
+ ('a', NS(foo=42, bar='a')),\r
+ ('a b', NS(foo='a', bar='b')),\r
+ ]\r
+\r
+\r
+class TestPositionalsNargs2ZeroOrMore(ParserTestCase):\r
+ """Test a Positional with 2 nargs followed by one with unlimited"""\r
+\r
+ argument_signatures = [Sig('foo', nargs=2), Sig('bar', nargs='*')]\r
+ failures = ['', '--foo', 'a']\r
+ successes = [\r
+ ('a b', NS(foo=['a', 'b'], bar=[])),\r
+ ('a b c', NS(foo=['a', 'b'], bar=['c'])),\r
+ ]\r
+\r
+\r
+class TestPositionalsNargs2OneOrMore(ParserTestCase):\r
+ """Test a Positional with 2 nargs followed by one with one or more"""\r
+\r
+ argument_signatures = [Sig('foo', nargs=2), Sig('bar', nargs='+')]\r
+ failures = ['', '--foo', 'a', 'a b']\r
+ successes = [\r
+ ('a b c', NS(foo=['a', 'b'], bar=['c'])),\r
+ ]\r
+\r
+\r
+class TestPositionalsNargs2Optional(ParserTestCase):\r
+ """Test a Positional with 2 nargs followed by one optional"""\r
+\r
+ argument_signatures = [Sig('foo', nargs=2), Sig('bar', nargs='?')]\r
+ failures = ['', '--foo', 'a', 'a b c d']\r
+ successes = [\r
+ ('a b', NS(foo=['a', 'b'], bar=None)),\r
+ ('a b c', NS(foo=['a', 'b'], bar='c')),\r
+ ]\r
+\r
+\r
+class TestPositionalsNargsZeroOrMore1(ParserTestCase):\r
+ """Test a Positional with unlimited nargs followed by one with 1"""\r
+\r
+ argument_signatures = [Sig('foo', nargs='*'), Sig('bar', nargs=1)]\r
+ failures = ['', '--foo', ]\r
+ successes = [\r
+ ('a', NS(foo=[], bar=['a'])),\r
+ ('a b', NS(foo=['a'], bar=['b'])),\r
+ ('a b c', NS(foo=['a', 'b'], bar=['c'])),\r
+ ]\r
+\r
+\r
+class TestPositionalsNargsOneOrMore1(ParserTestCase):\r
+ """Test a Positional with one or more nargs followed by one with 1"""\r
+\r
+ argument_signatures = [Sig('foo', nargs='+'), Sig('bar', nargs=1)]\r
+ failures = ['', '--foo', 'a']\r
+ successes = [\r
+ ('a b', NS(foo=['a'], bar=['b'])),\r
+ ('a b c', NS(foo=['a', 'b'], bar=['c'])),\r
+ ]\r
+\r
+\r
+class TestPositionalsNargsOptional1(ParserTestCase):\r
+ """Test a Positional with an Optional nargs followed by one with 1"""\r
+\r
+ argument_signatures = [Sig('foo', nargs='?'), Sig('bar', nargs=1)]\r
+ failures = ['', '--foo', 'a b c']\r
+ successes = [\r
+ ('a', NS(foo=None, bar=['a'])),\r
+ ('a b', NS(foo='a', bar=['b'])),\r
+ ]\r
+\r
+\r
+class TestPositionalsNargsNoneZeroOrMore1(ParserTestCase):\r
+ """Test three Positionals: no nargs, unlimited nargs and 1 nargs"""\r
+\r
+ argument_signatures = [\r
+ Sig('foo'),\r
+ Sig('bar', nargs='*'),\r
+ Sig('baz', nargs=1),\r
+ ]\r
+ failures = ['', '--foo', 'a']\r
+ successes = [\r
+ ('a b', NS(foo='a', bar=[], baz=['b'])),\r
+ ('a b c', NS(foo='a', bar=['b'], baz=['c'])),\r
+ ]\r
+\r
+\r
+class TestPositionalsNargsNoneOneOrMore1(ParserTestCase):\r
+ """Test three Positionals: no nargs, one or more nargs and 1 nargs"""\r
+\r
+ argument_signatures = [\r
+ Sig('foo'),\r
+ Sig('bar', nargs='+'),\r
+ Sig('baz', nargs=1),\r
+ ]\r
+ failures = ['', '--foo', 'a', 'b']\r
+ successes = [\r
+ ('a b c', NS(foo='a', bar=['b'], baz=['c'])),\r
+ ('a b c d', NS(foo='a', bar=['b', 'c'], baz=['d'])),\r
+ ]\r
+\r
+\r
+class TestPositionalsNargsNoneOptional1(ParserTestCase):\r
+ """Test three Positionals: no nargs, optional narg and 1 nargs"""\r
+\r
+ argument_signatures = [\r
+ Sig('foo'),\r
+ Sig('bar', nargs='?', default=0.625),\r
+ Sig('baz', nargs=1),\r
+ ]\r
+ failures = ['', '--foo', 'a']\r
+ successes = [\r
+ ('a b', NS(foo='a', bar=0.625, baz=['b'])),\r
+ ('a b c', NS(foo='a', bar='b', baz=['c'])),\r
+ ]\r
+\r
+\r
+class TestPositionalsNargsOptionalOptional(ParserTestCase):\r
+ """Test two optional nargs"""\r
+\r
+ argument_signatures = [\r
+ Sig('foo', nargs='?'),\r
+ Sig('bar', nargs='?', default=42),\r
+ ]\r
+ failures = ['--foo', 'a b c']\r
+ successes = [\r
+ ('', NS(foo=None, bar=42)),\r
+ ('a', NS(foo='a', bar=42)),\r
+ ('a b', NS(foo='a', bar='b')),\r
+ ]\r
+\r
+\r
+class TestPositionalsNargsOptionalZeroOrMore(ParserTestCase):\r
+ """Test an Optional narg followed by unlimited nargs"""\r
+\r
+ argument_signatures = [Sig('foo', nargs='?'), Sig('bar', nargs='*')]\r
+ failures = ['--foo']\r
+ successes = [\r
+ ('', NS(foo=None, bar=[])),\r
+ ('a', NS(foo='a', bar=[])),\r
+ ('a b', NS(foo='a', bar=['b'])),\r
+ ('a b c', NS(foo='a', bar=['b', 'c'])),\r
+ ]\r
+\r
+\r
+class TestPositionalsNargsOptionalOneOrMore(ParserTestCase):\r
+ """Test an Optional narg followed by one or more nargs"""\r
+\r
+ argument_signatures = [Sig('foo', nargs='?'), Sig('bar', nargs='+')]\r
+ failures = ['', '--foo']\r
+ successes = [\r
+ ('a', NS(foo=None, bar=['a'])),\r
+ ('a b', NS(foo='a', bar=['b'])),\r
+ ('a b c', NS(foo='a', bar=['b', 'c'])),\r
+ ]\r
+\r
+\r
+class TestPositionalsChoicesString(ParserTestCase):\r
+ """Test a set of single-character choices"""\r
+\r
+ argument_signatures = [Sig('spam', choices=set('abcdefg'))]\r
+ failures = ['', '--foo', 'h', '42', 'ef']\r
+ successes = [\r
+ ('a', NS(spam='a')),\r
+ ('g', NS(spam='g')),\r
+ ]\r
+\r
+\r
+class TestPositionalsChoicesInt(ParserTestCase):\r
+ """Test a set of integer choices"""\r
+\r
+ argument_signatures = [Sig('spam', type=int, choices=range(20))]\r
+ failures = ['', '--foo', 'h', '42', 'ef']\r
+ successes = [\r
+ ('4', NS(spam=4)),\r
+ ('15', NS(spam=15)),\r
+ ]\r
+\r
+\r
+class TestPositionalsActionAppend(ParserTestCase):\r
+ """Test the 'append' action"""\r
+\r
+ argument_signatures = [\r
+ Sig('spam', action='append'),\r
+ Sig('spam', action='append', nargs=2),\r
+ ]\r
+ failures = ['', '--foo', 'a', 'a b', 'a b c d']\r
+ successes = [\r
+ ('a b c', NS(spam=['a', ['b', 'c']])),\r
+ ]\r
+\r
+# ========================================\r
+# Combined optionals and positionals tests\r
+# ========================================\r
+\r
+class TestOptionalsNumericAndPositionals(ParserTestCase):\r
+ """Tests negative number args when numeric options are present"""\r
+\r
+ argument_signatures = [\r
+ Sig('x', nargs='?'),\r
+ Sig('-4', dest='y', action='store_true'),\r
+ ]\r
+ failures = ['-2', '-315']\r
+ successes = [\r
+ ('', NS(x=None, y=False)),\r
+ ('a', NS(x='a', y=False)),\r
+ ('-4', NS(x=None, y=True)),\r
+ ('-4 a', NS(x='a', y=True)),\r
+ ]\r
+\r
+\r
+class TestOptionalsAlmostNumericAndPositionals(ParserTestCase):\r
+ """Tests negative number args when almost numeric options are present"""\r
+\r
+ argument_signatures = [\r
+ Sig('x', nargs='?'),\r
+ Sig('-k4', dest='y', action='store_true'),\r
+ ]\r
+ failures = ['-k3']\r
+ successes = [\r
+ ('', NS(x=None, y=False)),\r
+ ('-2', NS(x='-2', y=False)),\r
+ ('a', NS(x='a', y=False)),\r
+ ('-k4', NS(x=None, y=True)),\r
+ ('-k4 a', NS(x='a', y=True)),\r
+ ]\r
+\r
+\r
+class TestEmptyAndSpaceContainingArguments(ParserTestCase):\r
+\r
+ argument_signatures = [\r
+ Sig('x', nargs='?'),\r
+ Sig('-y', '--yyy', dest='y'),\r
+ ]\r
+ failures = ['-y']\r
+ successes = [\r
+ ([''], NS(x='', y=None)),\r
+ (['a badger'], NS(x='a badger', y=None)),\r
+ (['-a badger'], NS(x='-a badger', y=None)),\r
+ (['-y', ''], NS(x=None, y='')),\r
+ (['-y', 'a badger'], NS(x=None, y='a badger')),\r
+ (['-y', '-a badger'], NS(x=None, y='-a badger')),\r
+ (['--yyy=a badger'], NS(x=None, y='a badger')),\r
+ (['--yyy=-a badger'], NS(x=None, y='-a badger')),\r
+ ]\r
+\r
+\r
+class TestPrefixCharacterOnlyArguments(ParserTestCase):\r
+\r
+ parser_signature = Sig(prefix_chars='-+')\r
+ argument_signatures = [\r
+ Sig('-', dest='x', nargs='?', const='badger'),\r
+ Sig('+', dest='y', type=int, default=42),\r
+ Sig('-+-', dest='z', action='store_true'),\r
+ ]\r
+ failures = ['-y', '+ -']\r
+ successes = [\r
+ ('', NS(x=None, y=42, z=False)),\r
+ ('-', NS(x='badger', y=42, z=False)),\r
+ ('- X', NS(x='X', y=42, z=False)),\r
+ ('+ -3', NS(x=None, y=-3, z=False)),\r
+ ('-+-', NS(x=None, y=42, z=True)),\r
+ ('- ===', NS(x='===', y=42, z=False)),\r
+ ]\r
+\r
+\r
+class TestNargsZeroOrMore(ParserTestCase):\r
+ """Tests specifying an args for an Optional that accepts zero or more"""\r
+\r
+ argument_signatures = [Sig('-x', nargs='*'), Sig('y', nargs='*')]\r
+ failures = []\r
+ successes = [\r
+ ('', NS(x=None, y=[])),\r
+ ('-x', NS(x=[], y=[])),\r
+ ('-x a', NS(x=['a'], y=[])),\r
+ ('-x a -- b', NS(x=['a'], y=['b'])),\r
+ ('a', NS(x=None, y=['a'])),\r
+ ('a -x', NS(x=[], y=['a'])),\r
+ ('a -x b', NS(x=['b'], y=['a'])),\r
+ ]\r
+\r
+\r
+class TestNargsRemainder(ParserTestCase):\r
+ """Tests specifying a positional with nargs=REMAINDER"""\r
+\r
+ argument_signatures = [Sig('x'), Sig('y', nargs='...'), Sig('-z')]\r
+ failures = ['', '-z', '-z Z']\r
+ successes = [\r
+ ('X', NS(x='X', y=[], z=None)),\r
+ ('-z Z X', NS(x='X', y=[], z='Z')),\r
+ ('X A B -z Z', NS(x='X', y=['A', 'B', '-z', 'Z'], z=None)),\r
+ ('X Y --foo', NS(x='X', y=['Y', '--foo'], z=None)),\r
+ ]\r
+\r
+\r
+class TestOptionLike(ParserTestCase):\r
+ """Tests options that may or may not be arguments"""\r
+\r
+ argument_signatures = [\r
+ Sig('-x', type=float),\r
+ Sig('-3', type=float, dest='y'),\r
+ Sig('z', nargs='*'),\r
+ ]\r
+ failures = ['-x', '-y2.5', '-xa', '-x -a',\r
+ '-x -3', '-x -3.5', '-3 -3.5',\r
+ '-x -2.5', '-x -2.5 a', '-3 -.5',\r
+ 'a x -1', '-x -1 a', '-3 -1 a']\r
+ successes = [\r
+ ('', NS(x=None, y=None, z=[])),\r
+ ('-x 2.5', NS(x=2.5, y=None, z=[])),\r
+ ('-x 2.5 a', NS(x=2.5, y=None, z=['a'])),\r
+ ('-3.5', NS(x=None, y=0.5, z=[])),\r
+ ('-3-.5', NS(x=None, y=-0.5, z=[])),\r
+ ('-3 .5', NS(x=None, y=0.5, z=[])),\r
+ ('a -3.5', NS(x=None, y=0.5, z=['a'])),\r
+ ('a', NS(x=None, y=None, z=['a'])),\r
+ ('a -x 1', NS(x=1.0, y=None, z=['a'])),\r
+ ('-x 1 a', NS(x=1.0, y=None, z=['a'])),\r
+ ('-3 1 a', NS(x=None, y=1.0, z=['a'])),\r
+ ]\r
+\r
+\r
+class TestDefaultSuppress(ParserTestCase):\r
+ """Test actions with suppressed defaults"""\r
+\r
+ argument_signatures = [\r
+ Sig('foo', nargs='?', default=argparse.SUPPRESS),\r
+ Sig('bar', nargs='*', default=argparse.SUPPRESS),\r
+ Sig('--baz', action='store_true', default=argparse.SUPPRESS),\r
+ ]\r
+ failures = ['-x']\r
+ successes = [\r
+ ('', NS()),\r
+ ('a', NS(foo='a')),\r
+ ('a b', NS(foo='a', bar=['b'])),\r
+ ('--baz', NS(baz=True)),\r
+ ('a --baz', NS(foo='a', baz=True)),\r
+ ('--baz a b', NS(foo='a', bar=['b'], baz=True)),\r
+ ]\r
+\r
+\r
+class TestParserDefaultSuppress(ParserTestCase):\r
+ """Test actions with a parser-level default of SUPPRESS"""\r
+\r
+ parser_signature = Sig(argument_default=argparse.SUPPRESS)\r
+ argument_signatures = [\r
+ Sig('foo', nargs='?'),\r
+ Sig('bar', nargs='*'),\r
+ Sig('--baz', action='store_true'),\r
+ ]\r
+ failures = ['-x']\r
+ successes = [\r
+ ('', NS()),\r
+ ('a', NS(foo='a')),\r
+ ('a b', NS(foo='a', bar=['b'])),\r
+ ('--baz', NS(baz=True)),\r
+ ('a --baz', NS(foo='a', baz=True)),\r
+ ('--baz a b', NS(foo='a', bar=['b'], baz=True)),\r
+ ]\r
+\r
+\r
+class TestParserDefault42(ParserTestCase):\r
+ """Test actions with a parser-level default of 42"""\r
+\r
+ parser_signature = Sig(argument_default=42, version='1.0')\r
+ argument_signatures = [\r
+ Sig('foo', nargs='?'),\r
+ Sig('bar', nargs='*'),\r
+ Sig('--baz', action='store_true'),\r
+ ]\r
+ failures = ['-x']\r
+ successes = [\r
+ ('', NS(foo=42, bar=42, baz=42)),\r
+ ('a', NS(foo='a', bar=42, baz=42)),\r
+ ('a b', NS(foo='a', bar=['b'], baz=42)),\r
+ ('--baz', NS(foo=42, bar=42, baz=True)),\r
+ ('a --baz', NS(foo='a', bar=42, baz=True)),\r
+ ('--baz a b', NS(foo='a', bar=['b'], baz=True)),\r
+ ]\r
+\r
+\r
+class TestArgumentsFromFile(TempDirMixin, ParserTestCase):\r
+ """Test reading arguments from a file"""\r
+\r
+ def setUp(self):\r
+ super(TestArgumentsFromFile, self).setUp()\r
+ file_texts = [\r
+ ('hello', 'hello world!\n'),\r
+ ('recursive', '-a\n'\r
+ 'A\n'\r
+ '@hello'),\r
+ ('invalid', '@no-such-path\n'),\r
+ ]\r
+ for path, text in file_texts:\r
+ file = open(path, 'w')\r
+ file.write(text)\r
+ file.close()\r
+\r
+ parser_signature = Sig(fromfile_prefix_chars='@')\r
+ argument_signatures = [\r
+ Sig('-a'),\r
+ Sig('x'),\r
+ Sig('y', nargs='+'),\r
+ ]\r
+ failures = ['', '-b', 'X', '@invalid', '@missing']\r
+ successes = [\r
+ ('X Y', NS(a=None, x='X', y=['Y'])),\r
+ ('X -a A Y Z', NS(a='A', x='X', y=['Y', 'Z'])),\r
+ ('@hello X', NS(a=None, x='hello world!', y=['X'])),\r
+ ('X @hello', NS(a=None, x='X', y=['hello world!'])),\r
+ ('-a B @recursive Y Z', NS(a='A', x='hello world!', y=['Y', 'Z'])),\r
+ ('X @recursive Z -a B', NS(a='B', x='X', y=['hello world!', 'Z'])),\r
+ ]\r
+\r
+\r
+class TestArgumentsFromFileConverter(TempDirMixin, ParserTestCase):\r
+ """Test reading arguments from a file"""\r
+\r
+ def setUp(self):\r
+ super(TestArgumentsFromFileConverter, self).setUp()\r
+ file_texts = [\r
+ ('hello', 'hello world!\n'),\r
+ ]\r
+ for path, text in file_texts:\r
+ file = open(path, 'w')\r
+ file.write(text)\r
+ file.close()\r
+\r
+ class FromFileConverterArgumentParser(ErrorRaisingArgumentParser):\r
+\r
+ def convert_arg_line_to_args(self, arg_line):\r
+ for arg in arg_line.split():\r
+ if not arg.strip():\r
+ continue\r
+ yield arg\r
+ parser_class = FromFileConverterArgumentParser\r
+ parser_signature = Sig(fromfile_prefix_chars='@')\r
+ argument_signatures = [\r
+ Sig('y', nargs='+'),\r
+ ]\r
+ failures = []\r
+ successes = [\r
+ ('@hello X', NS(y=['hello', 'world!', 'X'])),\r
+ ]\r
+\r
+\r
+# =====================\r
+# Type conversion tests\r
+# =====================\r
+\r
+class TestFileTypeRepr(TestCase):\r
+\r
+ def test_r(self):\r
+ type = argparse.FileType('r')\r
+ self.assertEqual("FileType('r')", repr(type))\r
+\r
+ def test_wb_1(self):\r
+ type = argparse.FileType('wb', 1)\r
+ self.assertEqual("FileType('wb', 1)", repr(type))\r
+\r
+\r
+class RFile(object):\r
+ seen = {}\r
+\r
+ def __init__(self, name):\r
+ self.name = name\r
+\r
+ def __eq__(self, other):\r
+ if other in self.seen:\r
+ text = self.seen[other]\r
+ else:\r
+ text = self.seen[other] = other.read()\r
+ other.close()\r
+ if not isinstance(text, str):\r
+ text = text.decode('ascii')\r
+ return self.name == other.name == text\r
+\r
+\r
+class TestFileTypeR(TempDirMixin, ParserTestCase):\r
+ """Test the FileType option/argument type for reading files"""\r
+\r
+ def setUp(self):\r
+ super(TestFileTypeR, self).setUp()\r
+ for file_name in ['foo', 'bar']:\r
+ file = open(os.path.join(self.temp_dir, file_name), 'w')\r
+ file.write(file_name)\r
+ file.close()\r
+\r
+ argument_signatures = [\r
+ Sig('-x', type=argparse.FileType()),\r
+ Sig('spam', type=argparse.FileType('r')),\r
+ ]\r
+ failures = ['-x', '-x bar']\r
+ successes = [\r
+ ('foo', NS(x=None, spam=RFile('foo'))),\r
+ ('-x foo bar', NS(x=RFile('foo'), spam=RFile('bar'))),\r
+ ('bar -x foo', NS(x=RFile('foo'), spam=RFile('bar'))),\r
+ ('-x - -', NS(x=sys.stdin, spam=sys.stdin)),\r
+ ]\r
+\r
+\r
+class TestFileTypeRB(TempDirMixin, ParserTestCase):\r
+ """Test the FileType option/argument type for reading files"""\r
+\r
+ def setUp(self):\r
+ super(TestFileTypeRB, self).setUp()\r
+ for file_name in ['foo', 'bar']:\r
+ file = open(os.path.join(self.temp_dir, file_name), 'w')\r
+ file.write(file_name)\r
+ file.close()\r
+\r
+ argument_signatures = [\r
+ Sig('-x', type=argparse.FileType('rb')),\r
+ Sig('spam', type=argparse.FileType('rb')),\r
+ ]\r
+ failures = ['-x', '-x bar']\r
+ successes = [\r
+ ('foo', NS(x=None, spam=RFile('foo'))),\r
+ ('-x foo bar', NS(x=RFile('foo'), spam=RFile('bar'))),\r
+ ('bar -x foo', NS(x=RFile('foo'), spam=RFile('bar'))),\r
+ ('-x - -', NS(x=sys.stdin, spam=sys.stdin)),\r
+ ]\r
+\r
+\r
+class WFile(object):\r
+ seen = set()\r
+\r
+ def __init__(self, name):\r
+ self.name = name\r
+\r
+ def __eq__(self, other):\r
+ if other not in self.seen:\r
+ text = 'Check that file is writable.'\r
+ if 'b' in other.mode:\r
+ text = text.encode('ascii')\r
+ other.write(text)\r
+ other.close()\r
+ self.seen.add(other)\r
+ return self.name == other.name\r
+\r
+\r
+class TestFileTypeW(TempDirMixin, ParserTestCase):\r
+ """Test the FileType option/argument type for writing files"""\r
+\r
+ argument_signatures = [\r
+ Sig('-x', type=argparse.FileType('w')),\r
+ Sig('spam', type=argparse.FileType('w')),\r
+ ]\r
+ failures = ['-x', '-x bar']\r
+ successes = [\r
+ ('foo', NS(x=None, spam=WFile('foo'))),\r
+ ('-x foo bar', NS(x=WFile('foo'), spam=WFile('bar'))),\r
+ ('bar -x foo', NS(x=WFile('foo'), spam=WFile('bar'))),\r
+ ('-x - -', NS(x=sys.stdout, spam=sys.stdout)),\r
+ ]\r
+\r
+\r
+class TestFileTypeWB(TempDirMixin, ParserTestCase):\r
+\r
+ argument_signatures = [\r
+ Sig('-x', type=argparse.FileType('wb')),\r
+ Sig('spam', type=argparse.FileType('wb')),\r
+ ]\r
+ failures = ['-x', '-x bar']\r
+ successes = [\r
+ ('foo', NS(x=None, spam=WFile('foo'))),\r
+ ('-x foo bar', NS(x=WFile('foo'), spam=WFile('bar'))),\r
+ ('bar -x foo', NS(x=WFile('foo'), spam=WFile('bar'))),\r
+ ('-x - -', NS(x=sys.stdout, spam=sys.stdout)),\r
+ ]\r
+\r
+\r
+class TestTypeCallable(ParserTestCase):\r
+ """Test some callables as option/argument types"""\r
+\r
+ argument_signatures = [\r
+ Sig('--eggs', type=complex),\r
+ Sig('spam', type=float),\r
+ ]\r
+ failures = ['a', '42j', '--eggs a', '--eggs 2i']\r
+ successes = [\r
+ ('--eggs=42 42', NS(eggs=42, spam=42.0)),\r
+ ('--eggs 2j -- -1.5', NS(eggs=2j, spam=-1.5)),\r
+ ('1024.675', NS(eggs=None, spam=1024.675)),\r
+ ]\r
+\r
+\r
+class TestTypeUserDefined(ParserTestCase):\r
+ """Test a user-defined option/argument type"""\r
+\r
+ class MyType(TestCase):\r
+\r
+ def __init__(self, value):\r
+ self.value = value\r
+\r
+ def __eq__(self, other):\r
+ return (type(self), self.value) == (type(other), other.value)\r
+\r
+ argument_signatures = [\r
+ Sig('-x', type=MyType),\r
+ Sig('spam', type=MyType),\r
+ ]\r
+ failures = []\r
+ successes = [\r
+ ('a -x b', NS(x=MyType('b'), spam=MyType('a'))),\r
+ ('-xf g', NS(x=MyType('f'), spam=MyType('g'))),\r
+ ]\r
+\r
+\r
+class TestTypeClassicClass(ParserTestCase):\r
+ """Test a classic class type"""\r
+\r
+ class C:\r
+\r
+ def __init__(self, value):\r
+ self.value = value\r
+\r
+ def __eq__(self, other):\r
+ return (type(self), self.value) == (type(other), other.value)\r
+\r
+ argument_signatures = [\r
+ Sig('-x', type=C),\r
+ Sig('spam', type=C),\r
+ ]\r
+ failures = []\r
+ successes = [\r
+ ('a -x b', NS(x=C('b'), spam=C('a'))),\r
+ ('-xf g', NS(x=C('f'), spam=C('g'))),\r
+ ]\r
+\r
+\r
+class TestTypeRegistration(TestCase):\r
+ """Test a user-defined type by registering it"""\r
+\r
+ def test(self):\r
+\r
+ def get_my_type(string):\r
+ return 'my_type{%s}' % string\r
+\r
+ parser = argparse.ArgumentParser()\r
+ parser.register('type', 'my_type', get_my_type)\r
+ parser.add_argument('-x', type='my_type')\r
+ parser.add_argument('y', type='my_type')\r
+\r
+ self.assertEqual(parser.parse_args('1'.split()),\r
+ NS(x=None, y='my_type{1}'))\r
+ self.assertEqual(parser.parse_args('-x 1 42'.split()),\r
+ NS(x='my_type{1}', y='my_type{42}'))\r
+\r
+\r
+# ============\r
+# Action tests\r
+# ============\r
+\r
+class TestActionUserDefined(ParserTestCase):\r
+ """Test a user-defined option/argument action"""\r
+\r
+ class OptionalAction(argparse.Action):\r
+\r
+ def __call__(self, parser, namespace, value, option_string=None):\r
+ try:\r
+ # check destination and option string\r
+ assert self.dest == 'spam', 'dest: %s' % self.dest\r
+ assert option_string == '-s', 'flag: %s' % option_string\r
+ # when option is before argument, badger=2, and when\r
+ # option is after argument, badger=<whatever was set>\r
+ expected_ns = NS(spam=0.25)\r
+ if value in [0.125, 0.625]:\r
+ expected_ns.badger = 2\r
+ elif value in [2.0]:\r
+ expected_ns.badger = 84\r
+ else:\r
+ raise AssertionError('value: %s' % value)\r
+ assert expected_ns == namespace, ('expected %s, got %s' %\r
+ (expected_ns, namespace))\r
+ except AssertionError:\r
+ e = sys.exc_info()[1]\r
+ raise ArgumentParserError('opt_action failed: %s' % e)\r
+ setattr(namespace, 'spam', value)\r
+\r
+ class PositionalAction(argparse.Action):\r
+\r
+ def __call__(self, parser, namespace, value, option_string=None):\r
+ try:\r
+ assert option_string is None, ('option_string: %s' %\r
+ option_string)\r
+ # check destination\r
+ assert self.dest == 'badger', 'dest: %s' % self.dest\r
+ # when argument is before option, spam=0.25, and when\r
+ # option is after argument, spam=<whatever was set>\r
+ expected_ns = NS(badger=2)\r
+ if value in [42, 84]:\r
+ expected_ns.spam = 0.25\r
+ elif value in [1]:\r
+ expected_ns.spam = 0.625\r
+ elif value in [2]:\r
+ expected_ns.spam = 0.125\r
+ else:\r
+ raise AssertionError('value: %s' % value)\r
+ assert expected_ns == namespace, ('expected %s, got %s' %\r
+ (expected_ns, namespace))\r
+ except AssertionError:\r
+ e = sys.exc_info()[1]\r
+ raise ArgumentParserError('arg_action failed: %s' % e)\r
+ setattr(namespace, 'badger', value)\r
+\r
+ argument_signatures = [\r
+ Sig('-s', dest='spam', action=OptionalAction,\r
+ type=float, default=0.25),\r
+ Sig('badger', action=PositionalAction,\r
+ type=int, nargs='?', default=2),\r
+ ]\r
+ failures = []\r
+ successes = [\r
+ ('-s0.125', NS(spam=0.125, badger=2)),\r
+ ('42', NS(spam=0.25, badger=42)),\r
+ ('-s 0.625 1', NS(spam=0.625, badger=1)),\r
+ ('84 -s2', NS(spam=2.0, badger=84)),\r
+ ]\r
+\r
+\r
+class TestActionRegistration(TestCase):\r
+ """Test a user-defined action supplied by registering it"""\r
+\r
+ class MyAction(argparse.Action):\r
+\r
+ def __call__(self, parser, namespace, values, option_string=None):\r
+ setattr(namespace, self.dest, 'foo[%s]' % values)\r
+\r
+ def test(self):\r
+\r
+ parser = argparse.ArgumentParser()\r
+ parser.register('action', 'my_action', self.MyAction)\r
+ parser.add_argument('badger', action='my_action')\r
+\r
+ self.assertEqual(parser.parse_args(['1']), NS(badger='foo[1]'))\r
+ self.assertEqual(parser.parse_args(['42']), NS(badger='foo[42]'))\r
+\r
+\r
+# ================\r
+# Subparsers tests\r
+# ================\r
+\r
+class TestAddSubparsers(TestCase):\r
+ """Test the add_subparsers method"""\r
+\r
+ def assertArgumentParserError(self, *args, **kwargs):\r
+ self.assertRaises(ArgumentParserError, *args, **kwargs)\r
+\r
+ def _get_parser(self, subparser_help=False):\r
+ # create a parser with a subparsers argument\r
+ parser = ErrorRaisingArgumentParser(\r
+ prog='PROG', description='main description')\r
+ parser.add_argument(\r
+ '--foo', action='store_true', help='foo help')\r
+ parser.add_argument(\r
+ 'bar', type=float, help='bar help')\r
+\r
+ # check that only one subparsers argument can be added\r
+ subparsers = parser.add_subparsers(help='command help')\r
+ self.assertArgumentParserError(parser.add_subparsers)\r
+\r
+ # add first sub-parser\r
+ parser1_kwargs = dict(description='1 description')\r
+ if subparser_help:\r
+ parser1_kwargs['help'] = '1 help'\r
+ parser1 = subparsers.add_parser('1', **parser1_kwargs)\r
+ parser1.add_argument('-w', type=int, help='w help')\r
+ parser1.add_argument('x', choices='abc', help='x help')\r
+\r
+ # add second sub-parser\r
+ parser2_kwargs = dict(description='2 description')\r
+ if subparser_help:\r
+ parser2_kwargs['help'] = '2 help'\r
+ parser2 = subparsers.add_parser('2', **parser2_kwargs)\r
+ parser2.add_argument('-y', choices='123', help='y help')\r
+ parser2.add_argument('z', type=complex, nargs='*', help='z help')\r
+\r
+ # return the main parser\r
+ return parser\r
+\r
+ def setUp(self):\r
+ self.parser = self._get_parser()\r
+ self.command_help_parser = self._get_parser(subparser_help=True)\r
+\r
+ def test_parse_args_failures(self):\r
+ # check some failure cases:\r
+ for args_str in ['', 'a', 'a a', '0.5 a', '0.5 1',\r
+ '0.5 1 -y', '0.5 2 -w']:\r
+ args = args_str.split()\r
+ self.assertArgumentParserError(self.parser.parse_args, args)\r
+\r
+ def test_parse_args(self):\r
+ # check some non-failure cases:\r
+ self.assertEqual(\r
+ self.parser.parse_args('0.5 1 b -w 7'.split()),\r
+ NS(foo=False, bar=0.5, w=7, x='b'),\r
+ )\r
+ self.assertEqual(\r
+ self.parser.parse_args('0.25 --foo 2 -y 2 3j -- -1j'.split()),\r
+ NS(foo=True, bar=0.25, y='2', z=[3j, -1j]),\r
+ )\r
+ self.assertEqual(\r
+ self.parser.parse_args('--foo 0.125 1 c'.split()),\r
+ NS(foo=True, bar=0.125, w=None, x='c'),\r
+ )\r
+\r
+ def test_dest(self):\r
+ parser = ErrorRaisingArgumentParser()\r
+ parser.add_argument('--foo', action='store_true')\r
+ subparsers = parser.add_subparsers(dest='bar')\r
+ parser1 = subparsers.add_parser('1')\r
+ parser1.add_argument('baz')\r
+ self.assertEqual(NS(foo=False, bar='1', baz='2'),\r
+ parser.parse_args('1 2'.split()))\r
+\r
+ def test_help(self):\r
+ self.assertEqual(self.parser.format_usage(),\r
+ 'usage: PROG [-h] [--foo] bar {1,2} ...\n')\r
+ self.assertEqual(self.parser.format_help(), textwrap.dedent('''\\r
+ usage: PROG [-h] [--foo] bar {1,2} ...\r
+\r
+ main description\r
+\r
+ positional arguments:\r
+ bar bar help\r
+ {1,2} command help\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ --foo foo help\r
+ '''))\r
+\r
+ def test_parser_command_help(self):\r
+ self.assertEqual(self.command_help_parser.format_usage(),\r
+ 'usage: PROG [-h] [--foo] bar {1,2} ...\n')\r
+ self.assertEqual(self.command_help_parser.format_help(),\r
+ textwrap.dedent('''\\r
+ usage: PROG [-h] [--foo] bar {1,2} ...\r
+\r
+ main description\r
+\r
+ positional arguments:\r
+ bar bar help\r
+ {1,2} command help\r
+ 1 1 help\r
+ 2 2 help\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ --foo foo help\r
+ '''))\r
+\r
+ def test_subparser_title_help(self):\r
+ parser = ErrorRaisingArgumentParser(prog='PROG',\r
+ description='main description')\r
+ parser.add_argument('--foo', action='store_true', help='foo help')\r
+ parser.add_argument('bar', help='bar help')\r
+ subparsers = parser.add_subparsers(title='subcommands',\r
+ description='command help',\r
+ help='additional text')\r
+ parser1 = subparsers.add_parser('1')\r
+ parser2 = subparsers.add_parser('2')\r
+ self.assertEqual(parser.format_usage(),\r
+ 'usage: PROG [-h] [--foo] bar {1,2} ...\n')\r
+ self.assertEqual(parser.format_help(), textwrap.dedent('''\\r
+ usage: PROG [-h] [--foo] bar {1,2} ...\r
+\r
+ main description\r
+\r
+ positional arguments:\r
+ bar bar help\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ --foo foo help\r
+\r
+ subcommands:\r
+ command help\r
+\r
+ {1,2} additional text\r
+ '''))\r
+\r
+ def _test_subparser_help(self, args_str, expected_help):\r
+ try:\r
+ self.parser.parse_args(args_str.split())\r
+ except ArgumentParserError:\r
+ err = sys.exc_info()[1]\r
+ if err.stdout != expected_help:\r
+ print(repr(expected_help))\r
+ print(repr(err.stdout))\r
+ self.assertEqual(err.stdout, expected_help)\r
+\r
+ def test_subparser1_help(self):\r
+ self._test_subparser_help('5.0 1 -h', textwrap.dedent('''\\r
+ usage: PROG bar 1 [-h] [-w W] {a,b,c}\r
+\r
+ 1 description\r
+\r
+ positional arguments:\r
+ {a,b,c} x help\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ -w W w help\r
+ '''))\r
+\r
+ def test_subparser2_help(self):\r
+ self._test_subparser_help('5.0 2 -h', textwrap.dedent('''\\r
+ usage: PROG bar 2 [-h] [-y {1,2,3}] [z [z ...]]\r
+\r
+ 2 description\r
+\r
+ positional arguments:\r
+ z z help\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ -y {1,2,3} y help\r
+ '''))\r
+\r
+# ============\r
+# Groups tests\r
+# ============\r
+\r
+class TestPositionalsGroups(TestCase):\r
+ """Tests that order of group positionals matches construction order"""\r
+\r
+ def test_nongroup_first(self):\r
+ parser = ErrorRaisingArgumentParser()\r
+ parser.add_argument('foo')\r
+ group = parser.add_argument_group('g')\r
+ group.add_argument('bar')\r
+ parser.add_argument('baz')\r
+ expected = NS(foo='1', bar='2', baz='3')\r
+ result = parser.parse_args('1 2 3'.split())\r
+ self.failUnlessEqual(expected, result)\r
+\r
+ def test_group_first(self):\r
+ parser = ErrorRaisingArgumentParser()\r
+ group = parser.add_argument_group('xxx')\r
+ group.add_argument('foo')\r
+ parser.add_argument('bar')\r
+ parser.add_argument('baz')\r
+ expected = NS(foo='1', bar='2', baz='3')\r
+ result = parser.parse_args('1 2 3'.split())\r
+ self.failUnlessEqual(expected, result)\r
+\r
+ def test_interleaved_groups(self):\r
+ parser = ErrorRaisingArgumentParser()\r
+ group = parser.add_argument_group('xxx')\r
+ parser.add_argument('foo')\r
+ group.add_argument('bar')\r
+ parser.add_argument('baz')\r
+ group = parser.add_argument_group('yyy')\r
+ group.add_argument('frell')\r
+ expected = NS(foo='1', bar='2', baz='3', frell='4')\r
+ result = parser.parse_args('1 2 3 4'.split())\r
+ self.failUnlessEqual(expected, result)\r
+\r
+# ===================\r
+# Parent parser tests\r
+# ===================\r
+\r
+class TestParentParsers(TestCase):\r
+ """Tests that parsers can be created with parent parsers"""\r
+\r
+ def assertArgumentParserError(self, *args, **kwargs):\r
+ self.assertRaises(ArgumentParserError, *args, **kwargs)\r
+\r
+ def setUp(self):\r
+ self.wxyz_parent = ErrorRaisingArgumentParser(add_help=False)\r
+ self.wxyz_parent.add_argument('--w')\r
+ x_group = self.wxyz_parent.add_argument_group('x')\r
+ x_group.add_argument('-y')\r
+ self.wxyz_parent.add_argument('z')\r
+\r
+ self.abcd_parent = ErrorRaisingArgumentParser(add_help=False)\r
+ self.abcd_parent.add_argument('a')\r
+ self.abcd_parent.add_argument('-b')\r
+ c_group = self.abcd_parent.add_argument_group('c')\r
+ c_group.add_argument('--d')\r
+\r
+ self.w_parent = ErrorRaisingArgumentParser(add_help=False)\r
+ self.w_parent.add_argument('--w')\r
+\r
+ self.z_parent = ErrorRaisingArgumentParser(add_help=False)\r
+ self.z_parent.add_argument('z')\r
+\r
+ # parents with mutually exclusive groups\r
+ self.ab_mutex_parent = ErrorRaisingArgumentParser(add_help=False)\r
+ group = self.ab_mutex_parent.add_mutually_exclusive_group()\r
+ group.add_argument('-a', action='store_true')\r
+ group.add_argument('-b', action='store_true')\r
+\r
+ def test_single_parent(self):\r
+ parser = ErrorRaisingArgumentParser(parents=[self.wxyz_parent])\r
+ self.assertEqual(parser.parse_args('-y 1 2 --w 3'.split()),\r
+ NS(w='3', y='1', z='2'))\r
+\r
+ def test_single_parent_mutex(self):\r
+ self._test_mutex_ab(self.ab_mutex_parent.parse_args)\r
+ parser = ErrorRaisingArgumentParser(parents=[self.ab_mutex_parent])\r
+ self._test_mutex_ab(parser.parse_args)\r
+\r
+ def test_single_granparent_mutex(self):\r
+ parents = [self.ab_mutex_parent]\r
+ parser = ErrorRaisingArgumentParser(add_help=False, parents=parents)\r
+ parser = ErrorRaisingArgumentParser(parents=[parser])\r
+ self._test_mutex_ab(parser.parse_args)\r
+\r
+ def _test_mutex_ab(self, parse_args):\r
+ self.assertEqual(parse_args([]), NS(a=False, b=False))\r
+ self.assertEqual(parse_args(['-a']), NS(a=True, b=False))\r
+ self.assertEqual(parse_args(['-b']), NS(a=False, b=True))\r
+ self.assertArgumentParserError(parse_args, ['-a', '-b'])\r
+ self.assertArgumentParserError(parse_args, ['-b', '-a'])\r
+ self.assertArgumentParserError(parse_args, ['-c'])\r
+ self.assertArgumentParserError(parse_args, ['-a', '-c'])\r
+ self.assertArgumentParserError(parse_args, ['-b', '-c'])\r
+\r
+ def test_multiple_parents(self):\r
+ parents = [self.abcd_parent, self.wxyz_parent]\r
+ parser = ErrorRaisingArgumentParser(parents=parents)\r
+ self.assertEqual(parser.parse_args('--d 1 --w 2 3 4'.split()),\r
+ NS(a='3', b=None, d='1', w='2', y=None, z='4'))\r
+\r
+ def test_multiple_parents_mutex(self):\r
+ parents = [self.ab_mutex_parent, self.wxyz_parent]\r
+ parser = ErrorRaisingArgumentParser(parents=parents)\r
+ self.assertEqual(parser.parse_args('-a --w 2 3'.split()),\r
+ NS(a=True, b=False, w='2', y=None, z='3'))\r
+ self.assertArgumentParserError(\r
+ parser.parse_args, '-a --w 2 3 -b'.split())\r
+ self.assertArgumentParserError(\r
+ parser.parse_args, '-a -b --w 2 3'.split())\r
+\r
+ def test_conflicting_parents(self):\r
+ self.assertRaises(\r
+ argparse.ArgumentError,\r
+ argparse.ArgumentParser,\r
+ parents=[self.w_parent, self.wxyz_parent])\r
+\r
+ def test_conflicting_parents_mutex(self):\r
+ self.assertRaises(\r
+ argparse.ArgumentError,\r
+ argparse.ArgumentParser,\r
+ parents=[self.abcd_parent, self.ab_mutex_parent])\r
+\r
+ def test_same_argument_name_parents(self):\r
+ parents = [self.wxyz_parent, self.z_parent]\r
+ parser = ErrorRaisingArgumentParser(parents=parents)\r
+ self.assertEqual(parser.parse_args('1 2'.split()),\r
+ NS(w=None, y=None, z='2'))\r
+\r
+ def test_subparser_parents(self):\r
+ parser = ErrorRaisingArgumentParser()\r
+ subparsers = parser.add_subparsers()\r
+ abcde_parser = subparsers.add_parser('bar', parents=[self.abcd_parent])\r
+ abcde_parser.add_argument('e')\r
+ self.assertEqual(parser.parse_args('bar -b 1 --d 2 3 4'.split()),\r
+ NS(a='3', b='1', d='2', e='4'))\r
+\r
+ def test_subparser_parents_mutex(self):\r
+ parser = ErrorRaisingArgumentParser()\r
+ subparsers = parser.add_subparsers()\r
+ parents = [self.ab_mutex_parent]\r
+ abc_parser = subparsers.add_parser('foo', parents=parents)\r
+ c_group = abc_parser.add_argument_group('c_group')\r
+ c_group.add_argument('c')\r
+ parents = [self.wxyz_parent, self.ab_mutex_parent]\r
+ wxyzabe_parser = subparsers.add_parser('bar', parents=parents)\r
+ wxyzabe_parser.add_argument('e')\r
+ self.assertEqual(parser.parse_args('foo -a 4'.split()),\r
+ NS(a=True, b=False, c='4'))\r
+ self.assertEqual(parser.parse_args('bar -b --w 2 3 4'.split()),\r
+ NS(a=False, b=True, w='2', y=None, z='3', e='4'))\r
+ self.assertArgumentParserError(\r
+ parser.parse_args, 'foo -a -b 4'.split())\r
+ self.assertArgumentParserError(\r
+ parser.parse_args, 'bar -b -a 4'.split())\r
+\r
+ def test_parent_help(self):\r
+ parents = [self.abcd_parent, self.wxyz_parent]\r
+ parser = ErrorRaisingArgumentParser(parents=parents)\r
+ parser_help = parser.format_help()\r
+ self.assertEqual(parser_help, textwrap.dedent('''\\r
+ usage: test_argparse.py [-h] [-b B] [--d D] [--w W] [-y Y] a z\r
+\r
+ positional arguments:\r
+ a\r
+ z\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ -b B\r
+ --w W\r
+\r
+ c:\r
+ --d D\r
+\r
+ x:\r
+ -y Y\r
+ '''))\r
+\r
+ def test_groups_parents(self):\r
+ parent = ErrorRaisingArgumentParser(add_help=False)\r
+ g = parent.add_argument_group(title='g', description='gd')\r
+ g.add_argument('-w')\r
+ g.add_argument('-x')\r
+ m = parent.add_mutually_exclusive_group()\r
+ m.add_argument('-y')\r
+ m.add_argument('-z')\r
+ parser = ErrorRaisingArgumentParser(parents=[parent])\r
+\r
+ self.assertRaises(ArgumentParserError, parser.parse_args,\r
+ ['-y', 'Y', '-z', 'Z'])\r
+\r
+ parser_help = parser.format_help()\r
+ self.assertEqual(parser_help, textwrap.dedent('''\\r
+ usage: test_argparse.py [-h] [-w W] [-x X] [-y Y | -z Z]\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ -y Y\r
+ -z Z\r
+\r
+ g:\r
+ gd\r
+\r
+ -w W\r
+ -x X\r
+ '''))\r
+\r
+# ==============================\r
+# Mutually exclusive group tests\r
+# ==============================\r
+\r
+class TestMutuallyExclusiveGroupErrors(TestCase):\r
+\r
+ def test_invalid_add_argument_group(self):\r
+ parser = ErrorRaisingArgumentParser()\r
+ raises = self.assertRaises\r
+ raises(TypeError, parser.add_mutually_exclusive_group, title='foo')\r
+\r
+ def test_invalid_add_argument(self):\r
+ parser = ErrorRaisingArgumentParser()\r
+ group = parser.add_mutually_exclusive_group()\r
+ add_argument = group.add_argument\r
+ raises = self.assertRaises\r
+ raises(ValueError, add_argument, '--foo', required=True)\r
+ raises(ValueError, add_argument, 'bar')\r
+ raises(ValueError, add_argument, 'bar', nargs='+')\r
+ raises(ValueError, add_argument, 'bar', nargs=1)\r
+ raises(ValueError, add_argument, 'bar', nargs=argparse.PARSER)\r
+\r
+\r
+class MEMixin(object):\r
+\r
+ def test_failures_when_not_required(self):\r
+ parse_args = self.get_parser(required=False).parse_args\r
+ error = ArgumentParserError\r
+ for args_string in self.failures:\r
+ self.assertRaises(error, parse_args, args_string.split())\r
+\r
+ def test_failures_when_required(self):\r
+ parse_args = self.get_parser(required=True).parse_args\r
+ error = ArgumentParserError\r
+ for args_string in self.failures + ['']:\r
+ self.assertRaises(error, parse_args, args_string.split())\r
+\r
+ def test_successes_when_not_required(self):\r
+ parse_args = self.get_parser(required=False).parse_args\r
+ successes = self.successes + self.successes_when_not_required\r
+ for args_string, expected_ns in successes:\r
+ actual_ns = parse_args(args_string.split())\r
+ self.assertEqual(actual_ns, expected_ns)\r
+\r
+ def test_successes_when_required(self):\r
+ parse_args = self.get_parser(required=True).parse_args\r
+ for args_string, expected_ns in self.successes:\r
+ actual_ns = parse_args(args_string.split())\r
+ self.assertEqual(actual_ns, expected_ns)\r
+\r
+ def test_usage_when_not_required(self):\r
+ format_usage = self.get_parser(required=False).format_usage\r
+ expected_usage = self.usage_when_not_required\r
+ self.assertEqual(format_usage(), textwrap.dedent(expected_usage))\r
+\r
+ def test_usage_when_required(self):\r
+ format_usage = self.get_parser(required=True).format_usage\r
+ expected_usage = self.usage_when_required\r
+ self.assertEqual(format_usage(), textwrap.dedent(expected_usage))\r
+\r
+ def test_help_when_not_required(self):\r
+ format_help = self.get_parser(required=False).format_help\r
+ help = self.usage_when_not_required + self.help\r
+ self.assertEqual(format_help(), textwrap.dedent(help))\r
+\r
+ def test_help_when_required(self):\r
+ format_help = self.get_parser(required=True).format_help\r
+ help = self.usage_when_required + self.help\r
+ self.assertEqual(format_help(), textwrap.dedent(help))\r
+\r
+\r
+class TestMutuallyExclusiveSimple(MEMixin, TestCase):\r
+\r
+ def get_parser(self, required=None):\r
+ parser = ErrorRaisingArgumentParser(prog='PROG')\r
+ group = parser.add_mutually_exclusive_group(required=required)\r
+ group.add_argument('--bar', help='bar help')\r
+ group.add_argument('--baz', nargs='?', const='Z', help='baz help')\r
+ return parser\r
+\r
+ failures = ['--bar X --baz Y', '--bar X --baz']\r
+ successes = [\r
+ ('--bar X', NS(bar='X', baz=None)),\r
+ ('--bar X --bar Z', NS(bar='Z', baz=None)),\r
+ ('--baz Y', NS(bar=None, baz='Y')),\r
+ ('--baz', NS(bar=None, baz='Z')),\r
+ ]\r
+ successes_when_not_required = [\r
+ ('', NS(bar=None, baz=None)),\r
+ ]\r
+\r
+ usage_when_not_required = '''\\r
+ usage: PROG [-h] [--bar BAR | --baz [BAZ]]\r
+ '''\r
+ usage_when_required = '''\\r
+ usage: PROG [-h] (--bar BAR | --baz [BAZ])\r
+ '''\r
+ help = '''\\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ --bar BAR bar help\r
+ --baz [BAZ] baz help\r
+ '''\r
+\r
+\r
+class TestMutuallyExclusiveLong(MEMixin, TestCase):\r
+\r
+ def get_parser(self, required=None):\r
+ parser = ErrorRaisingArgumentParser(prog='PROG')\r
+ parser.add_argument('--abcde', help='abcde help')\r
+ parser.add_argument('--fghij', help='fghij help')\r
+ group = parser.add_mutually_exclusive_group(required=required)\r
+ group.add_argument('--klmno', help='klmno help')\r
+ group.add_argument('--pqrst', help='pqrst help')\r
+ return parser\r
+\r
+ failures = ['--klmno X --pqrst Y']\r
+ successes = [\r
+ ('--klmno X', NS(abcde=None, fghij=None, klmno='X', pqrst=None)),\r
+ ('--abcde Y --klmno X',\r
+ NS(abcde='Y', fghij=None, klmno='X', pqrst=None)),\r
+ ('--pqrst X', NS(abcde=None, fghij=None, klmno=None, pqrst='X')),\r
+ ('--pqrst X --fghij Y',\r
+ NS(abcde=None, fghij='Y', klmno=None, pqrst='X')),\r
+ ]\r
+ successes_when_not_required = [\r
+ ('', NS(abcde=None, fghij=None, klmno=None, pqrst=None)),\r
+ ]\r
+\r
+ usage_when_not_required = '''\\r
+ usage: PROG [-h] [--abcde ABCDE] [--fghij FGHIJ]\r
+ [--klmno KLMNO | --pqrst PQRST]\r
+ '''\r
+ usage_when_required = '''\\r
+ usage: PROG [-h] [--abcde ABCDE] [--fghij FGHIJ]\r
+ (--klmno KLMNO | --pqrst PQRST)\r
+ '''\r
+ help = '''\\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ --abcde ABCDE abcde help\r
+ --fghij FGHIJ fghij help\r
+ --klmno KLMNO klmno help\r
+ --pqrst PQRST pqrst help\r
+ '''\r
+\r
+\r
+class TestMutuallyExclusiveFirstSuppressed(MEMixin, TestCase):\r
+\r
+ def get_parser(self, required):\r
+ parser = ErrorRaisingArgumentParser(prog='PROG')\r
+ group = parser.add_mutually_exclusive_group(required=required)\r
+ group.add_argument('-x', help=argparse.SUPPRESS)\r
+ group.add_argument('-y', action='store_false', help='y help')\r
+ return parser\r
+\r
+ failures = ['-x X -y']\r
+ successes = [\r
+ ('-x X', NS(x='X', y=True)),\r
+ ('-x X -x Y', NS(x='Y', y=True)),\r
+ ('-y', NS(x=None, y=False)),\r
+ ]\r
+ successes_when_not_required = [\r
+ ('', NS(x=None, y=True)),\r
+ ]\r
+\r
+ usage_when_not_required = '''\\r
+ usage: PROG [-h] [-y]\r
+ '''\r
+ usage_when_required = '''\\r
+ usage: PROG [-h] -y\r
+ '''\r
+ help = '''\\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ -y y help\r
+ '''\r
+\r
+\r
+class TestMutuallyExclusiveManySuppressed(MEMixin, TestCase):\r
+\r
+ def get_parser(self, required):\r
+ parser = ErrorRaisingArgumentParser(prog='PROG')\r
+ group = parser.add_mutually_exclusive_group(required=required)\r
+ add = group.add_argument\r
+ add('--spam', action='store_true', help=argparse.SUPPRESS)\r
+ add('--badger', action='store_false', help=argparse.SUPPRESS)\r
+ add('--bladder', help=argparse.SUPPRESS)\r
+ return parser\r
+\r
+ failures = [\r
+ '--spam --badger',\r
+ '--badger --bladder B',\r
+ '--bladder B --spam',\r
+ ]\r
+ successes = [\r
+ ('--spam', NS(spam=True, badger=True, bladder=None)),\r
+ ('--badger', NS(spam=False, badger=False, bladder=None)),\r
+ ('--bladder B', NS(spam=False, badger=True, bladder='B')),\r
+ ('--spam --spam', NS(spam=True, badger=True, bladder=None)),\r
+ ]\r
+ successes_when_not_required = [\r
+ ('', NS(spam=False, badger=True, bladder=None)),\r
+ ]\r
+\r
+ usage_when_required = usage_when_not_required = '''\\r
+ usage: PROG [-h]\r
+ '''\r
+ help = '''\\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ '''\r
+\r
+\r
+class TestMutuallyExclusiveOptionalAndPositional(MEMixin, TestCase):\r
+\r
+ def get_parser(self, required):\r
+ parser = ErrorRaisingArgumentParser(prog='PROG')\r
+ group = parser.add_mutually_exclusive_group(required=required)\r
+ group.add_argument('--foo', action='store_true', help='FOO')\r
+ group.add_argument('--spam', help='SPAM')\r
+ group.add_argument('badger', nargs='*', default='X', help='BADGER')\r
+ return parser\r
+\r
+ failures = [\r
+ '--foo --spam S',\r
+ '--spam S X',\r
+ 'X --foo',\r
+ 'X Y Z --spam S',\r
+ '--foo X Y',\r
+ ]\r
+ successes = [\r
+ ('--foo', NS(foo=True, spam=None, badger='X')),\r
+ ('--spam S', NS(foo=False, spam='S', badger='X')),\r
+ ('X', NS(foo=False, spam=None, badger=['X'])),\r
+ ('X Y Z', NS(foo=False, spam=None, badger=['X', 'Y', 'Z'])),\r
+ ]\r
+ successes_when_not_required = [\r
+ ('', NS(foo=False, spam=None, badger='X')),\r
+ ]\r
+\r
+ usage_when_not_required = '''\\r
+ usage: PROG [-h] [--foo | --spam SPAM | badger [badger ...]]\r
+ '''\r
+ usage_when_required = '''\\r
+ usage: PROG [-h] (--foo | --spam SPAM | badger [badger ...])\r
+ '''\r
+ help = '''\\r
+\r
+ positional arguments:\r
+ badger BADGER\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ --foo FOO\r
+ --spam SPAM SPAM\r
+ '''\r
+\r
+\r
+class TestMutuallyExclusiveOptionalsMixed(MEMixin, TestCase):\r
+\r
+ def get_parser(self, required):\r
+ parser = ErrorRaisingArgumentParser(prog='PROG')\r
+ parser.add_argument('-x', action='store_true', help='x help')\r
+ group = parser.add_mutually_exclusive_group(required=required)\r
+ group.add_argument('-a', action='store_true', help='a help')\r
+ group.add_argument('-b', action='store_true', help='b help')\r
+ parser.add_argument('-y', action='store_true', help='y help')\r
+ group.add_argument('-c', action='store_true', help='c help')\r
+ return parser\r
+\r
+ failures = ['-a -b', '-b -c', '-a -c', '-a -b -c']\r
+ successes = [\r
+ ('-a', NS(a=True, b=False, c=False, x=False, y=False)),\r
+ ('-b', NS(a=False, b=True, c=False, x=False, y=False)),\r
+ ('-c', NS(a=False, b=False, c=True, x=False, y=False)),\r
+ ('-a -x', NS(a=True, b=False, c=False, x=True, y=False)),\r
+ ('-y -b', NS(a=False, b=True, c=False, x=False, y=True)),\r
+ ('-x -y -c', NS(a=False, b=False, c=True, x=True, y=True)),\r
+ ]\r
+ successes_when_not_required = [\r
+ ('', NS(a=False, b=False, c=False, x=False, y=False)),\r
+ ('-x', NS(a=False, b=False, c=False, x=True, y=False)),\r
+ ('-y', NS(a=False, b=False, c=False, x=False, y=True)),\r
+ ]\r
+\r
+ usage_when_required = usage_when_not_required = '''\\r
+ usage: PROG [-h] [-x] [-a] [-b] [-y] [-c]\r
+ '''\r
+ help = '''\\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ -x x help\r
+ -a a help\r
+ -b b help\r
+ -y y help\r
+ -c c help\r
+ '''\r
+\r
+\r
+class TestMutuallyExclusiveOptionalsAndPositionalsMixed(MEMixin, TestCase):\r
+\r
+ def get_parser(self, required):\r
+ parser = ErrorRaisingArgumentParser(prog='PROG')\r
+ parser.add_argument('x', help='x help')\r
+ parser.add_argument('-y', action='store_true', help='y help')\r
+ group = parser.add_mutually_exclusive_group(required=required)\r
+ group.add_argument('a', nargs='?', help='a help')\r
+ group.add_argument('-b', action='store_true', help='b help')\r
+ group.add_argument('-c', action='store_true', help='c help')\r
+ return parser\r
+\r
+ failures = ['X A -b', '-b -c', '-c X A']\r
+ successes = [\r
+ ('X A', NS(a='A', b=False, c=False, x='X', y=False)),\r
+ ('X -b', NS(a=None, b=True, c=False, x='X', y=False)),\r
+ ('X -c', NS(a=None, b=False, c=True, x='X', y=False)),\r
+ ('X A -y', NS(a='A', b=False, c=False, x='X', y=True)),\r
+ ('X -y -b', NS(a=None, b=True, c=False, x='X', y=True)),\r
+ ]\r
+ successes_when_not_required = [\r
+ ('X', NS(a=None, b=False, c=False, x='X', y=False)),\r
+ ('X -y', NS(a=None, b=False, c=False, x='X', y=True)),\r
+ ]\r
+\r
+ usage_when_required = usage_when_not_required = '''\\r
+ usage: PROG [-h] [-y] [-b] [-c] x [a]\r
+ '''\r
+ help = '''\\r
+\r
+ positional arguments:\r
+ x x help\r
+ a a help\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ -y y help\r
+ -b b help\r
+ -c c help\r
+ '''\r
+\r
+# =================================================\r
+# Mutually exclusive group in parent parser tests\r
+# =================================================\r
+\r
+class MEPBase(object):\r
+\r
+ def get_parser(self, required=None):\r
+ parent = super(MEPBase, self).get_parser(required=required)\r
+ parser = ErrorRaisingArgumentParser(\r
+ prog=parent.prog, add_help=False, parents=[parent])\r
+ return parser\r
+\r
+\r
+class TestMutuallyExclusiveGroupErrorsParent(\r
+ MEPBase, TestMutuallyExclusiveGroupErrors):\r
+ pass\r
+\r
+\r
+class TestMutuallyExclusiveSimpleParent(\r
+ MEPBase, TestMutuallyExclusiveSimple):\r
+ pass\r
+\r
+\r
+class TestMutuallyExclusiveLongParent(\r
+ MEPBase, TestMutuallyExclusiveLong):\r
+ pass\r
+\r
+\r
+class TestMutuallyExclusiveFirstSuppressedParent(\r
+ MEPBase, TestMutuallyExclusiveFirstSuppressed):\r
+ pass\r
+\r
+\r
+class TestMutuallyExclusiveManySuppressedParent(\r
+ MEPBase, TestMutuallyExclusiveManySuppressed):\r
+ pass\r
+\r
+\r
+class TestMutuallyExclusiveOptionalAndPositionalParent(\r
+ MEPBase, TestMutuallyExclusiveOptionalAndPositional):\r
+ pass\r
+\r
+\r
+class TestMutuallyExclusiveOptionalsMixedParent(\r
+ MEPBase, TestMutuallyExclusiveOptionalsMixed):\r
+ pass\r
+\r
+\r
+class TestMutuallyExclusiveOptionalsAndPositionalsMixedParent(\r
+ MEPBase, TestMutuallyExclusiveOptionalsAndPositionalsMixed):\r
+ pass\r
+\r
+# =================\r
+# Set default tests\r
+# =================\r
+\r
+class TestSetDefaults(TestCase):\r
+\r
+ def test_set_defaults_no_args(self):\r
+ parser = ErrorRaisingArgumentParser()\r
+ parser.set_defaults(x='foo')\r
+ parser.set_defaults(y='bar', z=1)\r
+ self.assertEqual(NS(x='foo', y='bar', z=1),\r
+ parser.parse_args([]))\r
+ self.assertEqual(NS(x='foo', y='bar', z=1),\r
+ parser.parse_args([], NS()))\r
+ self.assertEqual(NS(x='baz', y='bar', z=1),\r
+ parser.parse_args([], NS(x='baz')))\r
+ self.assertEqual(NS(x='baz', y='bar', z=2),\r
+ parser.parse_args([], NS(x='baz', z=2)))\r
+\r
+ def test_set_defaults_with_args(self):\r
+ parser = ErrorRaisingArgumentParser()\r
+ parser.set_defaults(x='foo', y='bar')\r
+ parser.add_argument('-x', default='xfoox')\r
+ self.assertEqual(NS(x='xfoox', y='bar'),\r
+ parser.parse_args([]))\r
+ self.assertEqual(NS(x='xfoox', y='bar'),\r
+ parser.parse_args([], NS()))\r
+ self.assertEqual(NS(x='baz', y='bar'),\r
+ parser.parse_args([], NS(x='baz')))\r
+ self.assertEqual(NS(x='1', y='bar'),\r
+ parser.parse_args('-x 1'.split()))\r
+ self.assertEqual(NS(x='1', y='bar'),\r
+ parser.parse_args('-x 1'.split(), NS()))\r
+ self.assertEqual(NS(x='1', y='bar'),\r
+ parser.parse_args('-x 1'.split(), NS(x='baz')))\r
+\r
+ def test_set_defaults_subparsers(self):\r
+ parser = ErrorRaisingArgumentParser()\r
+ parser.set_defaults(x='foo')\r
+ subparsers = parser.add_subparsers()\r
+ parser_a = subparsers.add_parser('a')\r
+ parser_a.set_defaults(y='bar')\r
+ self.assertEqual(NS(x='foo', y='bar'),\r
+ parser.parse_args('a'.split()))\r
+\r
+ def test_set_defaults_parents(self):\r
+ parent = ErrorRaisingArgumentParser(add_help=False)\r
+ parent.set_defaults(x='foo')\r
+ parser = ErrorRaisingArgumentParser(parents=[parent])\r
+ self.assertEqual(NS(x='foo'), parser.parse_args([]))\r
+\r
+ def test_set_defaults_same_as_add_argument(self):\r
+ parser = ErrorRaisingArgumentParser()\r
+ parser.set_defaults(w='W', x='X', y='Y', z='Z')\r
+ parser.add_argument('-w')\r
+ parser.add_argument('-x', default='XX')\r
+ parser.add_argument('y', nargs='?')\r
+ parser.add_argument('z', nargs='?', default='ZZ')\r
+\r
+ # defaults set previously\r
+ self.assertEqual(NS(w='W', x='XX', y='Y', z='ZZ'),\r
+ parser.parse_args([]))\r
+\r
+ # reset defaults\r
+ parser.set_defaults(w='WW', x='X', y='YY', z='Z')\r
+ self.assertEqual(NS(w='WW', x='X', y='YY', z='Z'),\r
+ parser.parse_args([]))\r
+\r
+ def test_set_defaults_same_as_add_argument_group(self):\r
+ parser = ErrorRaisingArgumentParser()\r
+ parser.set_defaults(w='W', x='X', y='Y', z='Z')\r
+ group = parser.add_argument_group('foo')\r
+ group.add_argument('-w')\r
+ group.add_argument('-x', default='XX')\r
+ group.add_argument('y', nargs='?')\r
+ group.add_argument('z', nargs='?', default='ZZ')\r
+\r
+\r
+ # defaults set previously\r
+ self.assertEqual(NS(w='W', x='XX', y='Y', z='ZZ'),\r
+ parser.parse_args([]))\r
+\r
+ # reset defaults\r
+ parser.set_defaults(w='WW', x='X', y='YY', z='Z')\r
+ self.assertEqual(NS(w='WW', x='X', y='YY', z='Z'),\r
+ parser.parse_args([]))\r
+\r
+# =================\r
+# Get default tests\r
+# =================\r
+\r
+class TestGetDefault(TestCase):\r
+\r
+ def test_get_default(self):\r
+ parser = ErrorRaisingArgumentParser()\r
+ self.assertEqual(None, parser.get_default("foo"))\r
+ self.assertEqual(None, parser.get_default("bar"))\r
+\r
+ parser.add_argument("--foo")\r
+ self.assertEqual(None, parser.get_default("foo"))\r
+ self.assertEqual(None, parser.get_default("bar"))\r
+\r
+ parser.add_argument("--bar", type=int, default=42)\r
+ self.assertEqual(None, parser.get_default("foo"))\r
+ self.assertEqual(42, parser.get_default("bar"))\r
+\r
+ parser.set_defaults(foo="badger")\r
+ self.assertEqual("badger", parser.get_default("foo"))\r
+ self.assertEqual(42, parser.get_default("bar"))\r
+\r
+# ==========================\r
+# Namespace 'contains' tests\r
+# ==========================\r
+\r
+class TestNamespaceContainsSimple(TestCase):\r
+\r
+ def test_empty(self):\r
+ ns = argparse.Namespace()\r
+ self.assertEquals('' in ns, False)\r
+ self.assertEquals('' not in ns, True)\r
+ self.assertEquals('x' in ns, False)\r
+\r
+ def test_non_empty(self):\r
+ ns = argparse.Namespace(x=1, y=2)\r
+ self.assertEquals('x' in ns, True)\r
+ self.assertEquals('x' not in ns, False)\r
+ self.assertEquals('y' in ns, True)\r
+ self.assertEquals('' in ns, False)\r
+ self.assertEquals('xx' in ns, False)\r
+ self.assertEquals('z' in ns, False)\r
+\r
+# =====================\r
+# Help formatting tests\r
+# =====================\r
+\r
+class TestHelpFormattingMetaclass(type):\r
+\r
+ def __init__(cls, name, bases, bodydict):\r
+ if name == 'HelpTestCase':\r
+ return\r
+\r
+ class AddTests(object):\r
+\r
+ def __init__(self, test_class, func_suffix, std_name):\r
+ self.func_suffix = func_suffix\r
+ self.std_name = std_name\r
+\r
+ for test_func in [self.test_format,\r
+ self.test_print,\r
+ self.test_print_file]:\r
+ test_name = '%s_%s' % (test_func.__name__, func_suffix)\r
+\r
+ def test_wrapper(self, test_func=test_func):\r
+ test_func(self)\r
+ try:\r
+ test_wrapper.__name__ = test_name\r
+ except TypeError:\r
+ pass\r
+ setattr(test_class, test_name, test_wrapper)\r
+\r
+ def _get_parser(self, tester):\r
+ parser = argparse.ArgumentParser(\r
+ *tester.parser_signature.args,\r
+ **tester.parser_signature.kwargs)\r
+ for argument_sig in tester.argument_signatures:\r
+ parser.add_argument(*argument_sig.args,\r
+ **argument_sig.kwargs)\r
+ group_signatures = tester.argument_group_signatures\r
+ for group_sig, argument_sigs in group_signatures:\r
+ group = parser.add_argument_group(*group_sig.args,\r
+ **group_sig.kwargs)\r
+ for argument_sig in argument_sigs:\r
+ group.add_argument(*argument_sig.args,\r
+ **argument_sig.kwargs)\r
+ return parser\r
+\r
+ def _test(self, tester, parser_text):\r
+ expected_text = getattr(tester, self.func_suffix)\r
+ expected_text = textwrap.dedent(expected_text)\r
+ if expected_text != parser_text:\r
+ print(repr(expected_text))\r
+ print(repr(parser_text))\r
+ for char1, char2 in zip(expected_text, parser_text):\r
+ if char1 != char2:\r
+ print('first diff: %r %r' % (char1, char2))\r
+ break\r
+ tester.assertEqual(expected_text, parser_text)\r
+\r
+ def test_format(self, tester):\r
+ parser = self._get_parser(tester)\r
+ format = getattr(parser, 'format_%s' % self.func_suffix)\r
+ self._test(tester, format())\r
+\r
+ def test_print(self, tester):\r
+ parser = self._get_parser(tester)\r
+ print_ = getattr(parser, 'print_%s' % self.func_suffix)\r
+ old_stream = getattr(sys, self.std_name)\r
+ setattr(sys, self.std_name, StringIO())\r
+ try:\r
+ print_()\r
+ parser_text = getattr(sys, self.std_name).getvalue()\r
+ finally:\r
+ setattr(sys, self.std_name, old_stream)\r
+ self._test(tester, parser_text)\r
+\r
+ def test_print_file(self, tester):\r
+ parser = self._get_parser(tester)\r
+ print_ = getattr(parser, 'print_%s' % self.func_suffix)\r
+ sfile = StringIO()\r
+ print_(sfile)\r
+ parser_text = sfile.getvalue()\r
+ self._test(tester, parser_text)\r
+\r
+ # add tests for {format,print}_{usage,help,version}\r
+ for func_suffix, std_name in [('usage', 'stdout'),\r
+ ('help', 'stdout'),\r
+ ('version', 'stderr')]:\r
+ AddTests(cls, func_suffix, std_name)\r
+\r
+bases = TestCase,\r
+HelpTestCase = TestHelpFormattingMetaclass('HelpTestCase', bases, {})\r
+\r
+\r
+class TestHelpBiggerOptionals(HelpTestCase):\r
+ """Make sure that argument help aligns when options are longer"""\r
+\r
+ parser_signature = Sig(prog='PROG', description='DESCRIPTION',\r
+ epilog='EPILOG', version='0.1')\r
+ argument_signatures = [\r
+ Sig('-x', action='store_true', help='X HELP'),\r
+ Sig('--y', help='Y HELP'),\r
+ Sig('foo', help='FOO HELP'),\r
+ Sig('bar', help='BAR HELP'),\r
+ ]\r
+ argument_group_signatures = []\r
+ usage = '''\\r
+ usage: PROG [-h] [-v] [-x] [--y Y] foo bar\r
+ '''\r
+ help = usage + '''\\r
+\r
+ DESCRIPTION\r
+\r
+ positional arguments:\r
+ foo FOO HELP\r
+ bar BAR HELP\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ -v, --version show program's version number and exit\r
+ -x X HELP\r
+ --y Y Y HELP\r
+\r
+ EPILOG\r
+ '''\r
+ version = '''\\r
+ 0.1\r
+ '''\r
+\r
+\r
+class TestHelpBiggerOptionalGroups(HelpTestCase):\r
+ """Make sure that argument help aligns when options are longer"""\r
+\r
+ parser_signature = Sig(prog='PROG', description='DESCRIPTION',\r
+ epilog='EPILOG', version='0.1')\r
+ argument_signatures = [\r
+ Sig('-x', action='store_true', help='X HELP'),\r
+ Sig('--y', help='Y HELP'),\r
+ Sig('foo', help='FOO HELP'),\r
+ Sig('bar', help='BAR HELP'),\r
+ ]\r
+ argument_group_signatures = [\r
+ (Sig('GROUP TITLE', description='GROUP DESCRIPTION'), [\r
+ Sig('baz', help='BAZ HELP'),\r
+ Sig('-z', nargs='+', help='Z HELP')]),\r
+ ]\r
+ usage = '''\\r
+ usage: PROG [-h] [-v] [-x] [--y Y] [-z Z [Z ...]] foo bar baz\r
+ '''\r
+ help = usage + '''\\r
+\r
+ DESCRIPTION\r
+\r
+ positional arguments:\r
+ foo FOO HELP\r
+ bar BAR HELP\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ -v, --version show program's version number and exit\r
+ -x X HELP\r
+ --y Y Y HELP\r
+\r
+ GROUP TITLE:\r
+ GROUP DESCRIPTION\r
+\r
+ baz BAZ HELP\r
+ -z Z [Z ...] Z HELP\r
+\r
+ EPILOG\r
+ '''\r
+ version = '''\\r
+ 0.1\r
+ '''\r
+\r
+\r
+class TestHelpBiggerPositionals(HelpTestCase):\r
+ """Make sure that help aligns when arguments are longer"""\r
+\r
+ parser_signature = Sig(usage='USAGE', description='DESCRIPTION')\r
+ argument_signatures = [\r
+ Sig('-x', action='store_true', help='X HELP'),\r
+ Sig('--y', help='Y HELP'),\r
+ Sig('ekiekiekifekang', help='EKI HELP'),\r
+ Sig('bar', help='BAR HELP'),\r
+ ]\r
+ argument_group_signatures = []\r
+ usage = '''\\r
+ usage: USAGE\r
+ '''\r
+ help = usage + '''\\r
+\r
+ DESCRIPTION\r
+\r
+ positional arguments:\r
+ ekiekiekifekang EKI HELP\r
+ bar BAR HELP\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ -x X HELP\r
+ --y Y Y HELP\r
+ '''\r
+\r
+ version = ''\r
+\r
+\r
+class TestHelpReformatting(HelpTestCase):\r
+ """Make sure that text after short names starts on the first line"""\r
+\r
+ parser_signature = Sig(\r
+ prog='PROG',\r
+ description=' oddly formatted\n'\r
+ 'description\n'\r
+ '\n'\r
+ 'that is so long that it should go onto multiple '\r
+ 'lines when wrapped')\r
+ argument_signatures = [\r
+ Sig('-x', metavar='XX', help='oddly\n'\r
+ ' formatted -x help'),\r
+ Sig('y', metavar='yyy', help='normal y help'),\r
+ ]\r
+ argument_group_signatures = [\r
+ (Sig('title', description='\n'\r
+ ' oddly formatted group\n'\r
+ '\n'\r
+ 'description'),\r
+ [Sig('-a', action='store_true',\r
+ help=' oddly \n'\r
+ 'formatted -a help \n'\r
+ ' again, so long that it should be wrapped over '\r
+ 'multiple lines')]),\r
+ ]\r
+ usage = '''\\r
+ usage: PROG [-h] [-x XX] [-a] yyy\r
+ '''\r
+ help = usage + '''\\r
+\r
+ oddly formatted description that is so long that it should go onto \\r
+multiple\r
+ lines when wrapped\r
+\r
+ positional arguments:\r
+ yyy normal y help\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ -x XX oddly formatted -x help\r
+\r
+ title:\r
+ oddly formatted group description\r
+\r
+ -a oddly formatted -a help again, so long that it should \\r
+be wrapped\r
+ over multiple lines\r
+ '''\r
+ version = ''\r
+\r
+\r
+class TestHelpWrappingShortNames(HelpTestCase):\r
+ """Make sure that text after short names starts on the first line"""\r
+\r
+ parser_signature = Sig(prog='PROG', description= 'D\nD' * 30)\r
+ argument_signatures = [\r
+ Sig('-x', metavar='XX', help='XHH HX' * 20),\r
+ Sig('y', metavar='yyy', help='YH YH' * 20),\r
+ ]\r
+ argument_group_signatures = [\r
+ (Sig('ALPHAS'), [\r
+ Sig('-a', action='store_true', help='AHHH HHA' * 10)]),\r
+ ]\r
+ usage = '''\\r
+ usage: PROG [-h] [-x XX] [-a] yyy\r
+ '''\r
+ help = usage + '''\\r
+\r
+ D DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD \\r
+DD DD DD\r
+ DD DD DD DD D\r
+\r
+ positional arguments:\r
+ yyy YH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH \\r
+YHYH YHYH\r
+ YHYH YHYH YHYH YHYH YHYH YHYH YHYH YH\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ -x XX XHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH \\r
+HXXHH HXXHH\r
+ HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HX\r
+\r
+ ALPHAS:\r
+ -a AHHH HHAAHHH HHAAHHH HHAAHHH HHAAHHH HHAAHHH HHAAHHH \\r
+HHAAHHH\r
+ HHAAHHH HHAAHHH HHA\r
+ '''\r
+ version = ''\r
+\r
+\r
+class TestHelpWrappingLongNames(HelpTestCase):\r
+ """Make sure that text after long names starts on the next line"""\r
+\r
+ parser_signature = Sig(usage='USAGE', description= 'D D' * 30,\r
+ version='V V'*30)\r
+ argument_signatures = [\r
+ Sig('-x', metavar='X' * 25, help='XH XH' * 20),\r
+ Sig('y', metavar='y' * 25, help='YH YH' * 20),\r
+ ]\r
+ argument_group_signatures = [\r
+ (Sig('ALPHAS'), [\r
+ Sig('-a', metavar='A' * 25, help='AH AH' * 20),\r
+ Sig('z', metavar='z' * 25, help='ZH ZH' * 20)]),\r
+ ]\r
+ usage = '''\\r
+ usage: USAGE\r
+ '''\r
+ help = usage + '''\\r
+\r
+ D DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD \\r
+DD DD DD\r
+ DD DD DD DD D\r
+\r
+ positional arguments:\r
+ yyyyyyyyyyyyyyyyyyyyyyyyy\r
+ YH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH \\r
+YHYH YHYH\r
+ YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YH\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ -v, --version show program's version number and exit\r
+ -x XXXXXXXXXXXXXXXXXXXXXXXXX\r
+ XH XHXH XHXH XHXH XHXH XHXH XHXH XHXH XHXH \\r
+XHXH XHXH\r
+ XHXH XHXH XHXH XHXH XHXH XHXH XHXH XHXH XHXH XH\r
+\r
+ ALPHAS:\r
+ -a AAAAAAAAAAAAAAAAAAAAAAAAA\r
+ AH AHAH AHAH AHAH AHAH AHAH AHAH AHAH AHAH \\r
+AHAH AHAH\r
+ AHAH AHAH AHAH AHAH AHAH AHAH AHAH AHAH AHAH AH\r
+ zzzzzzzzzzzzzzzzzzzzzzzzz\r
+ ZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH \\r
+ZHZH ZHZH\r
+ ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZH\r
+ '''\r
+ version = '''\\r
+ V VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV \\r
+VV VV VV\r
+ VV VV VV VV V\r
+ '''\r
+\r
+\r
+class TestHelpUsage(HelpTestCase):\r
+ """Test basic usage messages"""\r
+\r
+ parser_signature = Sig(prog='PROG')\r
+ argument_signatures = [\r
+ Sig('-w', nargs='+', help='w'),\r
+ Sig('-x', nargs='*', help='x'),\r
+ Sig('a', help='a'),\r
+ Sig('b', help='b', nargs=2),\r
+ Sig('c', help='c', nargs='?'),\r
+ ]\r
+ argument_group_signatures = [\r
+ (Sig('group'), [\r
+ Sig('-y', nargs='?', help='y'),\r
+ Sig('-z', nargs=3, help='z'),\r
+ Sig('d', help='d', nargs='*'),\r
+ Sig('e', help='e', nargs='+'),\r
+ ])\r
+ ]\r
+ usage = '''\\r
+ usage: PROG [-h] [-w W [W ...]] [-x [X [X ...]]] [-y [Y]] [-z Z Z Z]\r
+ a b b [c] [d [d ...]] e [e ...]\r
+ '''\r
+ help = usage + '''\\r
+\r
+ positional arguments:\r
+ a a\r
+ b b\r
+ c c\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ -w W [W ...] w\r
+ -x [X [X ...]] x\r
+\r
+ group:\r
+ -y [Y] y\r
+ -z Z Z Z z\r
+ d d\r
+ e e\r
+ '''\r
+ version = ''\r
+\r
+\r
+class TestHelpOnlyUserGroups(HelpTestCase):\r
+ """Test basic usage messages"""\r
+\r
+ parser_signature = Sig(prog='PROG', add_help=False)\r
+ argument_signatures = []\r
+ argument_group_signatures = [\r
+ (Sig('xxxx'), [\r
+ Sig('-x', help='x'),\r
+ Sig('a', help='a'),\r
+ ]),\r
+ (Sig('yyyy'), [\r
+ Sig('b', help='b'),\r
+ Sig('-y', help='y'),\r
+ ]),\r
+ ]\r
+ usage = '''\\r
+ usage: PROG [-x X] [-y Y] a b\r
+ '''\r
+ help = usage + '''\\r
+\r
+ xxxx:\r
+ -x X x\r
+ a a\r
+\r
+ yyyy:\r
+ b b\r
+ -y Y y\r
+ '''\r
+ version = ''\r
+\r
+\r
+class TestHelpUsageLongProg(HelpTestCase):\r
+ """Test usage messages where the prog is long"""\r
+\r
+ parser_signature = Sig(prog='P' * 60)\r
+ argument_signatures = [\r
+ Sig('-w', metavar='W'),\r
+ Sig('-x', metavar='X'),\r
+ Sig('a'),\r
+ Sig('b'),\r
+ ]\r
+ argument_group_signatures = []\r
+ usage = '''\\r
+ usage: PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP\r
+ [-h] [-w W] [-x X] a b\r
+ '''\r
+ help = usage + '''\\r
+\r
+ positional arguments:\r
+ a\r
+ b\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ -w W\r
+ -x X\r
+ '''\r
+ version = ''\r
+\r
+\r
+class TestHelpUsageLongProgOptionsWrap(HelpTestCase):\r
+ """Test usage messages where the prog is long and the optionals wrap"""\r
+\r
+ parser_signature = Sig(prog='P' * 60)\r
+ argument_signatures = [\r
+ Sig('-w', metavar='W' * 25),\r
+ Sig('-x', metavar='X' * 25),\r
+ Sig('-y', metavar='Y' * 25),\r
+ Sig('-z', metavar='Z' * 25),\r
+ Sig('a'),\r
+ Sig('b'),\r
+ ]\r
+ argument_group_signatures = []\r
+ usage = '''\\r
+ usage: PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP\r
+ [-h] [-w WWWWWWWWWWWWWWWWWWWWWWWWW] \\r
+[-x XXXXXXXXXXXXXXXXXXXXXXXXX]\r
+ [-y YYYYYYYYYYYYYYYYYYYYYYYYY] [-z ZZZZZZZZZZZZZZZZZZZZZZZZZ]\r
+ a b\r
+ '''\r
+ help = usage + '''\\r
+\r
+ positional arguments:\r
+ a\r
+ b\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ -w WWWWWWWWWWWWWWWWWWWWWWWWW\r
+ -x XXXXXXXXXXXXXXXXXXXXXXXXX\r
+ -y YYYYYYYYYYYYYYYYYYYYYYYYY\r
+ -z ZZZZZZZZZZZZZZZZZZZZZZZZZ\r
+ '''\r
+ version = ''\r
+\r
+\r
+class TestHelpUsageLongProgPositionalsWrap(HelpTestCase):\r
+ """Test usage messages where the prog is long and the positionals wrap"""\r
+\r
+ parser_signature = Sig(prog='P' * 60, add_help=False)\r
+ argument_signatures = [\r
+ Sig('a' * 25),\r
+ Sig('b' * 25),\r
+ Sig('c' * 25),\r
+ ]\r
+ argument_group_signatures = []\r
+ usage = '''\\r
+ usage: PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP\r
+ aaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbb\r
+ ccccccccccccccccccccccccc\r
+ '''\r
+ help = usage + '''\\r
+\r
+ positional arguments:\r
+ aaaaaaaaaaaaaaaaaaaaaaaaa\r
+ bbbbbbbbbbbbbbbbbbbbbbbbb\r
+ ccccccccccccccccccccccccc\r
+ '''\r
+ version = ''\r
+\r
+\r
+class TestHelpUsageOptionalsWrap(HelpTestCase):\r
+ """Test usage messages where the optionals wrap"""\r
+\r
+ parser_signature = Sig(prog='PROG')\r
+ argument_signatures = [\r
+ Sig('-w', metavar='W' * 25),\r
+ Sig('-x', metavar='X' * 25),\r
+ Sig('-y', metavar='Y' * 25),\r
+ Sig('-z', metavar='Z' * 25),\r
+ Sig('a'),\r
+ Sig('b'),\r
+ Sig('c'),\r
+ ]\r
+ argument_group_signatures = []\r
+ usage = '''\\r
+ usage: PROG [-h] [-w WWWWWWWWWWWWWWWWWWWWWWWWW] \\r
+[-x XXXXXXXXXXXXXXXXXXXXXXXXX]\r
+ [-y YYYYYYYYYYYYYYYYYYYYYYYYY] \\r
+[-z ZZZZZZZZZZZZZZZZZZZZZZZZZ]\r
+ a b c\r
+ '''\r
+ help = usage + '''\\r
+\r
+ positional arguments:\r
+ a\r
+ b\r
+ c\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ -w WWWWWWWWWWWWWWWWWWWWWWWWW\r
+ -x XXXXXXXXXXXXXXXXXXXXXXXXX\r
+ -y YYYYYYYYYYYYYYYYYYYYYYYYY\r
+ -z ZZZZZZZZZZZZZZZZZZZZZZZZZ\r
+ '''\r
+ version = ''\r
+\r
+\r
+class TestHelpUsagePositionalsWrap(HelpTestCase):\r
+ """Test usage messages where the positionals wrap"""\r
+\r
+ parser_signature = Sig(prog='PROG')\r
+ argument_signatures = [\r
+ Sig('-x'),\r
+ Sig('-y'),\r
+ Sig('-z'),\r
+ Sig('a' * 25),\r
+ Sig('b' * 25),\r
+ Sig('c' * 25),\r
+ ]\r
+ argument_group_signatures = []\r
+ usage = '''\\r
+ usage: PROG [-h] [-x X] [-y Y] [-z Z]\r
+ aaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbb\r
+ ccccccccccccccccccccccccc\r
+ '''\r
+ help = usage + '''\\r
+\r
+ positional arguments:\r
+ aaaaaaaaaaaaaaaaaaaaaaaaa\r
+ bbbbbbbbbbbbbbbbbbbbbbbbb\r
+ ccccccccccccccccccccccccc\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ -x X\r
+ -y Y\r
+ -z Z\r
+ '''\r
+ version = ''\r
+\r
+\r
+class TestHelpUsageOptionalsPositionalsWrap(HelpTestCase):\r
+ """Test usage messages where the optionals and positionals wrap"""\r
+\r
+ parser_signature = Sig(prog='PROG')\r
+ argument_signatures = [\r
+ Sig('-x', metavar='X' * 25),\r
+ Sig('-y', metavar='Y' * 25),\r
+ Sig('-z', metavar='Z' * 25),\r
+ Sig('a' * 25),\r
+ Sig('b' * 25),\r
+ Sig('c' * 25),\r
+ ]\r
+ argument_group_signatures = []\r
+ usage = '''\\r
+ usage: PROG [-h] [-x XXXXXXXXXXXXXXXXXXXXXXXXX] \\r
+[-y YYYYYYYYYYYYYYYYYYYYYYYYY]\r
+ [-z ZZZZZZZZZZZZZZZZZZZZZZZZZ]\r
+ aaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbb\r
+ ccccccccccccccccccccccccc\r
+ '''\r
+ help = usage + '''\\r
+\r
+ positional arguments:\r
+ aaaaaaaaaaaaaaaaaaaaaaaaa\r
+ bbbbbbbbbbbbbbbbbbbbbbbbb\r
+ ccccccccccccccccccccccccc\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ -x XXXXXXXXXXXXXXXXXXXXXXXXX\r
+ -y YYYYYYYYYYYYYYYYYYYYYYYYY\r
+ -z ZZZZZZZZZZZZZZZZZZZZZZZZZ\r
+ '''\r
+ version = ''\r
+\r
+\r
+class TestHelpUsageOptionalsOnlyWrap(HelpTestCase):\r
+ """Test usage messages where there are only optionals and they wrap"""\r
+\r
+ parser_signature = Sig(prog='PROG')\r
+ argument_signatures = [\r
+ Sig('-x', metavar='X' * 25),\r
+ Sig('-y', metavar='Y' * 25),\r
+ Sig('-z', metavar='Z' * 25),\r
+ ]\r
+ argument_group_signatures = []\r
+ usage = '''\\r
+ usage: PROG [-h] [-x XXXXXXXXXXXXXXXXXXXXXXXXX] \\r
+[-y YYYYYYYYYYYYYYYYYYYYYYYYY]\r
+ [-z ZZZZZZZZZZZZZZZZZZZZZZZZZ]\r
+ '''\r
+ help = usage + '''\\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ -x XXXXXXXXXXXXXXXXXXXXXXXXX\r
+ -y YYYYYYYYYYYYYYYYYYYYYYYYY\r
+ -z ZZZZZZZZZZZZZZZZZZZZZZZZZ\r
+ '''\r
+ version = ''\r
+\r
+\r
+class TestHelpUsagePositionalsOnlyWrap(HelpTestCase):\r
+ """Test usage messages where there are only positionals and they wrap"""\r
+\r
+ parser_signature = Sig(prog='PROG', add_help=False)\r
+ argument_signatures = [\r
+ Sig('a' * 25),\r
+ Sig('b' * 25),\r
+ Sig('c' * 25),\r
+ ]\r
+ argument_group_signatures = []\r
+ usage = '''\\r
+ usage: PROG aaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbb\r
+ ccccccccccccccccccccccccc\r
+ '''\r
+ help = usage + '''\\r
+\r
+ positional arguments:\r
+ aaaaaaaaaaaaaaaaaaaaaaaaa\r
+ bbbbbbbbbbbbbbbbbbbbbbbbb\r
+ ccccccccccccccccccccccccc\r
+ '''\r
+ version = ''\r
+\r
+\r
+class TestHelpVariableExpansion(HelpTestCase):\r
+ """Test that variables are expanded properly in help messages"""\r
+\r
+ parser_signature = Sig(prog='PROG')\r
+ argument_signatures = [\r
+ Sig('-x', type=int,\r
+ help='x %(prog)s %(default)s %(type)s %%'),\r
+ Sig('-y', action='store_const', default=42, const='XXX',\r
+ help='y %(prog)s %(default)s %(const)s'),\r
+ Sig('--foo', choices='abc',\r
+ help='foo %(prog)s %(default)s %(choices)s'),\r
+ Sig('--bar', default='baz', choices=[1, 2], metavar='BBB',\r
+ help='bar %(prog)s %(default)s %(dest)s'),\r
+ Sig('spam', help='spam %(prog)s %(default)s'),\r
+ Sig('badger', default=0.5, help='badger %(prog)s %(default)s'),\r
+ ]\r
+ argument_group_signatures = [\r
+ (Sig('group'), [\r
+ Sig('-a', help='a %(prog)s %(default)s'),\r
+ Sig('-b', default=-1, help='b %(prog)s %(default)s'),\r
+ ])\r
+ ]\r
+ usage = ('''\\r
+ usage: PROG [-h] [-x X] [-y] [--foo {a,b,c}] [--bar BBB] [-a A] [-b B]\r
+ spam badger\r
+ ''')\r
+ help = usage + '''\\r
+\r
+ positional arguments:\r
+ spam spam PROG None\r
+ badger badger PROG 0.5\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ -x X x PROG None int %\r
+ -y y PROG 42 XXX\r
+ --foo {a,b,c} foo PROG None a, b, c\r
+ --bar BBB bar PROG baz bar\r
+\r
+ group:\r
+ -a A a PROG None\r
+ -b B b PROG -1\r
+ '''\r
+ version = ''\r
+\r
+\r
+class TestHelpVariableExpansionUsageSupplied(HelpTestCase):\r
+ """Test that variables are expanded properly when usage= is present"""\r
+\r
+ parser_signature = Sig(prog='PROG', usage='%(prog)s FOO')\r
+ argument_signatures = []\r
+ argument_group_signatures = []\r
+ usage = ('''\\r
+ usage: PROG FOO\r
+ ''')\r
+ help = usage + '''\\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ '''\r
+ version = ''\r
+\r
+\r
+class TestHelpVariableExpansionNoArguments(HelpTestCase):\r
+ """Test that variables are expanded properly with no arguments"""\r
+\r
+ parser_signature = Sig(prog='PROG', add_help=False)\r
+ argument_signatures = []\r
+ argument_group_signatures = []\r
+ usage = ('''\\r
+ usage: PROG\r
+ ''')\r
+ help = usage\r
+ version = ''\r
+\r
+\r
+class TestHelpSuppressUsage(HelpTestCase):\r
+ """Test that items can be suppressed in usage messages"""\r
+\r
+ parser_signature = Sig(prog='PROG', usage=argparse.SUPPRESS)\r
+ argument_signatures = [\r
+ Sig('--foo', help='foo help'),\r
+ Sig('spam', help='spam help'),\r
+ ]\r
+ argument_group_signatures = []\r
+ help = '''\\r
+ positional arguments:\r
+ spam spam help\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ --foo FOO foo help\r
+ '''\r
+ usage = ''\r
+ version = ''\r
+\r
+\r
+class TestHelpSuppressOptional(HelpTestCase):\r
+ """Test that optional arguments can be suppressed in help messages"""\r
+\r
+ parser_signature = Sig(prog='PROG', add_help=False)\r
+ argument_signatures = [\r
+ Sig('--foo', help=argparse.SUPPRESS),\r
+ Sig('spam', help='spam help'),\r
+ ]\r
+ argument_group_signatures = []\r
+ usage = '''\\r
+ usage: PROG spam\r
+ '''\r
+ help = usage + '''\\r
+\r
+ positional arguments:\r
+ spam spam help\r
+ '''\r
+ version = ''\r
+\r
+\r
+class TestHelpSuppressOptionalGroup(HelpTestCase):\r
+ """Test that optional groups can be suppressed in help messages"""\r
+\r
+ parser_signature = Sig(prog='PROG')\r
+ argument_signatures = [\r
+ Sig('--foo', help='foo help'),\r
+ Sig('spam', help='spam help'),\r
+ ]\r
+ argument_group_signatures = [\r
+ (Sig('group'), [Sig('--bar', help=argparse.SUPPRESS)]),\r
+ ]\r
+ usage = '''\\r
+ usage: PROG [-h] [--foo FOO] spam\r
+ '''\r
+ help = usage + '''\\r
+\r
+ positional arguments:\r
+ spam spam help\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ --foo FOO foo help\r
+ '''\r
+ version = ''\r
+\r
+\r
+class TestHelpSuppressPositional(HelpTestCase):\r
+ """Test that positional arguments can be suppressed in help messages"""\r
+\r
+ parser_signature = Sig(prog='PROG')\r
+ argument_signatures = [\r
+ Sig('--foo', help='foo help'),\r
+ Sig('spam', help=argparse.SUPPRESS),\r
+ ]\r
+ argument_group_signatures = []\r
+ usage = '''\\r
+ usage: PROG [-h] [--foo FOO]\r
+ '''\r
+ help = usage + '''\\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ --foo FOO foo help\r
+ '''\r
+ version = ''\r
+\r
+\r
+class TestHelpRequiredOptional(HelpTestCase):\r
+ """Test that required options don't look optional"""\r
+\r
+ parser_signature = Sig(prog='PROG')\r
+ argument_signatures = [\r
+ Sig('--foo', required=True, help='foo help'),\r
+ ]\r
+ argument_group_signatures = []\r
+ usage = '''\\r
+ usage: PROG [-h] --foo FOO\r
+ '''\r
+ help = usage + '''\\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ --foo FOO foo help\r
+ '''\r
+ version = ''\r
+\r
+\r
+class TestHelpAlternatePrefixChars(HelpTestCase):\r
+ """Test that options display with different prefix characters"""\r
+\r
+ parser_signature = Sig(prog='PROG', prefix_chars='^;', add_help=False)\r
+ argument_signatures = [\r
+ Sig('^^foo', action='store_true', help='foo help'),\r
+ Sig(';b', ';;bar', help='bar help'),\r
+ ]\r
+ argument_group_signatures = []\r
+ usage = '''\\r
+ usage: PROG [^^foo] [;b BAR]\r
+ '''\r
+ help = usage + '''\\r
+\r
+ optional arguments:\r
+ ^^foo foo help\r
+ ;b BAR, ;;bar BAR bar help\r
+ '''\r
+ version = ''\r
+\r
+\r
+class TestHelpNoHelpOptional(HelpTestCase):\r
+ """Test that the --help argument can be suppressed help messages"""\r
+\r
+ parser_signature = Sig(prog='PROG', add_help=False)\r
+ argument_signatures = [\r
+ Sig('--foo', help='foo help'),\r
+ Sig('spam', help='spam help'),\r
+ ]\r
+ argument_group_signatures = []\r
+ usage = '''\\r
+ usage: PROG [--foo FOO] spam\r
+ '''\r
+ help = usage + '''\\r
+\r
+ positional arguments:\r
+ spam spam help\r
+\r
+ optional arguments:\r
+ --foo FOO foo help\r
+ '''\r
+ version = ''\r
+\r
+\r
+class TestHelpVersionOptional(HelpTestCase):\r
+ """Test that the --version argument can be suppressed help messages"""\r
+\r
+ parser_signature = Sig(prog='PROG', version='1.0')\r
+ argument_signatures = [\r
+ Sig('--foo', help='foo help'),\r
+ Sig('spam', help='spam help'),\r
+ ]\r
+ argument_group_signatures = []\r
+ usage = '''\\r
+ usage: PROG [-h] [-v] [--foo FOO] spam\r
+ '''\r
+ help = usage + '''\\r
+\r
+ positional arguments:\r
+ spam spam help\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ -v, --version show program's version number and exit\r
+ --foo FOO foo help\r
+ '''\r
+ version = '''\\r
+ 1.0\r
+ '''\r
+\r
+\r
+class TestHelpNone(HelpTestCase):\r
+ """Test that no errors occur if no help is specified"""\r
+\r
+ parser_signature = Sig(prog='PROG')\r
+ argument_signatures = [\r
+ Sig('--foo'),\r
+ Sig('spam'),\r
+ ]\r
+ argument_group_signatures = []\r
+ usage = '''\\r
+ usage: PROG [-h] [--foo FOO] spam\r
+ '''\r
+ help = usage + '''\\r
+\r
+ positional arguments:\r
+ spam\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ --foo FOO\r
+ '''\r
+ version = ''\r
+\r
+\r
+class TestHelpTupleMetavar(HelpTestCase):\r
+ """Test specifying metavar as a tuple"""\r
+\r
+ parser_signature = Sig(prog='PROG')\r
+ argument_signatures = [\r
+ Sig('-w', help='w', nargs='+', metavar=('W1', 'W2')),\r
+ Sig('-x', help='x', nargs='*', metavar=('X1', 'X2')),\r
+ Sig('-y', help='y', nargs=3, metavar=('Y1', 'Y2', 'Y3')),\r
+ Sig('-z', help='z', nargs='?', metavar=('Z1', )),\r
+ ]\r
+ argument_group_signatures = []\r
+ usage = '''\\r
+ usage: PROG [-h] [-w W1 [W2 ...]] [-x [X1 [X2 ...]]] [-y Y1 Y2 Y3] \\r
+[-z [Z1]]\r
+ '''\r
+ help = usage + '''\\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ -w W1 [W2 ...] w\r
+ -x [X1 [X2 ...]] x\r
+ -y Y1 Y2 Y3 y\r
+ -z [Z1] z\r
+ '''\r
+ version = ''\r
+\r
+\r
+class TestHelpRawText(HelpTestCase):\r
+ """Test the RawTextHelpFormatter"""\r
+\r
+ parser_signature = Sig(\r
+ prog='PROG', formatter_class=argparse.RawTextHelpFormatter,\r
+ description='Keep the formatting\n'\r
+ ' exactly as it is written\n'\r
+ '\n'\r
+ 'here\n')\r
+\r
+ argument_signatures = [\r
+ Sig('--foo', help=' foo help should also\n'\r
+ 'appear as given here'),\r
+ Sig('spam', help='spam help'),\r
+ ]\r
+ argument_group_signatures = [\r
+ (Sig('title', description=' This text\n'\r
+ ' should be indented\n'\r
+ ' exactly like it is here\n'),\r
+ [Sig('--bar', help='bar help')]),\r
+ ]\r
+ usage = '''\\r
+ usage: PROG [-h] [--foo FOO] [--bar BAR] spam\r
+ '''\r
+ help = usage + '''\\r
+\r
+ Keep the formatting\r
+ exactly as it is written\r
+\r
+ here\r
+\r
+ positional arguments:\r
+ spam spam help\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ --foo FOO foo help should also\r
+ appear as given here\r
+\r
+ title:\r
+ This text\r
+ should be indented\r
+ exactly like it is here\r
+\r
+ --bar BAR bar help\r
+ '''\r
+ version = ''\r
+\r
+\r
+class TestHelpRawDescription(HelpTestCase):\r
+ """Test the RawTextHelpFormatter"""\r
+\r
+ parser_signature = Sig(\r
+ prog='PROG', formatter_class=argparse.RawDescriptionHelpFormatter,\r
+ description='Keep the formatting\n'\r
+ ' exactly as it is written\n'\r
+ '\n'\r
+ 'here\n')\r
+\r
+ argument_signatures = [\r
+ Sig('--foo', help=' foo help should not\n'\r
+ ' retain this odd formatting'),\r
+ Sig('spam', help='spam help'),\r
+ ]\r
+ argument_group_signatures = [\r
+ (Sig('title', description=' This text\n'\r
+ ' should be indented\n'\r
+ ' exactly like it is here\n'),\r
+ [Sig('--bar', help='bar help')]),\r
+ ]\r
+ usage = '''\\r
+ usage: PROG [-h] [--foo FOO] [--bar BAR] spam\r
+ '''\r
+ help = usage + '''\\r
+\r
+ Keep the formatting\r
+ exactly as it is written\r
+\r
+ here\r
+\r
+ positional arguments:\r
+ spam spam help\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ --foo FOO foo help should not retain this odd formatting\r
+\r
+ title:\r
+ This text\r
+ should be indented\r
+ exactly like it is here\r
+\r
+ --bar BAR bar help\r
+ '''\r
+ version = ''\r
+\r
+\r
+class TestHelpArgumentDefaults(HelpTestCase):\r
+ """Test the ArgumentDefaultsHelpFormatter"""\r
+\r
+ parser_signature = Sig(\r
+ prog='PROG', formatter_class=argparse.ArgumentDefaultsHelpFormatter,\r
+ description='description')\r
+\r
+ argument_signatures = [\r
+ Sig('--foo', help='foo help - oh and by the way, %(default)s'),\r
+ Sig('--bar', action='store_true', help='bar help'),\r
+ Sig('spam', help='spam help'),\r
+ Sig('badger', nargs='?', default='wooden', help='badger help'),\r
+ ]\r
+ argument_group_signatures = [\r
+ (Sig('title', description='description'),\r
+ [Sig('--baz', type=int, default=42, help='baz help')]),\r
+ ]\r
+ usage = '''\\r
+ usage: PROG [-h] [--foo FOO] [--bar] [--baz BAZ] spam [badger]\r
+ '''\r
+ help = usage + '''\\r
+\r
+ description\r
+\r
+ positional arguments:\r
+ spam spam help\r
+ badger badger help (default: wooden)\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ --foo FOO foo help - oh and by the way, None\r
+ --bar bar help (default: False)\r
+\r
+ title:\r
+ description\r
+\r
+ --baz BAZ baz help (default: 42)\r
+ '''\r
+ version = ''\r
+\r
+# =====================================\r
+# Optional/Positional constructor tests\r
+# =====================================\r
+\r
+class TestInvalidArgumentConstructors(TestCase):\r
+ """Test a bunch of invalid Argument constructors"""\r
+\r
+ def assertTypeError(self, *args, **kwargs):\r
+ parser = argparse.ArgumentParser()\r
+ self.assertRaises(TypeError, parser.add_argument,\r
+ *args, **kwargs)\r
+\r
+ def assertValueError(self, *args, **kwargs):\r
+ parser = argparse.ArgumentParser()\r
+ self.assertRaises(ValueError, parser.add_argument,\r
+ *args, **kwargs)\r
+\r
+ def test_invalid_keyword_arguments(self):\r
+ self.assertTypeError('-x', bar=None)\r
+ self.assertTypeError('-y', callback='foo')\r
+ self.assertTypeError('-y', callback_args=())\r
+ self.assertTypeError('-y', callback_kwargs={})\r
+\r
+ def test_missing_destination(self):\r
+ self.assertTypeError()\r
+ for action in ['append', 'store']:\r
+ self.assertTypeError(action=action)\r
+\r
+ def test_invalid_option_strings(self):\r
+ self.assertValueError('--')\r
+ self.assertValueError('---')\r
+\r
+ def test_invalid_type(self):\r
+ self.assertValueError('--foo', type='int')\r
+\r
+ def test_invalid_action(self):\r
+ self.assertValueError('-x', action='foo')\r
+ self.assertValueError('foo', action='baz')\r
+ parser = argparse.ArgumentParser()\r
+ try:\r
+ parser.add_argument("--foo", action="store-true")\r
+ except ValueError:\r
+ e = sys.exc_info()[1]\r
+ expected = 'unknown action'\r
+ msg = 'expected %r, found %r' % (expected, e)\r
+ self.failUnless(expected in str(e), msg)\r
+\r
+ def test_multiple_dest(self):\r
+ parser = argparse.ArgumentParser()\r
+ parser.add_argument(dest='foo')\r
+ try:\r
+ parser.add_argument('bar', dest='baz')\r
+ except ValueError:\r
+ e = sys.exc_info()[1]\r
+ expected = 'dest supplied twice for positional argument'\r
+ msg = 'expected %r, found %r' % (expected, e)\r
+ self.failUnless(expected in str(e), msg)\r
+\r
+ def test_no_argument_actions(self):\r
+ for action in ['store_const', 'store_true', 'store_false',\r
+ 'append_const', 'count']:\r
+ for attrs in [dict(type=int), dict(nargs='+'),\r
+ dict(choices='ab')]:\r
+ self.assertTypeError('-x', action=action, **attrs)\r
+\r
+ def test_no_argument_no_const_actions(self):\r
+ # options with zero arguments\r
+ for action in ['store_true', 'store_false', 'count']:\r
+\r
+ # const is always disallowed\r
+ self.assertTypeError('-x', const='foo', action=action)\r
+\r
+ # nargs is always disallowed\r
+ self.assertTypeError('-x', nargs='*', action=action)\r
+\r
+ def test_more_than_one_argument_actions(self):\r
+ for action in ['store', 'append']:\r
+\r
+ # nargs=0 is disallowed\r
+ self.assertValueError('-x', nargs=0, action=action)\r
+ self.assertValueError('spam', nargs=0, action=action)\r
+\r
+ # const is disallowed with non-optional arguments\r
+ for nargs in [1, '*', '+']:\r
+ self.assertValueError('-x', const='foo',\r
+ nargs=nargs, action=action)\r
+ self.assertValueError('spam', const='foo',\r
+ nargs=nargs, action=action)\r
+\r
+ def test_required_const_actions(self):\r
+ for action in ['store_const', 'append_const']:\r
+\r
+ # nargs is always disallowed\r
+ self.assertTypeError('-x', nargs='+', action=action)\r
+\r
+ def test_parsers_action_missing_params(self):\r
+ self.assertTypeError('command', action='parsers')\r
+ self.assertTypeError('command', action='parsers', prog='PROG')\r
+ self.assertTypeError('command', action='parsers',\r
+ parser_class=argparse.ArgumentParser)\r
+\r
+ def test_required_positional(self):\r
+ self.assertTypeError('foo', required=True)\r
+\r
+ def test_user_defined_action(self):\r
+\r
+ class Success(Exception):\r
+ pass\r
+\r
+ class Action(object):\r
+\r
+ def __init__(self,\r
+ option_strings,\r
+ dest,\r
+ const,\r
+ default,\r
+ required=False):\r
+ if dest == 'spam':\r
+ if const is Success:\r
+ if default is Success:\r
+ raise Success()\r
+\r
+ def __call__(self, *args, **kwargs):\r
+ pass\r
+\r
+ parser = argparse.ArgumentParser()\r
+ self.assertRaises(Success, parser.add_argument, '--spam',\r
+ action=Action, default=Success, const=Success)\r
+ self.assertRaises(Success, parser.add_argument, 'spam',\r
+ action=Action, default=Success, const=Success)\r
+\r
+# ================================\r
+# Actions returned by add_argument\r
+# ================================\r
+\r
+class TestActionsReturned(TestCase):\r
+\r
+ def test_dest(self):\r
+ parser = argparse.ArgumentParser()\r
+ action = parser.add_argument('--foo')\r
+ self.assertEqual(action.dest, 'foo')\r
+ action = parser.add_argument('-b', '--bar')\r
+ self.assertEqual(action.dest, 'bar')\r
+ action = parser.add_argument('-x', '-y')\r
+ self.assertEqual(action.dest, 'x')\r
+\r
+ def test_misc(self):\r
+ parser = argparse.ArgumentParser()\r
+ action = parser.add_argument('--foo', nargs='?', const=42,\r
+ default=84, type=int, choices=[1, 2],\r
+ help='FOO', metavar='BAR', dest='baz')\r
+ self.assertEqual(action.nargs, '?')\r
+ self.assertEqual(action.const, 42)\r
+ self.assertEqual(action.default, 84)\r
+ self.assertEqual(action.type, int)\r
+ self.assertEqual(action.choices, [1, 2])\r
+ self.assertEqual(action.help, 'FOO')\r
+ self.assertEqual(action.metavar, 'BAR')\r
+ self.assertEqual(action.dest, 'baz')\r
+\r
+\r
+# ================================\r
+# Argument conflict handling tests\r
+# ================================\r
+\r
+class TestConflictHandling(TestCase):\r
+\r
+ def test_bad_type(self):\r
+ self.assertRaises(ValueError, argparse.ArgumentParser,\r
+ conflict_handler='foo')\r
+\r
+ def test_conflict_error(self):\r
+ parser = argparse.ArgumentParser()\r
+ parser.add_argument('-x')\r
+ self.assertRaises(argparse.ArgumentError,\r
+ parser.add_argument, '-x')\r
+ parser.add_argument('--spam')\r
+ self.assertRaises(argparse.ArgumentError,\r
+ parser.add_argument, '--spam')\r
+\r
+ def test_resolve_error(self):\r
+ get_parser = argparse.ArgumentParser\r
+ parser = get_parser(prog='PROG', conflict_handler='resolve')\r
+\r
+ parser.add_argument('-x', help='OLD X')\r
+ parser.add_argument('-x', help='NEW X')\r
+ self.assertEqual(parser.format_help(), textwrap.dedent('''\\r
+ usage: PROG [-h] [-x X]\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ -x X NEW X\r
+ '''))\r
+\r
+ parser.add_argument('--spam', metavar='OLD_SPAM')\r
+ parser.add_argument('--spam', metavar='NEW_SPAM')\r
+ self.assertEqual(parser.format_help(), textwrap.dedent('''\\r
+ usage: PROG [-h] [-x X] [--spam NEW_SPAM]\r
+\r
+ optional arguments:\r
+ -h, --help show this help message and exit\r
+ -x X NEW X\r
+ --spam NEW_SPAM\r
+ '''))\r
+\r
+\r
+# =============================\r
+# Help and Version option tests\r
+# =============================\r
+\r
+class TestOptionalsHelpVersionActions(TestCase):\r
+ """Test the help and version actions"""\r
+\r
+ def _get_error(self, func, *args, **kwargs):\r
+ try:\r
+ func(*args, **kwargs)\r
+ except ArgumentParserError:\r
+ return sys.exc_info()[1]\r
+ else:\r
+ self.assertRaises(ArgumentParserError, func, *args, **kwargs)\r
+\r
+ def assertPrintHelpExit(self, parser, args_str):\r
+ self.assertEqual(\r
+ parser.format_help(),\r
+ self._get_error(parser.parse_args, args_str.split()).stdout)\r
+\r
+ def assertPrintVersionExit(self, parser, args_str):\r
+ self.assertEqual(\r
+ parser.format_version(),\r
+ self._get_error(parser.parse_args, args_str.split()).stderr)\r
+\r
+ def assertArgumentParserError(self, parser, *args):\r
+ self.assertRaises(ArgumentParserError, parser.parse_args, args)\r
+\r
+ def test_version(self):\r
+ parser = ErrorRaisingArgumentParser(version='1.0')\r
+ self.assertPrintHelpExit(parser, '-h')\r
+ self.assertPrintHelpExit(parser, '--help')\r
+ self.assertPrintVersionExit(parser, '-v')\r
+ self.assertPrintVersionExit(parser, '--version')\r
+\r
+ def test_version_format(self):\r
+ parser = ErrorRaisingArgumentParser(prog='PPP', version='%(prog)s 3.5')\r
+ msg = self._get_error(parser.parse_args, ['-v']).stderr\r
+ self.assertEqual('PPP 3.5\n', msg)\r
+\r
+ def test_version_no_help(self):\r
+ parser = ErrorRaisingArgumentParser(add_help=False, version='1.0')\r
+ self.assertArgumentParserError(parser, '-h')\r
+ self.assertArgumentParserError(parser, '--help')\r
+ self.assertPrintVersionExit(parser, '-v')\r
+ self.assertPrintVersionExit(parser, '--version')\r
+\r
+ def test_version_action(self):\r
+ parser = ErrorRaisingArgumentParser(prog='XXX')\r
+ parser.add_argument('-V', action='version', version='%(prog)s 3.7')\r
+ msg = self._get_error(parser.parse_args, ['-V']).stderr\r
+ self.assertEqual('XXX 3.7\n', msg)\r
+\r
+ def test_no_help(self):\r
+ parser = ErrorRaisingArgumentParser(add_help=False)\r
+ self.assertArgumentParserError(parser, '-h')\r
+ self.assertArgumentParserError(parser, '--help')\r
+ self.assertArgumentParserError(parser, '-v')\r
+ self.assertArgumentParserError(parser, '--version')\r
+\r
+ def test_alternate_help_version(self):\r
+ parser = ErrorRaisingArgumentParser()\r
+ parser.add_argument('-x', action='help')\r
+ parser.add_argument('-y', action='version')\r
+ self.assertPrintHelpExit(parser, '-x')\r
+ self.assertPrintVersionExit(parser, '-y')\r
+ self.assertArgumentParserError(parser, '-v')\r
+ self.assertArgumentParserError(parser, '--version')\r
+\r
+ def test_help_version_extra_arguments(self):\r
+ parser = ErrorRaisingArgumentParser(version='1.0')\r
+ parser.add_argument('-x', action='store_true')\r
+ parser.add_argument('y')\r
+\r
+ # try all combinations of valid prefixes and suffixes\r
+ valid_prefixes = ['', '-x', 'foo', '-x bar', 'baz -x']\r
+ valid_suffixes = valid_prefixes + ['--bad-option', 'foo bar baz']\r
+ for prefix in valid_prefixes:\r
+ for suffix in valid_suffixes:\r
+ format = '%s %%s %s' % (prefix, suffix)\r
+ self.assertPrintHelpExit(parser, format % '-h')\r
+ self.assertPrintHelpExit(parser, format % '--help')\r
+ self.assertPrintVersionExit(parser, format % '-v')\r
+ self.assertPrintVersionExit(parser, format % '--version')\r
+\r
+\r
+# ======================\r
+# str() and repr() tests\r
+# ======================\r
+\r
+class TestStrings(TestCase):\r
+ """Test str() and repr() on Optionals and Positionals"""\r
+\r
+ def assertStringEqual(self, obj, result_string):\r
+ for func in [str, repr]:\r
+ self.assertEqual(func(obj), result_string)\r
+\r
+ def test_optional(self):\r
+ option = argparse.Action(\r
+ option_strings=['--foo', '-a', '-b'],\r
+ dest='b',\r
+ type='int',\r
+ nargs='+',\r
+ default=42,\r
+ choices=[1, 2, 3],\r
+ help='HELP',\r
+ metavar='METAVAR')\r
+ string = (\r
+ "Action(option_strings=['--foo', '-a', '-b'], dest='b', "\r
+ "nargs='+', const=None, default=42, type='int', "\r
+ "choices=[1, 2, 3], help='HELP', metavar='METAVAR')")\r
+ self.assertStringEqual(option, string)\r
+\r
+ def test_argument(self):\r
+ argument = argparse.Action(\r
+ option_strings=[],\r
+ dest='x',\r
+ type=float,\r
+ nargs='?',\r
+ default=2.5,\r
+ choices=[0.5, 1.5, 2.5],\r
+ help='H HH H',\r
+ metavar='MV MV MV')\r
+ string = (\r
+ "Action(option_strings=[], dest='x', nargs='?', "\r
+ "const=None, default=2.5, type=%r, choices=[0.5, 1.5, 2.5], "\r
+ "help='H HH H', metavar='MV MV MV')" % float)\r
+ self.assertStringEqual(argument, string)\r
+\r
+ def test_namespace(self):\r
+ ns = argparse.Namespace(foo=42, bar='spam')\r
+ string = "Namespace(bar='spam', foo=42)"\r
+ self.assertStringEqual(ns, string)\r
+\r
+ def test_parser(self):\r
+ parser = argparse.ArgumentParser(prog='PROG')\r
+ string = (\r
+ "ArgumentParser(prog='PROG', usage=None, description=None, "\r
+ "version=None, formatter_class=%r, conflict_handler='error', "\r
+ "add_help=True)" % argparse.HelpFormatter)\r
+ self.assertStringEqual(parser, string)\r
+\r
+# ===============\r
+# Namespace tests\r
+# ===============\r
+\r
+class TestNamespace(TestCase):\r
+\r
+ def test_constructor(self):\r
+ ns = argparse.Namespace()\r
+ self.assertRaises(AttributeError, getattr, ns, 'x')\r
+\r
+ ns = argparse.Namespace(a=42, b='spam')\r
+ self.assertEqual(ns.a, 42)\r
+ self.assertEqual(ns.b, 'spam')\r
+\r
+ def test_equality(self):\r
+ ns1 = argparse.Namespace(a=1, b=2)\r
+ ns2 = argparse.Namespace(b=2, a=1)\r
+ ns3 = argparse.Namespace(a=1)\r
+ ns4 = argparse.Namespace(b=2)\r
+\r
+ self.assertEqual(ns1, ns2)\r
+ self.assertNotEqual(ns1, ns3)\r
+ self.assertNotEqual(ns1, ns4)\r
+ self.assertNotEqual(ns2, ns3)\r
+ self.assertNotEqual(ns2, ns4)\r
+ self.failUnless(ns1 != ns3)\r
+ self.failUnless(ns1 != ns4)\r
+ self.failUnless(ns2 != ns3)\r
+ self.failUnless(ns2 != ns4)\r
+\r
+\r
+# ===================\r
+# File encoding tests\r
+# ===================\r
+\r
+class TestEncoding(TestCase):\r
+\r
+ def _test_module_encoding(self, path):\r
+ path, _ = os.path.splitext(path)\r
+ path += ".py"\r
+ codecs.open(path, 'r', 'utf8').read()\r
+\r
+ def test_argparse_module_encoding(self):\r
+ self._test_module_encoding(argparse.__file__)\r
+\r
+ def test_test_argparse_module_encoding(self):\r
+ self._test_module_encoding(__file__)\r
+\r
+# ===================\r
+# ArgumentError tests\r
+# ===================\r
+\r
+class TestArgumentError(TestCase):\r
+\r
+ def test_argument_error(self):\r
+ msg = "my error here"\r
+ error = argparse.ArgumentError(None, msg)\r
+ self.failUnlessEqual(str(error), msg)\r
+\r
+# =======================\r
+# ArgumentTypeError tests\r
+# =======================\r
+\r
+class TestArgumentError(TestCase):\r
+\r
+ def test_argument_type_error(self):\r
+\r
+ def spam(string):\r
+ raise argparse.ArgumentTypeError('spam!')\r
+\r
+ parser = ErrorRaisingArgumentParser(prog='PROG', add_help=False)\r
+ parser.add_argument('x', type=spam)\r
+ try:\r
+ parser.parse_args(['XXX'])\r
+ except ArgumentParserError:\r
+ expected = 'usage: PROG x\nPROG: error: argument x: spam!\n'\r
+ msg = sys.exc_info()[1].stderr\r
+ self.failUnlessEqual(expected, msg)\r
+ else:\r
+ self.fail()\r
+\r
+# ======================\r
+# parse_known_args tests\r
+# ======================\r
+\r
+class TestParseKnownArgs(TestCase):\r
+\r
+ def test_optionals(self):\r
+ parser = argparse.ArgumentParser()\r
+ parser.add_argument('--foo')\r
+ args, extras = parser.parse_known_args('--foo F --bar --baz'.split())\r
+ self.failUnlessEqual(NS(foo='F'), args)\r
+ self.failUnlessEqual(['--bar', '--baz'], extras)\r
+\r
+ def test_mixed(self):\r
+ parser = argparse.ArgumentParser()\r
+ parser.add_argument('-v', nargs='?', const=1, type=int)\r
+ parser.add_argument('--spam', action='store_false')\r
+ parser.add_argument('badger')\r
+\r
+ argv = ["B", "C", "--foo", "-v", "3", "4"]\r
+ args, extras = parser.parse_known_args(argv)\r
+ self.failUnlessEqual(NS(v=3, spam=True, badger="B"), args)\r
+ self.failUnlessEqual(["C", "--foo", "4"], extras)\r
+\r
+# ============================\r
+# from argparse import * tests\r
+# ============================\r
+\r
+class TestImportStar(TestCase):\r
+\r
+ def test(self):\r
+ for name in argparse.__all__:\r
+ self.failUnless(hasattr(argparse, name))\r
+\r
+\r
+if __name__ == '__main__':\r
+ unittest.main()\r
projects / python / commitdiff