# Copyright (C) 2001-2018, Python Software Foundation
# For licence information, see README file.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2020-08-24 09:01+0200\n"
"PO-Revision-Date: 2018-07-29 23:43+0200\n"
"Last-Translator: Luka Peschke <mail@lukapeschke.com>\n"
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Poedit 2.0.3\n"

#: library/cmd.rst:2
msgid ":mod:`cmd` --- Support for line-oriented command interpreters"
msgstr ":mod:`cmd` — Interpréteurs en ligne de commande."

#: library/cmd.rst:9
msgid "**Source code:** :source:`Lib/cmd.py`"
msgstr "**Code source:** :source:`Lib/cmd.py`"

#: library/cmd.rst:13
msgid ""
"The :class:`Cmd` class provides a simple framework for writing line-oriented "
"command interpreters.  These are often useful for test harnesses, "
"administrative tools, and prototypes that will later be wrapped in a more "
"sophisticated interface."
msgstr ""
"La :class:`Cmd` fournit une base simple permettant d'écrire des "
"interpréteurs en ligne de commande. Ceux-ci sont souvent utiles pour piloter "
"des tests, pour des outils administratifs, et pour des prototypes destinés à "
"être intégrés à une interface plus sophistiquée."

#: library/cmd.rst:20
msgid ""
"A :class:`Cmd` instance or subclass instance is a line-oriented interpreter "
"framework.  There is no good reason to instantiate :class:`Cmd` itself; "
"rather, it's useful as a superclass of an interpreter class you define "
"yourself in order to inherit :class:`Cmd`'s methods and encapsulate action "
"methods."
msgstr ""
"Une instance de :class:`Cmd` ou d'une classe en héritant est un *framework* "
"orienté ligne de commande. Il n'y a pas de bonne raison d'instancier :class:"
"`Cmd` directement. Elle est plutôt utile en tant que classe mère d'une "
"classe-interprète que vous définirez afin d'hériter des méthodes de :class:"
"`Cmd` et d'encapsuler les opérations."

#: library/cmd.rst:25
msgid ""
"The optional argument *completekey* is the :mod:`readline` name of a "
"completion key; it defaults to :kbd:`Tab`. If *completekey* is not :const:"
"`None` and :mod:`readline` is available, command completion is done "
"automatically."
msgstr ""
"L'argument facultatif *completekey* est le nom :mod:`readline` d'une touche "
"de complétion. Si *completekey* ne vaut pas :const:`None` et que :mod:"
"`readline` est disponible, la complétion de commandes est faite "
"automatiquement."

#: library/cmd.rst:29
msgid ""
"The optional arguments *stdin* and *stdout* specify the  input and output "
"file objects that the Cmd instance or subclass  instance will use for input "
"and output. If not specified, they will default to :data:`sys.stdin` and :"
"data:`sys.stdout`."
msgstr ""
"Les arguments facultatifs *stdin* et *stdout* spécifient les objets-fichiers "
"de lecture et d'écriture que l'instance de Cmd ou d'une classe fille "
"utilisera comme entrée et sortie. Si ces arguments ne sont pas spécifiés, "
"ils prendront comme valeur par défaut :data:`sys.stdin` et :data:`sys."
"stdout`."

#: library/cmd.rst:34
msgid ""
"If you want a given *stdin* to be used, make sure to set the instance's :"
"attr:`use_rawinput` attribute to ``False``, otherwise *stdin* will be "
"ignored."
msgstr ""
"Si vous souhaitez qu'un *stdin* donné soit utilisé, assurez-vous que "
"l'attribut :attr:`use_rawinput` de l'instance vaille ``False``, faute de "
"quoi *stdin* sera ignoré."

#: library/cmd.rst:42
msgid "Cmd Objects"
msgstr "Objets Cmd"

#: library/cmd.rst:44
msgid "A :class:`Cmd` instance has the following methods:"
msgstr "Une instance de :class:`Cmd` possède les méthodes suivantes :"

#: library/cmd.rst:49
msgid ""
"Repeatedly issue a prompt, accept input, parse an initial prefix off the "
"received input, and dispatch to action methods, passing them the remainder "
"of the line as argument."
msgstr ""
"Affiche une invite de commande de manière répétée, accepte une entrée, "
"soustrait un préfixe initial de l'entrée reçue et envoie aux méthodes "
"d'opération la partie restante de l'entrée reçue."

#: library/cmd.rst:53
msgid ""
"The optional argument is a banner or intro string to be issued before the "
"first prompt (this overrides the :attr:`intro` class attribute)."
msgstr ""
"L'argument facultatif est une bannière ou chaîne de caractères "
"d'introduction à afficher avant la première invite de commande (il redéfinit "
"l'attribut de classe :attr:`intro`)."

#: library/cmd.rst:56
msgid ""
"If the :mod:`readline` module is loaded, input will automatically inherit :"
"program:`bash`\\ -like history-list editing (e.g. :kbd:`Control-P` scrolls "
"back to the last command, :kbd:`Control-N` forward to the next one, :kbd:"
"`Control-F` moves the cursor to the right non-destructively, :kbd:`Control-"
"B` moves the cursor to the left non-destructively, etc.)."
msgstr ""
"Si le module :mod:`readline` est chargé, l'entrée héritera automatiquement "
"d'une édition d'historique similaire à :program:`bash` (Par exemple, :kbd:"
"`Control-P` reviendra à la dernière commande, :kbd:`Control-N` avancera à la "
"suivante, :kbd:`Control-F` déplace le curseur vers la droite, :kbd:`Control-"
"B` déplace le curseur vers la gauche, etc...)."

#: library/cmd.rst:62
msgid "An end-of-file on input is passed back as the string ``'EOF'``."
msgstr ""
"Une caractère de fin de fichier est transmis via la chaîne de caractères "
"``'EOF'``."

#: library/cmd.rst:68
msgid ""
"An interpreter instance will recognize a command name ``foo`` if and only if "
"it has a method :meth:`do_foo`.  As a special case, a line beginning with "
"the character ``'?'`` is dispatched to the method :meth:`do_help`.  As "
"another special case, a line beginning with the character ``'!'`` is "
"dispatched to the method :meth:`do_shell` (if such a method is defined)."
msgstr ""
"Une instance d'un interpréteur reconnaîtra un nom de commande ``foo`` si et "
"seulement si celle-ci possède une méthode :meth:`do_foo`. Les lignes "
"commençant par le caractère ``'?'`` sont un cas particulier: elles sont "
"envoyées à la méthode :meth:`do_help`. Les lignes commençant par le "
"caractère ``'!'`` sont également un cas particulier: elles sont envoyées à "
"la méthode :meth:`do_shell` (si une telle méthode est définie)."

#: library/cmd.rst:74
msgid ""
"This method will return when the :meth:`postcmd` method returns a true "
"value. The *stop* argument to :meth:`postcmd` is the return value from the "
"command's corresponding :meth:`do_\\*` method."
msgstr ""
"Cette méthode ne s'arrêtera que lorsque :meth:`postcmd` renverra une valeur "
"vraie. L'argument *stop* de :meth:`postcmd` est la valeur de retour de la "
"méthode :meth:`do_\\*` correspondant à la commande."

#: library/cmd.rst:78
msgid ""
"If completion is enabled, completing commands will be done automatically, "
"and completing of commands args is done by calling :meth:`complete_foo` with "
"arguments *text*, *line*, *begidx*, and *endidx*.  *text* is the string "
"prefix we are attempting to match: all returned matches must begin with it. "
"*line* is the current input line with leading whitespace removed, *begidx* "
"and *endidx* are the beginning and ending indexes of the prefix text, which "
"could be used to provide different completion depending upon which position "
"the argument is in."
msgstr ""
"Si la complétion est activée, la complétion de commandes sera faite "
"automatiquement; et la complétion d'arguments sera faite en appelant :meth:"
"`complete_foo` avec les arguments *text*, *line*, *begidx*, et *endidx*. "
"*text* est le préfixe que nous cherchons à faire coïncider: toutes les "
"valeurs renvoyées doivent commencer par ce préfixe. *line* est la ligne "
"d'entrée actuelle sans les espaces blancs de début. *begidx* et *endidx* "
"sont les index de début et de fin du préfixe, ils pourraient être utilisés "
"pour fournir différentes complétions en fonction de la position de "
"l'argument."

#: library/cmd.rst:86
msgid ""
"All subclasses of :class:`Cmd` inherit a predefined :meth:`do_help`.  This "
"method, called with an argument ``'bar'``, invokes the corresponding method :"
"meth:`help_bar`, and if that is not present, prints the docstring of :meth:"
"`do_bar`, if available.  With no argument, :meth:`do_help` lists all "
"available help topics (that is, all commands with corresponding :meth:`help_"
"\\*` methods or commands that have docstrings), and also lists any "
"undocumented commands."
msgstr ""
"Toutes les classes filles de :class:`Cmd` héritent d'une méthode :meth:"
"`do_help` prédéfinie. Cette méthode appellera la méthode :meth:`help_bar` "
"lorsqu'elle est appelée avec un argument ``'bar'``. Si celle-ci n'est pas "
"définie, elle affichera la *docstring* de :meth:`do_bar`, (si elle a une "
"*docstring*). Sans argument, :meth:`do_help` listera tous les sujets d'aide "
"(c'est à dire, toutes les commandes avec une méthode :meth:`help_\\\\*` "
"correspondante ou commande ayant une *docstring*, elle lisera aussi les "
"commandes non documentées."

#: library/cmd.rst:97
msgid ""
"Interpret the argument as though it had been typed in response to the "
"prompt. This may be overridden, but should not normally need to be; see the :"
"meth:`precmd` and :meth:`postcmd` methods for useful execution hooks.  The "
"return value is a flag indicating whether interpretation of commands by the "
"interpreter should stop.  If there is a :meth:`do_\\*` method for the "
"command *str*, the return value of that method is returned, otherwise the "
"return value from the :meth:`default` method is returned."
msgstr ""
"Interprète l'argument comme si il avait été entré en réponse à l'invite de "
"commande. Cette méthode peut être surchargée, mais ne devrait normalement "
"pas avoir besoin de l'être; voir les méthodes :meth:`precmd` et :meth:"
"`postcmd` pour altérer l'exécution d'une commande. La valeur de retour est "
"un *flag* indiquant si l'interprétation de commandes par l'interpréteur "
"devrait arrêter. S'il existe une méthode :meth:`do_\\*` pour la commande "
"*str*, la valeur de retour de cette méthode est renvoyée. Dans le cas "
"contraire, la valeur de retour de la méthode :meth:`default` est renvoyée."

#: library/cmd.rst:108
msgid ""
"Method called when an empty line is entered in response to the prompt. If "
"this method is not overridden, it repeats the last nonempty command entered."
msgstr ""
"Méthode appelée quand une ligne vide est entrée en réponse à l'invite de "
"commande. Si cette méthode n'est pas surchargée, elle répète la dernière "
"commande non-vide entrée."

#: library/cmd.rst:114
msgid ""
"Method called on an input line when the command prefix is not recognized. If "
"this method is not overridden, it prints an error message and returns."
msgstr ""
"Méthode appelée lorsque le préfixe de commande d'une ligne entrée n'est pas "
"reconnu. Si cette méthode n'est pas surchargée, elle affiche un message "
"d'erreur et s'arrête."

#: library/cmd.rst:120
msgid ""
"Method called to complete an input line when no command-specific :meth:"
"`complete_\\*` method is available.  By default, it returns an empty list."
msgstr ""
"Méthode appelée pour compléter une ligne entrée quand aucune méthode :meth:"
"`complete_\\*` spécifique à la commande n'est disponible. Par défaut, elle "
"renvoie une liste vide."

#: library/cmd.rst:126
msgid ""
"Hook method executed just before the command line *line* is interpreted, but "
"after the input prompt is generated and issued.  This method is a stub in :"
"class:`Cmd`; it exists to be overridden by subclasses.  The return value is "
"used as the command which will be executed by the :meth:`onecmd` method; "
"the :meth:`precmd` implementation may re-write the command or simply return "
"*line* unchanged."
msgstr ""
"Méthode de rappel exécutée juste avant que la ligne de commande *line* ne "
"soit interprétée, mais après que l'invite de commande ait été généré et "
"affiché. Cette méthode existe afin d'être surchargée par des classes filles "
"de :class:`Cmd`. La valeur de retour est utilisée comme la commande qui sera "
"exécutée par la méthode :meth:`onecmd`. L'implémentation de :meth:`precmd` "
"peut réécrire la commande ou simplement renvoyer *line* sans modification."

#: library/cmd.rst:136
msgid ""
"Hook method executed just after a command dispatch is finished.  This method "
"is a stub in :class:`Cmd`; it exists to be overridden by subclasses.  *line* "
"is the command line which was executed, and *stop* is a flag which indicates "
"whether execution will be terminated after the call to :meth:`postcmd`; this "
"will be the return value of the :meth:`onecmd` method.  The return value of "
"this method will be used as the new value for the internal flag which "
"corresponds to *stop*; returning false will cause interpretation to continue."
msgstr ""
"Méthode de rappel exécutée juste après qu'une commande ait été exécutée. "
"Cette méthode existe afin d'être surchargée par des classes filles de :class:"
"`Cmd`. *line est la ligne de commande ayant été exécutée et *stop* est un "
"*flag* indiquant si l'exécution sera terminée après un appel à :meth:"
"`postcmd`. *stop* sera la valeur de retour de :meth:`onecmd`. La valeur de "
"retour de cette méthode sera utilisée comme nouvelle valeur pour le *flag* "
"interne correspondant à *stop*. Renvoyer *False* permettra à "
"l'interprétation de continuer."

#: library/cmd.rst:147
msgid ""
"Hook method executed once when :meth:`cmdloop` is called.  This method is a "
"stub in :class:`Cmd`; it exists to be overridden by subclasses."
msgstr ""
"Méthode de rappel exécutée une fois lorsque :meth:`cmdloop` est appelée. "
"Cette méthode existe afin d'être surchargée par des classes filles de :class:"
"`Cmd`."

#: library/cmd.rst:153
msgid ""
"Hook method executed once when :meth:`cmdloop` is about to return. This "
"method is a stub in :class:`Cmd`; it exists to be overridden by subclasses."
msgstr ""
"Méthode de rappel exécutée une fois lorsque :meth:`cmdloop` va s'arrêter. "
"Cette méthode existe afin d'être surchargée par des classes filles de :class:"
"`Cmd`."

#: library/cmd.rst:157
msgid ""
"Instances of :class:`Cmd` subclasses have some public instance variables:"
msgstr ""
"Les instances de classes filles de :class:`Cmd` possèdent des variables "
"d'instance publiques:"

#: library/cmd.rst:161
msgid "The prompt issued to solicit input."
msgstr "L'invite de commande affiché pour solliciter une entrée."

#: library/cmd.rst:166
msgid "The string of characters accepted for the command prefix."
msgstr "La chaîne de caractères acceptée en tant que préfixe de commande."

#: library/cmd.rst:171
msgid "The last nonempty command prefix seen."
msgstr "Le dernier préfixe de commande non-vide vu."

#: library/cmd.rst:176
msgid ""
"A list of queued input lines.  The cmdqueue list is checked in :meth:"
"`cmdloop` when new input is needed; if it is nonempty, its elements will be "
"processed in order, as if entered at the prompt."
msgstr ""
"Une liste de lignes entrées en file. La liste *cmdqueue* est vérifiée dans :"
"meth:`cmdloop` lorsqu'une nouvelle entrée est nécessitée; si elle n'est pas "
"vide, ses éléments seront traités dans l'ordre, comme si ils avaient entrés "
"dans l'invite de commande."

#: library/cmd.rst:183
msgid ""
"A string to issue as an intro or banner.  May be overridden by giving the :"
"meth:`cmdloop` method an argument."
msgstr ""
"Une chaîne de caractères à afficher en introduction ou bannière. Peut être "
"surchargée en passant un argument à la méthode :meth:`cmdloop`."

#: library/cmd.rst:189
msgid ""
"The header to issue if the help output has a section for documented commands."
msgstr ""
"L'en-tête à afficher si la sortie de l'aide possède une section pour les "
"commandes documentées."

#: library/cmd.rst:194
msgid ""
"The header to issue if the help output has a section for miscellaneous  help "
"topics (that is, there are :meth:`help_\\*` methods without corresponding :"
"meth:`do_\\*` methods)."
msgstr ""
"L'en-tête à afficher si la sortie de l'aide possède une section pour divers "
"sujets (c'est-à-dire qu'il existe des méthodes :meth:`help_\\*` sans "
"méthodes :meth:`do_\\*` correspondantes)."

#: library/cmd.rst:201
msgid ""
"The header to issue if the help output has a section for undocumented  "
"commands (that is, there are :meth:`do_\\*` methods without corresponding :"
"meth:`help_\\*` methods)."
msgstr ""
"L'en-tête à afficher si la sortie de l'aide possède une section pour les "
"commandes non documentées (c'est-à-dire qu'il existe des méthodes :meth:`dop_"
"\\*` sans méthodes :meth:`help_\\*` correspondantes)."

#: library/cmd.rst:208
msgid ""
"The character used to draw separator lines under the help-message headers.  "
"If empty, no ruler line is drawn.  It defaults to ``'='``."
msgstr ""
"Le caractère utilisé pour afficher des lignes de séparation sous les en-"
"têtes de messages d'aide. Si il est vide, aucune ligne de séparation n'est "
"affichée. Par défaut, ce caractère vaut ``'='``."

#: library/cmd.rst:214
msgid ""
"A flag, defaulting to true.  If true, :meth:`cmdloop` uses :func:`input` to "
"display a prompt and read the next command; if false, :meth:`sys.stdout."
"write` and :meth:`sys.stdin.readline` are used. (This means that by "
"importing :mod:`readline`, on systems that support it, the interpreter will "
"automatically support :program:`Emacs`\\ -like line editing  and command-"
"history keystrokes.)"
msgstr ""
"Un *flag*, valant *True* par défaut. Si ce *flag* est vrai, :meth:`cmdloop` "
"utilise :func:`input` pour afficher une invite de commande et lire la "
"prochaine commande; si il est faux, :meth:`sys.stdout.write` et :meth:`sys."
"stdin.readline` sont utilisées. (Cela signifie qu'en important :mod:"
"`readline` sur les systèmes qui le supportent, l'interpréteur va "
"automatiquement supporter une édition de ligne similaire à :program:`Emacs` "
"ainsi que des touches d'historique de commande)."

#: library/cmd.rst:224
msgid "Cmd Example"
msgstr "Exemple"

#: library/cmd.rst:228
msgid ""
"The :mod:`cmd` module is mainly useful for building custom shells that let a "
"user work with a program interactively."
msgstr ""
"Le module :mod:`cmd` est utile pour produire des invites de commande "
"permettant à l'utilisateur de travailler avec un programme de manière "
"interactive."

#: library/cmd.rst:231
msgid ""
"This section presents a simple example of how to build a shell around a few "
"of the commands in the :mod:`turtle` module."
msgstr ""
"Cette section présente un exemple simple de comment produire une invite de "
"commande autour de quelques commandes du module :mod:`turtle`."

#: library/cmd.rst:234
msgid ""
"Basic turtle commands such as :meth:`~turtle.forward` are added to a :class:"
"`Cmd` subclass with method named :meth:`do_forward`.  The argument is "
"converted to a number and dispatched to the turtle module.  The docstring is "
"used in the help utility provided by the shell."
msgstr ""
"Des commandes *turtle* basiques telles que :meth:`~turtle.forward` sont "
"ajoutées à une classe fille de :class:`Cmd` avec la méthode appelée :meth:"
"`do_forward`. L'argument est converti en nombre et envoyé au module "
"*turtle*. La *docstring* est utilisée dans l'utilitaire d'aide fourni par "
"l'invite de commande."

#: library/cmd.rst:239
msgid ""
"The example also includes a basic record and playback facility implemented "
"with the :meth:`~Cmd.precmd` method which is responsible for converting the "
"input to lowercase and writing the commands to a file.  The :meth:"
"`do_playback` method reads the file and adds the recorded commands to the :"
"attr:`cmdqueue` for immediate playback::"
msgstr ""
"L'exemple inclut également un utilitaire d'enregistrement et de *playback* "
"implémenté avec la méthode :meth:`~Cmd.precmd`, qui est responsable du "
"passage de l'entrée en minuscules ainsi que d'écrire les commandes dans un "
"fichier. La méthode :meth:`do_playback` lit le fichier et ajoute les "
"commandes enregistrées à :attr:`cmdqueue` pour être rejouées immédiatement ::"

#: library/cmd.rst:320
msgid ""
"Here is a sample session with the turtle shell showing the help functions, "
"using blank lines to repeat commands, and the simple record and playback "
"facility:"
msgstr ""
"Voici une session d'exemple avec l'invite de commande *turtle*. Elle montre "
"les fonctions d'aide, utilise les lignes vides pour répéter des commandes et "
"montre l'utilitaire de *playback*:"
