# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001-2024, Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.12\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2025-11-26 22:26+0200\n"

"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"

"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"

"Language-Team: LANGUAGE <LL@li.org>\n"

"Language: \n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

#: library/argparse.rst:2

msgid ""

":mod:`!argparse` --- Parser for command-line options, arguments and "

"subcommands"

msgstr ""

#: library/argparse.rst:12

msgid "**Source code:** :source:`Lib/argparse.py`"

msgstr ""

#: library/argparse.rst:-1

msgid "Tutorial"

msgstr ""

#: library/argparse.rst:18

msgid ""

"This page contains the API reference information. For a more gentle "

"introduction to Python command-line parsing, have a look at the :ref:"

"`argparse tutorial <argparse-tutorial>`."

msgstr ""

#: library/argparse.rst:22

msgid ""

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

"line interfaces. The program defines what arguments it requires, and :mod:`!"

"argparse` will figure out how to parse those out of :data:`sys.argv`. The :"

"mod:`!argparse` module also automatically generates help and usage "

"messages. The module will also issue errors when users give the program "

"invalid arguments."

msgstr ""

#: library/argparse.rst:28

msgid ""

"The :mod:`!argparse` module's support for command-line interfaces is built "

"around an instance of :class:`argparse.ArgumentParser`. It is a container "

"for argument specifications and has options that apply to the parser as "

"whole::"

msgstr ""

#: library/argparse.rst:32

msgid ""

"parser = argparse.ArgumentParser(\n"

" prog='ProgramName',\n"

" description='What the program does',\n"

" epilog='Text at the bottom of help')"

msgstr ""

#: library/argparse.rst:37

msgid ""

"The :meth:`ArgumentParser.add_argument` method attaches individual argument "

"specifications to the parser. It supports positional arguments, options "

"that accept values, and on/off flags::"

msgstr ""

#: library/argparse.rst:41

msgid ""

"parser.add_argument('filename') # positional argument\n"

"parser.add_argument('-c', '--count') # option that takes a value\n"

"parser.add_argument('-v', '--verbose',\n"

" action='store_true') # on/off flag"

msgstr ""

#: library/argparse.rst:46

msgid ""

"The :meth:`ArgumentParser.parse_args` method runs the parser and places the "

"extracted data in a :class:`argparse.Namespace` object::"

msgstr ""

#: library/argparse.rst:49

msgid ""

"args = parser.parse_args()\n"

"print(args.filename, args.count, args.verbose)"

msgstr ""

#: library/argparse.rst:53

msgid ""

"If you're looking for a guide about how to upgrade :mod:`optparse` code to :"

"mod:`!argparse`, see :ref:`Upgrading Optparse Code <upgrading-optparse-"

"code>`."

msgstr ""

#: library/argparse.rst:57

msgid "ArgumentParser objects"

msgstr ""

#: library/argparse.rst:66

msgid ""

"Create a new :class:`ArgumentParser` object. All parameters should be passed "

"as keyword arguments. Each parameter has its own more detailed description "

"below, but in short they are:"

msgstr ""

#: library/argparse.rst:70

msgid ""

"prog_ - The name of the program (default: ``os.path.basename(sys.argv[0])``)"

msgstr ""

#: library/argparse.rst:73

msgid ""

"usage_ - The string describing the program usage (default: generated from "

"arguments added to parser)"

msgstr ""

#: library/argparse.rst:76

msgid ""

"description_ - Text to display before the argument help (by default, no text)"

msgstr ""

#: library/argparse.rst:79

msgid "epilog_ - Text to display after the argument help (by default, no text)"

msgstr ""

#: library/argparse.rst:81

msgid ""

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

"also be included"

msgstr ""

#: library/argparse.rst:84

msgid "formatter_class_ - A class for customizing the help output"

msgstr ""

#: library/argparse.rst:86

msgid ""

"prefix_chars_ - The set of characters that prefix optional arguments "

"(default: '-')"

msgstr ""

#: library/argparse.rst:89

msgid ""

"fromfile_prefix_chars_ - The set of characters that prefix files from which "

"additional arguments should be read (default: ``None``)"

msgstr ""

#: library/argparse.rst:92

msgid ""

"argument_default_ - The global default value for arguments (default: "

"``None``)"

msgstr ""

#: library/argparse.rst:95

msgid ""

"conflict_handler_ - The strategy for resolving conflicting optionals "

"(usually unnecessary)"

msgstr ""

#: library/argparse.rst:98

msgid ""

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

msgstr ""

#: library/argparse.rst:100

msgid ""

"allow_abbrev_ - Allows long options to be abbreviated if the abbreviation is "

"unambiguous. (default: ``True``)"

msgstr ""

#: library/argparse.rst:103

msgid ""

"exit_on_error_ - Determines whether or not :class:`!ArgumentParser` exits "

"with error info when an error occurs. (default: ``True``)"

msgstr ""

#: library/argparse.rst:106

msgid "*allow_abbrev* parameter was added."

msgstr ""

#: library/argparse.rst:109

msgid ""

"In previous versions, *allow_abbrev* also disabled grouping of short flags "

"such as ``-vv`` to mean ``-v -v``."

msgstr ""

#: library/argparse.rst:113

msgid "*exit_on_error* parameter was added."

msgstr ""

#: library/argparse.rst:596

msgid "The following sections describe how each of these are used."

msgstr ""

#: library/argparse.rst:122

msgid "prog"

msgstr ""

#: library/argparse.rst:125

msgid ""

"By default, :class:`ArgumentParser` calculates the name of the program to "

"display in help messages depending on the way the Python interpreter was run:"

msgstr ""

#: library/argparse.rst:128

msgid ""

"The :func:`base name <os.path.basename>` of ``sys.argv[0]`` if a file was "

"passed as argument."

msgstr ""

#: library/argparse.rst:130

msgid ""

"The Python interpreter name followed by ``sys.argv[0]`` if a directory or a "

"zipfile was passed as argument."

msgstr ""

#: library/argparse.rst:132

msgid ""

"The Python interpreter name followed by ``-m`` followed by the module or "

"package name if the :option:`-m` option was used."

msgstr ""

#: library/argparse.rst:135

msgid ""

"This default is almost always desirable because it will make the help "

"messages match the string that was used to invoke the program on the command "

"line. However, to change this default behavior, another value can be "

"supplied using the ``prog=`` argument to :class:`ArgumentParser`::"

msgstr ""

#: library/argparse.rst:140

msgid ""

">>> parser = argparse.ArgumentParser(prog='myprogram')\n"

">>> parser.print_help()\n"

"usage: myprogram [-h]\n"

"\n"

"options:\n"

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

msgstr ""

#: library/argparse.rst:147

msgid ""

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

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

"format specifier."

msgstr ""

#: library/argparse.rst:153

msgid ""

">>> parser = argparse.ArgumentParser(prog='myprogram')\n"

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

">>> parser.print_help()\n"

"usage: myprogram [-h] [--foo FOO]\n"

"\n"

"options:\n"

" -h, --help show this help message and exit\n"

" --foo FOO foo of the myprogram program"

msgstr ""

#: library/argparse.rst:164

msgid "usage"

msgstr ""

#: library/argparse.rst:166

msgid ""

"By default, :class:`ArgumentParser` calculates the usage message from the "

"arguments it contains. The default message can be overridden with the "

"``usage=`` keyword argument::"

msgstr ""

#: library/argparse.rst:170

msgid ""

">>> parser = argparse.ArgumentParser(prog='PROG', usage='%(prog)s "

"[options]')\n"

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

">>> parser.add_argument('bar', nargs='+', help='bar help')\n"

">>> parser.print_help()\n"

"usage: PROG [options]\n"

"\n"

"positional arguments:\n"

" bar bar help\n"

"\n"

"options:\n"

" -h, --help show this help message and exit\n"

" --foo [FOO] foo help"

msgstr ""

#: library/argparse.rst:183

msgid ""

"The ``%(prog)s`` format specifier is available to fill in the program name "

"in your usage messages."

msgstr ""

#: library/argparse.rst:190

msgid "description"

msgstr ""

#: library/argparse.rst:192

msgid ""

"Most calls to the :class:`ArgumentParser` constructor will use the "

"``description=`` keyword argument. This argument gives a brief description "

"of what the program does and how it works. In help messages, the "

"description is displayed between the command-line usage string and the help "

"messages for the various arguments."

msgstr ""

#: library/argparse.rst:198

msgid ""

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

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

msgstr ""

#: library/argparse.rst:203

msgid "epilog"

msgstr ""

#: library/argparse.rst:205

msgid ""

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

"the description of the arguments. Such text can be specified using the "

"``epilog=`` argument to :class:`ArgumentParser`::"

msgstr ""

#: library/argparse.rst:209

msgid ""

">>> parser = argparse.ArgumentParser(\n"

"... description='A foo that bars',\n"

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

">>> parser.print_help()\n"

"usage: argparse.py [-h]\n"

"\n"

"A foo that bars\n"

"\n"

"options:\n"

" -h, --help show this help message and exit\n"

"\n"

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

msgstr ""

#: library/argparse.rst:222

msgid ""

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

"wrapped, but this behavior can be adjusted with the formatter_class_ "

"argument to :class:`ArgumentParser`."

msgstr ""

#: library/argparse.rst:228

msgid "parents"

msgstr ""

#: library/argparse.rst:230

msgid ""

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

"repeating the definitions of these arguments, a single parser with all the "

"shared arguments and passed to ``parents=`` argument to :class:"

"`ArgumentParser` can be used. The ``parents=`` argument takes a list of :"

"class:`ArgumentParser` objects, collects all the positional and optional "

"actions from them, and adds these actions to the :class:`ArgumentParser` "

"object being constructed::"

msgstr ""

#: library/argparse.rst:237

msgid ""

">>> parent_parser = argparse.ArgumentParser(add_help=False)\n"

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

"\n"

">>> foo_parser = argparse.ArgumentParser(parents=[parent_parser])\n"

">>> foo_parser.add_argument('foo')\n"

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

"Namespace(foo='XXX', parent=2)\n"

"\n"

">>> bar_parser = argparse.ArgumentParser(parents=[parent_parser])\n"

">>> bar_parser.add_argument('--bar')\n"

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

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

msgstr ""

#: library/argparse.rst:250

msgid ""

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

"the :class:`ArgumentParser` will see two ``-h/--help`` options (one in the "

"parent and one in the child) and raise an error."

msgstr ""

#: library/argparse.rst:255

msgid ""

"You must fully initialize the parsers before passing them via ``parents=``. "

"If you change the parent parsers after the child parser, those changes will "

"not be reflected in the child."

msgstr ""

#: library/argparse.rst:263

msgid "formatter_class"

msgstr ""

#: library/argparse.rst:265

msgid ""

":class:`ArgumentParser` objects allow the help formatting to be customized "

"by specifying an alternate formatting class. Currently, there are four such "

"classes:"

msgstr ""

#: library/argparse.rst:274

msgid ""

":class:`RawDescriptionHelpFormatter` and :class:`RawTextHelpFormatter` give "

"more control over how textual descriptions are displayed. By default, :class:"

"`ArgumentParser` objects line-wrap the description_ and epilog_ texts in "

"command-line help messages::"

msgstr ""

#: library/argparse.rst:279

msgid ""

">>> parser = argparse.ArgumentParser(\n"

"... prog='PROG',\n"

"... description='''this description\n"

"... was indented weird\n"

"... but that is okay''',\n"

"... epilog='''\n"

"... likewise for this epilog whose whitespace will\n"

"... be cleaned up and whose words will be wrapped\n"

"... across a couple lines''')\n"

">>> parser.print_help()\n"

"usage: PROG [-h]\n"

"\n"

"this description was indented weird but that is okay\n"

"\n"

"options:\n"

" -h, --help show this help message and exit\n"

"\n"

"likewise for this epilog whose whitespace will be cleaned up and whose "

"words\n"

"will be wrapped across a couple lines"

msgstr ""

#: library/argparse.rst:299

msgid ""

"Passing :class:`RawDescriptionHelpFormatter` as ``formatter_class=`` "

"indicates that description_ and epilog_ are already correctly formatted and "

"should not be line-wrapped::"

msgstr ""

#: library/argparse.rst:303

msgid ""

">>> parser = argparse.ArgumentParser(\n"

"... prog='PROG',\n"

"... formatter_class=argparse.RawDescriptionHelpFormatter,\n"

"... description=textwrap.dedent('''\\\n"

"... Please do not mess up this text!\n"

"... --------------------------------\n"

"... I have indented it\n"

"... exactly the way\n"

"... I want it\n"

"... '''))\n"

">>> parser.print_help()\n"

"usage: PROG [-h]\n"

"\n"

"Please do not mess up this text!\n"

"--------------------------------\n"

" I have indented it\n"

" exactly the way\n"

" I want it\n"

"\n"

"options:\n"

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

msgstr ""

#: library/argparse.rst:325

msgid ""

":class:`RawTextHelpFormatter` maintains whitespace for all sorts of help "

"text, including argument descriptions. However, multiple newlines are "

"replaced with one. If you wish to preserve multiple blank lines, add spaces "

"between the newlines."

msgstr ""

#: library/argparse.rst:330

msgid ""

":class:`ArgumentDefaultsHelpFormatter` automatically adds information about "

"default values to each of the argument help messages::"

msgstr ""

#: library/argparse.rst:333

msgid ""

">>> parser = argparse.ArgumentParser(\n"

"... prog='PROG',\n"

"... formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n"

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

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

">>> parser.print_help()\n"

"usage: PROG [-h] [--foo FOO] [bar ...]\n"

"\n"

"positional arguments:\n"

" bar BAR! (default: [1, 2, 3])\n"

"\n"

"options:\n"

" -h, --help show this help message and exit\n"

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

msgstr ""

#: library/argparse.rst:348

msgid ""

":class:`MetavarTypeHelpFormatter` uses the name of the type_ argument for "

"each argument as the display name for its values (rather than using the "

"dest_ as the regular formatter does)::"

msgstr ""

#: library/argparse.rst:352

msgid ""

">>> parser = argparse.ArgumentParser(\n"

"... prog='PROG',\n"

"... formatter_class=argparse.MetavarTypeHelpFormatter)\n"

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

">>> parser.add_argument('bar', type=float)\n"

">>> parser.print_help()\n"

"usage: PROG [-h] [--foo int] float\n"

"\n"

"positional arguments:\n"

" float\n"

"\n"

"options:\n"

" -h, --help show this help message and exit\n"

" --foo int"

msgstr ""

#: library/argparse.rst:369

msgid "prefix_chars"

msgstr ""

#: library/argparse.rst:371

msgid ""

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

"Parsers that need to support different or additional prefix characters, e.g. "

"for options like ``+f`` or ``/foo``, may specify them using the "

"``prefix_chars=`` argument to the :class:`ArgumentParser` constructor::"

msgstr ""

#: library/argparse.rst:377

msgid ""

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

">>> parser.add_argument('+f')\n"

">>> parser.add_argument('++bar')\n"

">>> parser.parse_args('+f X ++bar Y'.split())\n"

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

msgstr ""

#: library/argparse.rst:383

msgid ""

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

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

"disallowed."

msgstr ""

#: library/argparse.rst:389

msgid "fromfile_prefix_chars"

msgstr ""

#: library/argparse.rst:391

msgid ""

"Sometimes, when dealing with a particularly long argument list, it may make "

"sense to keep the list of arguments in a file rather than typing it out at "

"the command line. If the ``fromfile_prefix_chars=`` argument is given to "

"the :class:`ArgumentParser` constructor, then arguments that start with any "

"of the specified characters will be treated as files, and will be replaced "

"by the arguments they contain. For example::"

msgstr ""

#: library/argparse.rst:398

msgid ""

">>> with open('args.txt', 'w', encoding=sys.getfilesystemencoding()) as fp:\n"

"... fp.write('-f\\nbar')\n"

"...\n"

">>> parser = argparse.ArgumentParser(fromfile_prefix_chars='@')\n"

">>> parser.add_argument('-f')\n"

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

"Namespace(f='bar')"

msgstr ""

#: library/argparse.rst:406

msgid ""

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

"meth:`~ArgumentParser.convert_arg_line_to_args`) and are treated as if they "

"were in the same place as the original file referencing argument on the "

"command line. So in the example above, the expression ``['-f', 'foo', "

"'@args.txt']`` is considered equivalent to the expression ``['-f', 'foo', '-"

"f', 'bar']``."

msgstr ""

#: library/argparse.rst:412

msgid ""

":class:`ArgumentParser` uses :term:`filesystem encoding and error handler` "

"to read the file containing arguments."

msgstr ""

#: library/argparse.rst:415

msgid ""

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

"arguments will never be treated as file references."

msgstr ""

#: library/argparse.rst:418

msgid ""

":class:`ArgumentParser` changed encoding and errors to read arguments files "

"from default (e.g. :func:`locale.getpreferredencoding(False) <locale."

"getpreferredencoding>` and ``\"strict\"``) to the :term:`filesystem encoding "

"and error handler`. Arguments file should be encoded in UTF-8 instead of "

"ANSI Codepage on Windows."

msgstr ""

#: library/argparse.rst:426

msgid "argument_default"

msgstr ""

#: library/argparse.rst:428

msgid ""

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

"meth:`~ArgumentParser.add_argument` or by calling the :meth:`~ArgumentParser."

"set_defaults` methods with a specific set of name-value pairs. Sometimes "

"however, it may be useful to specify a single parser-wide default for "

"arguments. This can be accomplished by passing the ``argument_default=`` "

"keyword argument to :class:`ArgumentParser`. For example, to globally "

"suppress attribute creation on :meth:`~ArgumentParser.parse_args` calls, we "

"supply ``argument_default=SUPPRESS``::"

msgstr ""

#: library/argparse.rst:437

msgid ""

">>> parser = argparse.ArgumentParser(argument_default=argparse.SUPPRESS)\n"

">>> parser.add_argument('--foo')\n"

">>> parser.add_argument('bar', nargs='?')\n"

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

"Namespace(bar='BAR', foo='1')\n"

">>> parser.parse_args([])\n"

"Namespace()"

msgstr ""

#: library/argparse.rst:448

msgid "allow_abbrev"

msgstr ""

#: library/argparse.rst:450

msgid ""

"Normally, when you pass an argument list to the :meth:`~ArgumentParser."

"parse_args` method of an :class:`ArgumentParser`, it :ref:`recognizes "

"abbreviations <prefix-matching>` of long options."

msgstr ""

#: library/argparse.rst:454

msgid "This feature can be disabled by setting ``allow_abbrev`` to ``False``::"

msgstr ""

#: library/argparse.rst:456

msgid ""

">>> parser = argparse.ArgumentParser(prog='PROG', allow_abbrev=False)\n"

">>> parser.add_argument('--foobar', action='store_true')\n"

">>> parser.add_argument('--foonley', action='store_false')\n"

">>> parser.parse_args(['--foon'])\n"

"usage: PROG [-h] [--foobar] [--foonley]\n"

"PROG: error: unrecognized arguments: --foon"

msgstr ""

#: library/argparse.rst:467

msgid "conflict_handler"

msgstr ""

#: library/argparse.rst:469

msgid ""

":class:`ArgumentParser` objects do not allow two actions with the same "

"option string. By default, :class:`ArgumentParser` objects raise an "

"exception if an attempt is made to create an argument with an option string "

"that is already in use::"

msgstr ""

#: library/argparse.rst:474

msgid ""

">>> parser = argparse.ArgumentParser(prog='PROG')\n"

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

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

"Traceback (most recent call last):\n"

" ..\n"

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

msgstr ""

#: library/argparse.rst:481

msgid ""

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

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

"value ``'resolve'`` can be supplied to the ``conflict_handler=`` argument "

"of :class:`ArgumentParser`::"

msgstr ""

#: library/argparse.rst:486

msgid ""

">>> parser = argparse.ArgumentParser(prog='PROG', "

"conflict_handler='resolve')\n"

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

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

">>> parser.print_help()\n"

"usage: PROG [-h] [-f FOO] [--foo FOO]\n"

"\n"

"options:\n"

" -h, --help show this help message and exit\n"

" -f FOO old foo help\n"

" --foo FOO new foo help"

msgstr ""

#: library/argparse.rst:497

msgid ""

"Note that :class:`ArgumentParser` objects only remove an action if all of "

"its option strings are overridden. So, in the example above, the old ``-f/--"

"foo`` action is retained as the ``-f`` action, because only the ``--foo`` "

"option string was overridden."

msgstr ""

#: library/argparse.rst:504

msgid "add_help"

msgstr ""

#: library/argparse.rst:506

msgid ""

"By default, :class:`ArgumentParser` objects add an option which simply "

"displays the parser's help message. If ``-h`` or ``--help`` is supplied at "

"the command line, the :class:`!ArgumentParser` help will be printed."

msgstr ""

#: library/argparse.rst:510

msgid ""

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

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

"class:`ArgumentParser`::"

msgstr ""

#: library/argparse.rst:514

msgid ""

">>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)\n"

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

">>> parser.print_help()\n"

"usage: PROG [--foo FOO]\n"

"\n"

"options:\n"

" --foo FOO foo help"

msgstr ""

#: library/argparse.rst:522

msgid ""

"The help option is typically ``-h/--help``. The exception to this is if the "

"``prefix_chars=`` is specified and does not include ``-``, in which case ``-"

"h`` and ``--help`` are not valid options. In this case, the first character "

"in ``prefix_chars`` is used to prefix the help options::"

msgstr ""

#: library/argparse.rst:528

msgid ""

">>> parser = argparse.ArgumentParser(prog='PROG', prefix_chars='+/')\n"

">>> parser.print_help()\n"

"usage: PROG [+h]\n"

"\n"

"options:\n"

" +h, ++help show this help message and exit"

msgstr ""

#: library/argparse.rst:537

msgid "exit_on_error"

msgstr ""

#: library/argparse.rst:539

msgid ""

"Normally, when you pass an invalid argument list to the :meth:"

"`~ArgumentParser.parse_args` method of an :class:`ArgumentParser`, it will "

"print a *message* to :data:`sys.stderr` and exit with a status code of 2."

msgstr ""

#: library/argparse.rst:543

msgid ""

"If the user would like to catch errors manually, the feature can be enabled "

"by setting ``exit_on_error`` to ``False``::"

msgstr ""

#: library/argparse.rst:546

msgid ""

">>> parser = argparse.ArgumentParser(exit_on_error=False)\n"

">>> parser.add_argument('--integers', type=int)\n"

"_StoreAction(option_strings=['--integers'], dest='integers', nargs=None, "

"const=None, default=None, type=<class 'int'>, choices=None, help=None, "

"metavar=None)\n"

">>> try:\n"

"... parser.parse_args('--integers a'.split())\n"

"... except argparse.ArgumentError:\n"

"... print('Catching an argumentError')\n"

"...\n"

"Catching an argumentError"

msgstr ""

#: library/argparse.rst:560

msgid "The add_argument() method"

msgstr ""

#: library/argparse.rst:566

msgid ""

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

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

msgstr ""

#: library/argparse.rst:569

msgid ""

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

"or ``'-f', '--foo'``."

msgstr ""

#: library/argparse.rst:572

msgid ""

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

"encountered at the command line."

msgstr ""

#: library/argparse.rst:575

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

msgstr ""

#: library/argparse.rst:577

msgid ""

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

msgstr ""

#: library/argparse.rst:579

msgid ""

"default_ - The value produced if the argument is absent from the command "

"line and if it is absent from the namespace object."

msgstr ""

#: library/argparse.rst:582

msgid ""

"type_ - The type to which the command-line argument should be converted."

msgstr ""

#: library/argparse.rst:584

msgid "choices_ - A sequence of the allowable values for the argument."

msgstr ""

#: library/argparse.rst:586

msgid ""

"required_ - Whether or not the command-line option may be omitted (optionals "

"only)."

msgstr ""

#: library/argparse.rst:589

msgid "help_ - A brief description of what the argument does."

msgstr ""

#: library/argparse.rst:591

msgid "metavar_ - A name for the argument in usage messages."

msgstr ""

#: library/argparse.rst:593

msgid ""

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

"meth:`parse_args`."

msgstr ""

#: library/argparse.rst:602

msgid "name or flags"

msgstr ""

#: library/argparse.rst:604

msgid ""

"The :meth:`~ArgumentParser.add_argument` method must know whether an "

"optional argument, like ``-f`` or ``--foo``, or a positional argument, like "

"a list of filenames, is expected. The first arguments passed to :meth:"

"`~ArgumentParser.add_argument` must therefore be either a series of flags, "

"or a simple argument name."

msgstr ""

#: library/argparse.rst:610

msgid "For example, an optional argument could be created like::"

msgstr ""

#: library/argparse.rst:612

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

msgstr ""

#: library/argparse.rst:614

msgid "while a positional argument could be created like::"

msgstr ""

#: library/argparse.rst:616

msgid ">>> parser.add_argument('bar')"

msgstr ""

#: library/argparse.rst:618

msgid ""

"When :meth:`~ArgumentParser.parse_args` is called, optional arguments will "

"be identified by the ``-`` prefix, and the remaining arguments will be "

"assumed to be positional::"

msgstr ""

#: library/argparse.rst:622

msgid ""

">>> parser = argparse.ArgumentParser(prog='PROG')\n"

">>> parser.add_argument('-f', '--foo')\n"

">>> parser.add_argument('bar')\n"

">>> parser.parse_args(['BAR'])\n"

"Namespace(bar='BAR', foo=None)\n"

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

"Namespace(bar='BAR', foo='FOO')\n"

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

"usage: PROG [-h] [-f FOO] bar\n"

"PROG: error: the following arguments are required: bar"

msgstr ""

#: library/argparse.rst:637

msgid "action"

msgstr ""

#: library/argparse.rst:639

msgid ""

":class:`ArgumentParser` objects associate command-line arguments with "

"actions. These actions can do just about anything with the command-line "

"arguments associated with them, though most actions simply add an attribute "

"to the object returned by :meth:`~ArgumentParser.parse_args`. The "

"``action`` keyword argument specifies how the command-line arguments should "

"be handled. The supplied actions are:"

msgstr ""

#: library/argparse.rst:645

msgid ""

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

"action."

msgstr ""

#: library/argparse.rst:648

msgid ""

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

"argument; note that the const_ keyword argument defaults to ``None``. The "

"``'store_const'`` action is most commonly used with optional arguments that "

"specify some sort of flag. For example::"

msgstr ""

#: library/argparse.rst:653

msgid ""

">>> parser = argparse.ArgumentParser()\n"

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

">>> parser.parse_args(['--foo'])\n"

"Namespace(foo=42)"

msgstr ""

#: library/argparse.rst:658

msgid ""

"``'store_true'`` and ``'store_false'`` - These are special cases of "

"``'store_const'`` used for storing the values ``True`` and ``False`` "

"respectively. In addition, they create default values of ``False`` and "

"``True`` respectively::"

msgstr ""

#: library/argparse.rst:663

msgid ""

">>> parser = argparse.ArgumentParser()\n"

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

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

">>> parser.add_argument('--baz', action='store_false')\n"

">>> parser.parse_args('--foo --bar'.split())\n"

"Namespace(foo=True, bar=False, baz=True)"

msgstr ""

#: library/argparse.rst:670

msgid ""

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

"list. It is useful to allow an option to be specified multiple times. If the "

"default value is non-empty, the default elements will be present in the "

"parsed value for the option, with any values from the command line appended "

"after those default values. Example usage::"

msgstr ""

#: library/argparse.rst:676

msgid ""

">>> parser = argparse.ArgumentParser()\n"

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

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

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

msgstr ""

#: library/argparse.rst:681

msgid ""

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

"the const_ keyword argument to the list; note that the const_ keyword "

"argument defaults to ``None``. The ``'append_const'`` action is typically "

"useful when multiple arguments need to store constants to the same list. For "

"example::"

msgstr ""

#: library/argparse.rst:687

msgid ""

">>> parser = argparse.ArgumentParser()\n"

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

"const=str)\n"

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

"const=int)\n"