# 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 \n" "Language-Team: FRENCH \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 `: not Emscripten, not WASI." msgstr ":ref:`Disponibilité ` : 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) ` 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) ` 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 `. 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 ` 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 ` 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 ` " "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 " "` 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 ` 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 `. 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 ` 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 ` 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 `: POSIX" msgstr ":ref:`Disponibilité ` : 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 ` ``subprocess.Popen`` with " "arguments ``executable``, ``args``, ``cwd``, ``env``." msgstr "" "Lève un :ref:`évènement d'audit ` ``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 ` ``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 ` ``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 `_ vulnerabilities. On :ref:`some platforms " "`, 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 " "`_." #: 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 `, :attr:`.stdout.read ` or :attr:`.stderr.read ` 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 `, :attr:`.stdout.read ` ou :attr:`.stderr.read ` 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 `__ 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 `__ 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 `__ 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 `__, à 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 `__." msgstr "" "Dictionnaire des attributs supplémentaires pour la création d'un processus " "comme donnés dans ``STARTUPINFOEX``, lisez `UpdateProcThreadAttribute " "`__ (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 ` family" msgstr "Remplacer les fonctions de la famille :func:`os.spawn `" #: 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 `: Unix, Windows." msgstr ":ref:`Disponibilité ` : 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*."