python-docs-fr/library/subprocess.po

# 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: 2023-02-12 21:25+0100\n"
"PO-Revision-Date: 2022-10-18 16:00+0200\n"
"Last-Translator: Mathieu Dupuy <deronnax@gmail.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.3\n"

#: library/subprocess.rst:2
msgid ":mod:`subprocess` --- Subprocess management"
msgstr ":mod:`subprocess` — Gestion de sous-processus"

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

#: library/subprocess.rst:14
msgid ""
"The :mod:`subprocess` module allows you to spawn new processes, connect to "
"their input/output/error pipes, and obtain their return codes.  This module "
"intends to replace several older modules and functions::"
msgstr ""
"Le module :mod:`subprocess` vous permet de lancer de nouveaux processus, les "
"connecter à des tubes d'entrée/sortie/erreur, et d'obtenir leurs codes de "
"retour.  Ce module a l'intention de remplacer plusieurs anciens modules et "
"fonctions ::"

#: library/subprocess.rst:21
msgid ""
"Information about how the :mod:`subprocess` module can be used to replace "
"these modules and functions can be found in the following sections."
msgstr ""
"De plus amples informations sur comment le module :mod:`subprocess` peut "
"être utilisé pour remplacer ces modules et fonctions peuvent être trouvées "
"dans les sections suivantes."

#: library/subprocess.rst:26
msgid ":pep:`324` -- PEP proposing the subprocess module"
msgstr ":pep:`324` -- PEP proposant le module *subprocess*"

#: includes/wasm-notavail.rst:3
#, fuzzy
msgid ":ref:`Availability <availability>`: not Emscripten, not WASI."
msgstr ":ref:`Disponibilité <availability>` : POSIX et Windows."

#: includes/wasm-notavail.rst:5
msgid ""
"This module does not work or is not available on WebAssembly platforms "
"``wasm32-emscripten`` and ``wasm32-wasi``. See :ref:`wasm-availability` for "
"more information."
msgstr ""

#: library/subprocess.rst:31
msgid "Using the :mod:`subprocess` Module"
msgstr "Utiliser le module :mod:`subprocess`"

#: library/subprocess.rst:33
msgid ""
"The recommended approach to invoking subprocesses is to use the :func:`run` "
"function for all use cases it can handle. For more advanced use cases, the "
"underlying :class:`Popen` interface can be used directly."
msgstr ""
"L'approche recommandée pour invoquer un sous-processus est d'utiliser la "
"fonction :func:`run` pour tous les cas d'utilisation qu'elle gère. Pour les "
"cas d'utilisation plus avancés, l'interface inhérente :class:`Popen` peut "
"être utilisée directement."

#: library/subprocess.rst:43
msgid ""
"Run the command described by *args*.  Wait for command to complete, then "
"return a :class:`CompletedProcess` instance."
msgstr ""
"Lance la commande décrite par *args*.  Attend que la commande se termine, "
"puis renvoie une instance :class:`CompletedProcess`."

#: library/subprocess.rst:46
msgid ""
"The arguments shown above are merely the most common ones, described below "
"in :ref:`frequently-used-arguments` (hence the use of keyword-only notation "
"in the abbreviated signature). The full function signature is largely the "
"same as that of the :class:`Popen` constructor - most of the arguments to "
"this function are passed through to that interface. (*timeout*,  *input*, "
"*check*, and *capture_output* are not.)"
msgstr ""
"Les arguments présentés ci-dessus sont simplement les plus utilisés, décrits "
"ci-dessous dans la section :ref:`frequently-used-arguments` (d'où "
"l'utilisation de la notation *keyword-only* dans la signature abrégée). La "
"signature complète de la fonction est sensiblement la même que celle du "
"constructeur de :class:`Popen`, à l'exception de *timeout*, *input*, *check* "
"et *capture_output*, tous les arguments donnés à cette fonction passent à "
"travers cette interface."

#: library/subprocess.rst:53
msgid ""
"If *capture_output* is true, stdout and stderr will be captured. When used, "
"the internal :class:`Popen` object is automatically created with "
"``stdout=PIPE`` and ``stderr=PIPE``. The *stdout* and *stderr* arguments may "
"not be supplied at the same time as *capture_output*.  If you wish to "
"capture and combine both streams into one, use ``stdout=PIPE`` and "
"``stderr=STDOUT`` instead of *capture_output*."
msgstr ""
"Si *capture_output* est vrai, la sortie et l'erreur standard (``stdout`` et "
"``stderr``) sont capturées. Dans ce cas, l'objet interne :class:`Popen` est "
"automatiquement créé avec les arguments ``stdout=PIPE`` et ``stderr=PIPE``. "
"Les arguments *stdout* et *stderr* ne doivent pas être passés en même temps "
"que *capture_output*. Si vous souhaitez capturer et combiner les deux flux "
"dans un seul, utilisez ``stdout=PIPE`` et ``stderr=STDOUT`` au lieu de "
"*capture_output*."

#: library/subprocess.rst:60
msgid ""
"The *timeout* argument is passed to :meth:`Popen.communicate`. If the "
"timeout expires, the child process will be killed and waited for.  The :exc:"
"`TimeoutExpired` exception will be re-raised after the child process has "
"terminated."
msgstr ""
"L'argument *timeout* est passé à :meth:`Popen.communicate`. Si le *timeout* "
"expire, le processus enfant sera tué et attendu.  Une exception :exc:"
"`TimeoutExpired` sera levée une fois que le processus enfant se sera terminé."

#: library/subprocess.rst:65
msgid ""
"The *input* argument is passed to :meth:`Popen.communicate` and thus to the "
"subprocess's stdin.  If used it must be a byte sequence, or a string if "
"*encoding* or *errors* is specified or *text* is true.  When used, the "
"internal :class:`Popen` object is automatically created with ``stdin=PIPE``, "
"and the *stdin* argument may not be used as well."
msgstr ""
"L'argument *input* est passé à :meth:`Popen.communicate` et donc à l'entrée "
"standard (*stdin*) du sous-processus.  Si l'argument est utilisé, il doit "
"contenir une séquence de *bytes*, ou une chaîne de caractères si *encoding* "
"ou *errors* sont spécifiés, ou si *text* est vrai. Quand cet argument est "
"utilisé, l'objet interne :class:`Popen` est automatiquement créé avec "
"``stdin=PIPE``, et l'argument *stdin* ne doit donc pas être utilisé."

#: library/subprocess.rst:71
msgid ""
"If *check* is true, and the process exits with a non-zero exit code, a :exc:"
"`CalledProcessError` exception will be raised. Attributes of that exception "
"hold the arguments, the exit code, and stdout and stderr if they were "
"captured."
msgstr ""
"Si *check* est vrai, et que le processus s'arrête avec un code de statut non "
"nul, une exception :exc:`CalledProcessError` est levée.  Les attributs de "
"cette exception contiennent les arguments, le code de statut, et les sorties "
"standard et d'erreur si elles ont été capturées."

#: library/subprocess.rst:76
msgid ""
"If *encoding* or *errors* are specified, or *text* is true, file objects for "
"stdin, stdout and stderr are opened in text mode using the specified "
"*encoding* and *errors* or the :class:`io.TextIOWrapper` default. The "
"*universal_newlines* argument is equivalent  to *text* and is provided for "
"backwards compatibility. By default, file objects are opened in binary mode."
msgstr ""
"Si *encoding* ou *errors* sont spécifiés, ou *text* est vrai, les fichiers "
"pour les entrées et sorties sont ouverts en mode texte en utilisant les "
"paramètres *encoding* et *errors* spécifiés, ou les valeurs par défaut de :"
"class:`io.TextIOWrapper`. L'argument *universal_newlines* est équivalent à "
"*text* et est fourni pour la rétrocompatibilité. Par défaut, les fichiers "
"sont ouverts en mode binaire."

#: library/subprocess.rst:82
#, fuzzy
msgid ""
"If *env* is not ``None``, it must be a mapping that defines the environment "
"variables for the new process; these are used instead of the default "
"behavior of inheriting the current process' environment. It is passed "
"directly to :class:`Popen`. This mapping can be str to str on any platform "
"or bytes to bytes on POSIX platforms much like :data:`os.environ` or :data:"
"`os.environb`."
msgstr ""
"Si *env* n'est pas ``None``, il doit être un tableau associatif définissant "
"les variables d'environnement du nouveau processus ; elles seront utilisées "
"à la place du comportement par défaut qui est d'hériter de l'environnement "
"du processus courant. Il est passé directement à :class:`Popen`."

#: library/subprocess.rst:89
msgid "Examples::"
msgstr "Exemples ::"

#: library/subprocess.rst:107
msgid "Added *encoding* and *errors* parameters"
msgstr "Ajout des paramètres *encoding* et *errors*"

#: library/subprocess.rst:111
msgid ""
"Added the *text* parameter, as a more understandable alias of "
"*universal_newlines*. Added the *capture_output* parameter."
msgstr ""
"Ajout du paramètre *text*, qui agit comme un alias plus compréhensible de "
"*universal_newlines*. Ajout du paramètre *capture_output*."

#: library/subprocess.rst:501 library/subprocess.rst:1221
#: library/subprocess.rst:1284
msgid ""
"Changed Windows shell search order for ``shell=True``. The current directory "
"and ``%PATH%`` are replaced with ``%COMSPEC%`` and ``%SystemRoot%"
"\\System32\\cmd.exe``. As a result, dropping a malicious program named ``cmd."
"exe`` into a current directory no longer works."
msgstr ""

#: library/subprocess.rst:124
msgid ""
"The return value from :func:`run`, representing a process that has finished."
msgstr ""
"La valeur de retour de :func:`run`, représentant un processus qui s'est "
"terminé."

#: library/subprocess.rst:128
msgid ""
"The arguments used to launch the process. This may be a list or a string."
msgstr ""
"Les arguments utilisés pour lancer le processus. Cela peut être une liste ou "
"une chaîne de caractères."

#: library/subprocess.rst:132
msgid ""
"Exit status of the child process. Typically, an exit status of 0 indicates "
"that it ran successfully."
msgstr ""
"Le code de statut du processus fils.  Typiquement, un code de statut de 0 "
"indique qu'il s'est exécuté avec succès."

#: library/subprocess.rst:928
msgid ""
"A negative value ``-N`` indicates that the child was terminated by signal "
"``N`` (POSIX only)."
msgstr ""
"Une valeur négative ``-N`` indique que le processus enfant a été terminé par "
"un signal ``N`` (seulement sur les systèmes *POSIX*)."

#: library/subprocess.rst:140
msgid ""
"Captured stdout from the child process. A bytes sequence, or a string if :"
"func:`run` was called with an encoding, errors, or text=True. ``None`` if "
"stdout was not captured."
msgstr ""
"La sortie standard capturée du processus enfant. Une séquence de *bytes*, ou "
"une chaîne de caractères si :func:`run` a été appelée avec *encoding*, "
"*errors* ou *text=True*. Vaut ``None`` si la sortie standard n'était pas "
"capturée."

#: library/subprocess.rst:144
msgid ""
"If you ran the process with ``stderr=subprocess.STDOUT``, stdout and stderr "
"will be combined in this attribute, and :attr:`stderr` will be ``None``."
msgstr ""
"Si vous avez lancé le processus avec ``stderr=subprocess.STDOUT``, les "
"sorties standard et d'erreur seront combinées dans cet attribut, et :attr:"
"`stderr` sera mis à ``None``."

#: library/subprocess.rst:150
msgid ""
"Captured stderr from the child process. A bytes sequence, or a string if :"
"func:`run` was called with an encoding, errors, or text=True. ``None`` if "
"stderr was not captured."
msgstr ""
"La sortie d'erreur capturée du processus enfant. Une séquence de *bytes*, ou "
"une chaîne de caractères si :func:`run` a été appelée avec *encoding*, "
"*errors* ou *text=True*. Vaut ``None`` si la sortie d'erreur n'était pas "
"capturée."

#: library/subprocess.rst:156
msgid "If :attr:`returncode` is non-zero, raise a :exc:`CalledProcessError`."
msgstr ""
"Si :attr:`returncode` n'est pas nul, lève une :exc:`CalledProcessError`."

#: library/subprocess.rst:162
msgid ""
"Special value that can be used as the *stdin*, *stdout* or *stderr* argument "
"to :class:`Popen` and indicates that the special file :data:`os.devnull` "
"will be used."
msgstr ""
"Valeur spéciale qui peut être utilisée pour les arguments *stdin*, *stdout* "
"ou *stderr* de :class:`Popen` et qui indique que le fichier spécial :data:"
"`os.devnull` sera utilisé."

#: library/subprocess.rst:171
msgid ""
"Special value that can be used as the *stdin*, *stdout* or *stderr* argument "
"to :class:`Popen` and indicates that a pipe to the standard stream should be "
"opened.  Most useful with :meth:`Popen.communicate`."
msgstr ""
"Valeur spéciale qui peut être utilisée pour les arguments *stdin*, *stdout* "
"ou *stderr* de :class:`Popen` et qui indique qu'un tube vers le flux "
"standard doit être ouvert.  Surtout utile avec :meth:`Popen.communicate`."

#: library/subprocess.rst:178
msgid ""
"Special value that can be used as the *stderr* argument to :class:`Popen` "
"and indicates that standard error should go into the same handle as standard "
"output."
msgstr ""
"Valeur spéciale qui peut être utilisée pour l'argument *stderr* de :class:"
"`Popen` et qui indique que la sortie d'erreur doit être redirigée vers le "
"même descripteur que la sortie standard."

#: library/subprocess.rst:185
msgid "Base class for all other exceptions from this module."
msgstr "Classe de base à toutes les autres exceptions du module."

#: library/subprocess.rst:192
msgid ""
"Subclass of :exc:`SubprocessError`, raised when a timeout expires while "
"waiting for a child process."
msgstr ""
"Sous-classe de :exc:`SubprocessError`, levée quand un *timeout* expire "
"pendant l'attente d'un processus enfant."

#: library/subprocess.rst:241
msgid "Command that was used to spawn the child process."
msgstr "La commande utilisée pour instancier le processus fils."

#: library/subprocess.rst:201
msgid "Timeout in seconds."
msgstr "Le *timeout* en secondes."

#: library/subprocess.rst:205
msgid ""
"Output of the child process if it was captured by :func:`run` or :func:"
"`check_output`.  Otherwise, ``None``.  This is always :class:`bytes` when "
"any output was captured regardless of the ``text=True`` setting.  It may "
"remain ``None`` instead of ``b''`` when no output was observed."
msgstr ""

#: library/subprocess.rst:250
msgid "Alias for output, for symmetry with :attr:`stderr`."
msgstr "Alias pour *output*, afin d'avoir une symétrie avec :attr:`stderr`."

#: library/subprocess.rst:217
msgid ""
"Stderr output of the child process if it was captured by :func:`run`. "
"Otherwise, ``None``.  This is always :class:`bytes` when stderr output was "
"captured regardless of the ``text=True`` setting.  It may remain ``None`` "
"instead of ``b''`` when no stderr output was observed."
msgstr ""

#: library/subprocess.rst:257
msgid "*stdout* and *stderr* attributes added"
msgstr "Ajout des attributs *stdout* et *stderr*"

#: library/subprocess.rst:229
#, fuzzy
msgid ""
"Subclass of :exc:`SubprocessError`, raised when a process run by :func:"
"`check_call`, :func:`check_output`, or :func:`run` (with ``check=True``) "
"returns a non-zero exit status."
msgstr ""
"Sous-classe de :exc:`SubprocessError`, levée quand un processus lancé par :"
"func:`check_call` ou :func:`check_output` renvoie un code de statut non nul."

#: library/subprocess.rst:236
msgid ""
"Exit status of the child process.  If the process exited due to a signal, "
"this will be the negative signal number."
msgstr ""
"Code de statut du processus fils.  Si le processus a été arrêté par un "
"signal, le code sera négatif et correspondra à l'opposé du numéro de signal."

#: library/subprocess.rst:245
msgid ""
"Output of the child process if it was captured by :func:`run` or :func:"
"`check_output`.  Otherwise, ``None``."
msgstr ""
"La sortie du processus fils, si capturée par :func:`run` ou :func:"
"`check_output`.  Autrement, ``None``."

#: library/subprocess.rst:254
msgid ""
"Stderr output of the child process if it was captured by :func:`run`. "
"Otherwise, ``None``."
msgstr ""
"La sortie d'erreur du processus fils, si capturée par :func:`run`. "
"Autrement, ``None``."

#: library/subprocess.rst:264
msgid "Frequently Used Arguments"
msgstr "Arguments fréquemment utilisés"

#: library/subprocess.rst:266
msgid ""
"To support a wide variety of use cases, the :class:`Popen` constructor (and "
"the convenience functions) accept a large number of optional arguments. For "
"most typical use cases, many of these arguments can be safely left at their "
"default values. The arguments that are most commonly needed are:"
msgstr ""
"Pour gérer un large ensemble de cas, le constructeur de :class:`Popen` (et "
"les fonctions de convenance) acceptent de nombreux arguments optionnels. "
"Pour les cas d'utilisation les plus typiques, beaucoup de ces arguments "
"peuvent sans problème être laissés à leurs valeurs par défaut. Les arguments "
"les plus communément nécessaires sont :"

#: library/subprocess.rst:271
msgid ""
"*args* is required for all calls and should be a string, or a sequence of "
"program arguments. Providing a sequence of arguments is generally preferred, "
"as it allows the module to take care of any required escaping and quoting of "
"arguments (e.g. to permit spaces in file names). If passing a single string, "
"either *shell* must be :const:`True` (see below) or else the string must "
"simply name the program to be executed without specifying any arguments."
msgstr ""
"*args* est requis pour tous les appels et doit être une chaîne de caractères "
"ou une séquence d'arguments du programme. Il est généralement préférable de "
"fournir une séquence d'arguments, puisque cela permet au module de s'occuper "
"des potentiels échappements ou guillemets autour des arguments (p. ex. pour "
"permettre des espaces dans des noms de fichiers). Si l'argument est passé "
"comme une simple chaîne, soit *shell* doit valoir :const:`True` (voir ci-"
"dessous) soit la chaîne doit simplement contenir le nom du programme à "
"exécuter sans spécifier d'arguments supplémentaires."

#: library/subprocess.rst:279
#, fuzzy
msgid ""
"*stdin*, *stdout* and *stderr* specify the executed program's standard "
"input, standard output and standard error file handles, respectively.  Valid "
"values are :data:`PIPE`, :data:`DEVNULL`, an existing file descriptor (a "
"positive integer), an existing file object with a valid file descriptor, and "
"``None``. :data:`PIPE` indicates that a new pipe to the child should be "
"created. :data:`DEVNULL` indicates that the special file :data:`os.devnull` "
"will be used.  With the default settings of ``None``, no redirection will "
"occur; the child's file handles will be inherited from the parent. "
"Additionally, *stderr* can be :data:`STDOUT`, which indicates that the "
"stderr data from the child process should be captured into the same file "
"handle as for *stdout*."
msgstr ""
"*stdin*, *stdout* et *stderr* spécifient respectivement les descripteurs "
"d'entrée standard, de sortie standard et de sortie d'erreur du programme "
"exécuté.  Les valeurs acceptées sont :data:`PIPE`, :data:`DEVNULL`, un "
"descripteur de fichier existant (nombre entier positif), un objet de "
"fichier, et ``None``.  :data:`PIPE` indique qu'un nouveau tube vers le "
"processus enfant sera créé.  :data:`DEVNULL` indique que le fichier spécial :"
"data:`os.devnull` sera utilisé.  Avec les paramètres ``None`` par défaut, "
"aucune redirection ne se produira, les descripteurs de fichiers du fils "
"seront hérités du parent.  Additionnellement, *stderr* peut valoir :data:"
"`STDOUT`, qui indique que les données de la sortie d'erreur du processus "
"fils doivent être capturées dans le même descripteur de fichier que la "
"sortie standard."

#: library/subprocess.rst:294
msgid ""
"If *encoding* or *errors* are specified, or *text* (also known as "
"*universal_newlines*) is true, the file objects *stdin*, *stdout* and "
"*stderr* will be opened in text mode using the *encoding* and *errors* "
"specified in the call or the defaults for :class:`io.TextIOWrapper`."
msgstr ""
"Si *encoding* ou *errors* sont spécifiés, ou si *text* (aussi appelé "
"*universal_newlines*) est vrai, les fichiers *stdin*, *stdout* et *stderr* "
"seront ouverts en mode texte en utilisant les *encoding* et *errors* "
"spécifiés à l'appel, ou les valeurs par défaut de :class:`io.TextIOWrapper`."

#: library/subprocess.rst:300
msgid ""
"For *stdin*, line ending characters ``'\\n'`` in the input will be converted "
"to the default line separator :data:`os.linesep`. For *stdout* and *stderr*, "
"all line endings in the output will be converted to ``'\\n'``.  For more "
"information see the documentation of the :class:`io.TextIOWrapper` class "
"when the *newline* argument to its constructor is ``None``."
msgstr ""
"Pour *stdin*, les caractères de fin de ligne ``'\\n'`` de l'entrée seront "
"convertis vers des séparateurs de ligne par défaut :data:`os.linesep`. Pour "
"*stdout* et *stderr*, toutes les fins de lignes des sorties seront "
"converties vers ``'\\n'``.  Pour plus d'informations, voir la documentation "
"de la classe :class:`io.TextIOWrapper` quand l'argument *newline* du "
"constructeur est ``None``."

#: library/subprocess.rst:306
msgid ""
"If text mode is not used, *stdin*, *stdout* and *stderr* will be opened as "
"binary streams. No encoding or line ending conversion is performed."
msgstr ""
"Si le mode texte n'est pas utilisé, *stdin*, *stdout* et *stderr* seront "
"ouverts comme des flux binaires. Aucune conversion d'encodage ou de fins de "
"ligne ne sera réalisée."

#: library/subprocess.rst:309
msgid "Added *encoding* and *errors* parameters."
msgstr "Ajout des paramètres *encoding* et *errors*."

#: library/subprocess.rst:312
msgid "Added the *text* parameter as an alias for *universal_newlines*."
msgstr "Ajout du paramètre *text* comme alias de *universal_newlines*."

#: library/subprocess.rst:317
msgid ""
"The newlines attribute of the file objects :attr:`Popen.stdin`, :attr:`Popen."
"stdout` and :attr:`Popen.stderr` are not updated by the :meth:`Popen."
"communicate` method."
msgstr ""
"L'attribut *newlines* des objets :attr:`Popen.stdin`, :attr:`Popen.stdout` "
"et :attr:`Popen.stderr` ne sont pas mis à jour par la méthode :meth:`Popen."
"communicate`."

#: library/subprocess.rst:321
msgid ""
"If *shell* is ``True``, the specified command will be executed through the "
"shell.  This can be useful if you are using Python primarily for the "
"enhanced control flow it offers over most system shells and still want "
"convenient access to other shell features such as shell pipes, filename "
"wildcards, environment variable expansion, and expansion of ``~`` to a "
"user's home directory.  However, note that Python itself offers "
"implementations of many shell-like features (in particular, :mod:`glob`, :"
"mod:`fnmatch`, :func:`os.walk`, :func:`os.path.expandvars`, :func:`os.path."
"expanduser`, and :mod:`shutil`)."
msgstr ""
"Si *shell* vaut ``True``, la commande spécifiée sera exécutée à travers un "
"*shell*.  Cela peut être utile si vous utilisez Python pour le contrôle de "
"flot qu'il propose par rapport à beaucoup de *shells* système et voulez tout "
"de même profiter des autres fonctionnalités des *shells* telles que les "
"tubes (*pipes*), les motifs de fichiers, l'expansion des variables "
"d'environnement, et l'expansion du ``~`` vers le répertoire d’accueil de "
"l'utilisateur. Cependant, notez que Python lui-même propose l'implémentation "
"de beaucoup de ces fonctionnalités (en particulier :mod:`glob`, :mod:"
"`fnmatch`, :func:`os.walk`, :func:`os.path.expandvars`, :func:`os.path."
"expanduser` et :mod:`shutil`)."

#: library/subprocess.rst:331
msgid ""
"When *universal_newlines* is ``True``, the class uses the encoding :func:"
"`locale.getpreferredencoding(False) <locale.getpreferredencoding>` instead "
"of ``locale.getpreferredencoding()``.  See the :class:`io.TextIOWrapper` "
"class for more information on this change."
msgstr ""
"Quand *universal_newlines* vaut ``True``, la classe utilise l'encodage :func:"
"`locale.getpreferredencoding(False) <locale.getpreferredencoding>` plutôt "
"que ``locale.getpreferredencoding()``.  Voir la classe :class:`io."
"TextIOWrapper` pour plus d'informations sur ce changement."

#: library/subprocess.rst:460
msgid ""
"Read the `Security Considerations`_ section before using ``shell=True``."
msgstr ""
"Lire la section `Security Considerations`_ avant d'utiliser ``shell=True``."

#: library/subprocess.rst:341
msgid ""
"These options, along with all of the other options, are described in more "
"detail in the :class:`Popen` constructor documentation."
msgstr ""
"Ces options, ainsi que toutes les autres, sont décrites plus en détails dans "
"la documentation du constructeur de :class:`Popen`."

#: library/subprocess.rst:346
msgid "Popen Constructor"
msgstr "Constructeur de *Popen*"

#: library/subprocess.rst:348
msgid ""
"The underlying process creation and management in this module is handled by "
"the :class:`Popen` class. It offers a lot of flexibility so that developers "
"are able to handle the less common cases not covered by the convenience "
"functions."
msgstr ""
"La création et la gestion sous-jacentes des processus est gérée par la "
"classe :class:`Popen`. Elle offre beaucoup de flexibilité de façon à ce que "
"les développeurs soient capables de gérer les cas d'utilisation les moins "
"communs, non couverts par les fonctions de convenance."

#: library/subprocess.rst:363
#, fuzzy
msgid ""
"Execute a child program in a new process.  On POSIX, the class uses :meth:"
"`os.execvpe`-like behavior to execute the child program.  On Windows, the "
"class uses the Windows ``CreateProcess()`` function.  The arguments to :"
"class:`Popen` are as follows."
msgstr ""
"Exécute un programme fils dans un nouveau processus.  Sur les systèmes "
"*POSIX*, la classe utilise un comportement similaire à :meth:`os.execvp` "
"pour exécuter le programme.  Sur Windows, la classe utilise la fonction "
"Windows ``CreateProcess()``.  Les arguments de :class:`Popen` sont les "
"suivants."

#: library/subprocess.rst:368
msgid ""
"*args* should be a sequence of program arguments or else a single string or :"
"term:`path-like object`. By default, the program to execute is the first "
"item in *args* if *args* is a sequence.  If *args* is a string, the "
"interpretation is platform-dependent and described below.  See the *shell* "
"and *executable* arguments for additional differences from the default "
"behavior.  Unless otherwise stated, it is recommended to pass *args* as a "
"sequence."
msgstr ""
"*args* peut être une séquence d'arguments du programme, une chaîne seule ou "
"un :term:`objet chemin <path-like object>`. Par défaut, le programme à "
"exécuter est le premier élément de *args* si *args* est une séquence. Si "
"*args* est une chaîne de caractères, l'interprétation dépend de la "
"plateforme et est décrite plus bas. Voir les arguments *shell* et "
"*executable* pour d'autres différences avec le comportement par défaut. Sans "
"autre indication, il est recommandé de passer *args* comme une séquence."

#: library/subprocess.rst:378
msgid ""
"For maximum reliability, use a fully qualified path for the executable. To "
"search for an unqualified name on :envvar:`PATH`, use :meth:`shutil.which`. "
"On all platforms, passing :data:`sys.executable` is the recommended way to "
"launch the current Python interpreter again, and use the ``-m`` command-line "
"format to launch an installed module."
msgstr ""

#: library/subprocess.rst:384
msgid ""
"Resolving the path of *executable* (or the first item of *args*) is platform "
"dependent. For POSIX, see :meth:`os.execvpe`, and note that when resolving "
"or searching for the executable path, *cwd* overrides the current working "
"directory and *env* can override the ``PATH`` environment variable. For "
"Windows, see the documentation of the ``lpApplicationName`` and "
"``lpCommandLine`` parameters of WinAPI ``CreateProcess``, and note that when "
"resolving or searching for the executable path with ``shell=False``, *cwd* "
"does not override the current working directory and *env* cannot override "
"the ``PATH`` environment variable. Using a full path avoids all of these "
"variations."
msgstr ""

#: library/subprocess.rst:395
msgid ""
"An example of passing some arguments to an external program as a sequence "
"is::"
msgstr ""

#: library/subprocess.rst:400
msgid ""
"On POSIX, if *args* is a string, the string is interpreted as the name or "
"path of the program to execute.  However, this can only be done if not "
"passing arguments to the program."
msgstr ""
"Sur les systèmes *POSIX*, si *args* est une chaîne, elle est interprétée "
"comme le nom ou le chemin du programme à exécuter.  Cependant, cela ne peut "
"être fait que si le programme est passé sans arguments."

#: library/subprocess.rst:406
msgid ""
"It may not be obvious how to break a shell command into a sequence of "
"arguments, especially in complex cases. :meth:`shlex.split` can illustrate "
"how to determine the correct tokenization for *args*::"
msgstr ""

#: library/subprocess.rst:418
msgid ""
"Note in particular that options (such as *-input*) and arguments (such as "
"*eggs.txt*) that are separated by whitespace in the shell go in separate "
"list elements, while arguments that need quoting or backslash escaping when "
"used in the shell (such as filenames containing spaces or the *echo* command "
"shown above) are single list elements."
msgstr ""
"Notez en particulier que les options (comme *-input*) et arguments (comme "
"*eggs.txt*) qui sont séparés par des espaces dans le *shell* iront dans des "
"éléments séparés de la liste, alors que les arguments qui nécessitent des "
"guillemets et échappements quand utilisés dans le *shell* (comme les noms de "
"fichiers contenant des espaces ou la commande *echo* montrée plus haut) "
"forment des éléments uniques."

#: library/subprocess.rst:424
msgid ""
"On Windows, if *args* is a sequence, it will be converted to a string in a "
"manner described in :ref:`converting-argument-sequence`.  This is because "
"the underlying ``CreateProcess()`` operates on strings."
msgstr ""
"Sous Windows, si *args* est une séquence, elle sera convertie vers une "
"chaîne de caractères de la manière décrite dans :ref:`converting-argument-"
"sequence`.  Cela fonctionne ainsi parce que la fonction ``CreateProcess()`` "
"opère sur des chaînes."

#: library/subprocess.rst:428
msgid ""
"*args* parameter accepts a :term:`path-like object` if *shell* is ``False`` "
"and a sequence containing path-like objects on POSIX."
msgstr ""
"Le paramètre *args* accepte un :term:`objet chemin <path-like object>` si "
"*shell* vaut ``False`` et une séquence contenant des objets fichier sur "
"POSIX."

#: library/subprocess.rst:432
msgid ""
"*args* parameter accepts a :term:`path-like object` if *shell* is ``False`` "
"and a sequence containing bytes and path-like objects on Windows."
msgstr ""
"Le paramètre *args* accepte un :term:`objet chemin <path-like object>` si "
"*shell* vaut ``False`` et une séquence contenant des chaines d'octets et des "
"objets chemins sur Windows."

#: library/subprocess.rst:437
msgid ""
"The *shell* argument (which defaults to ``False``) specifies whether to use "
"the shell as the program to execute.  If *shell* is ``True``, it is "
"recommended to pass *args* as a string rather than as a sequence."
msgstr ""
"L'argument *shell* (qui vaut ``False`` par défaut) spécifie s'il faut "
"utiliser un *shell* comme programme à exécuter.  Si *shell* vaut ``True``, "
"il est recommandé de passer *args* comme une chaîne de caractères plutôt "
"qu'une séquence."

#: library/subprocess.rst:441
msgid ""
"On POSIX with ``shell=True``, the shell defaults to :file:`/bin/sh`.  If "
"*args* is a string, the string specifies the command to execute through the "
"shell.  This means that the string must be formatted exactly as it would be "
"when typed at the shell prompt.  This includes, for example, quoting or "
"backslash escaping filenames with spaces in them.  If *args* is a sequence, "
"the first item specifies the command string, and any additional items will "
"be treated as additional arguments to the shell itself.  That is to say, :"
"class:`Popen` does the equivalent of::"
msgstr ""
"Sur les systèmes POSIX avec ``shell=True``, le *shell* par défaut est :file:"
"`/bin/sh`.  Si *args* est une chaîne de caractères, la chaîne spécifie la "
"commande à exécuter à travers le *shell*.  Cela signifie que la chaîne doit "
"être formatée exactement comme elle le serait si elle était tapée dans "
"l'invite de commandes du *shell*.  Cela inclut, par exemple, les guillemets "
"ou les *backslashs* échappant les noms de fichiers contenant des espaces.  "
"Si *args* est une séquence, le premier élément spécifie la commande, et les "
"éléments supplémentaires seront traités comme des arguments additionnels à "
"passer au *shell* lui-même.  Pour ainsi dire, :class:`Popen` réalise "
"l'équivalent de ::"

#: library/subprocess.rst:452
msgid ""
"On Windows with ``shell=True``, the :envvar:`COMSPEC` environment variable "
"specifies the default shell.  The only time you need to specify "
"``shell=True`` on Windows is when the command you wish to execute is built "
"into the shell (e.g. :command:`dir` or :command:`copy`).  You do not need "
"``shell=True`` to run a batch file or console-based executable."
msgstr ""
"Sous Windows avec ``shell=True``, la variable d'environnement :envvar:"
"`COMSPEC` spécifie le *shell* par défaut.  La seule raison pour laquelle "
"vous devriez spécifier ``shell=True`` sous Windows est quand la commande que "
"vous souhaitez exécuter est une *built-in* du *shell* (p. ex. :command:`dir` "
"ou :command:`copy`).  Vous n'avez pas besoin de ``shell=True`` pour lancer "
"un fichier batch ou un exécutable console."

#: library/subprocess.rst:462
msgid ""
"*bufsize* will be supplied as the corresponding argument to the :func:`open` "
"function when creating the stdin/stdout/stderr pipe file objects:"
msgstr ""
"*bufsize* sera fourni comme l'argument correspondant à la fonction :func:"
"`open`, lors de la création des objets de fichiers pour les tubes *stdin*/"
"*stdout*/*stderr* :"

#: library/subprocess.rst:466
msgid ""
":const:`0` means unbuffered (read and write are one system call and can "
"return short)"
msgstr ""
":const:`0` indique de ne pas utiliser de tampon (les lectures et écritures "
"sont des appels systèmes et peuvent renvoyer des données incomplètes) ;"

#: library/subprocess.rst:468
#, fuzzy
msgid ""
":const:`1` means line buffered (only usable if ``text=True`` or "
"``universal_newlines=True``)"
msgstr ""
":const:`1` indique une mise en cache par ligne (utilisable seulement si "
"``universal_newlines=True``, c'est-à-dire en mode texte) ;"

#: library/subprocess.rst:470
msgid "any other positive value means use a buffer of approximately that size"
msgstr ""
"toutes les autres valeurs positives indiquent d'utiliser un tampon "
"d'approximativement cette taille ;"

#: library/subprocess.rst:472
msgid ""
"negative bufsize (the default) means the system default of io."
"DEFAULT_BUFFER_SIZE will be used."
msgstr ""
"un *bufsize* négatif (par défaut) indique au système d'utiliser la valeur "
"par défaut *io.DEFAULT_BUFFER_SIZE*."

#: library/subprocess.rst:475
msgid ""
"*bufsize* now defaults to -1 to enable buffering by default to match the "
"behavior that most code expects.  In versions prior to Python 3.2.4 and "
"3.3.1 it incorrectly defaulted to :const:`0` which was unbuffered and "
"allowed short reads.  This was unintentional and did not match the behavior "
"of Python 2 as most code expected."
msgstr ""
"*bufsize* vaut maintenant ``-1`` par défaut, pour activer par défaut la mise "
"en cache et correspondre au comportement attendu par la plupart des codes.  "
"Dans les versions de Python antérieures à 3.2.4 et 3.3.1, par erreur, la "
"valeur par défaut était :const:`0` qui ne réalisait aucune mise en cache et "
"autorisait les lectures incomplètes.  Cela n'était pas intentionnel et ne "
"correspondait pas au comportement de Python 2 attendu par la plupart des "
"codes."

#: library/subprocess.rst:482
msgid ""
"The *executable* argument specifies a replacement program to execute.   It "
"is very seldom needed.  When ``shell=False``, *executable* replaces the "
"program to execute specified by *args*.  However, the original *args* is "
"still passed to the program.  Most programs treat the program specified by "
"*args* as the command name, which can then be different from the program "
"actually executed.  On POSIX, the *args* name becomes the display name for "
"the executable in utilities such as :program:`ps`.  If ``shell=True``, on "
"POSIX the *executable* argument specifies a replacement shell for the "
"default :file:`/bin/sh`."
msgstr ""
"L'argument *executable* spécifie un programme de remplacement à exécuter.  "
"Il est très rarement nécessaire.  Quand ``shell=False``, *executable* "
"remplace le programme à exécuter spécifié par *args*.  Cependant, les "
"arguments originels d'*args` sont toujours passés au programme.  La plupart "
"des programmes traitent le programme spécifié par *args* comme le nom de la "
"commande, qui peut être différent du programme réellement exécuté.  Sur les "
"systèmes POSIX, le nom tiré d'*args* devient le nom affiché pour "
"l'exécutable dans des utilitaires tels que :program:`ps`.  Si "
"``shell=True``, sur les systèmes POSIX, l'argument *executable* précise le "
"*shell* à utiliser plutôt que :file:`/bin/sh` par défaut."

#: library/subprocess.rst:492
msgid "*executable* parameter accepts a :term:`path-like object` on POSIX."
msgstr ""
"le paramètre *executable* accepte un :term:`objet chemin <path-like object>` "
"sur les systèmes POSIX."

#: library/subprocess.rst:495
msgid ""
"*executable* parameter accepts a bytes and :term:`path-like object` on "
"Windows."
msgstr ""
"le paramètre *executable* accepte un objet *bytes* ou un :term:`objet chemin "
"<path-like object>` sur Windows."

#: library/subprocess.rst:507
#, fuzzy
msgid ""
"*stdin*, *stdout* and *stderr* specify the executed program's standard "
"input, standard output and standard error file handles, respectively.  Valid "
"values are :data:`PIPE`, :data:`DEVNULL`, an existing file descriptor (a "
"positive integer), an existing :term:`file object` with a valid file "
"descriptor, and ``None``.  :data:`PIPE` indicates that a new pipe to the "
"child should be created.  :data:`DEVNULL` indicates that the special file :"
"data:`os.devnull` will be used. With the default settings of ``None``, no "
"redirection will occur; the child's file handles will be inherited from the "
"parent.  Additionally, *stderr* can be :data:`STDOUT`, which indicates that "
"the stderr data from the applications should be captured into the same file "
"handle as for stdout."
msgstr ""
"*stdin*, *stdout* et *stderr* spécifient respectivement les descripteurs "
"d'entrée standard, de sortie standard et de sortie d'erreur du programme "
"exécuté.  Les valeurs acceptées sont :data:`PIPE`, :data:`DEVNULL`, un "
"descripteur de fichier existant (nombre entier positif), un :term:`file "
"object`, et ``None``.  :data:`PIPE` indique qu'un nouveau tube vers le "
"processus enfant sera créé.  :data:`DEVNULL` indique que le fichier spécial :"
"data:`os.devnull` sera utilisé.  Avec les paramètres ``None`` par défaut, "
"aucune redirection ne se produira, les descripteurs de fichiers du fils "
"seront hérités du parent.  Additionnellement, *stderr* peut valoir :data:"
"`STDOUT`, qui indique que les données de la sortie d'erreur du processus "
"fils doivent être capturées dans le même descripteur de fichier que la "
"sortie standard."

#: library/subprocess.rst:519
msgid ""
"If *preexec_fn* is set to a callable object, this object will be called in "
"the child process just before the child is executed. (POSIX only)"
msgstr ""
"Si un objet appelable est passé à *preexec_fn*, cet objet sera appelé dans "
"le processus enfant juste avant d'exécuter le programme.  (POSIX seulement)"

#: library/subprocess.rst:525
#, fuzzy
msgid ""
"The *preexec_fn* parameter is NOT SAFE to use in the presence of threads in "
"your application.  The child process could deadlock before exec is called."
msgstr ""
"Le paramètre *preexec_fn* n'est pas sain à utiliser en présence d'autres "
"fils d'exécution dans votre application.  Le processus fils pourrait être "
"bloqué (*deadlock*) avant qu'*exec* ne soit appelée. Si vous devez utiliser "
"ce paramètre, gardez son utilisation triviale !  Minimisez le nombre de "
"bibliothèques que vous y appelez."

#: library/subprocess.rst:531
#, fuzzy
msgid ""
"If you need to modify the environment for the child use the *env* parameter "
"rather than doing it in a *preexec_fn*. The *start_new_session* and "
"*process_group* parameters should take the place of code using *preexec_fn* "
"to call :func:`os.setsid` or :func:`os.setpgid` in the child."
msgstr ""
"Si vous devez modifier l'environnement du fils, utilisez le paramètre *env* "
"plutôt que faire cela dans une *preexec_fn*. Le paramètre "
"*start_new_session* peut prendre la place de *preexec_fn* qui était "
"autrefois communément utilisé pour appeler *os.setsid()* dans le fils."

#: library/subprocess.rst:538
msgid ""
"The *preexec_fn* parameter is no longer supported in subinterpreters. The "
"use of the parameter in a subinterpreter raises :exc:`RuntimeError`. The new "
"restriction may affect applications that are deployed in mod_wsgi, uWSGI, "
"and other embedded environments."
msgstr ""
"Le paramètre *preexec_fn* n'est plus pris en charge dans les sous-"
"interpréteurs. L'utilisation de ce paramètre lève :exc:`RuntimeError`. Cette "
"nouvelle restriction peut affecter les applications déployées avec "
"*mod_wsgi*, *uWSGI* et d'autres environnements qui peuvent embarquer Python."

#: library/subprocess.rst:543
msgid ""
"If *close_fds* is true, all file descriptors except :const:`0`, :const:`1` "
"and :const:`2` will be closed before the child process is executed.  "
"Otherwise when *close_fds* is false, file descriptors obey their inheritable "
"flag as described in :ref:`fd_inheritance`."
msgstr ""
"Si *close_fds* est vrai, tous les descripteurs de fichiers exceptés :const:"
"`0`,  :const:`1` et  :const:`2` sont fermés avant que le processus enfant "
"soit exécuté. Sinon, quand *close_fds* est faux, les descripteurs de "
"fichiers se comportent conformément à leur option d'héritage décrite dans :"
"ref:`fd_inheritance`."

#: library/subprocess.rst:548
msgid ""
"On Windows, if *close_fds* is true then no handles will be inherited by the "
"child process unless explicitly passed in the ``handle_list`` element of :"
"attr:`STARTUPINFO.lpAttributeList`, or by standard handle redirection."
msgstr ""
"Sur Windows, si *close_fds* est vrai, alors aucun descripteur n'est hérité "
"par le processus enfant à moins d'être explicitement passé dans l'élément "
"``handle_list`` de :attr:`STARTUPINFO.lpAttributeList`, ou par redirection "
"des descripteurs standards."

#: library/subprocess.rst:552
msgid ""
"The default for *close_fds* was changed from :const:`False` to what is "
"described above."
msgstr ""
"La valeur par défaut de *close_fds* n'est plus :const:`False`, comme décrit "
"ci-dessus."

#: library/subprocess.rst:556
msgid ""
"On Windows the default for *close_fds* was changed from :const:`False` to :"
"const:`True` when redirecting the standard handles. It's now possible to set "
"*close_fds* to :const:`True` when redirecting the standard handles."
msgstr ""
"Sur Windows, la valeur par défaut de *close_fds* a été changée de :const:"
"`False` à :const:`True` lors d'une redirection des descripteurs standards. "
"Il est maintenant possible de donner la valeur :const:`True` à *close_fds* "
"lors d'une redirection de descripteurs standards."

#: library/subprocess.rst:561
msgid ""
"*pass_fds* is an optional sequence of file descriptors to keep open between "
"the parent and child.  Providing any *pass_fds* forces *close_fds* to be :"
"const:`True`.  (POSIX only)"
msgstr ""
"*pass_fds* est une séquence optionnelle de descripteurs de fichiers à garder "
"ouverts entre le parent et l'enfant.  Fournir *pass_fds* force *close_fds* à "
"valoir :const:`True`. (POSIX seulement)"

#: library/subprocess.rst:565
msgid "The *pass_fds* parameter was added."
msgstr "Ajout du paramètre *pass_fds*."

#: library/subprocess.rst:568
#, fuzzy
msgid ""
"If *cwd* is not ``None``, the function changes the working directory to "
"*cwd* before executing the child.  *cwd* can be a string, bytes or :term:"
"`path-like <path-like object>` object.  On POSIX, the function looks for "
"*executable* (or for the first item in *args*) relative to *cwd* if the "
"executable path is a relative path."
msgstr ""
"Si *cwd* ne vaut pas ``None``, la fonction change de répertoire courant pour "
"*cwd* avant d'exécuter le fils. *cwd* peut être une chaîne de caractères, "
"une séquence d'octets ou un :term:`objet chemin <path-like object>`. En "
"particulier, la fonction recherche *executable* (ou le premier élément dans "
"*args*) relativement à *cwd* si le chemin d'exécution est relatif."

#: library/subprocess.rst:574
msgid "*cwd* parameter accepts a :term:`path-like object` on POSIX."
msgstr ""
"le paramètre *cwd* accepte un :term:`objet chemin <path-like object>` sur "
"les systèmes POSIX."

#: library/subprocess.rst:577
msgid "*cwd* parameter accepts a :term:`path-like object` on Windows."
msgstr ""
"le paramètre *cwd* accepte un :term:`objet chemin <path-like object>` sur "
"Windows."

#: library/subprocess.rst:580
msgid "*cwd* parameter accepts a bytes object on Windows."
msgstr "le paramètre *cwd* accepte une séquence d'octets sur Windows"

#: library/subprocess.rst:583
msgid ""
"If *restore_signals* is true (the default) all signals that Python has set "
"to SIG_IGN are restored to SIG_DFL in the child process before the exec. "
"Currently this includes the SIGPIPE, SIGXFZ and SIGXFSZ signals. (POSIX only)"
msgstr ""
"Si *restore_signals* est vrai (par défaut), tous les signaux que Python a "
"mis à *SIG_IGN* sont restaurés à *SIG_DFL* dans le processus fils avant "
"l'appel à *exec*.  Actuellement, cela inclut les signaux *SIGPIPE*, *SIGXFZ* "
"et *SIGXFSZ*.  (POSIX seulement)"

#: library/subprocess.rst:588
msgid "*restore_signals* was added."
msgstr "Ajout de *restore_signals*."

#: library/subprocess.rst:591
#, fuzzy
msgid ""
"If *start_new_session* is true the ``setsid()`` system call will be made in "
"the child process prior to the execution of the subprocess."
msgstr ""
"Si *start_new_session* est vrai, l'appel système à *setsid()* sera réalisé "
"dans le processus fils avant l'exécution du sous-processus.  (POSIX "
"seulement)"

#: library/subprocess.rst:601 library/subprocess.rst:620
#: library/subprocess.rst:635
#, fuzzy
msgid ":ref:`Availability <availability>`: POSIX"
msgstr ":ref:`Disponibilité <availability>` : POSIX et Windows."

#: library/subprocess.rst:595
msgid "*start_new_session* was added."
msgstr "Ajout de *start_new_session*."

#: library/subprocess.rst:598
#, fuzzy
msgid ""
"If *process_group* is a non-negative integer, the ``setpgid(0, value)`` "
"system call will be made in the child process prior to the execution of the "
"subprocess."
msgstr ""
"Si *start_new_session* est vrai, l'appel système à *setsid()* sera réalisé "
"dans le processus fils avant l'exécution du sous-processus.  (POSIX "
"seulement)"

#: library/subprocess.rst:602
#, fuzzy
msgid "*process_group* was added."
msgstr "Ajout de *timeout*."

#: library/subprocess.rst:605
msgid ""
"If *group* is not ``None``, the setregid() system call will be made in the "
"child process prior to the execution of the subprocess. If the provided "
"value is a string, it will be looked up via :func:`grp.getgrnam()` and the "
"value in ``gr_gid`` will be used. If the value is an integer, it will be "
"passed verbatim. (POSIX only)"
msgstr ""

#: library/subprocess.rst:614
msgid ""
"If *extra_groups* is not ``None``, the setgroups() system call will be made "
"in the child process prior to the execution of the subprocess. Strings "
"provided in *extra_groups* will be looked up via :func:`grp.getgrnam()` and "
"the values in ``gr_gid`` will be used. Integer values will be passed "
"verbatim. (POSIX only)"
msgstr ""

#: library/subprocess.rst:623
msgid ""
"If *user* is not ``None``, the setreuid() system call will be made in the "
"child process prior to the execution of the subprocess. If the provided "
"value is a string, it will be looked up via :func:`pwd.getpwnam()` and the "
"value in ``pw_uid`` will be used. If the value is an integer, it will be "
"passed verbatim. (POSIX only)"
msgstr ""

#: library/subprocess.rst:632
#, fuzzy
msgid ""
"If *umask* is not negative, the umask() system call will be made in the "
"child process prior to the execution of the subprocess."
msgstr ""
"Si *start_new_session* est vrai, l'appel système à *setsid()* sera réalisé "
"dans le processus fils avant l'exécution du sous-processus.  (POSIX "
"seulement)"

#: library/subprocess.rst:638
#, fuzzy
msgid ""
"If *env* is not ``None``, it must be a mapping that defines the environment "
"variables for the new process; these are used instead of the default "
"behavior of inheriting the current process' environment. This mapping can be "
"str to str on any platform or bytes to bytes on POSIX platforms much like :"
"data:`os.environ` or :data:`os.environb`."
msgstr ""
"Si *env* n'est pas ``None``, il doit être un tableau associatif définissant "
"les variables d'environnement du nouveau processus ; elles seront utilisées "
"à la place du comportement par défaut qui est d'hériter de l'environnement "
"du processus courant. Il est passé directement à :class:`Popen`."

#: library/subprocess.rst:646
msgid ""
"If specified, *env* must provide any variables required for the program to "
"execute.  On Windows, in order to run a `side-by-side assembly`_ the "
"specified *env* **must** include a valid :envvar:`SystemRoot`."
msgstr ""
"Si spécifié, *env* doit fournir chaque variable requise pour l'exécution du "
"programme.  Sous Windows, afin d'exécuter un `side-by-side assembly`_, "
"l'environnement *env* spécifié **doit** contenir une variable :envvar:"
"`SystemRoot` valide."

#: library/subprocess.rst:652
#, fuzzy
msgid ""
"If *encoding* or *errors* are specified, or *text* is true, the file objects "
"*stdin*, *stdout* and *stderr* are opened in text mode with the specified "
"*encoding* and *errors*, as described above in :ref:`frequently-used-"
"arguments`. The *universal_newlines* argument is equivalent  to *text* and "
"is provided for backwards compatibility. By default, file objects are opened "
"in binary mode."
msgstr ""
"Si *encoding* ou *errors* sont spécifiés, ou si *text* est vrai, les "
"fichiers *stdin*, *stdout* et *stderr* sont ouverts en mode texte, avec "
"l'encodage et la valeur d'*errors* spécifiés, comme décrit ci-dessus dans :"
"ref:`frequently-used-arguments`. L'argument *universal_newlines*, équivalent "
"à *text*, est fourni pour la rétrocompatibilité. Autrement, ils sont ouverts "
"comme des flux binaires."

#: library/subprocess.rst:658
msgid "*encoding* and *errors* were added."
msgstr "Ajout d'*encoding* et *errors*."

#: library/subprocess.rst:1279
msgid "*text* was added as a more readable alias for *universal_newlines*."
msgstr ""
"*text* a été ajouté comme un alias plus lisible de *universal_newlines*."

#: library/subprocess.rst:664
msgid ""
"If given, *startupinfo* will be a :class:`STARTUPINFO` object, which is "
"passed to the underlying ``CreateProcess`` function. *creationflags*, if "
"given, can be one or more of the following flags:"
msgstr ""
"Si fourni, *startupinfo* sera un objet :class:`STARTUPINFO`, qui sera passé "
"à la fonction ``CreateProcess`` inhérente.  *creationflags*, si fourni, peut "
"avoir l'une des valeurs suivantes :"

#: library/subprocess.rst:668
msgid ":data:`CREATE_NEW_CONSOLE`"
msgstr ":data:`CREATE_NEW_CONSOLE`"

#: library/subprocess.rst:669
msgid ":data:`CREATE_NEW_PROCESS_GROUP`"
msgstr ":data:`CREATE_NEW_PROCESS_GROUP`"

#: library/subprocess.rst:670
msgid ":data:`ABOVE_NORMAL_PRIORITY_CLASS`"
msgstr ":data:`ABOVE_NORMAL_PRIORITY_CLASS`"

#: library/subprocess.rst:671
msgid ":data:`BELOW_NORMAL_PRIORITY_CLASS`"
msgstr ":data:`BELOW_NORMAL_PRIORITY_CLASS`"

#: library/subprocess.rst:672
msgid ":data:`HIGH_PRIORITY_CLASS`"
msgstr ":data:`HIGH_PRIORITY_CLASS`"

#: library/subprocess.rst:673
msgid ":data:`IDLE_PRIORITY_CLASS`"
msgstr ":data:`IDLE_PRIORITY_CLASS`"

#: library/subprocess.rst:674
msgid ":data:`NORMAL_PRIORITY_CLASS`"
msgstr ":data:`NORMAL_PRIORITY_CLASS`"

#: library/subprocess.rst:675
msgid ":data:`REALTIME_PRIORITY_CLASS`"
msgstr ":data:`REALTIME_PRIORITY_CLASS`"

#: library/subprocess.rst:676
msgid ":data:`CREATE_NO_WINDOW`"
msgstr ":data:`CREATE_NO_WINDOW`"

#: library/subprocess.rst:677
msgid ":data:`DETACHED_PROCESS`"
msgstr ":data:`DETACHED_PROCESS`"

#: library/subprocess.rst:678
msgid ":data:`CREATE_DEFAULT_ERROR_MODE`"
msgstr ":data:`CREATE_DEFAULT_ERROR_MODE`"

#: library/subprocess.rst:679
msgid ":data:`CREATE_BREAKAWAY_FROM_JOB`"
msgstr ":data:`CREATE_BREAKAWAY_FROM_JOB`"

#: library/subprocess.rst:681
msgid ""
"*pipesize* can be used to change the size of the pipe when :data:`PIPE` is "
"used for *stdin*, *stdout* or *stderr*. The size of the pipe is only changed "
"on platforms that support this (only Linux at this time of writing). Other "
"platforms will ignore this parameter."
msgstr ""

#: library/subprocess.rst:686
#, fuzzy
msgid "The ``pipesize`` parameter was added."
msgstr "Ajout du paramètre *pass_fds*."

#: library/subprocess.rst:689
msgid ""
"Popen objects are supported as context managers via the :keyword:`with` "
"statement: on exit, standard file descriptors are closed, and the process is "
"waited for. ::"
msgstr ""
"Les objets *Popen* sont gérés comme gestionnaires de contexte avec "
"l'instruction :keyword:`with` : à la sortie, les descripteurs de fichiers "
"standards sont fermés, et le processus est attendu ::"

#: library/subprocess.rst:334
msgid ""
"Raises an :ref:`auditing event <auditing>` ``subprocess.Popen`` with "
"arguments ``executable``, ``args``, ``cwd``, ``env``."
msgstr ""
"Lève un :ref:`évènement d'audit <auditing>` ``subprocess.Popen`` avec comme "
"arguments ``executable``, ``args``, ``cwd`` et ``env``."

#: library/subprocess.rst:698
msgid ""
"Popen and the other functions in this module that use it raise an :ref:"
"`auditing event <auditing>` ``subprocess.Popen`` with arguments "
"``executable``, ``args``, ``cwd``, and ``env``. The value for ``args`` may "
"be a single string or a list of strings, depending on platform."
msgstr ""
"*Popen* et les autres fonctions dans ce module qui l'utilisent lèvent un :"
"ref:`évènement d'audit <auditing>` ``subprocess.Popen`` avec comme arguments "
"``executable``, ``args``, ``cwd`` et ``env``. La valeur pour ``args`` peut "
"être une simple chaîne de caractères ou une liste de chaînes, en fonction de "
"la plateforme."

#: library/subprocess.rst:703
msgid "Added context manager support."
msgstr "Ajout de la gestion des gestionnaires de contexte."

#: library/subprocess.rst:706
msgid ""
"Popen destructor now emits a :exc:`ResourceWarning` warning if the child "
"process is still running."
msgstr ""
"Le destructeur de *Popen* émet maintenant un avertissement :exc:"
"`ResourceWarning` si le processus fils est toujours en cours d'exécution."

#: library/subprocess.rst:710
msgid ""
"Popen can use :func:`os.posix_spawn` in some cases for better performance. "
"On Windows Subsystem for Linux and QEMU User Emulation, Popen constructor "
"using :func:`os.posix_spawn` no longer raise an exception on errors like "
"missing program, but the child process fails with a non-zero :attr:`~Popen."
"returncode`."
msgstr ""
"*Popen* peut utiliser :func:`os.posix_spawn` dans certains cas pour de "
"meilleures performances. Sur le sous-système Linux de Windows et sur *QEMU* "
"en mode utilisateur, le constructeur de *Popen* utilisant :func:`os."
"posix_spawn` ne lève plus d'exception sur les erreurs comme programme "
"manquant, mais le processus enfant échoue avec un :attr:`~Popen.returncode` "
"différent de zéro."

#: library/subprocess.rst:719
msgid "Exceptions"
msgstr "Exceptions"

#: library/subprocess.rst:721
msgid ""
"Exceptions raised in the child process, before the new program has started "
"to execute, will be re-raised in the parent."
msgstr ""
"Les exceptions levées dans le processus fils, avant que le nouveau programme "
"ait commencé à s'exécuter, seront ré-levées dans le parent."

#: library/subprocess.rst:724
msgid ""
"The most common exception raised is :exc:`OSError`.  This occurs, for "
"example, when trying to execute a non-existent file.  Applications should "
"prepare for :exc:`OSError` exceptions. Note that, when ``shell=True``, :exc:"
"`OSError` will be raised by the child only if the selected shell itself was "
"not found. To determine if the shell failed to find the requested "
"application, it is necessary to check the return code or output from the "
"subprocess."
msgstr ""

#: library/subprocess.rst:731
msgid ""
"A :exc:`ValueError` will be raised if :class:`Popen` is called with invalid "
"arguments."
msgstr ""
"Une :exc:`ValueError` sera levée si :class:`Popen` est appelé avec des "
"arguments invalides."

#: library/subprocess.rst:734
msgid ""
":func:`check_call` and :func:`check_output` will raise :exc:"
"`CalledProcessError` if the called process returns a non-zero return code."
msgstr ""
":func:`check_call` et :func:`check_output` lèveront une :exc:"
"`CalledProcessError` si le processus appelé renvoie un code de retour non "
"nul."

#: library/subprocess.rst:738
msgid ""
"All of the functions and methods that accept a *timeout* parameter, such as :"
"func:`call` and :meth:`Popen.communicate` will raise :exc:`TimeoutExpired` "
"if the timeout expires before the process exits."
msgstr ""
"Toutes les fonctions et méthodes qui acceptent un paramètre *timeout*, "
"telles que :func:`call` et :meth:`Popen.communicate` lèveront une :exc:"
"`TImeoutExpired` si le *timeout* expire avant la fin du processus."

#: library/subprocess.rst:742
msgid ""
"Exceptions defined in this module all inherit from :exc:`SubprocessError`."
msgstr ""
"Toutes les exceptions définies dans ce module héritent de :exc:"
"`SubprocessError`."

#: library/subprocess.rst:744
msgid "The :exc:`SubprocessError` base class was added."
msgstr "Ajout de la classe de base :exc:`SubprocessError`."

#: library/subprocess.rst:750
msgid "Security Considerations"
msgstr "Considérations de sécurité"

#: library/subprocess.rst:752
#, fuzzy
msgid ""
"Unlike some other popen functions, this implementation will never implicitly "
"call a system shell.  This means that all characters, including shell "
"metacharacters, can safely be passed to child processes. If the shell is "
"invoked explicitly, via ``shell=True``, it is the application's "
"responsibility to ensure that all whitespace and metacharacters are quoted "
"appropriately to avoid `shell injection <https://en.wikipedia.org/wiki/"
"Shell_injection#Shell_injection>`_ vulnerabilities. On :ref:`some platforms "
"<shlex-quote-warning>`, it is possible to use :func:`shlex.quote` for this "
"escaping."
msgstr ""
"Contrairement à quelques autres fonctions *popen*, cette implémentation "
"n'appellera jamais implicitement le *shell* du système.  Cela signifie que "
"tous les caractères, incluant les métacaractères des *shells*, peuvent être "
"passés aux processus fils en toute sécurité. Si le *shell* est invoqué "
"explicitement, avec ``shell=True``, il est de la responsabilité de "
"l'application d'assurer que les espaces et métacaractères sont échappés "
"correctement pour éviter les vulnérabilités de type `shell injection "
"<https://en.wikipedia.org/wiki/Shell_injection#Shell_injection>`_."

#: library/subprocess.rst:764
msgid "Popen Objects"
msgstr "Objets *Popen*"

#: library/subprocess.rst:766
msgid "Instances of the :class:`Popen` class have the following methods:"
msgstr ""
"Les instances de la classe :class:`Popen` possèdent les méthodes suivantes :"

#: library/subprocess.rst:771
msgid ""
"Check if child process has terminated.  Set and return :attr:`~Popen."
"returncode` attribute. Otherwise, returns ``None``."
msgstr ""
"Vérifie que le processus enfant s'est terminé.  Modifie et renvoie "
"l'attribut :attr:`~Popen.returncode`, sinon, renvoie ``None``."

#: library/subprocess.rst:777
msgid ""
"Wait for child process to terminate.  Set and return :attr:`~Popen."
"returncode` attribute."
msgstr ""
"Attend qu'un processus enfant se termine.  Modifie l'attribut :attr:`~Popen."
"returncode` et le renvoie."

#: library/subprocess.rst:780
msgid ""
"If the process does not terminate after *timeout* seconds, raise a :exc:"
"`TimeoutExpired` exception.  It is safe to catch this exception and retry "
"the wait."
msgstr ""
"Si le processus ne se termine pas après le nombre de secondes spécifié par "
"*timeout*, une exception :exc:`TimeoutExpired` est levée.  Cela ne pose "
"aucun problème d'attraper cette exception et de réessayer d'attendre."

#: library/subprocess.rst:786
msgid ""
"This will deadlock when using ``stdout=PIPE`` or ``stderr=PIPE`` and the "
"child process generates enough output to a pipe such that it blocks waiting "
"for the OS pipe buffer to accept more data. Use :meth:`Popen.communicate` "
"when using pipes to avoid that."
msgstr ""
"Cela provoquera un blocage (*deadlock*) lors de l'utilisation de "
"``stdout=PIPE`` ou ``stderr=PIPE`` si le processus fils génère tellement de "
"données sur le tube qu'il le bloque, en attente que le système "
"d'exploitation permette au tampon du tube d'accepter plus de données.  "
"Utilisez :meth:`Popen.communicate` pour éviter ce problème lors de "
"l'utilisation de tubes."

#: library/subprocess.rst:793
msgid ""
"The function is implemented using a busy loop (non-blocking call and short "
"sleeps). Use the :mod:`asyncio` module for an asynchronous wait: see :class:"
"`asyncio.create_subprocess_exec`."
msgstr ""
"Cette fonction est implémentée avec une attente active (appels non bloquants "
"et *sleep* courts). Utilisez le module :mod:`asyncio` pour une attente "
"asynchrone : voir :class:`asyncio.create_subprocess_exec`."

#: library/subprocess.rst:838 library/subprocess.rst:1216
#: library/subprocess.rst:1270
msgid "*timeout* was added."
msgstr "Ajout de *timeout*."

#: library/subprocess.rst:802
#, fuzzy
msgid ""
"Interact with process: Send data to stdin.  Read data from stdout and "
"stderr, until end-of-file is reached.  Wait for process to terminate and set "
"the :attr:`~Popen.returncode` attribute.  The optional *input* argument "
"should be data to be sent to the child process, or ``None``, if no data "
"should be sent to the child.  If streams were opened in text mode, *input* "
"must be a string. Otherwise, it must be bytes."
msgstr ""
"Interagit avec le processus : envoie des données sur l'entrée standard, lit "
"en retour les données sur les sorties standard et d'erreur, et attend que le "
"processus se termine.  L'argument optionnel *input* contient les données à "
"envoyer au processus fils, ou ``None`` s'il n'y a aucune donnée à lui "
"transmettre.  Si les flux sont ouverts en mode texte, *input* doit être une "
"chaîne de caractère.  Autrement, ce doit être un objet *bytes*."

#: library/subprocess.rst:809
msgid ""
":meth:`communicate` returns a tuple ``(stdout_data, stderr_data)``. The data "
"will be strings if streams were opened in text mode; otherwise, bytes."
msgstr ""
":meth:`communicate` renvoie une paire ``(stdout_data, stderr_data)``. Les "
"données seront des chaînes de caractères si les flux sont ouverts en mode "
"texte, et des objets *bytes* dans le cas contraire."

#: library/subprocess.rst:813
msgid ""
"Note that if you want to send data to the process's stdin, you need to "
"create the Popen object with ``stdin=PIPE``.  Similarly, to get anything "
"other than ``None`` in the result tuple, you need to give ``stdout=PIPE`` "
"and/or ``stderr=PIPE`` too."
msgstr ""
"Notez que si vous souhaitez envoyer des données sur l'entrée standard du "
"processus, vous devez créer l'objet *Popen* avec ``stdin=PIPE``.  "
"Similairement, pour obtenir autre chose que ``None`` dans le *n*-uplet "
"résultant, vous devez aussi préciser ``stdout=PIPE`` et/ou ``stderr=PIPE``."

#: library/subprocess.rst:818
msgid ""
"If the process does not terminate after *timeout* seconds, a :exc:"
"`TimeoutExpired` exception will be raised.  Catching this exception and "
"retrying communication will not lose any output."
msgstr ""
"Si le processus ne se termine pas après *timeout* secondes, une exception :"
"exc:`TimeoutExpired` est levée.  Attraper cette exception et retenter la "
"communication ne fait perdre aucune donnée de sortie."

#: library/subprocess.rst:822
msgid ""
"The child process is not killed if the timeout expires, so in order to "
"cleanup properly a well-behaved application should kill the child process "
"and finish communication::"
msgstr ""
"Le processus enfant n'est pas tué si le *timeout* expire, donc afin de "
"nettoyer proprement le tout, une application polie devrait tuer le processus "
"fils et terminer la communication ::"

#: library/subprocess.rst:835
msgid ""
"The data read is buffered in memory, so do not use this method if the data "
"size is large or unlimited."
msgstr ""
"Les données lues sont mises en cache en mémoire, donc n'utilisez pas cette "
"méthode si la taille des données est importante voire illimitée."

#: library/subprocess.rst:844
msgid "Sends the signal *signal* to the child."
msgstr "Envoie le signal *signal* au fils."

#: library/subprocess.rst:846
msgid "Do nothing if the process completed."
msgstr ""

#: library/subprocess.rst:850
#, fuzzy
msgid ""
"On Windows, SIGTERM is an alias for :meth:`terminate`. CTRL_C_EVENT and "
"CTRL_BREAK_EVENT can be sent to processes started with a *creationflags* "
"parameter which includes ``CREATE_NEW_PROCESS_GROUP``."
msgstr ""
"Sous Windows, *SIGTERM* est un alias pour :meth:`terminate`. *CTRL_C_EVENT* "
"et *CTRL_BREAK_EVENT* peuvent être envoyés aux processus démarrés avec un "
"paramètre *creationflags* incluant ``CREATE_NEW_PROCESS_GROUP``."

#: library/subprocess.rst:857
msgid ""
"Stop the child. On POSIX OSs the method sends SIGTERM to the child. On "
"Windows the Win32 API function :c:func:`TerminateProcess` is called to stop "
"the child."
msgstr ""
"Stoppe le processus fils. Sur les systèmes POSIX, la méthode envoie un "
"signal *SIGTERM* au fils. Sous Windows, la fonction :c:func:"
"`TerminateProcess` de l'API *Win32* est appelée pour arrêter le fils."

#: library/subprocess.rst:864
msgid ""
"Kills the child. On POSIX OSs the function sends SIGKILL to the child. On "
"Windows :meth:`kill` is an alias for :meth:`terminate`."
msgstr ""
"Tue le processus fils. Sur les systèmes POSIX, la fonction envoie un signal "
"*SIGKILL* au fils. Sous Windows, :meth:`kill` est un alias pour :meth:"
"`terminate`."

#: library/subprocess.rst:868
msgid ""
"The following attributes are also set by the class for you to access. "
"Reassigning them to new values is unsupported:"
msgstr ""

#: library/subprocess.rst:873
msgid ""
"The *args* argument as it was passed to :class:`Popen` -- a sequence of "
"program arguments or else a single string."
msgstr ""
"L'argument *args* tel que passé à :class:`Popen` -- une séquence d'arguments "
"du programme ou une simple chaîne de caractères."

#: library/subprocess.rst:880
#, fuzzy
msgid ""
"If the *stdin* argument was :data:`PIPE`, this attribute is a writeable "
"stream object as returned by :func:`open`. If the *encoding* or *errors* "
"arguments were specified or the *text* or *universal_newlines* argument was "
"``True``, the stream is a text stream, otherwise it is a byte stream. If the "
"*stdin* argument was not :data:`PIPE`, this attribute is ``None``."
msgstr ""
"Si l'argument *stdin* valait :data:`PIPE`, cet attribut est un flux "
"accessible en écriture comme renvoyé par :func:`open`. Si les arguments "
"*encoding* ou *errors* ont été spécifiés, ou si *universal_newlines* valait "
"``True``, le flux est textuel, il est autrement binaire. Si l'argument "
"*stdin* ne valait pas :data:`PIPE`, cet attribut est ``None``."

#: library/subprocess.rst:889
#, fuzzy
msgid ""
"If the *stdout* argument was :data:`PIPE`, this attribute is a readable "
"stream object as returned by :func:`open`. Reading from the stream provides "
"output from the child process. If the *encoding* or *errors* arguments were "
"specified or the *text* or *universal_newlines* argument was ``True``, the "
"stream is a text stream, otherwise it is a byte stream. If the *stdout* "
"argument was not :data:`PIPE`, this attribute is ``None``."
msgstr ""
"Si l'argument *stdout* valait :data:`PIPE`, cet attribut est un flux "
"accessible en lecture comme renvoyé par :func:`open`. Lire depuis le flux "
"fournit la sortie du processus fils. Si les arguments *encoding* ou *errors* "
"ont été spécifiés, ou si *universal_newlines* valait ``True``, le flux est "
"textuel, il est autrement binaire. Si l'argument *stdout* ne valait pas :"
"data:`PIPE`, cet attribut est ``None``."

#: library/subprocess.rst:899
#, fuzzy
msgid ""
"If the *stderr* argument was :data:`PIPE`, this attribute is a readable "
"stream object as returned by :func:`open`. Reading from the stream provides "
"error output from the child process. If the *encoding* or *errors* arguments "
"were specified or the *text* or *universal_newlines* argument was ``True``, "
"the stream is a text stream, otherwise it is a byte stream. If the *stderr* "
"argument was not :data:`PIPE`, this attribute is ``None``."
msgstr ""
"Si l'argument *stderr* valait :data:`PIPE`, cet attribut est un flux "
"accessible en lecture comme renvoyé par :func:`open`. Lire depuis le flux "
"fournit la sortie d'erreur du processus fils. Si les arguments *encoding* ou "
"*errors* ont été spécifiés, ou si *universal_newlines* valait ``True``, le "
"flux est textuel, il est autrement binaire. Si l'argument *stderr* ne valait "
"pas :data:`PIPE`, cet attribut est ``None``."

#: library/subprocess.rst:908
msgid ""
"Use :meth:`~Popen.communicate` rather than :attr:`.stdin.write <Popen."
"stdin>`, :attr:`.stdout.read <Popen.stdout>` or :attr:`.stderr.read <Popen."
"stderr>` to avoid deadlocks due to any of the other OS pipe buffers filling "
"up and blocking the child process."
msgstr ""
"Utilisez :meth:`~Popen.communicate` plutôt que :attr:`.stdin.write <Popen."
"stdin>`, :attr:`.stdout.read <Popen.stdout>` ou :attr:`.stderr.read <Popen."
"stderr>` pour empêcher les *deadlocks* dus au remplissage des tampons des "
"tubes de l'OS et bloquant le processus enfant."

#: library/subprocess.rst:916
msgid "The process ID of the child process."
msgstr "L'identifiant de processus du processus enfant."

#: library/subprocess.rst:918
msgid ""
"Note that if you set the *shell* argument to ``True``, this is the process "
"ID of the spawned shell."
msgstr ""
"Notez que si vous passez l'argument *shell* à ``True``, il s'agit alors de "
"l'identifiant du *shell* instancié."

#: library/subprocess.rst:924
msgid ""
"The child return code, set by :meth:`poll` and :meth:`wait` (and indirectly "
"by :meth:`communicate`).  A ``None`` value indicates that the process hasn't "
"terminated yet."
msgstr ""
"Le code de retour de l'enfant, attribué par :meth:`poll` et :meth:`wait` (et "
"indirectement par :meth:`communicate`).  Une valeur ``None`` indique que le "
"processus ne s'est pas encore terminé."

#: library/subprocess.rst:933
msgid "Windows Popen Helpers"
msgstr "Utilitaires *Popen* pour Windows"

#: library/subprocess.rst:935
msgid ""
"The :class:`STARTUPINFO` class and following constants are only available on "
"Windows."
msgstr ""
"La classe :class:`STARTUPINFO` et les constantes suivantes sont seulement "
"disponibles sous Windows."

#: library/subprocess.rst:941
msgid ""
"Partial support of the Windows `STARTUPINFO <https://msdn.microsoft.com/en-"
"us/library/ms686331(v=vs.85).aspx>`__ structure is used for :class:`Popen` "
"creation.  The following attributes can be set by passing them as keyword-"
"only arguments."
msgstr ""
"Une gestion partielle de la structure `STARTUPINFO <https://msdn.microsoft."
"com/en-us/library/ms686331(v=vs.85).aspx>`__ est utilisée lors de la "
"création d'un objet :class:`Popen`. Les attributs ci-dessous peuvent être "
"passés en tant que paramètres *keyword-only*."

#: library/subprocess.rst:946
msgid "Keyword-only argument support was added."
msgstr "Ajout de la gestion des paramètres *keyword-only*."

#: library/subprocess.rst:951
msgid ""
"A bit field that determines whether certain :class:`STARTUPINFO` attributes "
"are used when the process creates a window. ::"
msgstr ""
"Un champ de bits déterminant si certains attributs :class:`STARTUPINFO` sont "
"utilisés quand le processus crée une fenêtre ::"

#: library/subprocess.rst:959
msgid ""
"If :attr:`dwFlags` specifies :data:`STARTF_USESTDHANDLES`, this attribute is "
"the standard input handle for the process. If :data:`STARTF_USESTDHANDLES` "
"is not specified, the default for standard input is the keyboard buffer."
msgstr ""
"Si :attr:`dwFlags` spécifie :data:`STARTF_USESTDHANDLES`, cet attribut est "
"le descripteur d'entrée standard du processus. Si :data:"
"`STARTF_USESTDHANDLES` n'est pas spécifié, l'entrée standard par défaut est "
"le tampon du clavier."

#: library/subprocess.rst:966
msgid ""
"If :attr:`dwFlags` specifies :data:`STARTF_USESTDHANDLES`, this attribute is "
"the standard output handle for the process. Otherwise, this attribute is "
"ignored and the default for standard output is the console window's buffer."
msgstr ""
"Si :attr:`dwFlags` spécifie :data:`STARTF_USESTDHANDLES`, cet attribut est "
"le descripteur de sortie standard du processus. Autrement, l'attribut est "
"ignoré et la sortie standard par défaut est le tampon de la console."

#: library/subprocess.rst:973
msgid ""
"If :attr:`dwFlags` specifies :data:`STARTF_USESTDHANDLES`, this attribute is "
"the standard error handle for the process. Otherwise, this attribute is "
"ignored and the default for standard error is the console window's buffer."
msgstr ""
"Si :attr:`dwFlags` spécifie :data:`STARTF_USESTDHANDLES`, cet attribut est "
"le descripteur de sortie d'erreur du processus. Autrement, l'attribut est "
"ignoré et la sortie d'erreur par défaut est le tampon de la console."

#: library/subprocess.rst:979
msgid ""
"If :attr:`dwFlags` specifies :data:`STARTF_USESHOWWINDOW`, this attribute "
"can be any of the values that can be specified in the ``nCmdShow`` parameter "
"for the `ShowWindow <https://msdn.microsoft.com/en-us/library/"
"ms633548(v=vs.85).aspx>`__ function, except for ``SW_SHOWDEFAULT``. "
"Otherwise, this attribute is ignored."
msgstr ""
"Si :attr:`dwFlags` spécifie :data:`STARTF_USESHOWWINDOW`, cet attribut peut-"
"être n'importe quel attribut valide pour le paramètre ``nCmdShow`` de la "
"fonction `ShowWindow <https://msdn.microsoft.com/en-us/library/"
"ms633548(v=vs.85).aspx>`__, à l'exception de ``SW_SHOWDEFAULT``. Autrement, "
"cet attribut est ignoré."

#: library/subprocess.rst:986
msgid ""
":data:`SW_HIDE` is provided for this attribute. It is used when :class:"
"`Popen` is called with ``shell=True``."
msgstr ""
":data:`SW_HIDE` est fourni pour cet attribut. Il est utilisé quand :class:"
"`Popen` est appelée avec ``shell=True``."

#: library/subprocess.rst:991
msgid ""
"A dictionary of additional attributes for process creation as given in "
"``STARTUPINFOEX``, see `UpdateProcThreadAttribute <https://msdn.microsoft."
"com/en-us/library/windows/desktop/ms686880(v=vs.85).aspx>`__."
msgstr ""
"Dictionnaire des attributs supplémentaires pour la création d'un processus "
"comme donnés dans ``STARTUPINFOEX``, lisez `UpdateProcThreadAttribute "
"<https://msdn.microsoft.com/en-us/library/windows/desktop/ms686880(v=vs.85)."
"aspx>`__ (ressource en anglais)."

#: library/subprocess.rst:995
msgid "Supported attributes:"
msgstr "Attributs gérés :"

#: library/subprocess.rst:1013
msgid "**handle_list**"
msgstr "**handle_list**"

#: library/subprocess.rst:998
msgid ""
"Sequence of handles that will be inherited. *close_fds* must be true if non-"
"empty."
msgstr ""
"Séquence des descripteurs qui hérités du parent. *close_fds* doit être vrai "
"si la séquence n'est pas vide."

#: library/subprocess.rst:1001
msgid ""
"The handles must be temporarily made inheritable by :func:`os."
"set_handle_inheritable` when passed to the :class:`Popen` constructor, else :"
"class:`OSError` will be raised with Windows error "
"``ERROR_INVALID_PARAMETER`` (87)."
msgstr ""
"Les descripteurs doivent être temporairement héritables par :func:`os."
"set_handle_inheritable` quand ils sont passés au constructeur :class:"
"`Popen`, sinon :class:`OSError` est levée avec l'erreur Windows "
"``ERROR_INVALID_PARAMETER`` (87)."

#: library/subprocess.rst:1008
msgid ""
"In a multithreaded process, use caution to avoid leaking handles that are "
"marked inheritable when combining this feature with concurrent calls to "
"other process creation functions that inherit all handles such as :func:`os."
"system`.  This also applies to standard handle redirection, which "
"temporarily creates inheritable handles."
msgstr ""
"Dans un processus avec plusieurs fils d'exécution, faites très attention à "
"éviter la fuite de descripteurs qui sont marqués comme héritables quand vous "
"combinez ceci avec des appels concurrents vers des fonctions de création "
"d'autres processus qui héritent de tous les descripteurs (telle que :func:"
"`os.system`)."

#: library/subprocess.rst:1018
msgid "Windows Constants"
msgstr "Constantes Windows"

#: library/subprocess.rst:1020
msgid "The :mod:`subprocess` module exposes the following constants."
msgstr "Le module :mod:`subprocess` expose les constantes suivantes."

#: library/subprocess.rst:1024
msgid ""
"The standard input device. Initially, this is the console input buffer, "
"``CONIN$``."
msgstr ""
"Le périphérique d'entrée standard. Initialement, il s'agit du tampon de la "
"console d'entrée, ``CONIN$``."

#: library/subprocess.rst:1029
msgid ""
"The standard output device. Initially, this is the active console screen "
"buffer, ``CONOUT$``."
msgstr ""
"Le périphérique de sortie standard. Initialement, il s'agit du tampon de "
"l'écran de console actif, ``CONOUT$``."

#: library/subprocess.rst:1034
msgid ""
"The standard error device. Initially, this is the active console screen "
"buffer, ``CONOUT$``."
msgstr ""
"Le périphérique de sortie d'erreur. Initialement, il s'agit du tampon de "
"l'écran de console actif, ``CONOUT$``."

#: library/subprocess.rst:1039
msgid "Hides the window. Another window will be activated."
msgstr "Cache la fenêtre. Une autre fenêtre sera activée."

#: library/subprocess.rst:1043
msgid ""
"Specifies that the :attr:`STARTUPINFO.hStdInput`, :attr:`STARTUPINFO."
"hStdOutput`, and :attr:`STARTUPINFO.hStdError` attributes contain additional "
"information."
msgstr ""
"Spécifie que les attributs :attr:`STARTUPINFO.hStdInput`, :attr:`STARTUPINFO."
"hStdOutput` et :attr:`STARTUPINFO.hStdError` contiennent des informations "
"additionnelles."

#: library/subprocess.rst:1049
msgid ""
"Specifies that the :attr:`STARTUPINFO.wShowWindow` attribute contains "
"additional information."
msgstr ""
"Spécifie que l'attribut :attr:`STARTUPINFO.wShowWindow` contient des "
"informations additionnelles."

#: library/subprocess.rst:1054
msgid ""
"The new process has a new console, instead of inheriting its parent's "
"console (the default)."
msgstr ""
"Le nouveau processus instancie une nouvelle console, plutôt que d'hériter de "
"celle de son père (par défaut)."

#: library/subprocess.rst:1059
msgid ""
"A :class:`Popen` ``creationflags`` parameter to specify that a new process "
"group will be created. This flag is necessary for using :func:`os.kill` on "
"the subprocess."
msgstr ""
"Paramètre ``creationflags`` de :class:`Popen` pour spécifier si un nouveau "
"groupe de processus doit être créé. Cette option est nécessaire pour "
"utiliser :func:`os.kill` sur le sous-processus."

#: library/subprocess.rst:1063
msgid "This flag is ignored if :data:`CREATE_NEW_CONSOLE` is specified."
msgstr "L'option est ignorée si :data:`CREATE_NEW_CONSOLE` est spécifié."

#: library/subprocess.rst:1067
msgid ""
"A :class:`Popen` ``creationflags`` parameter to specify that a new process "
"will have an above average priority."
msgstr ""
"Paramètre ``creationflags`` de :class:`Popen` pour spécifier qu'un processus "
"aura une priorité au-dessus de la moyenne."

#: library/subprocess.rst:1074
msgid ""
"A :class:`Popen` ``creationflags`` parameter to specify that a new process "
"will have a below average priority."
msgstr ""
"Paramètre ``creationflags`` de :class:`Popen` pour spécifier qu'un processus "
"aura une priorité au-dessous de la moyenne."

#: library/subprocess.rst:1081
msgid ""
"A :class:`Popen` ``creationflags`` parameter to specify that a new process "
"will have a high priority."
msgstr ""
"Paramètre ``creationflags`` de :class:`Popen` pour spécifier qu'un processus "
"aura une priorité haute."

#: library/subprocess.rst:1088
msgid ""
"A :class:`Popen` ``creationflags`` parameter to specify that a new process "
"will have an idle (lowest) priority."
msgstr ""
"Paramètre ``creationflags`` de :class:`Popen` pour spécifier qu'un processus "
"aura la priorité la plus basse (inactif ou *idle*)."

#: library/subprocess.rst:1095
msgid ""
"A :class:`Popen` ``creationflags`` parameter to specify that a new process "
"will have an normal priority. (default)"
msgstr ""
"Paramètre ``creationflags`` de :class:`Popen` pour spécifier qu'un processus "
"aura une priorité normale (le défaut)."

#: library/subprocess.rst:1102
msgid ""
"A :class:`Popen` ``creationflags`` parameter to specify that a new process "
"will have realtime priority. You should almost never use "
"REALTIME_PRIORITY_CLASS, because this interrupts system threads that manage "
"mouse input, keyboard input, and background disk flushing. This class can be "
"appropriate for applications that \"talk\" directly to hardware or that "
"perform brief tasks that should have limited interruptions."
msgstr ""
"Paramètre ``creationflags`` de :class:`Popen` pour spécifier qu’un nouveau "
"processus aura une priorité en temps réel. Vous ne devriez presque JAMAIS "
"utiliser ``REALTIME_PRIORITY_CLASS``, car cela interrompt les fils "
"d’exécution système qui gèrent les entrées de la souris, du clavier et "
"*flush* le cache de disque en arrière-plan. Cette classe peut convenir aux "
"applications qui « parlent » directement au matériel ou qui effectuent de "
"brèves tâches nécessitant des interruptions limitées."

#: library/subprocess.rst:1113
msgid ""
"A :class:`Popen` ``creationflags`` parameter to specify that a new process "
"will not create a window."
msgstr ""
"Paramètre ``creationflags`` de :class:`Popen` pour spécifier qu'un processus "
"ne créera pas une nouvelle fenêtre."

#: library/subprocess.rst:1120
msgid ""
"A :class:`Popen` ``creationflags`` parameter to specify that a new process "
"will not inherit its parent's console. This value cannot be used with "
"CREATE_NEW_CONSOLE."
msgstr ""
"Paramètre ``creationflags`` de :class:`Popen` pour spécifier qu'un nouveau "
"processus n'héritera pas de la console du processus parent. Cette valeur ne "
"peut pas être utilisée avec CREATE_NEW_CONSOLE."

#: library/subprocess.rst:1128
msgid ""
"A :class:`Popen` ``creationflags`` parameter to specify that a new process "
"does not inherit the error mode of the calling process. Instead, the new "
"process gets the default error mode. This feature is particularly useful for "
"multithreaded shell applications that run with hard errors disabled."
msgstr ""
"Paramètre ``creationflags`` de :class:`Popen` pour spécifier qu'un nouveau "
"processus n'hérite pas du mode de gestion des erreurs du processus appelant. "
"À la place, le nouveau processus acquiert le mode d'erreur par défaut. Cette "
"fonctionnalité est particulièrement utile pour les applications *shell* avec "
"de multiples fils d'exécution qui s'exécutent avec les erreurs irréversibles "
"désactivées."

#: library/subprocess.rst:1138
msgid ""
"A :class:`Popen` ``creationflags`` parameter to specify that a new process "
"is not associated with the job."
msgstr ""
"Paramètre ``creationflags`` de :class:`Popen` pour spécifier qu'un processus "
"n'est pas associé au *job*."

#: library/subprocess.rst:1146
msgid "Older high-level API"
msgstr "Ancienne interface (*API*) haut-niveau"

#: library/subprocess.rst:1148
msgid ""
"Prior to Python 3.5, these three functions comprised the high level API to "
"subprocess. You can now use :func:`run` in many cases, but lots of existing "
"code calls these functions."
msgstr ""
"Avant Python 3.5, ces trois fonctions représentaient l'API haut-niveau de "
"*subprocess*. Vous pouvez maintenant utiliser :func:`run` dans de nombreux "
"cas, mais beaucoup de codes existant font appel à ces trois fonctions."

#: library/subprocess.rst:1155
msgid ""
"Run the command described by *args*.  Wait for command to complete, then "
"return the :attr:`~Popen.returncode` attribute."
msgstr ""
"Lance la commande décrite par *args*, attend qu'elle se termine, et renvoie "
"son attribut :attr:`~Popen.returncode`."

#: library/subprocess.rst:1198
msgid ""
"Code needing to capture stdout or stderr should use :func:`run` instead::"
msgstr ""
"Le code ayant besoin de capturer *stdout* ou *stderr* doit plutôt utiliser ::"
"func:`run` ::"

#: library/subprocess.rst:1202
msgid "To suppress stdout or stderr, supply a value of :data:`DEVNULL`."
msgstr "Pour supprimer *stdout* ou *stderr*, passez la valeur :data:`DEVNULL`."

#: library/subprocess.rst:1204
msgid ""
"The arguments shown above are merely some common ones. The full function "
"signature is the same as that of the :class:`Popen` constructor - this "
"function passes all supplied arguments other than *timeout* directly through "
"to that interface."
msgstr ""
"Les arguments montrés plus haut sont sûrement les plus communs. La signature "
"complète de la fonction est en grande partie la même que le constructeur de :"
"class:`Popen` : cette fonction passe tous les arguments fournis autre que "
"*timeout* directement à travers cette interface."

#: library/subprocess.rst:1211
msgid ""
"Do not use ``stdout=PIPE`` or ``stderr=PIPE`` with this function.  The child "
"process will block if it generates enough output to a pipe to fill up the OS "
"pipe buffer as the pipes are not being read from."
msgstr ""
"N'utilisez pas ``stdout=PIPE`` ou ``stderr=PIPE`` avec cette fonction.  Le "
"processus enfant bloquera s'il génère assez de données pour remplir le "
"tampon du tube de l'OS, puisque les tubes ne seront jamais lus."

#: library/subprocess.rst:1191
#, fuzzy
msgid ""
"Run command with arguments.  Wait for command to complete. If the return "
"code was zero then return, otherwise raise :exc:`CalledProcessError`. The :"
"exc:`CalledProcessError` object will have the return code in the :attr:"
"`~CalledProcessError.returncode` attribute. If :func:`check_call` was unable "
"to start the process it will propagate the exception that was raised."
msgstr ""
"Lance la commande avec les arguments et attend qu'elle se termine. Se "
"termine normalement si le code de retour est zéro, et lève une :exc:"
"`CalledProcessError` autrement. L'objet :exc:`CalledProcessError` contiendra "
"le code de retour dans son attribut :attr:`~CalledProcessError.returncode`."

#: library/subprocess.rst:1233
msgid "Run command with arguments and return its output."
msgstr "Lance la commande avec les arguments et renvoie sa sortie."

#: library/subprocess.rst:1235
msgid ""
"If the return code was non-zero it raises a :exc:`CalledProcessError`. The :"
"exc:`CalledProcessError` object will have the return code in the :attr:"
"`~CalledProcessError.returncode` attribute and any output in the :attr:"
"`~CalledProcessError.output` attribute."
msgstr ""
"Si le code de retour est non-nul, la fonction lève une :exc:"
"`CalledProcessError`. L'objet :exc:`CalledProcessError` contiendra le code "
"de retour dans son attribut :attr:`~CalledProcessError.returncode`, et la "
"sortie du programme dans son attribut :attr:`~CalledProcessError.output`."

#: library/subprocess.rst:1240
msgid "This is equivalent to::"
msgstr "C’est équivalent à ::"

#: library/subprocess.rst:1244
#, fuzzy
msgid ""
"The arguments shown above are merely some common ones. The full function "
"signature is largely the same as that of :func:`run` - most arguments are "
"passed directly through to that interface. One API deviation from :func:"
"`run` behavior exists: passing ``input=None`` will behave the same as "
"``input=b''`` (or ``input=''``, depending on other arguments) rather than "
"using the parent's standard input file handle."
msgstr ""
"Les arguments montrés plus haut sont sûrement les plus communs. La signature "
"complète de la fonction est en grande partie la même que :func:`run` : la "
"plupart des arguments sont passés directement par cette interface. "
"Cependant, passer explicitement ``input=None`` pour hériter du descripteur "
"d'entrée standard du parent n'est pas géré."

#: library/subprocess.rst:1251
msgid ""
"By default, this function will return the data as encoded bytes. The actual "
"encoding of the output data may depend on the command being invoked, so the "
"decoding to text will often need to be handled at the application level."
msgstr ""
"Par défaut, cette fonction renvoie les données encodées sous forme de "
"*bytes*. Le réel encodage des données de sortie peut dépendre de la commande "
"invoquée, donc le décodage du texte devra souvent être géré au niveau de "
"l'application."

#: library/subprocess.rst:1255
msgid ""
"This behaviour may be overridden by setting *text*, *encoding*, *errors*, or "
"*universal_newlines* to ``True`` as described in :ref:`frequently-used-"
"arguments` and :func:`run`."
msgstr ""
"Ce comportement peut être redéfini en mettant *text*, *encoding*, *errors*, "
"ou *universal_newlines* à ``True`` comme décrit dans :ref:`frequently-used-"
"arguments` et :func:`run`."

#: library/subprocess.rst:1259
msgid ""
"To also capture standard error in the result, use ``stderr=subprocess."
"STDOUT``::"
msgstr ""
"Pour capturer aussi la sortie d'erreur dans le résultat, utilisez "
"``stderr=subprocess.STDOUT`` ::"

#: library/subprocess.rst:1273
msgid "Support for the *input* keyword argument was added."
msgstr "Ajout de la gestion de l'argument nommé *input*."

#: library/subprocess.rst:1276
msgid "*encoding* and *errors* were added.  See :func:`run` for details."
msgstr ""
"Ajout d'*encoding* et *errors*. Consultez :func:`run` pour plus "
"d'informations."

#: library/subprocess.rst:1294
msgid "Replacing Older Functions with the :mod:`subprocess` Module"
msgstr "Remplacer les fonctions plus anciennes par le module :mod:`subprocess`"

#: library/subprocess.rst:1296
msgid ""
"In this section, \"a becomes b\" means that b can be used as a replacement "
"for a."
msgstr ""
"Dans cette section, « a devient b » signifie que b peut être utilisée en "
"remplacement de a."

#: library/subprocess.rst:1300
msgid ""
"All \"a\" functions in this section fail (more or less) silently if the "
"executed program cannot be found; the \"b\" replacements raise :exc:"
"`OSError` instead."
msgstr ""
"Toutes les fonctions « a » dans cette section échouent (plus ou moins) "
"silencieusement si le programme à exécuter ne peut être trouvé ; les "
"fonctions « b » de remplacement lèvent à la place une :exc:`OSError`."

#: library/subprocess.rst:1304
msgid ""
"In addition, the replacements using :func:`check_output` will fail with a :"
"exc:`CalledProcessError` if the requested operation produces a non-zero "
"return code. The output is still available as the :attr:`~CalledProcessError."
"output` attribute of the raised exception."
msgstr ""
"De plus, les remplacements utilisant :func:`check_output` échoueront avec "
"une :exc:`CalledProcessError` si l'opération requise produit un code de "
"retour non-nul. La sortie est toujours disponible par l'attribut :attr:"
"`~CalledProcessError.output` de l'exception levée."

#: library/subprocess.rst:1309
msgid ""
"In the following examples, we assume that the relevant functions have "
"already been imported from the :mod:`subprocess` module."
msgstr ""
"Dans les exemples suivants, nous supposons que les fonctions utilisées ont "
"déjà été importées depuis le module :mod:`subprocess`."

#: library/subprocess.rst:1314
msgid "Replacing :program:`/bin/sh` shell command substitution"
msgstr ""
"Remplacement de la substitution de commandes de terminal :program:`/bin/sh`"

#: library/subprocess.rst:1331 library/subprocess.rst:1348
msgid "becomes::"
msgstr "devient ::"

#: library/subprocess.rst:1325
msgid "Replacing shell pipeline"
msgstr "Remplacer les *pipes* du *shell*"

#: library/subprocess.rst:1338
msgid ""
"The ``p1.stdout.close()`` call after starting the p2 is important in order "
"for p1 to receive a SIGPIPE if p2 exits before p1."
msgstr ""
"L'appel à ``p1.stdout.close()`` après le démarrage de *p2* est important "
"pour que *p1* reçoive un *SIGPIPE* si *p2* se termine avant lui."

#: library/subprocess.rst:1341
msgid ""
"Alternatively, for trusted input, the shell's own pipeline support may still "
"be used directly:"
msgstr ""
"Alternativement, pour des entrées fiables, la gestion des tubes du *shell* "
"peut directement être utilisé :"

#: library/subprocess.rst:1354
msgid "Replacing :func:`os.system`"
msgstr "Remplacer :func:`os.system`"

#: library/subprocess.rst:1362
msgid "Notes:"
msgstr "Notes :"

#: library/subprocess.rst:1364
msgid "Calling the program through the shell is usually not required."
msgstr ""
"Appeler le programme à travers un *shell* n'est habituellement pas requis."

#: library/subprocess.rst:1365
msgid ""
"The :func:`call` return value is encoded differently to that of :func:`os."
"system`."
msgstr ""

#: library/subprocess.rst:1368
msgid ""
"The :func:`os.system` function ignores SIGINT and SIGQUIT signals while the "
"command is running, but the caller must do this separately when using the :"
"mod:`subprocess` module."
msgstr ""

#: library/subprocess.rst:1372
msgid "A more realistic example would look like this::"
msgstr "Un exemple plus réaliste ressemblerait à cela ::"

#: library/subprocess.rst:1385
msgid "Replacing the :func:`os.spawn <os.spawnl>` family"
msgstr "Remplacer les fonctions de la famille :func:`os.spawn <os.spawnl>`"

#: library/subprocess.rst:1387
msgid "P_NOWAIT example::"
msgstr "Exemple avec *P_NOWAIT* ::"

#: library/subprocess.rst:1393
msgid "P_WAIT example::"
msgstr "Exemple avec *P_WAIT* ::"

#: library/subprocess.rst:1399
msgid "Vector example::"
msgstr "Exemple avec un tableau ::"

#: library/subprocess.rst:1405
msgid "Environment example::"
msgstr "Exemple en passant un environnement ::"

#: library/subprocess.rst:1414
msgid "Replacing :func:`os.popen`, :func:`os.popen2`, :func:`os.popen3`"
msgstr "Remplacer :func:`os.popen`, :func:`os.popen2`, :func:`os.popen3`"

#: library/subprocess.rst:1444
msgid "Return code handling translates as follows::"
msgstr "La gestion du code de retour se traduit comme suit ::"

#: library/subprocess.rst:1460
msgid "Replacing functions from the :mod:`popen2` module"
msgstr "Remplacer les fonctions du module :mod:`popen2`"

#: library/subprocess.rst:1464
msgid ""
"If the cmd argument to popen2 functions is a string, the command is executed "
"through /bin/sh.  If it is a list, the command is directly executed."
msgstr ""
"Si l'argument *cmd* des fonctions de *popen2* est une chaîne de caractères, "
"la commande est exécutée à travers */bin/sh*.  Si c'est une liste, la "
"commande est directement exécutée."

#: library/subprocess.rst:1483
msgid ""
":class:`popen2.Popen3` and :class:`popen2.Popen4` basically work as :class:"
"`subprocess.Popen`, except that:"
msgstr ""
":class:`popen2.Popen3` et :class:`popen2.Popen4` fonctionnent basiquement "
"comme :class:`subprocess.Popen`, excepté que :"

#: library/subprocess.rst:1486
msgid ":class:`Popen` raises an exception if the execution fails."
msgstr ":class:`Popen` lève une exception si l'exécution échoue."

#: library/subprocess.rst:1488
msgid "The *capturestderr* argument is replaced with the *stderr* argument."
msgstr "L'argument *capturestderr* est remplacé par *stderr*."

#: library/subprocess.rst:1490
msgid "``stdin=PIPE`` and ``stdout=PIPE`` must be specified."
msgstr "``stdin=PIPE`` et ``stdout=PIPE`` doivent être spécifiés."

#: library/subprocess.rst:1492
msgid ""
"popen2 closes all file descriptors by default, but you have to specify "
"``close_fds=True`` with :class:`Popen` to guarantee this behavior on all "
"platforms or past Python versions."
msgstr ""
"*popen2* ferme tous les descripteurs de fichiers par défaut, mais vous devez "
"spécifier ``close_fds=True`` avec :class:`Popen` pour garantir ce "
"comportement sur toutes les plateformes ou les anciennes versions de Python."

#: library/subprocess.rst:1498
msgid "Legacy Shell Invocation Functions"
msgstr "Remplacement des fonctions originales d'invocation du *shell*"

#: library/subprocess.rst:1500
msgid ""
"This module also provides the following legacy functions from the 2.x "
"``commands`` module. These operations implicitly invoke the system shell and "
"none of the guarantees described above regarding security and exception "
"handling consistency are valid for these functions."
msgstr ""
"Ce module fournit aussi les fonctions suivantes héritées du module "
"``commands`` de Python 2.x. Ces opérations invoquent implicitement le "
"*shell* du système et n'apportent aucune des garanties décrites ci-dessus "
"par rapport à la sécurité ou la cohérence de la gestion des exceptions."

#: library/subprocess.rst:1507
msgid "Return ``(exitcode, output)`` of executing *cmd* in a shell."
msgstr ""
"Renvoie les valeurs ``(exitcode, output)`` de l'exécution de *cmd* dans un "
"*shell*."

#: library/subprocess.rst:1509
#, fuzzy
msgid ""
"Execute the string *cmd* in a shell with :meth:`Popen.check_output` and "
"return a 2-tuple ``(exitcode, output)``. *encoding* and *errors* are used to "
"decode output; see the notes on :ref:`frequently-used-arguments` for more "
"details."
msgstr ""
"Exécute la chaîne *cmd* dans un *shell* avec :meth:`Popen.check_output` et "
"renvoie une paire ``(exitcode, output)``. L'encodage local est utilisé, voir "
"les notes de la section :ref:`frequently-used-arguments` pour plus de "
"détails."

#: library/subprocess.rst:1514
msgid ""
"A trailing newline is stripped from the output. The exit code for the "
"command can be interpreted as the return code of subprocess.  Example::"
msgstr ""
"Si la sortie se termine par un caractère de fin de ligne, ce dernier est "
"supprimé. Le code de statut de la commande peut être interprété comme le "
"code de retour de *subprocess*.  Par exemple ::"

#: library/subprocess.rst:1549
#, fuzzy
msgid ":ref:`Availability <availability>`: Unix, Windows."
msgstr ":ref:`Disponibilité <availability>` : POSIX et Windows."

#: library/subprocess.rst:1529
msgid "Windows support was added."
msgstr "Ajout de la gestion de Windows."

#: library/subprocess.rst:1532
msgid ""
"The function now returns (exitcode, output) instead of (status, output) as "
"it did in Python 3.3.3 and earlier.  exitcode has the same value as :attr:"
"`~Popen.returncode`."
msgstr ""
"La fonction renvoie maintenant ``(exitcode, output)`` plutôt que ``(status, "
"output)`` comme dans les versions de Python 3.3.3 ou antérieures.  "
"*exitcode* vaut la même valeur que :attr:`~Popen.returncode`."

#: library/subprocess.rst:1554
#, fuzzy
msgid "Added *encoding* and *errors* arguments."
msgstr "Ajout des paramètres *encoding* et *errors*."

#: library/subprocess.rst:1541
msgid "Return output (stdout and stderr) of executing *cmd* in a shell."
msgstr ""
"Renvoie la sortie (standard et d'erreur) de l'exécution de *cmd* dans un "
"*shell*."

#: library/subprocess.rst:1543
msgid ""
"Like :func:`getstatusoutput`, except the exit code is ignored and the return "
"value is a string containing the command's output.  Example::"
msgstr ""
"Comme :func:`getstatusoutput`, à l'exception que le code de statut est "
"ignoré et que la valeur de retour est une chaîne contenant la sortie de la "
"commande.  Exemple ::"

#: library/subprocess.rst:1551
msgid "Windows support added"
msgstr "Ajout de la gestion de Windows"

#: library/subprocess.rst:1559
msgid "Notes"
msgstr "Notes"

#: library/subprocess.rst:1564
msgid "Converting an argument sequence to a string on Windows"
msgstr ""
"Convertir une séquence d'arguments vers une chaîne de caractères sous Windows"

#: library/subprocess.rst:1566
msgid ""
"On Windows, an *args* sequence is converted to a string that can be parsed "
"using the following rules (which correspond to the rules used by the MS C "
"runtime):"
msgstr ""
"Sous Windows, une séquence *args* est convertie vers une chaîne qui peut "
"être analysée avec les règles suivantes (qui correspondent aux règles "
"utilisées par l'environnement *MS C*) :"

#: library/subprocess.rst:1570
msgid ""
"Arguments are delimited by white space, which is either a space or a tab."
msgstr ""
"Les arguments sont délimités par des espacements, qui peuvent être des "
"espaces ou des tabulations."

#: library/subprocess.rst:1573
msgid ""
"A string surrounded by double quotation marks is interpreted as a single "
"argument, regardless of white space contained within.  A quoted string can "
"be embedded in an argument."
msgstr ""
"Une chaîne entourée de double guillemets est interprétée comme un argument "
"seul, qu'elle contienne ou non des espacements.  Une chaîne entre guillemets "
"peut être intégrée dans un argument."

#: library/subprocess.rst:1578
msgid ""
"A double quotation mark preceded by a backslash is interpreted as a literal "
"double quotation mark."
msgstr ""
"Un guillemet double précédé d'un *backslash* est interprété comme un "
"guillemet double littéral."

#: library/subprocess.rst:1581
msgid ""
"Backslashes are interpreted literally, unless they immediately precede a "
"double quotation mark."
msgstr ""
"Les *backslashs* sont interprétés littéralement, à moins qu'ils précèdent "
"immédiatement un guillemet double."

#: library/subprocess.rst:1584
msgid ""
"If backslashes immediately precede a double quotation mark, every pair of "
"backslashes is interpreted as a literal backslash.  If the number of "
"backslashes is odd, the last backslash escapes the next double quotation "
"mark as described in rule 3."
msgstr ""
"Si des *backslashs* précèdent directement un guillemet double, toute paire "
"de *backslashs* est interprétée comme un *backslash* littéral.  Si le nombre "
"de *backslashs* est impair, le dernier *backslash* échappe le prochain "
"guillemet double comme décrit en règle 3."

#: library/subprocess.rst:1593
msgid ":mod:`shlex`"
msgstr ":mod:`shlex`"

#: library/subprocess.rst:1594
msgid "Module which provides function to parse and escape command lines."
msgstr ""
"Module qui fournit des fonctions pour analyser et échapper les lignes de "
"commandes."

#: library/subprocess.rst:1601
msgid "Disabling use of ``vfork()`` or ``posix_spawn()``"
msgstr ""

#: library/subprocess.rst:1603
msgid ""
"On Linux, :mod:`subprocess` defaults to using the ``vfork()`` system call "
"internally when it is safe to do so rather than ``fork()``. This greatly "
"improves performance."
msgstr ""

#: library/subprocess.rst:1607
msgid ""
"If you ever encounter a presumed highly unusual situation where you need to "
"prevent ``vfork()`` from being used by Python, you can set the :attr:"
"`subprocess._USE_VFORK` attribute to a false value."
msgstr ""

#: library/subprocess.rst:1615
msgid ""
"Setting this has no impact on use of ``posix_spawn()`` which could use "
"``vfork()`` internally within its libc implementation.  There is a similar :"
"attr:`subprocess._USE_POSIX_SPAWN` attribute if you need to prevent use of "
"that."
msgstr ""

#: library/subprocess.rst:1624
msgid ""
"It is safe to set these to false on any Python version. They will have no "
"effect on older versions when unsupported. Do not assume the attributes are "
"available to read. Despite their names, a true value does not indicate that "
"the corresponding function will be used, only that that it may be."
msgstr ""

#: library/subprocess.rst:1629
msgid ""
"Please file issues any time you have to use these private knobs with a way "
"to reproduce the issue you were seeing. Link to that issue from a comment in "
"your code."
msgstr ""

#: library/subprocess.rst:1633
msgid "``_USE_POSIX_SPAWN``"
msgstr ""

#: library/subprocess.rst:1634
msgid "``_USE_VFORK``"
msgstr ""

#~ msgid "The following attributes are also available:"
#~ msgstr "Les attributs suivants sont aussi disponibles :"

#~ msgid ""
#~ "If *env* is not ``None``, it must be a mapping that defines the "
#~ "environment variables for the new process; these are used instead of the "
#~ "default behavior of inheriting the current process' environment."
#~ msgstr ""
#~ "Si *env* n'est pas ``None``, il doit être un tableau associatif "
#~ "définissant les variables d'environnement du nouveau processus ; elles "
#~ "seront utilisées à la place du comportement par défaut qui est d'hériter "
#~ "de l'environnement du processus courant."

#~ msgid ""
#~ "The :func:`run` function was added in Python 3.5; if you need to retain "
#~ "compatibility with older versions, see the :ref:`call-function-trio` "
#~ "section."
#~ msgstr ""
#~ "La fonction :func:`run` a été ajoutée avec Python 3.5 ; si vous avez "
#~ "besoin d'une compatibilité avec des versions plus anciennes, référez-vous "
#~ "à la section :ref:`call-function-trio`."

#~ msgid ""
#~ "The most common exception raised is :exc:`OSError`.  This occurs, for "
#~ "example, when trying to execute a non-existent file.  Applications should "
#~ "prepare for :exc:`OSError` exceptions."
#~ msgstr ""
#~ "L'exception la plus communément levée est :exc:`OSError`.  Elle survient, "
#~ "par exemple, si vous essayez d'exécuter un fichier inexistant.  Les "
#~ "applications doivent se préparer à traiter des exceptions :exc:`OSError`."

#~ msgid ""
#~ "When using ``shell=True``, the :func:`shlex.quote` function can be used "
#~ "to properly escape whitespace and shell metacharacters in strings that "
#~ "are going to be used to construct shell commands."
#~ msgstr ""
#~ "Avec ``shell=True``, la fonction :func:`shlex.quote` peut être utilisée "
#~ "pour échapper proprement les espaces et métacaractères dans les chaînes "
#~ "qui seront utilisées pour construire les commandes *shell*."