2016-10-30 09:46:26 +00:00
|
|
|
# SOME DESCRIPTIVE TITLE.
|
|
|
|
# Copyright (C) 2001-2016, 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.6\n"
|
|
|
|
"Report-Msgid-Bugs-To: \n"
|
2017-05-27 17:46:38 +00:00
|
|
|
"POT-Creation-Date: 2017-05-27 19:40+0200\n"
|
2016-10-30 09:46:26 +00:00
|
|
|
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
|
|
|
|
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
|
|
|
|
"Language-Team: LANGUAGE <LL@li.org>\n"
|
2017-05-23 22:40:56 +00:00
|
|
|
"Language: fr\n"
|
2016-10-30 09:46:26 +00:00
|
|
|
"MIME-Version: 1.0\n"
|
|
|
|
"Content-Type: text/plain; charset=UTF-8\n"
|
|
|
|
"Content-Transfer-Encoding: 8bit\n"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:2
|
|
|
|
msgid ""
|
|
|
|
":mod:`argparse` --- Parser for command-line options, arguments and sub-"
|
|
|
|
"commands"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:12
|
|
|
|
msgid "**Source code:** :source:`Lib/argparse.py`"
|
|
|
|
msgstr "**Code source:** :source:`Lib/argparse.py`"
|
|
|
|
|
|
|
|
#: ../Doc/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 ""
|
|
|
|
|
|
|
|
#: ../Doc/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 "
|
|
|
|
"and issues errors when users give the program invalid arguments."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:30
|
|
|
|
msgid "Example"
|
|
|
|
msgstr "Exemple"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:32
|
|
|
|
msgid ""
|
|
|
|
"The following code is a Python program that takes a list of integers and "
|
|
|
|
"produces either the sum or the max::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:47
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:64
|
|
|
|
msgid ""
|
|
|
|
"When run with the appropriate arguments, it prints either the sum or the max "
|
|
|
|
"of the command-line integers:"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:75
|
|
|
|
msgid "If invalid arguments are passed in, it will issue an error:"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:83
|
|
|
|
msgid "The following sections walk you through this example."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:87
|
|
|
|
msgid "Creating a parser"
|
|
|
|
msgstr "Créer un parseur"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:89
|
|
|
|
msgid ""
|
|
|
|
"The first step in using the :mod:`argparse` is creating an :class:"
|
|
|
|
"`ArgumentParser` object::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:94
|
|
|
|
msgid ""
|
|
|
|
"The :class:`ArgumentParser` object will hold all the information necessary "
|
|
|
|
"to parse the command line into Python data types."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:99
|
|
|
|
msgid "Adding arguments"
|
|
|
|
msgstr "Ajouter des arguments"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:101
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:113
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:121
|
|
|
|
msgid "Parsing arguments"
|
|
|
|
msgstr "Analyse des arguments"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:123
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:132
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:138
|
|
|
|
msgid "ArgumentParser objects"
|
|
|
|
msgstr "Objets ArgumentParser"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:147
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:151
|
|
|
|
msgid "prog_ - The name of the program (default: ``sys.argv[0]``)"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:153
|
|
|
|
msgid ""
|
|
|
|
"usage_ - The string describing the program usage (default: generated from "
|
|
|
|
"arguments added to parser)"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:156
|
|
|
|
msgid "description_ - Text to display before the argument help (default: none)"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:158
|
|
|
|
msgid "epilog_ - Text to display after the argument help (default: none)"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:160
|
|
|
|
msgid ""
|
|
|
|
"parents_ - A list of :class:`ArgumentParser` objects whose arguments should "
|
|
|
|
"also be included"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:163
|
|
|
|
msgid "formatter_class_ - A class for customizing the help output"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:165
|
|
|
|
msgid ""
|
|
|
|
"prefix_chars_ - The set of characters that prefix optional arguments "
|
|
|
|
"(default: '-')"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:168
|
|
|
|
msgid ""
|
|
|
|
"fromfile_prefix_chars_ - The set of characters that prefix files from which "
|
|
|
|
"additional arguments should be read (default: ``None``)"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:171
|
|
|
|
msgid ""
|
|
|
|
"argument_default_ - The global default value for arguments (default: "
|
|
|
|
"``None``)"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:174
|
|
|
|
msgid ""
|
|
|
|
"conflict_handler_ - The strategy for resolving conflicting optionals "
|
|
|
|
"(usually unnecessary)"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:177
|
2017-04-02 20:14:06 +00:00
|
|
|
msgid ""
|
|
|
|
"add_help_ - Add a ``-h/--help`` option to the parser (default: ``True``)"
|
2016-10-30 09:46:26 +00:00
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:179
|
|
|
|
msgid ""
|
|
|
|
"allow_abbrev_ - Allows long options to be abbreviated if the abbreviation is "
|
|
|
|
"unambiguous. (default: ``True``)"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:182
|
|
|
|
msgid "*allow_abbrev* parameter was added."
|
|
|
|
msgstr "Le paramètre *allow_abbrev* est ajouté."
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:185 ../Doc/library/argparse.rst:681
|
|
|
|
msgid "The following sections describe how each of these are used."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:189
|
|
|
|
msgid "prog"
|
|
|
|
msgstr "prog"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:191
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:202
|
|
|
|
msgid ""
|
|
|
|
"The help for this program will display ``myprogram.py`` as the program name "
|
|
|
|
"(regardless of where the program was invoked from):"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:221
|
|
|
|
msgid ""
|
|
|
|
"To change this default behavior, another value can be supplied using the "
|
|
|
|
"``prog=`` argument to :class:`ArgumentParser`::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:231
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:248
|
|
|
|
msgid "usage"
|
|
|
|
msgstr "usage"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:250
|
|
|
|
msgid ""
|
|
|
|
"By default, :class:`ArgumentParser` calculates the usage message from the "
|
|
|
|
"arguments it contains::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:266
|
|
|
|
msgid ""
|
|
|
|
"The default message can be overridden with the ``usage=`` keyword argument::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:281
|
|
|
|
msgid ""
|
|
|
|
"The ``%(prog)s`` format specifier is available to fill in the program name "
|
|
|
|
"in your usage messages."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:286
|
|
|
|
msgid "description"
|
|
|
|
msgstr "description"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:288
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:303
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:308
|
|
|
|
msgid "epilog"
|
|
|
|
msgstr "epilog"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:310
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:327
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:333
|
|
|
|
msgid "parents"
|
|
|
|
msgstr "parents"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:335
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:355
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:360
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:366
|
|
|
|
msgid "formatter_class"
|
|
|
|
msgstr "formatte_class"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:368
|
|
|
|
msgid ""
|
|
|
|
":class:`ArgumentParser` objects allow the help formatting to be customized "
|
|
|
|
"by specifying an alternate formatting class. Currently, there are four such "
|
|
|
|
"classes:"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:377
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:402
|
|
|
|
msgid ""
|
|
|
|
"Passing :class:`RawDescriptionHelpFormatter` as ``formatter_class=`` "
|
|
|
|
"indicates that description_ and epilog_ are already correctly formatted and "
|
|
|
|
"should not be line-wrapped::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:428
|
|
|
|
msgid ""
|
|
|
|
":class:`RawTextHelpFormatter` maintains whitespace for all sorts of help "
|
|
|
|
"text, including argument descriptions."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:431
|
|
|
|
msgid ""
|
|
|
|
":class:`ArgumentDefaultsHelpFormatter` automatically adds information about "
|
|
|
|
"default values to each of the argument help messages::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:449
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:470
|
|
|
|
msgid "prefix_chars"
|
|
|
|
msgstr "préfixe_chars"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:472
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:484
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:490
|
|
|
|
msgid "fromfile_prefix_chars"
|
|
|
|
msgstr "fromfile_préfixe_chars"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:492
|
|
|
|
msgid ""
|
|
|
|
"Sometimes, for example when dealing with a particularly long argument lists, "
|
|
|
|
"it may make sense to keep the list of arguments in a file rather than typing "
|
|
|
|
"it out at the command line. If the ``fromfile_prefix_chars=`` argument is "
|
|
|
|
"given to the :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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:506
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:512
|
|
|
|
msgid ""
|
|
|
|
"The ``fromfile_prefix_chars=`` argument defaults to ``None``, meaning that "
|
|
|
|
"arguments will never be treated as file references."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:517
|
|
|
|
msgid "argument_default"
|
|
|
|
msgstr "argument_default"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:519
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:539
|
|
|
|
msgid "allow_abbrev"
|
|
|
|
msgstr "allow_abbrev"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:541
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:545
|
|
|
|
msgid "This feature can be disabled by setting ``allow_abbrev`` to ``False``::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:558
|
|
|
|
msgid "conflict_handler"
|
|
|
|
msgstr "conflict_handler"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:560
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:572
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:588
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:595
|
|
|
|
msgid "add_help"
|
|
|
|
msgstr "add_help"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:597
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:606
|
|
|
|
msgid ""
|
|
|
|
"If ``-h`` or ``--help`` is supplied at the command line, the ArgumentParser "
|
|
|
|
"help will be printed:"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:618
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:630
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:645
|
|
|
|
msgid "The add_argument() method"
|
|
|
|
msgstr "La méthode add_argument()"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:651
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:654
|
|
|
|
msgid ""
|
|
|
|
"`name or flags`_ - Either a name or a list of option strings, e.g. ``foo`` "
|
|
|
|
"or ``-f, --foo``."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:657
|
|
|
|
msgid ""
|
|
|
|
"action_ - The basic type of action to be taken when this argument is "
|
|
|
|
"encountered at the command line."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:660
|
|
|
|
msgid "nargs_ - The number of command-line arguments that should be consumed."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:662
|
|
|
|
msgid ""
|
|
|
|
"const_ - A constant value required by some action_ and nargs_ selections."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:664
|
|
|
|
msgid ""
|
|
|
|
"default_ - The value produced if the argument is absent from the command "
|
|
|
|
"line."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:667
|
|
|
|
msgid ""
|
|
|
|
"type_ - The type to which the command-line argument should be converted."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:669
|
|
|
|
msgid "choices_ - A container of the allowable values for the argument."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:671
|
|
|
|
msgid ""
|
|
|
|
"required_ - Whether or not the command-line option may be omitted (optionals "
|
|
|
|
"only)."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:674
|
|
|
|
msgid "help_ - A brief description of what the argument does."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:676
|
|
|
|
msgid "metavar_ - A name for the argument in usage messages."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:678
|
|
|
|
msgid ""
|
|
|
|
"dest_ - The name of the attribute to be added to the object returned by :"
|
|
|
|
"meth:`parse_args`."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:685
|
|
|
|
msgid "name or flags"
|
|
|
|
msgstr "nom ou option"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:687
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:696
|
|
|
|
msgid "while a positional argument could be created like::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:700
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:717
|
|
|
|
msgid "action"
|
|
|
|
msgstr "action"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:719
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:725
|
|
|
|
msgid ""
|
|
|
|
"``'store'`` - This just stores the argument's value. This is the default "
|
|
|
|
"action. For example::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:733
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:742
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:754
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:763
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:775
|
|
|
|
msgid ""
|
|
|
|
"``'count'`` - This counts the number of times a keyword argument occurs. For "
|
|
|
|
"example, this is useful for increasing verbosity levels::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:783
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:788
|
|
|
|
msgid ""
|
|
|
|
"``'version'`` - This expects a ``version=`` keyword argument in the :meth:"
|
|
|
|
"`~ArgumentParser.add_argument` call, and prints version information and "
|
|
|
|
"exits when invoked::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:798
|
|
|
|
msgid ""
|
|
|
|
"You may also specify an arbitrary action by passing an Action subclass or "
|
|
|
|
"other object that implements the same interface. The recommended way to do "
|
|
|
|
"this is to extend :class:`Action`, overriding the ``__call__`` method and "
|
|
|
|
"optionally the ``__init__`` method."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:803
|
|
|
|
msgid "An example of a custom action::"
|
|
|
|
msgstr "Un exemple d'action personnalisée : ::"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:823
|
|
|
|
msgid "For more details, see :class:`Action`."
|
|
|
|
msgstr "Pour plus d'information, voir :class:`Action`."
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:826
|
|
|
|
msgid "nargs"
|
|
|
|
msgstr "nargs"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:828
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:833
|
|
|
|
msgid ""
|
|
|
|
"``N`` (an integer). ``N`` arguments from the command line will be gathered "
|
|
|
|
"together into a list. For example::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:842
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:845
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:862
|
|
|
|
msgid ""
|
|
|
|
"One of the more common uses of ``nargs='?'`` is to allow optional input and "
|
|
|
|
"output files::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:877
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:889
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:901
|
|
|
|
msgid ""
|
|
|
|
"``argparse.REMAINDER``. All the remaining command-line arguments are "
|
|
|
|
"gathered into a list. This is commonly useful for command line utilities "
|
|
|
|
"that dispatch to other command line utilities::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:912
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:918
|
|
|
|
msgid "const"
|
|
|
|
msgstr "const"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:920
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:924
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:929
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:936
|
|
|
|
msgid ""
|
|
|
|
"With the ``'store_const'`` and ``'append_const'`` actions, the ``const`` "
|
|
|
|
"keyword argument must be given. For other actions, it defaults to ``None``."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:941
|
|
|
|
msgid "default"
|
|
|
|
msgstr "default"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:943
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:957
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:968
|
|
|
|
msgid ""
|
|
|
|
"For positional arguments with nargs_ equal to ``?`` or ``*``, the "
|
|
|
|
"``default`` value is used when no command-line argument was present::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:979
|
|
|
|
msgid ""
|
|
|
|
"Providing ``default=argparse.SUPPRESS`` causes no attribute to be added if "
|
|
|
|
"the command-line argument was not present.::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:991
|
|
|
|
msgid "type"
|
|
|
|
msgstr "type"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:993
|
|
|
|
msgid ""
|
|
|
|
"By default, :class:`ArgumentParser` objects read command-line arguments in "
|
|
|
|
"as simple strings. However, quite often the command-line string should "
|
|
|
|
"instead be interpreted as another type, like a :class:`float` or :class:"
|
|
|
|
"`int`. The ``type`` keyword argument of :meth:`~ArgumentParser."
|
|
|
|
"add_argument` allows any necessary type-checking and type conversions to be "
|
|
|
|
"performed. Common built-in types and functions can be used directly as the "
|
|
|
|
"value of the ``type`` argument::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1006
|
|
|
|
msgid ""
|
|
|
|
"See the section on the default_ keyword argument for information on when the "
|
|
|
|
"``type`` argument is applied to default arguments."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1009
|
|
|
|
msgid ""
|
|
|
|
"To ease the use of various types of files, the argparse module provides the "
|
|
|
|
"factory FileType which takes the ``mode=``, ``bufsize=``, ``encoding=`` and "
|
|
|
|
"``errors=`` arguments of the :func:`open` function. For example, "
|
|
|
|
"``FileType('w')`` can be used to create a writable file::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1019
|
|
|
|
msgid ""
|
|
|
|
"``type=`` can take any callable that takes a single string argument and "
|
|
|
|
"returns the converted value::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1038
|
|
|
|
msgid ""
|
|
|
|
"The choices_ keyword argument may be more convenient for type checkers that "
|
|
|
|
"simply check against a range of values::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1049
|
|
|
|
msgid "See the choices_ section for more details."
|
|
|
|
msgstr "Voir la section choices_ pour plus de détails."
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1053
|
|
|
|
msgid "choices"
|
|
|
|
msgstr "choices"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1055
|
|
|
|
msgid ""
|
|
|
|
"Some command-line arguments should be selected from a restricted set of "
|
|
|
|
"values. These can be handled by passing a container 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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1070
|
|
|
|
msgid ""
|
|
|
|
"Note that inclusion in the *choices* container is checked after any type_ "
|
|
|
|
"conversions have been performed, so the type of the objects in the *choices* "
|
|
|
|
"container should match the type_ specified::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1082
|
|
|
|
msgid ""
|
|
|
|
"Any object that supports the ``in`` operator can be passed as the *choices* "
|
|
|
|
"value, so :class:`dict` objects, :class:`set` objects, custom containers, "
|
|
|
|
"etc. are all supported."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1088
|
|
|
|
msgid "required"
|
|
|
|
msgstr "required"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1090
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1103
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1109
|
|
|
|
msgid ""
|
|
|
|
"Required options are generally considered bad form because users expect "
|
|
|
|
"*options* to be *optional*, and thus they should be avoided when possible."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1114
|
|
|
|
msgid "help"
|
|
|
|
msgstr "help"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1116
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1136
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1153
|
|
|
|
msgid ""
|
|
|
|
"As the help string supports %-formatting, if you want a literal ``%`` to "
|
|
|
|
"appear in the help string, you must escape it as ``%%``."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1156
|
|
|
|
msgid ""
|
|
|
|
":mod:`argparse` supports silencing the help entry for certain options, by "
|
|
|
|
"setting the ``help`` value to ``argparse.SUPPRESS``::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1169
|
|
|
|
msgid "metavar"
|
|
|
|
msgstr "metavar"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1171
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1195
|
|
|
|
msgid "An alternative name can be specified with ``metavar``::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1212
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1216
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1233
|
|
|
|
msgid "dest"
|
|
|
|
msgstr "dest"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1235
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1247
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1264
|
|
|
|
msgid "``dest`` allows a custom attribute name to be provided::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1272
|
|
|
|
msgid "Action classes"
|
|
|
|
msgstr "Classes Action"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1274
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1283
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1289
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1294
|
|
|
|
msgid ""
|
|
|
|
"Action instances should be callable, so subclasses must override the "
|
|
|
|
"``__call__`` method, which should accept four parameters:"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1297
|
|
|
|
msgid "``parser`` - The ArgumentParser object which contains this action."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1299
|
|
|
|
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 ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1303
|
|
|
|
msgid ""
|
|
|
|
"``values`` - The associated command-line arguments, with any type "
|
|
|
|
"conversions applied. Type conversions are specified with the type_ keyword "
|
|
|
|
"argument to :meth:`~ArgumentParser.add_argument`."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1307
|
|
|
|
msgid ""
|
|
|
|
"``option_string`` - The option string that was used to invoke this action. "
|
|
|
|
"The ``option_string`` argument is optional, and will be absent if the action "
|
|
|
|
"is associated with a positional argument."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1311
|
|
|
|
msgid ""
|
|
|
|
"The ``__call__`` method may perform arbitrary actions, but will typically "
|
|
|
|
"set attributes on the ``namespace`` based on ``dest`` and ``values``."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1316
|
|
|
|
msgid "The parse_args() method"
|
|
|
|
msgstr "La méthode parse_args()"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1320
|
|
|
|
msgid ""
|
|
|
|
"Convert argument strings to objects and assign them as attributes of the "
|
|
|
|
"namespace. Return the populated namespace."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1323
|
|
|
|
msgid ""
|
|
|
|
"Previous calls to :meth:`add_argument` determine exactly what objects are "
|
|
|
|
"created and how they are assigned. See the documentation for :meth:"
|
|
|
|
"`add_argument` for details."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1327
|
|
|
|
msgid ""
|
|
|
|
"By default, the argument strings are taken from :data:`sys.argv`, and a new "
|
|
|
|
"empty :class:`Namespace` object is created for the attributes."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1332
|
|
|
|
msgid "Option value syntax"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1334
|
|
|
|
msgid ""
|
|
|
|
"The :meth:`~ArgumentParser.parse_args` method supports several ways of "
|
|
|
|
"specifying the value of an option (if it takes one). In the simplest case, "
|
|
|
|
"the option and its value are passed as two separate arguments::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1346
|
|
|
|
msgid ""
|
|
|
|
"For long options (options with names longer than a single character), the "
|
|
|
|
"option and value can also be passed as a single command-line argument, using "
|
|
|
|
"``=`` to separate them::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1353
|
|
|
|
msgid ""
|
|
|
|
"For short options (options only one character long), the option and its "
|
|
|
|
"value can be concatenated::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1359
|
|
|
|
msgid ""
|
|
|
|
"Several short options can be joined together, using only a single ``-`` "
|
|
|
|
"prefix, as long as only the last option (or none of them) requires a value::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1371
|
|
|
|
msgid "Invalid arguments"
|
|
|
|
msgstr "Arguments invalides"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1373
|
|
|
|
msgid ""
|
|
|
|
"While parsing the command line, :meth:`~ArgumentParser.parse_args` checks "
|
|
|
|
"for a variety of errors, including ambiguous options, invalid types, invalid "
|
|
|
|
"options, wrong number of positional arguments, etc. When it encounters such "
|
|
|
|
"an error, it exits and prints the error along with a usage message::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1399
|
|
|
|
msgid "Arguments containing ``-``"
|
|
|
|
msgstr "Arguments contenant ``-``"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1401
|
|
|
|
msgid ""
|
|
|
|
"The :meth:`~ArgumentParser.parse_args` method attempts to give errors "
|
|
|
|
"whenever the user has clearly made a mistake, but some situations are "
|
|
|
|
"inherently ambiguous. For example, the command-line argument ``-1`` could "
|
|
|
|
"either be an attempt to specify an option or an attempt to provide a "
|
|
|
|
"positional argument. The :meth:`~ArgumentParser.parse_args` method is "
|
|
|
|
"cautious here: positional arguments may only begin with ``-`` if they look "
|
|
|
|
"like negative numbers and there are no options in the parser that look like "
|
|
|
|
"negative numbers::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1439
|
|
|
|
msgid ""
|
|
|
|
"If you have positional arguments that must begin with ``-`` and don't look "
|
|
|
|
"like negative numbers, you can insert the pseudo-argument ``'--'`` which "
|
|
|
|
"tells :meth:`~ArgumentParser.parse_args` that everything after that is a "
|
|
|
|
"positional argument::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1450
|
|
|
|
msgid "Argument abbreviations (prefix matching)"
|
|
|
|
msgstr "Arguments abrégés (Part comparaison de leur préfixes)"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1452
|
|
|
|
msgid ""
|
|
|
|
"The :meth:`~ArgumentParser.parse_args` method :ref:`by default "
|
|
|
|
"<allow_abbrev>` allows long options to be abbreviated to a prefix, if the "
|
|
|
|
"abbreviation is unambiguous (the prefix matches a unique option)::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1467
|
|
|
|
msgid ""
|
|
|
|
"An error is produced for arguments that could produce more than one options. "
|
|
|
|
"This feature can be disabled by setting :ref:`allow_abbrev` to ``False``."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1472
|
|
|
|
msgid "Beyond ``sys.argv``"
|
|
|
|
msgstr "Au delà de ``sys.argv``"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1474
|
|
|
|
msgid ""
|
|
|
|
"Sometimes it may be useful to have an ArgumentParser parse arguments other "
|
|
|
|
"than those of :data:`sys.argv`. This can be accomplished by passing a list "
|
|
|
|
"of strings to :meth:`~ArgumentParser.parse_args`. This is useful for "
|
|
|
|
"testing at the interactive prompt::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1493
|
|
|
|
msgid "The Namespace object"
|
|
|
|
msgstr "L'objet Namespace"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1497
|
|
|
|
msgid ""
|
|
|
|
"Simple class used by default by :meth:`~ArgumentParser.parse_args` to create "
|
|
|
|
"an object holding attributes and return it."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1500
|
|
|
|
msgid ""
|
|
|
|
"This class is deliberately simple, just an :class:`object` subclass with a "
|
|
|
|
"readable string representation. If you prefer to have dict-like view of the "
|
|
|
|
"attributes, you can use the standard Python idiom, :func:`vars`::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1510
|
|
|
|
msgid ""
|
|
|
|
"It may also be useful to have an :class:`ArgumentParser` assign attributes "
|
|
|
|
"to an already existing object, rather than a new :class:`Namespace` object. "
|
|
|
|
"This can be achieved by specifying the ``namespace=`` keyword argument::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1526
|
|
|
|
msgid "Other utilities"
|
|
|
|
msgstr "Autres outils"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1529
|
|
|
|
msgid "Sub-commands"
|
|
|
|
msgstr "Sous commandes"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1536
|
|
|
|
msgid ""
|
|
|
|
"Many programs split up their functionality into a number of sub-commands, "
|
|
|
|
"for example, the ``svn`` program can invoke sub-commands like ``svn "
|
|
|
|
"checkout``, ``svn update``, and ``svn commit``. Splitting up functionality "
|
|
|
|
"this way can be a particularly good idea when a program performs several "
|
|
|
|
"different functions which require different kinds of command-line "
|
|
|
|
"arguments. :class:`ArgumentParser` supports the creation of such sub-"
|
|
|
|
"commands with the :meth:`add_subparsers` method. The :meth:`add_subparsers` "
|
|
|
|
"method is normally called with no arguments and returns a special action "
|
|
|
|
"object. This object has a single method, :meth:`~ArgumentParser."
|
|
|
|
"add_parser`, which takes a command name and any :class:`ArgumentParser` "
|
|
|
|
"constructor arguments, and returns an :class:`ArgumentParser` object that "
|
|
|
|
"can be modified as usual."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1548
|
|
|
|
msgid "Description of parameters:"
|
|
|
|
msgstr "Description des paramètres"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1550
|
|
|
|
msgid ""
|
|
|
|
"title - title for the sub-parser group in help output; by default "
|
|
|
|
"\"subcommands\" if description is provided, otherwise uses title for "
|
|
|
|
"positional arguments"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1554
|
|
|
|
msgid ""
|
|
|
|
"description - description for the sub-parser group in help output, by "
|
|
|
|
"default ``None``"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1557
|
|
|
|
msgid ""
|
|
|
|
"prog - usage information that will be displayed with sub-command help, by "
|
|
|
|
"default the name of the program and any positional arguments before the "
|
|
|
|
"subparser argument"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1561
|
|
|
|
msgid ""
|
|
|
|
"parser_class - class which will be used to create sub-parser instances, by "
|
|
|
|
"default the class of the current parser (e.g. ArgumentParser)"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1564
|
|
|
|
msgid ""
|
|
|
|
"action_ - the basic type of action to be taken when this argument is "
|
|
|
|
"encountered at the command line"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1567
|
|
|
|
msgid ""
|
|
|
|
"dest_ - name of the attribute under which sub-command name will be stored; "
|
|
|
|
"by default ``None`` and no value is stored"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1570
|
|
|
|
msgid "help_ - help for sub-parser group in help output, by default ``None``"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1572
|
|
|
|
msgid ""
|
|
|
|
"metavar_ - string presenting available sub-commands in help; by default it "
|
|
|
|
"is ``None`` and presents sub-commands in form {cmd1, cmd2, ..}"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1575
|
|
|
|
msgid "Some example usage::"
|
|
|
|
msgstr "Quelques exemples d'utilisation : ::"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1596
|
|
|
|
msgid ""
|
|
|
|
"Note that the object returned by :meth:`parse_args` will only contain "
|
|
|
|
"attributes for the main parser and the subparser that was selected by the "
|
|
|
|
"command line (and not any other subparsers). So in the example above, when "
|
|
|
|
"the ``a`` command is specified, only the ``foo`` and ``bar`` attributes are "
|
|
|
|
"present, and when the ``b`` command is specified, only the ``foo`` and "
|
|
|
|
"``baz`` attributes are present."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1603
|
|
|
|
msgid ""
|
|
|
|
"Similarly, when a help message is requested from a subparser, only the help "
|
|
|
|
"for that particular parser will be printed. The help message will not "
|
|
|
|
"include parent parser or sibling parser messages. (A help message for each "
|
|
|
|
"subparser command, however, can be given by supplying the ``help=`` argument "
|
|
|
|
"to :meth:`add_parser` as above.)"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1639
|
|
|
|
msgid ""
|
|
|
|
"The :meth:`add_subparsers` method also supports ``title`` and "
|
|
|
|
"``description`` keyword arguments. When either is present, the subparser's "
|
|
|
|
"commands will appear in their own group in the help output. For example::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1660
|
|
|
|
msgid ""
|
|
|
|
"Furthermore, ``add_parser`` supports an additional ``aliases`` argument, "
|
|
|
|
"which allows multiple strings to refer to the same subparser. This example, "
|
|
|
|
"like ``svn``, aliases ``co`` as a shorthand for ``checkout``::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1671
|
|
|
|
msgid ""
|
|
|
|
"One particularly effective way of handling sub-commands is to combine the "
|
|
|
|
"use of the :meth:`add_subparsers` method with calls to :meth:`set_defaults` "
|
|
|
|
"so that each subparser knows which Python function it should execute. For "
|
|
|
|
"example::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1708
|
|
|
|
msgid ""
|
|
|
|
"This way, you can let :meth:`parse_args` do the job of calling the "
|
|
|
|
"appropriate function after argument parsing is complete. Associating "
|
|
|
|
"functions with actions like this is typically the easiest way to handle the "
|
|
|
|
"different actions for each of your subparsers. However, if it is necessary "
|
|
|
|
"to check the name of the subparser that was invoked, the ``dest`` keyword "
|
|
|
|
"argument to the :meth:`add_subparsers` call will work::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1726
|
|
|
|
msgid "FileType objects"
|
|
|
|
msgstr "Objets ``FileType``"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1730
|
|
|
|
msgid ""
|
|
|
|
"The :class:`FileType` factory creates objects that can be passed to the type "
|
|
|
|
"argument of :meth:`ArgumentParser.add_argument`. Arguments that have :class:"
|
|
|
|
"`FileType` objects as their type will open command-line arguments as files "
|
|
|
|
"with the requested modes, buffer sizes, encodings and error handling (see "
|
|
|
|
"the :func:`open` function for more details)::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1742
|
|
|
|
msgid ""
|
|
|
|
"FileType objects understand the pseudo-argument ``'-'`` and automatically "
|
|
|
|
"convert this into ``sys.stdin`` for readable :class:`FileType` objects and "
|
|
|
|
"``sys.stdout`` for writable :class:`FileType` objects::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1751
|
|
|
|
msgid "The *encodings* and *errors* keyword arguments."
|
|
|
|
msgstr "Les arguments nommés ``encodings`` et ``errors``."
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1756
|
|
|
|
msgid "Argument groups"
|
|
|
|
msgstr "Groupes d'arguments"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1760
|
|
|
|
msgid ""
|
|
|
|
"By default, :class:`ArgumentParser` groups command-line arguments into "
|
|
|
|
"\"positional arguments\" and \"optional arguments\" when displaying help "
|
|
|
|
"messages. When there is a better conceptual grouping of arguments than this "
|
|
|
|
"default one, appropriate groups can be created using the :meth:"
|
|
|
|
"`add_argument_group` method::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1777
|
|
|
|
msgid ""
|
|
|
|
"The :meth:`add_argument_group` method returns an argument group object which "
|
|
|
|
"has an :meth:`~ArgumentParser.add_argument` method just like a regular :"
|
|
|
|
"class:`ArgumentParser`. When an argument is added to the group, the parser "
|
|
|
|
"treats it just like a normal argument, but displays the argument in a "
|
|
|
|
"separate group for help messages. The :meth:`add_argument_group` method "
|
|
|
|
"accepts *title* and *description* arguments which can be used to customize "
|
|
|
|
"this display::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1803
|
|
|
|
msgid ""
|
|
|
|
"Note that any arguments not in your user-defined groups will end up back in "
|
|
|
|
"the usual \"positional arguments\" and \"optional arguments\" sections."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1808
|
|
|
|
msgid "Mutual exclusion"
|
|
|
|
msgstr "Exclusion mutuelle"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1812
|
|
|
|
msgid ""
|
|
|
|
"Create a mutually exclusive group. :mod:`argparse` will make sure that only "
|
|
|
|
"one of the arguments in the mutually exclusive group was present on the "
|
|
|
|
"command line::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1828
|
|
|
|
msgid ""
|
|
|
|
"The :meth:`add_mutually_exclusive_group` method also accepts a *required* "
|
|
|
|
"argument, to indicate that at least one of the mutually exclusive arguments "
|
|
|
|
"is required::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1840
|
|
|
|
msgid ""
|
|
|
|
"Note that currently mutually exclusive argument groups do not support the "
|
|
|
|
"*title* and *description* arguments of :meth:`~ArgumentParser."
|
|
|
|
"add_argument_group`."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1846
|
|
|
|
msgid "Parser defaults"
|
|
|
|
msgstr "Valeurs par défaut du parseur"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1850
|
|
|
|
msgid ""
|
|
|
|
"Most of the time, the attributes of the object returned by :meth:"
|
|
|
|
"`parse_args` will be fully determined by inspecting the command-line "
|
|
|
|
"arguments and the argument actions. :meth:`set_defaults` allows some "
|
|
|
|
"additional attributes that are determined without any inspection of the "
|
|
|
|
"command line to be added::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1862
|
|
|
|
msgid ""
|
|
|
|
"Note that parser-level defaults always override argument-level defaults::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1870
|
|
|
|
msgid ""
|
|
|
|
"Parser-level defaults can be particularly useful when working with multiple "
|
|
|
|
"parsers. See the :meth:`~ArgumentParser.add_subparsers` method for an "
|
|
|
|
"example of this type."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1876
|
|
|
|
msgid ""
|
|
|
|
"Get the default value for a namespace attribute, as set by either :meth:"
|
|
|
|
"`~ArgumentParser.add_argument` or by :meth:`~ArgumentParser.set_defaults`::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1887
|
|
|
|
msgid "Printing help"
|
|
|
|
msgstr "Afficher l'aide"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1889
|
|
|
|
msgid ""
|
|
|
|
"In most typical applications, :meth:`~ArgumentParser.parse_args` will take "
|
|
|
|
"care of formatting and printing any usage or error messages. However, "
|
|
|
|
"several formatting methods are available:"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1895
|
|
|
|
msgid ""
|
|
|
|
"Print a brief description of how the :class:`ArgumentParser` should be "
|
|
|
|
"invoked on the command line. If *file* is ``None``, :data:`sys.stdout` is "
|
|
|
|
"assumed."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1901
|
|
|
|
msgid ""
|
|
|
|
"Print a help message, including the program usage and information about the "
|
|
|
|
"arguments registered with the :class:`ArgumentParser`. If *file* is "
|
|
|
|
"``None``, :data:`sys.stdout` is assumed."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1905
|
|
|
|
msgid ""
|
|
|
|
"There are also variants of these methods that simply return a string instead "
|
|
|
|
"of printing it:"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1910
|
|
|
|
msgid ""
|
|
|
|
"Return a string containing a brief description of how the :class:"
|
|
|
|
"`ArgumentParser` should be invoked on the command line."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1915
|
|
|
|
msgid ""
|
|
|
|
"Return a string containing a help message, including the program usage and "
|
|
|
|
"information about the arguments registered with the :class:`ArgumentParser`."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1920
|
|
|
|
msgid "Partial parsing"
|
|
|
|
msgstr "*Parsing* partiel"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1924
|
|
|
|
msgid ""
|
|
|
|
"Sometimes a script may only parse a few of the command-line arguments, "
|
|
|
|
"passing the remaining arguments on to another script or program. In these "
|
|
|
|
"cases, the :meth:`~ArgumentParser.parse_known_args` method can be useful. "
|
|
|
|
"It works much like :meth:`~ArgumentParser.parse_args` except that it does "
|
|
|
|
"not produce an error when extra arguments are present. Instead, it returns "
|
|
|
|
"a two item tuple containing the populated namespace and the list of "
|
|
|
|
"remaining argument strings."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1940
|
|
|
|
msgid ""
|
|
|
|
":ref:`Prefix matching <prefix-matching>` rules apply to :meth:"
|
|
|
|
"`parse_known_args`. The parser may consume an option even if it's just a "
|
|
|
|
"prefix of one of its known options, instead of leaving it in the remaining "
|
|
|
|
"arguments list."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1947
|
|
|
|
msgid "Customizing file parsing"
|
|
|
|
msgstr "Personnaliser le *parsing* de fichiers"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1951
|
|
|
|
msgid ""
|
|
|
|
"Arguments that are read from a file (see the *fromfile_prefix_chars* keyword "
|
|
|
|
"argument to the :class:`ArgumentParser` constructor) are read one argument "
|
|
|
|
"per line. :meth:`convert_arg_line_to_args` can be overridden for fancier "
|
|
|
|
"reading."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1956
|
|
|
|
msgid ""
|
|
|
|
"This method takes a single argument *arg_line* which is a string read from "
|
|
|
|
"the argument file. It returns a list of arguments parsed from this string. "
|
|
|
|
"The method is called once per line read from the argument file, in order."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1960
|
|
|
|
msgid ""
|
|
|
|
"A useful override of this method is one that treats each space-separated "
|
|
|
|
"word as an argument. The following example demonstrates how to do this::"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1969
|
|
|
|
msgid "Exiting methods"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1973
|
|
|
|
msgid ""
|
|
|
|
"This method terminates the program, exiting with the specified *status* and, "
|
|
|
|
"if given, it prints a *message* before that."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1978
|
|
|
|
msgid ""
|
|
|
|
"This method prints a usage message including the *message* to the standard "
|
|
|
|
"error and terminates the program with a status code of 2."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1984
|
|
|
|
msgid "Upgrading optparse code"
|
|
|
|
msgstr "Mettre à jour du code ``optparse``"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1986
|
|
|
|
msgid ""
|
|
|
|
"Originally, the :mod:`argparse` module had attempted to maintain "
|
|
|
|
"compatibility with :mod:`optparse`. However, :mod:`optparse` was difficult "
|
|
|
|
"to extend transparently, particularly with the changes required to support "
|
|
|
|
"the new ``nargs=`` specifiers and better usage messages. When most "
|
|
|
|
"everything in :mod:`optparse` had either been copy-pasted over or monkey-"
|
|
|
|
"patched, it no longer seemed practical to try to maintain the backwards "
|
|
|
|
"compatibility."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1993
|
|
|
|
msgid ""
|
|
|
|
"The :mod:`argparse` module improves on the standard library :mod:`optparse` "
|
|
|
|
"module in a number of ways including:"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1996
|
|
|
|
msgid "Handling positional arguments."
|
|
|
|
msgstr "Gérer les arguments positionnels"
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1997
|
|
|
|
msgid "Supporting sub-commands."
|
|
|
|
msgstr "Gérer les sous commandes."
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1998
|
|
|
|
msgid "Allowing alternative option prefixes like ``+`` and ``/``."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:1999
|
|
|
|
msgid "Handling zero-or-more and one-or-more style arguments."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:2000
|
|
|
|
msgid "Producing more informative usage messages."
|
|
|
|
msgstr "Fournir des message d'aide plus complets."
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:2001
|
|
|
|
msgid "Providing a much simpler interface for custom ``type`` and ``action``."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:2003
|
|
|
|
msgid "A partial upgrade path from :mod:`optparse` to :mod:`argparse`:"
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:2005
|
|
|
|
msgid ""
|
|
|
|
"Replace all :meth:`optparse.OptionParser.add_option` calls with :meth:"
|
|
|
|
"`ArgumentParser.add_argument` calls."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:2008
|
|
|
|
msgid ""
|
|
|
|
"Replace ``(options, args) = parser.parse_args()`` with ``args = parser."
|
|
|
|
"parse_args()`` and add additional :meth:`ArgumentParser.add_argument` calls "
|
|
|
|
"for the positional arguments. Keep in mind that what was previously called "
|
|
|
|
"``options``, now in :mod:`argparse` context is called ``args``."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:2013
|
|
|
|
msgid ""
|
|
|
|
"Replace callback actions and the ``callback_*`` keyword arguments with "
|
|
|
|
"``type`` or ``action`` arguments."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:2016
|
|
|
|
msgid ""
|
|
|
|
"Replace string names for ``type`` keyword arguments with the corresponding "
|
|
|
|
"type objects (e.g. int, float, complex, etc)."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:2019
|
|
|
|
msgid ""
|
|
|
|
"Replace :class:`optparse.Values` with :class:`Namespace` and :exc:`optparse."
|
|
|
|
"OptionError` and :exc:`optparse.OptionValueError` with :exc:`ArgumentError`."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:2023
|
|
|
|
msgid ""
|
|
|
|
"Replace strings with implicit arguments such as ``%default`` or ``%prog`` "
|
|
|
|
"with the standard Python syntax to use dictionaries to format strings, that "
|
|
|
|
"is, ``%(default)s`` and ``%(prog)s``."
|
|
|
|
msgstr ""
|
|
|
|
|
|
|
|
#: ../Doc/library/argparse.rst:2027
|
|
|
|
msgid ""
|
|
|
|
"Replace the OptionParser constructor ``version`` argument with a call to "
|
|
|
|
"``parser.add_argument('--version', action='version', version='<the "
|
|
|
|
"version>')``."
|
|
|
|
msgstr ""
|
2017-05-27 17:46:38 +00:00
|
|
|
|
|
|
|
#~ msgid "Tutorial"
|
|
|
|
#~ msgstr "Tutoriel"
|