# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001 Python Software Foundation

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

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# python-doc bot, 2025

# Rafael Fontenelle <[email protected]>, 2025

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2026-04-15 15:01+0000\n"

"PO-Revision-Date: 2025-09-16 00:00+0000\n"

"Last-Translator: Rafael Fontenelle <[email protected]>, 2025\n"

"Language-Team: Polish (https://app.transifex.com/python-doc/teams/5390/pl/)\n"

"MIME-Version: 1.0\n"

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

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

"Language: pl\n"

"Plural-Forms: nplurals=4; plural=(n==1 ? 0 : (n%10>=2 && n%10<=4) && "

"(n%100<12 || n%100>14) ? 1 : n!=1 && (n%10>=0 && n%10<=1) || (n%10>=5 && "

"n%10<=9) || (n%100>=12 && n%100<=14) ? 2 : 3);\n"

msgid ""

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

"subcommands"

msgstr ""

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

msgstr "**Kod źródłowy:** :source:`Lib/argparse.py`"

msgid ""

"While :mod:`!argparse` is the default recommended standard library module "

"for implementing basic command line applications, authors with more exacting "

"requirements for exactly how their command line applications behave may find "

"it doesn't provide the necessary level of control. Refer to :ref:`choosing-"

"an-argument-parser` for alternatives to consider when ``argparse`` doesn't "

"support behaviors that the application requires (such as entirely disabling "

"support for interspersed options and positional arguments, or accepting "

"option parameter values that start with ``-`` even when they correspond to "

"another defined option)."

msgstr ""

msgid "Tutorial"

msgstr "Tutorial"

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 ""

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 ""

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 ""

msgid ""

"parser = argparse.ArgumentParser(\n"

" prog='ProgramName',\n"

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

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

msgstr ""

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 ""

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 ""

msgid ""

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

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

msgstr ""

msgid ""

"args = parser.parse_args()\n"

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

msgstr ""

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 ""

msgid "ArgumentParser objects"

msgstr ""

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 ""

msgid ""

"prog_ - The name of the program (default: generated from the ``__main__`` "

"module attributes and ``sys.argv[0]``)"

msgstr ""

msgid ""

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

"arguments added to parser)"

msgstr ""

msgid ""

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

msgstr ""

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

msgstr ""

msgid ""

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

"also be included"

msgstr ""

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

msgstr ""

msgid ""

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

"(default: '-')"

msgstr ""

msgid ""

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

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

msgstr ""

msgid ""

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

"``None``)"

msgstr ""

msgid ""

"conflict_handler_ - The strategy for resolving conflicting optionals "

"(usually unnecessary)"

msgstr ""

msgid ""

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

msgstr ""

msgid ""

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

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

msgstr ""

msgid ""

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

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

msgstr ""

msgid ""

"suggest_on_error_ - Enables suggestions for mistyped argument choices and "

"subparser names (default: ``False``)"

msgstr ""

msgid "color_ - Allow color output (default: ``True``)"

msgstr ""

msgid "*allow_abbrev* parameter was added."

msgstr ""

msgid ""

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

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

msgstr ""

msgid "*exit_on_error* parameter was added."

msgstr ""

msgid "*suggest_on_error* and *color* parameters were added."

msgstr ""

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

msgstr ""

msgid "prog"

msgstr ""

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 ""

msgid ""

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

"passed as argument."

msgstr ""

msgid ""

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

"zipfile was passed as argument."

msgstr ""

msgid ""

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

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

msgstr ""

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 ""

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 ""

msgid ""

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

"the ``__main__`` module attributes or from the ``prog=`` argument, is "

"available to help messages using the ``%(prog)s`` format specifier."

msgstr ""

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 ""

msgid ""

"The default ``prog`` value now reflects how ``__main__`` was actually "

"executed, rather than always being ``os.path.basename(sys.argv[0])``."

msgstr ""

msgid "usage"

msgstr ""

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 ""

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 ""

msgid ""

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

"in your usage messages."

msgstr ""

msgid ""

"When a custom usage message is specified for the main parser, you may also "

"want to consider passing the ``prog`` argument to :meth:`~ArgumentParser."

"add_subparsers` or the ``prog`` and the ``usage`` arguments to :meth:"

"`~_SubParsersAction.add_parser`, to ensure consistent command prefixes and "

"usage information across subparsers."

msgstr ""

msgid "description"

msgstr ""

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 ""

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 ""

msgid "epilog"

msgstr ""

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 ""

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 ""

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 ""

msgid "parents"

msgstr ""

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 ""

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 ""

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 ""

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 ""

msgid "formatter_class"

msgstr "formatter_class"

msgid ""

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

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

"classes:"

msgstr ""

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 ""

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 ""

msgid ""

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

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

"should not be line-wrapped::"

msgstr ""

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 ""

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 ""

msgid ""

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

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

msgstr ""

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 ""

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 ""

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 ""

msgid "prefix_chars"

msgstr ""

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 ""

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 ""

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 ""

msgid "fromfile_prefix_chars"

msgstr ""

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 ""

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 ""

msgid ""

"Arguments read from a file must be one per line by default (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 ""

msgid ""

"Empty lines are treated as empty strings (``''``), which are allowed as "

"values but not as arguments. Empty lines that are read as arguments will "

"result in an \"unrecognized arguments\" error."

msgstr ""

msgid ""

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

"to read the file containing arguments."

msgstr ""

msgid ""

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

"arguments will never be treated as file references."

msgstr ""

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 ""

msgid "argument_default"

msgstr "argument_default"

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 ""

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 ""

msgid "allow_abbrev"

msgstr ""

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 ""

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

msgstr ""

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 ""

msgid "conflict_handler"

msgstr ""

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 ""

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 ""

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 ""

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 ""

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 ""

msgid "add_help"

msgstr ""

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 ""

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 ""

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 ""

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 ""

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 ""

msgid "exit_on_error"

msgstr ""

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 ""

msgid ""

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

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

msgstr ""

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 ""

msgid "suggest_on_error"

msgstr ""

msgid ""

"By default, when a user passes an invalid argument choice or subparser "

"name, :class:`ArgumentParser` will exit with error info and list the "

"permissible argument choices (if specified) or subparser names as part of "

"the error message."

msgstr ""

msgid ""

"If the user would like to enable suggestions for mistyped argument choices "

"and subparser names, the feature can be enabled by setting "

"``suggest_on_error`` to ``True``. Note that this only applies for arguments "

"when the choices specified are strings::"

msgstr ""

msgid ""

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

">>> parser.add_argument('--action', choices=['debug', 'dryrun'])\n"

">>> parser.parse_args(['--action', 'debugg'])\n"

"usage: tester.py [-h] [--action {debug,dryrun}]\n"

"tester.py: error: argument --action: invalid choice: 'debugg', maybe you "

"meant 'debug'? (choose from debug, dryrun)"

msgstr ""

msgid ""

"If you're writing code that needs to be compatible with older Python "

"versions and want to opportunistically use ``suggest_on_error`` when it's "

"available, you can set it as an attribute after initializing the parser "

"instead of using the keyword argument::"

msgstr ""

msgid ""

">>> parser = argparse.ArgumentParser(description='Process some integers.')\n"

">>> parser.suggest_on_error = True"

msgstr ""

msgid "color"

msgstr ""

msgid ""

"By default, the help message is printed in color using `ANSI escape "

"sequences <https://en.wikipedia.org/wiki/ANSI_escape_code>`__. If you want "

"plain text help messages, you can disable this :ref:`in your local "

"environment <using-on-controlling-color>`, or in the argument parser itself "

"by setting ``color`` to ``False``::"

msgstr ""

msgid ""

">>> parser = argparse.ArgumentParser(description='Process some integers.',\n"

"... color=False)\n"

">>> parser.add_argument('--action', choices=['sum', 'max'])\n"

">>> parser.add_argument('integers', metavar='N', type=int, nargs='+',\n"

"... help='an integer for the accumulator')\n"

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

msgstr ""

msgid ""

"Note that when ``color=True``, colored output depends on both environment "

"variables and terminal capabilities. However, if ``color=False``, colored "

"output is always disabled, even if environment variables like "

"``FORCE_COLOR`` are set."

msgstr ""

msgid ""

"Error messages will include color codes when redirecting stderr to a file. "

"To avoid this, set the |NO_COLOR|_ or :envvar:`PYTHON_COLORS` environment "

"variable (for example, ``NO_COLOR=1 python script.py 2> errors.txt``)."

msgstr ""

msgid "The add_argument() method"

msgstr ""

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 ""

msgid ""

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

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

msgstr ""

msgid ""

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

"encountered at the command line."

msgstr ""

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

msgstr ""

msgid ""

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

msgstr ""

msgid ""

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

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

msgstr ""

msgid ""

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

msgstr ""

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

msgstr ""

msgid ""

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

"only)."

msgstr ""

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

msgstr ""

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

msgstr ""

msgid ""

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

"meth:`parse_args`."

msgstr ""

msgid "deprecated_ - Whether or not use of the argument is deprecated."

msgstr ""

msgid "The method returns an :class:`Action` object representing the argument."

msgstr ""

msgid "name or flags"

msgstr ""

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 ""

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

msgstr ""

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

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

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

msgstr ""

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

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

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 ""

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 ""

msgid ""

"By default, :mod:`!argparse` automatically handles the internal naming and "

"display names of arguments, simplifying the process without requiring "

"additional configuration. As such, you do not need to specify the dest_ and "

"metavar_ parameters. For optional arguments, the dest_ parameter defaults to "

"the argument name, with underscores ``_`` replacing hyphens ``-``. The "

"metavar_ parameter defaults to the upper-cased name. For example::"

msgstr ""

msgid ""

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

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

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

"Namespace(foo_bar='FOO-BAR')\n"

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

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

"\n"

"optional arguments:\n"

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

" --foo-bar FOO-BAR"

msgstr ""

msgid "action"

msgstr ""

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 ""

msgid ""

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

"action."

msgstr ""

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 ""

msgid ""

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

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

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

"Namespace(foo=42)"

msgstr ""

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

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

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

"Namespace(foo=42)"

msgid ""

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

"``'store_const'`` that respectively store the values ``True`` and ``False`` "

"with default values of ``False`` and ``True``::"

msgstr ""

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 ""

msgid ""

"``'append'`` - This appends each argument value to a list. It is useful for "

"allowing an option to be specified multiple times. If the default value is a "

"non-empty list, the parsed value will start with the default list's elements "

"and any values from the command line will be appended after those default "

"values. Example usage::"

msgstr ""

msgid ""

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