# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001-2026, 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

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2026-04-09 18:19+0000\n"

"PO-Revision-Date: 2025-09-22 15:57+0000\n"

"Last-Translator: python-doc bot, 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 sub-"

"commands"

msgstr ""

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

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

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 "

"and issues errors when users give the program invalid arguments."

msgstr ""

msgid "Example"

msgstr "Przykład"

msgid ""

"The following code is a Python program that takes a list of integers and "

"produces either the sum or the max::"

msgstr ""

msgid ""

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

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

msgstr ""

msgid ""

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

"of the command-line integers:"

msgstr ""

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

msgstr ""

msgid "The following sections walk you through this example."

msgstr ""

msgid "Creating a parser"

msgstr ""

msgid ""

"The first step in using the :mod:`argparse` is creating an :class:"

"`ArgumentParser` object::"

msgstr ""

msgid ""

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

"to parse the command line into Python data types."

msgstr ""

msgid "Adding arguments"

msgstr ""

msgid ""

"Filling an :class:`ArgumentParser` with information about program arguments "

"is done by making calls to the :meth:`~ArgumentParser.add_argument` method. "

"Generally, these calls tell the :class:`ArgumentParser` how to take the "

"strings on the command line and turn them into objects. This information is "

"stored and used when :meth:`~ArgumentParser.parse_args` is called. For "

"example::"

msgstr ""

msgid ""

"Later, calling :meth:`~ArgumentParser.parse_args` will return an object with "

"two attributes, ``integers`` and ``accumulate``. The ``integers`` attribute "

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

"either the :func:`sum` function, if ``--sum`` was specified at the command "

"line, or the :func:`max` function if it was not."

msgstr ""

msgid "Parsing arguments"

msgstr "Parsowanie argumentów"

msgid ""

":class:`ArgumentParser` parses arguments through the :meth:`~ArgumentParser."

"parse_args` method. This will inspect the command line, convert each "

"argument to the appropriate type and then invoke the appropriate action. In "

"most cases, this means a simple :class:`Namespace` object will be built up "

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

msgstr ""

msgid ""

"In a script, :meth:`~ArgumentParser.parse_args` will typically be called "

"with no arguments, and the :class:`ArgumentParser` will automatically "

"determine the command-line arguments from :data:`sys.argv`."

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: ``os.path.basename(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 ArgumentParser exits with error "

"info when an error occurs. (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 "The following sections describe how each of these are used."

msgstr ""

msgid "prog"

msgstr ""

msgid ""

"By default, :class:`ArgumentParser` objects use ``sys.argv[0]`` to determine "

"how to display the name of the program in help messages. This default is "

"almost always desirable because it will make the help messages match how the "

"program was invoked on the command line. For example, consider a file named "

"``myprogram.py`` with the following code::"

msgstr ""

msgid ""

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

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

msgstr ""

msgid ""

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

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

msgstr ""

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

msgid "usage"

msgstr ""

msgid ""

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

"arguments it contains::"

msgstr ""

msgid ""

"The default message can be overridden with the ``usage=`` keyword argument::"

msgstr ""

msgid ""

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

"in your usage messages."

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

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

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

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

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

"should not be line-wrapped::"

msgstr ""

msgid ""

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

"text, including argument descriptions. However, multiple new lines 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 ""

":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 "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 ArgumentParser constructor::"

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, for example 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 ""

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

msgid ""

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

"arguments will never be treated as file references."

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

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

"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, ArgumentParser objects add an option which simply displays the "

"parser's help message. For example, consider a file named ``myprogram.py`` "

"containing the following code::"

msgstr ""

msgid ""

"If ``-h`` or ``--help`` is supplied at the command line, the 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 ""

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

"exit with error info."

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 "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 "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. For example, an optional argument could be "

"created like::"

msgstr ""

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

msgstr ""

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 "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. For example::"

msgstr ""

msgid ""

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

"argument. The ``'store_const'`` action is most commonly used with optional "

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

msgstr ""

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. For example::"

msgstr ""

msgid ""

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

"list. This is useful to allow an option to be specified multiple times. "

"Example usage::"

msgstr ""

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

msgid ""

"``'count'`` - This counts the number of times a keyword argument occurs. For "

"example, this is useful for increasing verbosity levels::"

msgstr ""

msgid "Note, the *default* will be ``None`` unless explicitly set to *0*."

msgstr ""

msgid ""

"``'help'`` - This prints a complete help message for all the options in the "

"current parser and then exits. By default a help action is automatically "

"added to the parser. See :class:`ArgumentParser` for details of how the "

"output is created."

msgstr ""

msgid ""

"``'version'`` - This expects a ``version=`` keyword argument in the :meth:"

"`~ArgumentParser.add_argument` call, and prints version information and "

"exits when invoked::"

msgstr ""

msgid ""

"``'extend'`` - This stores a list, and extends each argument value to the "

"list. Example usage::"

msgstr ""

msgid ""

"You may also specify an arbitrary action by passing an Action subclass or "

"other object that implements the same interface. The "

"``BooleanOptionalAction`` is available in ``argparse`` and adds support for "

"boolean actions such as ``--foo`` and ``--no-foo``::"

msgstr ""

msgid ""

"The recommended way to create a custom action is to extend :class:`Action`, "

"overriding the ``__call__`` method and optionally the ``__init__`` and "

"``format_usage`` methods."

msgstr ""

msgid "An example of a custom action::"

msgstr ""

msgid "For more details, see :class:`Action`."

msgstr ""

msgid "nargs"

msgstr ""

msgid ""

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

"a single action to be taken. The ``nargs`` keyword argument associates a "

"different number of command-line arguments with a single action. The "

"supported values are:"

msgstr ""

msgid ""

"``N`` (an integer). ``N`` arguments from the command line will be gathered "

"together into a list. For example::"

msgstr ""

msgid ""

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

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

msgstr ""

msgid ""

"``'?'``. One argument will be consumed from the command line if possible, "

"and produced as a single item. If no command-line argument is present, the "

"value from default_ will be produced. Note that for optional arguments, "

"there is an additional case - the option string is present but not followed "

"by a command-line argument. In this case the value from const_ will be "

"produced. Some examples to illustrate this::"

msgstr ""

msgid ""

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

"output files::"

msgstr ""

msgid ""

"``'*'``. All command-line arguments present are gathered into a list. Note "

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

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

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

msgstr ""

msgid ""

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

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

"least one command-line argument present. For example::"

msgstr ""

msgid ""

"If the ``nargs`` keyword argument is not provided, the number of arguments "

"consumed is determined by the action_. Generally this means a single "

"command-line argument will be consumed and a single item (not a list) will "

"be produced."

msgstr ""

msgid "const"

msgstr ""

msgid ""

"The ``const`` argument of :meth:`~ArgumentParser.add_argument` is used to "

"hold constant values that are not read from the command line but are "

"required for the various :class:`ArgumentParser` actions. The two most "

"common uses of it are:"

msgstr ""

msgid ""

"When :meth:`~ArgumentParser.add_argument` is called with "

"``action='store_const'`` or ``action='append_const'``. These actions add "

"the ``const`` value to one of the attributes of the object returned by :meth:"

"`~ArgumentParser.parse_args`. See the action_ description for examples."

msgstr ""

msgid ""

"When :meth:`~ArgumentParser.add_argument` is called with option strings "

"(like ``-f`` or ``--foo``) and ``nargs='?'``. This creates an optional "

"argument that can be followed by zero or one command-line arguments. When "

"parsing the command line, if the option string is encountered with no "

"command-line argument following it, the value of ``const`` will be assumed "

"instead. See the nargs_ description for examples."

msgstr ""

msgid ""

"With the ``'store_const'`` and ``'append_const'`` actions, the ``const`` "

"keyword argument must be given. For other actions, it defaults to ``None``."

msgstr ""

msgid "default"

msgstr ""

msgid ""

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

"command line. The ``default`` keyword argument of :meth:`~ArgumentParser."

"add_argument`, whose value defaults to ``None``, specifies what value should "

"be used if the command-line argument is not present. For optional arguments, "

"the ``default`` value is used when the option string was not present at the "

"command line::"

msgstr ""

msgid ""

"If the target namespace already has an attribute set, the action *default* "

"will not over write it::"

msgstr ""

msgid ""

"If the ``default`` value is a string, the parser parses the value as if it "

"were a command-line argument. In particular, the parser applies any type_ "

"conversion argument, if provided, before setting the attribute on the :class:"

"`Namespace` return value. Otherwise, the parser uses the value as is::"

msgstr ""

msgid ""

"For positional arguments with nargs_ equal to ``?`` or ``*``, the "

"``default`` value is used when no command-line argument was present::"

msgstr ""

msgid ""

"Providing ``default=argparse.SUPPRESS`` causes no attribute to be added if "

"the command-line argument was not present::"

msgstr ""

msgid "type"

msgstr "typ"

msgid ""

"By default, the parser reads command-line arguments in as simple strings. "

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

"as another type, such as a :class:`float` or :class:`int`. The ``type`` "

"keyword for :meth:`~ArgumentParser.add_argument` allows any necessary type-"

"checking and type conversions to be performed."

msgstr ""

msgid ""

"If the type_ keyword is used with the default_ keyword, the type converter "

"is only applied if the default is a string."

msgstr ""

msgid ""

"The argument to ``type`` can be any callable that accepts a single string. "

"If the function raises :exc:`ArgumentTypeError`, :exc:`TypeError`, or :exc:"

"`ValueError`, the exception is caught and a nicely formatted error message "

"is displayed. No other exception types are handled."

msgstr ""

msgid "Common built-in types and functions can be used as type converters:"

msgstr ""

msgid "User defined functions can be used as well:"

msgstr ""

msgid ""

"The :func:`bool` function is not recommended as a type converter. All it "

"does is convert empty strings to ``False`` and non-empty strings to "

"``True``. This is usually not what is desired."

msgstr ""

msgid ""

"In general, the ``type`` keyword is a convenience that should only be used "

"for simple conversions that can only raise one of the three supported "

"exceptions. Anything with more interesting error-handling or resource "

"management should be done downstream after the arguments are parsed."

msgstr ""

msgid ""

"For example, JSON or YAML conversions have complex error cases that require "

"better reporting than can be given by the ``type`` keyword. A :exc:`~json."

"JSONDecodeError` would not be well formatted and a :exc:`FileNotFound` "

"exception would not be handled at all."

msgstr ""

msgid ""

"Even :class:`~argparse.FileType` has its limitations for use with the "

"``type`` keyword. If one argument uses *FileType* and then a subsequent "

"argument fails, an error is reported but the file is not automatically "

"closed. In this case, it would be better to wait until after the parser has "

"run and then use the :keyword:`with`-statement to manage the files."

msgstr ""

msgid ""

"For type checkers that simply check against a fixed set of values, consider "

"using the choices_ keyword instead."

msgstr ""

msgid "choices"

msgstr ""

msgid ""

"Some command-line arguments should be selected from a restricted set of "

"values. These can be handled by passing a sequence object as the *choices* "

"keyword argument to :meth:`~ArgumentParser.add_argument`. When the command "

"line is parsed, argument values will be checked, and an error message will "

"be displayed if the argument was not one of the acceptable values::"

msgstr ""

msgid ""

"Note that inclusion in the *choices* sequence is checked after any type_ "

"conversions have been performed, so the type of the objects in the *choices* "

"sequence should match the type_ specified::"

msgstr ""

msgid ""

"Any sequence can be passed as the *choices* value, so :class:`list` "

"objects, :class:`tuple` objects, and custom sequences are all supported."

msgstr ""

msgid ""

"Use of :class:`enum.Enum` is not recommended because it is difficult to "

"control its appearance in usage, help, and error messages."

msgstr ""

msgid ""

"Formatted choices overrides the default *metavar* which is normally derived "

"from *dest*. This is usually what you want because the user never sees the "

"*dest* parameter. If this display isn't desirable (perhaps because there "

"are many choices), just specify an explicit metavar_."

msgstr ""

msgid "required"

msgstr ""

msgid ""

"In general, the :mod:`argparse` module assumes that flags like ``-f`` and "

"``--bar`` indicate *optional* arguments, which can always be omitted at the "

"command line. To make an option *required*, ``True`` can be specified for "

"the ``required=`` keyword argument to :meth:`~ArgumentParser.add_argument`::"

msgstr ""

msgid ""

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

"`~ArgumentParser.parse_args` will report an error if that option is not "

"present at the command line."

msgstr ""

msgid ""

"Required options are generally considered bad form because users expect "

"*options* to be *optional*, and thus they should be avoided when possible."

msgstr ""

msgid "help"

msgstr "pomoc"

msgid ""

"The ``help`` value is a string containing a brief description of the "

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

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

"each argument::"

msgstr ""

msgid ""

"The ``help`` strings can include various format specifiers to avoid "

"repetition of things like the program name or the argument default_. The "

"available specifiers include the program name, ``%(prog)s`` and most keyword "

"arguments to :meth:`~ArgumentParser.add_argument`, e.g. ``%(default)s``, "

"``%(type)s``, etc.::"

msgstr ""

msgid ""

"As the help string supports %-formatting, if you want a literal ``%`` to "

"appear in the help string, you must escape it as ``%%``."

msgstr ""

msgid ""

":mod:`argparse` supports silencing the help entry for certain options, by "

"setting the ``help`` value to ``argparse.SUPPRESS``::"

msgstr ""

msgid "metavar"

msgstr ""

msgid ""

"When :class:`ArgumentParser` generates help messages, it needs some way to "

"refer to each expected argument. By default, ArgumentParser objects use the "

"dest_ value as the \"name\" of each object. By default, for positional "

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

"argument actions, the dest_ value is uppercased. So, a single positional "

"argument with ``dest='bar'`` will be referred to as ``bar``. A single "

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

"argument will be referred to as ``FOO``. An example::"

msgstr ""

msgid "An alternative name can be specified with ``metavar``::"

msgstr ""

msgid ""

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

"attribute on the :meth:`~ArgumentParser.parse_args` object is still "

"determined by the dest_ value."

msgstr ""

msgid ""

"Different values of ``nargs`` may cause the metavar to be used multiple "

"times. Providing a tuple to ``metavar`` specifies a different display for "

"each of the arguments::"

msgstr ""

msgid "dest"

msgstr ""

msgid ""

"Most :class:`ArgumentParser` actions add some value as an attribute of the "

"object returned by :meth:`~ArgumentParser.parse_args`. The name of this "

"attribute is determined by the ``dest`` keyword argument of :meth:"

"`~ArgumentParser.add_argument`. For positional argument actions, ``dest`` "

"is normally supplied as the first argument to :meth:`~ArgumentParser."

"add_argument`::"

msgstr ""

msgid ""

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

"from the option strings. :class:`ArgumentParser` generates the value of "

"``dest`` by taking the first long option string and stripping away the "

"initial ``--`` string. If no long option strings were supplied, ``dest`` "

"will be derived from the first short option string by stripping the initial "

"``-`` character. Any internal ``-`` characters will be converted to ``_`` "

"characters to make sure the string is a valid attribute name. The examples "

"below illustrate this behavior::"

msgstr ""

msgid "``dest`` allows a custom attribute name to be provided::"

msgstr ""

msgid "Action classes"

msgstr ""

msgid ""

"Action classes implement the Action API, a callable which returns a callable "

"which processes arguments from the command-line. Any object which follows "

"this API may be passed as the ``action`` parameter to :meth:`add_argument`."

msgstr ""

msgid ""

"Action objects are used by an ArgumentParser to represent the information "

"needed to parse a single argument from one or more strings from the command "

"line. The Action class must accept the two positional arguments plus any "

"keyword arguments passed to :meth:`ArgumentParser.add_argument` except for "

"the ``action`` itself."

msgstr ""

msgid ""

"Instances of Action (or return value of any callable to the ``action`` "

"parameter) should have attributes \"dest\", \"option_strings\", \"default\", "

"\"type\", \"required\", \"help\", etc. defined. The easiest way to ensure "

"these attributes are defined is to call ``Action.__init__``."

msgstr ""

msgid ""

"Action instances should be callable, so subclasses must override the "

"``__call__`` method, which should accept four parameters:"

msgstr ""

msgid "``parser`` - The ArgumentParser object which contains this action."

msgstr ""

msgid ""

"``namespace`` - The :class:`Namespace` object that will be returned by :meth:"

"`~ArgumentParser.parse_args`. Most actions add an attribute to this object "

"using :func:`setattr`."

msgstr ""

msgid ""

"``values`` - The associated command-line arguments, with any type "